1 /* Procman
2  * Copyright (C) 2001 Kevin Vandersloot
3  * Copyright (C) 2012-2021 MATE Developers
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public
16  * License along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  */
20 
21 #include <config.h>
22 
23 #include <stdlib.h>
24 
25 #include <locale.h>
26 
27 #include <gtkmm.h>
28 #include <glib/gi18n.h>
29 
30 #include "procman-app.h"
31 #include "procman.h"
32 #include "proctable.h"
33 
ProcData()34 ProcData::ProcData()
35     : tree(NULL),
36       cpu_graph(NULL),
37       mem_graph(NULL),
38       net_graph(NULL),
39       selected_process(NULL),
40       timeout(0),
41       disk_timeout(0),
42       cpu_total_time(1),
43       cpu_total_time_last(1)
44 { }
45 
get_instance()46 ProcData* ProcData::get_instance()
47 {
48     static ProcData instance;
49     return &instance;
50 }
51 
52 gboolean
procman_get_tree_state(GSettings * settings,GtkWidget * tree,const gchar * child_schema)53 procman_get_tree_state (GSettings *settings, GtkWidget *tree, const gchar *child_schema)
54 {
55     GtkTreeModel *model;
56     GList *columns, *it;
57     gint sort_col;
58     GtkSortType order;
59 
60     g_assert(tree);
61     g_assert(child_schema);
62 
63     GSettings *pt_settings = g_settings_get_child (settings, child_schema);
64 
65     model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
66 
67     sort_col = g_settings_get_int (pt_settings, "sort-col");
68 
69     order = static_cast<GtkSortType>(g_settings_get_int (pt_settings, "sort-order"));
70 
71     if (sort_col != -1)
72         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
73                                               sort_col,
74                                               order);
75 
76     columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
77 
78     if (g_strcmp0(child_schema, "proctree") == 0 ||
79         g_strcmp0(child_schema, "disktreenew") == 0)
80     {
81         for (it = columns; it; it = it->next)
82         {
83             GtkTreeViewColumn *column;
84             gint width;
85             gboolean visible;
86             int id;
87             gchar *key;
88 
89             column = static_cast<GtkTreeViewColumn*>(it->data);
90             id = gtk_tree_view_column_get_sort_column_id (column);
91 
92             key = g_strdup_printf ("col-%d-width", id);
93             g_settings_get (pt_settings, key, "i", &width);
94             g_free (key);
95 
96             key = g_strdup_printf ("col-%d-visible", id);
97             visible = g_settings_get_boolean (pt_settings, key);
98             g_free (key);
99 
100             column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree), id);
101             if (column == NULL)
102                 continue;
103 
104             gtk_tree_view_column_set_visible (column, visible);
105             if (visible) {
106                 /* ensure column is really visible */
107                 width = MAX(width, 20);
108                 gtk_tree_view_column_set_fixed_width(column, width);
109             }
110         }
111 
112         GVariant     *value;
113         GVariantIter iter;
114         int          sortIndex;
115 
116         GSList *order = NULL;
117 
118         value = g_settings_get_value(pt_settings, "columns-order");
119         g_variant_iter_init(&iter, value);
120 
121         while (g_variant_iter_loop (&iter, "i", &sortIndex))
122             order = g_slist_append(order, GINT_TO_POINTER(sortIndex));
123 
124         proctable_set_columns_order(GTK_TREE_VIEW(tree), order);
125 
126         g_variant_unref(value);
127         g_slist_free(order);
128     }
129 
130     g_object_unref(pt_settings);
131     pt_settings = NULL;
132 
133     g_list_free(columns);
134 
135     return TRUE;
136 }
137 
138 void
procman_save_tree_state(GSettings * settings,GtkWidget * tree,const gchar * child_schema)139 procman_save_tree_state (GSettings *settings, GtkWidget *tree, const gchar *child_schema)
140 {
141     GtkTreeModel *model;
142     GList *columns;
143     gint sort_col;
144     GtkSortType order;
145 
146     if (ProcData::get_instance()->terminating)
147         return;
148 
149     g_assert(tree);
150     g_assert(child_schema);
151 
152     GSettings *pt_settings = g_settings_get_child (settings, child_schema);
153 
154     model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
155     if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model), &sort_col,
156                                               &order)) {
157         g_settings_set_int (pt_settings, "sort-col", sort_col);
158         g_settings_set_int (pt_settings, "sort-order", order);
159     }
160 
161     columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
162 
163     if (g_strcmp0(child_schema, "proctree") == 0 ||
164         g_strcmp0(child_schema, "disktreenew") == 0)
165     {
166         GSList *order;
167         GSList *order_node;
168         GVariantBuilder *builder;
169         GVariant *order_variant;
170 
171         order = proctable_get_columns_order(GTK_TREE_VIEW(tree));
172 
173         builder = g_variant_builder_new (G_VARIANT_TYPE ("ai"));
174 
175         for (order_node = order; order_node; order_node = order_node->next)
176             g_variant_builder_add(builder, "i", GPOINTER_TO_INT(order_node->data));
177 
178         order_variant = g_variant_new("ai", builder);
179         g_settings_set_value(pt_settings, "columns-order", order_variant);
180 
181         g_slist_free(order);
182     }
183 
184     g_list_free(columns);
185 }
186 
187 void
procman_save_config(ProcData * data)188 procman_save_config (ProcData *data)
189 {
190     GSettings *settings = data->settings;
191 
192     g_assert(data);
193 
194     data->config.maximized = gdk_window_get_state(gtk_widget_get_window (data->app)) & GDK_WINDOW_STATE_MAXIMIZED;
195     if (!data->config.maximized) {
196         // we only want to store/overwrite size and position info with non-maximized state info
197         data->config.width  = gdk_window_get_width (gtk_widget_get_window (data->app));
198         data->config.height = gdk_window_get_height(gtk_widget_get_window (data->app));
199 
200         gtk_window_get_position(GTK_WINDOW(data->app), &data->config.xpos, &data->config.ypos);
201 
202         g_settings_set (settings, "window-state", "(iiii)",
203                         data->config.width, data->config.height,
204                         data->config.xpos, data->config.ypos);
205     }
206     g_settings_set_boolean (settings, "maximized", data->config.maximized);
207 
208     g_settings_set_int (settings, "current-tab", data->config.current_tab);
209 }
210 
211 int
main(int argc,char * argv[])212 main (int argc, char *argv[])
213 {
214     bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
215     bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
216     textdomain (GETTEXT_PACKAGE);
217     setlocale (LC_ALL, "");
218 
219     Glib::RefPtr<ProcmanApp> application = ProcmanApp::create();
220     return application->run (argc, argv);
221 }
222