/* Procman * Copyright (C) 2001 Kevin Vandersloot * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "load-graph.h" #include "procman.h" #include "interface.h" #include "proctable.h" #include "prettytable.h" #include "callbacks.h" #include "smooth_refresh.h" #include "util.h" #include "mateconf-keys.h" #include "argv.h" ProcData::ProcData() : tree(NULL), cpu_graph(NULL), mem_graph(NULL), net_graph(NULL), selected_process(NULL), timeout(0), disk_timeout(0), cpu_total_time(1), cpu_total_time_last(1) { } ProcData* ProcData::get_instance() { static ProcData instance; return &instance; } static void tree_changed_cb (MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData *procdata = static_cast(data); MateConfValue *value = mateconf_entry_get_value (entry); procdata->config.show_tree = mateconf_value_get_bool (value); g_object_set(G_OBJECT(procdata->tree), "show-expanders", procdata->config.show_tree, NULL); proctable_clear_tree (procdata); proctable_update_all (procdata); } static void solaris_mode_changed_cb(MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData *procdata = static_cast(data); MateConfValue *value = mateconf_entry_get_value (entry); procdata->config.solaris_mode = mateconf_value_get_bool(value); proctable_update_all (procdata); } static void network_in_bits_changed_cb(MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData *procdata = static_cast(data); MateConfValue *value = mateconf_entry_get_value (entry); procdata->config.network_in_bits = mateconf_value_get_bool(value); // force scale to be redrawn procdata->net_graph->clear_background(); } static void view_as_changed_cb (MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData *procdata = static_cast(data); MateConfValue *value = mateconf_entry_get_value (entry); procdata->config.whose_process = mateconf_value_get_int (value); procdata->config.whose_process = CLAMP (procdata->config.whose_process, 0, 2); proctable_clear_tree (procdata); proctable_update_all (procdata); } static void warning_changed_cb (MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData *procdata = static_cast(data); const gchar *key = mateconf_entry_get_key (entry); MateConfValue *value = mateconf_entry_get_value (entry); if (g_str_equal (key, "/apps/procman/kill_dialog")) { procdata->config.show_kill_warning = mateconf_value_get_bool (value); } } static void timeouts_changed_cb (MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData *procdata = static_cast(data); const gchar *key = mateconf_entry_get_key (entry); MateConfValue *value = mateconf_entry_get_value (entry); if (g_str_equal (key, "/apps/procman/update_interval")) { procdata->config.update_interval = mateconf_value_get_int (value); 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, "/apps/procman/graph_update_interval")){ procdata->config.graph_update_interval = mateconf_value_get_int (value); 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, "/apps/procman/disks_interval")) { procdata->config.disks_update_interval = mateconf_value_get_int (value); 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 (MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData * const procdata = static_cast(data); const gchar *key = mateconf_entry_get_key (entry); MateConfValue *value = mateconf_entry_get_value (entry); const gchar *color = mateconf_value_get_string (value); if (g_str_has_prefix (key, "/apps/procman/cpu_color")) { for (int i = 0; i < GLIBTOP_NCPU; i++) { string cpu_key = make_string(g_strdup_printf("/apps/procman/cpu_color%d", i)); 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, "/apps/procman/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, "/apps/procman/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, "/apps/procman/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, "/apps/procman/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 (MateConfClient *client, guint id, MateConfEntry *entry, gpointer data) { ProcData * const procdata = static_cast(data); MateConfValue *value = mateconf_entry_get_value (entry); procdata->config.show_all_fs = mateconf_value_get_bool (value); cb_update_disks (data); } static ProcData * procman_data_new (MateConfClient *client) { ProcData *pd; gchar *color; gint swidth, sheight; gint i; glibtop_cpu cpu; pd = ProcData::get_instance(); pd->config.width = mateconf_client_get_int (client, "/apps/procman/width", NULL); pd->config.height = mateconf_client_get_int (client, "/apps/procman/height", NULL); pd->config.show_tree = mateconf_client_get_bool (client, "/apps/procman/show_tree", NULL); mateconf_client_notify_add (client, "/apps/procman/show_tree", tree_changed_cb, pd, NULL, NULL); pd->config.solaris_mode = mateconf_client_get_bool(client, procman::mateconf::solaris_mode.c_str(), NULL); mateconf_client_notify_add(client, procman::mateconf::solaris_mode.c_str(), solaris_mode_changed_cb, pd, NULL, NULL); pd->config.network_in_bits = mateconf_client_get_bool(client, procman::mateconf::network_in_bits.c_str(), NULL); mateconf_client_notify_add(client, procman::mateconf::network_in_bits.c_str(), network_in_bits_changed_cb, pd, NULL, NULL); pd->config.show_kill_warning = mateconf_client_get_bool (client, "/apps/procman/kill_dialog", NULL); mateconf_client_notify_add (client, "/apps/procman/kill_dialog", warning_changed_cb, pd, NULL, NULL); pd->config.update_interval = mateconf_client_get_int (client, "/apps/procman/update_interval", NULL); mateconf_client_notify_add (client, "/apps/procman/update_interval", timeouts_changed_cb, pd, NULL, NULL); pd->config.graph_update_interval = mateconf_client_get_int (client, "/apps/procman/graph_update_interval", NULL); mateconf_client_notify_add (client, "/apps/procman/graph_update_interval", timeouts_changed_cb, pd, NULL, NULL); pd->config.disks_update_interval = mateconf_client_get_int (client, "/apps/procman/disks_interval", NULL); mateconf_client_notify_add (client, "/apps/procman/disks_interval", timeouts_changed_cb, pd, NULL, NULL); /* /apps/procman/show_all_fs */ pd->config.show_all_fs = mateconf_client_get_bool ( client, "/apps/procman/show_all_fs", NULL); mateconf_client_notify_add (client, "/apps/procman/show_all_fs", show_all_fs_changed_cb, pd, NULL, NULL); pd->config.whose_process = mateconf_client_get_int (client, "/apps/procman/view_as", NULL); mateconf_client_notify_add (client, "/apps/procman/view_as", view_as_changed_cb, pd, NULL, NULL); pd->config.current_tab = mateconf_client_get_int (client, "/apps/procman/current_tab", NULL); for (int i = 0; i < GLIBTOP_NCPU; i++) { gchar *key; key = g_strdup_printf ("/apps/procman/cpu_color%d", i); color = mateconf_client_get_string (client, key, NULL); if (!color) color = g_strdup ("#f25915e815e8"); mateconf_client_notify_add (client, key, color_changed_cb, pd, NULL, NULL); gdk_color_parse(color, &pd->config.cpu_color[i]); g_free (color); g_free (key); } color = mateconf_client_get_string (client, "/apps/procman/mem_color", NULL); if (!color) color = g_strdup ("#000000ff0082"); mateconf_client_notify_add (client, "/apps/procman/mem_color", color_changed_cb, pd, NULL, NULL); gdk_color_parse(color, &pd->config.mem_color); g_free (color); color = mateconf_client_get_string (client, "/apps/procman/swap_color", NULL); if (!color) color = g_strdup ("#00b6000000ff"); mateconf_client_notify_add (client, "/apps/procman/swap_color", color_changed_cb, pd, NULL, NULL); gdk_color_parse(color, &pd->config.swap_color); g_free (color); color = mateconf_client_get_string (client, "/apps/procman/net_in_color", NULL); if (!color) color = g_strdup ("#000000f200f2"); mateconf_client_notify_add (client, "/apps/procman/net_in_color", color_changed_cb, pd, NULL, NULL); gdk_color_parse(color, &pd->config.net_in_color); g_free (color); color = mateconf_client_get_string (client, "/apps/procman/net_out_color", NULL); if (!color) color = g_strdup ("#00f2000000c1"); mateconf_client_notify_add (client, "/apps/procman/net_out_color", color_changed_cb, pd, NULL, NULL); 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); /* 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; // delayed initialization as SmoothRefresh() needs ProcData // i.e. we can't call ProcData::get_instance pd->smooth_refresh = new SmoothRefresh(); return pd; } static void procman_free_data (ProcData *procdata) { proctable_free_table (procdata); delete procdata->smooth_refresh; } gboolean procman_get_tree_state (MateConfClient *client, GtkWidget *tree, const gchar *prefix) { GtkTreeModel *model; GList *columns, *it; gint sort_col; GtkSortType order; gchar *key; g_assert(tree); g_assert(prefix); if (!mateconf_client_dir_exists (client, prefix, NULL)) return FALSE; model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree)); key = g_strdup_printf ("%s/sort_col", prefix); sort_col = mateconf_client_get_int (client, key, NULL); g_free (key); key = g_strdup_printf ("%s/sort_order", prefix); order = static_cast(mateconf_client_get_int (client, key, NULL)); g_free (key); 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)); for(it = columns; it; it = it->next) { GtkTreeViewColumn *column; MateConfValue *value = NULL; gint width; gboolean visible; int id; column = static_cast(it->data); id = gtk_tree_view_column_get_sort_column_id (column); key = g_strdup_printf ("%s/col_%d_width", prefix, id); value = mateconf_client_get (client, key, NULL); g_free (key); if (value != NULL) { width = mateconf_value_get_int(value); mateconf_value_free (value); key = g_strdup_printf ("%s/col_%d_visible", prefix, id); visible = mateconf_client_get_bool (client, key, NULL); 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_str_has_suffix(prefix, "proctree") || g_str_has_suffix(prefix, "disktreenew")) { GSList *order; char *key; key = g_strdup_printf("%s/columns_order", prefix); order = mateconf_client_get_list(client, key, MATECONF_VALUE_INT, NULL); proctable_set_columns_order(GTK_TREE_VIEW(tree), order); g_slist_free(order); g_free(key); } g_list_free(columns); return TRUE; } void procman_save_tree_state (MateConfClient *client, GtkWidget *tree, const gchar *prefix) { GtkTreeModel *model; GList *it, *columns; gint sort_col; GtkSortType order; g_assert(tree); g_assert(prefix); 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)) { gchar *key; key = g_strdup_printf ("%s/sort_col", prefix); mateconf_client_set_int (client, key, sort_col, NULL); g_free (key); key = g_strdup_printf ("%s/sort_order", prefix); mateconf_client_set_int (client, key, order, NULL); g_free (key); } columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree)); for(it = columns; it; it = it->next) { GtkTreeViewColumn *column; gboolean visible; gint width; gchar *key; int id; column = static_cast(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 ("%s/col_%d_width", prefix, id); mateconf_client_set_int (client, key, width, NULL); g_free (key); key = g_strdup_printf ("%s/col_%d_visible", prefix, id); mateconf_client_set_bool (client, key, visible, NULL); g_free (key); } if(g_str_has_suffix(prefix, "proctree") || g_str_has_suffix(prefix, "disktreenew")) { GSList *order; char *key; GError *error = NULL; key = g_strdup_printf("%s/columns_order", prefix); order = proctable_get_columns_order(GTK_TREE_VIEW(tree)); if(!mateconf_client_set_list(client, key, MATECONF_VALUE_INT, order, &error)) { g_critical("Could not save MateConf key '%s' : %s", key, error->message); g_error_free(error); } g_slist_free(order); g_free(key); } g_list_free(columns); } void procman_save_config (ProcData *data) { MateConfClient *client = data->client; g_assert(data); procman_save_tree_state (data->client, data->tree, "/apps/procman/proctree"); procman_save_tree_state (data->client, data->disk_list, "/apps/procman/disktreenew"); #if GTK_CHECK_VERSION(3, 0, 0) 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)); #else gint width, height; gdk_drawable_get_size(gtk_widget_get_window(data->app), &width, &height); data->config.width = width; data->config.height = height; #endif mateconf_client_set_int (client, "/apps/procman/width", data->config.width, NULL); mateconf_client_set_int (client, "/apps/procman/height", data->config.height, NULL); mateconf_client_set_int (client, "/apps/procman/current_tab", data->config.current_tab, NULL); mateconf_client_suggest_sync (client, NULL); } static guint32 get_startup_timestamp () { 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; startup_id = g_strdup (startup_id_env); time_str = g_strrstr (startup_id, "_TIME"); if (time_str == NULL) goto out; /* Skip past the "_TIME" part */ time_str += 5; retval = strtoul (time_str, NULL, 0); out: g_free (startup_id); return retval; } static void cb_server (const gchar *msg, gpointer user_data) { GdkWindow *window; ProcData *procdata; guint32 timestamp = 0; window = gdk_get_default_root_window (); 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); if (timestamp == 0) { /* fall back to rountripping to X */ timestamp = gdk_x11_get_server_time (window); } gdk_x11_window_set_user_time (window, timestamp); gtk_window_present (GTK_WINDOW(procdata->app)); } static void mount_changed(const Glib::RefPtr&) { cb_update_disks(ProcData::get_instance()); } static void init_volume_monitor(ProcData *procdata) { using namespace Gio; using namespace Glib; RefPtr 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)); } namespace procman { const std::string SHOW_SYSTEM_TAB_CMD("SHOWSYSTAB"); } int main (int argc, char *argv[]) { guint32 startup_timestamp; MateConfClient *client; ProcData *procdata; BaconMessageConnection *conn; bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); 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 ("mate-system-monitor"); if (!conn) g_error("Couldn't connect to mate-system-monitor"); if (bacon_message_connection_get_is_server (conn)) { bacon_message_connection_set_callback (conn, cb_server, &procdata); } else /* client */ { char *timestamp; timestamp = g_strdup_printf ("%" G_GUINT32_FORMAT, startup_timestamp); if (option_group.show_system_tab) bacon_message_connection_send(conn, procman::SHOW_SYSTEM_TAB_CMD.c_str()); bacon_message_connection_send (conn, timestamp); gdk_notify_startup_complete (); g_free (timestamp); bacon_message_connection_free (conn); exit (0); } gtk_window_set_default_icon_name ("utilities-system-monitor"); g_set_application_name(_("System Monitor")); mateconf_init (argc, argv, NULL); client = mateconf_client_get_default (); mateconf_client_add_dir(client, "/apps/procman", MATECONF_CLIENT_PRELOAD_NONE, NULL); glibtop_init (); procman_debug("end init"); procdata = procman_data_new (client); procdata->client = client; procman_debug("begin create_main_window"); create_main_window (procdata); procman_debug("end create_main_window"); // proctable_update_all (procdata); init_volume_monitor (procdata); 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); } gtk_widget_show(procdata->app); procman_debug("begin gtk_main"); kit.run(); procman_free_data (procdata); glibtop_close (); return 0; }