[gnome-system-monitor] Make indentation uniform across source files.
- From: Chris KÃhl <chriskuehl src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-system-monitor] Make indentation uniform across source files.
- Date: Sun, 3 Jul 2011 00:08:21 +0000 (UTC)
commit 38c5296cdda1afab6cb7cfe6bcafb991a665ebc9
Author: Chris KÃhl <chrisk openismus com>
Date: Sun Jul 3 01:47:25 2011 +0200
Make indentation uniform across source files.
This patch replaces tabs with spaces and sets indentation to 4 across
all source files. Previously there was a mix between spaces and tabs
between files and sometimes within a file as well as different
indentation widths.
It's regrettable that such a git-history intrusive commit is required.
src/argv.cpp | 20 +-
src/argv.h | 14 +-
src/bacon-message-connection.c | 530 ++++++++--------
src/bacon-message-connection.h | 18 +-
src/callbacks.cpp | 366 ++++++------
src/callbacks.h | 74 ++--
src/defaulttable.h | 56 +-
src/disks.cpp | 646 ++++++++++----------
src/e_date.c | 290 +++++-----
src/gsm_color_button.h | 36 +-
src/iconthemewrapper.cpp | 14 +-
src/iconthemewrapper.h | 18 +-
src/interface.cpp | 1374 ++++++++++++++++++++--------------------
src/interface.h | 6 +-
src/load-graph.cpp | 1196 +++++++++++++++++-----------------
src/load-graph.h | 118 ++--
src/lsof.cpp | 620 +++++++++---------
src/memmaps.cpp | 752 +++++++++++-----------
src/memmaps.h | 2 +-
src/openfiles.cpp | 488 +++++++-------
src/openfiles.h | 2 +-
src/prettytable.h | 40 +-
src/procactions.cpp | 200 +++---
src/procactions.h | 6 +-
src/procdialogs.cpp | 1294 +++++++++++++++++++-------------------
src/procdialogs.h | 18 +-
src/procman.cpp | 1002 +++++++++++++++---------------
src/procman.h | 274 ++++----
src/procman_gksu.cpp | 40 +-
src/procman_gnomesu.cpp | 20 +-
src/proctable.cpp | 1276 +++++++++++++++++++-------------------
src/proctable.h | 60 +-
src/selection.cpp | 60 +-
src/selection.h | 16 +-
src/selinux.cpp | 50 +-
src/settings-keys.cpp | 14 +-
src/settings-keys.h | 14 +-
src/smooth_refresh.cpp | 142 ++--
src/smooth_refresh.h | 116 ++--
src/sysinfo.cpp | 1064 ++++++++++++++++----------------
src/sysinfo.h | 2 +-
src/util.cpp | 628 +++++++++---------
src/util.h | 142 ++--
43 files changed, 6559 insertions(+), 6559 deletions(-)
---
diff --git a/src/argv.cpp b/src/argv.cpp
index a81a3c0..f1a3a86 100644
--- a/src/argv.cpp
+++ b/src/argv.cpp
@@ -8,15 +8,15 @@
namespace procman
{
- OptionGroup::OptionGroup()
- : Glib::OptionGroup("", ""),
- show_system_tab(false)
- {
- Glib::OptionEntry sys_tab;
- sys_tab.set_long_name("show-system-tab");
- sys_tab.set_short_name('s');
- sys_tab.set_description(_("Show the System tab"));
- this->add_entry(sys_tab, this->show_system_tab);
- }
+ OptionGroup::OptionGroup()
+ : Glib::OptionGroup("", ""),
+ show_system_tab(false)
+ {
+ Glib::OptionEntry sys_tab;
+ sys_tab.set_long_name("show-system-tab");
+ sys_tab.set_short_name('s');
+ sys_tab.set_description(_("Show the System tab"));
+ this->add_entry(sys_tab, this->show_system_tab);
+ }
}
diff --git a/src/argv.h b/src/argv.h
index a0f7205..9a604d5 100644
--- a/src/argv.h
+++ b/src/argv.h
@@ -5,14 +5,14 @@
namespace procman
{
- class OptionGroup
- : public Glib::OptionGroup
- {
- public:
- OptionGroup();
+ class OptionGroup
+ : public Glib::OptionGroup
+ {
+ public:
+ OptionGroup();
- bool show_system_tab;
- };
+ bool show_system_tab;
+ };
}
#endif // H_PROCMAN_ARGV_1205873424
diff --git a/src/bacon-message-connection.c b/src/bacon-message-connection.c
index c8000de..3fee6f4 100644
--- a/src/bacon-message-connection.c
+++ b/src/bacon-message-connection.c
@@ -35,362 +35,362 @@
#endif
struct BaconMessageConnection {
- /* A server accepts connections */
- gboolean is_server;
+ /* A server accepts connections */
+ gboolean is_server;
- /* The socket path itself */
- char *path;
+ /* The socket path itself */
+ char *path;
- /* File descriptor of the socket */
- int fd;
- /* Channel to watch */
- GIOChannel *chan;
- /* Event id returned by g_io_add_watch() */
- int conn_id;
+ /* File descriptor of the socket */
+ int fd;
+ /* Channel to watch */
+ GIOChannel *chan;
+ /* Event id returned by g_io_add_watch() */
+ int conn_id;
- /* Connections accepted by this connection */
- GSList *accepted_connections;
+ /* Connections accepted by this connection */
+ GSList *accepted_connections;
- /* callback */
- void (*func) (const char *message, gpointer user_data);
- gpointer data;
+ /* callback */
+ void (*func) (const char *message, gpointer user_data);
+ gpointer data;
};
static gboolean
test_is_socket (const char *path)
{
- struct stat s;
+ struct stat s;
- if (stat (path, &s) == -1)
- return FALSE;
+ if (stat (path, &s) == -1)
+ return FALSE;
- if (S_ISSOCK (s.st_mode))
- return TRUE;
+ if (S_ISSOCK (s.st_mode))
+ return TRUE;
- return FALSE;
+ return FALSE;
}
static gboolean
is_owned_by_user_and_socket (const char *path)
{
- struct stat s;
+ struct stat s;
- if (stat (path, &s) == -1)
- return FALSE;
+ if (stat (path, &s) == -1)
+ return FALSE;
- if (s.st_uid != geteuid ())
- return FALSE;
+ if (s.st_uid != geteuid ())
+ return FALSE;
- if ((s.st_mode & S_IFSOCK) != S_IFSOCK)
- return FALSE;
-
- return TRUE;
+ if ((s.st_mode & S_IFSOCK) != S_IFSOCK)
+ return FALSE;
+
+ return TRUE;
}
static gboolean server_cb (GIOChannel *source,
- GIOCondition condition, gpointer data);
+ GIOCondition condition, gpointer data);
static gboolean
setup_connection (BaconMessageConnection *conn)
{
- g_return_val_if_fail (conn->chan == NULL, FALSE);
+ g_return_val_if_fail (conn->chan == NULL, FALSE);
- conn->chan = g_io_channel_unix_new (conn->fd);
- if (!conn->chan) {
- return FALSE;
- }
- g_io_channel_set_line_term (conn->chan, "\n", 1);
- conn->conn_id = g_io_add_watch (conn->chan, G_IO_IN, server_cb, conn);
+ conn->chan = g_io_channel_unix_new (conn->fd);
+ if (!conn->chan) {
+ return FALSE;
+ }
+ g_io_channel_set_line_term (conn->chan, "\n", 1);
+ conn->conn_id = g_io_add_watch (conn->chan, G_IO_IN, server_cb, conn);
- return TRUE;
+ return TRUE;
}
static void
accept_new_connection (BaconMessageConnection *server_conn)
{
- BaconMessageConnection *conn;
- int alen;
+ BaconMessageConnection *conn;
+ int alen;
- g_return_if_fail (server_conn->is_server);
+ g_return_if_fail (server_conn->is_server);
- conn = g_new0 (BaconMessageConnection, 1);
- conn->is_server = FALSE;
- conn->func = server_conn->func;
- conn->data = server_conn->data;
+ conn = g_new0 (BaconMessageConnection, 1);
+ conn->is_server = FALSE;
+ conn->func = server_conn->func;
+ conn->data = server_conn->data;
- conn->fd = accept (server_conn->fd, NULL, (guint *)&alen);
+ conn->fd = accept (server_conn->fd, NULL, (guint *)&alen);
- server_conn->accepted_connections =
- g_slist_prepend (server_conn->accepted_connections, conn);
+ server_conn->accepted_connections =
+ g_slist_prepend (server_conn->accepted_connections, conn);
- setup_connection (conn);
+ setup_connection (conn);
}
static gboolean
server_cb (GIOChannel *source, GIOCondition condition, gpointer data)
{
- BaconMessageConnection *conn = (BaconMessageConnection *)data;
- char *message, *subs, buf;
- int cd, rc, offset;
- gboolean finished;
-
- offset = 0;
- if (conn->is_server && conn->fd == g_io_channel_unix_get_fd (source)) {
- accept_new_connection (conn);
- return TRUE;
- }
- message = g_malloc (1);
- cd = conn->fd;
- rc = read (cd, &buf, 1);
- while (rc > 0 && buf != '\n')
- {
- message = g_realloc (message, rc + offset + 1);
- message[offset] = buf;
- offset = offset + rc;
- rc = read (cd, &buf, 1);
- }
- if (rc <= 0) {
- g_io_channel_shutdown (conn->chan, FALSE, NULL);
- g_io_channel_unref (conn->chan);
- conn->chan = NULL;
- close (conn->fd);
- conn->fd = -1;
- g_free (message);
- conn->conn_id = 0;
-
- return FALSE;
- }
- message[offset] = '\0';
-
- subs = message;
- finished = FALSE;
-
- while (finished == FALSE && *subs != '\0')
- {
- if (conn->func != NULL)
- (*conn->func) (subs, conn->data);
-
- subs += strlen (subs) + 1;
- if (subs - message >= offset)
- finished = TRUE;
- }
-
- g_free (message);
-
- return TRUE;
+ BaconMessageConnection *conn = (BaconMessageConnection *)data;
+ char *message, *subs, buf;
+ int cd, rc, offset;
+ gboolean finished;
+
+ offset = 0;
+ if (conn->is_server && conn->fd == g_io_channel_unix_get_fd (source)) {
+ accept_new_connection (conn);
+ return TRUE;
+ }
+ message = g_malloc (1);
+ cd = conn->fd;
+ rc = read (cd, &buf, 1);
+ while (rc > 0 && buf != '\n')
+ {
+ message = g_realloc (message, rc + offset + 1);
+ message[offset] = buf;
+ offset = offset + rc;
+ rc = read (cd, &buf, 1);
+ }
+ if (rc <= 0) {
+ g_io_channel_shutdown (conn->chan, FALSE, NULL);
+ g_io_channel_unref (conn->chan);
+ conn->chan = NULL;
+ close (conn->fd);
+ conn->fd = -1;
+ g_free (message);
+ conn->conn_id = 0;
+
+ return FALSE;
+ }
+ message[offset] = '\0';
+
+ subs = message;
+ finished = FALSE;
+
+ while (finished == FALSE && *subs != '\0')
+ {
+ if (conn->func != NULL)
+ (*conn->func) (subs, conn->data);
+
+ subs += strlen (subs) + 1;
+ if (subs - message >= offset)
+ finished = TRUE;
+ }
+
+ g_free (message);
+
+ return TRUE;
}
static char *
find_file_with_pattern (const char *dir, const char *pattern)
{
- GDir *filedir;
- char *found_filename;
- const char *filename;
- GPatternSpec *pat;
-
- filedir = g_dir_open (dir, 0, NULL);
- if (filedir == NULL)
- return NULL;
-
- pat = g_pattern_spec_new (pattern);
- if (pat == NULL)
- {
- g_dir_close (filedir);
- return NULL;
- }
-
- found_filename = NULL;
-
- while ((filename = g_dir_read_name (filedir)))
- {
- if (g_pattern_match_string (pat, filename))
- {
- char *tmp = g_build_filename (dir, filename, NULL);
- if (is_owned_by_user_and_socket (tmp))
- found_filename = g_strdup (filename);
- g_free (tmp);
- }
-
- if (found_filename != NULL)
- break;
- }
-
- g_pattern_spec_free (pat);
- g_dir_close (filedir);
-
- return found_filename;
+ GDir *filedir;
+ char *found_filename;
+ const char *filename;
+ GPatternSpec *pat;
+
+ filedir = g_dir_open (dir, 0, NULL);
+ if (filedir == NULL)
+ return NULL;
+
+ pat = g_pattern_spec_new (pattern);
+ if (pat == NULL)
+ {
+ g_dir_close (filedir);
+ return NULL;
+ }
+
+ found_filename = NULL;
+
+ while ((filename = g_dir_read_name (filedir)))
+ {
+ if (g_pattern_match_string (pat, filename))
+ {
+ char *tmp = g_build_filename (dir, filename, NULL);
+ if (is_owned_by_user_and_socket (tmp))
+ found_filename = g_strdup (filename);
+ g_free (tmp);
+ }
+
+ if (found_filename != NULL)
+ break;
+ }
+
+ g_pattern_spec_free (pat);
+ g_dir_close (filedir);
+
+ return found_filename;
}
static char *
socket_filename (const char *prefix)
{
- char *pattern, *newfile, *path, *filename;
- const char *tmpdir;
-
- pattern = g_strdup_printf ("%s.%s.*", prefix, g_get_user_name ());
- tmpdir = g_get_tmp_dir ();
- filename = find_file_with_pattern (tmpdir, pattern);
- if (filename == NULL)
- {
- newfile = g_strdup_printf ("%s.%s.%u", prefix,
- g_get_user_name (), g_random_int ());
- path = g_build_filename (tmpdir, newfile, NULL);
- g_free (newfile);
- } else {
- path = g_build_filename (tmpdir, filename, NULL);
- g_free (filename);
- }
-
- g_free (pattern);
- return path;
+ char *pattern, *newfile, *path, *filename;
+ const char *tmpdir;
+
+ pattern = g_strdup_printf ("%s.%s.*", prefix, g_get_user_name ());
+ tmpdir = g_get_tmp_dir ();
+ filename = find_file_with_pattern (tmpdir, pattern);
+ if (filename == NULL)
+ {
+ newfile = g_strdup_printf ("%s.%s.%u", prefix,
+ g_get_user_name (), g_random_int ());
+ path = g_build_filename (tmpdir, newfile, NULL);
+ g_free (newfile);
+ } else {
+ path = g_build_filename (tmpdir, filename, NULL);
+ g_free (filename);
+ }
+
+ g_free (pattern);
+ return path;
}
static gboolean
try_server (BaconMessageConnection *conn)
{
- struct sockaddr_un uaddr;
-
- uaddr.sun_family = AF_UNIX;
- strncpy (uaddr.sun_path, conn->path,
- MIN (strlen(conn->path)+1, UNIX_PATH_MAX));
- conn->fd = socket (PF_UNIX, SOCK_STREAM, 0);
- if (bind (conn->fd, (struct sockaddr *) &uaddr, sizeof (uaddr)) == -1)
- {
- conn->fd = -1;
- return FALSE;
- }
- listen (conn->fd, 5);
-
- if (!setup_connection (conn))
- return FALSE;
- return TRUE;
+ struct sockaddr_un uaddr;
+
+ uaddr.sun_family = AF_UNIX;
+ strncpy (uaddr.sun_path, conn->path,
+ MIN (strlen(conn->path)+1, UNIX_PATH_MAX));
+ conn->fd = socket (PF_UNIX, SOCK_STREAM, 0);
+ if (bind (conn->fd, (struct sockaddr *) &uaddr, sizeof (uaddr)) == -1)
+ {
+ conn->fd = -1;
+ return FALSE;
+ }
+ listen (conn->fd, 5);
+
+ if (!setup_connection (conn))
+ return FALSE;
+ return TRUE;
}
static gboolean
try_client (BaconMessageConnection *conn)
{
- struct sockaddr_un uaddr;
-
- uaddr.sun_family = AF_UNIX;
- strncpy (uaddr.sun_path, conn->path,
- MIN(strlen(conn->path)+1, UNIX_PATH_MAX));
- conn->fd = socket (PF_UNIX, SOCK_STREAM, 0);
- if (connect (conn->fd, (struct sockaddr *) &uaddr,
- sizeof (uaddr)) == -1)
- {
- conn->fd = -1;
- return FALSE;
- }
-
- return setup_connection (conn);
+ struct sockaddr_un uaddr;
+
+ uaddr.sun_family = AF_UNIX;
+ strncpy (uaddr.sun_path, conn->path,
+ MIN(strlen(conn->path)+1, UNIX_PATH_MAX));
+ conn->fd = socket (PF_UNIX, SOCK_STREAM, 0);
+ if (connect (conn->fd, (struct sockaddr *) &uaddr,
+ sizeof (uaddr)) == -1)
+ {
+ conn->fd = -1;
+ return FALSE;
+ }
+
+ return setup_connection (conn);
}
BaconMessageConnection *
bacon_message_connection_new (const char *prefix)
{
- BaconMessageConnection *conn;
-
- g_return_val_if_fail (prefix != NULL, NULL);
-
- conn = g_new0 (BaconMessageConnection, 1);
- conn->path = socket_filename (prefix);
-
- if (test_is_socket (conn->path) == FALSE)
- {
- if (!try_server (conn))
- {
- bacon_message_connection_free (conn);
- return NULL;
- }
-
- conn->is_server = TRUE;
- return conn;
- }
-
- if (try_client (conn) == FALSE)
- {
- unlink (conn->path);
- try_server (conn);
- if (conn->fd == -1)
- {
- bacon_message_connection_free (conn);
- return NULL;
- }
-
- conn->is_server = TRUE;
- return conn;
- }
-
- conn->is_server = FALSE;
- return conn;
+ BaconMessageConnection *conn;
+
+ g_return_val_if_fail (prefix != NULL, NULL);
+
+ conn = g_new0 (BaconMessageConnection, 1);
+ conn->path = socket_filename (prefix);
+
+ if (test_is_socket (conn->path) == FALSE)
+ {
+ if (!try_server (conn))
+ {
+ bacon_message_connection_free (conn);
+ return NULL;
+ }
+
+ conn->is_server = TRUE;
+ return conn;
+ }
+
+ if (try_client (conn) == FALSE)
+ {
+ unlink (conn->path);
+ try_server (conn);
+ if (conn->fd == -1)
+ {
+ bacon_message_connection_free (conn);
+ return NULL;
+ }
+
+ conn->is_server = TRUE;
+ return conn;
+ }
+
+ conn->is_server = FALSE;
+ return conn;
}
void
bacon_message_connection_free (BaconMessageConnection *conn)
{
- GSList *child_conn;
-
- g_return_if_fail (conn != NULL);
- /* Only servers can accept other connections */
- g_return_if_fail (conn->is_server != FALSE ||
- conn->accepted_connections == NULL);
-
- child_conn = conn->accepted_connections;
- while (child_conn != NULL) {
- bacon_message_connection_free (child_conn->data);
- child_conn = g_slist_next (child_conn);
- }
- g_slist_free (conn->accepted_connections);
-
- if (conn->conn_id) {
- g_source_remove (conn->conn_id);
- conn->conn_id = 0;
- }
- if (conn->chan) {
- g_io_channel_shutdown (conn->chan, FALSE, NULL);
- g_io_channel_unref (conn->chan);
- }
-
- if (conn->is_server != FALSE) {
- unlink (conn->path);
- }
- if (conn->fd != -1) {
- close (conn->fd);
- }
-
- g_free (conn->path);
- g_free (conn);
+ GSList *child_conn;
+
+ g_return_if_fail (conn != NULL);
+ /* Only servers can accept other connections */
+ g_return_if_fail (conn->is_server != FALSE ||
+ conn->accepted_connections == NULL);
+
+ child_conn = conn->accepted_connections;
+ while (child_conn != NULL) {
+ bacon_message_connection_free (child_conn->data);
+ child_conn = g_slist_next (child_conn);
+ }
+ g_slist_free (conn->accepted_connections);
+
+ if (conn->conn_id) {
+ g_source_remove (conn->conn_id);
+ conn->conn_id = 0;
+ }
+ if (conn->chan) {
+ g_io_channel_shutdown (conn->chan, FALSE, NULL);
+ g_io_channel_unref (conn->chan);
+ }
+
+ if (conn->is_server != FALSE) {
+ unlink (conn->path);
+ }
+ if (conn->fd != -1) {
+ close (conn->fd);
+ }
+
+ g_free (conn->path);
+ g_free (conn);
}
void
bacon_message_connection_set_callback (BaconMessageConnection *conn,
- BaconMessageReceivedFunc func,
- gpointer user_data)
+ BaconMessageReceivedFunc func,
+ gpointer user_data)
{
- g_return_if_fail (conn != NULL);
+ g_return_if_fail (conn != NULL);
- conn->func = func;
- conn->data = user_data;
+ conn->func = func;
+ conn->data = user_data;
}
void
bacon_message_connection_send (BaconMessageConnection *conn,
- const char *message)
+ const char *message)
{
- g_return_if_fail (conn != NULL);
- g_return_if_fail (message != NULL);
+ g_return_if_fail (conn != NULL);
+ g_return_if_fail (message != NULL);
- g_io_channel_write_chars (conn->chan, message, strlen (message),
- NULL, NULL);
- g_io_channel_write_chars (conn->chan, "\n", 1, NULL, NULL);
- g_io_channel_flush (conn->chan, NULL);
+ g_io_channel_write_chars (conn->chan, message, strlen (message),
+ NULL, NULL);
+ g_io_channel_write_chars (conn->chan, "\n", 1, NULL, NULL);
+ g_io_channel_flush (conn->chan, NULL);
}
gboolean
bacon_message_connection_get_is_server (BaconMessageConnection *conn)
{
- g_return_val_if_fail (conn != NULL, FALSE);
+ g_return_val_if_fail (conn != NULL, FALSE);
- return conn->is_server;
+ return conn->is_server;
}
diff --git a/src/bacon-message-connection.h b/src/bacon-message-connection.h
index aac7a2d..7c86b33 100644
--- a/src/bacon-message-connection.h
+++ b/src/bacon-message-connection.h
@@ -25,18 +25,18 @@
G_BEGIN_DECLS
typedef void (*BaconMessageReceivedFunc) (const char *message,
- gpointer user_data);
+ gpointer user_data);
typedef struct BaconMessageConnection BaconMessageConnection;
-BaconMessageConnection *bacon_message_connection_new (const char *prefix);
-void bacon_message_connection_free (BaconMessageConnection *conn);
-void bacon_message_connection_set_callback (BaconMessageConnection *conn,
- BaconMessageReceivedFunc func,
- gpointer user_data);
-void bacon_message_connection_send (BaconMessageConnection *conn,
- const char *message);
-gboolean bacon_message_connection_get_is_server (BaconMessageConnection *conn);
+BaconMessageConnection *bacon_message_connection_new (const char *prefix);
+void bacon_message_connection_free (BaconMessageConnection *conn);
+void bacon_message_connection_set_callback (BaconMessageConnection *conn,
+ BaconMessageReceivedFunc func,
+ gpointer user_data);
+void bacon_message_connection_send (BaconMessageConnection *conn,
+ const char *message);
+gboolean bacon_message_connection_get_is_server (BaconMessageConnection *conn);
G_END_DECLS
diff --git a/src/callbacks.cpp b/src/callbacks.cpp
index 7b4d383..bacebd3 100644
--- a/src/callbacks.cpp
+++ b/src/callbacks.cpp
@@ -41,10 +41,10 @@
void
cb_kill_sigstop(GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- /* no confirmation */
- kill_process (procdata, SIGSTOP);
+ /* no confirmation */
+ kill_process (procdata, SIGSTOP);
}
@@ -53,10 +53,10 @@ cb_kill_sigstop(GtkAction *action, gpointer data)
void
cb_kill_sigcont(GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- /* no confirmation */
- kill_process (procdata, SIGCONT);
+ /* no confirmation */
+ kill_process (procdata, SIGCONT);
}
@@ -65,149 +65,149 @@ cb_kill_sigcont(GtkAction *action, gpointer data)
static void
kill_process_helper(ProcData *procdata, int sig)
{
- if (procdata->config.show_kill_warning)
- procdialog_create_kill_dialog (procdata, sig);
- else
- kill_process (procdata, sig);
+ if (procdata->config.show_kill_warning)
+ procdialog_create_kill_dialog (procdata, sig);
+ else
+ kill_process (procdata, sig);
}
void
cb_edit_preferences (GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- procdialog_create_preferences_dialog (procdata);
+ procdialog_create_preferences_dialog (procdata);
}
void
cb_renice (GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- procdialog_create_renice_dialog (procdata);
+ procdialog_create_renice_dialog (procdata);
}
void
cb_end_process (GtkAction *action, gpointer data)
{
- kill_process_helper(static_cast<ProcData*>(data), SIGTERM);
+ kill_process_helper(static_cast<ProcData*>(data), SIGTERM);
}
void
cb_kill_process (GtkAction *action, gpointer data)
{
- kill_process_helper(static_cast<ProcData*>(data), SIGKILL);
+ kill_process_helper(static_cast<ProcData*>(data), SIGKILL);
}
void
cb_show_memory_maps (GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- create_memmaps_dialog (procdata);
+ create_memmaps_dialog (procdata);
}
void
cb_show_open_files (GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
-
- create_openfiles_dialog (procdata);
+ ProcData *procdata = static_cast<ProcData*>(data);
+
+ create_openfiles_dialog (procdata);
}
void
cb_show_lsof(GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- procman_lsof(procdata);
+ ProcData *procdata = static_cast<ProcData*>(data);
+ procman_lsof(procdata);
}
void
cb_about (GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
-
- const gchar * const authors[] = {
- "Kevin Vandersloot",
- "Erik Johnsson",
- "Jorgen Scheibengruber",
- "BenoÃt Dejean",
- "Paolo Borelli",
- "Karl Lattimer",
- NULL
- };
-
- const gchar * const documenters[] = {
- "Bill Day",
- "Sun Microsystems",
- NULL
- };
-
- const gchar * const artists[] = {
- "Baptiste Mille-Mathias",
- NULL
- };
-
- gtk_show_about_dialog (
- GTK_WINDOW (procdata->app),
- "name", _("System Monitor"),
- "comments", _("View current processes and monitor "
- "system state"),
- "version", VERSION,
- "copyright", "Copyright \xc2\xa9 2001-2004 Kevin Vandersloot\n"
- "Copyright \xc2\xa9 2005-2007 BenoÃt Dejean",
- "logo-icon-name", "utilities-system-monitor",
- "authors", authors,
- "artists", artists,
- "documenters", documenters,
- "translator-credits", _("translator-credits"),
- "license", "GPL 2+",
- "wrap-license", TRUE,
- NULL
- );
+ ProcData *procdata = static_cast<ProcData*>(data);
+
+ const gchar * const authors[] = {
+ "Kevin Vandersloot",
+ "Erik Johnsson",
+ "Jorgen Scheibengruber",
+ "BenoÃt Dejean",
+ "Paolo Borelli",
+ "Karl Lattimer",
+ NULL
+ };
+
+ const gchar * const documenters[] = {
+ "Bill Day",
+ "Sun Microsystems",
+ NULL
+ };
+
+ const gchar * const artists[] = {
+ "Baptiste Mille-Mathias",
+ NULL
+ };
+
+ gtk_show_about_dialog (
+ GTK_WINDOW (procdata->app),
+ "name", _("System Monitor"),
+ "comments", _("View current processes and monitor "
+ "system state"),
+ "version", VERSION,
+ "copyright", "Copyright \xc2\xa9 2001-2004 Kevin Vandersloot\n"
+ "Copyright \xc2\xa9 2005-2007 BenoÃt Dejean",
+ "logo-icon-name", "utilities-system-monitor",
+ "authors", authors,
+ "artists", artists,
+ "documenters", documenters,
+ "translator-credits", _("translator-credits"),
+ "license", "GPL 2+",
+ "wrap-license", TRUE,
+ NULL
+ );
}
void
cb_help_contents (GtkAction *action, gpointer data)
{
- GError* error = 0;
- if (!g_app_info_launch_default_for_uri("ghelp:gnome-system-monitor", NULL, &error)) {
- g_warning("Could not display help : %s", error->message);
- g_error_free(error);
- }
+ GError* error = 0;
+ if (!g_app_info_launch_default_for_uri("ghelp:gnome-system-monitor", NULL, &error)) {
+ g_warning("Could not display help : %s", error->message);
+ g_error_free(error);
+ }
}
void
cb_app_exit (GtkAction *action, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- cb_app_delete (NULL, NULL, procdata);
+ cb_app_delete (NULL, NULL, procdata);
}
gboolean
cb_app_delete (GtkWidget *window, GdkEventAny *event, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(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);
+ procman_save_config (procdata);
+ if (procdata->timeout)
+ g_source_remove (procdata->timeout);
+ if (procdata->disk_timeout)
+ g_source_remove (procdata->disk_timeout);
- gtk_main_quit ();
+ gtk_main_quit ();
- return TRUE;
+ return TRUE;
}
@@ -215,183 +215,183 @@ cb_app_delete (GtkWidget *window, GdkEventAny *event, gpointer data)
void
cb_end_process_button_pressed (GtkButton *button, gpointer data)
{
- kill_process_helper(static_cast<ProcData*>(data), SIGTERM);
+ kill_process_helper(static_cast<ProcData*>(data), SIGTERM);
}
static void change_settings_color(GSettings *settings, const char *key,
- GSMColorButton *cp)
+ GSMColorButton *cp)
{
- GdkColor c;
- char color[24]; /* color should be 1 + 3*4 + 1 = 15 chars -> 24 */
+ GdkColor c;
+ char color[24]; /* color should be 1 + 3*4 + 1 = 15 chars -> 24 */
- gsm_color_button_get_color(cp, &c);
- g_snprintf(color, sizeof color, "#%04x%04x%04x", c.red, c.green, c.blue);
- g_settings_set_string (settings, key, color);
+ gsm_color_button_get_color(cp, &c);
+ g_snprintf(color, sizeof color, "#%04x%04x%04x", c.red, c.green, c.blue);
+ g_settings_set_string (settings, key, color);
}
void
cb_cpu_color_changed (GSMColorButton *cp, gpointer data)
{
- char key[80];
- gint i = GPOINTER_TO_INT (data);
- GSettings *settings = g_settings_new (GSM_GSETTINGS_SCHEMA);
+ char key[80];
+ gint i = GPOINTER_TO_INT (data);
+ GSettings *settings = g_settings_new (GSM_GSETTINGS_SCHEMA);
- g_snprintf(key, sizeof key, "cpu-color%d", i%4);
+ g_snprintf(key, sizeof key, "cpu-color%d", i%4);
- change_settings_color(settings, key, cp);
+ change_settings_color(settings, key, cp);
}
void
cb_mem_color_changed (GSMColorButton *cp, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- change_settings_color(procdata->settings, "mem-color", cp);
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ change_settings_color(procdata->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);
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ change_settings_color(procdata->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);
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ change_settings_color(procdata->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);
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ change_settings_color(procdata->settings, "net-out-color", cp);
}
static void
get_last_selected (GtkTreeModel *model, GtkTreePath *path,
- GtkTreeIter *iter, gpointer data)
+ GtkTreeIter *iter, gpointer data)
{
- ProcInfo **info = static_cast<ProcInfo**>(data);
+ ProcInfo **info = static_cast<ProcInfo**>(data);
- gtk_tree_model_get (model, iter, COL_POINTER, info, -1);
+ gtk_tree_model_get (model, iter, COL_POINTER, info, -1);
}
void
cb_row_selected (GtkTreeSelection *selection, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- procdata->selection = selection;
+ procdata->selection = selection;
- /* 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);
+ /* 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);
- update_sensitivity(procdata);
+ update_sensitivity(procdata);
}
gboolean
cb_tree_button_pressed (GtkWidget *widget,
- GdkEventButton *event,
- gpointer data)
+ GdkEventButton *event,
+ gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
- do_popup_menu (procdata, event);
+ if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
+ do_popup_menu (procdata, event);
- return FALSE;
+ return FALSE;
}
gboolean
cb_tree_popup_menu (GtkWidget *widget, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- do_popup_menu (procdata, NULL);
+ do_popup_menu (procdata, NULL);
- return TRUE;
+ return TRUE;
}
void
cb_switch_page (GtkNotebook *nb, GtkWidget *page,
- gint num, gpointer data)
+ gint num, gpointer data)
{
- cb_change_current_page (nb, num, data);
+ cb_change_current_page (nb, num, data);
}
void
cb_change_current_page (GtkNotebook *nb, gint num, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- procdata->config.current_tab = num;
+ procdata->config.current_tab = num;
- if (num == PROCMAN_TAB_PROCESSES) {
+ if (num == PROCMAN_TAB_PROCESSES) {
- cb_timeout (procdata);
+ cb_timeout (procdata);
- if (!procdata->timeout)
- procdata->timeout = g_timeout_add (
- procdata->config.update_interval,
- cb_timeout, procdata);
+ if (!procdata->timeout)
+ procdata->timeout = g_timeout_add (
+ procdata->config.update_interval,
+ cb_timeout, procdata);
- update_sensitivity(procdata);
- }
- else {
- if (procdata->timeout) {
- g_source_remove (procdata->timeout);
- procdata->timeout = 0;
- }
+ update_sensitivity(procdata);
+ }
+ else {
+ if (procdata->timeout) {
+ g_source_remove (procdata->timeout);
+ procdata->timeout = 0;
+ }
- update_sensitivity(procdata);
- }
+ update_sensitivity(procdata);
+ }
- if (num == PROCMAN_TAB_RESOURCES) {
- load_graph_start (procdata->cpu_graph);
- load_graph_start (procdata->mem_graph);
- load_graph_start (procdata->net_graph);
- }
- else {
- load_graph_stop (procdata->cpu_graph);
- load_graph_stop (procdata->mem_graph);
- load_graph_stop (procdata->net_graph);
- }
+ if (num == PROCMAN_TAB_RESOURCES) {
+ load_graph_start (procdata->cpu_graph);
+ load_graph_start (procdata->mem_graph);
+ load_graph_start (procdata->net_graph);
+ }
+ else {
+ load_graph_stop (procdata->cpu_graph);
+ load_graph_stop (procdata->mem_graph);
+ load_graph_stop (procdata->net_graph);
+ }
- if (num == PROCMAN_TAB_DISKS) {
+ if (num == PROCMAN_TAB_DISKS) {
- cb_update_disks (procdata);
+ cb_update_disks (procdata);
- if(!procdata->disk_timeout) {
- procdata->disk_timeout =
- g_timeout_add (procdata->config.disks_update_interval,
- cb_update_disks,
- procdata);
- }
- }
- else {
- if(procdata->disk_timeout) {
- g_source_remove (procdata->disk_timeout);
- procdata->disk_timeout = 0;
- }
- }
+ if(!procdata->disk_timeout) {
+ procdata->disk_timeout =
+ g_timeout_add (procdata->config.disks_update_interval,
+ cb_update_disks,
+ procdata);
+ }
+ }
+ else {
+ if(procdata->disk_timeout) {
+ g_source_remove (procdata->disk_timeout);
+ procdata->disk_timeout = 0;
+ }
+ }
- if (num == PROCMAN_TAB_SYSINFO) {
- procman::build_sysinfo_ui();
- }
+ if (num == PROCMAN_TAB_SYSINFO) {
+ procman::build_sysinfo_ui();
+ }
}
@@ -399,39 +399,39 @@ 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);
- return FALSE;
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ proctable_update_all(procdata);
+ return FALSE;
}
gint
cb_timeout (gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- guint new_interval;
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ guint new_interval;
- proctable_update_all (procdata);
+ proctable_update_all (procdata);
- if (procdata->smooth_refresh->get(new_interval))
- {
- procdata->timeout = g_timeout_add(new_interval,
- cb_timeout,
- procdata);
- return FALSE;
- }
+ if (procdata->smooth_refresh->get(new_interval))
+ {
+ procdata->timeout = g_timeout_add(new_interval,
+ cb_timeout,
+ procdata);
+ return FALSE;
+ }
- return TRUE;
+ return TRUE;
}
void
cb_radio_processes(GtkAction *action, GtkRadioAction *current, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- procdata->config.whose_process = gtk_radio_action_get_current_value(current);
+ procdata->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 (procdata->settings, "view-as",
+ procdata->config.whose_process);
}
diff --git a/src/callbacks.h b/src/callbacks.h
index 6ce3e18..8988ffa 100644
--- a/src/callbacks.h
+++ b/src/callbacks.h
@@ -26,57 +26,57 @@
#include "gsm_color_button.h"
-void cb_show_memory_maps (GtkAction *action, gpointer data);
-void cb_show_open_files (GtkAction *action, gpointer data);
-void cb_show_lsof(GtkAction *action, gpointer data);
-void cb_renice (GtkAction *action, gpointer data);
-void cb_end_process (GtkAction *action, gpointer data);
-void cb_kill_process (GtkAction *action, gpointer data);
-void cb_edit_preferences (GtkAction *action, gpointer data);
+void cb_show_memory_maps (GtkAction *action, gpointer data);
+void cb_show_open_files (GtkAction *action, gpointer data);
+void cb_show_lsof(GtkAction *action, gpointer data);
+void cb_renice (GtkAction *action, gpointer data);
+void cb_end_process (GtkAction *action, gpointer data);
+void cb_kill_process (GtkAction *action, gpointer data);
+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_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);
+void cb_app_exit (GtkAction *action, gpointer data);
+gboolean cb_app_delete (GtkWidget *window, GdkEventAny *event, gpointer data);
-void cb_end_process_button_pressed (GtkButton *button, gpointer data);
-void cb_logout (GtkButton *button, gpointer data);
+void cb_end_process_button_pressed (GtkButton *button, gpointer data);
+void cb_logout (GtkButton *button, gpointer data);
-void cb_info_button_pressed (GtkButton *button, gpointer user_data);
+void cb_info_button_pressed (GtkButton *button, gpointer user_data);
-void cb_cpu_color_changed (GSMColorButton *widget, gpointer user_data);
-void cb_mem_color_changed (GSMColorButton *widget, gpointer user_data);
-void cb_swap_color_changed (GSMColorButton *widget, gpointer user_data);
-void cb_net_in_color_changed (GSMColorButton *widget, gpointer user_data);
-void cb_net_out_color_changed (GSMColorButton *widget, gpointer user_data);
+void cb_cpu_color_changed (GSMColorButton *widget, gpointer user_data);
+void cb_mem_color_changed (GSMColorButton *widget, gpointer user_data);
+void cb_swap_color_changed (GSMColorButton *widget, gpointer user_data);
+void cb_net_in_color_changed (GSMColorButton *widget, gpointer user_data);
+void cb_net_out_color_changed (GSMColorButton *widget, gpointer user_data);
-void cb_row_selected (GtkTreeSelection *selection, gpointer data);
+void cb_row_selected (GtkTreeSelection *selection, gpointer data);
-gboolean cb_tree_popup_menu (GtkWidget *widget, gpointer data);
-gboolean cb_tree_button_pressed (GtkWidget *widget, GdkEventButton *event,
- gpointer data);
+gboolean cb_tree_popup_menu (GtkWidget *widget, gpointer data);
+gboolean cb_tree_button_pressed (GtkWidget *widget, GdkEventButton *event,
+ gpointer data);
-void cb_change_current_page (GtkNotebook *nb,
- gint num, gpointer data);
-void cb_switch_page (GtkNotebook *nb, GtkWidget *page,
- gint num, gpointer data);
+void cb_change_current_page (GtkNotebook *nb,
+ gint num, gpointer data);
+void cb_switch_page (GtkNotebook *nb, GtkWidget *page,
+ gint num, gpointer data);
-gint cb_update_disks (gpointer data);
-gint cb_user_refresh (GtkAction* action, gpointer data);
-gint cb_timeout (gpointer data);
+gint cb_update_disks (gpointer data);
+gint cb_user_refresh (GtkAction* action, gpointer data);
+gint cb_timeout (gpointer data);
-void cb_radio_processes(GtkAction *action,
- GtkRadioAction *current,
- gpointer data);
+void cb_radio_processes(GtkAction *action,
+ GtkRadioAction *current,
+ gpointer data);
-void cb_kill_sigstop(GtkAction *action,
- gpointer data);
+void cb_kill_sigstop(GtkAction *action,
+ gpointer data);
-void cb_kill_sigcont(GtkAction *action,
- gpointer data);
+void cb_kill_sigcont(GtkAction *action,
+ gpointer data);
#endif /* _PROCMAN_CALLBACKS_H_ */
diff --git a/src/defaulttable.h b/src/defaulttable.h
index fec06bb..f5adbec 100644
--- a/src/defaulttable.h
+++ b/src/defaulttable.h
@@ -9,41 +9,41 @@
struct PrettyTableItem
{
- Glib::RefPtr<Glib::Regex> command;
- std::string icon;
+ Glib::RefPtr<Glib::Regex> command;
+ std::string icon;
- PrettyTableItem(const std::string& a_command, const std::string& a_icon)
- : command(Glib::Regex::create("^(" + a_command + ")$")),
- icon(a_icon)
- { }
+PrettyTableItem(const std::string& a_command, const std::string& a_icon)
+: command(Glib::Regex::create("^(" + a_command + ")$")),
+ icon(a_icon)
+ { }
};
#define ITEM PrettyTableItem
/* The current table is only a test */
static const PrettyTableItem default_table[] = {
- ITEM("(ba|z|tc|c|k)?sh", "utilities-terminal"),
- ITEM("(k|sys|u)logd|logger", "internet-news-reader"),
- ITEM("X(org)?", "display"),
- ITEM("apache2?|httpd|lighttpd", "internet-web-browser"),
- ITEM(".*applet(-?2)?", "gnome-applets"),
- ITEM("atd|cron|CRON|ntpd", "date"),
- ITEM("cupsd|lpd?", "printer"),
- ITEM("cvsd|mtn|git|svn", "file-manager"),
- ITEM("emacs(server|\\d+)?", "gnome-emacs"),
- ITEM("evolution.*", "internet-mail"),
- ITEM("famd|gam_server", "file-manager"),
- ITEM("gconfd-2", "preferences-desktop"),
- ITEM("getty", "input-keyboard"),
- ITEM("gdb|((gcc|g\\+\\+)(-.*)?)|ar|ld|make", "applications-development"),
- ITEM("metacity", "gnome-window-manager"),
- ITEM("sendmail|exim\\d?", "internet-mail"),
- ITEM("squid", "proxy"),
- ITEM("ssh(d|-agent)", "ssh-askpass-gnome"),
- ITEM("top|vmstat", "system-monitor"),
- ITEM("vim?", "vim"),
- ITEM("x?inetd", "internet-web-browser"),
- ITEM("vino.*", "gnome-remote-desktop")
+ ITEM("(ba|z|tc|c|k)?sh", "utilities-terminal"),
+ ITEM("(k|sys|u)logd|logger", "internet-news-reader"),
+ ITEM("X(org)?", "display"),
+ ITEM("apache2?|httpd|lighttpd", "internet-web-browser"),
+ ITEM(".*applet(-?2)?", "gnome-applets"),
+ ITEM("atd|cron|CRON|ntpd", "date"),
+ ITEM("cupsd|lpd?", "printer"),
+ ITEM("cvsd|mtn|git|svn", "file-manager"),
+ ITEM("emacs(server|\\d+)?", "gnome-emacs"),
+ ITEM("evolution.*", "internet-mail"),
+ ITEM("famd|gam_server", "file-manager"),
+ ITEM("gconfd-2", "preferences-desktop"),
+ ITEM("getty", "input-keyboard"),
+ ITEM("gdb|((gcc|g\\+\\+)(-.*)?)|ar|ld|make", "applications-development"),
+ ITEM("metacity", "gnome-window-manager"),
+ ITEM("sendmail|exim\\d?", "internet-mail"),
+ ITEM("squid", "proxy"),
+ ITEM("ssh(d|-agent)", "ssh-askpass-gnome"),
+ ITEM("top|vmstat", "system-monitor"),
+ ITEM("vim?", "vim"),
+ ITEM("x?inetd", "internet-web-browser"),
+ ITEM("vino.*", "gnome-remote-desktop")
};
#undef ITEM
diff --git a/src/disks.cpp b/src/disks.cpp
index 97ac949..121765f 100644
--- a/src/disks.cpp
+++ b/src/disks.cpp
@@ -15,120 +15,120 @@
enum DiskColumns
{
- /* string columns* */
- DISK_DEVICE,
- DISK_DIR,
- DISK_TYPE,
- DISK_TOTAL,
- DISK_FREE,
- DISK_AVAIL,
- /* USED has to be the last column */
- DISK_USED,
- // then unvisible columns
- /* PixBuf column */
- DISK_ICON,
- /* numeric columns */
- DISK_USED_PERCENTAGE,
- DISK_N_COLUMNS
+ /* string columns* */
+ DISK_DEVICE,
+ DISK_DIR,
+ DISK_TYPE,
+ DISK_TOTAL,
+ DISK_FREE,
+ DISK_AVAIL,
+ /* USED has to be the last column */
+ DISK_USED,
+ // then unvisible columns
+ /* PixBuf column */
+ DISK_ICON,
+ /* numeric columns */
+ DISK_USED_PERCENTAGE,
+ DISK_N_COLUMNS
};
static void
fsusage_stats(const glibtop_fsusage *buf,
- guint64 *bused, guint64 *bfree, guint64 *bavail, guint64 *btotal,
- gint *percentage)
+ guint64 *bused, guint64 *bfree, guint64 *bavail, guint64 *btotal,
+ gint *percentage)
{
- guint64 total = buf->blocks * buf->block_size;
-
- if (!total) {
- /* not a real device */
- *btotal = *bfree = *bavail = *bused = 0ULL;
- *percentage = 0;
- } else {
- int percent;
- *btotal = total;
- *bfree = buf->bfree * buf->block_size;
- *bavail = buf->bavail * buf->block_size;
- *bused = *btotal - *bfree;
- /* percent = 100.0f * *bused / *btotal; */
- percent = 100 * *bused / (*bused + *bavail);
- *percentage = CLAMP(percent, 0, 100);
- }
+ guint64 total = buf->blocks * buf->block_size;
+
+ if (!total) {
+ /* not a real device */
+ *btotal = *bfree = *bavail = *bused = 0ULL;
+ *percentage = 0;
+ } else {
+ int percent;
+ *btotal = total;
+ *bfree = buf->bfree * buf->block_size;
+ *bavail = buf->bavail * buf->block_size;
+ *bused = *btotal - *bfree;
+ /* percent = 100.0f * *bused / *btotal; */
+ percent = 100 * *bused / (*bused + *bavail);
+ *percentage = CLAMP(percent, 0, 100);
+ }
}
namespace
{
- string get_icon_for_path(const std::string& path)
- {
- using namespace Glib;
- using namespace Gio;
-
- // FIXME: I don't know whether i should use Volume or Mount or UnixMount
- // all i need an icon name.
- RefPtr<VolumeMonitor> monitor = VolumeMonitor::get();
-
- std::vector<RefPtr<Mount> > mounts = monitor->get_mounts();
-
- for (size_t i = 0; i != mounts.size(); ++i) {
- if (mounts[i]->get_name() != path)
- continue;
-
- RefPtr<Icon> icon = mounts[i]->get_icon();
- RefPtr<ThemedIcon> themed_icon = RefPtr<ThemedIcon>::cast_dynamic(icon);
-
- if (themed_icon) {
- char* name = 0;
- // FIXME: not wrapped yet
- g_object_get(G_OBJECT(themed_icon->gobj()), "name", &name, NULL);
- return make_string(name);
- }
- }
+ string get_icon_for_path(const std::string& path)
+ {
+ using namespace Glib;
+ using namespace Gio;
+
+ // FIXME: I don't know whether i should use Volume or Mount or UnixMount
+ // all i need an icon name.
+ RefPtr<VolumeMonitor> monitor = VolumeMonitor::get();
+
+ std::vector<RefPtr<Mount> > mounts = monitor->get_mounts();
+
+ for (size_t i = 0; i != mounts.size(); ++i) {
+ if (mounts[i]->get_name() != path)
+ continue;
+
+ RefPtr<Icon> icon = mounts[i]->get_icon();
+ RefPtr<ThemedIcon> themed_icon = RefPtr<ThemedIcon>::cast_dynamic(icon);
+
+ if (themed_icon) {
+ char* name = 0;
+ // FIXME: not wrapped yet
+ g_object_get(G_OBJECT(themed_icon->gobj()), "name", &name, NULL);
+ return make_string(name);
+ }
+ }
- return "";
- }
+ return "";
+ }
}
static Glib::RefPtr<Gdk::Pixbuf>
get_icon_for_device(const char *mountpoint)
{
- procman::IconThemeWrapper icon_theme;
- string icon_name = get_icon_for_path(mountpoint);
- if (icon_name == "")
- // FIXME: defaults to a safe value
- icon_name = "drive-harddisk"; // get_icon_for_path("/");
- return icon_theme->load_icon(icon_name, 24, Gtk::ICON_LOOKUP_USE_BUILTIN);
+ procman::IconThemeWrapper icon_theme;
+ string icon_name = get_icon_for_path(mountpoint);
+ if (icon_name == "")
+ // FIXME: defaults to a safe value
+ icon_name = "drive-harddisk"; // get_icon_for_path("/");
+ return icon_theme->load_icon(icon_name, 24, Gtk::ICON_LOOKUP_USE_BUILTIN);
}
static gboolean
find_disk_in_model(GtkTreeModel *model, const char *mountpoint,
- GtkTreeIter *result)
+ GtkTreeIter *result)
{
- GtkTreeIter iter;
- gboolean found = FALSE;
+ GtkTreeIter iter;
+ gboolean found = FALSE;
- if (gtk_tree_model_get_iter_first(model, &iter)) {
- do {
- char *dir;
+ if (gtk_tree_model_get_iter_first(model, &iter)) {
+ do {
+ char *dir;
- gtk_tree_model_get(model, &iter,
- DISK_DIR, &dir,
- -1);
+ gtk_tree_model_get(model, &iter,
+ DISK_DIR, &dir,
+ -1);
- if (dir && !strcmp(dir, mountpoint)) {
- *result = iter;
- found = TRUE;
- }
+ if (dir && !strcmp(dir, mountpoint)) {
+ *result = iter;
+ found = TRUE;
+ }
- g_free(dir);
+ g_free(dir);
- } while (!found && gtk_tree_model_iter_next(model, &iter));
- }
+ } while (!found && gtk_tree_model_iter_next(model, &iter));
+ }
- return found;
+ return found;
}
@@ -136,39 +136,39 @@ find_disk_in_model(GtkTreeModel *model, const char *mountpoint,
static void
remove_old_disks(GtkTreeModel *model, const glibtop_mountentry *entries, guint n)
{
- GtkTreeIter iter;
-
- if (!gtk_tree_model_get_iter_first(model, &iter))
- return;
-
- while (true) {
- char *dir;
- guint i;
- gboolean found = FALSE;
-
- gtk_tree_model_get(model, &iter,
- DISK_DIR, &dir,
- -1);
-
- for (i = 0; i != n; ++i) {
- if (!strcmp(dir, entries[i].mountdir)) {
- found = TRUE;
- break;
- }
- }
-
- g_free(dir);
-
- if (!found) {
- if (!gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
- break;
- else
- continue;
- }
-
- if (!gtk_tree_model_iter_next(model, &iter))
- break;
- }
+ GtkTreeIter iter;
+
+ if (!gtk_tree_model_get_iter_first(model, &iter))
+ return;
+
+ while (true) {
+ char *dir;
+ guint i;
+ gboolean found = FALSE;
+
+ gtk_tree_model_get(model, &iter,
+ DISK_DIR, &dir,
+ -1);
+
+ for (i = 0; i != n; ++i) {
+ if (!strcmp(dir, entries[i].mountdir)) {
+ found = TRUE;
+ break;
+ }
+ }
+
+ g_free(dir);
+
+ if (!found) {
+ if (!gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
+ break;
+ else
+ continue;
+ }
+
+ if (!gtk_tree_model_iter_next(model, &iter))
+ break;
+ }
}
@@ -176,41 +176,41 @@ remove_old_disks(GtkTreeModel *model, const glibtop_mountentry *entries, guint n
static void
add_disk(GtkListStore *list, const glibtop_mountentry *entry, bool show_all_fs)
{
- Glib::RefPtr<Gdk::Pixbuf> pixbuf;
- GtkTreeIter iter;
- glibtop_fsusage usage;
- guint64 bused, bfree, bavail, btotal;
- gint percentage;
-
- glibtop_get_fsusage(&usage, entry->mountdir);
-
- if (not show_all_fs and usage.blocks == 0) {
- if (find_disk_in_model(GTK_TREE_MODEL(list), entry->mountdir, &iter))
- gtk_list_store_remove(list, &iter);
- return;
- }
-
- fsusage_stats(&usage, &bused, &bfree, &bavail, &btotal, &percentage);
- pixbuf = get_icon_for_device(entry->mountdir);
-
- /* if we can find a row with the same mountpoint, we get it but we
- still need to update all the fields.
- This makes selection persistent.
- */
- if (!find_disk_in_model(GTK_TREE_MODEL(list), entry->mountdir, &iter))
- gtk_list_store_append(list, &iter);
-
- gtk_list_store_set(list, &iter,
- DISK_ICON, pixbuf->gobj(),
- DISK_DEVICE, entry->devname,
- DISK_DIR, entry->mountdir,
- DISK_TYPE, entry->type,
- DISK_USED_PERCENTAGE, percentage,
- DISK_TOTAL, btotal,
- DISK_FREE, bfree,
- DISK_AVAIL, bavail,
- DISK_USED, bused,
- -1);
+ Glib::RefPtr<Gdk::Pixbuf> pixbuf;
+ GtkTreeIter iter;
+ glibtop_fsusage usage;
+ guint64 bused, bfree, bavail, btotal;
+ gint percentage;
+
+ glibtop_get_fsusage(&usage, entry->mountdir);
+
+ if (not show_all_fs and usage.blocks == 0) {
+ if (find_disk_in_model(GTK_TREE_MODEL(list), entry->mountdir, &iter))
+ gtk_list_store_remove(list, &iter);
+ return;
+ }
+
+ fsusage_stats(&usage, &bused, &bfree, &bavail, &btotal, &percentage);
+ pixbuf = get_icon_for_device(entry->mountdir);
+
+ /* if we can find a row with the same mountpoint, we get it but we
+ still need to update all the fields.
+ This makes selection persistent.
+ */
+ if (!find_disk_in_model(GTK_TREE_MODEL(list), entry->mountdir, &iter))
+ gtk_list_store_append(list, &iter);
+
+ gtk_list_store_set(list, &iter,
+ DISK_ICON, pixbuf->gobj(),
+ DISK_DEVICE, entry->devname,
+ DISK_DIR, entry->mountdir,
+ DISK_TYPE, entry->type,
+ DISK_USED_PERCENTAGE, percentage,
+ DISK_TOTAL, btotal,
+ DISK_FREE, bfree,
+ DISK_AVAIL, bavail,
+ DISK_USED, bused,
+ -1);
}
@@ -218,204 +218,204 @@ 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);
+ ProcData *const procdata = static_cast<ProcData*>(data);
- GtkListStore *list;
- glibtop_mountentry * entries;
- glibtop_mountlist mountlist;
- guint i;
+ 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(procdata->disk_list)));
- entries = glibtop_get_mountlist(&mountlist, procdata->config.show_all_fs);
+ entries = glibtop_get_mountlist(&mountlist, procdata->config.show_all_fs);
- remove_old_disks(GTK_TREE_MODEL(list), entries, mountlist.number);
+ 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);
+ for (i = 0; i < mountlist.number; i++)
+ add_disk(list, &entries[i], procdata->config.show_all_fs);
- g_free(entries);
+ g_free(entries);
- return TRUE;
+ return TRUE;
}
static void
cb_disk_columns_changed(GtkTreeView *treeview, gpointer user_data)
{
- ProcData * const procdata = static_cast<ProcData*>(user_data);
+ ProcData * const procdata = static_cast<ProcData*>(user_data);
- procman_save_tree_state(procdata->settings,
- GTK_WIDGET(treeview),
- "disktreenew");
+ procman_save_tree_state(procdata->settings,
+ GTK_WIDGET(treeview),
+ "disktreenew");
}
static void open_dir(GtkTreeView *tree_view,
- GtkTreePath *path,
- GtkTreeViewColumn *column,
- gpointer user_data)
+ GtkTreePath *path,
+ GtkTreeViewColumn *column,
+ gpointer user_data)
{
- GtkTreeIter iter;
- GtkTreeModel *model;
- char *dir, *url;
-
- model = gtk_tree_view_get_model(tree_view);
-
- if (!gtk_tree_model_get_iter(model, &iter, path)) {
- char *p;
- p = gtk_tree_path_to_string(path);
- g_warning("Cannot get iter for path '%s'\n", p);
- g_free(p);
- return;
- }
+ GtkTreeIter iter;
+ GtkTreeModel *model;
+ char *dir, *url;
+
+ model = gtk_tree_view_get_model(tree_view);
+
+ if (!gtk_tree_model_get_iter(model, &iter, path)) {
+ char *p;
+ p = gtk_tree_path_to_string(path);
+ g_warning("Cannot get iter for path '%s'\n", p);
+ g_free(p);
+ return;
+ }
- gtk_tree_model_get(model, &iter, DISK_DIR, &dir, -1);
+ gtk_tree_model_get(model, &iter, DISK_DIR, &dir, -1);
- url = g_strdup_printf("file://%s", dir);
+ url = g_strdup_printf("file://%s", dir);
- GError* error = 0;
- if (!g_app_info_launch_default_for_uri(url, NULL, &error)) {
- g_warning("Cannot open '%s' : %s\n", url, error->message);
- g_error_free(error);
- }
+ GError* error = 0;
+ if (!g_app_info_launch_default_for_uri(url, NULL, &error)) {
+ g_warning("Cannot open '%s' : %s\n", url, error->message);
+ g_error_free(error);
+ }
- g_free(url);
- g_free(dir);
+ g_free(url);
+ g_free(dir);
}
GtkWidget *
create_disk_view(ProcData *procdata)
{
- GtkWidget *disk_box;
- GtkWidget *scrolled;
- GtkWidget *disk_tree;
- GtkListStore *model;
- GtkTreeViewColumn *col;
- GtkCellRenderer *cell;
- guint i;
-
- const gchar * const titles[] = {
- N_("Device"),
- N_("Directory"),
- N_("Type"),
- N_("Total"),
- N_("Free"),
- N_("Available"),
- N_("Used")
- };
-
- disk_box = gtk_vbox_new(FALSE, 6);
-
- gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12);
-
- scrolled = gtk_scrolled_window_new(NULL, NULL);
- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
- GTK_SHADOW_IN);
-
- gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0);
-
- model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
- G_TYPE_STRING, /* DISK_DEVICE */
- G_TYPE_STRING, /* DISK_DIR */
- G_TYPE_STRING, /* DISK_TYPE */
- G_TYPE_UINT64, /* DISK_TOTAL */
- G_TYPE_UINT64, /* DISK_FREE */
- G_TYPE_UINT64, /* DISK_AVAIL */
- G_TYPE_UINT64, /* DISK_USED */
- GDK_TYPE_PIXBUF, /* DISK_ICON */
- G_TYPE_INT /* DISK_USED_PERCENTAGE */
- );
-
- disk_tree = 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;
- 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));
-
- /* icon + device */
-
- col = gtk_tree_view_column_new();
- cell = gtk_cell_renderer_pixbuf_new();
- gtk_tree_view_column_pack_start(col, cell, FALSE);
- gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
- NULL);
-
- cell = gtk_cell_renderer_text_new();
- gtk_tree_view_column_pack_start(col, cell, FALSE);
- gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
- NULL);
- gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
- gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
- gtk_tree_view_column_set_reorderable(col, TRUE);
- gtk_tree_view_column_set_resizable(col, TRUE);
- gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
-
- /* sizes - used */
-
- for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
- cell = gtk_cell_renderer_text_new();
- col = gtk_tree_view_column_new();
- gtk_tree_view_column_pack_start(col, cell, TRUE);
- gtk_tree_view_column_set_title(col, _(titles[i]));
- gtk_tree_view_column_set_resizable(col, TRUE);
- gtk_tree_view_column_set_sort_column_id(col, i);
- gtk_tree_view_column_set_reorderable(col, TRUE);
- gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
-
- switch (i) {
- case DISK_TOTAL:
- case DISK_FREE:
- case DISK_AVAIL:
- g_object_set(cell, "xalign", 1.0f, NULL);
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::size_cell_data_func,
- GUINT_TO_POINTER(i),
- NULL);
- break;
-
- default:
- gtk_tree_view_column_set_attributes(col, cell,
- "text", i,
- NULL);
- break;
- }
- }
-
- /* used + percentage */
-
- col = gtk_tree_view_column_new();
- cell = gtk_cell_renderer_text_new();
- g_object_set(cell, "xalign", 1.0f, NULL);
- gtk_tree_view_column_pack_start(col, cell, FALSE);
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::size_cell_data_func,
- GUINT_TO_POINTER(DISK_USED),
- NULL);
- gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
-
- cell = gtk_cell_renderer_progress_new();
- gtk_tree_view_column_pack_start(col, cell, TRUE);
- gtk_tree_view_column_set_attributes(col, cell, "value",
- DISK_USED_PERCENTAGE, NULL);
- gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
- gtk_tree_view_column_set_resizable(col, TRUE);
- gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
- gtk_tree_view_column_set_reorderable(col, TRUE);
-
- /* numeric sort */
-
- gtk_widget_show_all(disk_box);
-
- procman_get_tree_state(procdata->settings, disk_tree,
- "disktreenew");
-
- g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
- G_CALLBACK(cb_disk_columns_changed), procdata);
-
- return disk_box;
+ GtkWidget *disk_box;
+ GtkWidget *scrolled;
+ GtkWidget *disk_tree;
+ GtkListStore *model;
+ GtkTreeViewColumn *col;
+ GtkCellRenderer *cell;
+ guint i;
+
+ const gchar * const titles[] = {
+ N_("Device"),
+ N_("Directory"),
+ N_("Type"),
+ N_("Total"),
+ N_("Free"),
+ N_("Available"),
+ N_("Used")
+ };
+
+ disk_box = gtk_vbox_new(FALSE, 6);
+
+ gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12);
+
+ scrolled = gtk_scrolled_window_new(NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
+ GTK_SHADOW_IN);
+
+ gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0);
+
+ model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
+ G_TYPE_STRING, /* DISK_DEVICE */
+ G_TYPE_STRING, /* DISK_DIR */
+ G_TYPE_STRING, /* DISK_TYPE */
+ G_TYPE_UINT64, /* DISK_TOTAL */
+ G_TYPE_UINT64, /* DISK_FREE */
+ G_TYPE_UINT64, /* DISK_AVAIL */
+ G_TYPE_UINT64, /* DISK_USED */
+ GDK_TYPE_PIXBUF, /* DISK_ICON */
+ G_TYPE_INT /* DISK_USED_PERCENTAGE */
+ );
+
+ disk_tree = 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;
+ 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));
+
+ /* icon + device */
+
+ col = gtk_tree_view_column_new();
+ cell = gtk_cell_renderer_pixbuf_new();
+ gtk_tree_view_column_pack_start(col, cell, FALSE);
+ gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
+ NULL);
+
+ cell = gtk_cell_renderer_text_new();
+ gtk_tree_view_column_pack_start(col, cell, FALSE);
+ gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
+ NULL);
+ gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
+ gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
+ gtk_tree_view_column_set_reorderable(col, TRUE);
+ gtk_tree_view_column_set_resizable(col, TRUE);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
+
+ /* sizes - used */
+
+ for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
+ cell = gtk_cell_renderer_text_new();
+ col = gtk_tree_view_column_new();
+ gtk_tree_view_column_pack_start(col, cell, TRUE);
+ gtk_tree_view_column_set_title(col, _(titles[i]));
+ gtk_tree_view_column_set_resizable(col, TRUE);
+ gtk_tree_view_column_set_sort_column_id(col, i);
+ gtk_tree_view_column_set_reorderable(col, TRUE);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
+
+ switch (i) {
+ case DISK_TOTAL:
+ case DISK_FREE:
+ case DISK_AVAIL:
+ g_object_set(cell, "xalign", 1.0f, NULL);
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::size_cell_data_func,
+ GUINT_TO_POINTER(i),
+ NULL);
+ break;
+
+ default:
+ gtk_tree_view_column_set_attributes(col, cell,
+ "text", i,
+ NULL);
+ break;
+ }
+ }
+
+ /* used + percentage */
+
+ col = gtk_tree_view_column_new();
+ cell = gtk_cell_renderer_text_new();
+ g_object_set(cell, "xalign", 1.0f, NULL);
+ gtk_tree_view_column_pack_start(col, cell, FALSE);
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::size_cell_data_func,
+ GUINT_TO_POINTER(DISK_USED),
+ NULL);
+ gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
+
+ cell = gtk_cell_renderer_progress_new();
+ gtk_tree_view_column_pack_start(col, cell, TRUE);
+ gtk_tree_view_column_set_attributes(col, cell, "value",
+ DISK_USED_PERCENTAGE, NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
+ gtk_tree_view_column_set_resizable(col, TRUE);
+ gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
+ gtk_tree_view_column_set_reorderable(col, TRUE);
+
+ /* numeric sort */
+
+ gtk_widget_show_all(disk_box);
+
+ procman_get_tree_state(procdata->settings, disk_tree,
+ "disktreenew");
+
+ g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
+ G_CALLBACK(cb_disk_columns_changed), procdata);
+
+ return disk_box;
}
diff --git a/src/e_date.c b/src/e_date.c
index 9b9a894..bca3165 100644
--- a/src/e_date.c
+++ b/src/e_date.c
@@ -17,27 +17,27 @@
static size_t e_strftime(char *s, size_t max, const char *fmt, const struct tm *tm)
{
#ifdef HAVE_LKSTRFTIME
- return strftime(s, max, fmt, tm);
+ return strftime(s, max, fmt, tm);
#else
- char *c, *ffmt, *ff;
- size_t ret;
-
- ffmt = g_strdup(fmt);
- ff = ffmt;
- while ((c = strstr(ff, "%l")) != NULL) {
- c[1] = 'I';
- ff = c;
- }
-
- ff = ffmt;
- while ((c = strstr(ff, "%k")) != NULL) {
- c[1] = 'H';
- ff = c;
- }
-
- ret = strftime(s, max, ffmt, tm);
- g_free(ffmt);
- return ret;
+ char *c, *ffmt, *ff;
+ size_t ret;
+
+ ffmt = g_strdup(fmt);
+ ff = ffmt;
+ while ((c = strstr(ff, "%l")) != NULL) {
+ c[1] = 'I';
+ ff = c;
+ }
+
+ ff = ffmt;
+ while ((c = strstr(ff, "%k")) != NULL) {
+ c[1] = 'H';
+ ff = c;
+ }
+
+ ret = strftime(s, max, ffmt, tm);
+ g_free(ffmt);
+ return ret;
#endif
}
@@ -62,146 +62,146 @@ static size_t e_strftime(char *s, size_t max, const char *fmt, const struct tm *
static size_t e_strftime_fix_am_pm(char *s, size_t max, const char *fmt, const struct tm *tm)
{
- char buf[10];
- char *sp;
- char *ffmt;
- size_t ret;
-
- if (strstr(fmt, "%p")==NULL && strstr(fmt, "%P")==NULL) {
- /* No AM/PM involved - can use the fmt string directly */
- ret=e_strftime(s, max, fmt, tm);
- } else {
- /* Get the AM/PM symbol from the locale */
- e_strftime (buf, 10, "%p", tm);
-
- if (buf[0]) {
- /**
- * AM/PM have been defined in the locale
- * so we can use the fmt string directly
- **/
- ret=e_strftime(s, max, fmt, tm);
- } else {
- /**
- * No AM/PM defined by locale
- * must change to 24 hour clock
- **/
- ffmt=g_strdup(fmt);
- for (sp=ffmt; (sp=strstr(sp, "%l")); sp++) {
- /**
- * Maybe this should be 'k', but I have never
- * seen a 24 clock actually use that format
- **/
- sp[1]='H';
- }
- for (sp=ffmt; (sp=strstr(sp, "%I")); sp++) {
- sp[1]='H';
- }
- ret=e_strftime(s, max, ffmt, tm);
- g_free(ffmt);
- }
- }
- return(ret);
+ char buf[10];
+ char *sp;
+ char *ffmt;
+ size_t ret;
+
+ if (strstr(fmt, "%p")==NULL && strstr(fmt, "%P")==NULL) {
+ /* No AM/PM involved - can use the fmt string directly */
+ ret=e_strftime(s, max, fmt, tm);
+ } else {
+ /* Get the AM/PM symbol from the locale */
+ e_strftime (buf, 10, "%p", tm);
+
+ if (buf[0]) {
+ /**
+ * AM/PM have been defined in the locale
+ * so we can use the fmt string directly
+ **/
+ ret=e_strftime(s, max, fmt, tm);
+ } else {
+ /**
+ * No AM/PM defined by locale
+ * must change to 24 hour clock
+ **/
+ ffmt=g_strdup(fmt);
+ for (sp=ffmt; (sp=strstr(sp, "%l")); sp++) {
+ /**
+ * Maybe this should be 'k', but I have never
+ * seen a 24 clock actually use that format
+ **/
+ sp[1]='H';
+ }
+ for (sp=ffmt; (sp=strstr(sp, "%I")); sp++) {
+ sp[1]='H';
+ }
+ ret=e_strftime(s, max, ffmt, tm);
+ g_free(ffmt);
+ }
+ }
+ return(ret);
}
-static size_t
+static size_t
e_utf8_strftime_fix_am_pm(char *s, size_t max, const char *fmt, const struct tm *tm)
{
- size_t sz, ret;
- char *locale_fmt, *buf;
-
- locale_fmt = g_locale_from_utf8(fmt, -1, NULL, &sz, NULL);
- if (!locale_fmt)
- return 0;
-
- ret = e_strftime_fix_am_pm(s, max, locale_fmt, tm);
- if (!ret) {
- g_free (locale_fmt);
- return 0;
- }
-
- buf = g_locale_to_utf8(s, ret, NULL, &sz, NULL);
- if (!buf) {
- g_free (locale_fmt);
- return 0;
- }
-
- if (sz >= max) {
- char *tmp = buf + max - 1;
- tmp = g_utf8_find_prev_char(buf, tmp);
- if (tmp)
- sz = tmp - buf;
- else
- sz = 0;
- }
- memcpy(s, buf, sz);
- s[sz] = '\0';
- g_free(locale_fmt);
- g_free(buf);
- return sz;
+ size_t sz, ret;
+ char *locale_fmt, *buf;
+
+ locale_fmt = g_locale_from_utf8(fmt, -1, NULL, &sz, NULL);
+ if (!locale_fmt)
+ return 0;
+
+ ret = e_strftime_fix_am_pm(s, max, locale_fmt, tm);
+ if (!ret) {
+ g_free (locale_fmt);
+ return 0;
+ }
+
+ buf = g_locale_to_utf8(s, ret, NULL, &sz, NULL);
+ if (!buf) {
+ g_free (locale_fmt);
+ return 0;
+ }
+
+ if (sz >= max) {
+ char *tmp = buf + max - 1;
+ tmp = g_utf8_find_prev_char(buf, tmp);
+ if (tmp)
+ sz = tmp - buf;
+ else
+ sz = 0;
+ }
+ memcpy(s, buf, sz);
+ s[sz] = '\0';
+ g_free(locale_fmt);
+ g_free(buf);
+ return sz;
}
static char *
filter_date (time_t date)
{
- time_t nowdate = time(NULL);
- time_t yesdate;
- struct tm then, now, yesterday;
- char buf[26];
- gboolean done = FALSE;
-
- if (date == 0)
- // xgettext: ? stands for unknown
- return g_strdup (_("?"));
-
- localtime_r (&date, &then);
- localtime_r (&nowdate, &now);
- if (then.tm_mday == now.tm_mday &&
- then.tm_mon == now.tm_mon &&
- then.tm_year == now.tm_year) {
- e_utf8_strftime_fix_am_pm (buf, 26, _("Today %l:%M %p"), &then);
- done = TRUE;
- }
- if (!done) {
- yesdate = nowdate - 60 * 60 * 24;
- localtime_r (&yesdate, &yesterday);
- if (then.tm_mday == yesterday.tm_mday &&
- then.tm_mon == yesterday.tm_mon &&
- then.tm_year == yesterday.tm_year) {
- e_utf8_strftime_fix_am_pm (buf, 26, _("Yesterday %l:%M %p"), &then);
- done = TRUE;
- }
- }
- if (!done) {
- int i;
- for (i = 2; i < 7; i++) {
- yesdate = nowdate - 60 * 60 * 24 * i;
- localtime_r (&yesdate, &yesterday);
- if (then.tm_mday == yesterday.tm_mday &&
- then.tm_mon == yesterday.tm_mon &&
- then.tm_year == yesterday.tm_year) {
- e_utf8_strftime_fix_am_pm (buf, 26, _("%a %l:%M %p"), &then);
- done = TRUE;
- break;
- }
- }
- }
- if (!done) {
- if (then.tm_year == now.tm_year) {
- e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %l:%M %p"), &then);
- } else {
- e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %Y"), &then);
- }
- }
+ time_t nowdate = time(NULL);
+ time_t yesdate;
+ struct tm then, now, yesterday;
+ char buf[26];
+ gboolean done = FALSE;
+
+ if (date == 0)
+ // xgettext: ? stands for unknown
+ return g_strdup (_("?"));
+
+ localtime_r (&date, &then);
+ localtime_r (&nowdate, &now);
+ if (then.tm_mday == now.tm_mday &&
+ then.tm_mon == now.tm_mon &&
+ then.tm_year == now.tm_year) {
+ e_utf8_strftime_fix_am_pm (buf, 26, _("Today %l:%M %p"), &then);
+ done = TRUE;
+ }
+ if (!done) {
+ yesdate = nowdate - 60 * 60 * 24;
+ localtime_r (&yesdate, &yesterday);
+ if (then.tm_mday == yesterday.tm_mday &&
+ then.tm_mon == yesterday.tm_mon &&
+ then.tm_year == yesterday.tm_year) {
+ e_utf8_strftime_fix_am_pm (buf, 26, _("Yesterday %l:%M %p"), &then);
+ done = TRUE;
+ }
+ }
+ if (!done) {
+ int i;
+ for (i = 2; i < 7; i++) {
+ yesdate = nowdate - 60 * 60 * 24 * i;
+ localtime_r (&yesdate, &yesterday);
+ if (then.tm_mday == yesterday.tm_mday &&
+ then.tm_mon == yesterday.tm_mon &&
+ then.tm_year == yesterday.tm_year) {
+ e_utf8_strftime_fix_am_pm (buf, 26, _("%a %l:%M %p"), &then);
+ done = TRUE;
+ break;
+ }
+ }
+ }
+ if (!done) {
+ if (then.tm_year == now.tm_year) {
+ e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %l:%M %p"), &then);
+ } else {
+ e_utf8_strftime_fix_am_pm (buf, 26, _("%b %d %Y"), &then);
+ }
+ }
#if 0
#ifdef CTIME_R_THREE_ARGS
- ctime_r (&date, buf, 26);
+ ctime_r (&date, buf, 26);
#else
- ctime_r (&date, buf);
+ ctime_r (&date, buf);
#endif
#endif
- return g_strdup (buf);
+ return g_strdup (buf);
}
@@ -210,5 +210,5 @@ filter_date (time_t date)
char *
procman_format_date_for_display(time_t d)
{
- return filter_date(d);
+ return filter_date(d);
}
diff --git a/src/gsm_color_button.h b/src/gsm_color_button.h
index 35efe70..848f47e 100644
--- a/src/gsm_color_button.h
+++ b/src/gsm_color_button.h
@@ -30,9 +30,9 @@
#include <librsvg/rsvg-cairo.h>
G_BEGIN_DECLS
-/* The GtkColorSelectionButton widget is a simple color picker in a button.
- * The button displays a sample of the currently selected color. When
- * the user clicks on the button, a color selection dialog pops up.
+/* The GtkColorSelectionButton widget is a simple color picker in a button.
+ * The button displays a sample of the currently selected color. When
+ * the user clicks on the button, a color selection dialog pops up.
* The color picker emits the "color_set" signal when the color is set.
*/
#define GSM_TYPE_COLOR_BUTTON (gsm_color_button_get_type ())
@@ -47,34 +47,34 @@ typedef struct _GSMColorButtonPrivate GSMColorButtonPrivate;
struct _GSMColorButton
{
- GtkDrawingArea widget;
+ GtkDrawingArea widget;
- /*< private > */
+ /*< private > */
- GSMColorButtonPrivate *priv;
+ GSMColorButtonPrivate *priv;
};
/* Widget types */
enum
{
- GSMCP_TYPE_CPU,
- GSMCP_TYPE_PIE,
- GSMCP_TYPE_NETWORK_IN,
- GSMCP_TYPE_NETWORK_OUT,
- GSMCP_TYPES
+ GSMCP_TYPE_CPU,
+ GSMCP_TYPE_PIE,
+ GSMCP_TYPE_NETWORK_IN,
+ GSMCP_TYPE_NETWORK_OUT,
+ GSMCP_TYPES
};
struct _GSMColorButtonClass
{
- GtkWidgetClass parent_class;
+ GtkWidgetClass parent_class;
- void (*color_set) (GSMColorButton * cp);
+ void (*color_set) (GSMColorButton * cp);
- /* Padding for future expansion */
- void (*_gtk_reserved1) (void);
- void (*_gtk_reserved2) (void);
- void (*_gtk_reserved3) (void);
- void (*_gtk_reserved4) (void);
+ /* Padding for future expansion */
+ void (*_gtk_reserved1) (void);
+ void (*_gtk_reserved2) (void);
+ void (*_gtk_reserved3) (void);
+ void (*_gtk_reserved4) (void);
};
GType gsm_color_button_get_type (void) G_GNUC_CONST;
diff --git a/src/iconthemewrapper.cpp b/src/iconthemewrapper.cpp
index 496dd45..fb062da 100644
--- a/src/iconthemewrapper.cpp
+++ b/src/iconthemewrapper.cpp
@@ -7,17 +7,17 @@
Glib::RefPtr<Gdk::Pixbuf>
procman::IconThemeWrapper::load_icon(const Glib::ustring& icon_name,
- int size, Gtk::IconLookupFlags flags) const
+ int size, Gtk::IconLookupFlags flags) const
{
- try
+ try
{
- return Gtk::IconTheme::get_default()->load_icon(icon_name, size, flags);
+ return Gtk::IconTheme::get_default()->load_icon(icon_name, size, flags);
}
- catch (Gtk::IconThemeError &error)
+ catch (Gtk::IconThemeError &error)
{
- if (error.code() != Gtk::IconThemeError::ICON_THEME_NOT_FOUND)
- g_error("Cannot load icon '%s' from theme: %s", icon_name.c_str(), error.what().c_str());
- return Glib::RefPtr<Gdk::Pixbuf>();
+ if (error.code() != Gtk::IconThemeError::ICON_THEME_NOT_FOUND)
+ g_error("Cannot load icon '%s' from theme: %s", icon_name.c_str(), error.what().c_str());
+ return Glib::RefPtr<Gdk::Pixbuf>();
}
}
diff --git a/src/iconthemewrapper.h b/src/iconthemewrapper.h
index 6127f01..81fb8d8 100644
--- a/src/iconthemewrapper.h
+++ b/src/iconthemewrapper.h
@@ -8,16 +8,16 @@
namespace procman
{
- class IconThemeWrapper
- {
- public:
- // returns 0 instead of raising an exception
- Glib::RefPtr<Gdk::Pixbuf>
- load_icon(const Glib::ustring& icon_name, int size, Gtk::IconLookupFlags flags) const;
+ class IconThemeWrapper
+ {
+ public:
+ // returns 0 instead of raising an exception
+ Glib::RefPtr<Gdk::Pixbuf>
+ load_icon(const Glib::ustring& icon_name, int size, Gtk::IconLookupFlags flags) const;
- const IconThemeWrapper* operator->() const
- { return this; }
- };
+ const IconThemeWrapper* operator->() const
+ { return this; }
+ };
}
#endif // H_PROCMAN_ICONTHEMEWRAPPER_H_1185707711
diff --git a/src/interface.cpp b/src/interface.cpp
index 9da7b1b..d12baee 100644
--- a/src/interface.cpp
+++ b/src/interface.cpp
@@ -41,535 +41,535 @@
#include "sysinfo.h"
#include "gsm_color_button.h"
-static void cb_toggle_tree (GtkAction *action, gpointer data);
-static void cb_proc_goto_tab (gint tab);
+static void cb_toggle_tree (GtkAction *action, gpointer data);
+static void cb_proc_goto_tab (gint tab);
static const GtkActionEntry menu_entries[] =
{
- // xgettext: noun, top level menu.
- // "File" did not make sense for system-monitor
- { "Monitor", NULL, N_("_Monitor") },
- { "Edit", NULL, N_("_Edit") },
- { "View", NULL, N_("_View") },
- { "Help", NULL, N_("_Help") },
-
- { "Lsof", GTK_STOCK_FIND, N_("Search for _Open Files"), "<control>O",
- N_("Search for open files"), G_CALLBACK(cb_show_lsof) },
- { "Quit", GTK_STOCK_QUIT, NULL, NULL,
- N_("Quit the program"), G_CALLBACK (cb_app_exit) },
-
-
- { "StopProcess", NULL, N_("_Stop Process"), "<control>S",
- N_("Stop process"), G_CALLBACK(cb_kill_sigstop) },
- { "ContProcess", NULL, N_("_Continue Process"), "<control>C",
- N_("Continue process if stopped"), G_CALLBACK(cb_kill_sigcont) },
-
- { "EndProcess", NULL, N_("_End Process"), "<control>E",
- N_("Force process to finish normally"), G_CALLBACK (cb_end_process) },
- { "KillProcess", NULL, N_("_Kill Process"), "<control>K",
- N_("Force process to finish immediately"), G_CALLBACK (cb_kill_process) },
- { "ChangePriority", NULL, N_("_Change Priority..."), "<control>N",
- N_("Change the order of priority of process"), G_CALLBACK (cb_renice) },
- { "Preferences", GTK_STOCK_PREFERENCES, NULL, NULL,
- N_("Configure the application"), G_CALLBACK (cb_edit_preferences) },
-
- { "Refresh", GTK_STOCK_REFRESH, N_("_Refresh"), "<control>R",
- N_("Refresh the process list"), G_CALLBACK(cb_user_refresh) },
-
- { "MemoryMaps", NULL, N_("_Memory Maps"), "<control>M",
- N_("Open the memory maps associated with a process"), G_CALLBACK (cb_show_memory_maps) },
- // Translators: this means 'Files that are open' (open is no verb here)
- { "OpenFiles", NULL, N_("Open _Files"), "<control>F",
- N_("View the files opened by a process"), G_CALLBACK (cb_show_open_files) },
-
- { "HelpContents", GTK_STOCK_HELP, N_("_Contents"), "F1",
- N_("Open the manual"), G_CALLBACK (cb_help_contents) },
- { "About", GTK_STOCK_ABOUT, NULL, NULL,
- N_("About this application"), G_CALLBACK (cb_about) }
+ // xgettext: noun, top level menu.
+ // "File" did not make sense for system-monitor
+ { "Monitor", NULL, N_("_Monitor") },
+ { "Edit", NULL, N_("_Edit") },
+ { "View", NULL, N_("_View") },
+ { "Help", NULL, N_("_Help") },
+
+ { "Lsof", GTK_STOCK_FIND, N_("Search for _Open Files"), "<control>O",
+ N_("Search for open files"), G_CALLBACK(cb_show_lsof) },
+ { "Quit", GTK_STOCK_QUIT, NULL, NULL,
+ N_("Quit the program"), G_CALLBACK (cb_app_exit) },
+
+
+ { "StopProcess", NULL, N_("_Stop Process"), "<control>S",
+ N_("Stop process"), G_CALLBACK(cb_kill_sigstop) },
+ { "ContProcess", NULL, N_("_Continue Process"), "<control>C",
+ N_("Continue process if stopped"), G_CALLBACK(cb_kill_sigcont) },
+
+ { "EndProcess", NULL, N_("_End Process"), "<control>E",
+ N_("Force process to finish normally"), G_CALLBACK (cb_end_process) },
+ { "KillProcess", NULL, N_("_Kill Process"), "<control>K",
+ N_("Force process to finish immediately"), G_CALLBACK (cb_kill_process) },
+ { "ChangePriority", NULL, N_("_Change Priority..."), "<control>N",
+ N_("Change the order of priority of process"), G_CALLBACK (cb_renice) },
+ { "Preferences", GTK_STOCK_PREFERENCES, NULL, NULL,
+ N_("Configure the application"), G_CALLBACK (cb_edit_preferences) },
+
+ { "Refresh", GTK_STOCK_REFRESH, N_("_Refresh"), "<control>R",
+ N_("Refresh the process list"), G_CALLBACK(cb_user_refresh) },
+
+ { "MemoryMaps", NULL, N_("_Memory Maps"), "<control>M",
+ N_("Open the memory maps associated with a process"), G_CALLBACK (cb_show_memory_maps) },
+ // Translators: this means 'Files that are open' (open is no verb here)
+ { "OpenFiles", NULL, N_("Open _Files"), "<control>F",
+ N_("View the files opened by a process"), G_CALLBACK (cb_show_open_files) },
+
+ { "HelpContents", GTK_STOCK_HELP, N_("_Contents"), "F1",
+ N_("Open the manual"), G_CALLBACK (cb_help_contents) },
+ { "About", GTK_STOCK_ABOUT, NULL, NULL,
+ N_("About this application"), G_CALLBACK (cb_about) }
};
static const GtkToggleActionEntry toggle_menu_entries[] =
{
- { "ShowDependencies", NULL, N_("_Dependencies"), "<control>D",
- N_("Show parent/child relationship between processes"),
- G_CALLBACK (cb_toggle_tree), TRUE },
+ { "ShowDependencies", NULL, N_("_Dependencies"), "<control>D",
+ N_("Show parent/child relationship between processes"),
+ G_CALLBACK (cb_toggle_tree), TRUE },
};
static const GtkRadioActionEntry radio_menu_entries[] =
{
- { "ShowActiveProcesses", NULL, N_("_Active Processes"), NULL,
- N_("Show active processes"), ACTIVE_PROCESSES },
- { "ShowAllProcesses", NULL, N_("A_ll Processes"), NULL,
- N_("Show all processes"), ALL_PROCESSES },
- { "ShowMyProcesses", NULL, N_("M_y Processes"), NULL,
- N_("Show only user-owned processes"), MY_PROCESSES }
+ { "ShowActiveProcesses", NULL, N_("_Active Processes"), NULL,
+ N_("Show active processes"), ACTIVE_PROCESSES },
+ { "ShowAllProcesses", NULL, N_("A_ll Processes"), NULL,
+ N_("Show all processes"), ALL_PROCESSES },
+ { "ShowMyProcesses", NULL, N_("M_y Processes"), NULL,
+ N_("Show only user-owned processes"), MY_PROCESSES }
};
static const char ui_info[] =
-" <menubar name=\"MenuBar\">"
-" <menu name=\"MonitorMenu\" action=\"Monitor\">"
-" <menuitem name=\"MonitorLsofMenu\" action=\"Lsof\" />"
-" <menuitem name=\"MonitorQuitMenu\" action=\"Quit\" />"
-" </menu>"
-" <menu name=\"EditMenu\" action=\"Edit\">"
-" <menuitem name=\"EditStopProcessMenu\" action=\"StopProcess\" />"
-" <menuitem name=\"EditContProcessMenu\" action=\"ContProcess\" />"
-" <separator />"
-" <menuitem name=\"EditEndProcessMenu\" action=\"EndProcess\" />"
-" <menuitem name=\"EditKillProcessMenu\" action=\"KillProcess\" />"
-" <separator />"
-" <menuitem name=\"EditChangePriorityMenu\" action=\"ChangePriority\" />"
-" <separator />"
-" <menuitem name=\"EditPreferencesMenu\" action=\"Preferences\" />"
-" </menu>"
-" <menu name=\"ViewMenu\" action=\"View\">"
-" <menuitem name=\"ViewActiveProcesses\" action=\"ShowActiveProcesses\" />"
-" <menuitem name=\"ViewAllProcesses\" action=\"ShowAllProcesses\" />"
-" <menuitem name=\"ViewMyProcesses\" action=\"ShowMyProcesses\" />"
-" <separator />"
-" <menuitem name=\"ViewDependenciesMenu\" action=\"ShowDependencies\" />"
-" <separator />"
-" <menuitem name=\"ViewMemoryMapsMenu\" action=\"MemoryMaps\" />"
-" <menuitem name=\"ViewOpenFilesMenu\" action=\"OpenFiles\" />"
-" <separator />"
-" <menuitem name=\"ViewRefresh\" action=\"Refresh\" />"
-" </menu>"
-" <menu name=\"HelpMenu\" action=\"Help\">"
-" <menuitem name=\"HelpContentsMenu\" action=\"HelpContents\" />"
-" <menuitem name=\"HelpAboutMenu\" action=\"About\" />"
-" </menu>"
-" </menubar>"
-" <popup name=\"PopupMenu\" action=\"Popup\">"
-" <menuitem action=\"StopProcess\" />"
-" <menuitem action=\"ContProcess\" />"
-" <separator />"
-" <menuitem action=\"EndProcess\" />"
-" <menuitem action=\"KillProcess\" />"
-" <separator />"
-" <menuitem action=\"ChangePriority\" />"
-" <separator />"
-" <menuitem action=\"MemoryMaps\" />"
-" <menuitem action=\"OpenFiles\" />"
-" </popup>";
+ " <menubar name=\"MenuBar\">"
+ " <menu name=\"MonitorMenu\" action=\"Monitor\">"
+ " <menuitem name=\"MonitorLsofMenu\" action=\"Lsof\" />"
+ " <menuitem name=\"MonitorQuitMenu\" action=\"Quit\" />"
+ " </menu>"
+ " <menu name=\"EditMenu\" action=\"Edit\">"
+ " <menuitem name=\"EditStopProcessMenu\" action=\"StopProcess\" />"
+ " <menuitem name=\"EditContProcessMenu\" action=\"ContProcess\" />"
+ " <separator />"
+ " <menuitem name=\"EditEndProcessMenu\" action=\"EndProcess\" />"
+ " <menuitem name=\"EditKillProcessMenu\" action=\"KillProcess\" />"
+ " <separator />"
+ " <menuitem name=\"EditChangePriorityMenu\" action=\"ChangePriority\" />"
+ " <separator />"
+ " <menuitem name=\"EditPreferencesMenu\" action=\"Preferences\" />"
+ " </menu>"
+ " <menu name=\"ViewMenu\" action=\"View\">"
+ " <menuitem name=\"ViewActiveProcesses\" action=\"ShowActiveProcesses\" />"
+ " <menuitem name=\"ViewAllProcesses\" action=\"ShowAllProcesses\" />"
+ " <menuitem name=\"ViewMyProcesses\" action=\"ShowMyProcesses\" />"
+ " <separator />"
+ " <menuitem name=\"ViewDependenciesMenu\" action=\"ShowDependencies\" />"
+ " <separator />"
+ " <menuitem name=\"ViewMemoryMapsMenu\" action=\"MemoryMaps\" />"
+ " <menuitem name=\"ViewOpenFilesMenu\" action=\"OpenFiles\" />"
+ " <separator />"
+ " <menuitem name=\"ViewRefresh\" action=\"Refresh\" />"
+ " </menu>"
+ " <menu name=\"HelpMenu\" action=\"Help\">"
+ " <menuitem name=\"HelpContentsMenu\" action=\"HelpContents\" />"
+ " <menuitem name=\"HelpAboutMenu\" action=\"About\" />"
+ " </menu>"
+ " </menubar>"
+ " <popup name=\"PopupMenu\" action=\"Popup\">"
+ " <menuitem action=\"StopProcess\" />"
+ " <menuitem action=\"ContProcess\" />"
+ " <separator />"
+ " <menuitem action=\"EndProcess\" />"
+ " <menuitem action=\"KillProcess\" />"
+ " <separator />"
+ " <menuitem action=\"ChangePriority\" />"
+ " <separator />"
+ " <menuitem action=\"MemoryMaps\" />"
+ " <menuitem action=\"OpenFiles\" />"
+ " </popup>";
static GtkWidget *
create_proc_view (ProcData *procdata)
{
- GtkWidget *vbox1;
- GtkWidget *hbox1;
- GtkWidget *scrolled;
- GtkWidget *hbox2;
- char* string;
-
- vbox1 = gtk_vbox_new (FALSE, 18);
- gtk_container_set_border_width (GTK_CONTAINER (vbox1), 12);
-
- hbox1 = gtk_hbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
-
- string = make_loadavg_string ();
- procdata->loadavg = gtk_label_new (string);
- g_free (string);
- gtk_box_pack_start (GTK_BOX (hbox1), procdata->loadavg, FALSE, FALSE, 0);
-
-
- scrolled = proctable_new (procdata);
- if (!scrolled)
- return NULL;
- gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
- GTK_SHADOW_IN);
-
- gtk_box_pack_start (GTK_BOX (vbox1), scrolled, TRUE, TRUE, 0);
-
-
- hbox2 = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 0);
-
- procdata->endprocessbutton = gtk_button_new_with_mnemonic (_("End _Process"));
- gtk_box_pack_end (GTK_BOX (hbox2), procdata->endprocessbutton, FALSE, FALSE, 0);
- g_signal_connect (G_OBJECT (procdata->endprocessbutton), "clicked",
- G_CALLBACK (cb_end_process_button_pressed), procdata);
-
-
- /* create popup_menu */
- procdata->popup_menu = gtk_ui_manager_get_widget (procdata->uimanager, "/PopupMenu");
-
- return vbox1;
+ GtkWidget *vbox1;
+ GtkWidget *hbox1;
+ GtkWidget *scrolled;
+ GtkWidget *hbox2;
+ char* string;
+
+ vbox1 = gtk_vbox_new (FALSE, 18);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox1), 12);
+
+ hbox1 = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 0);
+
+ string = make_loadavg_string ();
+ procdata->loadavg = gtk_label_new (string);
+ g_free (string);
+ gtk_box_pack_start (GTK_BOX (hbox1), procdata->loadavg, FALSE, FALSE, 0);
+
+
+ scrolled = proctable_new (procdata);
+ if (!scrolled)
+ return NULL;
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+ GTK_SHADOW_IN);
+
+ gtk_box_pack_start (GTK_BOX (vbox1), scrolled, TRUE, TRUE, 0);
+
+
+ hbox2 = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 0);
+
+ procdata->endprocessbutton = gtk_button_new_with_mnemonic (_("End _Process"));
+ gtk_box_pack_end (GTK_BOX (hbox2), procdata->endprocessbutton, FALSE, FALSE, 0);
+ g_signal_connect (G_OBJECT (procdata->endprocessbutton), "clicked",
+ G_CALLBACK (cb_end_process_button_pressed), procdata);
+
+
+ /* create popup_menu */
+ procdata->popup_menu = gtk_ui_manager_get_widget (procdata->uimanager, "/PopupMenu");
+
+ return vbox1;
}
GtkWidget *
make_title_label (const char *text)
{
- GtkWidget *label;
- char *full;
+ GtkWidget *label;
+ char *full;
- full = g_strdup_printf ("<span weight=\"bold\">%s</span>", text);
- label = gtk_label_new (full);
- g_free (full);
+ full = g_strdup_printf ("<span weight=\"bold\">%s</span>", text);
+ label = gtk_label_new (full);
+ g_free (full);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
- gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
- return label;
+ return label;
}
static GtkWidget *
create_sys_view (ProcData *procdata)
{
- GtkWidget *vbox, *hbox;
- GtkWidget *cpu_box, *mem_box, *net_box;
- GtkWidget *cpu_graph_box, *mem_graph_box, *net_graph_box;
- GtkWidget *label,*cpu_label, *spacer;
- GtkWidget *table;
- GtkWidget *color_picker;
- GtkWidget *mem_legend_box, *net_legend_box;
- LoadGraph *cpu_graph, *mem_graph, *net_graph;
- gint i;
-
-
- vbox = gtk_vbox_new (FALSE, 18);
-
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
-
- /* The CPU BOX */
-
- cpu_box = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (vbox), cpu_box, TRUE, TRUE, 0);
-
- label = make_title_label (_("CPU History"));
- gtk_box_pack_start (GTK_BOX (cpu_box), label, FALSE, FALSE, 0);
-
- cpu_graph_box = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (cpu_box), cpu_graph_box, TRUE, TRUE, 0);
-
- cpu_graph = new LoadGraph(LOAD_GRAPH_CPU);
- gtk_box_pack_start (GTK_BOX (cpu_graph_box),
- load_graph_get_widget(cpu_graph),
- TRUE,
- TRUE,
- 0);
-
- hbox = gtk_hbox_new(FALSE, 0);
- spacer = gtk_label_new ("");
- gtk_widget_set_size_request(GTK_WIDGET(spacer), 57, -1);
- gtk_box_pack_start (GTK_BOX (hbox), spacer,
- FALSE, FALSE, 0);
-
-
- gtk_box_pack_start (GTK_BOX (cpu_graph_box), hbox,
- FALSE, FALSE, 0);
-
- /*cpu_legend_box = gtk_hbox_new(TRUE, 10);
- gtk_box_pack_start (GTK_BOX (hbox), cpu_legend_box,
- TRUE, TRUE, 0);*/
-
- GtkWidget* cpu_table = gtk_table_new(std::min(procdata->config.num_cpus / 4, 1),
- std::min(procdata->config.num_cpus, 4),
- TRUE);
- gtk_table_set_row_spacings(GTK_TABLE(cpu_table), 6);
- gtk_table_set_col_spacings(GTK_TABLE(cpu_table), 6);
- gtk_box_pack_start(GTK_BOX(hbox), cpu_table, TRUE, TRUE, 0);
-
- for (i=0;i<procdata->config.num_cpus; i++) {
- GtkWidget *temp_hbox;
- gchar *text;
-
- temp_hbox = gtk_hbox_new (FALSE, 0);
- gtk_table_attach(GTK_TABLE(cpu_table), temp_hbox,
- i % 4, i % 4 + 1,
- i / 4, i / 4 + 1,
- static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL),
- static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL),
- 0, 0);
- //gtk_size_group_add_widget (sizegroup, temp_hbox);
- /*g_signal_connect (G_OBJECT (temp_hbox), "size_request",
- G_CALLBACK(size_request), &cpu_size);
-*/
- color_picker = gsm_color_button_new (&cpu_graph->colors.at(i), GSMCP_TYPE_CPU);
- g_signal_connect (G_OBJECT (color_picker), "color_set",
- G_CALLBACK (cb_cpu_color_changed), GINT_TO_POINTER (i));
- gtk_box_pack_start (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) {
- text = g_strdup (_("CPU"));
- } else {
- text = g_strdup_printf (_("CPU%d"), i+1);
- }
- label = gtk_label_new (text);
- gtk_box_pack_start (GTK_BOX (temp_hbox), label, FALSE, FALSE, 6);
- g_free (text);
-
- cpu_label = gtk_label_new (NULL);
- gtk_misc_set_alignment (GTK_MISC (cpu_label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (temp_hbox), cpu_label, TRUE, TRUE, 0);
- load_graph_get_labels(cpu_graph)->cpu[i] = cpu_label;
-
- }
-
- procdata->cpu_graph = cpu_graph;
-
- mem_box = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (vbox), mem_box, TRUE, TRUE, 0);
-
- label = make_title_label (_("Memory and Swap History"));
- gtk_box_pack_start (GTK_BOX (mem_box), label, FALSE, FALSE, 0);
-
- mem_graph_box = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (mem_box), mem_graph_box, TRUE, TRUE, 0);
-
-
- mem_graph = new LoadGraph(LOAD_GRAPH_MEM);
- gtk_box_pack_start (GTK_BOX (mem_graph_box),
- load_graph_get_widget(mem_graph),
- TRUE,
- TRUE,
- 0);
-
- hbox = gtk_hbox_new(FALSE, 0);
- spacer = gtk_label_new ("");
- gtk_widget_set_size_request(GTK_WIDGET(spacer), 54, -1);
- gtk_box_pack_start (GTK_BOX (hbox), spacer,
- FALSE, FALSE, 0);
-
-
- gtk_box_pack_start (GTK_BOX (mem_graph_box), hbox,
- FALSE, FALSE, 0);
-
- mem_legend_box = gtk_hbox_new(TRUE, 10);
- gtk_box_pack_start (GTK_BOX (hbox), mem_legend_box,
- TRUE, TRUE, 0);
-
- table = gtk_table_new (2, 7, FALSE);
- gtk_table_set_row_spacings (GTK_TABLE (table), 6);
- gtk_table_set_col_spacings (GTK_TABLE (table), 6);
- gtk_box_pack_start (GTK_BOX (mem_legend_box), table,
- TRUE, TRUE, 0);
-
- 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);
- gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
-
- label = gtk_label_new (_("Memory"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_table_attach (GTK_TABLE (table), label, 1, 7, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
-
- gtk_table_attach (GTK_TABLE (table),
- load_graph_get_labels(mem_graph)->memory,
- 1,
- 2,
- 1,
- 2,
- GTK_FILL,
- GTK_FILL,
- 0,
- 0);
-
- table = gtk_table_new (2, 7, FALSE);
- gtk_table_set_row_spacings (GTK_TABLE (table), 6);
- gtk_table_set_col_spacings (GTK_TABLE (table), 6);
- gtk_box_pack_start (GTK_BOX (mem_legend_box), table,
- TRUE, TRUE, 0);
-
- 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);
- gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
-
- label = gtk_label_new (_("Swap"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_table_attach (GTK_TABLE (table), label, 1, 7, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
-
- gtk_table_attach (GTK_TABLE (table),
- load_graph_get_labels(mem_graph)->swap,
- 1,
- 2,
- 1,
- 2,
- GTK_FILL,
- GTK_FILL,
- 0,
- 0);
-
- procdata->mem_graph = mem_graph;
-
- /* The net box */
- net_box = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (vbox), net_box, TRUE, TRUE, 0);
-
- label = make_title_label (_("Network History"));
- gtk_box_pack_start (GTK_BOX (net_box), label, FALSE, FALSE, 0);
-
- net_graph_box = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (net_box), net_graph_box, TRUE, TRUE, 0);
-
- net_graph = new LoadGraph(LOAD_GRAPH_NET);
- gtk_box_pack_start (GTK_BOX (net_graph_box),
- load_graph_get_widget(net_graph),
- TRUE,
- TRUE,
- 0);
-
- hbox = gtk_hbox_new(FALSE, 0);
- spacer = gtk_label_new ("");
- gtk_widget_set_size_request(GTK_WIDGET(spacer), 54, -1);
- gtk_box_pack_start (GTK_BOX (hbox), spacer,
- FALSE, FALSE, 0);
-
-
- gtk_box_pack_start (GTK_BOX (net_graph_box), hbox,
- FALSE, FALSE, 0);
-
- net_legend_box = gtk_hbox_new(TRUE, 10);
- gtk_box_pack_start (GTK_BOX (hbox), net_legend_box,
- TRUE, TRUE, 0);
-
- table = gtk_table_new (2, 4, FALSE);
- gtk_table_set_row_spacings (GTK_TABLE (table), 6);
- gtk_table_set_col_spacings (GTK_TABLE (table), 6);
- gtk_box_pack_start (GTK_BOX (net_legend_box), table,
- TRUE, TRUE, 0);
-
- 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);
- gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
-
- label = gtk_label_new (_("Receiving"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
-
- gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_in),
- 1.0,
- 0.5);
+ GtkWidget *vbox, *hbox;
+ GtkWidget *cpu_box, *mem_box, *net_box;
+ GtkWidget *cpu_graph_box, *mem_graph_box, *net_graph_box;
+ GtkWidget *label,*cpu_label, *spacer;
+ GtkWidget *table;
+ GtkWidget *color_picker;
+ GtkWidget *mem_legend_box, *net_legend_box;
+ LoadGraph *cpu_graph, *mem_graph, *net_graph;
+ gint i;
+
+
+ vbox = gtk_vbox_new (FALSE, 18);
+
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
+
+ /* The CPU BOX */
+
+ cpu_box = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), cpu_box, TRUE, TRUE, 0);
+
+ label = make_title_label (_("CPU History"));
+ gtk_box_pack_start (GTK_BOX (cpu_box), label, FALSE, FALSE, 0);
+
+ cpu_graph_box = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (cpu_box), cpu_graph_box, TRUE, TRUE, 0);
+
+ cpu_graph = new LoadGraph(LOAD_GRAPH_CPU);
+ gtk_box_pack_start (GTK_BOX (cpu_graph_box),
+ load_graph_get_widget(cpu_graph),
+ TRUE,
+ TRUE,
+ 0);
+
+ hbox = gtk_hbox_new(FALSE, 0);
+ spacer = gtk_label_new ("");
+ gtk_widget_set_size_request(GTK_WIDGET(spacer), 57, -1);
+ gtk_box_pack_start (GTK_BOX (hbox), spacer,
+ FALSE, FALSE, 0);
+
+
+ gtk_box_pack_start (GTK_BOX (cpu_graph_box), hbox,
+ FALSE, FALSE, 0);
+
+ /*cpu_legend_box = gtk_hbox_new(TRUE, 10);
+ gtk_box_pack_start (GTK_BOX (hbox), cpu_legend_box,
+ TRUE, TRUE, 0);*/
+
+ GtkWidget* cpu_table = gtk_table_new(std::min(procdata->config.num_cpus / 4, 1),
+ std::min(procdata->config.num_cpus, 4),
+ TRUE);
+ gtk_table_set_row_spacings(GTK_TABLE(cpu_table), 6);
+ gtk_table_set_col_spacings(GTK_TABLE(cpu_table), 6);
+ gtk_box_pack_start(GTK_BOX(hbox), cpu_table, TRUE, TRUE, 0);
+
+ for (i=0;i<procdata->config.num_cpus; i++) {
+ GtkWidget *temp_hbox;
+ gchar *text;
+
+ temp_hbox = gtk_hbox_new (FALSE, 0);
+ gtk_table_attach(GTK_TABLE(cpu_table), temp_hbox,
+ i % 4, i % 4 + 1,
+ i / 4, i / 4 + 1,
+ static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL),
+ static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL),
+ 0, 0);
+ //gtk_size_group_add_widget (sizegroup, temp_hbox);
+ /*g_signal_connect (G_OBJECT (temp_hbox), "size_request",
+ G_CALLBACK(size_request), &cpu_size);
+ */
+ color_picker = gsm_color_button_new (&cpu_graph->colors.at(i), GSMCP_TYPE_CPU);
+ g_signal_connect (G_OBJECT (color_picker), "color_set",
+ G_CALLBACK (cb_cpu_color_changed), GINT_TO_POINTER (i));
+ gtk_box_pack_start (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) {
+ text = g_strdup (_("CPU"));
+ } else {
+ text = g_strdup_printf (_("CPU%d"), i+1);
+ }
+ label = gtk_label_new (text);
+ gtk_box_pack_start (GTK_BOX (temp_hbox), label, FALSE, FALSE, 6);
+ g_free (text);
+
+ cpu_label = gtk_label_new (NULL);
+ gtk_misc_set_alignment (GTK_MISC (cpu_label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (temp_hbox), cpu_label, TRUE, TRUE, 0);
+ load_graph_get_labels(cpu_graph)->cpu[i] = cpu_label;
+
+ }
+
+ procdata->cpu_graph = cpu_graph;
+
+ mem_box = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), mem_box, TRUE, TRUE, 0);
+
+ label = make_title_label (_("Memory and Swap History"));
+ gtk_box_pack_start (GTK_BOX (mem_box), label, FALSE, FALSE, 0);
+
+ mem_graph_box = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (mem_box), mem_graph_box, TRUE, TRUE, 0);
+
+
+ mem_graph = new LoadGraph(LOAD_GRAPH_MEM);
+ gtk_box_pack_start (GTK_BOX (mem_graph_box),
+ load_graph_get_widget(mem_graph),
+ TRUE,
+ TRUE,
+ 0);
+
+ hbox = gtk_hbox_new(FALSE, 0);
+ spacer = gtk_label_new ("");
+ gtk_widget_set_size_request(GTK_WIDGET(spacer), 54, -1);
+ gtk_box_pack_start (GTK_BOX (hbox), spacer,
+ FALSE, FALSE, 0);
+
+
+ gtk_box_pack_start (GTK_BOX (mem_graph_box), hbox,
+ FALSE, FALSE, 0);
+
+ mem_legend_box = gtk_hbox_new(TRUE, 10);
+ gtk_box_pack_start (GTK_BOX (hbox), mem_legend_box,
+ TRUE, TRUE, 0);
+
+ table = gtk_table_new (2, 7, FALSE);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_box_pack_start (GTK_BOX (mem_legend_box), table,
+ TRUE, TRUE, 0);
+
+ 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);
+ gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
+
+ label = gtk_label_new (_("Memory"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), label, 1, 7, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+
+ gtk_table_attach (GTK_TABLE (table),
+ load_graph_get_labels(mem_graph)->memory,
+ 1,
+ 2,
+ 1,
+ 2,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ table = gtk_table_new (2, 7, FALSE);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_box_pack_start (GTK_BOX (mem_legend_box), table,
+ TRUE, TRUE, 0);
+
+ 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);
+ gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
+
+ label = gtk_label_new (_("Swap"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), label, 1, 7, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+
+ gtk_table_attach (GTK_TABLE (table),
+ load_graph_get_labels(mem_graph)->swap,
+ 1,
+ 2,
+ 1,
+ 2,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ procdata->mem_graph = mem_graph;
+
+ /* The net box */
+ net_box = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), net_box, TRUE, TRUE, 0);
+
+ label = make_title_label (_("Network History"));
+ gtk_box_pack_start (GTK_BOX (net_box), label, FALSE, FALSE, 0);
+
+ net_graph_box = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (net_box), net_graph_box, TRUE, TRUE, 0);
+
+ net_graph = new LoadGraph(LOAD_GRAPH_NET);
+ gtk_box_pack_start (GTK_BOX (net_graph_box),
+ load_graph_get_widget(net_graph),
+ TRUE,
+ TRUE,
+ 0);
+
+ hbox = gtk_hbox_new(FALSE, 0);
+ spacer = gtk_label_new ("");
+ gtk_widget_set_size_request(GTK_WIDGET(spacer), 54, -1);
+ gtk_box_pack_start (GTK_BOX (hbox), spacer,
+ FALSE, FALSE, 0);
+
+
+ gtk_box_pack_start (GTK_BOX (net_graph_box), hbox,
+ FALSE, FALSE, 0);
+
+ net_legend_box = gtk_hbox_new(TRUE, 10);
+ gtk_box_pack_start (GTK_BOX (hbox), net_legend_box,
+ TRUE, TRUE, 0);
+
+ table = gtk_table_new (2, 4, FALSE);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_box_pack_start (GTK_BOX (net_legend_box), table,
+ TRUE, TRUE, 0);
+
+ 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);
+ gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
+
+ label = gtk_label_new (_("Receiving"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+
+ gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_in),
+ 1.0,
+ 0.5);
/*
- hbox = gtk_hbox_new (FALSE, 0);
- g_signal_connect (G_OBJECT (hbox), "size_request",
- G_CALLBACK(size_request), &net_size);
- gtk_box_pack_start (GTK_BOX (hbox),
- load_graph_get_labels(net_graph)->net_in,
- TRUE,
- TRUE,
- 0);
+ hbox = gtk_hbox_new (FALSE, 0);
+ g_signal_connect (G_OBJECT (hbox), "size_request",
+ G_CALLBACK(size_request), &net_size);
+ gtk_box_pack_start (GTK_BOX (hbox),
+ load_graph_get_labels(net_graph)->net_in,
+ TRUE,
+ TRUE,
+ 0);
*/
- gtk_widget_set_size_request(GTK_WIDGET(load_graph_get_labels(net_graph)->net_in), 100, -1);
- gtk_table_attach (GTK_TABLE (table), load_graph_get_labels(net_graph)->net_in, 2, 3, 0, 1,
- static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
-
- label = gtk_label_new (_("Total Received"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_table_attach (GTK_TABLE (table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
-
- gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_in_total),
- 1.0,
- 0.5);
- gtk_table_attach (GTK_TABLE (table),
- load_graph_get_labels(net_graph)->net_in_total,
- 2,
- 3,
- 1,
- 2,
- GTK_FILL,
- GTK_FILL,
- 0,
- 0);
-
- spacer = gtk_label_new ("");
- gtk_widget_set_size_request(GTK_WIDGET(spacer), 38, -1);
- gtk_table_attach (GTK_TABLE (table), spacer, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
-
- table = gtk_table_new (2, 3, FALSE);
- gtk_table_set_row_spacings (GTK_TABLE (table), 6);
- gtk_table_set_col_spacings (GTK_TABLE (table), 6);
- gtk_box_pack_start (GTK_BOX (net_legend_box), table,
- TRUE, TRUE, 0);
-
- 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);
- gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
-
- label = gtk_label_new (_("Sending"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
-
- gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_out),
- 1.0,
- 0.5);
+ gtk_widget_set_size_request(GTK_WIDGET(load_graph_get_labels(net_graph)->net_in), 100, -1);
+ gtk_table_attach (GTK_TABLE (table), load_graph_get_labels(net_graph)->net_in, 2, 3, 0, 1,
+ static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
+
+ label = gtk_label_new (_("Total Received"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
+
+ gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_in_total),
+ 1.0,
+ 0.5);
+ gtk_table_attach (GTK_TABLE (table),
+ load_graph_get_labels(net_graph)->net_in_total,
+ 2,
+ 3,
+ 1,
+ 2,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ spacer = gtk_label_new ("");
+ gtk_widget_set_size_request(GTK_WIDGET(spacer), 38, -1);
+ gtk_table_attach (GTK_TABLE (table), spacer, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+
+ table = gtk_table_new (2, 3, FALSE);
+ gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+ gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+ gtk_box_pack_start (GTK_BOX (net_legend_box), table,
+ TRUE, TRUE, 0);
+
+ 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);
+ gtk_table_attach (GTK_TABLE (table), color_picker, 0, 1, 0, 2, GTK_SHRINK, GTK_SHRINK, 0, 0);
+
+ label = gtk_label_new (_("Sending"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+
+ gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_out),
+ 1.0,
+ 0.5);
/*
- hbox = gtk_hbox_new (FALSE, 0);
- g_signal_connect (G_OBJECT (load_graph_get_labels(net_graph)->net_out), "size_request",
- G_CALLBACK(size_request), &net_size);
-
- gtk_box_pack_start (GTK_BOX (hbox),
- load_graph_get_labels(net_graph)->net_out,
- TRUE,
- TRUE,
- 0);
+ hbox = gtk_hbox_new (FALSE, 0);
+ g_signal_connect (G_OBJECT (load_graph_get_labels(net_graph)->net_out), "size_request",
+ G_CALLBACK(size_request), &net_size);
+
+ gtk_box_pack_start (GTK_BOX (hbox),
+ load_graph_get_labels(net_graph)->net_out,
+ TRUE,
+ TRUE,
+ 0);
*/
- gtk_widget_set_size_request(GTK_WIDGET(load_graph_get_labels(net_graph)->net_out), 100, -1);
- gtk_table_attach (GTK_TABLE (table), load_graph_get_labels(net_graph)->net_out, 2, 3, 0, 1,
- static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
-
- label = gtk_label_new (_("Total Sent"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_table_attach (GTK_TABLE (table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
-
- gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_out_total),
- 1.0,
- 0.5);
- gtk_table_attach (GTK_TABLE (table),
- load_graph_get_labels(net_graph)->net_out_total,
- 2,
- 3,
- 1,
- 2,
- GTK_FILL,
- GTK_FILL,
- 0,
- 0);
-
- spacer = gtk_label_new ("");
- gtk_widget_set_size_request(GTK_WIDGET(spacer), 38, -1);
- gtk_table_attach (GTK_TABLE (table), spacer, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
-
- procdata->net_graph = net_graph;
-
- return vbox;
+ gtk_widget_set_size_request(GTK_WIDGET(load_graph_get_labels(net_graph)->net_out), 100, -1);
+ gtk_table_attach (GTK_TABLE (table), load_graph_get_labels(net_graph)->net_out, 2, 3, 0, 1,
+ static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
+
+ label = gtk_label_new (_("Total Sent"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_table_attach (GTK_TABLE (table), label, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
+
+ gtk_misc_set_alignment (GTK_MISC (load_graph_get_labels(net_graph)->net_out_total),
+ 1.0,
+ 0.5);
+ gtk_table_attach (GTK_TABLE (table),
+ load_graph_get_labels(net_graph)->net_out_total,
+ 2,
+ 3,
+ 1,
+ 2,
+ GTK_FILL,
+ GTK_FILL,
+ 0,
+ 0);
+
+ spacer = gtk_label_new ("");
+ gtk_widget_set_size_request(GTK_WIDGET(spacer), 38, -1);
+ gtk_table_attach (GTK_TABLE (table), spacer, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
+
+ procdata->net_graph = net_graph;
+
+ return vbox;
}
static void
menu_item_select_cb (GtkMenuItem *proxy,
ProcData *procdata)
{
- GtkAction *action;
- char *message;
-
- action = gtk_activatable_get_related_action (GTK_ACTIVATABLE(proxy));
- g_assert(action);
-
- g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
- if (message)
- {
- gtk_statusbar_push (GTK_STATUSBAR (procdata->statusbar),
- procdata->tip_message_cid, message);
- g_free (message);
- }
+ GtkAction *action;
+ char *message;
+
+ action = gtk_activatable_get_related_action (GTK_ACTIVATABLE(proxy));
+ g_assert(action);
+
+ g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
+ if (message)
+ {
+ gtk_statusbar_push (GTK_STATUSBAR (procdata->statusbar),
+ procdata->tip_message_cid, message);
+ g_free (message);
+ }
}
static void
menu_item_deselect_cb (GtkMenuItem *proxy,
ProcData *procdata)
{
- gtk_statusbar_pop (GTK_STATUSBAR (procdata->statusbar),
- procdata->tip_message_cid);
+ gtk_statusbar_pop (GTK_STATUSBAR (procdata->statusbar),
+ procdata->tip_message_cid);
}
static void
@@ -578,12 +578,12 @@ connect_proxy_cb (GtkUIManager *manager,
GtkWidget *proxy,
ProcData *procdata)
{
- if (GTK_IS_MENU_ITEM (proxy)) {
- g_signal_connect (proxy, "select",
- G_CALLBACK (menu_item_select_cb), procdata);
- g_signal_connect (proxy, "deselect",
- G_CALLBACK (menu_item_deselect_cb), procdata);
- }
+ if (GTK_IS_MENU_ITEM (proxy)) {
+ g_signal_connect (proxy, "select",
+ G_CALLBACK (menu_item_select_cb), procdata);
+ g_signal_connect (proxy, "deselect",
+ G_CALLBACK (menu_item_deselect_cb), procdata);
+ }
}
static void
@@ -592,234 +592,234 @@ disconnect_proxy_cb (GtkUIManager *manager,
GtkWidget *proxy,
ProcData *procdata)
{
- if (GTK_IS_MENU_ITEM (proxy)) {
- g_signal_handlers_disconnect_by_func
- (proxy, (void*)(G_CALLBACK(menu_item_select_cb)), procdata);
- g_signal_handlers_disconnect_by_func
- (proxy, (void*)(G_CALLBACK(menu_item_deselect_cb)), procdata);
- }
+ if (GTK_IS_MENU_ITEM (proxy)) {
+ g_signal_handlers_disconnect_by_func
+ (proxy, (void*)(G_CALLBACK(menu_item_select_cb)), procdata);
+ g_signal_handlers_disconnect_by_func
+ (proxy, (void*)(G_CALLBACK(menu_item_deselect_cb)), procdata);
+ }
}
void
create_main_window (ProcData *procdata)
{
- gint i;
- gint width, height;
- GtkWidget *app;
- GtkAction *action;
- GtkWidget *menubar;
- GtkWidget *main_box;
- GtkWidget *notebook;
- GtkWidget *tab_label1, *tab_label2, *tab_label3;
- GtkWidget *vbox1;
- GtkWidget *sys_box, *devices_box;
- GtkWidget *sysinfo_box, *sysinfo_label;
-
- app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title(GTK_WINDOW(app), _("System Monitor"));
-
- GdkScreen* screen = gtk_widget_get_screen(app);
- GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
-
- /* use visual, if available */
- if (visual)
- gtk_widget_set_visual(app, visual);
-
- main_box = gtk_vbox_new (FALSE, 0);
- gtk_container_add(GTK_CONTAINER(app), main_box);
-
- width = procdata->config.width;
- height = procdata->config.height;
- gtk_window_set_default_size (GTK_WINDOW (app), width, height);
- gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
-
- /* create the menubar */
- procdata->uimanager = gtk_ui_manager_new ();
-
- /* show tooltips in the statusbar */
- g_signal_connect (procdata->uimanager, "connect_proxy",
- G_CALLBACK (connect_proxy_cb), procdata);
- g_signal_connect (procdata->uimanager, "disconnect_proxy",
- G_CALLBACK (disconnect_proxy_cb), procdata);
-
- gtk_window_add_accel_group (GTK_WINDOW (app),
- gtk_ui_manager_get_accel_group (procdata->uimanager));
-
- if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager,
- ui_info,
- -1,
- NULL)) {
- g_error("building menus failed");
- }
-
- 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,
- menu_entries,
- G_N_ELEMENTS (menu_entries),
- procdata);
- gtk_action_group_add_toggle_actions (procdata->action_group,
- toggle_menu_entries,
- G_N_ELEMENTS (toggle_menu_entries),
- procdata);
-
- gtk_action_group_add_radio_actions (procdata->action_group,
- radio_menu_entries,
- G_N_ELEMENTS (radio_menu_entries),
- procdata->config.whose_process,
- G_CALLBACK(cb_radio_processes),
- procdata);
-
- gtk_ui_manager_insert_action_group (procdata->uimanager,
- procdata->action_group,
- 0);
-
- menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar");
- gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
-
-
- /* create the main notebook */
- procdata->notebook = notebook = gtk_notebook_new ();
- gtk_box_pack_start (GTK_BOX (main_box),
- notebook,
- TRUE,
- TRUE,
- 0);
-
- sysinfo_box = gtk_hbox_new(TRUE, 0); // procman_create_sysinfo_view();
- sysinfo_label = gtk_label_new(_("System"));
- gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label);
-
- vbox1 = create_proc_view (procdata);
- tab_label1 = gtk_label_new (_("Processes"));
- gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1);
-
- sys_box = create_sys_view (procdata);
- tab_label2 = gtk_label_new (_("Resources"));
- gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2);
-
- devices_box = create_disk_view (procdata);
- tab_label3 = gtk_label_new (_("File Systems"));
- gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3);
-
- g_signal_connect (G_OBJECT (notebook), "switch-page",
- G_CALLBACK (cb_switch_page), procdata);
- g_signal_connect (G_OBJECT (notebook), "change-current-page",
- G_CALLBACK (cb_change_current_page), procdata);
-
- 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);
-
- GtkAccelGroup *accel_group;
- GClosure *goto_tab_closure[4];
- accel_group = gtk_accel_group_new ();
- gtk_window_add_accel_group (GTK_WINDOW(app), accel_group);
- for (i = 0; i < 4; ++i) {
- goto_tab_closure[i] = g_cclosure_new_swap (G_CALLBACK (cb_proc_goto_tab),
- (gpointer) i, NULL);
- gtk_accel_group_connect (accel_group, '0'+(i+1),
- GDK_MOD1_MASK, GTK_ACCEL_VISIBLE,
- goto_tab_closure[i]);
- }
-
- /* create the statusbar */
- procdata->statusbar = gtk_statusbar_new();
- gtk_box_pack_end(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0);
- procdata->tip_message_cid = gtk_statusbar_get_context_id
- (GTK_STATUSBAR (procdata->statusbar), "tip_message");
-
-
- action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies");
- gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
- procdata->config.show_tree);
-
- gtk_widget_show_all(app);
- procdata->app = app;
+ gint i;
+ gint width, height;
+ GtkWidget *app;
+ GtkAction *action;
+ GtkWidget *menubar;
+ GtkWidget *main_box;
+ GtkWidget *notebook;
+ GtkWidget *tab_label1, *tab_label2, *tab_label3;
+ GtkWidget *vbox1;
+ GtkWidget *sys_box, *devices_box;
+ GtkWidget *sysinfo_box, *sysinfo_label;
+
+ app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(app), _("System Monitor"));
+
+ GdkScreen* screen = gtk_widget_get_screen(app);
+ GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
+
+ /* use visual, if available */
+ if (visual)
+ gtk_widget_set_visual(app, visual);
+
+ main_box = gtk_vbox_new (FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(app), main_box);
+
+ width = procdata->config.width;
+ height = procdata->config.height;
+ gtk_window_set_default_size (GTK_WINDOW (app), width, height);
+ gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
+
+ /* create the menubar */
+ procdata->uimanager = gtk_ui_manager_new ();
+
+ /* show tooltips in the statusbar */
+ g_signal_connect (procdata->uimanager, "connect_proxy",
+ G_CALLBACK (connect_proxy_cb), procdata);
+ g_signal_connect (procdata->uimanager, "disconnect_proxy",
+ G_CALLBACK (disconnect_proxy_cb), procdata);
+
+ gtk_window_add_accel_group (GTK_WINDOW (app),
+ gtk_ui_manager_get_accel_group (procdata->uimanager));
+
+ if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager,
+ ui_info,
+ -1,
+ NULL)) {
+ g_error("building menus failed");
+ }
+
+ 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,
+ menu_entries,
+ G_N_ELEMENTS (menu_entries),
+ procdata);
+ gtk_action_group_add_toggle_actions (procdata->action_group,
+ toggle_menu_entries,
+ G_N_ELEMENTS (toggle_menu_entries),
+ procdata);
+
+ gtk_action_group_add_radio_actions (procdata->action_group,
+ radio_menu_entries,
+ G_N_ELEMENTS (radio_menu_entries),
+ procdata->config.whose_process,
+ G_CALLBACK(cb_radio_processes),
+ procdata);
+
+ gtk_ui_manager_insert_action_group (procdata->uimanager,
+ procdata->action_group,
+ 0);
+
+ menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar");
+ gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
+
+
+ /* create the main notebook */
+ procdata->notebook = notebook = gtk_notebook_new ();
+ gtk_box_pack_start (GTK_BOX (main_box),
+ notebook,
+ TRUE,
+ TRUE,
+ 0);
+
+ sysinfo_box = gtk_hbox_new(TRUE, 0); // procman_create_sysinfo_view();
+ sysinfo_label = gtk_label_new(_("System"));
+ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label);
+
+ vbox1 = create_proc_view (procdata);
+ tab_label1 = gtk_label_new (_("Processes"));
+ gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1);
+
+ sys_box = create_sys_view (procdata);
+ tab_label2 = gtk_label_new (_("Resources"));
+ gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2);
+
+ devices_box = create_disk_view (procdata);
+ tab_label3 = gtk_label_new (_("File Systems"));
+ gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3);
+
+ g_signal_connect (G_OBJECT (notebook), "switch-page",
+ G_CALLBACK (cb_switch_page), procdata);
+ g_signal_connect (G_OBJECT (notebook), "change-current-page",
+ G_CALLBACK (cb_change_current_page), procdata);
+
+ 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);
+
+ GtkAccelGroup *accel_group;
+ GClosure *goto_tab_closure[4];
+ accel_group = gtk_accel_group_new ();
+ gtk_window_add_accel_group (GTK_WINDOW(app), accel_group);
+ for (i = 0; i < 4; ++i) {
+ goto_tab_closure[i] = g_cclosure_new_swap (G_CALLBACK (cb_proc_goto_tab),
+ (gpointer) i, NULL);
+ gtk_accel_group_connect (accel_group, '0'+(i+1),
+ GDK_MOD1_MASK, GTK_ACCEL_VISIBLE,
+ goto_tab_closure[i]);
+ }
+
+ /* create the statusbar */
+ procdata->statusbar = gtk_statusbar_new();
+ gtk_box_pack_end(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0);
+ procdata->tip_message_cid = gtk_statusbar_get_context_id
+ (GTK_STATUSBAR (procdata->statusbar), "tip_message");
+
+
+ action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies");
+ gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
+ procdata->config.show_tree);
+
+ gtk_widget_show_all(app);
+ procdata->app = app;
}
void
do_popup_menu (ProcData *procdata, GdkEventButton *event)
{
- guint button;
- guint32 event_time;
-
- if (event) {
- button = event->button;
- event_time = event->time;
- }
- else {
- button = 0;
- event_time = gtk_get_current_event_time ();
- }
-
- gtk_menu_popup (GTK_MENU (procdata->popup_menu), NULL, NULL,
- NULL, NULL, button, event_time);
+ guint button;
+ guint32 event_time;
+
+ if (event) {
+ button = event->button;
+ event_time = event->time;
+ }
+ else {
+ button = 0;
+ event_time = gtk_get_current_event_time ();
+ }
+
+ gtk_menu_popup (GTK_MENU (procdata->popup_menu), NULL, NULL,
+ NULL, NULL, button, event_time);
}
void
update_sensitivity(ProcData *data)
{
- const char * const selected_actions[] = { "StopProcess",
- "ContProcess",
- "EndProcess",
- "KillProcess",
- "ChangePriority",
- "MemoryMaps",
- "OpenFiles" };
-
- const char * const processes_actions[] = { "ShowActiveProcesses",
- "ShowAllProcesses",
- "ShowMyProcesses",
- "ShowDependencies",
- "Refresh"
- };
-
- size_t i;
- gboolean processes_sensitivity, selected_sensitivity;
- GtkAction *action;
-
- processes_sensitivity = (data->config.current_tab == PROCMAN_TAB_PROCESSES);
- selected_sensitivity = (processes_sensitivity && data->selected_process != NULL);
-
- if(data->endprocessbutton) {
- /* avoid error on startup if endprocessbutton
- has not been built yet */
- gtk_widget_set_sensitive(data->endprocessbutton, selected_sensitivity);
- }
-
- for (i = 0; i != G_N_ELEMENTS(processes_actions); ++i) {
- action = gtk_action_group_get_action(data->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,
- selected_actions[i]);
- gtk_action_set_sensitive(action, selected_sensitivity);
- }
+ const char * const selected_actions[] = { "StopProcess",
+ "ContProcess",
+ "EndProcess",
+ "KillProcess",
+ "ChangePriority",
+ "MemoryMaps",
+ "OpenFiles" };
+
+ const char * const processes_actions[] = { "ShowActiveProcesses",
+ "ShowAllProcesses",
+ "ShowMyProcesses",
+ "ShowDependencies",
+ "Refresh"
+ };
+
+ size_t i;
+ gboolean processes_sensitivity, selected_sensitivity;
+ GtkAction *action;
+
+ processes_sensitivity = (data->config.current_tab == PROCMAN_TAB_PROCESSES);
+ selected_sensitivity = (processes_sensitivity && data->selected_process != NULL);
+
+ if(data->endprocessbutton) {
+ /* avoid error on startup if endprocessbutton
+ has not been built yet */
+ gtk_widget_set_sensitive(data->endprocessbutton, selected_sensitivity);
+ }
+
+ for (i = 0; i != G_N_ELEMENTS(processes_actions); ++i) {
+ action = gtk_action_group_get_action(data->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,
+ selected_actions[i]);
+ gtk_action_set_sensitive(action, selected_sensitivity);
+ }
}
-static void
+static void
cb_toggle_tree (GtkAction *action, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings; gboolean show;
+ ProcData *procdata = static_cast<ProcData*>(data);
+ GSettings *settings = procdata->settings; gboolean show;
- show = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
- if (show == procdata->config.show_tree)
- return;
+ show = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
+ if (show == procdata->config.show_tree)
+ return;
- g_settings_set_boolean (settings, "show-tree", show);
+ g_settings_set_boolean (settings, "show-tree", show);
}
static void
cb_proc_goto_tab (gint tab)
{
- ProcData *data = ProcData::get_instance ();
- gtk_notebook_set_current_page (GTK_NOTEBOOK (data->notebook), tab);
+ ProcData *data = ProcData::get_instance ();
+ gtk_notebook_set_current_page (GTK_NOTEBOOK (data->notebook), tab);
}
diff --git a/src/interface.h b/src/interface.h
index b26b670..bf18a5e 100644
--- a/src/interface.h
+++ b/src/interface.h
@@ -24,9 +24,9 @@
#include <gtk/gtk.h>
#include "procman.h"
-void create_main_window (ProcData *data);
-void update_sensitivity (ProcData *data);
+void create_main_window (ProcData *data);
+void update_sensitivity (ProcData *data);
void do_popup_menu(ProcData *data, GdkEventButton *event);
-GtkWidget * make_title_label (const char *text);
+GtkWidget * make_title_label (const char *text);
#endif /* _PROCMAN_INTERFACE_H_ */
diff --git a/src/load-graph.cpp b/src/load-graph.cpp
index 9291179..3a61eeb 100644
--- a/src/load-graph.cpp
+++ b/src/load-graph.cpp
@@ -31,169 +31,169 @@
void LoadGraph::clear_background()
{
- if (this->background) {
- cairo_surface_destroy (this->background);
- this->background = NULL;
- }
+ if (this->background) {
+ cairo_surface_destroy (this->background);
+ this->background = NULL;
+ }
}
unsigned LoadGraph::num_bars() const
{
- unsigned n;
-
- // keep 100 % num_bars == 0
- switch (static_cast<int>(this->draw_height / (this->fontsize + 14)))
- {
- case 0:
- case 1:
- n = 1;
- break;
- case 2:
- case 3:
- n = 2;
- break;
- case 4:
- n = 4;
- break;
- default:
- n = 5;
- }
-
- return n;
+ unsigned n;
+
+ // keep 100 % num_bars == 0
+ switch (static_cast<int>(this->draw_height / (this->fontsize + 14)))
+ {
+ case 0:
+ case 1:
+ n = 1;
+ break;
+ case 2:
+ case 3:
+ n = 2;
+ break;
+ case 4:
+ n = 4;
+ break;
+ default:
+ n = 5;
+ }
+
+ return n;
}
#define FRAME_WIDTH 4
void draw_background(LoadGraph *g) {
- GtkAllocation allocation;
- double dash[2] = { 1.0, 2.0 };
- cairo_t *cr;
- guint i;
- unsigned num_bars;
- char *caption;
- cairo_text_extents_t extents;
-
- num_bars = g->num_bars();
- g->graph_dely = (g->draw_height - 15) / num_bars; /* round to int to avoid AA blur */
- g->real_draw_height = g->graph_dely * num_bars;
- g->graph_delx = (g->draw_width - 2.0 - g->rmargin - g->indent) / (LoadGraph::NUM_POINTS - 3);
- g->graph_buffer_offset = (int) (1.5 * g->graph_delx) + FRAME_WIDTH ;
-
- gtk_widget_get_allocation (g->disp, &allocation);
- g->background = gdk_window_create_similar_surface (gtk_widget_get_window (g->disp),
- CAIRO_CONTENT_COLOR,
- allocation.width,
- allocation.height);
- cr = cairo_create (g->background);
-
- // set the background colour
- GtkStyle *style = gtk_widget_get_style (ProcData::get_instance()->notebook);
- gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]);
- cairo_paint (cr);
-
- /* draw frame */
- cairo_translate (cr, FRAME_WIDTH, FRAME_WIDTH);
-
- /* Draw background rectangle */
- cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
- cairo_rectangle (cr, g->rmargin + g->indent, 0,
- g->draw_width - g->rmargin - g->indent, g->real_draw_height);
- cairo_fill(cr);
-
- cairo_set_line_width (cr, 1.0);
- cairo_set_dash (cr, dash, 2, 0);
- cairo_set_font_size (cr, g->fontsize);
-
- for (i = 0; i <= num_bars; ++i) {
- double y;
-
- if (i == 0)
- y = 0.5 + g->fontsize / 2.0;
- else if (i == num_bars)
- y = i * g->graph_dely + 0.5;
- else
- y = i * g->graph_dely + g->fontsize / 2.0;
-
- gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]);
- if (g->type == LOAD_GRAPH_NET) {
- // operation orders matters so it's 0 if i == num_bars
- unsigned rate = g->net.max - (i * g->net.max / num_bars);
- const std::string caption(procman::format_network_rate(rate, g->net.max));
- cairo_text_extents (cr, caption.c_str(), &extents);
- cairo_move_to (cr, g->indent - extents.width + 20, y);
- cairo_show_text (cr, caption.c_str());
- } else {
- // operation orders matters so it's 0 if i == num_bars
- caption = g_strdup_printf("%d %%", 100 - i * (100 / num_bars));
- cairo_text_extents (cr, caption, &extents);
- cairo_move_to (cr, g->indent - extents.width + 20, y);
- cairo_show_text (cr, caption);
- g_free (caption);
- }
-
- cairo_set_source_rgba (cr, 0, 0, 0, 0.75);
- cairo_move_to (cr, g->rmargin + g->indent - 3, i * g->graph_dely + 0.5);
- cairo_line_to (cr, g->draw_width - 0.5, i * g->graph_dely + 0.5);
- }
- cairo_stroke (cr);
-
- cairo_set_dash (cr, dash, 2, 1.5);
-
- const unsigned total_seconds = g->speed * (LoadGraph::NUM_POINTS - 2) / 1000;
-
- for (unsigned int i = 0; i < 7; i++) {
- double x = (i) * (g->draw_width - g->rmargin - g->indent) / 6;
- cairo_set_source_rgba (cr, 0, 0, 0, 0.75);
- cairo_move_to (cr, (ceil(x) + 0.5) + g->rmargin + g->indent, 0.5);
- cairo_line_to (cr, (ceil(x) + 0.5) + g->rmargin + g->indent, g->real_draw_height + 4.5);
- cairo_stroke(cr);
- unsigned seconds = total_seconds - i * total_seconds / 6;
- const char* format;
- if (i == 0)
- format = dngettext(GETTEXT_PACKAGE, "%u second", "%u seconds", seconds);
- else
- format = "%u";
- caption = g_strdup_printf(format, seconds);
- cairo_text_extents (cr, caption, &extents);
- cairo_move_to (cr, ((ceil(x) + 0.5) + g->rmargin + g->indent) - (extents.width/2), g->draw_height);
- gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]);
- cairo_show_text (cr, caption);
- g_free (caption);
- }
-
- cairo_stroke (cr);
- cairo_destroy (cr);
+ GtkAllocation allocation;
+ double dash[2] = { 1.0, 2.0 };
+ cairo_t *cr;
+ guint i;
+ unsigned num_bars;
+ char *caption;
+ cairo_text_extents_t extents;
+
+ num_bars = g->num_bars();
+ g->graph_dely = (g->draw_height - 15) / num_bars; /* round to int to avoid AA blur */
+ g->real_draw_height = g->graph_dely * num_bars;
+ g->graph_delx = (g->draw_width - 2.0 - g->rmargin - g->indent) / (LoadGraph::NUM_POINTS - 3);
+ g->graph_buffer_offset = (int) (1.5 * g->graph_delx) + FRAME_WIDTH ;
+
+ gtk_widget_get_allocation (g->disp, &allocation);
+ g->background = gdk_window_create_similar_surface (gtk_widget_get_window (g->disp),
+ CAIRO_CONTENT_COLOR,
+ allocation.width,
+ allocation.height);
+ cr = cairo_create (g->background);
+
+ // set the background colour
+ GtkStyle *style = gtk_widget_get_style (ProcData::get_instance()->notebook);
+ gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]);
+ cairo_paint (cr);
+
+ /* draw frame */
+ cairo_translate (cr, FRAME_WIDTH, FRAME_WIDTH);
+
+ /* Draw background rectangle */
+ cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
+ cairo_rectangle (cr, g->rmargin + g->indent, 0,
+ g->draw_width - g->rmargin - g->indent, g->real_draw_height);
+ cairo_fill(cr);
+
+ cairo_set_line_width (cr, 1.0);
+ cairo_set_dash (cr, dash, 2, 0);
+ cairo_set_font_size (cr, g->fontsize);
+
+ for (i = 0; i <= num_bars; ++i) {
+ double y;
+
+ if (i == 0)
+ y = 0.5 + g->fontsize / 2.0;
+ else if (i == num_bars)
+ y = i * g->graph_dely + 0.5;
+ else
+ y = i * g->graph_dely + g->fontsize / 2.0;
+
+ gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]);
+ if (g->type == LOAD_GRAPH_NET) {
+ // operation orders matters so it's 0 if i == num_bars
+ unsigned rate = g->net.max - (i * g->net.max / num_bars);
+ const std::string caption(procman::format_network_rate(rate, g->net.max));
+ cairo_text_extents (cr, caption.c_str(), &extents);
+ cairo_move_to (cr, g->indent - extents.width + 20, y);
+ cairo_show_text (cr, caption.c_str());
+ } else {
+ // operation orders matters so it's 0 if i == num_bars
+ caption = g_strdup_printf("%d %%", 100 - i * (100 / num_bars));
+ cairo_text_extents (cr, caption, &extents);
+ cairo_move_to (cr, g->indent - extents.width + 20, y);
+ cairo_show_text (cr, caption);
+ g_free (caption);
+ }
+
+ cairo_set_source_rgba (cr, 0, 0, 0, 0.75);
+ cairo_move_to (cr, g->rmargin + g->indent - 3, i * g->graph_dely + 0.5);
+ cairo_line_to (cr, g->draw_width - 0.5, i * g->graph_dely + 0.5);
+ }
+ cairo_stroke (cr);
+
+ cairo_set_dash (cr, dash, 2, 1.5);
+
+ const unsigned total_seconds = g->speed * (LoadGraph::NUM_POINTS - 2) / 1000;
+
+ for (unsigned int i = 0; i < 7; i++) {
+ double x = (i) * (g->draw_width - g->rmargin - g->indent) / 6;
+ cairo_set_source_rgba (cr, 0, 0, 0, 0.75);
+ cairo_move_to (cr, (ceil(x) + 0.5) + g->rmargin + g->indent, 0.5);
+ cairo_line_to (cr, (ceil(x) + 0.5) + g->rmargin + g->indent, g->real_draw_height + 4.5);
+ cairo_stroke(cr);
+ unsigned seconds = total_seconds - i * total_seconds / 6;
+ const char* format;
+ if (i == 0)
+ format = dngettext(GETTEXT_PACKAGE, "%u second", "%u seconds", seconds);
+ else
+ format = "%u";
+ caption = g_strdup_printf(format, seconds);
+ cairo_text_extents (cr, caption, &extents);
+ cairo_move_to (cr, ((ceil(x) + 0.5) + g->rmargin + g->indent) - (extents.width/2), g->draw_height);
+ gdk_cairo_set_source_color (cr, &style->fg[GTK_STATE_NORMAL]);
+ cairo_show_text (cr, caption);
+ g_free (caption);
+ }
+
+ cairo_stroke (cr);
+ cairo_destroy (cr);
}
/* Redraws the backing buffer for the load graph and updates the window */
void
load_graph_queue_draw (LoadGraph *g)
{
- /* repaint */
- gtk_widget_queue_draw (g->disp);
+ /* repaint */
+ gtk_widget_queue_draw (g->disp);
}
static int load_graph_update (gpointer user_data); // predeclare load_graph_update so we can compile ;)
static gboolean
load_graph_configure (GtkWidget *widget,
- GdkEventConfigure *event,
- gpointer data_ptr)
+ GdkEventConfigure *event,
+ gpointer data_ptr)
{
- GtkAllocation allocation;
- LoadGraph * const g = static_cast<LoadGraph*>(data_ptr);
+ GtkAllocation allocation;
+ LoadGraph * const g = static_cast<LoadGraph*>(data_ptr);
- gtk_widget_get_allocation (widget, &allocation);
- g->draw_width = allocation.width - 2 * FRAME_WIDTH;
- g->draw_height = allocation.height - 2 * FRAME_WIDTH;
+ gtk_widget_get_allocation (widget, &allocation);
+ g->draw_width = allocation.width - 2 * FRAME_WIDTH;
+ g->draw_height = allocation.height - 2 * FRAME_WIDTH;
- g->clear_background();
+ g->clear_background();
- load_graph_queue_draw (g);
+ load_graph_queue_draw (g);
- return TRUE;
+ return TRUE;
}
static gboolean
@@ -201,115 +201,115 @@ load_graph_draw (GtkWidget *widget,
cairo_t * context,
gpointer data_ptr)
{
- LoadGraph * const g = static_cast<LoadGraph*>(data_ptr);
- GtkAllocation allocation;
- GdkWindow *window;
-
- guint i, j;
- gdouble sample_width, x_offset;
-
- window = gtk_widget_get_window (g->disp);
- gtk_widget_get_allocation (g->disp, &allocation);
-
- if (g->background == NULL) {
- draw_background(g);
- cairo_pattern_t * pattern = cairo_pattern_create_for_surface (g->background);
- gdk_window_set_background_pattern (window, pattern);
- cairo_pattern_destroy (pattern);
+ LoadGraph * const g = static_cast<LoadGraph*>(data_ptr);
+ GtkAllocation allocation;
+ GdkWindow *window;
+
+ guint i, j;
+ gdouble sample_width, x_offset;
+
+ window = gtk_widget_get_window (g->disp);
+ gtk_widget_get_allocation (g->disp, &allocation);
+
+ if (g->background == NULL) {
+ draw_background(g);
+ cairo_pattern_t * pattern = cairo_pattern_create_for_surface (g->background);
+ gdk_window_set_background_pattern (window, pattern);
+ cairo_pattern_destroy (pattern);
+ }
+
+ /* Number of pixels wide for one graph point */
+ sample_width = (float)(g->draw_width - g->rmargin - g->indent) / (float)LoadGraph::NUM_POINTS;
+ /* General offset */
+ x_offset = g->draw_width - g->rmargin + (sample_width*2);
+
+ /* Subframe offset */
+ x_offset += g->rmargin - ((sample_width / g->frames_per_unit) * g->render_counter);
+
+ /* draw the graph */
+ cairo_t* cr;
+
+ cr = gdk_cairo_create (window);
+
+ cairo_set_line_width (cr, 1);
+ cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+ cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
+ cairo_rectangle (cr, g->rmargin + g->indent + FRAME_WIDTH + 1, FRAME_WIDTH - 1,
+ g->draw_width - g->rmargin - g->indent - 1, g->real_draw_height + FRAME_WIDTH - 1);
+ cairo_clip(cr);
+
+ for (j = 0; j < g->n; ++j) {
+ cairo_move_to (cr, x_offset, (1.0f - g->data[0][j]) * g->real_draw_height);
+ gdk_cairo_set_source_color (cr, &(g->colors [j]));
+
+ for (i = 1; i < LoadGraph::NUM_POINTS; ++i) {
+ if (g->data[i][j] == -1.0f)
+ continue;
+ cairo_curve_to (cr,
+ x_offset - ((i - 0.5f) * g->graph_delx),
+ (1.0f - g->data[i-1][j]) * g->real_draw_height + 3.5f,
+ x_offset - ((i - 0.5f) * g->graph_delx),
+ (1.0f - g->data[i][j]) * g->real_draw_height + 3.5f,
+ x_offset - (i * g->graph_delx),
+ (1.0f - g->data[i][j]) * g->real_draw_height + 3.5f);
}
+ cairo_stroke (cr);
- /* Number of pixels wide for one graph point */
- sample_width = (float)(g->draw_width - g->rmargin - g->indent) / (float)LoadGraph::NUM_POINTS;
- /* General offset */
- x_offset = g->draw_width - g->rmargin + (sample_width*2);
-
- /* Subframe offset */
- x_offset += g->rmargin - ((sample_width / g->frames_per_unit) * g->render_counter);
-
- /* draw the graph */
- cairo_t* cr;
+ }
- cr = gdk_cairo_create (window);
+ cairo_destroy (cr);
- cairo_set_line_width (cr, 1);
- cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
- cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
- cairo_rectangle (cr, g->rmargin + g->indent + FRAME_WIDTH + 1, FRAME_WIDTH - 1,
- g->draw_width - g->rmargin - g->indent - 1, g->real_draw_height + FRAME_WIDTH - 1);
- cairo_clip(cr);
-
- for (j = 0; j < g->n; ++j) {
- cairo_move_to (cr, x_offset, (1.0f - g->data[0][j]) * g->real_draw_height);
- gdk_cairo_set_source_color (cr, &(g->colors [j]));
-
- for (i = 1; i < LoadGraph::NUM_POINTS; ++i) {
- if (g->data[i][j] == -1.0f)
- continue;
- cairo_curve_to (cr,
- x_offset - ((i - 0.5f) * g->graph_delx),
- (1.0f - g->data[i-1][j]) * g->real_draw_height + 3.5f,
- x_offset - ((i - 0.5f) * g->graph_delx),
- (1.0f - g->data[i][j]) * g->real_draw_height + 3.5f,
- x_offset - (i * g->graph_delx),
- (1.0f - g->data[i][j]) * g->real_draw_height + 3.5f);
- }
- cairo_stroke (cr);
-
- }
-
- cairo_destroy (cr);
-
- return TRUE;
+ return TRUE;
}
static void
get_load (LoadGraph *g)
{
- guint i;
- glibtop_cpu cpu;
+ guint i;
+ glibtop_cpu cpu;
- glibtop_get_cpu (&cpu);
+ glibtop_get_cpu (&cpu);
#undef NOW
#undef LAST
#define NOW (g->cpu.times[g->cpu.now])
#define LAST (g->cpu.times[g->cpu.now ^ 1])
- if (g->n == 1) {
- NOW[0][CPU_TOTAL] = cpu.total;
- NOW[0][CPU_USED] = cpu.user + cpu.nice + cpu.sys;
- } else {
- for (i = 0; i < g->n; i++) {
- NOW[i][CPU_TOTAL] = cpu.xcpu_total[i];
- NOW[i][CPU_USED] = cpu.xcpu_user[i] + cpu.xcpu_nice[i]
- + cpu.xcpu_sys[i];
- }
- }
-
- // on the first call, LAST is 0
- // which means data is set to the average load since boot
- // that value has no meaning, we just want all the
- // graphs to be aligned, so the CPU graph needs to start
- // immediately
-
- for (i = 0; i < g->n; i++) {
- float load;
- float total, used;
- gchar *text;
-
- total = NOW[i][CPU_TOTAL] - LAST[i][CPU_TOTAL];
- used = NOW[i][CPU_USED] - LAST[i][CPU_USED];
-
- load = used / MAX(total, 1.0f);
- g->data[0][i] = load;
-
- /* Update label */
- text = g_strdup_printf("%.1f%%", load * 100.0f);
- gtk_label_set_text(GTK_LABEL(g->labels.cpu[i]), text);
- g_free(text);
- }
-
- g->cpu.now ^= 1;
+ if (g->n == 1) {
+ NOW[0][CPU_TOTAL] = cpu.total;
+ NOW[0][CPU_USED] = cpu.user + cpu.nice + cpu.sys;
+ } else {
+ for (i = 0; i < g->n; i++) {
+ NOW[i][CPU_TOTAL] = cpu.xcpu_total[i];
+ NOW[i][CPU_USED] = cpu.xcpu_user[i] + cpu.xcpu_nice[i]
+ + cpu.xcpu_sys[i];
+ }
+ }
+
+ // on the first call, LAST is 0
+ // which means data is set to the average load since boot
+ // that value has no meaning, we just want all the
+ // graphs to be aligned, so the CPU graph needs to start
+ // immediately
+
+ for (i = 0; i < g->n; i++) {
+ float load;
+ float total, used;
+ gchar *text;
+
+ total = NOW[i][CPU_TOTAL] - LAST[i][CPU_TOTAL];
+ used = NOW[i][CPU_USED] - LAST[i][CPU_USED];
+
+ load = used / MAX(total, 1.0f);
+ g->data[0][i] = load;
+
+ /* Update label */
+ text = g_strdup_printf("%.1f%%", load * 100.0f);
+ gtk_label_set_text(GTK_LABEL(g->labels.cpu[i]), text);
+ g_free(text);
+ }
+
+ g->cpu.now ^= 1;
#undef NOW
#undef LAST
@@ -319,225 +319,225 @@ get_load (LoadGraph *g)
namespace
{
- void set_memory_label_and_picker(GtkLabel* label, GSMColorButton* picker,
- guint64 used, guint64 total, double percent)
- {
- char* used_text;
- char* total_text;
- char* text;
-
- used_text = procman::format_size(used);
- total_text = procman::format_size(total);
- // xgettext: 540MiB (53 %) of 1.0 GiB
- text = g_strdup_printf(_("%s (%.1f %%) of %s"), used_text, 100.0 * percent, total_text);
- gtk_label_set_text(label, text);
- g_free(used_text);
- g_free(total_text);
- g_free(text);
-
- if (picker)
- gsm_color_button_set_fraction(picker, percent);
- }
+ void set_memory_label_and_picker(GtkLabel* label, GSMColorButton* picker,
+ guint64 used, guint64 total, double percent)
+ {
+ char* used_text;
+ char* total_text;
+ char* text;
+
+ used_text = procman::format_size(used);
+ total_text = procman::format_size(total);
+ // xgettext: 540MiB (53 %) of 1.0 GiB
+ text = g_strdup_printf(_("%s (%.1f %%) of %s"), used_text, 100.0 * percent, total_text);
+ gtk_label_set_text(label, text);
+ g_free(used_text);
+ g_free(total_text);
+ g_free(text);
+
+ if (picker)
+ gsm_color_button_set_fraction(picker, percent);
+ }
}
static void
get_memory (LoadGraph *g)
{
- float mempercent, swappercent;
+ float mempercent, swappercent;
- glibtop_mem mem;
- glibtop_swap swap;
+ glibtop_mem mem;
+ glibtop_swap swap;
- glibtop_get_mem (&mem);
- glibtop_get_swap (&swap);
+ glibtop_get_mem (&mem);
+ glibtop_get_swap (&swap);
- /* There's no swap on LiveCD : 0.0f is better than NaN :) */
- swappercent = (swap.total ? (float)swap.used / (float)swap.total : 0.0f);
- mempercent = (float)mem.user / (float)mem.total;
+ /* There's no swap on LiveCD : 0.0f is better than NaN :) */
+ swappercent = (swap.total ? (float)swap.used / (float)swap.total : 0.0f);
+ mempercent = (float)mem.user / (float)mem.total;
- set_memory_label_and_picker(GTK_LABEL(g->labels.memory),
- GSM_COLOR_BUTTON(g->mem_color_picker),
- mem.user, mem.total, mempercent);
+ set_memory_label_and_picker(GTK_LABEL(g->labels.memory),
+ GSM_COLOR_BUTTON(g->mem_color_picker),
+ mem.user, mem.total, mempercent);
- set_memory_label_and_picker(GTK_LABEL(g->labels.swap),
- GSM_COLOR_BUTTON(g->swap_color_picker),
- swap.used, swap.total, swappercent);
+ set_memory_label_and_picker(GTK_LABEL(g->labels.swap),
+ GSM_COLOR_BUTTON(g->swap_color_picker),
+ swap.used, swap.total, swappercent);
- g->data[0][0] = mempercent;
- g->data[0][1] = swappercent;
+ g->data[0][0] = mempercent;
+ g->data[0][1] = swappercent;
}
static void
net_scale (LoadGraph *g, guint64 din, guint64 dout)
{
- g->data[0][0] = 1.0f * din / g->net.max;
- g->data[0][1] = 1.0f * dout / g->net.max;
-
- guint64 dmax = std::max(din, dout);
- g->net.values[g->net.cur] = dmax;
- g->net.cur = (g->net.cur + 1) % LoadGraph::NUM_POINTS;
-
- guint64 new_max;
- // both way, new_max is the greatest value
- if (dmax >= g->net.max)
- new_max = dmax;
- else
- new_max = *std::max_element(&g->net.values[0],
- &g->net.values[LoadGraph::NUM_POINTS]);
-
- //
- // Round network maximum
- //
-
- const guint64 bak_max(new_max);
-
- if (ProcData::get_instance()->config.network_in_bits) {
- // TODO: fix logic to give a nice scale with bits
-
- // round up to get some extra space
- // yes, it can overflow
- new_max = 1.1 * new_max;
- // make sure max is not 0 to avoid / 0
- // default to 125 bytes == 1kbit
- new_max = std::max(new_max, G_GUINT64_CONSTANT(125));
-
- } else {
- // round up to get some extra space
- // yes, it can overflow
- new_max = 1.1 * new_max;
- // make sure max is not 0 to avoid / 0
- // default to 1 KiB
- new_max = std::max(new_max, G_GUINT64_CONSTANT(1024));
-
- // decompose new_max = coef10 * 2**(base10 * 10)
- // where coef10 and base10 are integers and coef10 < 2**10
- //
- // e.g: ceil(100.5 KiB) = 101 KiB = 101 * 2**(1 * 10)
- // where base10 = 1, coef10 = 101, pow2 = 16
-
- guint64 pow2 = std::floor(log2(new_max));
- guint64 base10 = pow2 / 10.0;
- guint64 coef10 = std::ceil(new_max / double(G_GUINT64_CONSTANT(1) << (base10 * 10)));
- g_assert(new_max <= (coef10 * (G_GUINT64_CONSTANT(1) << (base10 * 10))));
-
- // then decompose coef10 = x * 10**factor10
- // where factor10 is integer and x < 10
- // so we new_max has only 1 significant digit
-
- guint64 factor10 = std::pow(10.0, std::floor(std::log10(coef10)));
- coef10 = std::ceil(coef10 / double(factor10)) * factor10;
-
- // then make coef10 divisible by num_bars
- if (coef10 % g->num_bars() != 0)
- coef10 = coef10 + (g->num_bars() - coef10 % g->num_bars());
- g_assert(coef10 % g->num_bars() == 0);
- new_max = coef10 * (G_GUINT64_CONSTANT(1) << guint64(base10 * 10));
- procman_debug("bak %" G_GUINT64_FORMAT " new_max %" G_GUINT64_FORMAT
- "pow2 %" G_GUINT64_FORMAT " coef10 %" G_GUINT64_FORMAT,
- bak_max, new_max, pow2, coef10);
- }
-
- if (bak_max > new_max) {
- procman_debug("overflow detected: bak=%" G_GUINT64_FORMAT
- " new=%" G_GUINT64_FORMAT,
- bak_max, new_max);
- new_max = bak_max;
- }
-
- // if max is the same or has decreased but not so much, don't
- // do anything to avoid rescaling
- if ((0.8 * g->net.max) < new_max && new_max <= g->net.max)
- return;
-
- const double scale = 1.0f * g->net.max / new_max;
-
- for (size_t i = 0; i < LoadGraph::NUM_POINTS; i++) {
- if (g->data[i][0] >= 0.0f) {
- g->data[i][0] *= scale;
- g->data[i][1] *= scale;
- }
- }
-
- procman_debug("rescale dmax = %" G_GUINT64_FORMAT
- " max = %" G_GUINT64_FORMAT
- " new_max = %" G_GUINT64_FORMAT,
- dmax, g->net.max, new_max);
-
- g->net.max = new_max;
-
- // force the graph background to be redrawn now that scale has changed
- g->clear_background();
+ g->data[0][0] = 1.0f * din / g->net.max;
+ g->data[0][1] = 1.0f * dout / g->net.max;
+
+ guint64 dmax = std::max(din, dout);
+ g->net.values[g->net.cur] = dmax;
+ g->net.cur = (g->net.cur + 1) % LoadGraph::NUM_POINTS;
+
+ guint64 new_max;
+ // both way, new_max is the greatest value
+ if (dmax >= g->net.max)
+ new_max = dmax;
+ else
+ new_max = *std::max_element(&g->net.values[0],
+ &g->net.values[LoadGraph::NUM_POINTS]);
+
+ //
+ // Round network maximum
+ //
+
+ const guint64 bak_max(new_max);
+
+ if (ProcData::get_instance()->config.network_in_bits) {
+ // TODO: fix logic to give a nice scale with bits
+
+ // round up to get some extra space
+ // yes, it can overflow
+ new_max = 1.1 * new_max;
+ // make sure max is not 0 to avoid / 0
+ // default to 125 bytes == 1kbit
+ new_max = std::max(new_max, G_GUINT64_CONSTANT(125));
+
+ } else {
+ // round up to get some extra space
+ // yes, it can overflow
+ new_max = 1.1 * new_max;
+ // make sure max is not 0 to avoid / 0
+ // default to 1 KiB
+ new_max = std::max(new_max, G_GUINT64_CONSTANT(1024));
+
+ // decompose new_max = coef10 * 2**(base10 * 10)
+ // where coef10 and base10 are integers and coef10 < 2**10
+ //
+ // e.g: ceil(100.5 KiB) = 101 KiB = 101 * 2**(1 * 10)
+ // where base10 = 1, coef10 = 101, pow2 = 16
+
+ guint64 pow2 = std::floor(log2(new_max));
+ guint64 base10 = pow2 / 10.0;
+ guint64 coef10 = std::ceil(new_max / double(G_GUINT64_CONSTANT(1) << (base10 * 10)));
+ g_assert(new_max <= (coef10 * (G_GUINT64_CONSTANT(1) << (base10 * 10))));
+
+ // then decompose coef10 = x * 10**factor10
+ // where factor10 is integer and x < 10
+ // so we new_max has only 1 significant digit
+
+ guint64 factor10 = std::pow(10.0, std::floor(std::log10(coef10)));
+ coef10 = std::ceil(coef10 / double(factor10)) * factor10;
+
+ // then make coef10 divisible by num_bars
+ if (coef10 % g->num_bars() != 0)
+ coef10 = coef10 + (g->num_bars() - coef10 % g->num_bars());
+ g_assert(coef10 % g->num_bars() == 0);
+ new_max = coef10 * (G_GUINT64_CONSTANT(1) << guint64(base10 * 10));
+ procman_debug("bak %" G_GUINT64_FORMAT " new_max %" G_GUINT64_FORMAT
+ "pow2 %" G_GUINT64_FORMAT " coef10 %" G_GUINT64_FORMAT,
+ bak_max, new_max, pow2, coef10);
+ }
+
+ if (bak_max > new_max) {
+ procman_debug("overflow detected: bak=%" G_GUINT64_FORMAT
+ " new=%" G_GUINT64_FORMAT,
+ bak_max, new_max);
+ new_max = bak_max;
+ }
+
+ // if max is the same or has decreased but not so much, don't
+ // do anything to avoid rescaling
+ if ((0.8 * g->net.max) < new_max && new_max <= g->net.max)
+ return;
+
+ const double scale = 1.0f * g->net.max / new_max;
+
+ for (size_t i = 0; i < LoadGraph::NUM_POINTS; i++) {
+ if (g->data[i][0] >= 0.0f) {
+ g->data[i][0] *= scale;
+ g->data[i][1] *= scale;
+ }
+ }
+
+ procman_debug("rescale dmax = %" G_GUINT64_FORMAT
+ " max = %" G_GUINT64_FORMAT
+ " new_max = %" G_GUINT64_FORMAT,
+ dmax, g->net.max, new_max);
+
+ g->net.max = new_max;
+
+ // force the graph background to be redrawn now that scale has changed
+ g->clear_background();
}
static void
get_net (LoadGraph *g)
{
- glibtop_netlist netlist;
- char **ifnames;
- guint32 i;
- guint64 in = 0, out = 0;
- GTimeVal time;
- guint64 din, dout;
-
- ifnames = glibtop_get_netlist(&netlist);
-
- for (i = 0; i < netlist.number; ++i)
- {
- glibtop_netload netload;
- glibtop_get_netload (&netload, ifnames[i]);
-
- if (netload.if_flags & (1 << GLIBTOP_IF_FLAGS_LOOPBACK))
- continue;
-
- /* Skip interfaces without any IPv4/IPv6 address (or
- those with only a LINK ipv6 addr) However we need to
- be able to exclude these while still keeping the
- value so when they get online (with NetworkManager
- for example) we don't get a suddent peak. Once we're
- able to get this, ignoring down interfaces will be
- possible too. */
- if (not (netload.flags & (1 << GLIBTOP_NETLOAD_ADDRESS6)
- and netload.scope6 != GLIBTOP_IF_IN6_SCOPE_LINK)
- and not (netload.flags & (1 << GLIBTOP_NETLOAD_ADDRESS)))
- continue;
-
- /* Don't skip interfaces that are down (GLIBTOP_IF_FLAGS_UP)
- to avoid spikes when they are brought up */
-
- in += netload.bytes_in;
- out += netload.bytes_out;
- }
-
- g_strfreev(ifnames);
-
- g_get_current_time (&time);
-
- if (in >= g->net.last_in && out >= g->net.last_out &&
- g->net.time.tv_sec != 0) {
- float dtime;
- dtime = time.tv_sec - g->net.time.tv_sec +
- (double) (time.tv_usec - g->net.time.tv_usec) / G_USEC_PER_SEC;
- din = static_cast<guint64>((in - g->net.last_in) / dtime);
- dout = static_cast<guint64>((out - g->net.last_out) / dtime);
- } else {
- /* Don't calc anything if new data is less than old (interface
- removed, counters reset, ...) or if it is the first time */
- din = 0;
- dout = 0;
- }
-
- g->net.last_in = in;
- g->net.last_out = out;
- g->net.time = time;
-
- net_scale(g, din, dout);
-
-
- gtk_label_set_text (GTK_LABEL (g->labels.net_in), procman::format_network_rate(din).c_str());
- gtk_label_set_text (GTK_LABEL (g->labels.net_in_total), procman::format_network(in).c_str());
-
- gtk_label_set_text (GTK_LABEL (g->labels.net_out), procman::format_network_rate(dout).c_str());
- gtk_label_set_text (GTK_LABEL (g->labels.net_out_total), procman::format_network(out).c_str());
+ glibtop_netlist netlist;
+ char **ifnames;
+ guint32 i;
+ guint64 in = 0, out = 0;
+ GTimeVal time;
+ guint64 din, dout;
+
+ ifnames = glibtop_get_netlist(&netlist);
+
+ for (i = 0; i < netlist.number; ++i)
+ {
+ glibtop_netload netload;
+ glibtop_get_netload (&netload, ifnames[i]);
+
+ if (netload.if_flags & (1 << GLIBTOP_IF_FLAGS_LOOPBACK))
+ continue;
+
+ /* Skip interfaces without any IPv4/IPv6 address (or
+ those with only a LINK ipv6 addr) However we need to
+ be able to exclude these while still keeping the
+ value so when they get online (with NetworkManager
+ for example) we don't get a suddent peak. Once we're
+ able to get this, ignoring down interfaces will be
+ possible too. */
+ if (not (netload.flags & (1 << GLIBTOP_NETLOAD_ADDRESS6)
+ and netload.scope6 != GLIBTOP_IF_IN6_SCOPE_LINK)
+ and not (netload.flags & (1 << GLIBTOP_NETLOAD_ADDRESS)))
+ continue;
+
+ /* Don't skip interfaces that are down (GLIBTOP_IF_FLAGS_UP)
+ to avoid spikes when they are brought up */
+
+ in += netload.bytes_in;
+ out += netload.bytes_out;
+ }
+
+ g_strfreev(ifnames);
+
+ g_get_current_time (&time);
+
+ if (in >= g->net.last_in && out >= g->net.last_out &&
+ g->net.time.tv_sec != 0) {
+ float dtime;
+ dtime = time.tv_sec - g->net.time.tv_sec +
+ (double) (time.tv_usec - g->net.time.tv_usec) / G_USEC_PER_SEC;
+ din = static_cast<guint64>((in - g->net.last_in) / dtime);
+ dout = static_cast<guint64>((out - g->net.last_out) / dtime);
+ } else {
+ /* Don't calc anything if new data is less than old (interface
+ removed, counters reset, ...) or if it is the first time */
+ din = 0;
+ dout = 0;
+ }
+
+ g->net.last_in = in;
+ g->net.last_out = out;
+ g->net.time = time;
+
+ net_scale(g, din, dout);
+
+
+ gtk_label_set_text (GTK_LABEL (g->labels.net_in), procman::format_network_rate(din).c_str());
+ gtk_label_set_text (GTK_LABEL (g->labels.net_in_total), procman::format_network(in).c_str());
+
+ gtk_label_set_text (GTK_LABEL (g->labels.net_out), procman::format_network_rate(dout).c_str());
+ gtk_label_set_text (GTK_LABEL (g->labels.net_out_total), procman::format_network(out).c_str());
}
@@ -545,47 +545,47 @@ get_net (LoadGraph *g)
static gboolean
load_graph_update (gpointer user_data)
{
- LoadGraph * const g = static_cast<LoadGraph*>(user_data);
-
- if (g->render_counter == g->frames_per_unit - 1) {
- std::rotate(&g->data[0], &g->data[LoadGraph::NUM_POINTS - 1], &g->data[LoadGraph::NUM_POINTS]);
-
- switch (g->type) {
- case LOAD_GRAPH_CPU:
- get_load(g);
- break;
- case LOAD_GRAPH_MEM:
- get_memory(g);
- break;
- case LOAD_GRAPH_NET:
- get_net(g);
- break;
- default:
- g_assert_not_reached();
- }
- }
-
- if (g->draw)
- load_graph_queue_draw (g);
-
- g->render_counter++;
-
- if (g->render_counter >= g->frames_per_unit)
- g->render_counter = 0;
-
- return TRUE;
+ LoadGraph * const g = static_cast<LoadGraph*>(user_data);
+
+ if (g->render_counter == g->frames_per_unit - 1) {
+ std::rotate(&g->data[0], &g->data[LoadGraph::NUM_POINTS - 1], &g->data[LoadGraph::NUM_POINTS]);
+
+ switch (g->type) {
+ case LOAD_GRAPH_CPU:
+ get_load(g);
+ break;
+ case LOAD_GRAPH_MEM:
+ get_memory(g);
+ break;
+ case LOAD_GRAPH_NET:
+ get_net(g);
+ break;
+ default:
+ g_assert_not_reached();
+ }
+ }
+
+ if (g->draw)
+ load_graph_queue_draw (g);
+
+ g->render_counter++;
+
+ if (g->render_counter >= g->frames_per_unit)
+ g->render_counter = 0;
+
+ return TRUE;
}
LoadGraph::~LoadGraph()
{
- load_graph_stop(this);
+ load_graph_stop(this);
- if (this->timer_index)
- g_source_remove(this->timer_index);
+ if (this->timer_index)
+ g_source_remove(this->timer_index);
- this->clear_background();
+ this->clear_background();
}
@@ -593,193 +593,193 @@ LoadGraph::~LoadGraph()
static gboolean
load_graph_destroy (GtkWidget *widget, gpointer data_ptr)
{
- LoadGraph * const g = static_cast<LoadGraph*>(data_ptr);
+ LoadGraph * const g = static_cast<LoadGraph*>(data_ptr);
- delete g;
+ delete g;
- return FALSE;
+ return FALSE;
}
LoadGraph::LoadGraph(guint type)
- : fontsize(0.0),
- rmargin(0.0),
- indent(0.0),
- n(0),
- type(0),
- speed(0),
- draw_width(0),
- draw_height(0),
- render_counter(0),
- frames_per_unit(0),
- graph_dely(0),
- real_draw_height(0),
- graph_delx(0.0),
- graph_buffer_offset(0),
- main_widget(NULL),
- disp(NULL),
- background(NULL),
- timer_index(0),
- draw(FALSE),
- mem_color_picker(NULL),
- swap_color_picker(NULL)
+ : fontsize(0.0),
+ rmargin(0.0),
+ indent(0.0),
+ n(0),
+ type(0),
+ speed(0),
+ draw_width(0),
+ draw_height(0),
+ render_counter(0),
+ frames_per_unit(0),
+ graph_dely(0),
+ real_draw_height(0),
+ graph_delx(0.0),
+ graph_buffer_offset(0),
+ main_widget(NULL),
+ disp(NULL),
+ background(NULL),
+ timer_index(0),
+ draw(FALSE),
+ mem_color_picker(NULL),
+ swap_color_picker(NULL)
{
- LoadGraph * const g = this;
-
- // FIXME:
- // on configure, g->frames_per_unit = g->draw_width/(LoadGraph::NUM_POINTS);
- // knock FRAMES down to 5 until cairo gets faster
- g->frames_per_unit = 10; // this will be changed but needs initialising
- g->fontsize = 8.0;
- g->rmargin = 3.5 * g->fontsize;
- g->indent = 24.0;
-
- g->type = type;
- switch (type) {
- case LOAD_GRAPH_CPU:
- memset(&this->cpu, 0, sizeof g->cpu);
- g->n = ProcData::get_instance()->config.num_cpus;
-
- for(guint i = 0; i < G_N_ELEMENTS(g->labels.cpu); ++i)
- g->labels.cpu[i] = gtk_label_new(NULL);
-
- break;
-
- case LOAD_GRAPH_MEM:
- g->n = 2;
- g->labels.memory = gtk_label_new(NULL);
- g->labels.swap = gtk_label_new(NULL);
- break;
-
- case LOAD_GRAPH_NET:
- memset(&this->net, 0, sizeof g->net);
- g->n = 2;
- g->net.max = 1;
- g->labels.net_in = gtk_label_new(NULL);
- g->labels.net_in_total = gtk_label_new(NULL);
- g->labels.net_out = gtk_label_new(NULL);
- g->labels.net_out_total = gtk_label_new(NULL);
- break;
- }
-
- g->speed = ProcData::get_instance()->config.graph_update_interval;
-
- g->colors.resize(g->n);
-
- switch (type) {
- case LOAD_GRAPH_CPU:
- memcpy(&g->colors[0], ProcData::get_instance()->config.cpu_color,
- g->n * sizeof g->colors[0]);
- break;
- case LOAD_GRAPH_MEM:
- g->colors[0] = ProcData::get_instance()->config.mem_color;
- g->colors[1] = ProcData::get_instance()->config.swap_color;
- g->mem_color_picker = gsm_color_button_new (&g->colors[0],
- GSMCP_TYPE_PIE);
- g->swap_color_picker = gsm_color_button_new (&g->colors[1],
- GSMCP_TYPE_PIE);
- break;
- case LOAD_GRAPH_NET:
- g->colors[0] = ProcData::get_instance()->config.net_in_color;
- g->colors[1] = ProcData::get_instance()->config.net_out_color;
- break;
- }
-
- g->timer_index = 0;
- g->render_counter = (g->frames_per_unit - 1);
- g->draw = FALSE;
-
- g->main_widget = gtk_vbox_new (FALSE, FALSE);
- gtk_widget_set_size_request(g->main_widget, -1, LoadGraph::GRAPH_MIN_HEIGHT);
- gtk_widget_show (g->main_widget);
-
- g->disp = gtk_drawing_area_new ();
- gtk_widget_show (g->disp);
- g_signal_connect (G_OBJECT (g->disp), "draw",
- G_CALLBACK (load_graph_draw), g);
- g_signal_connect (G_OBJECT(g->disp), "configure_event",
- G_CALLBACK (load_graph_configure), g);
- g_signal_connect (G_OBJECT(g->disp), "destroy",
- G_CALLBACK (load_graph_destroy), g);
-
- gtk_widget_set_events (g->disp, GDK_EXPOSURE_MASK);
-
- gtk_box_pack_start (GTK_BOX (g->main_widget), g->disp, TRUE, TRUE, 0);
-
-
- /* Allocate data in a contiguous block */
- g->data_block = std::vector<float>(g->n * LoadGraph::NUM_POINTS, -1.0f);
-
- for (guint i = 0; i < LoadGraph::NUM_POINTS; ++i)
- g->data[i] = &g->data_block[0] + i * g->n;
-
- gtk_widget_show_all (g->main_widget);
+ LoadGraph * const g = this;
+
+ // FIXME:
+ // on configure, g->frames_per_unit = g->draw_width/(LoadGraph::NUM_POINTS);
+ // knock FRAMES down to 5 until cairo gets faster
+ g->frames_per_unit = 10; // this will be changed but needs initialising
+ g->fontsize = 8.0;
+ g->rmargin = 3.5 * g->fontsize;
+ g->indent = 24.0;
+
+ g->type = type;
+ switch (type) {
+ case LOAD_GRAPH_CPU:
+ memset(&this->cpu, 0, sizeof g->cpu);
+ g->n = ProcData::get_instance()->config.num_cpus;
+
+ for(guint i = 0; i < G_N_ELEMENTS(g->labels.cpu); ++i)
+ g->labels.cpu[i] = gtk_label_new(NULL);
+
+ break;
+
+ case LOAD_GRAPH_MEM:
+ g->n = 2;
+ g->labels.memory = gtk_label_new(NULL);
+ g->labels.swap = gtk_label_new(NULL);
+ break;
+
+ case LOAD_GRAPH_NET:
+ memset(&this->net, 0, sizeof g->net);
+ g->n = 2;
+ g->net.max = 1;
+ g->labels.net_in = gtk_label_new(NULL);
+ g->labels.net_in_total = gtk_label_new(NULL);
+ g->labels.net_out = gtk_label_new(NULL);
+ g->labels.net_out_total = gtk_label_new(NULL);
+ break;
+ }
+
+ g->speed = ProcData::get_instance()->config.graph_update_interval;
+
+ g->colors.resize(g->n);
+
+ switch (type) {
+ case LOAD_GRAPH_CPU:
+ memcpy(&g->colors[0], ProcData::get_instance()->config.cpu_color,
+ g->n * sizeof g->colors[0]);
+ break;
+ case LOAD_GRAPH_MEM:
+ g->colors[0] = ProcData::get_instance()->config.mem_color;
+ g->colors[1] = ProcData::get_instance()->config.swap_color;
+ g->mem_color_picker = gsm_color_button_new (&g->colors[0],
+ GSMCP_TYPE_PIE);
+ g->swap_color_picker = gsm_color_button_new (&g->colors[1],
+ GSMCP_TYPE_PIE);
+ break;
+ case LOAD_GRAPH_NET:
+ g->colors[0] = ProcData::get_instance()->config.net_in_color;
+ g->colors[1] = ProcData::get_instance()->config.net_out_color;
+ break;
+ }
+
+ g->timer_index = 0;
+ g->render_counter = (g->frames_per_unit - 1);
+ g->draw = FALSE;
+
+ g->main_widget = gtk_vbox_new (FALSE, FALSE);
+ gtk_widget_set_size_request(g->main_widget, -1, LoadGraph::GRAPH_MIN_HEIGHT);
+ gtk_widget_show (g->main_widget);
+
+ g->disp = gtk_drawing_area_new ();
+ gtk_widget_show (g->disp);
+ g_signal_connect (G_OBJECT (g->disp), "draw",
+ G_CALLBACK (load_graph_draw), g);
+ g_signal_connect (G_OBJECT(g->disp), "configure_event",
+ G_CALLBACK (load_graph_configure), g);
+ g_signal_connect (G_OBJECT(g->disp), "destroy",
+ G_CALLBACK (load_graph_destroy), g);
+
+ gtk_widget_set_events (g->disp, GDK_EXPOSURE_MASK);
+
+ gtk_box_pack_start (GTK_BOX (g->main_widget), g->disp, TRUE, TRUE, 0);
+
+
+ /* Allocate data in a contiguous block */
+ g->data_block = std::vector<float>(g->n * LoadGraph::NUM_POINTS, -1.0f);
+
+ for (guint i = 0; i < LoadGraph::NUM_POINTS; ++i)
+ g->data[i] = &g->data_block[0] + i * g->n;
+
+ gtk_widget_show_all (g->main_widget);
}
void
load_graph_start (LoadGraph *g)
{
- if(!g->timer_index) {
+ if(!g->timer_index) {
- load_graph_update(g);
+ load_graph_update(g);
- g->timer_index = g_timeout_add (g->speed / g->frames_per_unit,
- load_graph_update,
- g);
- }
+ g->timer_index = g_timeout_add (g->speed / g->frames_per_unit,
+ load_graph_update,
+ g);
+ }
- g->draw = TRUE;
+ g->draw = TRUE;
}
void
load_graph_stop (LoadGraph *g)
{
- /* don't draw anymore, but continue to poll */
- g->draw = FALSE;
+ /* don't draw anymore, but continue to poll */
+ g->draw = FALSE;
}
void
load_graph_change_speed (LoadGraph *g,
- guint new_speed)
+ guint new_speed)
{
- if (g->speed == new_speed)
- return;
+ if (g->speed == new_speed)
+ return;
- g->speed = new_speed;
+ g->speed = new_speed;
- g_assert(g->timer_index);
+ g_assert(g->timer_index);
- if(g->timer_index) {
- g_source_remove (g->timer_index);
- g->timer_index = g_timeout_add (g->speed / g->frames_per_unit,
- load_graph_update,
- g);
- }
+ if(g->timer_index) {
+ g_source_remove (g->timer_index);
+ g->timer_index = g_timeout_add (g->speed / g->frames_per_unit,
+ load_graph_update,
+ g);
+ }
- g->clear_background();
+ g->clear_background();
}
LoadGraphLabels*
load_graph_get_labels (LoadGraph *g)
{
- return &g->labels;
+ return &g->labels;
}
GtkWidget*
load_graph_get_widget (LoadGraph *g)
{
- return g->main_widget;
+ return g->main_widget;
}
GtkWidget*
load_graph_get_mem_color_picker(LoadGraph *g)
{
- return g->mem_color_picker;
+ return g->mem_color_picker;
}
GtkWidget*
load_graph_get_swap_color_picker(LoadGraph *g)
{
- return g->swap_color_picker;
+ return g->swap_color_picker;
}
diff --git a/src/load-graph.h b/src/load-graph.h
index 9b43c86..73c13c3 100644
--- a/src/load-graph.h
+++ b/src/load-graph.h
@@ -6,92 +6,92 @@
enum
{
- LOAD_GRAPH_CPU,
- LOAD_GRAPH_MEM,
- LOAD_GRAPH_NET
+ LOAD_GRAPH_CPU,
+ LOAD_GRAPH_MEM,
+ LOAD_GRAPH_NET
};
enum {
- CPU_TOTAL,
- CPU_USED,
- N_CPU_STATES
+ CPU_TOTAL,
+ CPU_USED,
+ N_CPU_STATES
};
struct LoadGraphLabels
{
- GtkWidget *cpu[GLIBTOP_NCPU];
- GtkWidget *memory;
- GtkWidget *swap;
- GtkWidget *net_in;
- GtkWidget *net_in_total;
- GtkWidget *net_out;
- GtkWidget *net_out_total;
+ GtkWidget *cpu[GLIBTOP_NCPU];
+ GtkWidget *memory;
+ GtkWidget *swap;
+ GtkWidget *net_in;
+ GtkWidget *net_in_total;
+ GtkWidget *net_out;
+ GtkWidget *net_out_total;
};
struct LoadGraph {
- static const unsigned NUM_POINTS = 60 + 2;
- static const unsigned GRAPH_MIN_HEIGHT = 40;
+ static const unsigned NUM_POINTS = 60 + 2;
+ static const unsigned GRAPH_MIN_HEIGHT = 40;
- LoadGraph(guint type);
- ~LoadGraph();
+ LoadGraph(guint type);
+ ~LoadGraph();
- unsigned num_bars() const;
- void clear_background();
+ unsigned num_bars() const;
+ void clear_background();
- double fontsize;
- double rmargin;
- double indent;
+ double fontsize;
+ double rmargin;
+ double indent;
- guint n;
- gint type;
- guint speed;
- guint draw_width, draw_height;
- guint render_counter;
- guint frames_per_unit;
- guint graph_dely;
- guint real_draw_height;
- double graph_delx;
- guint graph_buffer_offset;
+ guint n;
+ gint type;
+ guint speed;
+ guint draw_width, draw_height;
+ guint render_counter;
+ guint frames_per_unit;
+ guint graph_dely;
+ guint real_draw_height;
+ double graph_delx;
+ guint graph_buffer_offset;
- std::vector<GdkColor> colors;
+ std::vector<GdkColor> colors;
- std::vector<float> data_block;
- gfloat* data[NUM_POINTS];
+ std::vector<float> data_block;
+ gfloat* data[NUM_POINTS];
- GtkWidget *main_widget;
- GtkWidget *disp;
+ GtkWidget *main_widget;
+ GtkWidget *disp;
- cairo_surface_t *background;
+ cairo_surface_t *background;
- guint timer_index;
+ guint timer_index;
- gboolean draw;
+ gboolean draw;
- LoadGraphLabels labels;
- GtkWidget *mem_color_picker;
- GtkWidget *swap_color_picker;
+ LoadGraphLabels labels;
+ GtkWidget *mem_color_picker;
+ GtkWidget *swap_color_picker;
- /* union { */
- struct {
- guint now; /* 0 -> current, 1 -> last
- now ^ 1 each time */
- /* times[now], times[now ^ 1] is last */
- guint64 times[2][GLIBTOP_NCPU][N_CPU_STATES];
- } cpu;
+ /* union { */
+ struct {
+ guint now; /* 0 -> current, 1 -> last
+ now ^ 1 each time */
+ /* times[now], times[now ^ 1] is last */
+ guint64 times[2][GLIBTOP_NCPU][N_CPU_STATES];
+ } cpu;
- struct {
- guint64 last_in, last_out;
- GTimeVal time;
- guint64 max;
- unsigned values[NUM_POINTS];
- size_t cur;
- } net;
- /* }; */
+ struct {
+ guint64 last_in, last_out;
+ GTimeVal time;
+ guint64 max;
+ unsigned values[NUM_POINTS];
+ size_t cur;
+ } net;
+ /* }; */
};
@@ -111,7 +111,7 @@ load_graph_stop (LoadGraph *g);
/* Change load graph speed and restart it if it has been previously started */
void
load_graph_change_speed (LoadGraph *g,
- guint new_speed);
+ guint new_speed);
LoadGraphLabels*
load_graph_get_labels (LoadGraph *g) G_GNUC_CONST;
diff --git a/src/lsof.cpp b/src/lsof.cpp
index 7773eff..95685d0 100644
--- a/src/lsof.cpp
+++ b/src/lsof.cpp
@@ -27,207 +27,207 @@ using std::string;
namespace
{
- class Lsof
- {
- Glib::RefPtr<Glib::Regex> re;
-
- bool matches(const string &filename) const
+ class Lsof
{
- return this->re->match(filename);
- }
+ Glib::RefPtr<Glib::Regex> re;
- public:
+ bool matches(const string &filename) const
+ {
+ return this->re->match(filename);
+ }
- Lsof(const string &pattern, bool caseless)
- {
- Glib::RegexCompileFlags flags = static_cast<Glib::RegexCompileFlags>(0);
+ public:
- if (caseless)
- flags |= Glib::REGEX_CASELESS;
+ Lsof(const string &pattern, bool caseless)
+ {
+ Glib::RegexCompileFlags flags = static_cast<Glib::RegexCompileFlags>(0);
- this->re = Glib::Regex::create(pattern, flags);
- }
+ if (caseless)
+ flags |= Glib::REGEX_CASELESS;
+ this->re = Glib::Regex::create(pattern, flags);
+ }
- template<typename OutputIterator>
- void search(const ProcInfo &info, OutputIterator out) const
- {
- glibtop_open_files_entry *entries;
- glibtop_proc_open_files buf;
- entries = glibtop_get_proc_open_files(&buf, info.pid);
+ template<typename OutputIterator>
+ void search(const ProcInfo &info, OutputIterator out) const
+ {
+ glibtop_open_files_entry *entries;
+ glibtop_proc_open_files buf;
- for (unsigned i = 0; i != buf.number; ++i) {
- if (entries[i].type & GLIBTOP_FILE_TYPE_FILE) {
- const string filename(entries[i].info.file.name);
- if (this->matches(filename))
- *out++ = filename;
- }
- }
+ entries = glibtop_get_proc_open_files(&buf, info.pid);
- g_free(entries);
- }
- };
+ for (unsigned i = 0; i != buf.number; ++i) {
+ if (entries[i].type & GLIBTOP_FILE_TYPE_FILE) {
+ const string filename(entries[i].info.file.name);
+ if (this->matches(filename))
+ *out++ = filename;
+ }
+ }
+ g_free(entries);
+ }
+ };
- // GUI Stuff
+ // GUI Stuff
- enum ProcmanLsof {
- PROCMAN_LSOF_COL_PIXBUF,
- PROCMAN_LSOF_COL_PROCESS,
- PROCMAN_LSOF_COL_PID,
- PROCMAN_LSOF_COL_FILENAME,
- PROCMAN_LSOF_NCOLS
- };
+ enum ProcmanLsof {
+ PROCMAN_LSOF_COL_PIXBUF,
+ PROCMAN_LSOF_COL_PROCESS,
+ PROCMAN_LSOF_COL_PID,
+ PROCMAN_LSOF_COL_FILENAME,
+ PROCMAN_LSOF_NCOLS
+ };
- struct GUI {
- GtkListStore *model;
- GtkEntry *entry;
- GtkWindow *window;
- GtkLabel *count;
- ProcData *procdata;
- bool case_insensitive;
+ struct GUI {
+ GtkListStore *model;
+ GtkEntry *entry;
+ GtkWindow *window;
+ GtkLabel *count;
+ ProcData *procdata;
+ bool case_insensitive;
- GUI()
- {
- procman_debug("New Lsof GUI %p", this);
- }
+ GUI()
+ {
+ procman_debug("New Lsof GUI %p", this);
+ }
- ~GUI()
- {
- procman_debug("Destroying Lsof GUI %p", this);
- }
+ ~GUI()
+ {
+ procman_debug("Destroying Lsof GUI %p", this);
+ }
- void clear_results()
- {
- gtk_list_store_clear(this->model);
- gtk_label_set_text(this->count, "");
- }
+ void clear_results()
+ {
+ gtk_list_store_clear(this->model);
+ gtk_label_set_text(this->count, "");
+ }
- void clear()
- {
- this->clear_results();
- gtk_entry_set_text(this->entry, "");
- }
+ void clear()
+ {
+ this->clear_results();
+ gtk_entry_set_text(this->entry, "");
+ }
- void display_regex_error(const Glib::RegexError& error)
- {
- const char * msg = _("<b>Error</b>\n"
- "'%s' is not a valid Perl regular expression.\n"
- "%s");
- std::string message = make_string(g_strdup_printf(msg, this->pattern().c_str(), error.what().c_str()));
- Gtk::MessageDialog dialog(message,
- true, // use markup
- Gtk::MESSAGE_ERROR,
- Gtk::BUTTONS_OK,
- true); // modal
- dialog.run();
- }
+ void display_regex_error(const Glib::RegexError& error)
+ {
+ const char * msg = _("<b>Error</b>\n"
+ "'%s' is not a valid Perl regular expression.\n"
+ "%s");
+ std::string message = make_string(g_strdup_printf(msg, this->pattern().c_str(), error.what().c_str()));
+ Gtk::MessageDialog dialog(message,
+ true, // use markup
+ Gtk::MESSAGE_ERROR,
+ Gtk::BUTTONS_OK,
+ true); // modal
+ dialog.run();
+ }
- void update_count(unsigned count)
- {
- string s = static_cast<std::ostringstream&>(std::ostringstream() << count).str();
- gtk_label_set_text(this->count, s.c_str());
- }
+ void update_count(unsigned count)
+ {
+ string s = static_cast<std::ostringstream&>(std::ostringstream() << count).str();
+ gtk_label_set_text(this->count, s.c_str());
+ }
- string pattern() const
- {
- return gtk_entry_get_text(this->entry);
- }
+ string pattern() const
+ {
+ return gtk_entry_get_text(this->entry);
+ }
- void search()
- {
- typedef std::set<string> MatchSet;
- typedef MatchSet::const_iterator iterator;
- this->clear_results();
+ void search()
+ {
+ typedef std::set<string> MatchSet;
+ typedef MatchSet::const_iterator iterator;
+ this->clear_results();
- try {
- Lsof lsof(this->pattern(), this->case_insensitive);
- unsigned count = 0;
+ try {
+ Lsof lsof(this->pattern(), this->case_insensitive);
- for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it) {
- const ProcInfo &info(*it->second);
+ unsigned count = 0;
- MatchSet matches;
- lsof.search(info, std::inserter(matches, matches.begin()));
- count += matches.size();
+ for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it) {
+ const ProcInfo &info(*it->second);
- for (iterator it(matches.begin()), end(matches.end()); it != end; ++it) {
- GtkTreeIter file;
- gtk_list_store_append(this->model, &file);
- gtk_list_store_set(this->model, &file,
- PROCMAN_LSOF_COL_PIXBUF, info.pixbuf->gobj(),
- PROCMAN_LSOF_COL_PROCESS, info.name,
- PROCMAN_LSOF_COL_PID, info.pid,
- PROCMAN_LSOF_COL_FILENAME, it->c_str(),
- -1);
- }
- }
+ MatchSet matches;
+ lsof.search(info, std::inserter(matches, matches.begin()));
+ count += matches.size();
- this->update_count(count);
- }
- catch (Glib::RegexError& error) {
- this->display_regex_error(error);
- }
- }
+ for (iterator it(matches.begin()), end(matches.end()); it != end; ++it) {
+ GtkTreeIter file;
+ gtk_list_store_append(this->model, &file);
+ gtk_list_store_set(this->model, &file,
+ PROCMAN_LSOF_COL_PIXBUF, info.pixbuf->gobj(),
+ PROCMAN_LSOF_COL_PROCESS, info.name,
+ PROCMAN_LSOF_COL_PID, info.pid,
+ PROCMAN_LSOF_COL_FILENAME, it->c_str(),
+ -1);
+ }
+ }
+ this->update_count(count);
+ }
+ catch (Glib::RegexError& error) {
+ this->display_regex_error(error);
+ }
+ }
- static void search_button_clicked(GtkButton *, gpointer data)
- {
- static_cast<GUI*>(data)->search();
- }
+ static void search_button_clicked(GtkButton *, gpointer data)
+ {
+ static_cast<GUI*>(data)->search();
+ }
- static void search_entry_activate(GtkEntry *, gpointer data)
- {
- static_cast<GUI*>(data)->search();
- }
+ static void search_entry_activate(GtkEntry *, gpointer data)
+ {
+ static_cast<GUI*>(data)->search();
+ }
- static void clear_button_clicked(GtkButton *, gpointer data)
- {
- static_cast<GUI*>(data)->clear();
- }
+ static void clear_button_clicked(GtkButton *, gpointer data)
+ {
+ static_cast<GUI*>(data)->clear();
+ }
- static void close_button_clicked(GtkButton *, gpointer data)
- {
- GUI *gui = static_cast<GUI*>(data);
- gtk_widget_destroy(GTK_WIDGET(gui->window));
- delete gui;
- }
+ static void close_button_clicked(GtkButton *, gpointer data)
+ {
+ GUI *gui = static_cast<GUI*>(data);
+ gtk_widget_destroy(GTK_WIDGET(gui->window));
+ delete gui;
+ }
- static void case_button_toggled(GtkToggleButton *button, gpointer data)
- {
- bool state = gtk_toggle_button_get_active(button);
- static_cast<GUI*>(data)->case_insensitive = state;
- }
+ static void case_button_toggled(GtkToggleButton *button, gpointer data)
+ {
+ bool state = gtk_toggle_button_get_active(button);
+ static_cast<GUI*>(data)->case_insensitive = state;
+ }
- static gboolean window_delete_event(GtkWidget *, GdkEvent *, gpointer data)
- {
- delete static_cast<GUI*>(data);
- return FALSE;
- }
- };
+ static gboolean window_delete_event(GtkWidget *, GdkEvent *, gpointer data)
+ {
+ delete static_cast<GUI*>(data);
+ return FALSE;
+ }
+
+ };
}
@@ -235,173 +235,173 @@ namespace
void procman_lsof(ProcData *procdata)
{
- GtkListStore *model = \
- gtk_list_store_new(PROCMAN_LSOF_NCOLS,
- GDK_TYPE_PIXBUF, // PROCMAN_LSOF_COL_PIXBUF
- G_TYPE_STRING, // PROCMAN_LSOF_COL_PROCESS
- G_TYPE_UINT, // PROCMAN_LSOF_COL_PID
- G_TYPE_STRING // PROCMAN_LSOF_COL_FILENAME
- );
-
- GtkWidget *tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
- g_object_unref(model);
- gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
-
-
- GtkTreeViewColumn *column;
- GtkCellRenderer *renderer;
-
- // PIXBUF / PROCESS
-
- column = gtk_tree_view_column_new();
-
- renderer = gtk_cell_renderer_pixbuf_new();
- gtk_tree_view_column_pack_start(column, renderer, FALSE);
- gtk_tree_view_column_set_attributes(column, renderer,
- "pixbuf", PROCMAN_LSOF_COL_PIXBUF,
- NULL);
-
- renderer = gtk_cell_renderer_text_new();
- gtk_tree_view_column_pack_start(column, renderer, FALSE);
- gtk_tree_view_column_set_attributes(column, renderer,
- "text", PROCMAN_LSOF_COL_PROCESS,
- NULL);
+ GtkListStore *model = \
+ gtk_list_store_new(PROCMAN_LSOF_NCOLS,
+ GDK_TYPE_PIXBUF, // PROCMAN_LSOF_COL_PIXBUF
+ G_TYPE_STRING, // PROCMAN_LSOF_COL_PROCESS
+ G_TYPE_UINT, // PROCMAN_LSOF_COL_PID
+ G_TYPE_STRING // PROCMAN_LSOF_COL_FILENAME
+ );
+
+ GtkWidget *tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
+ g_object_unref(model);
+ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
+
+
+ GtkTreeViewColumn *column;
+ GtkCellRenderer *renderer;
+
+ // PIXBUF / PROCESS
+
+ column = gtk_tree_view_column_new();
+
+ renderer = gtk_cell_renderer_pixbuf_new();
+ gtk_tree_view_column_pack_start(column, renderer, FALSE);
+ gtk_tree_view_column_set_attributes(column, renderer,
+ "pixbuf", PROCMAN_LSOF_COL_PIXBUF,
+ NULL);
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_tree_view_column_pack_start(column, renderer, FALSE);
+ gtk_tree_view_column_set_attributes(column, renderer,
+ "text", PROCMAN_LSOF_COL_PROCESS,
+ NULL);
- gtk_tree_view_column_set_title(column, _("Process"));
- gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_PROCESS);
- gtk_tree_view_column_set_resizable(column, TRUE);
- gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
- gtk_tree_view_column_set_min_width(column, 10);
- gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
- gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), PROCMAN_LSOF_COL_PROCESS,
- GTK_SORT_ASCENDING);
-
-
- // PID
- renderer = gtk_cell_renderer_text_new();
- column = gtk_tree_view_column_new_with_attributes(_("PID"), renderer,
- "text", PROCMAN_LSOF_COL_PID,
- NULL);
- gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_PID);
- gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
- gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
-
-
- // FILENAME
- renderer = gtk_cell_renderer_text_new();
- column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer,
- "text", PROCMAN_LSOF_COL_FILENAME,
- NULL);
- gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_FILENAME);
- gtk_tree_view_column_set_resizable(column, TRUE);
- gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
- gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
-
-
- GtkWidget *dialog; /* = gtk_dialog_new_with_buttons(_("Search for Open Files"), NULL,
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
- NULL); */
- dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(procdata->app));
- gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
- // gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
- gtk_window_set_title(GTK_WINDOW(dialog), _("Search for Open Files"));
-
- // g_signal_connect(G_OBJECT(dialog), "response",
- // G_CALLBACK(close_dialog), NULL);
- gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE);
- gtk_window_set_default_size(GTK_WINDOW(dialog), 575, 400);
- gtk_container_set_border_width(GTK_CONTAINER(dialog), 12);
- GtkWidget *mainbox = gtk_vbox_new(FALSE, 12);
- gtk_container_add(GTK_CONTAINER(dialog), mainbox);
- gtk_box_set_spacing(GTK_BOX(mainbox), 6);
-
-
- // Label, entry and search button
-
- GtkWidget *hbox1 = gtk_hbox_new(FALSE, 12);
- gtk_box_pack_start(GTK_BOX(mainbox), hbox1, FALSE, FALSE, 0);
-
- GtkWidget *image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_DIALOG);
- gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0);
-
-
- GtkWidget *vbox2 = gtk_vbox_new(FALSE, 12);
- gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
-
-
- GtkWidget *hbox = gtk_hbox_new(FALSE, 12);
- gtk_box_pack_start(GTK_BOX(vbox2), hbox, TRUE, TRUE, 0);
- GtkWidget *label = gtk_label_new_with_mnemonic(_("_Name contains:"));
- gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
- GtkWidget *entry = gtk_entry_new();
-
- // entry = sexy_icon_entry_new();
- // sexy_icon_entry_add_clear_button(SEXY_ICON_ENTRY(entry));
- // GtkWidget *icon = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
- // sexy_icon_entry_set_icon(SEXY_ICON_ENTRY(entry), SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE(icon));
-
- gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
- GtkWidget *search_button = gtk_button_new_from_stock(GTK_STOCK_FIND);
- gtk_box_pack_start(GTK_BOX(hbox), search_button, FALSE, FALSE, 0);
- GtkWidget *clear_button = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
- gtk_box_pack_start(GTK_BOX(hbox), clear_button, FALSE, FALSE, 0);
-
-
- GtkWidget *case_button = gtk_check_button_new_with_mnemonic(_("Case insensitive matching"));
- GtkWidget *hbox3 = gtk_hbox_new(FALSE, 12);
- gtk_box_pack_start(GTK_BOX(hbox3), case_button, FALSE, FALSE, 0);
- gtk_box_pack_start(GTK_BOX(vbox2), hbox3, FALSE, FALSE, 0);
-
-
- GtkWidget *results_box = gtk_hbox_new(FALSE, 12);
- gtk_box_pack_start(GTK_BOX(mainbox), results_box, FALSE, FALSE, 0);
- GtkWidget *results_label = gtk_label_new_with_mnemonic(_("S_earch results:"));
- gtk_box_pack_start(GTK_BOX(results_box), results_label, FALSE, FALSE, 0);
- GtkWidget *count_label = gtk_label_new(NULL);
- gtk_box_pack_end(GTK_BOX(results_box), count_label, FALSE, FALSE, 0);
-
-
-
-
- // Scrolled TreeView
- GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
- gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
- gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
- GTK_SHADOW_IN);
- gtk_container_add(GTK_CONTAINER(scrolled), tree);
- gtk_box_pack_start(GTK_BOX(mainbox), scrolled, TRUE, TRUE, 0);
-
- GtkWidget *bottom_box = gtk_hbox_new(FALSE, 12);
- GtkWidget *close_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
- gtk_box_pack_start(GTK_BOX(mainbox), bottom_box, FALSE, FALSE, 0);
- gtk_box_pack_end(GTK_BOX(bottom_box), close_button, FALSE, FALSE, 0);
-
-
- GUI *gui = new GUI; // wil be deleted by the close button or delete-event
- gui->procdata = procdata;
- gui->model = model;
- gui->window = GTK_WINDOW(dialog);
- gui->entry = GTK_ENTRY(entry);
- gui->count = GTK_LABEL(count_label);
-
- g_signal_connect(G_OBJECT(entry), "activate",
- G_CALLBACK(GUI::search_entry_activate), gui);
- g_signal_connect(G_OBJECT(clear_button), "clicked",
- G_CALLBACK(GUI::clear_button_clicked), gui);
- g_signal_connect(G_OBJECT(search_button), "clicked",
- G_CALLBACK(GUI::search_button_clicked), gui);
- g_signal_connect(G_OBJECT(close_button), "clicked",
- G_CALLBACK(GUI::close_button_clicked), gui);
- g_signal_connect(G_OBJECT(case_button), "toggled",
- G_CALLBACK(GUI::case_button_toggled), gui);
- g_signal_connect(G_OBJECT(dialog), "delete-event",
- G_CALLBACK(GUI::window_delete_event), gui);
+ gtk_tree_view_column_set_title(column, _("Process"));
+ gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_PROCESS);
+ gtk_tree_view_column_set_resizable(column, TRUE);
+ gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
+ gtk_tree_view_column_set_min_width(column, 10);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+ gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), PROCMAN_LSOF_COL_PROCESS,
+ GTK_SORT_ASCENDING);
+
+
+ // PID
+ renderer = gtk_cell_renderer_text_new();
+ column = gtk_tree_view_column_new_with_attributes(_("PID"), renderer,
+ "text", PROCMAN_LSOF_COL_PID,
+ NULL);
+ gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_PID);
+ gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+
+
+ // FILENAME
+ renderer = gtk_cell_renderer_text_new();
+ column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer,
+ "text", PROCMAN_LSOF_COL_FILENAME,
+ NULL);
+ gtk_tree_view_column_set_sort_column_id(column, PROCMAN_LSOF_COL_FILENAME);
+ gtk_tree_view_column_set_resizable(column, TRUE);
+ gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+
+
+ GtkWidget *dialog; /* = gtk_dialog_new_with_buttons(_("Search for Open Files"), NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+ NULL); */
+ dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(procdata->app));
+ gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
+ // gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
+ gtk_window_set_title(GTK_WINDOW(dialog), _("Search for Open Files"));
+
+ // g_signal_connect(G_OBJECT(dialog), "response",
+ // G_CALLBACK(close_dialog), NULL);
+ gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE);
+ gtk_window_set_default_size(GTK_WINDOW(dialog), 575, 400);
+ gtk_container_set_border_width(GTK_CONTAINER(dialog), 12);
+ GtkWidget *mainbox = gtk_vbox_new(FALSE, 12);
+ gtk_container_add(GTK_CONTAINER(dialog), mainbox);
+ gtk_box_set_spacing(GTK_BOX(mainbox), 6);
+
+
+ // Label, entry and search button
+
+ GtkWidget *hbox1 = gtk_hbox_new(FALSE, 12);
+ gtk_box_pack_start(GTK_BOX(mainbox), hbox1, FALSE, FALSE, 0);
+
+ GtkWidget *image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_DIALOG);
+ gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0);
+
+
+ GtkWidget *vbox2 = gtk_vbox_new(FALSE, 12);
+ gtk_box_pack_start(GTK_BOX(hbox1), vbox2, TRUE, TRUE, 0);
+
+
+ GtkWidget *hbox = gtk_hbox_new(FALSE, 12);
+ gtk_box_pack_start(GTK_BOX(vbox2), hbox, TRUE, TRUE, 0);
+ GtkWidget *label = gtk_label_new_with_mnemonic(_("_Name contains:"));
+ gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
+ GtkWidget *entry = gtk_entry_new();
+
+ // entry = sexy_icon_entry_new();
+ // sexy_icon_entry_add_clear_button(SEXY_ICON_ENTRY(entry));
+ // GtkWidget *icon = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
+ // sexy_icon_entry_set_icon(SEXY_ICON_ENTRY(entry), SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE(icon));
+
+ gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0);
+ GtkWidget *search_button = gtk_button_new_from_stock(GTK_STOCK_FIND);
+ gtk_box_pack_start(GTK_BOX(hbox), search_button, FALSE, FALSE, 0);
+ GtkWidget *clear_button = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
+ gtk_box_pack_start(GTK_BOX(hbox), clear_button, FALSE, FALSE, 0);
+
+
+ GtkWidget *case_button = gtk_check_button_new_with_mnemonic(_("Case insensitive matching"));
+ GtkWidget *hbox3 = gtk_hbox_new(FALSE, 12);
+ gtk_box_pack_start(GTK_BOX(hbox3), case_button, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(vbox2), hbox3, FALSE, FALSE, 0);
+
+
+ GtkWidget *results_box = gtk_hbox_new(FALSE, 12);
+ gtk_box_pack_start(GTK_BOX(mainbox), results_box, FALSE, FALSE, 0);
+ GtkWidget *results_label = gtk_label_new_with_mnemonic(_("S_earch results:"));
+ gtk_box_pack_start(GTK_BOX(results_box), results_label, FALSE, FALSE, 0);
+ GtkWidget *count_label = gtk_label_new(NULL);
+ gtk_box_pack_end(GTK_BOX(results_box), count_label, FALSE, FALSE, 0);
+
+
+
+
+ // Scrolled TreeView
+ GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
+ GTK_SHADOW_IN);
+ gtk_container_add(GTK_CONTAINER(scrolled), tree);
+ gtk_box_pack_start(GTK_BOX(mainbox), scrolled, TRUE, TRUE, 0);
+
+ GtkWidget *bottom_box = gtk_hbox_new(FALSE, 12);
+ GtkWidget *close_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
+ gtk_box_pack_start(GTK_BOX(mainbox), bottom_box, FALSE, FALSE, 0);
+ gtk_box_pack_end(GTK_BOX(bottom_box), close_button, FALSE, FALSE, 0);
+
+
+ GUI *gui = new GUI; // wil be deleted by the close button or delete-event
+ gui->procdata = procdata;
+ gui->model = model;
+ gui->window = GTK_WINDOW(dialog);
+ gui->entry = GTK_ENTRY(entry);
+ gui->count = GTK_LABEL(count_label);
+
+ g_signal_connect(G_OBJECT(entry), "activate",
+ G_CALLBACK(GUI::search_entry_activate), gui);
+ g_signal_connect(G_OBJECT(clear_button), "clicked",
+ G_CALLBACK(GUI::clear_button_clicked), gui);
+ g_signal_connect(G_OBJECT(search_button), "clicked",
+ G_CALLBACK(GUI::search_button_clicked), gui);
+ g_signal_connect(G_OBJECT(close_button), "clicked",
+ G_CALLBACK(GUI::close_button_clicked), gui);
+ g_signal_connect(G_OBJECT(case_button), "toggled",
+ G_CALLBACK(GUI::case_button_toggled), gui);
+ g_signal_connect(G_OBJECT(dialog), "delete-event",
+ G_CALLBACK(GUI::window_delete_event), gui);
- gtk_widget_show_all(dialog);
+ gtk_widget_show_all(dialog);
}
diff --git a/src/memmaps.cpp b/src/memmaps.cpp
index 3b64eb1..cfa69cc 100644
--- a/src/memmaps.cpp
+++ b/src/memmaps.cpp
@@ -23,172 +23,172 @@ using std::string;
/* be careful with this enum, you could break the column names */
enum
{
- MMAP_COL_FILENAME,
- MMAP_COL_VMSTART,
- MMAP_COL_VMEND,
- MMAP_COL_VMSZ,
- MMAP_COL_FLAGS,
- MMAP_COL_VMOFFSET,
- MMAP_COL_PRIVATE_CLEAN,
- MMAP_COL_PRIVATE_DIRTY,
- MMAP_COL_SHARED_CLEAN,
- MMAP_COL_SHARED_DIRTY,
- MMAP_COL_DEVICE,
- MMAP_COL_INODE,
- MMAP_COL_MAX
+ MMAP_COL_FILENAME,
+ MMAP_COL_VMSTART,
+ MMAP_COL_VMEND,
+ MMAP_COL_VMSZ,
+ MMAP_COL_FLAGS,
+ MMAP_COL_VMOFFSET,
+ MMAP_COL_PRIVATE_CLEAN,
+ MMAP_COL_PRIVATE_DIRTY,
+ MMAP_COL_SHARED_CLEAN,
+ MMAP_COL_SHARED_DIRTY,
+ MMAP_COL_DEVICE,
+ MMAP_COL_INODE,
+ MMAP_COL_MAX
};
namespace
{
- class OffsetFormater
- {
- string format;
+ class OffsetFormater
+ {
+ string format;
- public:
+ public:
- void set(const glibtop_map_entry &last_map)
- {
- this->format = (last_map.end <= G_MAXUINT32) ? "%08" G_GINT64_MODIFIER "x" : "%016" G_GINT64_MODIFIER "x";
- }
+ void set(const glibtop_map_entry &last_map)
+ {
+ this->format = (last_map.end <= G_MAXUINT32) ? "%08" G_GINT64_MODIFIER "x" : "%016" G_GINT64_MODIFIER "x";
+ }
- string operator()(guint64 v) const
- {
- char buffer[17];
- g_snprintf(buffer, sizeof buffer, this->format.c_str(), v);
- return buffer;
- }
- };
+ string operator()(guint64 v) const
+ {
+ char buffer[17];
+ g_snprintf(buffer, sizeof buffer, this->format.c_str(), v);
+ return buffer;
+ }
+ };
#if 0
- struct ColumnState
- {
- unsigned visible;
- unsigned id;
- unsigned width;
-
- int pack() const
+ struct ColumnState
{
- unsigned p = 0;
- p |= (this->visible & 0x0001) << 24;
- p |= (this->id & 0x00ff) << 16;
- p |= (this->width & 0xffff);
- return p;
- }
+ unsigned visible;
+ unsigned id;
+ unsigned width;
- void unpack(int i)
- {
- this->visible = 0x0001 & (i >> 24);
- this->id = 0x00ff & (i >> 16);
- this->width = 0xffff & i;
- }
- };
+ int pack() const
+ {
+ unsigned p = 0;
+ p |= (this->visible & 0x0001) << 24;
+ p |= (this->id & 0x00ff) << 16;
+ p |= (this->width & 0xffff);
+ return p;
+ }
+ void unpack(int i)
+ {
+ this->visible = 0x0001 & (i >> 24);
+ this->id = 0x00ff & (i >> 16);
+ this->width = 0xffff & i;
+ }
+ };
-#endif
-
+#endif
- class InodeDevices
- {
- typedef std::map<guint16, string> Map;
- Map devices;
- public:
- void update()
+ class InodeDevices
{
- this->devices.clear();
+ typedef std::map<guint16, string> Map;
+ Map devices;
- glibtop_mountlist list;
- glibtop_mountentry *entries = glibtop_get_mountlist(&list, 1);
+ public:
- for (unsigned i = 0; i != list.number; ++i) {
- struct stat buf;
+ void update()
+ {
+ this->devices.clear();
- if (stat(entries[i].devname, &buf) != -1)
- this->devices[buf.st_rdev] = entries[i].devname;
- }
+ glibtop_mountlist list;
+ glibtop_mountentry *entries = glibtop_get_mountlist(&list, 1);
- g_free(entries);
- }
+ for (unsigned i = 0; i != list.number; ++i) {
+ struct stat buf;
- string get(guint64 dev64)
- {
- if (dev64 == 0)
- return "";
+ if (stat(entries[i].devname, &buf) != -1)
+ this->devices[buf.st_rdev] = entries[i].devname;
+ }
- guint16 dev = dev64 & 0xffff;
+ g_free(entries);
+ }
- if (dev != dev64)
- g_warning("weird device %" G_GINT64_MODIFIER "x", dev64);
+ string get(guint64 dev64)
+ {
+ if (dev64 == 0)
+ return "";
- Map::iterator it(this->devices.find(dev));
+ guint16 dev = dev64 & 0xffff;
- if (it != this->devices.end())
- return it->second;
+ if (dev != dev64)
+ g_warning("weird device %" G_GINT64_MODIFIER "x", dev64);
- guint8 major, minor;
- major = dev >> 8;
- minor = dev;
+ Map::iterator it(this->devices.find(dev));
- std::ostringstream out;
- out << std::hex
- << std::setfill('0')
- << std::setw(2) << unsigned(major)
- << ':'
- << std::setw(2) << unsigned(minor);
+ if (it != this->devices.end())
+ return it->second;
- this->devices[dev] = out.str();
- return out.str();
- }
- };
+ guint8 major, minor;
+ major = dev >> 8;
+ minor = dev;
+ std::ostringstream out;
+ out << std::hex
+ << std::setfill('0')
+ << std::setw(2) << unsigned(major)
+ << ':'
+ << std::setw(2) << unsigned(minor);
- class MemMapsData
- {
- public:
- guint timer;
- GtkWidget *tree;
- GSettings *settings;
- ProcInfo *info;
- OffsetFormater format;
- mutable InodeDevices devices;
- const char * const schema;
-
- MemMapsData(GtkWidget *a_tree, GSettings *a_settings)
- : tree(a_tree),
- settings(a_settings),
- schema("memmapstree")
- {
- procman_get_tree_state(this->settings, this->tree, this->schema);
- }
+ this->devices[dev] = out.str();
+ return out.str();
+ }
+ };
- ~MemMapsData()
+
+ class MemMapsData
{
- procman_save_tree_state(this->settings, this->tree, this->schema);
- }
- };
+ public:
+ guint timer;
+ GtkWidget *tree;
+ GSettings *settings;
+ ProcInfo *info;
+ OffsetFormater format;
+ mutable InodeDevices devices;
+ const char * const schema;
+
+ MemMapsData(GtkWidget *a_tree, GSettings *a_settings)
+ : tree(a_tree),
+ settings(a_settings),
+ schema("memmapstree")
+ {
+ procman_get_tree_state(this->settings, this->tree, this->schema);
+ }
+
+ ~MemMapsData()
+ {
+ procman_save_tree_state(this->settings, this->tree, this->schema);
+ }
+ };
}
struct glibtop_map_entry_cmp
{
- bool operator()(const glibtop_map_entry &a, const guint64 start) const
- {
- return a.start < start;
- }
+ bool operator()(const glibtop_map_entry &a, const guint64 start) const
+ {
+ return a.start < start;
+ }
- bool operator()(const guint64 &start, const glibtop_map_entry &a) const
- {
- return not (*this)(a, start);
- }
+ bool operator()(const guint64 &start, const glibtop_map_entry &a) const
+ {
+ return not (*this)(a, start);
+ }
};
@@ -196,41 +196,41 @@ struct glibtop_map_entry_cmp
static void
update_row(GtkTreeModel *model, GtkTreeIter &row, const MemMapsData &mm, const glibtop_map_entry *memmaps)
{
- guint64 size;
- string filename, device;
- string vmstart, vmend, vmoffset;
- char flags[5] = "----";
-
- size = memmaps->end - memmaps->start;
-
- if(memmaps->perm & GLIBTOP_MAP_PERM_READ) flags [0] = 'r';
- if(memmaps->perm & GLIBTOP_MAP_PERM_WRITE) flags [1] = 'w';
- if(memmaps->perm & GLIBTOP_MAP_PERM_EXECUTE) flags [2] = 'x';
- if(memmaps->perm & GLIBTOP_MAP_PERM_SHARED) flags [3] = 's';
- if(memmaps->perm & GLIBTOP_MAP_PERM_PRIVATE) flags [3] = 'p';
-
- if (memmaps->flags & (1 << GLIBTOP_MAP_ENTRY_FILENAME))
- filename = memmaps->filename;
-
- vmstart = mm.format(memmaps->start);
- vmend = mm.format(memmaps->end);
- vmoffset = mm.format(memmaps->offset);
- device = mm.devices.get(memmaps->device);
-
- gtk_list_store_set (GTK_LIST_STORE (model), &row,
- MMAP_COL_FILENAME, filename.c_str(),
- MMAP_COL_VMSTART, vmstart.c_str(),
- MMAP_COL_VMEND, vmend.c_str(),
- MMAP_COL_VMSZ, size,
- MMAP_COL_FLAGS, flags,
- MMAP_COL_VMOFFSET, vmoffset.c_str(),
- MMAP_COL_PRIVATE_CLEAN, memmaps->private_clean,
- MMAP_COL_PRIVATE_DIRTY, memmaps->private_dirty,
- MMAP_COL_SHARED_CLEAN, memmaps->shared_clean,
- MMAP_COL_SHARED_DIRTY, memmaps->shared_dirty,
- MMAP_COL_DEVICE, device.c_str(),
- MMAP_COL_INODE, memmaps->inode,
- -1);
+ guint64 size;
+ string filename, device;
+ string vmstart, vmend, vmoffset;
+ char flags[5] = "----";
+
+ size = memmaps->end - memmaps->start;
+
+ if(memmaps->perm & GLIBTOP_MAP_PERM_READ) flags [0] = 'r';
+ if(memmaps->perm & GLIBTOP_MAP_PERM_WRITE) flags [1] = 'w';
+ if(memmaps->perm & GLIBTOP_MAP_PERM_EXECUTE) flags [2] = 'x';
+ if(memmaps->perm & GLIBTOP_MAP_PERM_SHARED) flags [3] = 's';
+ if(memmaps->perm & GLIBTOP_MAP_PERM_PRIVATE) flags [3] = 'p';
+
+ if (memmaps->flags & (1 << GLIBTOP_MAP_ENTRY_FILENAME))
+ filename = memmaps->filename;
+
+ vmstart = mm.format(memmaps->start);
+ vmend = mm.format(memmaps->end);
+ vmoffset = mm.format(memmaps->offset);
+ device = mm.devices.get(memmaps->device);
+
+ gtk_list_store_set (GTK_LIST_STORE (model), &row,
+ MMAP_COL_FILENAME, filename.c_str(),
+ MMAP_COL_VMSTART, vmstart.c_str(),
+ MMAP_COL_VMEND, vmend.c_str(),
+ MMAP_COL_VMSZ, size,
+ MMAP_COL_FLAGS, flags,
+ MMAP_COL_VMOFFSET, vmoffset.c_str(),
+ MMAP_COL_PRIVATE_CLEAN, memmaps->private_clean,
+ MMAP_COL_PRIVATE_DIRTY, memmaps->private_dirty,
+ MMAP_COL_SHARED_CLEAN, memmaps->shared_clean,
+ MMAP_COL_SHARED_DIRTY, memmaps->shared_dirty,
+ MMAP_COL_DEVICE, device.c_str(),
+ MMAP_COL_INODE, memmaps->inode,
+ -1);
}
@@ -239,79 +239,79 @@ update_row(GtkTreeModel *model, GtkTreeIter &row, const MemMapsData &mm, const g
static void
update_memmaps_dialog (MemMapsData *mmdata)
{
- GtkTreeModel *model;
- glibtop_map_entry *memmaps;
- glibtop_proc_map procmap;
-
- memmaps = glibtop_get_proc_map (&procmap, mmdata->info->pid);
- /* process has disappeared */
- if(!memmaps or procmap.number == 0) return;
-
- mmdata->format.set(memmaps[procmap.number - 1]);
-
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (mmdata->tree));
-
- GtkTreeIter iter;
-
- typedef std::map<guint64, GtkTreeIter> IterCache;
- IterCache iter_cache;
-
- /*
- removes the old maps and
- also fills a cache of start -> iter in order to speed
- up add
- */
-
- if (gtk_tree_model_get_iter_first(model, &iter)) {
- while (true) {
- char *vmstart = 0;
- guint64 start;
- gtk_tree_model_get(model, &iter,
- MMAP_COL_VMSTART, &vmstart,
- -1);
-
- try {
- std::istringstream(vmstart) >> std::hex >> start;
- } catch (std::logic_error &e) {
- g_warning("Could not parse %s", vmstart);
- start = 0;
- }
-
- g_free(vmstart);
-
- bool found = std::binary_search(memmaps, memmaps + procmap.number,
- start, glibtop_map_entry_cmp());
-
- if (found) {
- iter_cache[start] = iter;
- if (!gtk_tree_model_iter_next(model, &iter))
- break;
- } else {
- if (!gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
- break;
- }
- }
- }
-
- mmdata->devices.update();
-
- /*
- add the new maps
- */
-
- for (guint i = 0; i != procmap.number; i++) {
- GtkTreeIter iter;
- IterCache::iterator it(iter_cache.find(memmaps[i].start));
-
- if (it != iter_cache.end())
- iter = it->second;
- else
- gtk_list_store_prepend(GTK_LIST_STORE(model), &iter);
-
- update_row(model, iter, *mmdata, &memmaps[i]);
- }
-
- g_free (memmaps);
+ GtkTreeModel *model;
+ glibtop_map_entry *memmaps;
+ glibtop_proc_map procmap;
+
+ memmaps = glibtop_get_proc_map (&procmap, mmdata->info->pid);
+ /* process has disappeared */
+ if(!memmaps or procmap.number == 0) return;
+
+ mmdata->format.set(memmaps[procmap.number - 1]);
+
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (mmdata->tree));
+
+ GtkTreeIter iter;
+
+ typedef std::map<guint64, GtkTreeIter> IterCache;
+ IterCache iter_cache;
+
+ /*
+ removes the old maps and
+ also fills a cache of start -> iter in order to speed
+ up add
+ */
+
+ if (gtk_tree_model_get_iter_first(model, &iter)) {
+ while (true) {
+ char *vmstart = 0;
+ guint64 start;
+ gtk_tree_model_get(model, &iter,
+ MMAP_COL_VMSTART, &vmstart,
+ -1);
+
+ try {
+ std::istringstream(vmstart) >> std::hex >> start;
+ } catch (std::logic_error &e) {
+ g_warning("Could not parse %s", vmstart);
+ start = 0;
+ }
+
+ g_free(vmstart);
+
+ bool found = std::binary_search(memmaps, memmaps + procmap.number,
+ start, glibtop_map_entry_cmp());
+
+ if (found) {
+ iter_cache[start] = iter;
+ if (!gtk_tree_model_iter_next(model, &iter))
+ break;
+ } else {
+ if (!gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
+ break;
+ }
+ }
+ }
+
+ mmdata->devices.update();
+
+ /*
+ add the new maps
+ */
+
+ for (guint i = 0; i != procmap.number; i++) {
+ GtkTreeIter iter;
+ IterCache::iterator it(iter_cache.find(memmaps[i].start));
+
+ if (it != iter_cache.end())
+ iter = it->second;
+ else
+ gtk_list_store_prepend(GTK_LIST_STORE(model), &iter);
+
+ update_row(model, iter, *mmdata, &memmaps[i]);
+ }
+
+ g_free (memmaps);
}
@@ -319,196 +319,196 @@ update_memmaps_dialog (MemMapsData *mmdata)
static void
dialog_response (GtkDialog * dialog, gint response_id, gpointer data)
{
- MemMapsData * const mmdata = static_cast<MemMapsData*>(data);
+ MemMapsData * const mmdata = static_cast<MemMapsData*>(data);
- g_source_remove (mmdata->timer);
+ g_source_remove (mmdata->timer);
- delete mmdata;
- gtk_widget_destroy (GTK_WIDGET (dialog));
+ delete mmdata;
+ gtk_widget_destroy (GTK_WIDGET (dialog));
}
static MemMapsData*
create_memmapsdata (ProcData *procdata)
{
- GtkWidget *tree;
- GtkListStore *model;
- guint i;
-
- const gchar * const titles[] = {
- N_("Filename"),
- // xgettext: virtual memory start
- N_("VM Start"),
- // xgettext: virtual memory end
- N_("VM End"),
- // xgettext: virtual memory syze
- N_("VM Size"),
- N_("Flags"),
- // xgettext: virtual memory offset
- N_("VM Offset"),
- // xgettext: memory that has not been modified since
- // it has been allocated
- N_("Private clean"),
- // xgettext: memory that has been modified since it
- // has been allocated
- N_("Private dirty"),
- // xgettext: shared memory that has not been modified
- // since it has been allocated
- N_("Shared clean"),
- // xgettext: shared memory that has been modified
- // since it has been allocated
- N_("Shared dirty"),
- N_("Device"),
- N_("Inode")
- };
-
- model = gtk_list_store_new (MMAP_COL_MAX,
- G_TYPE_STRING, /* MMAP_COL_FILENAME */
- G_TYPE_STRING, /* MMAP_COL_VMSTART */
- G_TYPE_STRING, /* MMAP_COL_VMEND */
- G_TYPE_UINT64, /* MMAP_COL_VMSZ */
- G_TYPE_STRING, /* MMAP_COL_FLAGS */
- G_TYPE_STRING, /* MMAP_COL_VMOFFSET */
- G_TYPE_UINT64, /* MMAP_COL_PRIVATE_CLEAN */
- G_TYPE_UINT64, /* MMAP_COL_PRIVATE_DIRTY */
- G_TYPE_UINT64, /* MMAP_COL_SHARED_CLEAN */
- G_TYPE_UINT64, /* MMAP_COL_SHARED_DIRTY */
- G_TYPE_STRING, /* MMAP_COL_DEVICE */
- G_TYPE_UINT64 /* MMAP_COL_INODE */
- );
-
- tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
- gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree), TRUE);
- g_object_unref (G_OBJECT (model));
-
- for (i = 0; i < MMAP_COL_MAX; i++) {
- GtkCellRenderer *cell;
- GtkTreeViewColumn *col;
-
- cell = gtk_cell_renderer_text_new();
- col = gtk_tree_view_column_new();
- gtk_tree_view_column_pack_start(col, cell, TRUE);
- gtk_tree_view_column_set_title(col, _(titles[i]));
- gtk_tree_view_column_set_resizable(col, TRUE);
- gtk_tree_view_column_set_sort_column_id(col, i);
- gtk_tree_view_column_set_reorderable(col, TRUE);
- gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col);
-
- switch (i) {
- case MMAP_COL_PRIVATE_CLEAN:
- case MMAP_COL_PRIVATE_DIRTY:
- case MMAP_COL_SHARED_CLEAN:
- case MMAP_COL_SHARED_DIRTY:
- case MMAP_COL_VMSZ:
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::size_cell_data_func,
- GUINT_TO_POINTER(i),
- NULL);
-
- g_object_set(cell, "xalign", 1.0f, NULL);
- break;
-
- default:
- gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL);
- break;
- }
-
-
- switch (i) {
- case MMAP_COL_VMSTART:
- case MMAP_COL_VMEND:
- case MMAP_COL_FLAGS:
- case MMAP_COL_VMOFFSET:
- case MMAP_COL_DEVICE:
- g_object_set(cell, "family", "monospace", NULL);
- break;
- }
- }
-
- return new MemMapsData(tree, procdata->settings);
+ GtkWidget *tree;
+ GtkListStore *model;
+ guint i;
+
+ const gchar * const titles[] = {
+ N_("Filename"),
+ // xgettext: virtual memory start
+ N_("VM Start"),
+ // xgettext: virtual memory end
+ N_("VM End"),
+ // xgettext: virtual memory syze
+ N_("VM Size"),
+ N_("Flags"),
+ // xgettext: virtual memory offset
+ N_("VM Offset"),
+ // xgettext: memory that has not been modified since
+ // it has been allocated
+ N_("Private clean"),
+ // xgettext: memory that has been modified since it
+ // has been allocated
+ N_("Private dirty"),
+ // xgettext: shared memory that has not been modified
+ // since it has been allocated
+ N_("Shared clean"),
+ // xgettext: shared memory that has been modified
+ // since it has been allocated
+ N_("Shared dirty"),
+ N_("Device"),
+ N_("Inode")
+ };
+
+ model = gtk_list_store_new (MMAP_COL_MAX,
+ G_TYPE_STRING, /* MMAP_COL_FILENAME */
+ G_TYPE_STRING, /* MMAP_COL_VMSTART */
+ G_TYPE_STRING, /* MMAP_COL_VMEND */
+ G_TYPE_UINT64, /* MMAP_COL_VMSZ */
+ G_TYPE_STRING, /* MMAP_COL_FLAGS */
+ G_TYPE_STRING, /* MMAP_COL_VMOFFSET */
+ G_TYPE_UINT64, /* MMAP_COL_PRIVATE_CLEAN */
+ G_TYPE_UINT64, /* MMAP_COL_PRIVATE_DIRTY */
+ G_TYPE_UINT64, /* MMAP_COL_SHARED_CLEAN */
+ G_TYPE_UINT64, /* MMAP_COL_SHARED_DIRTY */
+ G_TYPE_STRING, /* MMAP_COL_DEVICE */
+ G_TYPE_UINT64 /* MMAP_COL_INODE */
+ );
+
+ tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree), TRUE);
+ g_object_unref (G_OBJECT (model));
+
+ for (i = 0; i < MMAP_COL_MAX; i++) {
+ GtkCellRenderer *cell;
+ GtkTreeViewColumn *col;
+
+ cell = gtk_cell_renderer_text_new();
+ col = gtk_tree_view_column_new();
+ gtk_tree_view_column_pack_start(col, cell, TRUE);
+ gtk_tree_view_column_set_title(col, _(titles[i]));
+ gtk_tree_view_column_set_resizable(col, TRUE);
+ gtk_tree_view_column_set_sort_column_id(col, i);
+ gtk_tree_view_column_set_reorderable(col, TRUE);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col);
+
+ switch (i) {
+ case MMAP_COL_PRIVATE_CLEAN:
+ case MMAP_COL_PRIVATE_DIRTY:
+ case MMAP_COL_SHARED_CLEAN:
+ case MMAP_COL_SHARED_DIRTY:
+ case MMAP_COL_VMSZ:
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::size_cell_data_func,
+ GUINT_TO_POINTER(i),
+ NULL);
+
+ g_object_set(cell, "xalign", 1.0f, NULL);
+ break;
+
+ default:
+ gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL);
+ break;
+ }
+
+
+ switch (i) {
+ case MMAP_COL_VMSTART:
+ case MMAP_COL_VMEND:
+ case MMAP_COL_FLAGS:
+ case MMAP_COL_VMOFFSET:
+ case MMAP_COL_DEVICE:
+ g_object_set(cell, "family", "monospace", NULL);
+ break;
+ }
+ }
+
+ return new MemMapsData(tree, procdata->settings);
}
static gboolean
memmaps_timer (gpointer data)
{
- MemMapsData * const mmdata = static_cast<MemMapsData*>(data);
- GtkTreeModel *model;
+ MemMapsData * const mmdata = static_cast<MemMapsData*>(data);
+ GtkTreeModel *model;
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (mmdata->tree));
- g_assert(model);
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (mmdata->tree));
+ g_assert(model);
- update_memmaps_dialog (mmdata);
+ update_memmaps_dialog (mmdata);
- return TRUE;
+ return TRUE;
}
static void
create_single_memmaps_dialog (GtkTreeModel *model, GtkTreePath *path,
- GtkTreeIter *iter, gpointer data)
+ GtkTreeIter *iter, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- MemMapsData *mmdata;
- GtkWidget *memmapsdialog;
- GtkWidget *dialog_vbox;
- GtkWidget *label;
- GtkWidget *scrolled;
- ProcInfo *info;
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ MemMapsData *mmdata;
+ GtkWidget *memmapsdialog;
+ GtkWidget *dialog_vbox;
+ GtkWidget *label;
+ GtkWidget *scrolled;
+ ProcInfo *info;
- gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+ gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
- if (!info)
- return;
+ if (!info)
+ return;
- mmdata = create_memmapsdata (procdata);
- mmdata->info = info;
+ mmdata = create_memmapsdata (procdata);
+ mmdata->info = info;
- memmapsdialog = gtk_dialog_new_with_buttons (_("Memory Maps"), GTK_WINDOW (procdata->app),
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
- NULL);
- gtk_window_set_resizable(GTK_WINDOW(memmapsdialog), TRUE);
- gtk_window_set_default_size(GTK_WINDOW(memmapsdialog), 575, 400);
- gtk_container_set_border_width(GTK_CONTAINER(memmapsdialog), 5);
+ memmapsdialog = gtk_dialog_new_with_buttons (_("Memory Maps"), GTK_WINDOW (procdata->app),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+ NULL);
+ gtk_window_set_resizable(GTK_WINDOW(memmapsdialog), TRUE);
+ gtk_window_set_default_size(GTK_WINDOW(memmapsdialog), 575, 400);
+ gtk_container_set_border_width(GTK_CONTAINER(memmapsdialog), 5);
- dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG(memmapsdialog));
- gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
+ dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG(memmapsdialog));
+ gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
- label = procman_make_label_for_mmaps_or_ofiles (
- _("_Memory maps for process \"%s\" (PID %u):"),
- info->name,
- info->pid);
+ label = procman_make_label_for_mmaps_or_ofiles (
+ _("_Memory maps for process \"%s\" (PID %u):"),
+ info->name,
+ info->pid);
- gtk_box_pack_start (GTK_BOX (dialog_vbox), label, FALSE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (dialog_vbox), label, FALSE, TRUE, 0);
- scrolled = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
- gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
- GTK_SHADOW_IN);
+ scrolled = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+ GTK_SHADOW_IN);
- gtk_container_add (GTK_CONTAINER (scrolled), mmdata->tree);
- gtk_label_set_mnemonic_widget (GTK_LABEL (label), mmdata->tree);
+ gtk_container_add (GTK_CONTAINER (scrolled), mmdata->tree);
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), mmdata->tree);
- gtk_box_pack_start (GTK_BOX (dialog_vbox), scrolled, TRUE, TRUE, 0);
+ gtk_box_pack_start (GTK_BOX (dialog_vbox), scrolled, TRUE, TRUE, 0);
- g_signal_connect(G_OBJECT(memmapsdialog), "response",
- G_CALLBACK(dialog_response), mmdata);
+ g_signal_connect(G_OBJECT(memmapsdialog), "response",
+ G_CALLBACK(dialog_response), mmdata);
- gtk_widget_show_all (memmapsdialog);
- mmdata->timer = g_timeout_add_seconds (5, memmaps_timer, mmdata);
+ gtk_widget_show_all (memmapsdialog);
+ mmdata->timer = g_timeout_add_seconds (5, memmaps_timer, mmdata);
- update_memmaps_dialog (mmdata);
+ update_memmaps_dialog (mmdata);
}
void
create_memmaps_dialog (ProcData *procdata)
{
- /* TODO: do we really want to open multiple dialogs ? */
- gtk_tree_selection_selected_foreach (procdata->selection, create_single_memmaps_dialog,
- procdata);
+ /* TODO: do we really want to open multiple dialogs ? */
+ gtk_tree_selection_selected_foreach (procdata->selection, create_single_memmaps_dialog,
+ procdata);
}
diff --git a/src/memmaps.h b/src/memmaps.h
index f0a00cd..b79476e 100644
--- a/src/memmaps.h
+++ b/src/memmaps.h
@@ -4,6 +4,6 @@
#include <glib.h>
#include "procman.h"
-void create_memmaps_dialog (ProcData *procdata);
+void create_memmaps_dialog (ProcData *procdata);
#endif /* _PROCMAN_MEMMAPS_H_ */
diff --git a/src/openfiles.cpp b/src/openfiles.cpp
index 2911890..3b6fcab 100644
--- a/src/openfiles.cpp
+++ b/src/openfiles.cpp
@@ -21,32 +21,32 @@
enum
{
- COL_FD,
- COL_TYPE,
- COL_OBJECT,
- COL_OPENFILE_STRUCT,
- NUM_OPENFILES_COL
+ COL_FD,
+ COL_TYPE,
+ COL_OBJECT,
+ COL_OPENFILE_STRUCT,
+ NUM_OPENFILES_COL
};
static const char*
get_type_name(enum glibtop_file_type t)
{
- switch(t)
- {
- case GLIBTOP_FILE_TYPE_FILE:
- return _("file");
- case GLIBTOP_FILE_TYPE_PIPE:
- return _("pipe");
- case GLIBTOP_FILE_TYPE_INET6SOCKET:
- return _("IPv6 network connection");
- case GLIBTOP_FILE_TYPE_INETSOCKET:
- return _("IPv4 network connection");
- case GLIBTOP_FILE_TYPE_LOCALSOCKET:
- return _("local socket");
- default:
- return _("unknown type");
- }
+ switch(t)
+ {
+ case GLIBTOP_FILE_TYPE_FILE:
+ return _("file");
+ case GLIBTOP_FILE_TYPE_PIPE:
+ return _("pipe");
+ case GLIBTOP_FILE_TYPE_INET6SOCKET:
+ return _("IPv6 network connection");
+ case GLIBTOP_FILE_TYPE_INETSOCKET:
+ return _("IPv4 network connection");
+ case GLIBTOP_FILE_TYPE_LOCALSOCKET:
+ return _("local socket");
+ default:
+ return _("unknown type");
+ }
}
@@ -54,32 +54,32 @@ get_type_name(enum glibtop_file_type t)
static char *
friendlier_hostname(const char *addr_str, int port)
{
- struct addrinfo hints = { };
- struct addrinfo *res = NULL;
- char hostname[NI_MAXHOST];
- char service[NI_MAXSERV];
- char port_str[6];
+ struct addrinfo hints = { };
+ struct addrinfo *res = NULL;
+ char hostname[NI_MAXHOST];
+ char service[NI_MAXSERV];
+ char port_str[6];
- if (!addr_str[0]) return g_strdup("");
+ if (!addr_str[0]) return g_strdup("");
- snprintf(port_str, sizeof port_str, "%d", port);
+ snprintf(port_str, sizeof port_str, "%d", port);
- hints.ai_family = AF_UNSPEC;
- hints.ai_socktype = SOCK_STREAM;
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
- if (getaddrinfo(addr_str, port_str, &hints, &res))
- goto failsafe;
+ if (getaddrinfo(addr_str, port_str, &hints, &res))
+ goto failsafe;
- if (getnameinfo(res->ai_addr, res->ai_addrlen, hostname,
- sizeof hostname, service, sizeof service, NI_IDN))
- goto failsafe;
+ if (getnameinfo(res->ai_addr, res->ai_addrlen, hostname,
+ sizeof hostname, service, sizeof service, NI_IDN))
+ goto failsafe;
- if (res) freeaddrinfo(res);
- return g_strdup_printf("%s, TCP port %d (%s)", hostname, port, service);
+ if (res) freeaddrinfo(res);
+ return g_strdup_printf("%s, TCP port %d (%s)", hostname, port, service);
- failsafe:
- if (res) freeaddrinfo(res);
- return g_strdup_printf("%s, TCP port %d", addr_str, port);
+ failsafe:
+ if (res) freeaddrinfo(res);
+ return g_strdup_printf("%s, TCP port %d", addr_str, port);
}
@@ -87,42 +87,42 @@ friendlier_hostname(const char *addr_str, int port)
static void
add_new_files (gpointer key, gpointer value, gpointer data)
{
- glibtop_open_files_entry *openfiles = static_cast<glibtop_open_files_entry*>(value);
-
- GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
- GtkTreeIter row;
-
- char *object;
-
- switch(openfiles->type)
- {
- case GLIBTOP_FILE_TYPE_FILE:
- object = g_strdup(openfiles->info.file.name);
- break;
-
- case GLIBTOP_FILE_TYPE_INET6SOCKET:
- case GLIBTOP_FILE_TYPE_INETSOCKET:
- object = friendlier_hostname(openfiles->info.sock.dest_host,
- openfiles->info.sock.dest_port);
- break;
-
- case GLIBTOP_FILE_TYPE_LOCALSOCKET:
- object = g_strdup(openfiles->info.localsock.name);
- break;
-
- default:
- object = g_strdup("");
- }
-
- gtk_list_store_insert (GTK_LIST_STORE (model), &row, 0);
- gtk_list_store_set (GTK_LIST_STORE (model), &row,
- COL_FD, openfiles->fd,
- COL_TYPE, get_type_name(static_cast<glibtop_file_type>(openfiles->type)),
- COL_OBJECT, object,
- COL_OPENFILE_STRUCT, g_memdup(openfiles, sizeof(*openfiles)),
- -1);
-
- g_free(object);
+ glibtop_open_files_entry *openfiles = static_cast<glibtop_open_files_entry*>(value);
+
+ GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
+ GtkTreeIter row;
+
+ char *object;
+
+ switch(openfiles->type)
+ {
+ case GLIBTOP_FILE_TYPE_FILE:
+ object = g_strdup(openfiles->info.file.name);
+ break;
+
+ case GLIBTOP_FILE_TYPE_INET6SOCKET:
+ case GLIBTOP_FILE_TYPE_INETSOCKET:
+ object = friendlier_hostname(openfiles->info.sock.dest_host,
+ openfiles->info.sock.dest_port);
+ break;
+
+ case GLIBTOP_FILE_TYPE_LOCALSOCKET:
+ object = g_strdup(openfiles->info.localsock.name);
+ break;
+
+ default:
+ object = g_strdup("");
+ }
+
+ gtk_list_store_insert (GTK_LIST_STORE (model), &row, 0);
+ gtk_list_store_set (GTK_LIST_STORE (model), &row,
+ COL_FD, openfiles->fd,
+ COL_TYPE, get_type_name(static_cast<glibtop_file_type>(openfiles->type)),
+ COL_OBJECT, object,
+ COL_OPENFILE_STRUCT, g_memdup(openfiles, sizeof(*openfiles)),
+ -1);
+
+ g_free(object);
}
static GList *old_maps = NULL;
@@ -130,25 +130,25 @@ static GList *old_maps = NULL;
static gboolean
classify_openfiles (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
- GHashTable *new_maps = static_cast<GHashTable*>(data);
- GtkTreeIter *old_iter;
- glibtop_open_files_entry *openfiles;
- gchar *old_name;
+ GHashTable *new_maps = static_cast<GHashTable*>(data);
+ GtkTreeIter *old_iter;
+ glibtop_open_files_entry *openfiles;
+ gchar *old_name;
- gtk_tree_model_get (model, iter, 1, &old_name, -1);
+ gtk_tree_model_get (model, iter, 1, &old_name, -1);
- openfiles = static_cast<glibtop_open_files_entry*>(g_hash_table_lookup (new_maps, old_name));
- if (openfiles) {
- g_hash_table_remove (new_maps, old_name);
- g_free (old_name);
- return FALSE;
+ openfiles = static_cast<glibtop_open_files_entry*>(g_hash_table_lookup (new_maps, old_name));
+ if (openfiles) {
+ g_hash_table_remove (new_maps, old_name);
+ g_free (old_name);
+ return FALSE;
- }
+ }
- old_iter = gtk_tree_iter_copy (iter);
- old_maps = g_list_append (old_maps, old_iter);
- g_free (old_name);
- return FALSE;
+ old_iter = gtk_tree_iter_copy (iter);
+ old_maps = g_list_append (old_maps, old_iter);
+ g_free (old_name);
+ return FALSE;
}
@@ -156,145 +156,145 @@ classify_openfiles (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, g
static gboolean
compare_open_files(gconstpointer a, gconstpointer b)
{
- const glibtop_open_files_entry *o1 = static_cast<const glibtop_open_files_entry *>(a);
- const glibtop_open_files_entry *o2 = static_cast<const glibtop_open_files_entry *>(b);
+ const glibtop_open_files_entry *o1 = static_cast<const glibtop_open_files_entry *>(a);
+ const glibtop_open_files_entry *o2 = static_cast<const glibtop_open_files_entry *>(b);
- /* Falta manejar los diferentes tipos! */
- return (o1->fd == o2->fd) && (o1->type == o1->type); /* XXX! */
+ /* Falta manejar los diferentes tipos! */
+ return (o1->fd == o2->fd) && (o1->type == o1->type); /* XXX! */
}
static void
update_openfiles_dialog (GtkWidget *tree)
{
- ProcInfo *info;
- GtkTreeModel *model;
- glibtop_open_files_entry *openfiles;
- glibtop_proc_open_files procmap;
- GHashTable *new_maps;
- guint i;
+ ProcInfo *info;
+ GtkTreeModel *model;
+ glibtop_open_files_entry *openfiles;
+ glibtop_proc_open_files procmap;
+ GHashTable *new_maps;
+ guint i;
- info = static_cast<ProcInfo*>(g_object_get_data (G_OBJECT (tree), "selected_info"));
+ info = static_cast<ProcInfo*>(g_object_get_data (G_OBJECT (tree), "selected_info"));
- if (!info)
- return;
+ if (!info)
+ return;
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
- openfiles = glibtop_get_proc_open_files (&procmap, info->pid);
+ openfiles = glibtop_get_proc_open_files (&procmap, info->pid);
- if (!openfiles)
- return;
+ if (!openfiles)
+ return;
- new_maps = static_cast<GHashTable *>(g_hash_table_new_full (g_str_hash, compare_open_files,
- NULL, NULL));
- for (i=0; i < procmap.number; i++)
- g_hash_table_insert (new_maps, openfiles + i, openfiles + i);
+ new_maps = static_cast<GHashTable *>(g_hash_table_new_full (g_str_hash, compare_open_files,
+ NULL, NULL));
+ for (i=0; i < procmap.number; i++)
+ g_hash_table_insert (new_maps, openfiles + i, openfiles + i);
- gtk_tree_model_foreach (model, classify_openfiles, new_maps);
+ gtk_tree_model_foreach (model, classify_openfiles, new_maps);
- g_hash_table_foreach (new_maps, add_new_files, model);
+ g_hash_table_foreach (new_maps, add_new_files, model);
- while (old_maps) {
- GtkTreeIter *iter = static_cast<GtkTreeIter*>(old_maps->data);
- glibtop_open_files_entry *openfiles = NULL;
+ while (old_maps) {
+ GtkTreeIter *iter = static_cast<GtkTreeIter*>(old_maps->data);
+ glibtop_open_files_entry *openfiles = NULL;
- gtk_tree_model_get (model, iter,
- COL_OPENFILE_STRUCT, &openfiles,
- -1);
+ gtk_tree_model_get (model, iter,
+ COL_OPENFILE_STRUCT, &openfiles,
+ -1);
- gtk_list_store_remove (GTK_LIST_STORE (model), iter);
- gtk_tree_iter_free (iter);
- g_free (openfiles);
+ gtk_list_store_remove (GTK_LIST_STORE (model), iter);
+ gtk_tree_iter_free (iter);
+ g_free (openfiles);
- old_maps = g_list_next (old_maps);
+ old_maps = g_list_next (old_maps);
- }
+ }
- g_hash_table_destroy (new_maps);
- g_free (openfiles);
+ g_hash_table_destroy (new_maps);
+ g_free (openfiles);
}
static void
close_openfiles_dialog (GtkDialog *dialog, gint id, gpointer data)
{
- GtkWidget *tree = static_cast<GtkWidget*>(data);
- GSettings *settings;
- guint timer;
+ GtkWidget *tree = static_cast<GtkWidget*>(data);
+ GSettings *settings;
+ guint timer;
- settings = static_cast<GSettings*>(g_object_get_data (G_OBJECT (tree), "settings"));
- procman_save_tree_state (settings, tree, procman::settings::open_files_tree_prefix.c_str());
+ settings = static_cast<GSettings*>(g_object_get_data (G_OBJECT (tree), "settings"));
+ procman_save_tree_state (settings, tree, procman::settings::open_files_tree_prefix.c_str());
- timer = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tree), "timer"));
- g_source_remove (timer);
+ timer = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (tree), "timer"));
+ g_source_remove (timer);
- gtk_widget_destroy (GTK_WIDGET (dialog));
+ gtk_widget_destroy (GTK_WIDGET (dialog));
- return ;
+ return ;
}
static GtkWidget *
create_openfiles_tree (ProcData *procdata)
{
- GtkWidget *tree;
- GtkListStore *model;
- GtkTreeViewColumn *column;
- GtkCellRenderer *cell;
- gint i;
-
- const gchar * const titles[] = {
- /* Translators: "FD" here means "File Descriptor". Please use
- a very short translation if possible, and at most
- 2-3 characters for it to be able to fit in the UI. */
- N_("FD"),
- N_("Type"),
- N_("Object")
- };
-
- model = gtk_list_store_new (NUM_OPENFILES_COL,
- G_TYPE_INT, /* FD */
- G_TYPE_STRING, /* Type */
- G_TYPE_STRING, /* Object */
- G_TYPE_POINTER /* open_files_entry */
- );
-
- tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
- gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree), TRUE);
- g_object_unref (G_OBJECT (model));
-
- for (i = 0; i < NUM_OPENFILES_COL-1; i++) {
- cell = gtk_cell_renderer_text_new ();
-
- switch (i) {
- case COL_FD:
- g_object_set(cell, "xalign", 1.0f, NULL);
- break;
- }
-
- column = gtk_tree_view_column_new_with_attributes (_(titles[i]),
- cell,
- "text", i,
- NULL);
- gtk_tree_view_column_set_sort_column_id (column, i);
- gtk_tree_view_column_set_resizable (column, TRUE);
- gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
- }
+ GtkWidget *tree;
+ GtkListStore *model;
+ GtkTreeViewColumn *column;
+ GtkCellRenderer *cell;
+ gint i;
+
+ const gchar * const titles[] = {
+ /* Translators: "FD" here means "File Descriptor". Please use
+ a very short translation if possible, and at most
+ 2-3 characters for it to be able to fit in the UI. */
+ N_("FD"),
+ N_("Type"),
+ N_("Object")
+ };
+
+ model = gtk_list_store_new (NUM_OPENFILES_COL,
+ G_TYPE_INT, /* FD */
+ G_TYPE_STRING, /* Type */
+ G_TYPE_STRING, /* Object */
+ G_TYPE_POINTER /* open_files_entry */
+ );
+
+ tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree), TRUE);
+ g_object_unref (G_OBJECT (model));
+
+ for (i = 0; i < NUM_OPENFILES_COL-1; i++) {
+ cell = gtk_cell_renderer_text_new ();
+
+ switch (i) {
+ case COL_FD:
+ g_object_set(cell, "xalign", 1.0f, NULL);
+ break;
+ }
+
+ column = gtk_tree_view_column_new_with_attributes (_(titles[i]),
+ cell,
+ "text", i,
+ NULL);
+ gtk_tree_view_column_set_sort_column_id (column, i);
+ gtk_tree_view_column_set_resizable (column, TRUE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
+ }
#if 0
- gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model),
- COL_VMSZ,
- sort_ints,
- GINT_TO_POINTER (COL_FD),
- NULL);
+ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model),
+ COL_VMSZ,
+ sort_ints,
+ GINT_TO_POINTER (COL_FD),
+ NULL);
/*gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
0,
GTK_SORT_ASCENDING);*/
#endif
- procman_get_tree_state (procdata->settings, tree, procman::settings::open_files_tree_prefix.c_str());
+ procman_get_tree_state (procdata->settings, tree, procman::settings::open_files_tree_prefix.c_str());
- return tree;
+ return tree;
}
@@ -302,89 +302,89 @@ create_openfiles_tree (ProcData *procdata)
static gboolean
openfiles_timer (gpointer data)
{
- GtkWidget *tree = static_cast<GtkWidget*>(data);
- GtkTreeModel *model;
+ GtkWidget *tree = static_cast<GtkWidget*>(data);
+ GtkTreeModel *model;
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
- g_assert(model);
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
+ g_assert(model);
- update_openfiles_dialog (tree);
+ update_openfiles_dialog (tree);
- return TRUE;
+ return TRUE;
}
static void
create_single_openfiles_dialog (GtkTreeModel *model, GtkTreePath *path,
- GtkTreeIter *iter, gpointer data)
+ GtkTreeIter *iter, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GtkWidget *openfilesdialog;
- GtkWidget *dialog_vbox, *vbox;
- GtkWidget *cmd_hbox;
- GtkWidget *label;
- GtkWidget *scrolled;
- GtkWidget *tree;
- ProcInfo *info;
- guint timer;
+ ProcData *procdata = static_cast<ProcData*>(data);
+ GtkWidget *openfilesdialog;
+ GtkWidget *dialog_vbox, *vbox;
+ GtkWidget *cmd_hbox;
+ GtkWidget *label;
+ GtkWidget *scrolled;
+ GtkWidget *tree;
+ ProcInfo *info;
+ guint timer;
- gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+ gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
- if (!info)
- return;
+ if (!info)
+ return;
- openfilesdialog = gtk_dialog_new_with_buttons (_("Open Files"), NULL,
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
- NULL);
- gtk_window_set_resizable (GTK_WINDOW (openfilesdialog), TRUE);
- gtk_window_set_default_size (GTK_WINDOW (openfilesdialog), 575, 400);
- gtk_container_set_border_width (GTK_CONTAINER (openfilesdialog), 5);
+ openfilesdialog = gtk_dialog_new_with_buttons (_("Open Files"), NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+ NULL);
+ gtk_window_set_resizable (GTK_WINDOW (openfilesdialog), TRUE);
+ gtk_window_set_default_size (GTK_WINDOW (openfilesdialog), 575, 400);
+ gtk_container_set_border_width (GTK_CONTAINER (openfilesdialog), 5);
- vbox = gtk_dialog_get_content_area (GTK_DIALOG (openfilesdialog));
- gtk_box_set_spacing (GTK_BOX (vbox), 2);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+ vbox = gtk_dialog_get_content_area (GTK_DIALOG (openfilesdialog));
+ gtk_box_set_spacing (GTK_BOX (vbox), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
- dialog_vbox = gtk_vbox_new (FALSE, 6);
- gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
- gtk_box_pack_start (GTK_BOX (vbox), dialog_vbox, TRUE, TRUE, 0);
+ dialog_vbox = gtk_vbox_new (FALSE, 6);
+ gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
+ gtk_box_pack_start (GTK_BOX (vbox), dialog_vbox, TRUE, TRUE, 0);
- cmd_hbox = gtk_hbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (dialog_vbox), cmd_hbox, FALSE, FALSE, 0);
+ cmd_hbox = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (dialog_vbox), cmd_hbox, FALSE, FALSE, 0);
- label = procman_make_label_for_mmaps_or_ofiles (
- _("_Files opened by process \"%s\" (PID %u):"),
- info->name,
- info->pid);
+ label = procman_make_label_for_mmaps_or_ofiles (
+ _("_Files opened by process \"%s\" (PID %u):"),
+ info->name,
+ info->pid);
- gtk_box_pack_start (GTK_BOX (cmd_hbox),label, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (cmd_hbox),label, FALSE, FALSE, 0);
- scrolled = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
- gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
- GTK_SHADOW_IN);
+ scrolled = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+ GTK_SHADOW_IN);
- tree = create_openfiles_tree (procdata);
- 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);
+ tree = create_openfiles_tree (procdata);
+ 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);
- gtk_box_pack_start (GTK_BOX (dialog_vbox), scrolled, TRUE, TRUE, 0);
- gtk_widget_show_all (scrolled);
+ gtk_box_pack_start (GTK_BOX (dialog_vbox), scrolled, TRUE, TRUE, 0);
+ gtk_widget_show_all (scrolled);
- g_signal_connect (G_OBJECT (openfilesdialog), "response",
- G_CALLBACK (close_openfiles_dialog), tree);
+ g_signal_connect (G_OBJECT (openfilesdialog), "response",
+ G_CALLBACK (close_openfiles_dialog), tree);
- gtk_widget_show_all (openfilesdialog);
+ gtk_widget_show_all (openfilesdialog);
- timer = g_timeout_add_seconds (5, openfiles_timer, tree);
- g_object_set_data (G_OBJECT (tree), "timer", GUINT_TO_POINTER (timer));
+ timer = g_timeout_add_seconds (5, openfiles_timer, tree);
+ g_object_set_data (G_OBJECT (tree), "timer", GUINT_TO_POINTER (timer));
- update_openfiles_dialog (tree);
+ update_openfiles_dialog (tree);
}
@@ -392,6 +392,6 @@ create_single_openfiles_dialog (GtkTreeModel *model, GtkTreePath *path,
void
create_openfiles_dialog (ProcData *procdata)
{
- gtk_tree_selection_selected_foreach (procdata->selection, create_single_openfiles_dialog,
- procdata);
+ gtk_tree_selection_selected_foreach (procdata->selection, create_single_openfiles_dialog,
+ procdata);
}
diff --git a/src/openfiles.h b/src/openfiles.h
index a8b7b05..d135942 100644
--- a/src/openfiles.h
+++ b/src/openfiles.h
@@ -5,6 +5,6 @@
#include "procman.h"
-void create_openfiles_dialog (ProcData *procdata);
+void create_openfiles_dialog (ProcData *procdata);
#endif
diff --git a/src/prettytable.h b/src/prettytable.h
index 7884cdd..64eb259 100644
--- a/src/prettytable.h
+++ b/src/prettytable.h
@@ -26,36 +26,36 @@ using std::string;
class PrettyTable
{
- public:
- PrettyTable();
- ~PrettyTable();
+public:
+ PrettyTable();
+ ~PrettyTable();
- void set_icon(ProcInfo &);
+ void set_icon(ProcInfo &);
private:
- static void on_application_opened(WnckScreen* screen, WnckApplication* app, gpointer data);
- static void on_application_closed(WnckScreen* screen, WnckApplication* app, gpointer data);
+ static void on_application_opened(WnckScreen* screen, WnckApplication* app, gpointer data);
+ static void on_application_closed(WnckScreen* screen, WnckApplication* app, gpointer data);
- void register_application(pid_t pid, Glib::RefPtr<Gdk::Pixbuf> icon);
- void unregister_application(pid_t pid);
+ void register_application(pid_t pid, Glib::RefPtr<Gdk::Pixbuf> icon);
+ void unregister_application(pid_t pid);
- Glib::RefPtr<Gdk::Pixbuf> get_icon_from_theme(const ProcInfo &);
- Glib::RefPtr<Gdk::Pixbuf> get_icon_from_default(const ProcInfo &);
- Glib::RefPtr<Gdk::Pixbuf> get_icon_from_wnck(const ProcInfo &);
- Glib::RefPtr<Gdk::Pixbuf> get_icon_from_name(const ProcInfo &);
- Glib::RefPtr<Gdk::Pixbuf> get_icon_for_kernel(const ProcInfo &);
- Glib::RefPtr<Gdk::Pixbuf> get_icon_dummy(const ProcInfo &);
+ Glib::RefPtr<Gdk::Pixbuf> get_icon_from_theme(const ProcInfo &);
+ Glib::RefPtr<Gdk::Pixbuf> get_icon_from_default(const ProcInfo &);
+ Glib::RefPtr<Gdk::Pixbuf> get_icon_from_wnck(const ProcInfo &);
+ Glib::RefPtr<Gdk::Pixbuf> get_icon_from_name(const ProcInfo &);
+ Glib::RefPtr<Gdk::Pixbuf> get_icon_for_kernel(const ProcInfo &);
+ Glib::RefPtr<Gdk::Pixbuf> get_icon_dummy(const ProcInfo &);
- bool get_default_icon_name(const string &cmd, string &name);
+ bool get_default_icon_name(const string &cmd, string &name);
- typedef std::map<string, Glib::RefPtr<Gdk::Pixbuf> > IconCache;
- typedef std::map<pid_t, Glib::RefPtr<Gdk::Pixbuf> > IconsForPID;
+ typedef std::map<string, Glib::RefPtr<Gdk::Pixbuf> > IconCache;
+ typedef std::map<pid_t, Glib::RefPtr<Gdk::Pixbuf> > IconsForPID;
- IconsForPID apps;
- IconCache defaults;
- procman::IconThemeWrapper theme;
+ IconsForPID apps;
+ IconCache defaults;
+ procman::IconThemeWrapper theme;
};
diff --git a/src/procactions.cpp b/src/procactions.cpp
index 8e79608..c7898d6 100644
--- a/src/procactions.cpp
+++ b/src/procactions.cpp
@@ -35,79 +35,79 @@
static void
renice_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
- const struct ReniceArgs * const args = static_cast<ReniceArgs*>(data);
+ const struct ReniceArgs * const args = static_cast<ReniceArgs*>(data);
- ProcInfo *info = NULL;
- gint error;
- int saved_errno;
- gchar *error_msg;
- GtkWidget *dialog;
+ ProcInfo *info = NULL;
+ gint error;
+ int saved_errno;
+ gchar *error_msg;
+ GtkWidget *dialog;
- gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+ gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
- if (!info)
- return;
+ if (!info)
+ return;
- error = setpriority (PRIO_PROCESS, info->pid, args->nice_value);
+ error = setpriority (PRIO_PROCESS, info->pid, args->nice_value);
- /* success */
- if(error != -1) return;
+ /* success */
+ if(error != -1) return;
- saved_errno = errno;
+ saved_errno = errno;
- /* need to be root */
- if(errno == EPERM || errno == EACCES) {
- gboolean success;
+ /* need to be root */
+ if(errno == EPERM || errno == EACCES) {
+ gboolean success;
- success = procdialog_create_root_password_dialog (
- PROCMAN_ACTION_RENICE, args->procdata, info->pid,
- args->nice_value);
+ success = procdialog_create_root_password_dialog (
+ PROCMAN_ACTION_RENICE, args->procdata, info->pid,
+ args->nice_value);
- if(success) return;
+ if(success) return;
- if(errno) {
- saved_errno = errno;
- }
- }
+ if(errno) {
+ saved_errno = errno;
+ }
+ }
- /* failed */
- error_msg = g_strdup_printf (
- _("Cannot change the priority of process with pid %d to %d.\n"
- "%s"),
- info->pid, args->nice_value, g_strerror(saved_errno));
+ /* failed */
+ error_msg = g_strdup_printf (
+ _("Cannot change the priority of process with pid %d to %d.\n"
+ "%s"),
+ info->pid, args->nice_value, g_strerror(saved_errno));
- dialog = gtk_message_dialog_new (
- NULL,
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_MESSAGE_ERROR,
- GTK_BUTTONS_OK,
- "%s", error_msg);
+ dialog = gtk_message_dialog_new (
+ NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ "%s", error_msg);
- gtk_dialog_run (GTK_DIALOG (dialog));
- gtk_widget_destroy (dialog);
- g_free (error_msg);
+ gtk_dialog_run (GTK_DIALOG (dialog));
+ gtk_widget_destroy (dialog);
+ g_free (error_msg);
}
void
renice (ProcData *procdata, int nice)
{
- struct ReniceArgs args = { procdata, nice };
+ struct ReniceArgs args = { procdata, 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);
+ /* 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);
- gtk_tree_selection_selected_foreach(procdata->selection, renice_single_process,
- &args);
+ gtk_tree_selection_selected_foreach(procdata->selection, renice_single_process,
+ &args);
- procdata->timeout = g_timeout_add(procdata->config.update_interval,
- cb_timeout,
- procdata);
+ procdata->timeout = g_timeout_add(procdata->config.update_interval,
+ cb_timeout,
+ procdata);
- proctable_update_all (procdata);
+ proctable_update_all (procdata);
}
@@ -116,75 +116,75 @@ renice (ProcData *procdata, int nice)
static void
kill_single_process (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
- const struct KillArgs * const args = static_cast<KillArgs*>(data);
- char *error_msg;
- ProcInfo *info;
- int error;
- int saved_errno;
- GtkWidget *dialog;
+ const struct KillArgs * const args = static_cast<KillArgs*>(data);
+ char *error_msg;
+ ProcInfo *info;
+ int error;
+ int saved_errno;
+ GtkWidget *dialog;
- gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
+ gtk_tree_model_get (model, iter, COL_POINTER, &info, -1);
- if (!info)
- return;
+ if (!info)
+ return;
- error = kill (info->pid, args->signal);
+ error = kill (info->pid, args->signal);
- /* success */
- if(error != -1) return;
+ /* success */
+ if(error != -1) return;
- saved_errno = errno;
+ saved_errno = errno;
- /* need to be root */
- if(errno == EPERM) {
- gboolean success;
+ /* need to be root */
+ if(errno == EPERM) {
+ gboolean success;
- success = procdialog_create_root_password_dialog (
- PROCMAN_ACTION_KILL, args->procdata, info->pid,
- args->signal);
+ success = procdialog_create_root_password_dialog (
+ PROCMAN_ACTION_KILL, args->procdata, info->pid,
+ args->signal);
- if(success) return;
+ if(success) return;
- if(errno) {
- saved_errno = errno;
- }
- }
+ if(errno) {
+ saved_errno = errno;
+ }
+ }
- /* failed */
- error_msg = g_strdup_printf (
- _("Cannot kill process with pid %d with signal %d.\n"
- "%s"),
- info->pid, args->signal, g_strerror(saved_errno));
+ /* failed */
+ error_msg = g_strdup_printf (
+ _("Cannot kill process with pid %d with signal %d.\n"
+ "%s"),
+ info->pid, args->signal, g_strerror(saved_errno));
- dialog = gtk_message_dialog_new (
- NULL,
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_MESSAGE_ERROR,
- GTK_BUTTONS_OK,
- "%s", error_msg);
+ dialog = gtk_message_dialog_new (
+ NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_OK,
+ "%s", error_msg);
- gtk_dialog_run (GTK_DIALOG (dialog));
- gtk_widget_destroy (dialog);
- g_free (error_msg);
+ gtk_dialog_run (GTK_DIALOG (dialog));
+ gtk_widget_destroy (dialog);
+ g_free (error_msg);
}
void
kill_process (ProcData *procdata, int sig)
{
- struct KillArgs args = { procdata, sig };
+ struct KillArgs args = { procdata, 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);
+ /* 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);
- gtk_tree_selection_selected_foreach (procdata->selection, kill_single_process,
- &args);
+ gtk_tree_selection_selected_foreach (procdata->selection, kill_single_process,
+ &args);
- procdata->timeout = g_timeout_add (procdata->config.update_interval,
- cb_timeout,
- procdata);
- proctable_update_all (procdata);
+ procdata->timeout = g_timeout_add (procdata->config.update_interval,
+ cb_timeout,
+ procdata);
+ proctable_update_all (procdata);
}
diff --git a/src/procactions.h b/src/procactions.h
index a4190d5..95e5ccb 100644
--- a/src/procactions.h
+++ b/src/procactions.h
@@ -20,9 +20,9 @@
#define _PROCACTIONS_H_
#include "procman.h"
-
-void renice (ProcData *procdata, int nice);
-void kill_process (ProcData *procdata, int sig);
+
+void renice (ProcData *procdata, int nice);
+void kill_process (ProcData *procdata, int sig);
#endif
diff --git a/src/procdialogs.cpp b/src/procdialogs.cpp
index 563c971..5b7b439 100644
--- a/src/procdialogs.cpp
+++ b/src/procdialogs.cpp
@@ -43,219 +43,219 @@ static gint new_nice_value = 0;
static void
kill_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
{
- struct KillArgs *kargs = static_cast<KillArgs*>(data);
-
- gtk_widget_destroy (GTK_WIDGET (dialog));
+ struct KillArgs *kargs = static_cast<KillArgs*>(data);
- if (id == GTK_RESPONSE_OK)
- kill_process (kargs->procdata, kargs->signal);
+ gtk_widget_destroy (GTK_WIDGET (dialog));
- g_free (kargs);
+ if (id == GTK_RESPONSE_OK)
+ kill_process (kargs->procdata, kargs->signal);
+
+ g_free (kargs);
}
void
procdialog_create_kill_dialog (ProcData *procdata, int signal)
{
- GtkWidget *kill_alert_dialog;
- gchar *primary, *secondary, *button_text;
- struct KillArgs *kargs;
-
- kargs = g_new(KillArgs, 1);
- kargs->procdata = procdata;
- kargs->signal = signal;
-
-
- if (signal == SIGKILL) {
- /*xgettext: primary alert message*/
- primary = _("Kill the selected process?");
- /*xgettext: secondary alert message*/
- secondary = _("Killing a process may destroy data, break the "
- "session or introduce a security risk. "
- "Only unresponding processes should be killed.");
- button_text = _("_Kill Process");
- }
- else {
- /*xgettext: primary alert message*/
- primary = _("End the selected process?");
- /*xgettext: secondary alert message*/
- secondary = _("Ending a process may destroy data, break the "
- "session or introduce a security risk. "
- "Only unresponding processes should be ended.");
- button_text = _("_End Process");
- }
-
- kill_alert_dialog = gtk_message_dialog_new (GTK_WINDOW (procdata->app),
- static_cast<GtkDialogFlags>(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
- GTK_MESSAGE_WARNING,
- GTK_BUTTONS_NONE,
- "%s",
- primary);
- gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (kill_alert_dialog),
- "%s",
- secondary);
-
- gtk_dialog_add_buttons (GTK_DIALOG (kill_alert_dialog),
- GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- button_text, GTK_RESPONSE_OK,
- NULL);
-
- gtk_dialog_set_default_response (GTK_DIALOG (kill_alert_dialog),
- GTK_RESPONSE_CANCEL);
-
- g_signal_connect (G_OBJECT (kill_alert_dialog), "response",
- G_CALLBACK (kill_dialog_button_pressed), kargs);
-
- gtk_widget_show_all (kill_alert_dialog);
+ GtkWidget *kill_alert_dialog;
+ gchar *primary, *secondary, *button_text;
+ struct KillArgs *kargs;
+
+ kargs = g_new(KillArgs, 1);
+ kargs->procdata = procdata;
+ kargs->signal = signal;
+
+
+ if (signal == SIGKILL) {
+ /*xgettext: primary alert message*/
+ primary = _("Kill the selected process?");
+ /*xgettext: secondary alert message*/
+ secondary = _("Killing a process may destroy data, break the "
+ "session or introduce a security risk. "
+ "Only unresponding processes should be killed.");
+ button_text = _("_Kill Process");
+ }
+ else {
+ /*xgettext: primary alert message*/
+ primary = _("End the selected process?");
+ /*xgettext: secondary alert message*/
+ secondary = _("Ending a process may destroy data, break the "
+ "session or introduce a security risk. "
+ "Only unresponding processes should be ended.");
+ button_text = _("_End Process");
+ }
+
+ kill_alert_dialog = gtk_message_dialog_new (GTK_WINDOW (procdata->app),
+ static_cast<GtkDialogFlags>(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
+ GTK_MESSAGE_WARNING,
+ GTK_BUTTONS_NONE,
+ "%s",
+ primary);
+ gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (kill_alert_dialog),
+ "%s",
+ secondary);
+
+ gtk_dialog_add_buttons (GTK_DIALOG (kill_alert_dialog),
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ button_text, GTK_RESPONSE_OK,
+ NULL);
+
+ gtk_dialog_set_default_response (GTK_DIALOG (kill_alert_dialog),
+ GTK_RESPONSE_CANCEL);
+
+ g_signal_connect (G_OBJECT (kill_alert_dialog), "response",
+ G_CALLBACK (kill_dialog_button_pressed), kargs);
+
+ gtk_widget_show_all (kill_alert_dialog);
}
static gchar *
get_nice_level (gint nice)
{
- if (nice < -7)
- return _("(Very High Priority)");
- else if (nice < -2)
- return _("(High Priority)");
- else if (nice < 3)
- return _("(Normal Priority)");
- else if (nice < 7)
- return _("(Low Priority)");
- else
- return _("(Very Low Priority)");
+ if (nice < -7)
+ return _("(Very High Priority)");
+ else if (nice < -2)
+ return _("(High Priority)");
+ else if (nice < 3)
+ return _("(Normal Priority)");
+ else if (nice < 7)
+ return _("(Low Priority)");
+ else
+ return _("(Very Low Priority)");
}
static void
renice_scale_changed (GtkAdjustment *adj, gpointer data)
{
- GtkWidget *label = GTK_WIDGET (data);
-
- new_nice_value = int(gtk_adjustment_get_value (adj));
- gtk_label_set_text (GTK_LABEL (label), get_nice_level (new_nice_value));
-
+ GtkWidget *label = GTK_WIDGET (data);
+
+ new_nice_value = int(gtk_adjustment_get_value (adj));
+ gtk_label_set_text (GTK_LABEL (label), get_nice_level (new_nice_value));
+
}
static void
renice_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
-
- if (id == 100) {
- if (new_nice_value == -100)
- return;
- renice(procdata, new_nice_value);
- }
-
- gtk_widget_destroy (GTK_WIDGET (dialog));
- renice_dialog = NULL;
+ ProcData *procdata = static_cast<ProcData*>(data);
+
+ if (id == 100) {
+ if (new_nice_value == -100)
+ return;
+ renice(procdata, new_nice_value);
+ }
+
+ gtk_widget_destroy (GTK_WIDGET (dialog));
+ renice_dialog = NULL;
}
void
procdialog_create_renice_dialog (ProcData *procdata)
{
- ProcInfo *info = procdata->selected_process;
- GtkWidget *dialog = NULL;
- GtkWidget *dialog_vbox;
- GtkWidget *vbox;
- GtkWidget *label;
- GtkWidget *priority_label;
- GtkWidget *table;
- GtkAdjustment *renice_adj;
- GtkWidget *hscale;
- GtkWidget *button;
- GtkWidget *icon;
- gchar *text;
-
- if (renice_dialog)
- return;
-
- if (!info)
- return;
-
- dialog = gtk_dialog_new_with_buttons (_("Change Priority"), NULL,
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
- NULL);
- renice_dialog = dialog;
- gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE);
- gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5);
-
- button = gtk_button_new_with_mnemonic (_("Change _Priority"));
- gtk_widget_set_can_default (button, TRUE);
-
- icon = gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON);
- gtk_button_set_image (GTK_BUTTON (button), icon);
-
- gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100);
- gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
- new_nice_value = -100;
-
- dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
- gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
- gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
-
- vbox = gtk_vbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
-
- table = gtk_table_new (2, 2, FALSE);
- gtk_table_set_col_spacings (GTK_TABLE(table), 12);
- gtk_table_set_row_spacings (GTK_TABLE(table), 6);
- gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
-
- label = gtk_label_new_with_mnemonic (_("_Nice value:"));
- gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 2,
- GTK_FILL, GTK_FILL, 0, 0);
-
- renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0);
- new_nice_value = 0;
- hscale = gtk_hscale_new (renice_adj);
- gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale);
- gtk_scale_set_digits (GTK_SCALE (hscale), 0);
- gtk_table_attach (GTK_TABLE (table), hscale, 1, 2, 0, 1,
- static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
-
- priority_label = gtk_label_new (get_nice_level (info->nice));
- gtk_table_attach (GTK_TABLE (table), priority_label, 1, 2, 1, 2,
- GTK_FILL, GTK_FILL, 0, 0);
-
- text = g_strconcat("<small><i><b>", _("Note:"), "</b> ",
- _("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."),
- "</i></small>", NULL);
- label = gtk_label_new (_(text));
- gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
- gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
- g_free (text);
-
- g_signal_connect (G_OBJECT (dialog), "response",
- G_CALLBACK (renice_dialog_button_pressed), procdata);
- g_signal_connect (G_OBJECT (renice_adj), "value_changed",
- G_CALLBACK (renice_scale_changed), priority_label);
-
- gtk_widget_show_all (dialog);
-
-
+ ProcInfo *info = procdata->selected_process;
+ GtkWidget *dialog = NULL;
+ GtkWidget *dialog_vbox;
+ GtkWidget *vbox;
+ GtkWidget *label;
+ GtkWidget *priority_label;
+ GtkWidget *table;
+ GtkAdjustment *renice_adj;
+ GtkWidget *hscale;
+ GtkWidget *button;
+ GtkWidget *icon;
+ gchar *text;
+
+ if (renice_dialog)
+ return;
+
+ if (!info)
+ return;
+
+ dialog = gtk_dialog_new_with_buttons (_("Change Priority"), NULL,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+ NULL);
+ renice_dialog = dialog;
+ gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE);
+ gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5);
+
+ button = gtk_button_new_with_mnemonic (_("Change _Priority"));
+ gtk_widget_set_can_default (button, TRUE);
+
+ icon = gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON);
+ gtk_button_set_image (GTK_BUTTON (button), icon);
+
+ gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100);
+ gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
+ new_nice_value = -100;
+
+ dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
+ gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
+ gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
+
+ vbox = gtk_vbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
+
+ table = gtk_table_new (2, 2, FALSE);
+ gtk_table_set_col_spacings (GTK_TABLE(table), 12);
+ gtk_table_set_row_spacings (GTK_TABLE(table), 6);
+ gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
+
+ label = gtk_label_new_with_mnemonic (_("_Nice value:"));
+ gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 2,
+ GTK_FILL, GTK_FILL, 0, 0);
+
+ renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0);
+ new_nice_value = 0;
+ hscale = gtk_hscale_new (renice_adj);
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale);
+ gtk_scale_set_digits (GTK_SCALE (hscale), 0);
+ gtk_table_attach (GTK_TABLE (table), hscale, 1, 2, 0, 1,
+ static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
+
+ priority_label = gtk_label_new (get_nice_level (info->nice));
+ gtk_table_attach (GTK_TABLE (table), priority_label, 1, 2, 1, 2,
+ GTK_FILL, GTK_FILL, 0, 0);
+
+ text = g_strconcat("<small><i><b>", _("Note:"), "</b> ",
+ _("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."),
+ "</i></small>", NULL);
+ label = gtk_label_new (_(text));
+ gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+ gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+ g_free (text);
+
+ g_signal_connect (G_OBJECT (dialog), "response",
+ G_CALLBACK (renice_dialog_button_pressed), procdata);
+ g_signal_connect (G_OBJECT (renice_adj), "value_changed",
+ G_CALLBACK (renice_scale_changed), priority_label);
+
+ gtk_widget_show_all (dialog);
+
+
}
static void
prefs_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
{
- gtk_widget_destroy (GTK_WIDGET (dialog));
-
- prefs_dialog = NULL;
+ gtk_widget_destroy (GTK_WIDGET (dialog));
+
+ prefs_dialog = NULL;
}
static void
show_kill_dialog_toggled (GtkToggleButton *button, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings;
-
- gboolean toggled;
-
- toggled = gtk_toggle_button_get_active (button);
-
- g_settings_set_boolean (settings, "kill-dialog", toggled);
+ ProcData *procdata = static_cast<ProcData*>(data);
+ GSettings *settings = procdata->settings;
+
+ gboolean toggled;
+
+ toggled = gtk_toggle_button_get_active (button);
+
+ g_settings_set_boolean (settings, "kill-dialog", toggled);
}
@@ -263,24 +263,24 @@ 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;
+ ProcData *procdata = static_cast<ProcData*>(data);
+ GSettings *settings = procdata->settings;
- gboolean toggled;
- toggled = gtk_toggle_button_get_active(button);
- g_settings_set_boolean(settings, procman::settings::solaris_mode.c_str(), toggled);
+ gboolean toggled;
+ toggled = gtk_toggle_button_get_active(button);
+ g_settings_set_boolean(settings, procman::settings::solaris_mode.c_str(), toggled);
}
static void
network_in_bits_toggled(GtkToggleButton *button, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
- GSettings *settings = procdata->settings;
+ ProcData *procdata = static_cast<ProcData*>(data);
+ GSettings *settings = procdata->settings;
- gboolean toggled;
- toggled = gtk_toggle_button_get_active(button);
- g_settings_set_boolean(settings, procman::settings::network_in_bits.c_str(), toggled);
+ gboolean toggled;
+ toggled = gtk_toggle_button_get_active(button);
+ g_settings_set_boolean(settings, procman::settings::network_in_bits.c_str(), toggled);
}
@@ -288,14 +288,14 @@ 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;
-
- gboolean toggled;
+ ProcData *procdata = static_cast<ProcData*>(data);
+ GSettings *settings = procdata->settings;
+
+ gboolean toggled;
- toggled = gtk_toggle_button_get_active(button);
+ toggled = gtk_toggle_button_get_active(button);
- g_settings_set_boolean(settings, SmoothRefresh::KEY.c_str(), toggled);
+ g_settings_set_boolean(settings, SmoothRefresh::KEY.c_str(), toggled);
}
@@ -303,44 +303,44 @@ 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;
-
- gboolean toggled;
+ ProcData *procdata = static_cast<ProcData*>(data);
+ GSettings *settings = procdata->settings;
- toggled = gtk_toggle_button_get_active (button);
+ gboolean toggled;
- g_settings_set_boolean (settings, "show-all-fs", toggled);
+ toggled = gtk_toggle_button_get_active (button);
+
+ g_settings_set_boolean (settings, "show-all-fs", toggled);
}
class SpinButtonUpdater
{
public:
- SpinButtonUpdater(const string& key)
- : key(key)
- { }
+ SpinButtonUpdater(const string& key)
+ : key(key)
+ { }
- static gboolean callback(GtkWidget *widget, GdkEventFocus *event, gpointer data)
- {
- SpinButtonUpdater* updater = static_cast<SpinButtonUpdater*>(data);
- updater->update(GTK_SPIN_BUTTON(widget));
- return FALSE;
- }
+ static gboolean callback(GtkWidget *widget, GdkEventFocus *event, gpointer data)
+ {
+ SpinButtonUpdater* updater = static_cast<SpinButtonUpdater*>(data);
+ updater->update(GTK_SPIN_BUTTON(widget));
+ return FALSE;
+ }
private:
- void update(GtkSpinButton* spin)
- {
- int new_value = int(1000 * gtk_spin_button_get_value(spin));
+ void update(GtkSpinButton* spin)
+ {
+ int new_value = int(1000 * gtk_spin_button_get_value(spin));
- g_settings_set_int(ProcData::get_instance()->settings,
- this->key.c_str(), new_value);
+ g_settings_set_int(ProcData::get_instance()->settings,
+ this->key.c_str(), new_value);
- procman_debug("set %s to %d", this->key.c_str(), new_value);
- }
+ procman_debug("set %s to %d", this->key.c_str(), new_value);
+ }
- const string key;
+ const string key;
};
@@ -349,444 +349,444 @@ private:
static void
field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
- GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
- GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
- GtkTreeIter iter;
- GtkTreeViewColumn *column;
- gboolean toggled;
-
- if (!path)
- return;
-
- gtk_tree_model_get_iter (model, &iter, path);
-
- gtk_tree_model_get (model, &iter, 2, &column, -1);
- toggled = gtk_cell_renderer_toggle_get_active (cell);
-
- gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1);
- gtk_tree_view_column_set_visible (column, !toggled);
-
- gtk_tree_path_free (path);
+ GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
+ GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
+ GtkTreeIter iter;
+ GtkTreeViewColumn *column;
+ gboolean toggled;
+
+ if (!path)
+ return;
+
+ gtk_tree_model_get_iter (model, &iter, path);
+
+ gtk_tree_model_get (model, &iter, 2, &column, -1);
+ toggled = gtk_cell_renderer_toggle_get_active (cell);
+
+ gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1);
+ gtk_tree_view_column_set_visible (column, !toggled);
+
+ gtk_tree_path_free (path);
}
static GtkWidget *
create_field_page(GtkWidget *tree, const char* text)
{
- GtkWidget *vbox;
- GtkWidget *scrolled;
- GtkWidget *label;
- GtkWidget *treeview;
- GList *it, *columns;
- GtkListStore *model;
- GtkTreeViewColumn *column;
- GtkCellRenderer *cell;
-
- vbox = gtk_vbox_new (FALSE, 6);
-
- label = gtk_label_new_with_mnemonic (text);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
-
- scrolled = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
- gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
- gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
-
- model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
-
- treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
- gtk_container_add (GTK_CONTAINER (scrolled), treeview);
- g_object_unref (G_OBJECT (model));
- gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
-
- column = gtk_tree_view_column_new ();
-
- cell = gtk_cell_renderer_toggle_new ();
- gtk_tree_view_column_pack_start (column, cell, FALSE);
- gtk_tree_view_column_set_attributes (column, cell,
- "active", 0,
- NULL);
- g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (field_toggled), model);
- gtk_tree_view_column_set_clickable (column, TRUE);
- gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
-
- column = gtk_tree_view_column_new ();
-
- cell = gtk_cell_renderer_text_new ();
- gtk_tree_view_column_pack_start (column, cell, FALSE);
- gtk_tree_view_column_set_attributes (column, cell,
- "text", 1,
- NULL);
-
- gtk_tree_view_column_set_title (column, "Not Shown");
- gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
- gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
-
- columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
-
- for(it = columns; it; it = it->next)
- {
- GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
- GtkTreeIter iter;
- const gchar *title;
- gboolean visible;
-
- title = gtk_tree_view_column_get_title (column);
- if (!title)
- title = _("Icon");
-
- visible = gtk_tree_view_column_get_visible (column);
-
- gtk_list_store_append (model, &iter);
- gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
- }
-
- g_list_free(columns);
-
- return vbox;
+ GtkWidget *vbox;
+ GtkWidget *scrolled;
+ GtkWidget *label;
+ GtkWidget *treeview;
+ GList *it, *columns;
+ GtkListStore *model;
+ GtkTreeViewColumn *column;
+ GtkCellRenderer *cell;
+
+ vbox = gtk_vbox_new (FALSE, 6);
+
+ label = gtk_label_new_with_mnemonic (text);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
+
+ scrolled = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
+ gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
+
+ model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
+
+ treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
+ gtk_container_add (GTK_CONTAINER (scrolled), treeview);
+ g_object_unref (G_OBJECT (model));
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
+
+ column = gtk_tree_view_column_new ();
+
+ cell = gtk_cell_renderer_toggle_new ();
+ gtk_tree_view_column_pack_start (column, cell, FALSE);
+ gtk_tree_view_column_set_attributes (column, cell,
+ "active", 0,
+ NULL);
+ g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (field_toggled), model);
+ gtk_tree_view_column_set_clickable (column, TRUE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+
+ column = gtk_tree_view_column_new ();
+
+ cell = gtk_cell_renderer_text_new ();
+ gtk_tree_view_column_pack_start (column, cell, FALSE);
+ gtk_tree_view_column_set_attributes (column, cell,
+ "text", 1,
+ NULL);
+
+ gtk_tree_view_column_set_title (column, "Not Shown");
+ gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
+
+ columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
+
+ for(it = columns; it; it = it->next)
+ {
+ GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
+ GtkTreeIter iter;
+ const gchar *title;
+ gboolean visible;
+
+ title = gtk_tree_view_column_get_title (column);
+ if (!title)
+ title = _("Icon");
+
+ visible = gtk_tree_view_column_get_visible (column);
+
+ gtk_list_store_append (model, &iter);
+ gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
+ }
+
+ g_list_free(columns);
+
+ return vbox;
}
void
procdialog_create_preferences_dialog (ProcData *procdata)
{
- static GtkWidget *dialog = NULL;
-
- typedef SpinButtonUpdater SBU;
-
- static SBU interval_updater("update-interval");
- static SBU graph_interval_updater("graph-update-interval");
- static SBU disks_interval_updater("disks-interval");
-
- GtkWidget *notebook;
- GtkWidget *proc_box;
- GtkWidget *sys_box;
- GtkWidget *main_vbox;
- GtkWidget *vbox, *vbox2, *vbox3;
- GtkWidget *hbox, *hbox2, *hbox3;
- GtkWidget *label;
- GtkAdjustment *adjustment;
- GtkWidget *spin_button;
- GtkWidget *check_button;
- GtkWidget *tab_label;
- GtkWidget *smooth_button;
- GtkSizeGroup *size;
- gfloat update;
- gchar *tmp;
-
- if (prefs_dialog)
- return;
-
- size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
-
- dialog = gtk_dialog_new_with_buttons (_("System Monitor Preferences"),
- GTK_WINDOW (procdata->app),
- GTK_DIALOG_DESTROY_WITH_PARENT,
- GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
- NULL);
- /* FIXME: we should not declare the window size, but let it's */
- /* driven by window childs. The problem is that the fields list */
- /* have to show at least 4 items to respect HIG. I don't know */
- /* any function to set list height by contents/items inside it. */
- gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 420);
- gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
- prefs_dialog = dialog;
-
- main_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
- gtk_box_set_spacing (GTK_BOX (main_vbox), 2);
-
- notebook = gtk_notebook_new ();
- gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
- gtk_box_pack_start (GTK_BOX (main_vbox), notebook, TRUE, TRUE, 0);
-
- proc_box = gtk_vbox_new (FALSE, 18);
- gtk_container_set_border_width (GTK_CONTAINER (proc_box), 12);
- tab_label = gtk_label_new (_("Processes"));
- gtk_widget_show (tab_label);
- gtk_notebook_append_page (GTK_NOTEBOOK (notebook), proc_box, tab_label);
-
- vbox = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (proc_box), vbox, FALSE, FALSE, 0);
-
- tmp = g_strdup_printf ("<b>%s</b>", _("Behavior"));
- label = gtk_label_new (NULL);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_label_set_markup (GTK_LABEL (label), tmp);
- g_free (tmp);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
- hbox = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
-
- label = gtk_label_new (" ");
- gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-
- vbox2 = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
-
- hbox2 = gtk_hbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
-
- label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
-
- hbox3 = gtk_hbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
-
- update = (gfloat) procdata->config.update_interval;
- adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0,
- MIN_UPDATE_INTERVAL / 1000,
- MAX_UPDATE_INTERVAL / 1000,
- 0.25,
- 1.0,
- 0);
-
- spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
- gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
- g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
- G_CALLBACK (SBU::callback), &interval_updater);
- gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
-
-
- hbox2 = gtk_hbox_new(FALSE, 6);
- gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
-
- smooth_button = gtk_check_button_new_with_mnemonic(_("Enable _smooth refresh"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(smooth_button),
- g_settings_get_boolean(procdata->settings,
- SmoothRefresh::KEY.c_str()));
- g_signal_connect(G_OBJECT(smooth_button), "toggled",
- G_CALLBACK(smooth_refresh_toggled), procdata);
- gtk_box_pack_start(GTK_BOX(hbox2), smooth_button, TRUE, TRUE, 0);
-
-
-
- hbox2 = gtk_hbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
-
- check_button = gtk_check_button_new_with_mnemonic (_("Alert before ending or _killing processes"));
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
- procdata->config.show_kill_warning);
- g_signal_connect (G_OBJECT (check_button), "toggled",
- G_CALLBACK (show_kill_dialog_toggled), procdata);
- gtk_box_pack_start (GTK_BOX (hbox2), check_button, TRUE, TRUE, 0);
-
-
-
-
- hbox2 = gtk_hbox_new(FALSE, 6);
- gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
-
- GtkWidget *solaris_button = gtk_check_button_new_with_mnemonic(_("Divide CPU usage by CPU count"));
- gtk_widget_set_tooltip_text(solaris_button, _("Solaris mode"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(solaris_button),
- g_settings_get_boolean(procdata->settings,
- procman::settings::solaris_mode.c_str()));
- g_signal_connect(G_OBJECT(solaris_button), "toggled",
- G_CALLBACK(solaris_mode_toggled), procdata);
- gtk_box_pack_start(GTK_BOX(hbox2), solaris_button, TRUE, TRUE, 0);
-
-
-
-
- hbox2 = gtk_hbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
-
- vbox = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (proc_box), vbox, TRUE, TRUE, 0);
-
- tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
- label = gtk_label_new (NULL);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_label_set_markup (GTK_LABEL (label), tmp);
- g_free (tmp);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
- hbox = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
-
- label = gtk_label_new (" ");
- gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-
- vbox2 = create_field_page (procdata->tree, _("Process i_nformation shown in list:"));
- gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
-
- sys_box = gtk_vbox_new (FALSE, 12);
- gtk_container_set_border_width (GTK_CONTAINER (sys_box), 12);
- tab_label = gtk_label_new (_("Resources"));
- gtk_widget_show (tab_label);
- gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label);
-
- vbox = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (sys_box), vbox, FALSE, FALSE, 0);
-
- tmp = g_strdup_printf ("<b>%s</b>", _("Graphs"));
- label = gtk_label_new (NULL);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_label_set_markup (GTK_LABEL (label), tmp);
- g_free (tmp);
- gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
-
- hbox = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
-
- label = gtk_label_new (" ");
- gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-
- vbox2 = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
-
- hbox2 = gtk_hbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
-
- label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
- gtk_size_group_add_widget (size, label);
-
- hbox3 = gtk_hbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
-
- update = (gfloat) procdata->config.graph_update_interval;
- adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25,
- 100.0, 0.25, 1.0, 0);
- spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
- g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
- G_CALLBACK(SBU::callback),
- &graph_interval_updater);
- gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
- gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
-
-
- GtkWidget *bits_button;
- bits_button = gtk_check_button_new_with_mnemonic(_("Show network speed in bits"));
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bits_button),
- g_settings_get_boolean(procdata->settings,
- procman::settings::network_in_bits.c_str()));
- g_signal_connect(G_OBJECT(bits_button), "toggled",
- G_CALLBACK(network_in_bits_toggled), procdata);
- gtk_box_pack_start(GTK_BOX(vbox2), bits_button, TRUE, TRUE, 0);
-
-
-
- hbox2 = gtk_hbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
-
- /*
- * Devices
- */
- vbox = gtk_vbox_new (FALSE, 6);
- gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
- tab_label = gtk_label_new (_("File Systems"));
- gtk_widget_show (tab_label);
- gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, tab_label);
-
- tmp = g_strdup_printf ("<b>%s</b>", _("File Systems"));
- label = gtk_label_new (NULL);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_label_set_markup (GTK_LABEL (label), tmp);
- g_free (tmp);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
- hbox = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
-
- label = gtk_label_new (" ");
- gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-
- vbox2 = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
-
- hbox2 = gtk_hbox_new (FALSE, 12);
- gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
-
- label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
-
- hbox3 = gtk_hbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
-
- update = (gfloat) procdata->config.disks_update_interval;
- adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0,
- 100.0, 1.0, 1.0, 0);
- spin_button = gtk_spin_button_new (adjustment, 1.0, 0);
- gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
- gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
- g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
- G_CALLBACK(SBU::callback),
- &disks_interval_updater);
-
-
- hbox2 = gtk_hbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
- check_button = gtk_check_button_new_with_mnemonic (_("Show _all filesystems"));
- gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
- procdata->config.show_all_fs);
- g_signal_connect (G_OBJECT (check_button), "toggled",
- G_CALLBACK (show_all_fs_toggled), procdata);
- gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
-
-
- vbox2 = gtk_vbox_new (FALSE, 6);
- gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
-
- label = gtk_label_new (" ");
- gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
-
- tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
- label = gtk_label_new (NULL);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
- gtk_label_set_markup (GTK_LABEL (label), tmp);
- g_free (tmp);
- gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
-
- hbox = gtk_hbox_new (FALSE, 0);
- gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
-
- label = gtk_label_new (" ");
- gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
-
- vbox3 = create_field_page (procdata->disk_list, _("File system i_nformation shown in list:"));
- gtk_box_pack_start (GTK_BOX (hbox), vbox3, TRUE, TRUE, 0);
-
- gtk_widget_show_all (dialog);
- g_signal_connect (G_OBJECT (dialog), "response",
- G_CALLBACK (prefs_dialog_button_pressed), procdata);
-
- switch (procdata->config.current_tab) {
- case PROCMAN_TAB_SYSINFO:
- case PROCMAN_TAB_PROCESSES:
- gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
- break;
- case PROCMAN_TAB_RESOURCES:
- gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 1);
- break;
- case PROCMAN_TAB_DISKS:
- gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 2);
- break;
-
- }
+ static GtkWidget *dialog = NULL;
+
+ typedef SpinButtonUpdater SBU;
+
+ static SBU interval_updater("update-interval");
+ static SBU graph_interval_updater("graph-update-interval");
+ static SBU disks_interval_updater("disks-interval");
+
+ GtkWidget *notebook;
+ GtkWidget *proc_box;
+ GtkWidget *sys_box;
+ GtkWidget *main_vbox;
+ GtkWidget *vbox, *vbox2, *vbox3;
+ GtkWidget *hbox, *hbox2, *hbox3;
+ GtkWidget *label;
+ GtkAdjustment *adjustment;
+ GtkWidget *spin_button;
+ GtkWidget *check_button;
+ GtkWidget *tab_label;
+ GtkWidget *smooth_button;
+ GtkSizeGroup *size;
+ gfloat update;
+ gchar *tmp;
+
+ if (prefs_dialog)
+ return;
+
+ size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
+
+ dialog = gtk_dialog_new_with_buttons (_("System Monitor Preferences"),
+ GTK_WINDOW (procdata->app),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
+ NULL);
+ /* FIXME: we should not declare the window size, but let it's */
+ /* driven by window childs. The problem is that the fields list */
+ /* have to show at least 4 items to respect HIG. I don't know */
+ /* any function to set list height by contents/items inside it. */
+ gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 420);
+ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
+ prefs_dialog = dialog;
+
+ main_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
+ gtk_box_set_spacing (GTK_BOX (main_vbox), 2);
+
+ notebook = gtk_notebook_new ();
+ gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
+ gtk_box_pack_start (GTK_BOX (main_vbox), notebook, TRUE, TRUE, 0);
+
+ proc_box = gtk_vbox_new (FALSE, 18);
+ gtk_container_set_border_width (GTK_CONTAINER (proc_box), 12);
+ tab_label = gtk_label_new (_("Processes"));
+ gtk_widget_show (tab_label);
+ gtk_notebook_append_page (GTK_NOTEBOOK (notebook), proc_box, tab_label);
+
+ vbox = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (proc_box), vbox, FALSE, FALSE, 0);
+
+ tmp = g_strdup_printf ("<b>%s</b>", _("Behavior"));
+ label = gtk_label_new (NULL);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_label_set_markup (GTK_LABEL (label), tmp);
+ g_free (tmp);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ label = gtk_label_new (" ");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+
+ vbox2 = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
+
+ hbox2 = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
+
+ label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
+
+ hbox3 = gtk_hbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
+
+ update = (gfloat) procdata->config.update_interval;
+ adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0,
+ MIN_UPDATE_INTERVAL / 1000,
+ MAX_UPDATE_INTERVAL / 1000,
+ 0.25,
+ 1.0,
+ 0);
+
+ spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
+ gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
+ g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
+ G_CALLBACK (SBU::callback), &interval_updater);
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
+
+
+ hbox2 = gtk_hbox_new(FALSE, 6);
+ gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
+
+ smooth_button = gtk_check_button_new_with_mnemonic(_("Enable _smooth refresh"));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(smooth_button),
+ g_settings_get_boolean(procdata->settings,
+ SmoothRefresh::KEY.c_str()));
+ g_signal_connect(G_OBJECT(smooth_button), "toggled",
+ G_CALLBACK(smooth_refresh_toggled), procdata);
+ gtk_box_pack_start(GTK_BOX(hbox2), smooth_button, TRUE, TRUE, 0);
+
+
+
+ hbox2 = gtk_hbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
+
+ check_button = gtk_check_button_new_with_mnemonic (_("Alert before ending or _killing processes"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
+ procdata->config.show_kill_warning);
+ g_signal_connect (G_OBJECT (check_button), "toggled",
+ G_CALLBACK (show_kill_dialog_toggled), procdata);
+ gtk_box_pack_start (GTK_BOX (hbox2), check_button, TRUE, TRUE, 0);
+
+
+
+
+ hbox2 = gtk_hbox_new(FALSE, 6);
+ gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
+
+ GtkWidget *solaris_button = gtk_check_button_new_with_mnemonic(_("Divide CPU usage by CPU count"));
+ gtk_widget_set_tooltip_text(solaris_button, _("Solaris mode"));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(solaris_button),
+ g_settings_get_boolean(procdata->settings,
+ procman::settings::solaris_mode.c_str()));
+ g_signal_connect(G_OBJECT(solaris_button), "toggled",
+ G_CALLBACK(solaris_mode_toggled), procdata);
+ gtk_box_pack_start(GTK_BOX(hbox2), solaris_button, TRUE, TRUE, 0);
+
+
+
+
+ hbox2 = gtk_hbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
+
+ vbox = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (proc_box), vbox, TRUE, TRUE, 0);
+
+ tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
+ label = gtk_label_new (NULL);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_label_set_markup (GTK_LABEL (label), tmp);
+ g_free (tmp);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+ label = gtk_label_new (" ");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+
+ vbox2 = create_field_page (procdata->tree, _("Process i_nformation shown in list:"));
+ gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
+
+ sys_box = gtk_vbox_new (FALSE, 12);
+ gtk_container_set_border_width (GTK_CONTAINER (sys_box), 12);
+ tab_label = gtk_label_new (_("Resources"));
+ gtk_widget_show (tab_label);
+ gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label);
+
+ vbox = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (sys_box), vbox, FALSE, FALSE, 0);
+
+ tmp = g_strdup_printf ("<b>%s</b>", _("Graphs"));
+ label = gtk_label_new (NULL);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_label_set_markup (GTK_LABEL (label), tmp);
+ g_free (tmp);
+ gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ label = gtk_label_new (" ");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+
+ vbox2 = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
+
+ hbox2 = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
+
+ label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
+ gtk_size_group_add_widget (size, label);
+
+ hbox3 = gtk_hbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
+
+ update = (gfloat) procdata->config.graph_update_interval;
+ adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25,
+ 100.0, 0.25, 1.0, 0);
+ spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
+ g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
+ G_CALLBACK(SBU::callback),
+ &graph_interval_updater);
+ gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
+
+
+ GtkWidget *bits_button;
+ bits_button = gtk_check_button_new_with_mnemonic(_("Show network speed in bits"));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bits_button),
+ g_settings_get_boolean(procdata->settings,
+ procman::settings::network_in_bits.c_str()));
+ g_signal_connect(G_OBJECT(bits_button), "toggled",
+ G_CALLBACK(network_in_bits_toggled), procdata);
+ gtk_box_pack_start(GTK_BOX(vbox2), bits_button, TRUE, TRUE, 0);
+
+
+
+ hbox2 = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
+
+ /*
+ * Devices
+ */
+ vbox = gtk_vbox_new (FALSE, 6);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
+ tab_label = gtk_label_new (_("File Systems"));
+ gtk_widget_show (tab_label);
+ gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, tab_label);
+
+ tmp = g_strdup_printf ("<b>%s</b>", _("File Systems"));
+ label = gtk_label_new (NULL);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_label_set_markup (GTK_LABEL (label), tmp);
+ g_free (tmp);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+ label = gtk_label_new (" ");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+
+ vbox2 = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
+
+ hbox2 = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
+
+ label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
+
+ hbox3 = gtk_hbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
+
+ update = (gfloat) procdata->config.disks_update_interval;
+ adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0,
+ 100.0, 1.0, 1.0, 0);
+ spin_button = gtk_spin_button_new (adjustment, 1.0, 0);
+ gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
+ g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
+ G_CALLBACK(SBU::callback),
+ &disks_interval_updater);
+
+
+ hbox2 = gtk_hbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
+ check_button = gtk_check_button_new_with_mnemonic (_("Show _all filesystems"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
+ procdata->config.show_all_fs);
+ g_signal_connect (G_OBJECT (check_button), "toggled",
+ G_CALLBACK (show_all_fs_toggled), procdata);
+ gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
+
+
+ vbox2 = gtk_vbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
+
+ label = gtk_label_new (" ");
+ gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
+
+ tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
+ label = gtk_label_new (NULL);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+ gtk_label_set_markup (GTK_LABEL (label), tmp);
+ g_free (tmp);
+ gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
+
+ label = gtk_label_new (" ");
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+
+ vbox3 = create_field_page (procdata->disk_list, _("File system i_nformation shown in list:"));
+ gtk_box_pack_start (GTK_BOX (hbox), vbox3, TRUE, TRUE, 0);
+
+ gtk_widget_show_all (dialog);
+ g_signal_connect (G_OBJECT (dialog), "response",
+ G_CALLBACK (prefs_dialog_button_pressed), procdata);
+
+ switch (procdata->config.current_tab) {
+ case PROCMAN_TAB_SYSINFO:
+ case PROCMAN_TAB_PROCESSES:
+ gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
+ break;
+ case PROCMAN_TAB_RESOURCES:
+ gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 1);
+ break;
+ case PROCMAN_TAB_DISKS:
+ gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 2);
+ break;
+
+ }
}
static char *
procman_action_to_command(ProcmanActionType type,
- gint pid,
- gint extra_value)
+ gint pid,
+ gint extra_value)
{
- switch (type) {
- case PROCMAN_ACTION_KILL:
- return g_strdup_printf("kill -s %d %d", extra_value, pid);
- case PROCMAN_ACTION_RENICE:
- return g_strdup_printf("renice %d %d", extra_value, pid);
- default:
- g_assert_not_reached();
- }
+ switch (type) {
+ case PROCMAN_ACTION_KILL:
+ return g_strdup_printf("kill -s %d %d", extra_value, pid);
+ case PROCMAN_ACTION_RENICE:
+ return g_strdup_printf("renice %d %d", extra_value, pid);
+ default:
+ g_assert_not_reached();
+ }
}
@@ -797,24 +797,24 @@ procman_action_to_command(ProcmanActionType type,
*/
gboolean
procdialog_create_root_password_dialog(ProcmanActionType type,
- ProcData *procdata,
- gint pid,
- gint extra_value)
+ ProcData *procdata,
+ gint pid,
+ gint extra_value)
{
- char * command;
- gboolean ret = FALSE;
+ char * command;
+ gboolean ret = FALSE;
- command = procman_action_to_command(type, pid, extra_value);
+ command = procman_action_to_command(type, pid, extra_value);
- procman_debug("Trying to run '%s' as root", command);
+ procman_debug("Trying to run '%s' as root", command);
- if (procman_has_gksu())
- ret = procman_gksu_create_root_password_dialog(command);
- else if (procman_has_gnomesu())
- ret = procman_gnomesu_create_root_password_dialog(command);
+ if (procman_has_gksu())
+ ret = procman_gksu_create_root_password_dialog(command);
+ else if (procman_has_gnomesu())
+ ret = procman_gnomesu_create_root_password_dialog(command);
- g_free(command);
- return ret;
+ g_free(command);
+ return ret;
}
diff --git a/src/procdialogs.h b/src/procdialogs.h
index 61decf8..752fa35 100644
--- a/src/procdialogs.h
+++ b/src/procdialogs.h
@@ -37,18 +37,18 @@
typedef enum
{
- PROCMAN_ACTION_RENICE,
- PROCMAN_ACTION_KILL
+ PROCMAN_ACTION_RENICE,
+ PROCMAN_ACTION_KILL
} ProcmanActionType;
-void procdialog_create_kill_dialog (ProcData *data, int signal);
-void procdialog_create_renice_dialog (ProcData *data);
-gboolean procdialog_create_root_password_dialog (ProcmanActionType type,
- ProcData *procdata,
- gint pid, gint extra_value);
-void procdialog_create_memmaps_dialog (ProcData *data);
-void procdialog_create_preferences_dialog (ProcData *data);
+void procdialog_create_kill_dialog (ProcData *data, int signal);
+void procdialog_create_renice_dialog (ProcData *data);
+gboolean procdialog_create_root_password_dialog (ProcmanActionType type,
+ ProcData *procdata,
+ gint pid, gint extra_value);
+void procdialog_create_memmaps_dialog (ProcData *data);
+void procdialog_create_preferences_dialog (ProcData *data);
#endif
diff --git a/src/procman.cpp b/src/procman.cpp
index daebdc7..dcefa18 100644
--- a/src/procman.cpp
+++ b/src/procman.cpp
@@ -48,301 +48,301 @@
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)
+ : 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;
+ static ProcData instance;
+ return &instance;
}
static void
tree_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcData *procdata = static_cast<ProcData*>(data);
- procdata->config.show_tree = g_settings_get_boolean(settings, key);
+ procdata->config.show_tree = g_settings_get_boolean(settings, key);
- g_object_set(G_OBJECT(procdata->tree),
- "show-expanders", procdata->config.show_tree,
- NULL);
+ g_object_set(G_OBJECT(procdata->tree),
+ "show-expanders", procdata->config.show_tree,
+ NULL);
- proctable_clear_tree (procdata);
- proctable_update_all (procdata);
+ proctable_clear_tree (procdata);
+ proctable_update_all (procdata);
}
static void
solaris_mode_changed_cb(GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcData *procdata = static_cast<ProcData*>(data);
- procdata->config.solaris_mode = g_settings_get_boolean(settings, key);
- proctable_update_all (procdata);
+ procdata->config.solaris_mode = g_settings_get_boolean(settings, key);
+ proctable_update_all (procdata);
}
static void
network_in_bits_changed_cb(GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcData *procdata = static_cast<ProcData*>(data);
- procdata->config.network_in_bits = g_settings_get_boolean(settings, key);
- // force scale to be redrawn
- procdata->net_graph->clear_background();
+ procdata->config.network_in_bits = g_settings_get_boolean(settings, key);
+ // force scale to be redrawn
+ procdata->net_graph->clear_background();
}
static void
view_as_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcData *procdata = static_cast<ProcData*>(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);
+ 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);
}
static void
warning_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData *procdata = static_cast<ProcData*>(data);
+ ProcData *procdata = static_cast<ProcData*>(data);
- if (g_str_equal (key, "kill-dialog")) {
- procdata->config.show_kill_warning = g_settings_get_boolean (settings, key);
- }
+ if (g_str_equal (key, "kill-dialog")) {
+ procdata->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);
-
- 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);
-
- procdata->smooth_refresh->reset();
-
- if(procdata->timeout) {
- g_source_remove (procdata->timeout);
- procdata->timeout = g_timeout_add (procdata->config.update_interval,
- cb_timeout,
- procdata);
- }
- }
- 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,
- 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);
- }
- 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);
-
- if(procdata->disk_timeout) {
- g_source_remove (procdata->disk_timeout);
- procdata->disk_timeout = \
- g_timeout_add (procdata->config.disks_update_interval,
- cb_update_disks,
- procdata);
- }
- }
- else {
- g_assert_not_reached();
- }
+ ProcData *procdata = static_cast<ProcData*>(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);
+
+ procdata->smooth_refresh->reset();
+
+ if(procdata->timeout) {
+ g_source_remove (procdata->timeout);
+ procdata->timeout = g_timeout_add (procdata->config.update_interval,
+ cb_timeout,
+ procdata);
+ }
+ }
+ 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,
+ 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);
+ }
+ 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);
+
+ if(procdata->disk_timeout) {
+ g_source_remove (procdata->disk_timeout);
+ procdata->disk_timeout = \
+ g_timeout_add (procdata->config.disks_update_interval,
+ cb_update_disks,
+ procdata);
+ }
+ }
+ else {
+ g_assert_not_reached();
+ }
}
static void
color_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
- const gchar *color = g_settings_get_string (settings, key);
-
- if (g_str_has_prefix (key, "cpu-color")) {
- for (int i = 0; i < procdata->config.num_cpus; i++) {
- string cpu_key = make_string(g_strdup_printf("cpu-color%d", i%4));
- if (cpu_key == key) {
- gdk_color_parse (color, &procdata->config.cpu_color[i]);
- procdata->cpu_graph->colors.at(i) = procdata->config.cpu_color[i];
- break;
- }
- }
- }
- else 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;
- }
- 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;
- }
- 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;
- }
- 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;
- }
- else {
- g_assert_not_reached();
- }
+ ProcData * const procdata = static_cast<ProcData*>(data);
+ const gchar *color = g_settings_get_string (settings, key);
+
+ if (g_str_has_prefix (key, "cpu-color")) {
+ for (int i = 0; i < procdata->config.num_cpus; i++) {
+ string cpu_key = make_string(g_strdup_printf("cpu-color%d", i%4));
+ if (cpu_key == key) {
+ gdk_color_parse (color, &procdata->config.cpu_color[i]);
+ procdata->cpu_graph->colors.at(i) = procdata->config.cpu_color[i];
+ break;
+ }
+ }
+ }
+ else 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;
+ }
+ 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;
+ }
+ 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;
+ }
+ 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;
+ }
+ else {
+ g_assert_not_reached();
+ }
}
static void
show_all_fs_changed_cb (GSettings *settings, const gchar *key, gpointer data)
{
- ProcData * const procdata = static_cast<ProcData*>(data);
+ ProcData * const procdata = static_cast<ProcData*>(data);
- procdata->config.show_all_fs = g_settings_get_boolean (settings, key);
+ procdata->config.show_all_fs = g_settings_get_boolean (settings, key);
- cb_update_disks (data);
+ cb_update_disks (data);
}
static ProcData *
procman_data_new (GSettings *settings)
{
- ProcData *pd;
- gchar *color;
- gint swidth, sheight;
- gint i;
- glibtop_cpu cpu;
-
- pd = ProcData::get_instance();
-
- pd->config.width = g_settings_get_int (settings, "width");
- pd->config.height = g_settings_get_int (settings, "height");
- 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);
-
- pd->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);
-
- pd->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);
-
- 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,
- "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);
-
-
- /* 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);
-
-
- 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");
-
- /* Determinie number of cpus since libgtop doesn't really tell you*/
- pd->config.num_cpus = 0;
- glibtop_get_cpu (&cpu);
- pd->frequency = cpu.frequency;
- i=0;
- while (i < GLIBTOP_NCPU && cpu.xcpu_total[i] != 0) {
- pd->config.num_cpus ++;
- i++;
- }
- if (pd->config.num_cpus == 0)
- pd->config.num_cpus = 1;
-
- for (int i = 0; i < pd->config.num_cpus; i++) {
- gchar *key;
- key = g_strdup_printf ("cpu-color%d", i%4);
-
- color = g_settings_get_string (settings, key);
- if (!color)
- color = g_strdup ("#f25915e815e8");
-
- detail_string = std::string("changed::") + std::string(key);
- g_signal_connect (G_OBJECT(settings), detail_string.c_str(),
- G_CALLBACK(color_changed_cb), pd);
- gdk_color_parse(color, &pd->config.cpu_color[i]);
- g_free (color);
- g_free (key);
- }
- 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_free (color);
-
- color = g_settings_get_string (settings, "swap-color");
- if (!color)
- color = g_strdup ("#00b6000000ff");
- g_signal_connect (G_OBJECT(settings), "changed::swap-color",
+ ProcData *pd;
+ gchar *color;
+ gint swidth, sheight;
+ gint i;
+ glibtop_cpu cpu;
+
+ pd = ProcData::get_instance();
+
+ pd->config.width = g_settings_get_int (settings, "width");
+ pd->config.height = g_settings_get_int (settings, "height");
+ 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);
+
+ pd->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);
+
+ pd->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);
+
+ 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,
+ "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);
+
+
+ /* 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);
+
+
+ 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");
+
+ /* Determinie number of cpus since libgtop doesn't really tell you*/
+ pd->config.num_cpus = 0;
+ glibtop_get_cpu (&cpu);
+ pd->frequency = cpu.frequency;
+ i=0;
+ while (i < GLIBTOP_NCPU && cpu.xcpu_total[i] != 0) {
+ pd->config.num_cpus ++;
+ i++;
+ }
+ if (pd->config.num_cpus == 0)
+ pd->config.num_cpus = 1;
+
+ for (int i = 0; i < pd->config.num_cpus; i++) {
+ gchar *key;
+ key = g_strdup_printf ("cpu-color%d", i%4);
+
+ color = g_settings_get_string (settings, key);
+ if (!color)
+ color = g_strdup ("#f25915e815e8");
+
+ detail_string = std::string("changed::") + std::string(key);
+ g_signal_connect (G_OBJECT(settings), detail_string.c_str(),
G_CALLBACK(color_changed_cb), pd);
- gdk_color_parse(color, &pd->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_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_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);
-
- return pd;
+ gdk_color_parse(color, &pd->config.cpu_color[i]);
+ g_free (color);
+ g_free (key);
+ }
+ 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_free (color);
+
+ color = g_settings_get_string (settings, "swap-color");
+ 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_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_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_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);
+
+ return pd;
}
@@ -350,248 +350,248 @@ static void
procman_free_data (ProcData *procdata)
{
- proctable_free_table (procdata);
- delete procdata->smooth_refresh;
+ proctable_free_table (procdata);
+ delete procdata->smooth_refresh;
}
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"))
+ 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)
{
- 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);
- }
+ 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;
+ }
+
+ if(!g_strcmp0(child_schema, "proctree") ||
+ !g_strcmp0(child_schema, "disktreenew"))
+ {
+ GVariant *value;
+ GVariantIter iter;
+ int sortIndex;
- GSList *order = NULL;
+ GSList *order = NULL;
- value = g_settings_get_value(pt_settings, "columns-order");
- g_variant_iter_init(&iter, value);
+ 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));
+ 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);
+ proctable_set_columns_order(GTK_TREE_VIEW(tree), order);
- g_slist_free(order);
- }
+ g_slist_free(order);
+ }
- g_object_unref(pt_settings);
- pt_settings = NULL;
+ g_object_unref(pt_settings);
+ pt_settings = NULL;
- g_list_free(columns);
-
- return TRUE;
+ g_list_free(columns);
+
+ return TRUE;
}
void
procman_save_tree_state (GSettings *settings, GtkWidget *tree, const gchar *child_schema)
{
- GtkTreeModel *model;
- GList *it, *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"))
+ GtkTreeModel *model;
+ GList *it, *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"))
+ {
+ for(it = columns; it; it = it->next)
{
- for(it = columns; it; it = it->next)
- {
- GtkTreeViewColumn *column;
- gboolean visible;
- gint width;
- gchar *key;
- int id;
-
- column = static_cast<GtkTreeViewColumn*>(it->data);
- id = gtk_tree_view_column_get_sort_column_id (column);
- visible = gtk_tree_view_column_get_visible (column);
- width = gtk_tree_view_column_get_width (column);
-
- key = g_strdup_printf ("col-%d-width", id);
- g_settings_set_int (pt_settings, key, width);
- g_free (key);
-
- key = g_strdup_printf ("col-%d-visible", id);
- g_settings_set_boolean (pt_settings, key, visible);
- g_free (key);
- }
- }
-
- 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);
+ GtkTreeViewColumn *column;
+ gboolean visible;
+ gint width;
+ gchar *key;
+ int id;
+
+ column = static_cast<GtkTreeViewColumn*>(it->data);
+ id = gtk_tree_view_column_get_sort_column_id (column);
+ visible = gtk_tree_view_column_get_visible (column);
+ width = gtk_tree_view_column_get_width (column);
+
+ key = g_strdup_printf ("col-%d-width", id);
+ g_settings_set_int (pt_settings, key, width);
+ g_free (key);
+
+ key = g_strdup_printf ("col-%d-visible", id);
+ g_settings_set_boolean (pt_settings, key, visible);
+ g_free (key);
}
+ }
+
+ 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);
- g_list_free(columns);
+ 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;
+ 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");
+ g_assert(data);
- 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));
+ procman_save_tree_state (data->settings, data->tree, "proctree");
+ procman_save_tree_state (data->settings, data->disk_list, "disktreenew");
- g_settings_set_int (settings, "width", data->config.width);
- g_settings_set_int (settings, "height", data->config.height);
- g_settings_set_int (settings, "current-tab", data->config.current_tab);
+ 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));
- g_settings_sync ();
+ g_settings_set_int (settings, "width", data->config.width);
+ g_settings_set_int (settings, "height", data->config.height);
+ g_settings_set_int (settings, "current-tab", data->config.current_tab);
+
+ g_settings_sync ();
}
static guint32
get_startup_timestamp ()
{
- const gchar *startup_id_env;
- gchar *startup_id = NULL;
- gchar *time_str;
- gulong retval = 0;
+ const gchar *startup_id_env;
+ gchar *startup_id = NULL;
+ gchar *time_str;
+ gulong retval = 0;
- /* we don't unset the env, since startup-notification
- * may still need it */
- startup_id_env = g_getenv ("DESKTOP-STARTUP-ID");
- if (startup_id_env == NULL)
- goto out;
+ /* we don't unset the env, since startup-notification
+ * may still need it */
+ startup_id_env = g_getenv ("DESKTOP-STARTUP-ID");
+ if (startup_id_env == NULL)
+ goto out;
- startup_id = g_strdup (startup_id_env);
+ startup_id = g_strdup (startup_id_env);
- time_str = g_strrstr (startup_id, "_TIME");
- if (time_str == NULL)
- goto out;
+ time_str = g_strrstr (startup_id, "_TIME");
+ if (time_str == NULL)
+ goto out;
- /* Skip past the "_TIME" part */
- time_str += 5;
+ /* Skip past the "_TIME" part */
+ time_str += 5;
- retval = strtoul (time_str, NULL, 0);
+ retval = strtoul (time_str, NULL, 0);
- out:
- g_free (startup_id);
+ out:
+ g_free (startup_id);
- return retval;
+ return retval;
}
static void
cb_server (const gchar *msg, gpointer user_data)
{
- GdkWindow *window;
- ProcData *procdata;
- guint32 timestamp = 0;
+ GdkWindow *window;
+ ProcData *procdata;
+ guint32 timestamp = 0;
- window = gdk_get_default_root_window ();
+ window = gdk_get_default_root_window ();
- procdata = *(ProcData**)user_data;
- g_assert (procdata != NULL);
+ procdata = *(ProcData**)user_data;
+ g_assert (procdata != NULL);
- procman_debug("cb_server(%s)", msg);
- if (msg != NULL && procman::SHOW_SYSTEM_TAB_CMD == msg) {
- procman_debug("Changing to PROCMAN_TAB_SYSINFO via bacon message");
- gtk_notebook_set_current_page(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO);
- cb_change_current_page(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO, procdata);
- } else
- timestamp = strtoul(msg, NULL, 0);
+ procman_debug("cb_server(%s)", msg);
+ if (msg != NULL && procman::SHOW_SYSTEM_TAB_CMD == msg) {
+ procman_debug("Changing to PROCMAN_TAB_SYSINFO via bacon message");
+ gtk_notebook_set_current_page(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO);
+ cb_change_current_page(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO, procdata);
+ } else
+ timestamp = strtoul(msg, NULL, 0);
- if (timestamp == 0)
- {
- /* fall back to rountripping to X */
- timestamp = gdk_x11_get_server_time (window);
- }
+ if (timestamp == 0)
+ {
+ /* fall back to rountripping to X */
+ timestamp = gdk_x11_get_server_time (window);
+ }
- gdk_x11_window_set_user_time (window, timestamp);
+ gdk_x11_window_set_user_time (window, timestamp);
- gtk_window_present (GTK_WINDOW(procdata->app));
+ gtk_window_present (GTK_WINDOW(procdata->app));
}
@@ -600,27 +600,27 @@ cb_server (const gchar *msg, gpointer user_data)
static void
mount_changed(const Glib::RefPtr<Gio::Mount>&)
{
- cb_update_disks(ProcData::get_instance());
+ cb_update_disks(ProcData::get_instance());
}
static void
init_volume_monitor(ProcData *procdata)
{
- using namespace Gio;
- using namespace Glib;
+ using namespace Gio;
+ using namespace Glib;
- RefPtr<VolumeMonitor> monitor = VolumeMonitor::get();
+ 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::ptr_fun(&mount_changed));
+ monitor->signal_mount_changed().connect(sigc::ptr_fun(&mount_changed));
+ monitor->signal_mount_removed().connect(sigc::ptr_fun(&mount_changed));
}
namespace procman
{
- const std::string SHOW_SYSTEM_TAB_CMD("SHOWSYSTAB");
+ const std::string SHOW_SYSTEM_TAB_CMD("SHOWSYSTAB");
}
@@ -628,104 +628,104 @@ namespace procman
int
main (int argc, char *argv[])
{
- guint32 startup_timestamp;
- GSettings *settings;
- ProcData *procdata;
- BaconMessageConnection *conn;
+ guint32 startup_timestamp;
+ GSettings *settings;
+ ProcData *procdata;
+ BaconMessageConnection *conn;
+
+ bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
+ bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+ textdomain (GETTEXT_PACKAGE);
+ setlocale (LC_ALL, "");
+
+ startup_timestamp = get_startup_timestamp();
+
+ Glib::OptionContext context;
+ context.set_summary(_("A simple process and system monitor."));
+ context.set_ignore_unknown_options(true);
+ procman::OptionGroup option_group;
+ context.set_main_group(option_group);
+
+ try {
+ context.parse(argc, argv);
+ } catch (const Glib::Error& ex) {
+ g_error("Arguments parse error : %s", ex.what().c_str());
+ }
+
+ Gio::init();
+ Gtk::Main kit(&argc, &argv);
+ procman_debug("post gtk_init");
+
+ conn = bacon_message_connection_new ("gnome-system-monitor");
+ if (!conn) g_error("Couldn't connect to gnome-system-monitor");
- bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
- bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
- textdomain (GETTEXT_PACKAGE);
- setlocale (LC_ALL, "");
-
- startup_timestamp = get_startup_timestamp();
+ if (bacon_message_connection_get_is_server (conn))
+ {
+ bacon_message_connection_set_callback (conn, cb_server, &procdata);
+ }
+ else /* client */
+ {
+ char *timestamp;
- Glib::OptionContext context;
- context.set_summary(_("A simple process and system monitor."));
- context.set_ignore_unknown_options(true);
- procman::OptionGroup option_group;
- context.set_main_group(option_group);
+ timestamp = g_strdup_printf ("%" G_GUINT32_FORMAT, startup_timestamp);
- try {
- context.parse(argc, argv);
- } catch (const Glib::Error& ex) {
- g_error("Arguments parse error : %s", ex.what().c_str());
- }
+ if (option_group.show_system_tab)
+ bacon_message_connection_send(conn, procman::SHOW_SYSTEM_TAB_CMD.c_str());
- Gio::init();
- Gtk::Main kit(&argc, &argv);
- procman_debug("post gtk_init");
+ bacon_message_connection_send (conn, timestamp);
- conn = bacon_message_connection_new ("gnome-system-monitor");
- if (!conn) g_error("Couldn't connect to gnome-system-monitor");
+ gdk_notify_startup_complete ();
- if (bacon_message_connection_get_is_server (conn))
- {
- bacon_message_connection_set_callback (conn, cb_server, &procdata);
- }
- else /* client */
- {
- char *timestamp;
+ g_free (timestamp);
+ bacon_message_connection_free (conn);
- timestamp = g_strdup_printf ("%" G_GUINT32_FORMAT, startup_timestamp);
+ exit (0);
+ }
- if (option_group.show_system_tab)
- bacon_message_connection_send(conn, procman::SHOW_SYSTEM_TAB_CMD.c_str());
+ /* initialize rsvg */
+ rsvg_init ();
- bacon_message_connection_send (conn, timestamp);
+ gtk_window_set_default_icon_name ("utilities-system-monitor");
+ g_set_application_name(_("System Monitor"));
- gdk_notify_startup_complete ();
+ settings = g_settings_new (GSM_GSETTINGS_SCHEMA);
- g_free (timestamp);
- bacon_message_connection_free (conn);
+ glibtop_init ();
- exit (0);
- }
+ procman_debug("end init");
- /* initialize rsvg */
- rsvg_init ();
+ procdata = procman_data_new (settings);
+ procdata->settings = g_settings_new(GSM_GSETTINGS_SCHEMA);
- gtk_window_set_default_icon_name ("utilities-system-monitor");
- g_set_application_name(_("System Monitor"));
+ procman_debug("begin create_main_window");
+ create_main_window (procdata);
+ procman_debug("end create_main_window");
- settings = g_settings_new (GSM_GSETTINGS_SCHEMA);
+ // proctable_update_all (procdata);
- glibtop_init ();
+ init_volume_monitor (procdata);
- procman_debug("end init");
-
- procdata = procman_data_new (settings);
- procdata->settings = g_settings_new(GSM_GSETTINGS_SCHEMA);
+ g_assert(procdata->app);
- procman_debug("begin create_main_window");
- create_main_window (procdata);
- procman_debug("end create_main_window");
-
- // proctable_update_all (procdata);
+ if (option_group.show_system_tab) {
+ procman_debug("Starting with PROCMAN_TAB_SYSINFO by commandline request");
+ gtk_notebook_set_current_page(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO);
+ cb_change_current_page (GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO, procdata);
+ }
- init_volume_monitor (procdata);
+ gtk_widget_show(procdata->app);
- g_assert(procdata->app);
-
- if (option_group.show_system_tab) {
- procman_debug("Starting with PROCMAN_TAB_SYSINFO by commandline request");
- gtk_notebook_set_current_page(GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO);
- cb_change_current_page (GTK_NOTEBOOK(procdata->notebook), PROCMAN_TAB_SYSINFO, procdata);
- }
+ procman_debug("begin gtk_main");
+ kit.run();
- gtk_widget_show(procdata->app);
-
- procman_debug("begin gtk_main");
- kit.run();
-
- procman_free_data (procdata);
+ procman_free_data (procdata);
- glibtop_close ();
+ glibtop_close ();
- // This function should only be called just before program exit.
- // See GNOME bug #592100 for a discussion about this.
- rsvg_term ();
+ // This function should only be called just before program exit.
+ // See GNOME bug #592100 for a discussion about this.
+ rsvg_term ();
- return 0;
+ return 0;
}
diff --git a/src/procman.h b/src/procman.h
index 1c3585f..689560a 100644
--- a/src/procman.h
+++ b/src/procman.h
@@ -44,9 +44,9 @@ struct LoadGraph;
enum
{
- ALL_PROCESSES,
- MY_PROCESSES,
- ACTIVE_PROCESSES
+ ALL_PROCESSES,
+ MY_PROCESSES,
+ ACTIVE_PROCESSES
};
@@ -56,178 +56,178 @@ static const unsigned MAX_UPDATE_INTERVAL = 100 * 1000;
namespace procman
{
- extern const std::string SHOW_SYSTEM_TAB_CMD;
+ extern const std::string SHOW_SYSTEM_TAB_CMD;
}
enum ProcmanTab
{
- PROCMAN_TAB_SYSINFO,
- PROCMAN_TAB_PROCESSES,
- PROCMAN_TAB_RESOURCES,
- PROCMAN_TAB_DISKS
+ PROCMAN_TAB_SYSINFO,
+ PROCMAN_TAB_PROCESSES,
+ PROCMAN_TAB_RESOURCES,
+ PROCMAN_TAB_DISKS
};
struct ProcConfig
{
- gint width;
- gint height;
- 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;
+ gint width;
+ gint height;
+ 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;
+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;
};
class ProcInfo
- : public MutableProcInfo
+: public MutableProcInfo
{
- /* undefined */ ProcInfo& operator=(const ProcInfo&);
- /* undefined */ ProcInfo(const ProcInfo&);
+ /* undefined */ ProcInfo& operator=(const ProcInfo&);
+ /* undefined */ ProcInfo(const ProcInfo&);
- typedef std::map<guint, std::string> UserMap;
- /* cached username */
- static UserMap users;
+ typedef std::map<guint, std::string> UserMap;
+ /* cached username */
+ static UserMap users;
- public:
+ 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;
+ // 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 List all;
- static ProcInfo* find(pid_t pid);
- static Iterator begin() { return ProcInfo::all.begin(); }
- static Iterator end() { return ProcInfo::all.end(); }
+ 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);
+ ProcInfo(pid_t pid);
+ ~ProcInfo();
+ // adds one more ref to icon
+ void set_icon(Glib::RefPtr<Gdk::Pixbuf> icon);
+ void set_user(guint uid);
- GtkTreeIter node;
- Glib::RefPtr<Gdk::Pixbuf> pixbuf;
- gchar *tooltip;
- gchar *name;
- gchar *arguments;
+ GtkTreeIter node;
+ Glib::RefPtr<Gdk::Pixbuf> pixbuf;
+ gchar *tooltip;
+ gchar *name;
+ gchar *arguments;
- gchar *security_context;
+ gchar *security_context;
- const guint pid;
- guint ppid;
- guint uid;
+ 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;
+ // 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;
};
struct ProcData
{
- // lazy initialization
- static ProcData* get_instance();
-
- GtkUIManager *uimanager;
- GtkActionGroup *action_group;
- GtkWidget *statusbar;
- gint tip_message_cid;
- 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 *app;
- GtkUIManager *menu;
-
- unsigned frequency;
-
- SmoothRefresh *smooth_refresh;
-
- guint64 cpu_total_time;
- guint64 cpu_total_time_last;
+ // lazy initialization
+ static ProcData* get_instance();
+
+ GtkUIManager *uimanager;
+ GtkActionGroup *action_group;
+ GtkWidget *statusbar;
+ gint tip_message_cid;
+ 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 *app;
+ GtkUIManager *menu;
+
+ unsigned frequency;
+
+ SmoothRefresh *smooth_refresh;
+
+ guint64 cpu_total_time;
+ guint64 cpu_total_time_last;
private:
- ProcData();
- /* undefined */ ProcData(const ProcData &);
- /* undefined */ ProcData& operator=(const ProcData &);
+ ProcData();
+ /* undefined */ ProcData(const ProcData &);
+ /* undefined */ ProcData& operator=(const ProcData &);
};
-void procman_save_config (ProcData *data);
-void procman_save_tree_state (GSettings *settings, GtkWidget *tree, const gchar *prefix);
-gboolean procman_get_tree_state (GSettings *settings, GtkWidget *tree, const gchar *prefix);
+void procman_save_config (ProcData *data);
+void procman_save_tree_state (GSettings *settings, GtkWidget *tree, const gchar *prefix);
+gboolean procman_get_tree_state (GSettings *settings, GtkWidget *tree, const gchar *prefix);
@@ -235,15 +235,15 @@ gboolean procman_get_tree_state (GSettings *settings, GtkWidget *tree, const gch
struct ReniceArgs
{
- ProcData *procdata;
- int nice_value;
+ ProcData *procdata;
+ int nice_value;
};
struct KillArgs
{
- ProcData *procdata;
- int signal;
+ ProcData *procdata;
+ int signal;
};
#endif /* _PROCMAN_PROCMAN_H_ */
diff --git a/src/procman_gksu.cpp b/src/procman_gksu.cpp
index d2737cc..58faa0c 100644
--- a/src/procman_gksu.cpp
+++ b/src/procman_gksu.cpp
@@ -9,16 +9,16 @@ static gboolean (*gksu_run)(const char *, GError **);
static void load_gksu(void)
{
- static gboolean init;
+ static gboolean init;
- if (init)
- return;
+ if (init)
+ return;
- init = TRUE;
+ init = TRUE;
- load_symbols("libgksu2.so",
- "gksu_run", &gksu_run,
- NULL);
+ load_symbols("libgksu2.so",
+ "gksu_run", &gksu_run,
+ NULL);
}
@@ -27,20 +27,20 @@ static void load_gksu(void)
gboolean procman_gksu_create_root_password_dialog(const char *command)
{
- GError *e = NULL;
+ GError *e = NULL;
- /* Returns FALSE or TRUE on success, depends on version ... */
- gksu_run(command, &e);
+ /* Returns FALSE or TRUE on success, depends on version ... */
+ gksu_run(command, &e);
- if (e) {
- g_critical("Could not run gksu_run(\"%s\") : %s\n",
- command, e->message);
- g_error_free(e);
- return FALSE;
- }
+ if (e) {
+ g_critical("Could not run gksu_run(\"%s\") : %s\n",
+ command, e->message);
+ g_error_free(e);
+ return FALSE;
+ }
- g_message("gksu_run did fine\n");
- return TRUE;
+ g_message("gksu_run did fine\n");
+ return TRUE;
}
@@ -48,7 +48,7 @@ gboolean procman_gksu_create_root_password_dialog(const char *command)
gboolean
procman_has_gksu(void)
{
- load_gksu();
- return gksu_run != NULL;
+ load_gksu();
+ return gksu_run != NULL;
}
diff --git a/src/procman_gnomesu.cpp b/src/procman_gnomesu.cpp
index b93504b..42f891c 100644
--- a/src/procman_gnomesu.cpp
+++ b/src/procman_gnomesu.cpp
@@ -12,29 +12,29 @@ gboolean (*gnomesu_exec)(const char *commandline);
static void
load_gnomesu(void)
{
- static gboolean init;
+ static gboolean init;
- if (init)
- return;
+ if (init)
+ return;
- init = TRUE;
+ init = TRUE;
- load_symbols("libgnomesu.so.0",
- "gnomesu_exec", &gnomesu_exec,
- NULL);
+ load_symbols("libgnomesu.so.0",
+ "gnomesu_exec", &gnomesu_exec,
+ NULL);
}
gboolean
procman_gnomesu_create_root_password_dialog(const char *command)
{
- return gnomesu_exec(command);
+ return gnomesu_exec(command);
}
gboolean
procman_has_gnomesu(void)
{
- load_gnomesu();
- return gnomesu_exec != NULL;
+ load_gnomesu();
+ return gnomesu_exec != NULL;
}
diff --git a/src/proctable.cpp b/src/proctable.cpp
index 92d0538..473094a 100644
--- a/src/proctable.cpp
+++ b/src/proctable.cpp
@@ -60,8 +60,8 @@ std::map<pid_t, guint64> ProcInfo::cpu_times;
ProcInfo* ProcInfo::find(pid_t pid)
{
- Iterator it(ProcInfo::all.find(pid));
- return (it == ProcInfo::all.end() ? NULL : it->second);
+ Iterator it(ProcInfo::all.find(pid));
+ return (it == ProcInfo::all.end() ? NULL : it->second);
}
@@ -70,77 +70,77 @@ ProcInfo* ProcInfo::find(pid_t pid)
static void
set_proctree_reorderable(ProcData *procdata)
{
- GList *columns, *col;
- GtkTreeView *proctree;
+ GList *columns, *col;
+ GtkTreeView *proctree;
- proctree = GTK_TREE_VIEW(procdata->tree);
+ proctree = GTK_TREE_VIEW(procdata->tree);
- columns = gtk_tree_view_get_columns (proctree);
+ columns = gtk_tree_view_get_columns (proctree);
- for(col = columns; col; col = col->next)
- gtk_tree_view_column_set_reorderable(static_cast<GtkTreeViewColumn*>(col->data), TRUE);
+ for(col = columns; col; col = col->next)
+ gtk_tree_view_column_set_reorderable(static_cast<GtkTreeViewColumn*>(col->data), TRUE);
- g_list_free(columns);
+ g_list_free(columns);
}
static void
cb_columns_changed(GtkTreeView *treeview, gpointer user_data)
{
- ProcData * const procdata = static_cast<ProcData*>(user_data);
+ ProcData * const procdata = static_cast<ProcData*>(user_data);
- procman_save_tree_state(procdata->settings,
- GTK_WIDGET(treeview),
- "proctree");
+ procman_save_tree_state(procdata->settings,
+ GTK_WIDGET(treeview),
+ "proctree");
}
static GtkTreeViewColumn*
my_gtk_tree_view_get_column_with_sort_column_id(GtkTreeView *treeview, int id)
{
- GList *columns, *it;
- GtkTreeViewColumn *col = NULL;
+ GList *columns, *it;
+ GtkTreeViewColumn *col = NULL;
- columns = gtk_tree_view_get_columns(treeview);
+ columns = gtk_tree_view_get_columns(treeview);
- for(it = columns; it; it = it->next)
- {
- if(gtk_tree_view_column_get_sort_column_id(static_cast<GtkTreeViewColumn*>(it->data)) == id)
- {
- col = static_cast<GtkTreeViewColumn*>(it->data);
- break;
- }
- }
+ for(it = columns; it; it = it->next)
+ {
+ if(gtk_tree_view_column_get_sort_column_id(static_cast<GtkTreeViewColumn*>(it->data)) == id)
+ {
+ col = static_cast<GtkTreeViewColumn*>(it->data);
+ break;
+ }
+ }
- g_list_free(columns);
+ g_list_free(columns);
- return col;
+ return col;
}
void
proctable_set_columns_order(GtkTreeView *treeview, GSList *order)
{
- GtkTreeViewColumn* last = NULL;
- GSList *it;
+ GtkTreeViewColumn* last = NULL;
+ GSList *it;
- for(it = order; it; it = it->next)
- {
- int id;
- GtkTreeViewColumn *cur;
+ for(it = order; it; it = it->next)
+ {
+ int id;
+ GtkTreeViewColumn *cur;
- id = GPOINTER_TO_INT(it->data);
+ id = GPOINTER_TO_INT(it->data);
- g_assert(id >= 0 && id < NUM_COLUMNS);
+ g_assert(id >= 0 && id < NUM_COLUMNS);
- cur = my_gtk_tree_view_get_column_with_sort_column_id(treeview, id);
+ cur = my_gtk_tree_view_get_column_with_sort_column_id(treeview, id);
- if(cur && cur != last)
- {
- gtk_tree_view_move_column_after(treeview, cur, last);
- last = cur;
- }
- }
+ if(cur && cur != last)
+ {
+ gtk_tree_view_move_column_after(treeview, cur, last);
+ last = cur;
+ }
+ }
}
@@ -148,50 +148,50 @@ proctable_set_columns_order(GtkTreeView *treeview, GSList *order)
GSList*
proctable_get_columns_order(GtkTreeView *treeview)
{
- GList *columns, *col;
- GSList *order = NULL;
+ GList *columns, *col;
+ GSList *order = NULL;
- columns = gtk_tree_view_get_columns(treeview);
+ columns = gtk_tree_view_get_columns(treeview);
- for(col = columns; col; col = col->next)
- {
- int id;
+ for(col = columns; col; col = col->next)
+ {
+ int id;
- id = gtk_tree_view_column_get_sort_column_id(static_cast<GtkTreeViewColumn*>(col->data));
- order = g_slist_prepend(order, GINT_TO_POINTER(id));
- }
+ id = gtk_tree_view_column_get_sort_column_id(static_cast<GtkTreeViewColumn*>(col->data));
+ order = g_slist_prepend(order, GINT_TO_POINTER(id));
+ }
- g_list_free(columns);
+ g_list_free(columns);
- order = g_slist_reverse(order);
+ order = g_slist_reverse(order);
- return order;
+ return order;
}
static gboolean
search_equal_func(GtkTreeModel *model,
- gint column,
- const gchar *key,
- GtkTreeIter *iter,
- gpointer search_data)
+ gint column,
+ const gchar *key,
+ GtkTreeIter *iter,
+ gpointer search_data)
{
- char* name;
- char* user;
- gboolean found;
+ char* name;
+ char* user;
+ gboolean found;
- gtk_tree_model_get(model, iter,
- COL_NAME, &name,
- COL_USER, &user,
- -1);
+ gtk_tree_model_get(model, iter,
+ COL_NAME, &name,
+ COL_USER, &user,
+ -1);
- found = !((name && strstr(name, key))
- || (user && strstr(user, key)));
+ found = !((name && strstr(name, key))
+ || (user && strstr(user, key)));
- g_free(name);
- g_free(user);
+ g_free(name);
+ g_free(user);
- return found;
+ return found;
}
@@ -199,253 +199,253 @@ search_equal_func(GtkTreeModel *model,
GtkWidget *
proctable_new (ProcData * const procdata)
{
- GtkWidget *proctree;
- GtkWidget *scrolled;
- GtkTreeStore *model;
- GtkTreeSelection *selection;
- GtkTreeViewColumn *column;
- GtkCellRenderer *cell_renderer;
-
- const gchar *titles[] = {
- N_("Process Name"),
- N_("User"),
- N_("Status"),
- N_("Virtual Memory"),
- N_("Resident Memory"),
- N_("Writable Memory"),
- N_("Shared Memory"),
- N_("X Server Memory"),
- /* xgettext:no-c-format */ N_("% CPU"),
- N_("CPU Time"),
- N_("Started"),
- N_("Nice"),
- N_("ID"),
- N_("Security Context"),
- N_("Command Line"),
- N_("Memory"),
- /* xgettext: wchan, see ps(1) or top(1) */
- N_("Waiting Channel"),
- NULL,
- "POINTER"
- };
-
- gint i;
-
- scrolled = gtk_scrolled_window_new (NULL, NULL);
- gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
- GTK_POLICY_AUTOMATIC,
- GTK_POLICY_AUTOMATIC);
-
- model = gtk_tree_store_new (NUM_COLUMNS,
- G_TYPE_STRING, /* Process Name */
- G_TYPE_STRING, /* User */
- G_TYPE_UINT, /* Status */
- G_TYPE_ULONG, /* VM Size */
- G_TYPE_ULONG, /* Resident Memory */
- G_TYPE_ULONG, /* Writable Memory */
- G_TYPE_ULONG, /* Shared Memory */
- G_TYPE_ULONG, /* X Server Memory */
- G_TYPE_UINT, /* % CPU */
- G_TYPE_UINT64, /* CPU time */
- G_TYPE_ULONG, /* Started */
- G_TYPE_INT, /* Nice */
- G_TYPE_UINT, /* ID */
- G_TYPE_STRING, /* Security Context */
- G_TYPE_STRING, /* Arguments */
- G_TYPE_ULONG, /* Memory */
- G_TYPE_STRING, /* wchan */
- GDK_TYPE_PIXBUF, /* Icon */
- G_TYPE_POINTER, /* ProcInfo */
- G_TYPE_STRING /* Sexy tooltip */
- );
-
- 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,
- NULL);
- gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (proctree),
- search_equal_func,
- NULL,
- NULL);
- gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (proctree), TRUE);
- g_object_unref (G_OBJECT (model));
-
- selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree));
- gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
-
- column = gtk_tree_view_column_new ();
-
- cell_renderer = gtk_cell_renderer_pixbuf_new ();
- gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);
- gtk_tree_view_column_set_attributes (column, cell_renderer,
- "pixbuf", COL_PIXBUF,
- NULL);
-
- cell_renderer = gtk_cell_renderer_text_new ();
- gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);
- gtk_tree_view_column_set_attributes (column, cell_renderer,
- "text", COL_NAME,
- NULL);
- gtk_tree_view_column_set_title (column, _(titles[0]));
- gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
- gtk_tree_view_column_set_resizable (column, TRUE);
- gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
- gtk_tree_view_column_set_min_width (column, 1);
- gtk_tree_view_append_column (GTK_TREE_VIEW (proctree), column);
- gtk_tree_view_set_expander_column (GTK_TREE_VIEW (proctree), column);
-
-
- for (i = COL_USER; i <= COL_WCHAN; i++) {
-
- GtkCellRenderer *cell;
- GtkTreeViewColumn *col;
-
- cell = gtk_cell_renderer_text_new();
- col = gtk_tree_view_column_new();
- gtk_tree_view_column_pack_start(col, cell, TRUE);
- gtk_tree_view_column_set_title(col, _(titles[i]));
- gtk_tree_view_column_set_resizable(col, TRUE);
- gtk_tree_view_column_set_sort_column_id(col, i);
- gtk_tree_view_column_set_reorderable(col, TRUE);
- gtk_tree_view_append_column(GTK_TREE_VIEW(proctree), col);
-
- // type
- switch (i) {
- case COL_MEMXSERVER:
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::size_cell_data_func,
- GUINT_TO_POINTER(i),
- NULL);
- break;
-
- case COL_VMSIZE:
- case COL_MEMRES:
- case COL_MEMSHARED:
- case COL_MEM:
- case COL_MEMWRITABLE:
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::size_na_cell_data_func,
- GUINT_TO_POINTER(i),
- NULL);
- break;
-
- case COL_CPU_TIME:
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::duration_cell_data_func,
- GUINT_TO_POINTER(i),
- NULL);
- break;
-
- case COL_START_TIME:
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::time_cell_data_func,
- GUINT_TO_POINTER(i),
- NULL);
- break;
-
- case COL_STATUS:
- gtk_tree_view_column_set_cell_data_func(col, cell,
- &procman::status_cell_data_func,
- GUINT_TO_POINTER(i),
- NULL);
- break;
-
- default:
- gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL);
- break;
- }
-
- // xaling
- switch(i)
- {
- case COL_VMSIZE:
- case COL_MEMRES:
- case COL_MEMWRITABLE:
- case COL_MEMSHARED:
- case COL_MEMXSERVER:
- case COL_CPU:
- case COL_NICE:
- case COL_PID:
- case COL_CPU_TIME:
- case COL_MEM:
- g_object_set(G_OBJECT(cell), "xalign", 1.0f, NULL);
- break;
- }
-
- // sizing
- switch (i) {
- case COL_ARGS:
- gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
- gtk_tree_view_column_set_min_width(col, 150);
- break;
- default:
- gtk_tree_view_column_set_min_width(column, 20);
- break;
- }
- }
-
- gtk_container_add (GTK_CONTAINER (scrolled), proctree);
-
- procdata->tree = proctree;
-
- set_proctree_reorderable(procdata);
-
- procman_get_tree_state (procdata->settings, proctree, "proctree");
-
- /* Override column settings by hiding this column if it's meaningless: */
- if (!can_show_security_context_column ()) {
- GtkTreeViewColumn *column;
- column = my_gtk_tree_view_get_column_with_sort_column_id (GTK_TREE_VIEW (proctree), COL_SECURITYCONTEXT);
- gtk_tree_view_column_set_visible (column, FALSE);
- }
-
- g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree))),
- "changed",
- G_CALLBACK (cb_row_selected), procdata);
- g_signal_connect (G_OBJECT (proctree), "popup_menu",
- G_CALLBACK (cb_tree_popup_menu), procdata);
- g_signal_connect (G_OBJECT (proctree), "button_press_event",
- G_CALLBACK (cb_tree_button_pressed), procdata);
-
- g_signal_connect (G_OBJECT(proctree), "columns-changed",
- G_CALLBACK(cb_columns_changed), procdata);
-
- return scrolled;
+ GtkWidget *proctree;
+ GtkWidget *scrolled;
+ GtkTreeStore *model;
+ GtkTreeSelection *selection;
+ GtkTreeViewColumn *column;
+ GtkCellRenderer *cell_renderer;
+
+ const gchar *titles[] = {
+ N_("Process Name"),
+ N_("User"),
+ N_("Status"),
+ N_("Virtual Memory"),
+ N_("Resident Memory"),
+ N_("Writable Memory"),
+ N_("Shared Memory"),
+ N_("X Server Memory"),
+ /* xgettext:no-c-format */ N_("% CPU"),
+ N_("CPU Time"),
+ N_("Started"),
+ N_("Nice"),
+ N_("ID"),
+ N_("Security Context"),
+ N_("Command Line"),
+ N_("Memory"),
+ /* xgettext: wchan, see ps(1) or top(1) */
+ N_("Waiting Channel"),
+ NULL,
+ "POINTER"
+ };
+
+ gint i;
+
+ scrolled = gtk_scrolled_window_new (NULL, NULL);
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+
+ model = gtk_tree_store_new (NUM_COLUMNS,
+ G_TYPE_STRING, /* Process Name */
+ G_TYPE_STRING, /* User */
+ G_TYPE_UINT, /* Status */
+ G_TYPE_ULONG, /* VM Size */
+ G_TYPE_ULONG, /* Resident Memory */
+ G_TYPE_ULONG, /* Writable Memory */
+ G_TYPE_ULONG, /* Shared Memory */
+ G_TYPE_ULONG, /* X Server Memory */
+ G_TYPE_UINT, /* % CPU */
+ G_TYPE_UINT64, /* CPU time */
+ G_TYPE_ULONG, /* Started */
+ G_TYPE_INT, /* Nice */
+ G_TYPE_UINT, /* ID */
+ G_TYPE_STRING, /* Security Context */
+ G_TYPE_STRING, /* Arguments */
+ G_TYPE_ULONG, /* Memory */
+ G_TYPE_STRING, /* wchan */
+ GDK_TYPE_PIXBUF, /* Icon */
+ G_TYPE_POINTER, /* ProcInfo */
+ G_TYPE_STRING /* Sexy tooltip */
+ );
+
+ 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,
+ NULL);
+ gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (proctree),
+ search_equal_func,
+ NULL,
+ NULL);
+ gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (proctree), TRUE);
+ g_object_unref (G_OBJECT (model));
+
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree));
+ gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
+
+ column = gtk_tree_view_column_new ();
+
+ cell_renderer = gtk_cell_renderer_pixbuf_new ();
+ gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);
+ gtk_tree_view_column_set_attributes (column, cell_renderer,
+ "pixbuf", COL_PIXBUF,
+ NULL);
+
+ cell_renderer = gtk_cell_renderer_text_new ();
+ gtk_tree_view_column_pack_start (column, cell_renderer, FALSE);
+ gtk_tree_view_column_set_attributes (column, cell_renderer,
+ "text", COL_NAME,
+ NULL);
+ gtk_tree_view_column_set_title (column, _(titles[0]));
+ gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
+ gtk_tree_view_column_set_resizable (column, TRUE);
+ gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+ gtk_tree_view_column_set_min_width (column, 1);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (proctree), column);
+ gtk_tree_view_set_expander_column (GTK_TREE_VIEW (proctree), column);
+
+
+ for (i = COL_USER; i <= COL_WCHAN; i++) {
+
+ GtkCellRenderer *cell;
+ GtkTreeViewColumn *col;
+
+ cell = gtk_cell_renderer_text_new();
+ col = gtk_tree_view_column_new();
+ gtk_tree_view_column_pack_start(col, cell, TRUE);
+ gtk_tree_view_column_set_title(col, _(titles[i]));
+ gtk_tree_view_column_set_resizable(col, TRUE);
+ gtk_tree_view_column_set_sort_column_id(col, i);
+ gtk_tree_view_column_set_reorderable(col, TRUE);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(proctree), col);
+
+ // type
+ switch (i) {
+ case COL_MEMXSERVER:
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::size_cell_data_func,
+ GUINT_TO_POINTER(i),
+ NULL);
+ break;
+
+ case COL_VMSIZE:
+ case COL_MEMRES:
+ case COL_MEMSHARED:
+ case COL_MEM:
+ case COL_MEMWRITABLE:
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::size_na_cell_data_func,
+ GUINT_TO_POINTER(i),
+ NULL);
+ break;
+
+ case COL_CPU_TIME:
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::duration_cell_data_func,
+ GUINT_TO_POINTER(i),
+ NULL);
+ break;
+
+ case COL_START_TIME:
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::time_cell_data_func,
+ GUINT_TO_POINTER(i),
+ NULL);
+ break;
+
+ case COL_STATUS:
+ gtk_tree_view_column_set_cell_data_func(col, cell,
+ &procman::status_cell_data_func,
+ GUINT_TO_POINTER(i),
+ NULL);
+ break;
+
+ default:
+ gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL);
+ break;
+ }
+
+ // xaling
+ switch(i)
+ {
+ case COL_VMSIZE:
+ case COL_MEMRES:
+ case COL_MEMWRITABLE:
+ case COL_MEMSHARED:
+ case COL_MEMXSERVER:
+ case COL_CPU:
+ case COL_NICE:
+ case COL_PID:
+ case COL_CPU_TIME:
+ case COL_MEM:
+ g_object_set(G_OBJECT(cell), "xalign", 1.0f, NULL);
+ break;
+ }
+
+ // sizing
+ switch (i) {
+ case COL_ARGS:
+ gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
+ gtk_tree_view_column_set_min_width(col, 150);
+ break;
+ default:
+ gtk_tree_view_column_set_min_width(column, 20);
+ break;
+ }
+ }
+
+ gtk_container_add (GTK_CONTAINER (scrolled), proctree);
+
+ procdata->tree = proctree;
+
+ set_proctree_reorderable(procdata);
+
+ procman_get_tree_state (procdata->settings, proctree, "proctree");
+
+ /* Override column settings by hiding this column if it's meaningless: */
+ if (!can_show_security_context_column ()) {
+ GtkTreeViewColumn *column;
+ column = my_gtk_tree_view_get_column_with_sort_column_id (GTK_TREE_VIEW (proctree), COL_SECURITYCONTEXT);
+ gtk_tree_view_column_set_visible (column, FALSE);
+ }
+
+ g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (proctree))),
+ "changed",
+ G_CALLBACK (cb_row_selected), procdata);
+ g_signal_connect (G_OBJECT (proctree), "popup_menu",
+ G_CALLBACK (cb_tree_popup_menu), procdata);
+ g_signal_connect (G_OBJECT (proctree), "button_press_event",
+ G_CALLBACK (cb_tree_button_pressed), procdata);
+
+ g_signal_connect (G_OBJECT(proctree), "columns-changed",
+ G_CALLBACK(cb_columns_changed), procdata);
+
+ return scrolled;
}
ProcInfo::~ProcInfo()
{
- g_free(this->name);
- g_free(this->tooltip);
- g_free(this->arguments);
- g_free(this->security_context);
+ g_free(this->name);
+ g_free(this->tooltip);
+ g_free(this->arguments);
+ g_free(this->security_context);
}
static void
get_process_name (ProcInfo *info,
- const gchar *cmd, const GStrv args)
+ const gchar *cmd, const GStrv args)
{
- if (args) {
- // look for /usr/bin/very_long_name
- // and also /usr/bin/interpreter /usr/.../very_long_name
- // which may have use prctl to alter 'cmd' name
- for (int i = 0; i != 2 && args[i]; ++i) {
- char* basename;
- basename = g_path_get_basename(args[i]);
-
- if (g_str_has_prefix(basename, cmd)) {
- info->name = basename;
- return;
- }
-
- g_free(basename);
- }
- }
-
- info->name = g_strdup (cmd);
+ if (args) {
+ // look for /usr/bin/very_long_name
+ // and also /usr/bin/interpreter /usr/.../very_long_name
+ // which may have use prctl to alter 'cmd' name
+ for (int i = 0; i != 2 && args[i]; ++i) {
+ char* basename;
+ basename = g_path_get_basename(args[i]);
+
+ if (g_str_has_prefix(basename, cmd)) {
+ info->name = basename;
+ return;
+ }
+
+ g_free(basename);
+ }
+ }
+
+ info->name = g_strdup (cmd);
}
@@ -453,82 +453,82 @@ get_process_name (ProcInfo *info,
void
ProcInfo::set_user(guint uid)
{
- if (G_LIKELY(this->uid == uid))
- return;
+ if (G_LIKELY(this->uid == uid))
+ return;
- this->uid = uid;
+ this->uid = uid;
- typedef std::pair<ProcInfo::UserMap::iterator, bool> Pair;
- ProcInfo::UserMap::value_type hint(uid, "");
- Pair p(ProcInfo::users.insert(hint));
+ typedef std::pair<ProcInfo::UserMap::iterator, bool> Pair;
+ ProcInfo::UserMap::value_type hint(uid, "");
+ Pair p(ProcInfo::users.insert(hint));
- // procman_debug("User lookup for uid %u: %s", uid, (p.second ? "MISS" : "HIT"));
+ // procman_debug("User lookup for uid %u: %s", uid, (p.second ? "MISS" : "HIT"));
- if (p.second) {
- struct passwd* pwd;
- pwd = getpwuid(uid);
+ if (p.second) {
+ struct passwd* pwd;
+ pwd = getpwuid(uid);
- if (pwd && pwd->pw_name)
- p.first->second = pwd->pw_name;
- else {
- char username[16];
- g_sprintf(username, "%u", uid);
- p.first->second = username;
- }
- }
+ if (pwd && pwd->pw_name)
+ p.first->second = pwd->pw_name;
+ else {
+ char username[16];
+ g_sprintf(username, "%u", uid);
+ p.first->second = username;
+ }
+ }
- this->user = p.first->second;
+ this->user = p.first->second;
}
static void get_process_memory_writable(ProcInfo *info)
{
- glibtop_proc_map buf;
- glibtop_map_entry *maps;
+ glibtop_proc_map buf;
+ glibtop_map_entry *maps;
- maps = glibtop_get_proc_map(&buf, info->pid);
+ maps = glibtop_get_proc_map(&buf, info->pid);
- gulong memwritable = 0;
- const unsigned number = buf.number;
+ gulong memwritable = 0;
+ const unsigned number = buf.number;
- for (unsigned i = 0; i < number; ++i) {
+ for (unsigned i = 0; i < number; ++i) {
#ifdef __linux__
- memwritable += maps[i].private_dirty;
+ memwritable += maps[i].private_dirty;
#else
- if (maps[i].perm & GLIBTOP_MAP_PERM_WRITE)
- memwritable += maps[i].size;
+ if (maps[i].perm & GLIBTOP_MAP_PERM_WRITE)
+ memwritable += maps[i].size;
#endif
- }
+ }
- info->memwritable = memwritable;
+ info->memwritable = memwritable;
- g_free(maps);
+ g_free(maps);
}
static void
get_process_memory_info(ProcInfo *info)
{
- glibtop_proc_mem procmem;
- WnckResourceUsage xresources;
+ glibtop_proc_mem procmem;
+ WnckResourceUsage xresources;
- wnck_pid_read_resource_usage (gdk_screen_get_display (gdk_screen_get_default ()),
- info->pid,
- &xresources);
+ wnck_pid_read_resource_usage (gdk_screen_get_display (gdk_screen_get_default ()),
+ info->pid,
+ &xresources);
- glibtop_get_proc_mem(&procmem, info->pid);
+ glibtop_get_proc_mem(&procmem, info->pid);
- info->vmsize = procmem.vsize;
- info->memres = procmem.resident;
- info->memshared = procmem.share;
+ info->vmsize = procmem.vsize;
+ info->memres = procmem.resident;
+ info->memshared = procmem.share;
- info->memxserver = xresources.total_bytes_estimate;
+ info->memxserver = xresources.total_bytes_estimate;
- get_process_memory_writable(info);
+ get_process_memory_writable(info);
- // fake the smart memory column if writable is not available
- info->mem = info->memxserver + (info->memwritable ? info->memwritable : info->memres);
+ // fake the smart memory column if writable is not available
+ info->mem = info->memxserver + (info->memwritable ? info->memwritable : info->memres);
}
@@ -536,25 +536,25 @@ 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));
-
- using procman::tree_store_update;
-
- tree_store_update(model, &info->node, COL_STATUS, info->status);
- tree_store_update(model, &info->node, COL_USER, info->user.c_str());
- tree_store_update(model, &info->node, COL_VMSIZE, info->vmsize);
- tree_store_update(model, &info->node, COL_MEMRES, info->memres);
- tree_store_update(model, &info->node, COL_MEMWRITABLE, info->memwritable);
- tree_store_update(model, &info->node, COL_MEMSHARED, info->memshared);
- tree_store_update(model, &info->node, COL_MEMXSERVER, info->memxserver);
- tree_store_update(model, &info->node, COL_CPU, info->pcpu);
- tree_store_update(model, &info->node, COL_CPU_TIME, info->cpu_time);
- tree_store_update(model, &info->node, COL_START_TIME, info->start_time);
- tree_store_update(model, &info->node, COL_NICE, info->nice);
- tree_store_update(model, &info->node, COL_MEM, info->mem);
- tree_store_update(model, &info->node, COL_WCHAN, info->wchan);
+ ProcData * const procdata = ProcData::get_instance();
+ GtkTreeModel *model;
+ model = gtk_tree_view_get_model(GTK_TREE_VIEW(procdata->tree));
+
+ using procman::tree_store_update;
+
+ tree_store_update(model, &info->node, COL_STATUS, info->status);
+ tree_store_update(model, &info->node, COL_USER, info->user.c_str());
+ tree_store_update(model, &info->node, COL_VMSIZE, info->vmsize);
+ tree_store_update(model, &info->node, COL_MEMRES, info->memres);
+ tree_store_update(model, &info->node, COL_MEMWRITABLE, info->memwritable);
+ tree_store_update(model, &info->node, COL_MEMSHARED, info->memshared);
+ tree_store_update(model, &info->node, COL_MEMXSERVER, info->memxserver);
+ tree_store_update(model, &info->node, COL_CPU, info->pcpu);
+ tree_store_update(model, &info->node, COL_CPU_TIME, info->cpu_time);
+ tree_store_update(model, &info->node, COL_START_TIME, info->start_time);
+ tree_store_update(model, &info->node, COL_NICE, info->nice);
+ tree_store_update(model, &info->node, COL_MEM, info->mem);
+ tree_store_update(model, &info->node, COL_WCHAN, info->wchan);
}
@@ -562,42 +562,42 @@ update_info_mutable_cols(ProcInfo *info)
static void
insert_info_to_tree (ProcInfo *info, ProcData *procdata, bool forced = false)
{
- GtkTreeModel *model;
+ GtkTreeModel *model;
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
- if (procdata->config.show_tree) {
+ if (procdata->config.show_tree) {
- ProcInfo *parent = 0;
+ ProcInfo *parent = 0;
- if (not forced)
- parent = ProcInfo::find(info->ppid);
+ if (not forced)
+ parent = ProcInfo::find(info->ppid);
- if (parent) {
- GtkTreePath *parent_node = gtk_tree_model_get_path(model, &parent->node);
- gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, &parent->node, 0);
+ if (parent) {
+ GtkTreePath *parent_node = gtk_tree_model_get_path(model, &parent->node);
+ gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, &parent->node, 0);
- if (!gtk_tree_view_row_expanded(GTK_TREE_VIEW(procdata->tree), parent_node))
- gtk_tree_view_expand_row(GTK_TREE_VIEW(procdata->tree), parent_node, FALSE);
- gtk_tree_path_free(parent_node);
- } else
- gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, NULL, 0);
- }
- else
- gtk_tree_store_insert (GTK_TREE_STORE (model), &info->node, NULL, 0);
+ if (!gtk_tree_view_row_expanded(GTK_TREE_VIEW(procdata->tree), parent_node))
+ gtk_tree_view_expand_row(GTK_TREE_VIEW(procdata->tree), parent_node, FALSE);
+ gtk_tree_path_free(parent_node);
+ } else
+ gtk_tree_store_insert(GTK_TREE_STORE(model), &info->node, NULL, 0);
+ }
+ else
+ gtk_tree_store_insert (GTK_TREE_STORE (model), &info->node, NULL, 0);
- gtk_tree_store_set (GTK_TREE_STORE (model), &info->node,
- COL_POINTER, info,
- COL_NAME, info->name,
- COL_ARGS, info->arguments,
- COL_TOOLTIP, info->tooltip,
- COL_PID, info->pid,
- COL_SECURITYCONTEXT, info->security_context,
- -1);
+ gtk_tree_store_set (GTK_TREE_STORE (model), &info->node,
+ COL_POINTER, info,
+ COL_NAME, info->name,
+ COL_ARGS, info->arguments,
+ COL_TOOLTIP, info->tooltip,
+ COL_PID, info->pid,
+ COL_SECURITYCONTEXT, info->security_context,
+ -1);
- procdata->pretty_table.set_icon(*info);
+ procdata->pretty_table.set_icon(*info);
- procman_debug("inserted %d%s", info->pid, (forced ? " (forced)" : ""));
+ procman_debug("inserted %d%s", info->pid, (forced ? " (forced)" : ""));
}
@@ -607,36 +607,36 @@ insert_info_to_tree (ProcInfo *info, ProcData *procdata, bool forced = false)
template<typename List>
static void
remove_info_from_tree (ProcData *procdata, GtkTreeModel *model,
- ProcInfo *current, List &orphans, unsigned lvl = 0)
+ ProcInfo *current, List &orphans, unsigned lvl = 0)
{
- GtkTreeIter child_node;
+ GtkTreeIter child_node;
- if (std::find(orphans.begin(), orphans.end(), current) != orphans.end()) {
- procman_debug("[%u] %d already removed from tree", lvl, int(current->pid));
- return;
- }
+ if (std::find(orphans.begin(), orphans.end(), current) != orphans.end()) {
+ procman_debug("[%u] %d already removed from tree", lvl, int(current->pid));
+ return;
+ }
- procman_debug("[%u] pid %d, %d children", lvl, int(current->pid),
- gtk_tree_model_iter_n_children(model, ¤t->node));
+ procman_debug("[%u] pid %d, %d children", lvl, int(current->pid),
+ gtk_tree_model_iter_n_children(model, ¤t->node));
- // it is not possible to iterate&erase over a treeview so instead we
- // just pop one child after another and recursively remove it and
- // its children
+ // it is not possible to iterate&erase over a treeview so instead we
+ // just pop one child after another and recursively remove it and
+ // its children
- while (gtk_tree_model_iter_children(model, &child_node, ¤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);
- }
+ 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);
+ }
- g_assert(not gtk_tree_model_iter_has_child(model, ¤t->node));
+ g_assert(not gtk_tree_model_iter_has_child(model, ¤t->node));
- if (procdata->selected_process == current)
- procdata->selected_process = NULL;
+ if (procdata->selected_process == current)
+ procdata->selected_process = NULL;
- orphans.push_back(current);
- gtk_tree_store_remove(GTK_TREE_STORE(model), ¤t->node);
- procman::poison(current->node, 0x69);
+ orphans.push_back(current);
+ gtk_tree_store_remove(GTK_TREE_STORE(model), ¤t->node);
+ procman::poison(current->node, 0x69);
}
@@ -644,77 +644,77 @@ remove_info_from_tree (ProcData *procdata, GtkTreeModel *model,
static void
update_info (ProcData *procdata, ProcInfo *info)
{
- glibtop_proc_state procstate;
- glibtop_proc_uid procuid;
- glibtop_proc_time proctime;
- glibtop_proc_kernel prockernel;
+ glibtop_proc_state procstate;
+ glibtop_proc_uid procuid;
+ glibtop_proc_time proctime;
+ glibtop_proc_kernel prockernel;
- glibtop_get_proc_kernel(&prockernel, info->pid);
- g_strlcpy(info->wchan, prockernel.wchan, sizeof info->wchan);
+ glibtop_get_proc_kernel(&prockernel, info->pid);
+ g_strlcpy(info->wchan, prockernel.wchan, sizeof info->wchan);
- glibtop_get_proc_state (&procstate, info->pid);
- info->status = procstate.state;
+ glibtop_get_proc_state (&procstate, info->pid);
+ info->status = procstate.state;
- glibtop_get_proc_uid (&procuid, info->pid);
- glibtop_get_proc_time (&proctime, info->pid);
+ glibtop_get_proc_uid (&procuid, info->pid);
+ glibtop_get_proc_time (&proctime, info->pid);
- get_process_memory_info(info);
+ get_process_memory_info(info);
- info->set_user(procstate.uid);
+ info->set_user(procstate.uid);
- info->pcpu = (proctime.rtime - info->cpu_time) * 100 / procdata->cpu_total_time;
- info->pcpu = MIN(info->pcpu, 100);
+ info->pcpu = (proctime.rtime - info->cpu_time) * 100 / procdata->cpu_total_time;
+ info->pcpu = MIN(info->pcpu, 100);
- if (not procdata->config.solaris_mode)
- info->pcpu *= procdata->config.num_cpus;
+ if (not procdata->config.solaris_mode)
+ info->pcpu *= procdata->config.num_cpus;
- ProcInfo::cpu_times[info->pid] = info->cpu_time = proctime.rtime;
- info->nice = procuid.nice;
- info->ppid = procuid.ppid;
+ ProcInfo::cpu_times[info->pid] = info->cpu_time = proctime.rtime;
+ info->nice = procuid.nice;
+ info->ppid = procuid.ppid;
}
ProcInfo::ProcInfo(pid_t pid)
- : tooltip(NULL),
- name(NULL),
- arguments(NULL),
- security_context(NULL),
- pid(pid),
- uid(-1)
+ : tooltip(NULL),
+ name(NULL),
+ arguments(NULL),
+ security_context(NULL),
+ pid(pid),
+ uid(-1)
{
- ProcInfo * const info = this;
- glibtop_proc_state procstate;
- glibtop_proc_time proctime;
- glibtop_proc_args procargs;
- gchar** arguments;
-
- glibtop_get_proc_state (&procstate, pid);
- glibtop_get_proc_time (&proctime, pid);
- arguments = glibtop_get_proc_argv (&procargs, pid, 0);
-
- /* FIXME : wrong. name and arguments may change with exec* */
- get_process_name (info, procstate.cmd, static_cast<const GStrv>(arguments));
-
- std::string tooltip = make_string(g_strjoinv(" ", arguments));
- if (tooltip.empty())
- tooltip = procstate.cmd;
-
- info->tooltip = g_markup_escape_text(tooltip.c_str(), -1);
-
- info->arguments = g_strescape(tooltip.c_str(), "\\\"");
- g_strfreev(arguments);
-
- guint64 cpu_time = proctime.rtime;
- std::map<pid_t, guint64>::iterator it(ProcInfo::cpu_times.find(pid));
- if (it != ProcInfo::cpu_times.end())
- {
- if (proctime.rtime >= it->second)
- cpu_time = it->second;
- }
- info->cpu_time = cpu_time;
- info->start_time = proctime.start_time;
-
- get_process_selinux_context (info);
+ ProcInfo * const info = this;
+ glibtop_proc_state procstate;
+ glibtop_proc_time proctime;
+ glibtop_proc_args procargs;
+ gchar** arguments;
+
+ glibtop_get_proc_state (&procstate, pid);
+ glibtop_get_proc_time (&proctime, pid);
+ arguments = glibtop_get_proc_argv (&procargs, pid, 0);
+
+ /* FIXME : wrong. name and arguments may change with exec* */
+ get_process_name (info, procstate.cmd, static_cast<const GStrv>(arguments));
+
+ std::string tooltip = make_string(g_strjoinv(" ", arguments));
+ if (tooltip.empty())
+ tooltip = procstate.cmd;
+
+ info->tooltip = g_markup_escape_text(tooltip.c_str(), -1);
+
+ info->arguments = g_strescape(tooltip.c_str(), "\\\"");
+ g_strfreev(arguments);
+
+ guint64 cpu_time = proctime.rtime;
+ std::map<pid_t, guint64>::iterator it(ProcInfo::cpu_times.find(pid));
+ if (it != ProcInfo::cpu_times.end())
+ {
+ if (proctime.rtime >= it->second)
+ cpu_time = it->second;
+ }
+ info->cpu_time = cpu_time;
+ info->start_time = proctime.start_time;
+
+ get_process_selinux_context (info);
}
@@ -723,212 +723,212 @@ ProcInfo::ProcInfo(pid_t pid)
static void
refresh_list (ProcData *procdata, const pid_t* pid_list, const guint n)
{
- typedef std::list<ProcInfo*> ProcList;
- ProcList addition;
+ typedef std::list<ProcInfo*> ProcList;
+ ProcList addition;
- GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
- guint i;
+ GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
+ guint i;
- // Add or update processes in the process list
- for(i = 0; i < n; ++i) {
- ProcInfo *info = ProcInfo::find(pid_list[i]);
-
- if (!info) {
- info = new ProcInfo(pid_list[i]);
- ProcInfo::all[info->pid] = info;
- addition.push_back(info);
- }
+ // Add or update processes in the process list
+ for(i = 0; i < n; ++i) {
+ ProcInfo *info = ProcInfo::find(pid_list[i]);
+
+ if (!info) {
+ info = new ProcInfo(pid_list[i]);
+ ProcInfo::all[info->pid] = info;
+ addition.push_back(info);
+ }
- update_info (procdata, info);
- }
+ update_info (procdata, info);
+ }
- // Remove dead processes from the process list and from the
- // tree. children are queued to be readded at the right place
- // in the tree.
+ // Remove dead processes from the process list and from the
+ // tree. children are queued to be readded at the right place
+ // in the tree.
- const std::set<pid_t> pids(pid_list, pid_list + n);
+ const std::set<pid_t> pids(pid_list, pid_list + n);
- ProcInfo::Iterator it(ProcInfo::begin());
+ ProcInfo::Iterator it(ProcInfo::begin());
- while (it != ProcInfo::end()) {
- ProcInfo * const info = it->second;
- ProcInfo::Iterator next(it);
- ++next;
+ while (it != ProcInfo::end()) {
+ ProcInfo * const info = it->second;
+ ProcInfo::Iterator next(it);
+ ++next;
- if (pids.find(info->pid) == pids.end()) {
- procman_debug("ripping %d", info->pid);
- remove_info_from_tree(procdata, model, info, addition);
- addition.remove(info);
- ProcInfo::all.erase(it);
- delete info;
- }
+ if (pids.find(info->pid) == pids.end()) {
+ procman_debug("ripping %d", info->pid);
+ remove_info_from_tree(procdata, model, info, addition);
+ addition.remove(info);
+ ProcInfo::all.erase(it);
+ delete info;
+ }
- it = next;
- }
+ it = next;
+ }
- // INVARIANT
- // pid_list == ProcInfo::all + addition
+ // INVARIANT
+ // pid_list == ProcInfo::all + addition
- if (procdata->config.show_tree) {
+ if (procdata->config.show_tree) {
- // insert process in the tree. walk through the addition list
- // (new process + process that have a new parent). This loop
- // handles the dependencies because we cannot insert a process
- // until its parent is in the tree.
+ // insert process in the tree. walk through the addition list
+ // (new process + process that have a new parent). This loop
+ // handles the dependencies because we cannot insert a process
+ // until its parent is in the tree.
- std::set<pid_t> in_tree(pids);
+ std::set<pid_t> in_tree(pids);
- for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)
- in_tree.erase((*it)->pid);
+ for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)
+ in_tree.erase((*it)->pid);
- while (not addition.empty()) {
- procman_debug("looking for %d parents", int(addition.size()));
- ProcList::iterator it(addition.begin());
+ while (not addition.empty()) {
+ procman_debug("looking for %d parents", int(addition.size()));
+ ProcList::iterator it(addition.begin());
- while (it != addition.end()) {
- procman_debug("looking for %d's parent with ppid %d",
- int((*it)->pid), int((*it)->ppid));
+ while (it != addition.end()) {
+ procman_debug("looking for %d's parent with ppid %d",
+ int((*it)->pid), int((*it)->ppid));
- // inserts the process in the treeview if :
- // - it is init
- // - its parent is already in tree
- // - its parent is unreachable
- //
- // rounds == 2 means that addition contains processes with
- // unreachable parents
- //
- // FIXME: this is broken if the unreachable parent becomes active
- // i.e. it gets active or changes ower
- // so we just clear the tree on __each__ update
- // see proctable_update_list (ProcData * const procdata)
+ // inserts the process in the treeview if :
+ // - it is init
+ // - its parent is already in tree
+ // - its parent is unreachable
+ //
+ // rounds == 2 means that addition contains processes with
+ // unreachable parents
+ //
+ // FIXME: this is broken if the unreachable parent becomes active
+ // i.e. it gets active or changes ower
+ // so we just clear the tree on __each__ update
+ // see proctable_update_list (ProcData * const procdata)
- if ((*it)->ppid == 0 or in_tree.find((*it)->ppid) != in_tree.end()) {
- insert_info_to_tree(*it, procdata);
- in_tree.insert((*it)->pid);
- it = addition.erase(it);
- continue;
- }
+ if ((*it)->ppid == 0 or in_tree.find((*it)->ppid) != in_tree.end()) {
+ insert_info_to_tree(*it, procdata);
+ in_tree.insert((*it)->pid);
+ it = addition.erase(it);
+ continue;
+ }
- ProcInfo *parent = ProcInfo::find((*it)->ppid);
- // if the parent is unreachable
- if (not parent) {
- // or std::find(addition.begin(), addition.end(), parent) == addition.end()) {
- insert_info_to_tree(*it, procdata, true);
- in_tree.insert((*it)->pid);
- it = addition.erase(it);
- continue;
- }
-
- ++it;
- }
- }
- }
- else {
- // don't care of the tree
- for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)
- insert_info_to_tree(*it, procdata);
- }
+ ProcInfo *parent = ProcInfo::find((*it)->ppid);
+ // if the parent is unreachable
+ if (not parent) {
+ // or std::find(addition.begin(), addition.end(), parent) == addition.end()) {
+ insert_info_to_tree(*it, procdata, true);
+ in_tree.insert((*it)->pid);
+ it = addition.erase(it);
+ continue;
+ }
+
+ ++it;
+ }
+ }
+ }
+ else {
+ // don't care of the tree
+ for (ProcList::iterator it(addition.begin()); it != addition.end(); ++it)
+ insert_info_to_tree(*it, procdata);
+ }
- for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it)
- update_info_mutable_cols(it->second);
+ for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it)
+ update_info_mutable_cols(it->second);
}
void
proctable_update_list (ProcData * const procdata)
{
- pid_t* pid_list;
- glibtop_proclist proclist;
- glibtop_cpu cpu;
- gint which, arg;
- procman::SelectionMemento selection;
-
- switch (procdata->config.whose_process) {
- case ALL_PROCESSES:
- which = GLIBTOP_KERN_PROC_ALL;
- arg = 0;
- break;
-
- case ACTIVE_PROCESSES:
- which = GLIBTOP_KERN_PROC_ALL | GLIBTOP_EXCLUDE_IDLE;
- arg = 0;
- if (procdata->config.show_tree)
- {
- selection.save(procdata->tree);
- proctable_clear_tree(procdata);
- }
- break;
-
- default:
- which = GLIBTOP_KERN_PROC_UID;
- arg = getuid ();
- if (procdata->config.show_tree)
- {
- selection.save(procdata->tree);
- proctable_clear_tree(procdata);
- }
- break;
- }
-
- pid_list = glibtop_get_proclist (&proclist, which, arg);
-
- /* FIXME: total cpu time elapsed should be calculated on an individual basis here
- ** should probably have a total_time_last gint in the ProcInfo structure */
- glibtop_get_cpu (&cpu);
- procdata->cpu_total_time = MAX(cpu.total - procdata->cpu_total_time_last, 1);
- procdata->cpu_total_time_last = cpu.total;
-
- refresh_list (procdata, pid_list, proclist.number);
-
- selection.restore(procdata->tree);
-
- g_free (pid_list);
-
- /* proclist.number == g_list_length(procdata->info) == g_hash_table_size(procdata->pids) */
+ pid_t* pid_list;
+ glibtop_proclist proclist;
+ glibtop_cpu cpu;
+ gint which, arg;
+ procman::SelectionMemento selection;
+
+ switch (procdata->config.whose_process) {
+ case ALL_PROCESSES:
+ which = GLIBTOP_KERN_PROC_ALL;
+ arg = 0;
+ break;
+
+ case ACTIVE_PROCESSES:
+ which = GLIBTOP_KERN_PROC_ALL | GLIBTOP_EXCLUDE_IDLE;
+ arg = 0;
+ if (procdata->config.show_tree)
+ {
+ selection.save(procdata->tree);
+ proctable_clear_tree(procdata);
+ }
+ break;
+
+ default:
+ which = GLIBTOP_KERN_PROC_UID;
+ arg = getuid ();
+ if (procdata->config.show_tree)
+ {
+ selection.save(procdata->tree);
+ proctable_clear_tree(procdata);
+ }
+ break;
+ }
+
+ pid_list = glibtop_get_proclist (&proclist, which, arg);
+
+ /* FIXME: total cpu time elapsed should be calculated on an individual basis here
+ ** should probably have a total_time_last gint in the ProcInfo structure */
+ glibtop_get_cpu (&cpu);
+ procdata->cpu_total_time = MAX(cpu.total - procdata->cpu_total_time_last, 1);
+ procdata->cpu_total_time_last = cpu.total;
+
+ refresh_list (procdata, pid_list, proclist.number);
+
+ selection.restore(procdata->tree);
+
+ g_free (pid_list);
+
+ /* proclist.number == g_list_length(procdata->info) == g_hash_table_size(procdata->pids) */
}
void
proctable_update_all (ProcData * const procdata)
{
- char* string;
+ char* string;
- string = make_loadavg_string();
- gtk_label_set_text (GTK_LABEL(procdata->loadavg), string);
- g_free (string);
+ string = make_loadavg_string();
+ gtk_label_set_text (GTK_LABEL(procdata->loadavg), string);
+ g_free (string);
- proctable_update_list (procdata);
+ proctable_update_list (procdata);
}
void
proctable_clear_tree (ProcData * const procdata)
{
- GtkTreeModel *model;
+ GtkTreeModel *model;
- model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
+ model = gtk_tree_view_get_model (GTK_TREE_VIEW (procdata->tree));
- gtk_tree_store_clear (GTK_TREE_STORE (model));
+ gtk_tree_store_clear (GTK_TREE_STORE (model));
- proctable_free_table (procdata);
+ proctable_free_table (procdata);
- update_sensitivity(procdata);
+ update_sensitivity(procdata);
}
void
proctable_free_table (ProcData * const procdata)
{
- for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it)
- delete it->second;
+ for (ProcInfo::Iterator it(ProcInfo::begin()); it != ProcInfo::end(); ++it)
+ delete it->second;
- ProcInfo::all.clear();
+ ProcInfo::all.clear();
}
@@ -936,16 +936,16 @@ proctable_free_table (ProcData * const procdata)
char*
make_loadavg_string(void)
{
- glibtop_loadavg buf;
+ glibtop_loadavg buf;
- glibtop_get_loadavg(&buf);
+ glibtop_get_loadavg(&buf);
- return g_strdup_printf(
- _("Load averages for the last 1, 5, 15 minutes: "
- "%0.2f, %0.2f, %0.2f"),
- buf.loadavg[0],
- buf.loadavg[1],
- buf.loadavg[2]);
+ return g_strdup_printf(
+ _("Load averages for the last 1, 5, 15 minutes: "
+ "%0.2f, %0.2f, %0.2f"),
+ buf.loadavg[0],
+ buf.loadavg[1],
+ buf.loadavg[2]);
}
@@ -953,11 +953,11 @@ make_loadavg_string(void)
void
ProcInfo::set_icon(Glib::RefPtr<Gdk::Pixbuf> icon)
{
- this->pixbuf = icon;
+ this->pixbuf = icon;
- GtkTreeModel *model;
- model = gtk_tree_view_get_model(GTK_TREE_VIEW(ProcData::get_instance()->tree));
- gtk_tree_store_set(GTK_TREE_STORE(model), &this->node,
- COL_PIXBUF, (this->pixbuf ? this->pixbuf->gobj() : NULL),
- -1);
+ GtkTreeModel *model;
+ model = gtk_tree_view_get_model(GTK_TREE_VIEW(ProcData::get_instance()->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 2cd1def..62cb529 100644
--- a/src/proctable.h
+++ b/src/proctable.h
@@ -26,40 +26,40 @@
enum
{
- COL_NAME = 0,
- COL_USER,
- COL_STATUS,
- COL_VMSIZE,
- COL_MEMRES,
- COL_MEMWRITABLE,
- COL_MEMSHARED,
- COL_MEMXSERVER,
- COL_CPU,
- COL_CPU_TIME,
- COL_START_TIME,
- COL_NICE,
- COL_PID,
- COL_SECURITYCONTEXT,
- COL_ARGS,
- COL_MEM,
- COL_WCHAN,
- COL_PIXBUF,
- COL_POINTER,
- COL_TOOLTIP,
- NUM_COLUMNS
+ COL_NAME = 0,
+ COL_USER,
+ COL_STATUS,
+ COL_VMSIZE,
+ COL_MEMRES,
+ COL_MEMWRITABLE,
+ COL_MEMSHARED,
+ COL_MEMXSERVER,
+ COL_CPU,
+ COL_CPU_TIME,
+ COL_START_TIME,
+ COL_NICE,
+ COL_PID,
+ COL_SECURITYCONTEXT,
+ COL_ARGS,
+ COL_MEM,
+ COL_WCHAN,
+ COL_PIXBUF,
+ COL_POINTER,
+ COL_TOOLTIP,
+ NUM_COLUMNS
};
-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 (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);
-GSList* proctable_get_columns_order(GtkTreeView *treeview);
-void proctable_set_columns_order(GtkTreeView *treeview, GSList *order);
+GSList* proctable_get_columns_order(GtkTreeView *treeview);
+void proctable_set_columns_order(GtkTreeView *treeview, GSList *order);
-char* make_loadavg_string(void);
+char* make_loadavg_string(void);
#endif /* _PROCMAN_PROCTABLE_H_ */
diff --git a/src/selection.cpp b/src/selection.cpp
index 6f293a6..7e15a9e 100644
--- a/src/selection.cpp
+++ b/src/selection.cpp
@@ -6,38 +6,38 @@
namespace procman
{
- void SelectionMemento::add_to_selected(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, gpointer data)
- {
- guint pid = 0;
- gtk_tree_model_get(model, iter, COL_PID, &pid, -1);
- if (pid)
- static_cast<SelectionMemento*>(data)->pids.push_back(pid);
- }
+ void SelectionMemento::add_to_selected(GtkTreeModel* model, GtkTreePath*, GtkTreeIter* iter, gpointer data)
+ {
+ guint pid = 0;
+ gtk_tree_model_get(model, iter, COL_PID, &pid, -1);
+ if (pid)
+ static_cast<SelectionMemento*>(data)->pids.push_back(pid);
+ }
- void SelectionMemento::save(GtkWidget* tree)
- {
- GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
- gtk_tree_selection_selected_foreach(selection, &SelectionMemento::add_to_selected, this);
- }
+ void SelectionMemento::save(GtkWidget* tree)
+ {
+ GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
+ gtk_tree_selection_selected_foreach(selection, &SelectionMemento::add_to_selected, this);
+ }
- void SelectionMemento::restore(GtkWidget* tree)
- {
- if (not this->pids.empty())
- {
- GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
- typedef std::vector<pid_t>::iterator iterator;
- for (iterator it(this->pids.begin()); it != this->pids.end(); ++it)
- {
- if (ProcInfo* proc = ProcInfo::find(*it))
- {
- gtk_tree_selection_select_iter(selection, &proc->node);
- procman_debug("Re-selected process %u", unsigned(*it));
- }
- else
- procman_debug("Could not find process %u, cannot re-select it", unsigned(*it));
- }
- }
- }
+ void SelectionMemento::restore(GtkWidget* tree)
+ {
+ if (not this->pids.empty())
+ {
+ GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
+ typedef std::vector<pid_t>::iterator iterator;
+ for (iterator it(this->pids.begin()); it != this->pids.end(); ++it)
+ {
+ if (ProcInfo* proc = ProcInfo::find(*it))
+ {
+ gtk_tree_selection_select_iter(selection, &proc->node);
+ procman_debug("Re-selected process %u", unsigned(*it));
+ }
+ else
+ procman_debug("Could not find process %u, cannot re-select it", unsigned(*it));
+ }
+ }
+ }
}
diff --git a/src/selection.h b/src/selection.h
index e521334..32829eb 100644
--- a/src/selection.h
+++ b/src/selection.h
@@ -7,15 +7,15 @@
namespace procman
{
- class SelectionMemento
- {
- std::vector<pid_t> pids;
- static void add_to_selected(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer data);
+ class SelectionMemento
+ {
+ std::vector<pid_t> pids;
+ static void add_to_selected(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer data);
- public:
- void save(GtkWidget* tree);
- void restore(GtkWidget* tree);
- };
+ public:
+ void save(GtkWidget* tree);
+ void restore(GtkWidget* tree);
+ };
}
#endif /* H_GNOME_SYSTEM_MONITOR_SELECTION_H_1183113337 */
diff --git a/src/selinux.cpp b/src/selinux.cpp
index 6bfee5a..f9eaddf 100644
--- a/src/selinux.cpp
+++ b/src/selinux.cpp
@@ -15,11 +15,11 @@ static gboolean has_selinux;
static gboolean load_selinux(void)
{
- return load_symbols("libselinux.so.1",
- "getpidcon", &getpidcon,
- "freecon", &freecon,
- "is_selinux_enabled", &is_selinux_enabled,
- NULL);
+ return load_symbols("libselinux.so.1",
+ "getpidcon", &getpidcon,
+ "freecon", &freecon,
+ "is_selinux_enabled", &is_selinux_enabled,
+ NULL);
}
@@ -27,12 +27,12 @@ static gboolean load_selinux(void)
void
get_process_selinux_context (ProcInfo *info)
{
- char *con;
+ char *con;
- if (has_selinux && !getpidcon (info->pid, &con)) {
- info->security_context = g_strdup (con);
- freecon (con);
- }
+ if (has_selinux && !getpidcon (info->pid, &con)) {
+ info->security_context = g_strdup (con);
+ freecon (con);
+ }
}
@@ -40,25 +40,25 @@ get_process_selinux_context (ProcInfo *info)
gboolean
can_show_security_context_column (void)
{
- if (!(has_selinux = load_selinux()))
- return FALSE;
+ if (!(has_selinux = load_selinux()))
+ return FALSE;
- switch (is_selinux_enabled()) {
- case 1:
- /* We're running on an SELinux kernel */
- return TRUE;
+ switch (is_selinux_enabled()) {
+ case 1:
+ /* We're running on an SELinux kernel */
+ return TRUE;
- case -1:
- /* Error; hide the security context column */
+ case -1:
+ /* Error; hide the security context column */
- case 0:
- /* We're not running on an SELinux kernel:
- hide the security context column */
+ case 0:
+ /* We're not running on an SELinux kernel:
+ hide the security context column */
- default:
- g_warning("SELinux was found but is not enabled.\n");
- return FALSE;
- }
+ default:
+ g_warning("SELinux was found but is not enabled.\n");
+ return FALSE;
+ }
}
diff --git a/src/settings-keys.cpp b/src/settings-keys.cpp
index a8a2e33..f330d4c 100644
--- a/src/settings-keys.cpp
+++ b/src/settings-keys.cpp
@@ -3,12 +3,12 @@
namespace procman
{
- namespace settings
- {
- const std::string root("/apps/procman");
- const std::string solaris_mode("solaris-mode");
- const std::string open_files_tree_prefix("openfilestree");
- const std::string network_in_bits("network-in-bits");
- }
+ namespace settings
+ {
+ const std::string root("/apps/procman");
+ const std::string solaris_mode("solaris-mode");
+ const std::string open_files_tree_prefix("openfilestree");
+ const std::string network_in_bits("network-in-bits");
+ }
}
diff --git a/src/settings-keys.h b/src/settings-keys.h
index e83f7b8..b30c720 100644
--- a/src/settings-keys.h
+++ b/src/settings-keys.h
@@ -5,13 +5,13 @@
namespace procman
{
- namespace settings
- {
- extern const std::string root;
- extern const std::string solaris_mode;
- extern const std::string open_files_tree_prefix;
- extern const std::string network_in_bits;
- }
+ namespace settings
+ {
+ extern const std::string root;
+ extern const std::string solaris_mode;
+ extern const std::string open_files_tree_prefix;
+ extern const std::string network_in_bits;
+ }
}
diff --git a/src/smooth_refresh.cpp b/src/smooth_refresh.cpp
index 78ae890..f3ef70e 100644
--- a/src/smooth_refresh.cpp
+++ b/src/smooth_refresh.cpp
@@ -21,25 +21,25 @@ const string SmoothRefresh::KEY("smooth-refresh");
unsigned SmoothRefresh::get_own_cpu_usage()
{
- glibtop_cpu cpu;
- glibtop_proc_time proctime;
- guint64 elapsed;
- unsigned usage = PCPU_LO;
+ glibtop_cpu cpu;
+ glibtop_proc_time proctime;
+ guint64 elapsed;
+ unsigned usage = PCPU_LO;
- glibtop_get_cpu (&cpu);
- elapsed = cpu.total - this->last_total_time;
+ glibtop_get_cpu (&cpu);
+ elapsed = cpu.total - this->last_total_time;
- if (elapsed) { // avoid division by 0
- glibtop_get_proc_time(&proctime, getpid());
- usage = (proctime.rtime - this->last_cpu_time) * 100 / elapsed;
- }
+ if (elapsed) { // avoid division by 0
+ glibtop_get_proc_time(&proctime, getpid());
+ usage = (proctime.rtime - this->last_cpu_time) * 100 / elapsed;
+ }
- usage = CLAMP(usage, 0, 100);
+ usage = CLAMP(usage, 0, 100);
- this->last_total_time = cpu.total;
- this->last_cpu_time = proctime.rtime;
+ this->last_total_time = cpu.total;
+ this->last_cpu_time = proctime.rtime;
- return usage;
+ return usage;
}
@@ -48,53 +48,53 @@ void SmoothRefresh::status_changed(GSettings *settings,
const gchar *key,
gpointer user_data)
{
- static_cast<SmoothRefresh*>(user_data)->load_settings_value(key);
+ static_cast<SmoothRefresh*>(user_data)->load_settings_value(key);
}
void SmoothRefresh::load_settings_value(const gchar *key)
{
- this->active = g_settings_get_boolean(settings, key);
+ this->active = g_settings_get_boolean(settings, key);
- if (this->active)
- procman_debug("smooth_refresh is enabled");
+ if (this->active)
+ procman_debug("smooth_refresh is enabled");
}
SmoothRefresh::SmoothRefresh(GSettings *a_settings)
-:
+ :
settings(a_settings)
{
- this->connection = g_signal_connect(G_OBJECT(settings),
- "changed::smooth-refresh",
- G_CALLBACK(status_changed),
- this);
+ this->connection = g_signal_connect(G_OBJECT(settings),
+ "changed::smooth-refresh",
+ G_CALLBACK(status_changed),
+ this);
- this->reset();
- this->load_settings_value(KEY.c_str());
+ this->reset();
+ this->load_settings_value(KEY.c_str());
}
void SmoothRefresh::reset()
{
- glibtop_cpu cpu;
- glibtop_proc_time proctime;
+ glibtop_cpu cpu;
+ glibtop_proc_time proctime;
- glibtop_get_cpu(&cpu);
- glibtop_get_proc_time(&proctime, getpid());
+ glibtop_get_cpu(&cpu);
+ glibtop_get_proc_time(&proctime, getpid());
- this->interval = ProcData::get_instance()->config.update_interval;
- this->last_pcpu = PCPU_LO;
- this->last_total_time = cpu.total;
- this->last_cpu_time = proctime.rtime;
+ this->interval = ProcData::get_instance()->config.update_interval;
+ this->last_pcpu = PCPU_LO;
+ this->last_total_time = cpu.total;
+ this->last_cpu_time = proctime.rtime;
}
SmoothRefresh::~SmoothRefresh()
{
- if (this->connection)
- g_signal_handler_disconnect(G_OBJECT(settings), this->connection);
+ if (this->connection)
+ g_signal_handler_disconnect(G_OBJECT(settings), this->connection);
}
@@ -102,59 +102,59 @@ SmoothRefresh::~SmoothRefresh()
bool
SmoothRefresh::get(guint &new_interval)
{
- const unsigned config_interval = ProcData::get_instance()->config.update_interval;
+ const unsigned config_interval = ProcData::get_instance()->config.update_interval;
- g_assert(this->interval >= config_interval);
+ g_assert(this->interval >= config_interval);
- if (not this->active)
- return false;
+ if (not this->active)
+ return false;
- const unsigned pcpu = this->get_own_cpu_usage();
- /*
- invariant: MAX_UPDATE_INTERVAL >= interval >= config_interval >= MIN_UPDATE_INTERVAL
+ const unsigned pcpu = this->get_own_cpu_usage();
+ /*
+ invariant: MAX_UPDATE_INTERVAL >= interval >= config_interval >= MIN_UPDATE_INTERVAL
- i see 3 cases:
+ i see 3 cases:
- a) interval is too big (CPU usage < 10%)
- -> increase interval
+ a) interval is too big (CPU usage < 10%)
+ -> increase interval
- b) interval is too small (CPU usage > 10%) AND interval != config_interval
- >
- -> decrease interval
+ b) interval is too small (CPU usage > 10%) AND interval != config_interval
+ >
+ -> decrease interval
- c) interval is config_interval (start or interval is perfect)
+ c) interval is config_interval (start or interval is perfect)
- */
+ */
- if (pcpu > PCPU_HI && this->last_pcpu > PCPU_HI)
- new_interval = this->interval * 11 / 10;
- else if (this->interval != config_interval && pcpu < PCPU_LO && this->last_pcpu < PCPU_LO)
- new_interval = this->interval * 9 / 10;
- else
- new_interval = this->interval;
+ if (pcpu > PCPU_HI && this->last_pcpu > PCPU_HI)
+ new_interval = this->interval * 11 / 10;
+ else if (this->interval != config_interval && pcpu < PCPU_LO && this->last_pcpu < PCPU_LO)
+ new_interval = this->interval * 9 / 10;
+ else
+ new_interval = this->interval;
- new_interval = CLAMP(new_interval, config_interval, config_interval * 2);
- new_interval = CLAMP(new_interval, MIN_UPDATE_INTERVAL, MAX_UPDATE_INTERVAL);
+ new_interval = CLAMP(new_interval, config_interval, config_interval * 2);
+ new_interval = CLAMP(new_interval, MIN_UPDATE_INTERVAL, MAX_UPDATE_INTERVAL);
- bool changed = this->interval != new_interval;
+ bool changed = this->interval != new_interval;
- if (changed)
- this->interval = new_interval;
+ if (changed)
+ this->interval = new_interval;
- this->last_pcpu = pcpu;
+ this->last_pcpu = pcpu;
- if (changed) {
- procman_debug("CPU usage is %3u%%, changed refresh_interval to %u (config %u)",
- this->last_pcpu,
- this->interval,
- config_interval);
- }
+ if (changed) {
+ procman_debug("CPU usage is %3u%%, changed refresh_interval to %u (config %u)",
+ this->last_pcpu,
+ this->interval,
+ config_interval);
+ }
- g_assert(this->interval == new_interval);
- g_assert(this->interval >= config_interval);
+ g_assert(this->interval == new_interval);
+ g_assert(this->interval >= config_interval);
- return changed;
+ return changed;
}
diff --git a/src/smooth_refresh.h b/src/smooth_refresh.h
index 8ba1680..92039e0 100644
--- a/src/smooth_refresh.h
+++ b/src/smooth_refresh.h
@@ -11,92 +11,92 @@ using std::string;
class SmoothRefresh
{
-public:
+ public:
- /*
- smooth_refresh_new
+ /*
+ smooth_refresh_new
- @config_interval : pointer to config_interval so we can observe
- config_interval changes.
+ @config_interval : pointer to config_interval so we can observe
+ config_interval changes.
- @return : initialized SmoothRefresh
- */
- SmoothRefresh(GSettings *a_settings);
+ @return : initialized SmoothRefresh
+ */
+ SmoothRefresh(GSettings *a_settings);
- ~SmoothRefresh();
+ ~SmoothRefresh();
- /*
- smooth_refresh_reset
+ /*
+ smooth_refresh_reset
- Resets state and re-read config_interval
- */
- void reset();
+ Resets state and re-read config_interval
+ */
+ void reset();
- /*
- smooth_refresh_get
+ /*
+ smooth_refresh_get
- Computes the new refresh_interval so that CPU usage is lower than
- SMOOTH_REFRESH_PCPU.
+ Computes the new refresh_interval so that CPU usage is lower than
+ SMOOTH_REFRESH_PCPU.
- @new_interval : where the new refresh_interval is stored.
+ @new_interval : where the new refresh_interval is stored.
- @return : TRUE is refresh_interval has changed. The new refresh_interval
- is stored in @new_interval. Else FALSE;
- */
- bool get(guint &new_interval);
+ @return : TRUE is refresh_interval has changed. The new refresh_interval
+ is stored in @new_interval. Else FALSE;
+ */
+ bool get(guint &new_interval);
- static const string KEY;
- static const bool KEY_DEFAULT_VALUE;
+ static const string KEY;
+ static const bool KEY_DEFAULT_VALUE;
-private:
+ private:
- unsigned get_own_cpu_usage();
+ unsigned get_own_cpu_usage();
- static void status_changed(GSettings *settings,
- const gchar *key,
- gpointer user_data);
+ static void status_changed(GSettings *settings,
+ const gchar *key,
+ gpointer user_data);
- void load_settings_value(const gchar *key);
+ void load_settings_value(const gchar *key);
- /*
- fuzzy logic:
- - decrease refresh interval only if current CPU% and last CPU%
- are higher than PCPU_LO
- - increase refresh interval only if current CPU% and last CPU%
- are higher than PCPU_HI
+ /*
+ fuzzy logic:
+ - decrease refresh interval only if current CPU% and last CPU%
+ are higher than PCPU_LO
+ - increase refresh interval only if current CPU% and last CPU%
+ are higher than PCPU_HI
- */
+ */
- enum
+ enum
{
- PCPU_HI = 22,
- PCPU_LO = 18
+ PCPU_HI = 22,
+ PCPU_LO = 18
};
- /*
- -self : procman's PID (so we call getpid() only once)
+ /*
+ -self : procman's PID (so we call getpid() only once)
- -interval : current refresh interval
+ -interval : current refresh interval
- -config_interval : pointer to the configuration refresh interval.
- Used to watch configuration changes
+ -config_interval : pointer to the configuration refresh interval.
+ Used to watch configuration changes
- -interval >= -config_interval
+ -interval >= -config_interval
- -last_pcpu : to avoid spikes, the last CPU%. See PCPU_{LO,HI}
+ -last_pcpu : to avoid spikes, the last CPU%. See PCPU_{LO,HI}
- -last_total_time:
- -last_cpu_time: Save last cpu and process times to compute CPU%
- */
+ -last_total_time:
+ -last_cpu_time: Save last cpu and process times to compute CPU%
+ */
- GSettings *settings;
- bool active;
- guint connection;
- guint interval;
- unsigned last_pcpu;
- guint64 last_total_time;
- guint64 last_cpu_time;
+ GSettings *settings;
+ bool active;
+ guint connection;
+ guint interval;
+ unsigned last_pcpu;
+ guint64 last_total_time;
+ guint64 last_cpu_time;
};
diff --git a/src/sysinfo.cpp b/src/sysinfo.cpp
index 0038cc4..718fb68 100644
--- a/src/sysinfo.cpp
+++ b/src/sysinfo.cpp
@@ -39,403 +39,403 @@ using std::vector;
namespace {
- class SysInfo
- {
- public:
- string hostname;
- string distro_name;
- string distro_release;
- string kernel;
- string gnome_version;
- guint64 memory_bytes;
- guint64 free_space_bytes;
-
- guint n_processors;
- vector<string> processors;
-
-
- SysInfo()
+ class SysInfo
{
- this->load_processors_info();
- this->load_memory_info();
- this->load_disk_info();
- this->load_uname_info();
- this->load_gnome_version();
- }
-
- virtual ~SysInfo()
- { }
-
- virtual void set_distro_labels(GtkWidget* name, GtkWidget* release)
- {
- g_object_set(G_OBJECT(name),
- "label",
- ("<big><big><b>" + this->distro_name + "</b></big></big>").c_str(),
- NULL);
-
+ public:
+ string hostname;
+ string distro_name;
+ string distro_release;
+ string kernel;
+ string gnome_version;
+ guint64 memory_bytes;
+ guint64 free_space_bytes;
- char* markup = g_strdup_printf(_("Release %s"), this->distro_release.c_str());
+ guint n_processors;
+ vector<string> processors;
- g_object_set(G_OBJECT(release),
- "label",
- markup,
- NULL);
- g_free(markup);
- }
-
- static string system()
- {
- return uname().sysname;
- }
+ SysInfo()
+ {
+ this->load_processors_info();
+ this->load_memory_info();
+ this->load_disk_info();
+ this->load_uname_info();
+ this->load_gnome_version();
+ }
- private:
-
- void load_memory_info()
- {
- glibtop_mem mem;
-
- glibtop_get_mem(&mem);
- this->memory_bytes = mem.total;
- }
-
-
- void load_processors_info()
- {
- const glibtop_sysinfo *info = glibtop_get_sysinfo();
-
- for (guint i = 0; i != info->ncpu; ++i) {
- const char * const keys[] = { "model name", "cpu", "Processor" };
- gchar *model = 0, *clock = 0;
- guint last;
-
- for (guint j = 0; !model && j != G_N_ELEMENTS(keys); ++j) {
- last = j;
- model = static_cast<char*>(g_hash_table_lookup(info->cpuinfo[i].values,
- keys[j]));
- }
-
- if (!model)
- continue;
-
- if (!strcmp(keys[last], "cpu"))
- clock = static_cast<char*>(g_hash_table_lookup(info->cpuinfo[i].values,
- "clock"));
- if (clock)
- this->processors.push_back(string(model) + " " + string(clock));
- else
- this->processors.push_back(model);
- }
- }
+ virtual ~SysInfo()
+ { }
+ virtual void set_distro_labels(GtkWidget* name, GtkWidget* release)
+ {
+ g_object_set(G_OBJECT(name),
+ "label",
+ ("<big><big><b>" + this->distro_name + "</b></big></big>").c_str(),
+ NULL);
- void load_disk_info()
- {
- glibtop_mountentry *entries;
- glibtop_mountlist mountlist;
+ char* markup = g_strdup_printf(_("Release %s"), this->distro_release.c_str());
- entries = glibtop_get_mountlist(&mountlist, 0);
+ g_object_set(G_OBJECT(release),
+ "label",
+ markup,
+ NULL);
- this->free_space_bytes = 0;
+ g_free(markup);
+ }
- for (guint i = 0; i != mountlist.number; ++i) {
+ static string system()
+ {
+ return uname().sysname;
+ }
- if (string(entries[i].devname).find("/dev/") != 0)
- continue;
+ private:
- if (string(entries[i].mountdir).find("/media/") == 0)
- continue;
+ void load_memory_info()
+ {
+ glibtop_mem mem;
- glibtop_fsusage usage;
- glibtop_get_fsusage(&usage, entries[i].mountdir);
- this->free_space_bytes += usage.bavail * usage.block_size;
- }
+ glibtop_get_mem(&mem);
+ this->memory_bytes = mem.total;
+ }
- g_free(entries);
- }
- static const struct utsname & uname()
- {
- static struct utsname name;
+ void load_processors_info()
+ {
+ const glibtop_sysinfo *info = glibtop_get_sysinfo();
- if (!name.sysname[0]) {
- ::uname(&name);
- }
+ for (guint i = 0; i != info->ncpu; ++i) {
+ const char * const keys[] = { "model name", "cpu", "Processor" };
+ gchar *model = 0, *clock = 0;
+ guint last;
- return name;
- }
+ for (guint j = 0; !model && j != G_N_ELEMENTS(keys); ++j) {
+ last = j;
+ model = static_cast<char*>(g_hash_table_lookup(info->cpuinfo[i].values,
+ keys[j]));
+ }
- void load_uname_info()
- {
- this->hostname = uname().nodename;
- this->kernel = string(uname().sysname) + ' ' + uname().release;
- }
+ if (!model)
+ continue;
+ if (!strcmp(keys[last], "cpu"))
+ clock = static_cast<char*>(g_hash_table_lookup(info->cpuinfo[i].values,
+ "clock"));
+ if (clock)
+ this->processors.push_back(string(model) + " " + string(clock));
+ else
+ this->processors.push_back(model);
+ }
+ }
- void load_gnome_version()
- {
- xmlDocPtr document;
- xmlXPathContextPtr context;
- const string nodes[3] = { "string(/gnome-version/platform)",
- "string(/gnome-version/minor)",
- "string(/gnome-version/micro)" };
- string values[3];
- if (not (document = xmlParseFile(DATADIR "/gnome/gnome-version.xml")))
- return;
- if (not (context = xmlXPathNewContext(document)))
- return;
+ void load_disk_info()
+ {
+ glibtop_mountentry *entries;
+ glibtop_mountlist mountlist;
- for (size_t i = 0; i != 3; ++i)
- {
- xmlXPathObjectPtr xpath;
- xpath = xmlXPathEvalExpression(BAD_CAST nodes[i].c_str(), context);
+ entries = glibtop_get_mountlist(&mountlist, 0);
- if (xpath and xpath->type == XPATH_STRING)
- values[i] = reinterpret_cast<const char*>(xpath->stringval);
+ this->free_space_bytes = 0;
- xmlXPathFreeObject(xpath);
- }
+ for (guint i = 0; i != mountlist.number; ++i) {
- xmlXPathFreeContext(context);
- xmlFreeDoc(document);
+ if (string(entries[i].devname).find("/dev/") != 0)
+ continue;
- this->gnome_version = values[0] + '.' + values[1] + '.' + values[2];
- }
- };
+ if (string(entries[i].mountdir).find("/media/") == 0)
+ continue;
+ glibtop_fsusage usage;
+ glibtop_get_fsusage(&usage, entries[i].mountdir);
+ this->free_space_bytes += usage.bavail * usage.block_size;
+ }
+ g_free(entries);
+ }
- class SolarisSysInfo
- : public SysInfo
- {
- public:
- SolarisSysInfo()
- {
- this->load_solaris_info();
- }
+ static const struct utsname & uname()
+ {
+ static struct utsname name;
- private:
- void load_solaris_info()
- {
- this->distro_name = "Solaris";
+ if (!name.sysname[0]) {
+ ::uname(&name);
+ }
- std::ifstream input("/etc/release");
+ return name;
+ }
- if (input)
- std::getline(input, this->distro_release);
- }
- };
+ void load_uname_info()
+ {
+ this->hostname = uname().nodename;
+ this->kernel = string(uname().sysname) + ' ' + uname().release;
+ }
- class LSBSysInfo
- : public SysInfo
- {
- public:
- LSBSysInfo()
- : re(Glib::Regex::create("^.+?:\\s*(.+)\\s*$"))
- {
- // start();
- }
+ void load_gnome_version()
+ {
+ xmlDocPtr document;
+ xmlXPathContextPtr context;
+ const string nodes[3] = { "string(/gnome-version/platform)",
+ "string(/gnome-version/minor)",
+ "string(/gnome-version/micro)" };
+ string values[3];
- virtual void set_distro_labels(GtkWidget* name, GtkWidget* release)
- {
- this->name = name;
- this->release = release;
+ if (not (document = xmlParseFile(DATADIR "/gnome/gnome-version.xml")))
+ return;
- this->start();
- }
+ if (not (context = xmlXPathNewContext(document)))
+ return;
+ for (size_t i = 0; i != 3; ++i)
+ {
+ xmlXPathObjectPtr xpath;
+ xpath = xmlXPathEvalExpression(BAD_CAST nodes[i].c_str(), context);
- private:
+ if (xpath and xpath->type == XPATH_STRING)
+ values[i] = reinterpret_cast<const char*>(xpath->stringval);
- sigc::connection child_watch;
- int lsb_fd;
- GtkWidget* name;
- GtkWidget* release;
+ xmlXPathFreeObject(xpath);
+ }
- void strip_description(string &s) const
- {
- const GRegexMatchFlags flags = static_cast<GRegexMatchFlags>(0);
- GMatchInfo* info = 0;
+ xmlXPathFreeContext(context);
+ xmlFreeDoc(document);
- if (g_regex_match(this->re->gobj(), s.c_str(), flags, &info)) {
- s = make_string(g_match_info_fetch(info, 1));
- g_match_info_free(info);
- }
- }
+ this->gnome_version = values[0] + '.' + values[1] + '.' + values[2];
+ }
+ };
- std::istream& get_value(std::istream &is, string &s) const
- {
- if (std::getline(is, s))
- this->strip_description(s);
- return is;
- }
- void read_lsb(Glib::Pid pid, int status)
+ class SolarisSysInfo
+ : public SysInfo
{
- this->child_watch.disconnect();
-
- if (!WIFEXITED(status) or WEXITSTATUS(status) != 0) {
- g_error("Child %d failed with status %d", int(pid), status);
- return;
- }
-
- Glib::RefPtr<Glib::IOChannel> channel = Glib::IOChannel::create_from_fd(this->lsb_fd);
- Glib::ustring content;
+ public:
+ SolarisSysInfo()
+ {
+ this->load_solaris_info();
+ }
- while (channel->read_to_end(content) == Glib::IO_STATUS_AGAIN)
- ;
+ private:
+ void load_solaris_info()
+ {
+ this->distro_name = "Solaris";
- channel->close();
- Glib::spawn_close_pid(pid);
+ std::ifstream input("/etc/release");
- procman_debug("lsb_release output = '%s'", content.c_str());
+ if (input)
+ std::getline(input, this->distro_release);
+ }
+ };
- string release, codename;
- std::istringstream input(content);
-
- this->get_value(input, this->distro_name)
- and this->get_value(input, release)
- and this->get_value(input, codename);
-
- this->distro_release = release;
- if (codename != "" && codename != "n/a")
- this->distro_release += " (" + codename + ')';
-
- this->SysInfo::set_distro_labels(this->name, this->release);
- }
-
- void start()
- {
- std::vector<string> argv(2);
- argv[0] = "lsb_release";
- argv[1] = "-irc";
-
- Glib::SpawnFlags flags = Glib::SPAWN_DO_NOT_REAP_CHILD
- | Glib::SPAWN_SEARCH_PATH
- | Glib::SPAWN_STDERR_TO_DEV_NULL;
-
- Glib::Pid child;
-
- try {
- Glib::spawn_async_with_pipes("/", // wd
- argv,
- flags,
- sigc::slot<void>(), // child setup
- &child,
- 0, // stdin
- &this->lsb_fd); // stdout
- } catch (Glib::SpawnError &e) {
- g_error("g_spawn_async_with_pipes error: %s", e.what().c_str());
- return;
- }
-
- sigc::slot<void,GPid, int> slot = sigc::mem_fun(this, &LSBSysInfo::read_lsb);
- this->child_watch = Glib::signal_child_watch().connect(slot, child);
- }
-
-
- void sync_lsb_release()
+ class LSBSysInfo
+ : public SysInfo
{
- char *out= 0;
- GError *error = 0;
- int status;
-
- if (g_spawn_command_line_sync("lsb_release -irc",
- &out,
- 0,
- &status,
- &error)) {
- string release, codename;
- if (!error and WIFEXITED(status) and WEXITSTATUS(status) == 0) {
- std::istringstream input(out);
- this->get_value(input, this->distro_name)
- and this->get_value(input, release)
- and this->get_value(input, codename);
- this->distro_release = release;
- if (codename != "" && codename != "n/a")
- this->distro_release += " (" + codename + ')';
- }
- }
-
- if (error)
- g_error_free(error);
-
- g_free(out);
- }
+ public:
+ LSBSysInfo()
+ : re(Glib::Regex::create("^.+?:\\s*(.+)\\s*$"))
+ {
+ // start();
+ }
- private:
- Glib::RefPtr<Glib::Regex> re;
- };
+ virtual void set_distro_labels(GtkWidget* name, GtkWidget* release)
+ {
+ this->name = name;
+ this->release = release;
+
+ this->start();
+ }
+
+
+ private:
+
+ sigc::connection child_watch;
+ int lsb_fd;
+ GtkWidget* name;
+ GtkWidget* release;
+
+ void strip_description(string &s) const
+ {
+ const GRegexMatchFlags flags = static_cast<GRegexMatchFlags>(0);
+ GMatchInfo* info = 0;
+
+ if (g_regex_match(this->re->gobj(), s.c_str(), flags, &info)) {
+ s = make_string(g_match_info_fetch(info, 1));
+ g_match_info_free(info);
+ }
+ }
+
+ std::istream& get_value(std::istream &is, string &s) const
+ {
+ if (std::getline(is, s))
+ this->strip_description(s);
+ return is;
+ }
+
+
+ void read_lsb(Glib::Pid pid, int status)
+ {
+ this->child_watch.disconnect();
+
+ if (!WIFEXITED(status) or WEXITSTATUS(status) != 0) {
+ g_error("Child %d failed with status %d", int(pid), status);
+ return;
+ }
+
+ Glib::RefPtr<Glib::IOChannel> channel = Glib::IOChannel::create_from_fd(this->lsb_fd);
+ Glib::ustring content;
+
+ while (channel->read_to_end(content) == Glib::IO_STATUS_AGAIN)
+ ;
+
+ channel->close();
+ Glib::spawn_close_pid(pid);
+
+ procman_debug("lsb_release output = '%s'", content.c_str());
+
+ string release, codename;
+ std::istringstream input(content);
+
+ this->get_value(input, this->distro_name)
+ and this->get_value(input, release)
+ and this->get_value(input, codename);
+
+ this->distro_release = release;
+ if (codename != "" && codename != "n/a")
+ this->distro_release += " (" + codename + ')';
+
+ this->SysInfo::set_distro_labels(this->name, this->release);
+ }
+
+
+ void start()
+ {
+ std::vector<string> argv(2);
+ argv[0] = "lsb_release";
+ argv[1] = "-irc";
+
+ Glib::SpawnFlags flags = Glib::SPAWN_DO_NOT_REAP_CHILD
+ | Glib::SPAWN_SEARCH_PATH
+ | Glib::SPAWN_STDERR_TO_DEV_NULL;
+
+ Glib::Pid child;
+
+ try {
+ Glib::spawn_async_with_pipes("/", // wd
+ argv,
+ flags,
+ sigc::slot<void>(), // child setup
+ &child,
+ 0, // stdin
+ &this->lsb_fd); // stdout
+ } catch (Glib::SpawnError &e) {
+ g_error("g_spawn_async_with_pipes error: %s", e.what().c_str());
+ return;
+ }
+
+ sigc::slot<void,GPid, int> slot = sigc::mem_fun(this, &LSBSysInfo::read_lsb);
+ this->child_watch = Glib::signal_child_watch().connect(slot, child);
+ }
+
+
+ void sync_lsb_release()
+ {
+ char *out= 0;
+ GError *error = 0;
+ int status;
+
+ if (g_spawn_command_line_sync("lsb_release -irc",
+ &out,
+ 0,
+ &status,
+ &error)) {
+ string release, codename;
+ if (!error and WIFEXITED(status) and WEXITSTATUS(status) == 0) {
+ std::istringstream input(out);
+ this->get_value(input, this->distro_name)
+ and this->get_value(input, release)
+ and this->get_value(input, codename);
+ this->distro_release = release;
+ if (codename != "" && codename != "n/a")
+ this->distro_release += " (" + codename + ')';
+ }
+ }
+
+ if (error)
+ g_error_free(error);
+
+ g_free(out);
+ }
+
+ private:
+ Glib::RefPtr<Glib::Regex> re;
+ };
- class NetBSDSysInfo
- : public SysInfo
- {
- public:
- NetBSDSysInfo()
+ class NetBSDSysInfo
+ : public SysInfo
{
- this->load_netbsd_info();
- }
+ public:
+ NetBSDSysInfo()
+ {
+ this->load_netbsd_info();
+ }
- private:
- void load_netbsd_info()
- {
- this->distro_name = "NetBSD";
+ private:
+ void load_netbsd_info()
+ {
+ this->distro_name = "NetBSD";
- std::ifstream input("/etc/release");
+ std::ifstream input("/etc/release");
- if (input)
- std::getline(input, this->distro_release);
- }
- };
+ if (input)
+ std::getline(input, this->distro_release);
+ }
+ };
- class OpenBSDSysInfo
- : public SysInfo
- {
- public:
- OpenBSDSysInfo()
+ class OpenBSDSysInfo
+ : public SysInfo
{
- this->load_openbsd_info();
- }
-
- private:
- void load_openbsd_info()
+ public:
+ OpenBSDSysInfo()
+ {
+ this->load_openbsd_info();
+ }
+
+ private:
+ void load_openbsd_info()
+ {
+ this->distro_name = "OpenBSD";
+ this->distro_release = this->kernel;
+
+ std::ifstream input("/etc/motd");
+
+ if (input)
+ std::getline(input, this->kernel);
+ }
+ };
+
+ SysInfo* get_sysinfo()
{
- this->distro_name = "OpenBSD";
- this->distro_release = this->kernel;
-
- std::ifstream input("/etc/motd");
-
- if (input)
- std::getline(input, this->kernel);
- }
- };
-
- SysInfo* get_sysinfo()
- {
- if (char *p = g_find_program_in_path("lsb_release")) {
- g_free(p);
- return new LSBSysInfo;
- }
- else if (SysInfo::system() == "SunOS") {
- return new SolarisSysInfo;
- }
- else if (SysInfo::system() == "NetBSD") {
- return new NetBSDSysInfo;
- }
- else if (SysInfo::system() == "OpenBSD") {
- return new OpenBSDSysInfo;
+ if (char *p = g_find_program_in_path("lsb_release")) {
+ g_free(p);
+ return new LSBSysInfo;
+ }
+ else if (SysInfo::system() == "SunOS") {
+ return new SolarisSysInfo;
+ }
+ else if (SysInfo::system() == "NetBSD") {
+ return new NetBSDSysInfo;
+ }
+ else if (SysInfo::system() == "OpenBSD") {
+ return new OpenBSDSysInfo;
+ }
+
+ return new SysInfo;
}
-
- return new SysInfo;
- }
}
@@ -450,258 +450,258 @@ sysinfo_logo_draw (GtkWidget *widget,
cairo_t *context,
gpointer data_ptr)
{
- GtkAllocation allocation;
- GtkStyle *style;
- cairo_t *cr;
- cairo_pattern_t *cp;
-
- cr = gdk_cairo_create(gtk_widget_get_window(widget));
-
- gtk_widget_get_allocation (widget, &allocation);
- cairo_translate(cr, allocation.x, allocation.y);
-
- cairo_move_to(cr, X_PAD + RADIUS, Y_PAD);
- cairo_line_to(cr, X_PAD + LOGO_W - RADIUS, Y_PAD);
- cairo_arc(cr, X_PAD + LOGO_W - RADIUS, Y_PAD + RADIUS, RADIUS, -0.5 * M_PI, 0);
- cairo_line_to(cr, X_PAD + LOGO_W, Y_PAD + LOGO_H - RADIUS);
- cairo_arc(cr, X_PAD + LOGO_W - RADIUS, Y_PAD + LOGO_H - RADIUS, RADIUS, 0, 0.5 * M_PI);
- cairo_line_to(cr, X_PAD + RADIUS, Y_PAD + LOGO_H);
- cairo_arc(cr, X_PAD + RADIUS, Y_PAD + LOGO_H - RADIUS, RADIUS, 0.5 * M_PI, -1.0 * M_PI);
- cairo_line_to(cr, X_PAD, Y_PAD + RADIUS);
- cairo_arc(cr, X_PAD + RADIUS, Y_PAD + RADIUS, RADIUS, -1.0 * M_PI, -0.5 * M_PI);
-
- cp = cairo_pattern_create_linear(0, Y_PAD, 0, Y_PAD + LOGO_H);
- style = gtk_widget_get_style (widget);
- cairo_pattern_add_color_stop_rgba(cp, 0.0,
- style->base[GTK_STATE_SELECTED].red / 65535.0,
- style->base[GTK_STATE_SELECTED].green / 65535.0,
- style->base[GTK_STATE_SELECTED].blue / 65535.0,
- 1.0);
- cairo_pattern_add_color_stop_rgba(cp, 1.0,
- style->base[GTK_STATE_SELECTED].red / 65535.0,
- style->base[GTK_STATE_SELECTED].green / 65535.0,
- style->base[GTK_STATE_SELECTED].blue / 65535.0,
- 0.0);
- cairo_set_source(cr, cp);
- cairo_fill(cr);
-
- cairo_pattern_destroy(cp);
- cairo_destroy(cr);
-
- return FALSE;
+ GtkAllocation allocation;
+ GtkStyle *style;
+ cairo_t *cr;
+ cairo_pattern_t *cp;
+
+ cr = gdk_cairo_create(gtk_widget_get_window(widget));
+
+ gtk_widget_get_allocation (widget, &allocation);
+ cairo_translate(cr, allocation.x, allocation.y);
+
+ cairo_move_to(cr, X_PAD + RADIUS, Y_PAD);
+ cairo_line_to(cr, X_PAD + LOGO_W - RADIUS, Y_PAD);
+ cairo_arc(cr, X_PAD + LOGO_W - RADIUS, Y_PAD + RADIUS, RADIUS, -0.5 * M_PI, 0);
+ cairo_line_to(cr, X_PAD + LOGO_W, Y_PAD + LOGO_H - RADIUS);
+ cairo_arc(cr, X_PAD + LOGO_W - RADIUS, Y_PAD + LOGO_H - RADIUS, RADIUS, 0, 0.5 * M_PI);
+ cairo_line_to(cr, X_PAD + RADIUS, Y_PAD + LOGO_H);
+ cairo_arc(cr, X_PAD + RADIUS, Y_PAD + LOGO_H - RADIUS, RADIUS, 0.5 * M_PI, -1.0 * M_PI);
+ cairo_line_to(cr, X_PAD, Y_PAD + RADIUS);
+ cairo_arc(cr, X_PAD + RADIUS, Y_PAD + RADIUS, RADIUS, -1.0 * M_PI, -0.5 * M_PI);
+
+ cp = cairo_pattern_create_linear(0, Y_PAD, 0, Y_PAD + LOGO_H);
+ style = gtk_widget_get_style (widget);
+ cairo_pattern_add_color_stop_rgba(cp, 0.0,
+ style->base[GTK_STATE_SELECTED].red / 65535.0,
+ style->base[GTK_STATE_SELECTED].green / 65535.0,
+ style->base[GTK_STATE_SELECTED].blue / 65535.0,
+ 1.0);
+ cairo_pattern_add_color_stop_rgba(cp, 1.0,
+ style->base[GTK_STATE_SELECTED].red / 65535.0,
+ style->base[GTK_STATE_SELECTED].green / 65535.0,
+ style->base[GTK_STATE_SELECTED].blue / 65535.0,
+ 0.0);
+ cairo_set_source(cr, cp);
+ cairo_fill(cr);
+
+ cairo_pattern_destroy(cp);
+ cairo_destroy(cr);
+
+ return FALSE;
}
static GtkWidget*
add_section(GtkBox *vbox , const char * title, int num_row, int num_col, GtkWidget **out_frame)
{
- GtkWidget *table;
-
- GtkWidget *frame = gtk_frame_new(title);
- gtk_frame_set_label_align(GTK_FRAME(frame), 0.0, 0.5);
- gtk_label_set_use_markup(
- GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))),
- TRUE
- );
- gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
- gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
-
- GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
- gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 12, 0);
- gtk_container_add(GTK_CONTAINER(frame), alignment);
-
- table = gtk_table_new(num_row, num_col, FALSE);
- gtk_table_set_row_spacings(GTK_TABLE(table), 6);
- gtk_table_set_col_spacings(GTK_TABLE(table), 6);
- gtk_container_set_border_width(GTK_CONTAINER(table), 6);
- gtk_container_add(GTK_CONTAINER(alignment), table);
-
- if(out_frame)
- *out_frame = frame;
-
- return table;
+ GtkWidget *table;
+
+ GtkWidget *frame = gtk_frame_new(title);
+ gtk_frame_set_label_align(GTK_FRAME(frame), 0.0, 0.5);
+ gtk_label_set_use_markup(
+ GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))),
+ TRUE
+ );
+ gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
+
+ GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
+ gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 12, 0);
+ gtk_container_add(GTK_CONTAINER(frame), alignment);
+
+ table = gtk_table_new(num_row, num_col, FALSE);
+ gtk_table_set_row_spacings(GTK_TABLE(table), 6);
+ gtk_table_set_col_spacings(GTK_TABLE(table), 6);
+ gtk_container_set_border_width(GTK_CONTAINER(table), 6);
+ gtk_container_add(GTK_CONTAINER(alignment), table);
+
+ if(out_frame)
+ *out_frame = frame;
+
+ return table;
}
static GtkWidget*
add_row(GtkTable * table, const char * label, const char * value, int row)
{
- GtkWidget *header = gtk_label_new(label);
- gtk_misc_set_alignment(GTK_MISC(header), 0.0, 0.5);
- gtk_table_attach(
- table, header,
- 0, 1, row, row + 1,
- GTK_FILL, GTK_FILL, 0, 0
- );
-
- GtkWidget *label_widget = gtk_label_new(value);
- gtk_misc_set_alignment(GTK_MISC(label_widget), 0.0, 0.5);
- gtk_table_attach(
- table, label_widget,
- 1, 2, row, row + 1,
- GTK_FILL, GTK_FILL, 0, 0
- );
- return label_widget;
+ GtkWidget *header = gtk_label_new(label);
+ gtk_misc_set_alignment(GTK_MISC(header), 0.0, 0.5);
+ gtk_table_attach(
+ table, header,
+ 0, 1, row, row + 1,
+ GTK_FILL, GTK_FILL, 0, 0
+ );
+
+ GtkWidget *label_widget = gtk_label_new(value);
+ gtk_misc_set_alignment(GTK_MISC(label_widget), 0.0, 0.5);
+ gtk_table_attach(
+ table, label_widget,
+ 1, 2, row, row + 1,
+ GTK_FILL, GTK_FILL, 0, 0
+ );
+ return label_widget;
}
static GtkWidget *
procman_create_sysinfo_view(void)
{
- GtkWidget *hbox;
- GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *vbox;
- SysInfo *data = get_sysinfo();;
+ SysInfo *data = get_sysinfo();;
- GtkWidget * logo;
+ GtkWidget * logo;
- GtkWidget *distro_frame;
- GtkWidget *distro_release_label;
- GtkWidget *distro_table;
+ GtkWidget *distro_frame;
+ GtkWidget *distro_release_label;
+ GtkWidget *distro_table;
- GtkWidget *hardware_table;
+ GtkWidget *hardware_table;
- GtkWidget *disk_space_table;
+ GtkWidget *disk_space_table;
- GtkWidget *header;
+ GtkWidget *header;
- gchar *markup;
+ gchar *markup;
- hbox = gtk_hbox_new(FALSE, 12);
- gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
+ hbox = gtk_hbox_new(FALSE, 12);
+ gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
- /* left-side logo */
+ /* left-side logo */
- logo = gtk_image_new_from_file(DATADIR "/pixmaps/gnome-system-monitor/side.png");
- gtk_misc_set_alignment(GTK_MISC(logo), 0.5, 0.0);
- gtk_misc_set_padding(GTK_MISC(logo), 5, 12);
- gtk_box_pack_start(GTK_BOX(hbox), logo, FALSE, FALSE, 0);
+ logo = gtk_image_new_from_file(DATADIR "/pixmaps/gnome-system-monitor/side.png");
+ gtk_misc_set_alignment(GTK_MISC(logo), 0.5, 0.0);
+ gtk_misc_set_padding(GTK_MISC(logo), 5, 12);
+ gtk_box_pack_start(GTK_BOX(hbox), logo, FALSE, FALSE, 0);
- g_signal_connect(G_OBJECT(logo), "draw",
- G_CALLBACK(sysinfo_logo_draw), NULL);
+ g_signal_connect(G_OBJECT(logo), "draw",
+ G_CALLBACK(sysinfo_logo_draw), NULL);
- vbox = gtk_vbox_new(FALSE, 12);
- gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
- gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
+ vbox = gtk_vbox_new(FALSE, 12);
+ gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
+ gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
- // hostname
+ // hostname
- markup = g_strdup_printf("<big><big><b><u>%s</u></b></big></big>",
- data->hostname.c_str());
- GtkWidget *hostname_frame = gtk_frame_new(markup);
- g_free(markup);
- gtk_frame_set_label_align(GTK_FRAME(hostname_frame), 0.0, 0.5);
- gtk_label_set_use_markup(
- GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(hostname_frame))),
- TRUE
- );
- gtk_frame_set_shadow_type(GTK_FRAME(hostname_frame), GTK_SHADOW_NONE);
- gtk_box_pack_start(GTK_BOX(vbox), hostname_frame, FALSE, FALSE, 0);
+ markup = g_strdup_printf("<big><big><b><u>%s</u></b></big></big>",
+ data->hostname.c_str());
+ GtkWidget *hostname_frame = gtk_frame_new(markup);
+ g_free(markup);
+ gtk_frame_set_label_align(GTK_FRAME(hostname_frame), 0.0, 0.5);
+ gtk_label_set_use_markup(
+ GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(hostname_frame))),
+ TRUE
+ );
+ gtk_frame_set_shadow_type(GTK_FRAME(hostname_frame), GTK_SHADOW_NONE);
+ gtk_box_pack_start(GTK_BOX(vbox), hostname_frame, FALSE, FALSE, 0);
- /* distro section */
+ /* distro section */
- unsigned table_size = 2;
- if (data->gnome_version != "")
- table_size++;
- distro_table = add_section(GTK_BOX(vbox), "???", table_size, 1, &distro_frame);
+ unsigned table_size = 2;
+ if (data->gnome_version != "")
+ table_size++;
+ distro_table = add_section(GTK_BOX(vbox), "???", table_size, 1, &distro_frame);
- unsigned table_count = 0;
+ unsigned table_count = 0;
- distro_release_label = gtk_label_new("???");
- gtk_misc_set_alignment(GTK_MISC(distro_release_label), 0.0, 0.5);
- gtk_table_attach(
- GTK_TABLE(distro_table), distro_release_label,
- 0, 1, table_count, table_count+1,
- GTK_FILL, GTK_FILL, 0, 0
- );
- table_count++;
- data->set_distro_labels(gtk_frame_get_label_widget(GTK_FRAME(distro_frame)), distro_release_label);
+ distro_release_label = gtk_label_new("???");
+ gtk_misc_set_alignment(GTK_MISC(distro_release_label), 0.0, 0.5);
+ gtk_table_attach(
+ GTK_TABLE(distro_table), distro_release_label,
+ 0, 1, table_count, table_count+1,
+ GTK_FILL, GTK_FILL, 0, 0
+ );
+ table_count++;
+ data->set_distro_labels(gtk_frame_get_label_widget(GTK_FRAME(distro_frame)), distro_release_label);
- markup = g_strdup_printf(_("Kernel %s"), data->kernel.c_str());
- header = gtk_label_new(markup);
- g_free(markup);
- gtk_misc_set_alignment(GTK_MISC(header), 0.0, 0.5);
- gtk_table_attach(
- GTK_TABLE(distro_table), header,
- 0, 1, table_count, table_count + 1,
- GTK_FILL, GTK_FILL, 0, 0
- );
- table_count++;
+ markup = g_strdup_printf(_("Kernel %s"), data->kernel.c_str());
+ header = gtk_label_new(markup);
+ g_free(markup);
+ gtk_misc_set_alignment(GTK_MISC(header), 0.0, 0.5);
+ gtk_table_attach(
+ GTK_TABLE(distro_table), header,
+ 0, 1, table_count, table_count + 1,
+ GTK_FILL, GTK_FILL, 0, 0
+ );
+ table_count++;
- if (data->gnome_version != "")
+ if (data->gnome_version != "")
{
- markup = g_strdup_printf(_("GNOME %s"), data->gnome_version.c_str());
- header = gtk_label_new(markup);
- g_free(markup);
- gtk_misc_set_alignment(GTK_MISC(header), 0.0, 0.5);
- gtk_table_attach(
- GTK_TABLE(distro_table), header,
- 0, 1, table_count, table_count + 1,
- GTK_FILL, GTK_FILL, 0, 0
- );
- table_count++;
+ markup = g_strdup_printf(_("GNOME %s"), data->gnome_version.c_str());
+ header = gtk_label_new(markup);
+ g_free(markup);
+ gtk_misc_set_alignment(GTK_MISC(header), 0.0, 0.5);
+ gtk_table_attach(
+ GTK_TABLE(distro_table), header,
+ 0, 1, table_count, table_count + 1,
+ GTK_FILL, GTK_FILL, 0, 0
+ );
+ table_count++;
}
- /* hardware section */
-
- markup = g_strdup_printf(_("<b>Hardware</b>"));
- hardware_table = add_section(GTK_BOX(vbox), markup, data->processors.size(), 2, NULL);
- g_free(markup);
-
- markup = procman::format_size(data->memory_bytes);
- add_row(GTK_TABLE(hardware_table), _("Memory:"),
- markup, 0);
- g_free(markup);
-
- for (guint i = 0; i < data->processors.size(); ++i) {
- const gchar * t;
- if (data->processors.size() > 1) {
- markup = g_strdup_printf(_("Processor %d:"), i);
- t = markup;
+ /* hardware section */
+
+ markup = g_strdup_printf(_("<b>Hardware</b>"));
+ hardware_table = add_section(GTK_BOX(vbox), markup, data->processors.size(), 2, NULL);
+ g_free(markup);
+
+ markup = procman::format_size(data->memory_bytes);
+ add_row(GTK_TABLE(hardware_table), _("Memory:"),
+ markup, 0);
+ g_free(markup);
+
+ for (guint i = 0; i < data->processors.size(); ++i) {
+ const gchar * t;
+ if (data->processors.size() > 1) {
+ markup = g_strdup_printf(_("Processor %d:"), i);
+ t = markup;
+ }
+ else {
+ markup = NULL;
+ t = _("Processor:");
+ }
+
+ add_row(GTK_TABLE(hardware_table), t,
+ data->processors[i].c_str(), 1 + i);
+
+ if(markup)
+ g_free(markup);
}
- else {
- markup = NULL;
- t = _("Processor:");
- }
-
- add_row(GTK_TABLE(hardware_table), t,
- data->processors[i].c_str(), 1 + i);
- if(markup)
- g_free(markup);
- }
+ /* disk space section */
- /* disk space section */
+ markup = g_strdup_printf(_("<b>System Status</b>"));
+ disk_space_table = add_section(GTK_BOX(vbox), markup, 1, 2, NULL);
+ g_free(markup);
- markup = g_strdup_printf(_("<b>System Status</b>"));
- disk_space_table = add_section(GTK_BOX(vbox), markup, 1, 2, NULL);
- g_free(markup);
+ markup = procman::format_size(data->free_space_bytes);
+ add_row(GTK_TABLE(disk_space_table),
+ _("Available disk space:"), markup,
+ 0);
+ g_free(markup);
- markup = procman::format_size(data->free_space_bytes);
- add_row(GTK_TABLE(disk_space_table),
- _("Available disk space:"), markup,
- 0);
- g_free(markup);
-
- return hbox;
+ return hbox;
}
namespace procman
{
- void build_sysinfo_ui()
- {
- 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),
- PROCMAN_TAB_SYSINFO));
- gtk_box_pack_start(box, ui, TRUE, TRUE, 0);
- gtk_widget_show_all(ui);
+ void build_sysinfo_ui()
+ {
+ 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),
+ PROCMAN_TAB_SYSINFO));
+ gtk_box_pack_start(box, ui, TRUE, TRUE, 0);
+ gtk_widget_show_all(ui);
+ }
}
- }
}
diff --git a/src/sysinfo.h b/src/sysinfo.h
index 8b0b162..48e5ce7 100644
--- a/src/sysinfo.h
+++ b/src/sysinfo.h
@@ -3,7 +3,7 @@
namespace procman
{
- void build_sysinfo_ui();
+ void build_sysinfo_ui();
}
#endif /* H_GNOME_SYSTEM_MONITOR_SYSINFO_H_1155594649 */
diff --git a/src/util.cpp b/src/util.cpp
index 7183ff4..a36f36e 100644
--- a/src/util.cpp
+++ b/src/util.cpp
@@ -22,32 +22,32 @@ extern "C" {
static const char*
format_process_state(guint state)
{
- const char *status;
+ const char *status;
- switch (state)
+ switch (state)
{
- case GLIBTOP_PROCESS_RUNNING:
- status = _("Running");
- break;
+ case GLIBTOP_PROCESS_RUNNING:
+ status = _("Running");
+ break;
- case GLIBTOP_PROCESS_STOPPED:
- status = _("Stopped");
- break;
+ case GLIBTOP_PROCESS_STOPPED:
+ status = _("Stopped");
+ break;
- case GLIBTOP_PROCESS_ZOMBIE:
- status = _("Zombie");
- break;
+ case GLIBTOP_PROCESS_ZOMBIE:
+ status = _("Zombie");
+ break;
- case GLIBTOP_PROCESS_UNINTERRUPTIBLE:
- status = _("Uninterruptible");
- break;
+ case GLIBTOP_PROCESS_UNINTERRUPTIBLE:
+ status = _("Uninterruptible");
+ break;
- default:
- status = _("Sleeping");
- break;
+ default:
+ status = _("Sleeping");
+ break;
}
- return status;
+ return status;
}
@@ -55,29 +55,29 @@ format_process_state(guint state)
static char *
mnemonic_safe_process_name(const char *process_name)
{
- const char *p;
- GString *name;
+ const char *p;
+ GString *name;
- name = g_string_new ("");
+ name = g_string_new ("");
- for(p = process_name; *p; ++p)
- {
- g_string_append_c (name, *p);
+ for(p = process_name; *p; ++p)
+ {
+ g_string_append_c (name, *p);
- if(*p == '_')
- g_string_append_c (name, '_');
- }
+ if(*p == '_')
+ g_string_append_c (name, '_');
+ }
- return g_string_free (name, FALSE);
+ return g_string_free (name, FALSE);
}
static inline unsigned divide(unsigned *q, unsigned *r, unsigned d)
{
- *q = *r / d;
- *r = *r % d;
- return *q != 0;
+ *q = *r / d;
+ *r = *r % d;
+ return *q != 0;
}
@@ -88,49 +88,49 @@ static inline unsigned divide(unsigned *q, unsigned *r, unsigned d)
static char *
format_duration_for_display(unsigned centiseconds)
{
- unsigned weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0;
+ unsigned weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0;
- (void)(divide(&seconds, ¢iseconds, 100)
- && divide(&minutes, &seconds, 60)
- && divide(&hours, &minutes, 60)
- && divide(&days, &hours, 24)
- && divide(&weeks, &days, 7));
+ (void)(divide(&seconds, ¢iseconds, 100)
+ && divide(&minutes, &seconds, 60)
+ && divide(&hours, &minutes, 60)
+ && divide(&days, &hours, 24)
+ && divide(&weeks, &days, 7));
- if (weeks)
- /* xgettext: weeks, days */
- return g_strdup_printf(_("%uw%ud"), weeks, days);
+ if (weeks)
+ /* xgettext: weeks, days */
+ return g_strdup_printf(_("%uw%ud"), weeks, days);
- if (days)
- /* xgettext: days, hours (0 -> 23) */
- return g_strdup_printf(_("%ud%02uh"), days, hours);
+ if (days)
+ /* xgettext: days, hours (0 -> 23) */
+ return g_strdup_printf(_("%ud%02uh"), days, hours);
- if (hours)
- /* xgettext: hours (0 -> 23), minutes, seconds */
- return g_strdup_printf(_("%u:%02u:%02u"), hours, minutes, seconds);
+ if (hours)
+ /* xgettext: hours (0 -> 23), minutes, seconds */
+ return g_strdup_printf(_("%u:%02u:%02u"), hours, minutes, seconds);
- /* xgettext: minutes, seconds, centiseconds */
- return g_strdup_printf(_("%u:%02u.%02u"), minutes, seconds, centiseconds);
+ /* xgettext: minutes, seconds, centiseconds */
+ return g_strdup_printf(_("%u:%02u.%02u"), minutes, seconds, centiseconds);
}
GtkWidget*
procman_make_label_for_mmaps_or_ofiles(const char *format,
- const char *process_name,
- unsigned pid)
+ const char *process_name,
+ unsigned pid)
{
- GtkWidget *label;
- char *name, *title;
+ GtkWidget *label;
+ char *name, *title;
- name = mnemonic_safe_process_name (process_name);
- title = g_strdup_printf(format, name, pid);
- label = gtk_label_new_with_mnemonic (title);
- gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
+ name = mnemonic_safe_process_name (process_name);
+ title = g_strdup_printf(format, name, pid);
+ label = gtk_label_new_with_mnemonic (title);
+ gtk_misc_set_alignment (GTK_MISC (label), 0.0f, 0.5f);
- g_free (title);
- g_free (name);
+ g_free (title);
+ g_free (name);
- return label;
+ return label;
}
@@ -138,11 +138,11 @@ procman_make_label_for_mmaps_or_ofiles(const char *format,
/**
* procman::format_size:
* @size:
- *
+ *
* Formats the file size passed in @bytes in a way that is easy for
* the user to read. Gives the size in bytes, kibibytes, mebibytes or
* gibibytes, choosing whatever is appropriate.
- *
+ *
* Returns: a newly allocated string with the size ready to be shown.
**/
@@ -150,64 +150,64 @@ gchar*
procman::format_size(guint64 size, guint64 max_size, bool want_bits)
{
- enum {
- K_INDEX,
- M_INDEX,
- G_INDEX,
- T_INDEX
- };
-
- struct Format {
- guint64 factor;
- const char* string;
- };
-
- const Format all_formats[2][4] = {
- { { G_GUINT64_CONSTANT(1) << 10, N_("%.1f KiB") },
- { G_GUINT64_CONSTANT(1) << 20, N_("%.1f MiB") },
- { G_GUINT64_CONSTANT(1) << 30, N_("%.1f GiB") },
- { G_GUINT64_CONSTANT(1) << 40, N_("%.1f TiB") } },
- { { G_GUINT64_CONSTANT(1000), N_("%.1f kbit") },
- { G_GUINT64_CONSTANT(1000000), N_("%.1f Mbit") },
- { G_GUINT64_CONSTANT(1000000000), N_("%.1f Gbit") },
- { G_GUINT64_CONSTANT(1000000000000), N_("%.1f Tbit") } }
- };
-
- const Format (&formats)[4] = all_formats[want_bits ? 1 : 0];
-
- if (want_bits) {
- size *= 8;
- max_size *= 8;
- }
-
- if (max_size == 0)
- max_size = size;
-
- if (max_size < formats[K_INDEX].factor) {
- const char *format = (want_bits
- ? dngettext(GETTEXT_PACKAGE, "%u bit", "%u bits", (guint) size)
- : dngettext(GETTEXT_PACKAGE, "%u byte", "%u bytes",(guint) size));
- return g_strdup_printf (format, (guint) size);
- } else {
- guint64 factor;
- const char* format = NULL;
-
- if (max_size < formats[M_INDEX].factor) {
- factor = formats[K_INDEX].factor;
- format = formats[K_INDEX].string;
- } else if (max_size < formats[G_INDEX].factor) {
- factor = formats[M_INDEX].factor;
- format = formats[M_INDEX].string;
- } else if (max_size < formats[T_INDEX].factor) {
- factor = formats[G_INDEX].factor;
- format = formats[G_INDEX].string;
- } else {
- factor = formats[T_INDEX].factor;
- format = formats[T_INDEX].string;
- }
-
- return g_strdup_printf(_(format), size / (double)factor);
- }
+ enum {
+ K_INDEX,
+ M_INDEX,
+ G_INDEX,
+ T_INDEX
+ };
+
+ struct Format {
+ guint64 factor;
+ const char* string;
+ };
+
+ const Format all_formats[2][4] = {
+ { { G_GUINT64_CONSTANT(1) << 10, N_("%.1f KiB") },
+ { G_GUINT64_CONSTANT(1) << 20, N_("%.1f MiB") },
+ { G_GUINT64_CONSTANT(1) << 30, N_("%.1f GiB") },
+ { G_GUINT64_CONSTANT(1) << 40, N_("%.1f TiB") } },
+ { { G_GUINT64_CONSTANT(1000), N_("%.1f kbit") },
+ { G_GUINT64_CONSTANT(1000000), N_("%.1f Mbit") },
+ { G_GUINT64_CONSTANT(1000000000), N_("%.1f Gbit") },
+ { G_GUINT64_CONSTANT(1000000000000), N_("%.1f Tbit") } }
+ };
+
+ const Format (&formats)[4] = all_formats[want_bits ? 1 : 0];
+
+ if (want_bits) {
+ size *= 8;
+ max_size *= 8;
+ }
+
+ if (max_size == 0)
+ max_size = size;
+
+ if (max_size < formats[K_INDEX].factor) {
+ const char *format = (want_bits
+ ? dngettext(GETTEXT_PACKAGE, "%u bit", "%u bits", (guint) size)
+ : dngettext(GETTEXT_PACKAGE, "%u byte", "%u bytes",(guint) size));
+ return g_strdup_printf (format, (guint) size);
+ } else {
+ guint64 factor;
+ const char* format = NULL;
+
+ if (max_size < formats[M_INDEX].factor) {
+ factor = formats[K_INDEX].factor;
+ format = formats[K_INDEX].string;
+ } else if (max_size < formats[G_INDEX].factor) {
+ factor = formats[M_INDEX].factor;
+ format = formats[M_INDEX].string;
+ } else if (max_size < formats[T_INDEX].factor) {
+ factor = formats[G_INDEX].factor;
+ format = formats[G_INDEX].string;
+ } else {
+ factor = formats[T_INDEX].factor;
+ format = formats[T_INDEX].string;
+ }
+
+ return g_strdup_printf(_(format), size / (double)factor);
+ }
}
@@ -215,301 +215,301 @@ procman::format_size(guint64 size, guint64 max_size, bool want_bits)
gboolean
load_symbols(const char *module, ...)
{
- GModule *mod;
- gboolean found_all = TRUE;
- va_list args;
+ GModule *mod;
+ gboolean found_all = TRUE;
+ va_list args;
- mod = g_module_open(module, static_cast<GModuleFlags>(G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL));
+ mod = g_module_open(module, static_cast<GModuleFlags>(G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL));
- if (!mod)
- return FALSE;
+ if (!mod)
+ return FALSE;
- procman_debug("Found %s", module);
+ procman_debug("Found %s", module);
- va_start(args, module);
+ va_start(args, module);
- while (1) {
- const char *name;
- void **symbol;
+ while (1) {
+ const char *name;
+ void **symbol;
- name = va_arg(args, char*);
+ name = va_arg(args, char*);
- if (!name)
- break;
+ if (!name)
+ break;
- symbol = va_arg(args, void**);
+ symbol = va_arg(args, void**);
- if (g_module_symbol(mod, name, symbol)) {
- procman_debug("Loaded %s from %s", name, module);
- }
- else {
- procman_debug("Could not load %s from %s", name, module);
- found_all = FALSE;
- break;
- }
- }
+ if (g_module_symbol(mod, name, symbol)) {
+ procman_debug("Loaded %s from %s", name, module);
+ }
+ else {
+ procman_debug("Could not load %s from %s", name, module);
+ found_all = FALSE;
+ break;
+ }
+ }
- va_end(args);
+ va_end(args);
- if (found_all)
- g_module_make_resident(mod);
- else
- g_module_close(mod);
+ if (found_all)
+ g_module_make_resident(mod);
+ else
+ g_module_close(mod);
- return found_all;
+ return found_all;
}
static gboolean
is_debug_enabled(void)
{
- static gboolean init;
- static gboolean enabled;
+ static gboolean init;
+ static gboolean enabled;
- if (!init) {
- enabled = g_getenv("GNOME_SYSTEM_MONITOR_DEBUG") != NULL;
- init = TRUE;
- }
+ if (!init) {
+ enabled = g_getenv("GNOME_SYSTEM_MONITOR_DEBUG") != NULL;
+ init = TRUE;
+ }
- return enabled;
+ return enabled;
}
static double get_relative_time(void)
{
- static unsigned long start_time;
- GTimeVal tv;
+ static unsigned long start_time;
+ GTimeVal tv;
- if (G_UNLIKELY(!start_time)) {
- glibtop_proc_time buf;
- glibtop_get_proc_time(&buf, getpid());
- start_time = buf.start_time;
- }
+ if (G_UNLIKELY(!start_time)) {
+ glibtop_proc_time buf;
+ glibtop_get_proc_time(&buf, getpid());
+ start_time = buf.start_time;
+ }
- g_get_current_time(&tv);
- return (tv.tv_sec - start_time) + 1e-6 * tv.tv_usec;
+ g_get_current_time(&tv);
+ return (tv.tv_sec - start_time) + 1e-6 * tv.tv_usec;
}
void
procman_debug_real(const char *file, int line, const char *func,
- const char *format, ...)
+ const char *format, ...)
{
- va_list args;
- char *msg;
+ va_list args;
+ char *msg;
- if (G_LIKELY(!is_debug_enabled()))
- return;
+ if (G_LIKELY(!is_debug_enabled()))
+ return;
- va_start(args, format);
- msg = g_strdup_vprintf(format, args);
- va_end(args);
+ va_start(args, format);
+ msg = g_strdup_vprintf(format, args);
+ va_end(args);
- g_debug("[%.3f %s:%d %s] %s", get_relative_time(), file, line, func, msg);
+ g_debug("[%.3f %s:%d %s] %s", get_relative_time(), file, line, func, msg);
- g_free(msg);
+ g_free(msg);
}
namespace procman
{
- void size_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data)
- {
- const guint index = GPOINTER_TO_UINT(user_data);
+ void size_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data)
+ {
+ const guint index = GPOINTER_TO_UINT(user_data);
- guint64 size;
- GValue value = { 0 };
+ guint64 size;
+ GValue value = { 0 };
- gtk_tree_model_get_value(model, iter, index, &value);
+ gtk_tree_model_get_value(model, iter, index, &value);
- switch (G_VALUE_TYPE(&value)) {
- case G_TYPE_ULONG:
- size = g_value_get_ulong(&value);
- break;
+ switch (G_VALUE_TYPE(&value)) {
+ case G_TYPE_ULONG:
+ size = g_value_get_ulong(&value);
+ break;
- case G_TYPE_UINT64:
- size = g_value_get_uint64(&value);
- break;
+ case G_TYPE_UINT64:
+ size = g_value_get_uint64(&value);
+ break;
- default:
- g_assert_not_reached();
- }
+ default:
+ g_assert_not_reached();
+ }
- g_value_unset(&value);
+ g_value_unset(&value);
- char *str = procman::format_size(size);
- g_object_set(renderer, "text", str, NULL);
- g_free(str);
- }
+ char *str = procman::format_size(size);
+ g_object_set(renderer, "text", str, NULL);
+ g_free(str);
+ }
- /*
- Same as above but handles size == 0 as not available
- */
- void size_na_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data)
- {
- const guint index = GPOINTER_TO_UINT(user_data);
+ /*
+ Same as above but handles size == 0 as not available
+ */
+ void size_na_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data)
+ {
+ const guint index = GPOINTER_TO_UINT(user_data);
- guint64 size;
- GValue value = { 0 };
+ guint64 size;
+ GValue value = { 0 };
- gtk_tree_model_get_value(model, iter, index, &value);
+ gtk_tree_model_get_value(model, iter, index, &value);
- switch (G_VALUE_TYPE(&value)) {
- case G_TYPE_ULONG:
- size = g_value_get_ulong(&value);
- break;
+ switch (G_VALUE_TYPE(&value)) {
+ case G_TYPE_ULONG:
+ size = g_value_get_ulong(&value);
+ break;
- case G_TYPE_UINT64:
- size = g_value_get_uint64(&value);
- break;
+ case G_TYPE_UINT64:
+ size = g_value_get_uint64(&value);
+ break;
- default:
- g_assert_not_reached();
- }
+ default:
+ g_assert_not_reached();
+ }
+
+ g_value_unset(&value);
- g_value_unset(&value);
+ if (size == 0)
+ g_object_set(renderer, "markup", _("<i>N/A</i>"), NULL);
+ else {
+ char *str = procman::format_size(size);
+ g_object_set(renderer, "text", str, NULL);
+ g_free(str);
+ }
- if (size == 0)
- g_object_set(renderer, "markup", _("<i>N/A</i>"), NULL);
- else {
- char *str = procman::format_size(size);
- g_object_set(renderer, "text", str, NULL);
- g_free(str);
}
- }
+ void duration_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data)
+ {
+ const guint index = GPOINTER_TO_UINT(user_data);
+
+ unsigned time;
+ GValue value = { 0 };
- void duration_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data)
- {
- const guint index = GPOINTER_TO_UINT(user_data);
+ gtk_tree_model_get_value(model, iter, index, &value);
- unsigned time;
- GValue value = { 0 };
+ switch (G_VALUE_TYPE(&value)) {
+ case G_TYPE_ULONG:
+ time = g_value_get_ulong(&value);
+ break;
- gtk_tree_model_get_value(model, iter, index, &value);
+ case G_TYPE_UINT64:
+ time = g_value_get_uint64(&value);
+ break;
- switch (G_VALUE_TYPE(&value)) {
- case G_TYPE_ULONG:
- time = g_value_get_ulong(&value);
- break;
+ default:
+ g_assert_not_reached();
+ }
- case G_TYPE_UINT64:
- time = g_value_get_uint64(&value);
- break;
+ g_value_unset(&value);
- default:
- g_assert_not_reached();
+ time = 100 * time / ProcData::get_instance()->frequency;
+ char *str = format_duration_for_display(time);
+ g_object_set(renderer, "text", str, NULL);
+ g_free(str);
}
- g_value_unset(&value);
- time = 100 * time / ProcData::get_instance()->frequency;
- char *str = format_duration_for_display(time);
- g_object_set(renderer, "text", str, NULL);
- g_free(str);
- }
+ void time_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data)
+ {
+ const guint index = GPOINTER_TO_UINT(user_data);
+ time_t time;
+ GValue value = { 0 };
- void time_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data)
- {
- const guint index = GPOINTER_TO_UINT(user_data);
+ gtk_tree_model_get_value(model, iter, index, &value);
- time_t time;
- GValue value = { 0 };
+ switch (G_VALUE_TYPE(&value)) {
+ case G_TYPE_ULONG:
+ time = g_value_get_ulong(&value);
+ break;
- gtk_tree_model_get_value(model, iter, index, &value);
+ default:
+ g_assert_not_reached();
+ }
- switch (G_VALUE_TYPE(&value)) {
- case G_TYPE_ULONG:
- time = g_value_get_ulong(&value);
- break;
+ g_value_unset(&value);
- default:
- g_assert_not_reached();
+ char *str = procman_format_date_for_display(time);
+ g_object_set(renderer, "text", str, NULL);
+ g_free(str);
}
- g_value_unset(&value);
+ void status_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data)
+ {
+ const guint index = GPOINTER_TO_UINT(user_data);
- char *str = procman_format_date_for_display(time);
- g_object_set(renderer, "text", str, NULL);
- g_free(str);
- }
+ guint state;
+ GValue value = { 0 };
- void status_cell_data_func(GtkTreeViewColumn *, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data)
- {
- const guint index = GPOINTER_TO_UINT(user_data);
+ gtk_tree_model_get_value(model, iter, index, &value);
- guint state;
- GValue value = { 0 };
+ switch (G_VALUE_TYPE(&value)) {
+ case G_TYPE_UINT:
+ state = g_value_get_uint(&value);
+ break;
- gtk_tree_model_get_value(model, iter, index, &value);
+ default:
+ g_assert_not_reached();
+ }
- switch (G_VALUE_TYPE(&value)) {
- case G_TYPE_UINT:
- state = g_value_get_uint(&value);
- break;
+ g_value_unset(&value);
- default:
- g_assert_not_reached();
+ const char *str = format_process_state(state);
+ g_object_set(renderer, "text", str, NULL);
}
- g_value_unset(&value);
- const char *str = format_process_state(state);
- g_object_set(renderer, "text", str, NULL);
- }
-
-
- template<>
- void tree_store_update<const char>(GtkTreeModel* model, GtkTreeIter* iter, int column, const char* new_value)
- {
- char* current_value;
+ template<>
+ void tree_store_update<const char>(GtkTreeModel* model, GtkTreeIter* iter, int column, const char* new_value)
+ {
+ char* current_value;
- gtk_tree_model_get(model, iter, column, ¤t_value, -1);
+ gtk_tree_model_get(model, iter, column, ¤t_value, -1);
- if (!current_value or std::strcmp(current_value, new_value) != 0)
- gtk_tree_store_set(GTK_TREE_STORE(model), iter, column, new_value, -1);
+ if (!current_value or std::strcmp(current_value, new_value) != 0)
+ gtk_tree_store_set(GTK_TREE_STORE(model), iter, column, new_value, -1);
- g_free(current_value);
- }
+ g_free(current_value);
+ }
- std::string format_rate(guint64 rate, guint64 max_rate, bool want_bits)
- {
- char* bytes = procman::format_size(rate, max_rate, want_bits);
- // xgettext: rate, 10MiB/s or 10Mbit/s
- std::string formatted_rate(make_string(g_strdup_printf(_("%s/s"), bytes)));
- g_free(bytes);
- return formatted_rate;
- }
+ std::string format_rate(guint64 rate, guint64 max_rate, bool want_bits)
+ {
+ char* bytes = procman::format_size(rate, max_rate, want_bits);
+ // xgettext: rate, 10MiB/s or 10Mbit/s
+ std::string formatted_rate(make_string(g_strdup_printf(_("%s/s"), bytes)));
+ g_free(bytes);
+ return formatted_rate;
+ }
- std::string format_network(guint64 rate, guint64 max_rate)
- {
- return procman::format_size(rate, max_rate, ProcData::get_instance()->config.network_in_bits);
- }
+ std::string format_network(guint64 rate, guint64 max_rate)
+ {
+ return procman::format_size(rate, max_rate, ProcData::get_instance()->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);
- }
+ std::string format_network_rate(guint64 rate, guint64 max_rate)
+ {
+ return procman::format_rate(rate, max_rate, ProcData::get_instance()->config.network_in_bits);
+ }
}
diff --git a/src/util.h b/src/util.h
index 89f0e61..7222be8 100644
--- a/src/util.h
+++ b/src/util.h
@@ -16,13 +16,13 @@ using std::string;
template<typename T>
inline int procman_cmp(T x, T y)
{
- if (x == y)
- return 0;
+ if (x == y)
+ return 0;
- if (x < y)
- return -1;
+ if (x < y)
+ return -1;
- return 1;
+ return 1;
}
#define PROCMAN_CMP(X, Y) procman_cmp((X), (Y))
@@ -30,8 +30,8 @@ inline int procman_cmp(T x, T y)
GtkWidget*
procman_make_label_for_mmaps_or_ofiles(const char *format,
- const char *process_name,
- unsigned pid);
+ const char *process_name,
+ unsigned pid);
gboolean
load_symbols(const char *module, ...) G_GNUC_NULL_TERMINATED;
@@ -39,20 +39,20 @@ load_symbols(const char *module, ...) G_GNUC_NULL_TERMINATED;
void
procman_debug_real(const char *file, int line, const char *func,
- const char *format, ...) G_GNUC_PRINTF(4, 5);
+ const char *format, ...) G_GNUC_PRINTF(4, 5);
#define procman_debug(FMT, ...) procman_debug_real(__FILE__, __LINE__, __func__, FMT, ##__VA_ARGS__)
inline string make_string(char *c_str)
{
- if (!c_str) {
- procman_debug("NULL string");
- return string();
- }
-
- string s(c_str);
- g_free(c_str);
- return s;
+ if (!c_str) {
+ procman_debug("NULL string");
+ return string();
+ }
+
+ string s(c_str);
+ g_free(c_str);
+ return s;
}
@@ -60,91 +60,91 @@ inline string make_string(char *c_str)
template<typename Map>
class UnrefMapValues
- : public std::unary_function<void, Map>
+ : public std::unary_function<void, Map>
{
public:
- void operator()(const typename Map::value_type &it) const
- {
- if (it.second)
- g_object_unref(it.second);
- }
+ void operator()(const typename Map::value_type &it) const
+ {
+ if (it.second)
+ g_object_unref(it.second);
+ }
};
template<typename Map>
inline void unref_map_values(Map &map)
{
- std::for_each(map.begin(), map.end(), UnrefMapValues<Map>());
+ std::for_each(map.begin(), map.end(), UnrefMapValues<Map>());
}
namespace procman
{
- void size_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data);
+ void size_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data);
- void size_na_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data);
+ void size_na_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data);
- void duration_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data);
+ void duration_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data);
- void time_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data);
+ void time_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data);
- void status_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
- GtkTreeModel *model, GtkTreeIter *iter,
- gpointer user_data);
+ void status_cell_data_func(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
+ GtkTreeModel *model, GtkTreeIter *iter,
+ gpointer user_data);
- template<typename T>
- void poison(T &t, char c)
- {
- memset(&t, c, sizeof t);
- }
+ template<typename T>
+ void poison(T &t, char c)
+ {
+ memset(&t, c, sizeof t);
+ }
- //
- // Stuff to update a tree_store in a smart way
- //
+ //
+ // Stuff to update a tree_store in a smart way
+ //
- template<typename T>
- void tree_store_update(GtkTreeModel* model, GtkTreeIter* iter, int column, const T& new_value)
- {
- T current_value;
+ template<typename T>
+ void tree_store_update(GtkTreeModel* model, GtkTreeIter* iter, int column, const T& new_value)
+ {
+ T current_value;
- gtk_tree_model_get(model, iter, column, ¤t_value, -1);
+ gtk_tree_model_get(model, iter, column, ¤t_value, -1);
- if (current_value != new_value)
- gtk_tree_store_set(GTK_TREE_STORE(model), iter, column, new_value, -1);
- }
+ if (current_value != new_value)
+ gtk_tree_store_set(GTK_TREE_STORE(model), iter, column, new_value, -1);
+ }
- // undefined
- // catch every thing about pointers
- // just to make sure i'm not doing anything wrong
- template<typename T>
- void tree_store_update(GtkTreeModel* model, GtkTreeIter* iter, int column, T* new_value);
+ // undefined
+ // catch every thing about pointers
+ // just to make sure i'm not doing anything wrong
+ template<typename T>
+ void tree_store_update(GtkTreeModel* model, GtkTreeIter* iter, int column, T* new_value);
- // specialized versions for strings
- template<>
- void tree_store_update<const char>(GtkTreeModel* model, GtkTreeIter* iter, int column, const char* new_value);
+ // specialized versions for strings
+ template<>
+ void tree_store_update<const char>(GtkTreeModel* model, GtkTreeIter* iter, int column, const char* new_value);
- template<>
- inline void tree_store_update<char>(GtkTreeModel* model, GtkTreeIter* iter, int column, char* new_value)
- {
- tree_store_update<const char>(model, iter, column, new_value);
- }
+ template<>
+ inline void tree_store_update<char>(GtkTreeModel* model, GtkTreeIter* iter, int column, char* new_value)
+ {
+ tree_store_update<const char>(model, iter, column, new_value);
+ }
- gchar* format_size(guint64 size, guint64 max = 0, bool want_bits = false);
+ gchar* format_size(guint64 size, guint64 max = 0, bool want_bits = false);
- std::string format_rate(guint64 rate, guint64 max_rate = 0, bool want_bits = false);
+ std::string format_rate(guint64 rate, guint64 max_rate = 0, bool want_bits = false);
- std::string format_network(guint64 rate, guint64 max_rate = 0);
- std::string format_network_rate(guint64 rate, guint64 max_rate = 0);
+ std::string format_network(guint64 rate, guint64 max_rate = 0);
+ std::string format_network_rate(guint64 rate, guint64 max_rate = 0);
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
