← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/gnome-system-monitor/oneiric-proposed

« back to all changes in this revision

Viewing changes to src/procdialogs.c

  • Committer: Bazaar Package Importer
  • Author(s): Loic Minier
  • Date: 2005-08-26 18:38:24 UTC
  • Revision ID: james.westby@ubuntu.com-20050826183824-zh2978nxikpkfxyd
Tags: upstream-2.8.1
Import upstream version 2.8.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/procdialogs.c
 
1
/* Procman - dialogs
 
2
 * Copyright (C) 2001 Kevin Vandersloot
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU General Public License
 
6
 * as published by the Free Software Foundation; either version 2
 
7
 * of the License, or (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Library General Public
 
15
 * License along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 
17
 *
 
18
 */
 
19
 
 
20
#ifdef HAVE_CONFIG_H
 
21
#  include <config.h>
 
22
#endif
 
23
 
 
24
#include <signal.h>
 
25
#include <string.h>
 
26
#include "procdialogs.h"
 
27
#include "favorites.h"
 
28
#include "proctable.h"
 
29
#include "callbacks.h"
 
30
#include "prettytable.h"
 
31
#include "procactions.h"
 
32
#include "util.h"
 
33
#include "load-graph.h"
 
34
 
 
35
static GtkWidget *renice_dialog = NULL;
 
36
static GtkWidget *prefs_dialog = NULL;
 
37
static gint new_nice_value = 0;
 
38
 
 
39
/* public */ int kill_signal = SIGTERM;
 
40
 
 
41
static void
 
42
cb_show_hide_message_toggled (GtkToggleButton *button, gpointer data)
 
43
{
 
44
        ProcData *procdata = data;
 
45
        GConfClient *client = procdata->client;
 
46
        gboolean toggle_state;
 
47
        
 
48
        toggle_state = gtk_toggle_button_get_active (button);
 
49
 
 
50
        gconf_client_set_bool (client, "/apps/procman/hide_message", toggle_state, NULL);
 
51
 
 
52
}
 
53
 
 
54
static void
 
55
hide_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
 
56
{
 
57
        ProcData *procdata = data;
 
58
        
 
59
        if (id == 100) {
 
60
                add_selected_to_blacklist (procdata);
 
61
        }
 
62
        
 
63
        gtk_widget_destroy (GTK_WIDGET (dialog));
 
64
                
 
65
}
 
66
 
 
67
void
 
68
procdialog_create_hide_dialog (ProcData *data)
 
69
{
 
70
        ProcData *procdata = data;
 
71
        GtkWidget *messagebox1;
 
72
        GtkWidget *dialog_vbox1, *vbox;
 
73
        GtkWidget *hbox, *hbox1;
 
74
        GtkWidget *dialog_action_area;
 
75
        GtkWidget *checkbutton1;
 
76
        GtkWidget *button;
 
77
        GtkWidget *image;
 
78
        GtkWidget *label;
 
79
        GtkWidget *align;
 
80
        GtkWidget *icon;
 
81
        const gchar *header  = _("Are you sure you want to hide this process?");
 
82
        const gchar *message = _("If you hide a process, you can unhide it by "
 
83
                                 "selecting 'Hidden Processes' in the Edit "
 
84
                                 "menu.");
 
85
        gchar *title;
 
86
                                        
 
87
        messagebox1 = gtk_dialog_new ();
 
88
        
 
89
        gtk_window_set_title (GTK_WINDOW (messagebox1), "");
 
90
        gtk_window_set_resizable (GTK_WINDOW (messagebox1), FALSE);
 
91
        gtk_window_set_modal (GTK_WINDOW (messagebox1), TRUE);
 
92
        
 
93
        gtk_dialog_set_has_separator (GTK_DIALOG (messagebox1), FALSE);
 
94
        gtk_container_set_border_width (GTK_CONTAINER (messagebox1), 5);
 
95
        
 
96
        dialog_vbox1 = GTK_DIALOG (messagebox1)->vbox;
 
97
        gtk_box_set_spacing (GTK_BOX (dialog_vbox1), 14);
 
98
 
 
99
        hbox = gtk_hbox_new (FALSE, 12);
 
100
        gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox, FALSE, FALSE, 0);
 
101
        gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
 
102
        gtk_widget_show (hbox);
 
103
 
 
104
        image = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG);
 
105
        gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
 
106
        gtk_widget_show (image);
 
107
        
 
108
        vbox = gtk_vbox_new (FALSE, 12);
 
109
        gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
 
110
        gtk_widget_show (vbox);
 
111
        
 
112
        title = g_strdup_printf("<b>%s</b>", header);
 
113
        label = gtk_label_new (title);  
 
114
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
115
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
 
116
        gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 
117
        gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 
118
        gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
 
119
        gtk_widget_show (label);
 
120
        g_free (title);
 
121
        
 
122
        label = gtk_label_new (_(message));
 
123
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
124
        gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 
125
        gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 
126
        gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
 
127
        gtk_widget_show (label);
 
128
        
 
129
        dialog_action_area = GTK_DIALOG (messagebox1)->action_area;
 
130
        gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area), GTK_BUTTONBOX_END);
 
131
 
 
132
        button = gtk_button_new_from_stock ("gtk-cancel");
 
133
        gtk_widget_show (button);
 
134
        gtk_dialog_add_action_widget (GTK_DIALOG (messagebox1), button, GTK_RESPONSE_CANCEL);
 
135
        GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 
136
 
 
137
        hbox1 = gtk_hbox_new (FALSE, 0);
 
138
        gtk_widget_show (hbox1);
 
139
        gtk_box_pack_end (GTK_BOX (vbox), hbox1, TRUE, TRUE, 0);
 
140
 
 
141
        checkbutton1 = gtk_check_button_new_with_mnemonic (_("_Show this dialog next time"));
 
142
        gtk_widget_show (checkbutton1);
 
143
        gtk_box_pack_end (GTK_BOX (hbox1), checkbutton1, FALSE, FALSE, 0);
 
144
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), TRUE);
 
145
 
 
146
        button = gtk_button_new ();
 
147
        GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 
148
                
 
149
        align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 
150
        gtk_container_add (GTK_CONTAINER (button), align);
 
151
                
 
152
        hbox = gtk_hbox_new (FALSE, 2);
 
153
        gtk_container_add (GTK_CONTAINER (align), hbox);
 
154
 
 
155
        icon = gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON);
 
156
        gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
 
157
        
 
158
        label = gtk_label_new_with_mnemonic (_("_Hide Process"));
 
159
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), button);
 
160
        gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
161
 
 
162
        gtk_dialog_add_action_widget (GTK_DIALOG (messagebox1), button, 100);
 
163
        gtk_dialog_set_default_response (GTK_DIALOG (messagebox1), 100);
 
164
        
 
165
        g_signal_connect (G_OBJECT (checkbutton1), "toggled",
 
166
                          G_CALLBACK (cb_show_hide_message_toggled), procdata);
 
167
        g_signal_connect (G_OBJECT (messagebox1), "response",
 
168
                          G_CALLBACK (hide_dialog_button_pressed), procdata);
 
169
        
 
170
        gtk_widget_show_all (messagebox1);
 
171
 
 
172
}
 
173
 
 
174
static void
 
175
cb_show_kill_warning_toggled (GtkToggleButton *button, gpointer data)
 
176
{
 
177
        ProcData *procdata = data;
 
178
        GConfClient *client = procdata->client;
 
179
        gboolean toggle_state;
 
180
        
 
181
        toggle_state = gtk_toggle_button_get_active (button);
 
182
        
 
183
        gconf_client_set_bool (client, "/apps/procman/kill_dialog", toggle_state, NULL);        
 
184
 
 
185
}
 
186
 
 
187
static void
 
188
kill_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
 
189
{
 
190
        ProcData *procdata = data;
 
191
        
 
192
        gtk_widget_destroy (GTK_WIDGET (dialog));
 
193
 
 
194
        if (id == 100) 
 
195
                kill_process (procdata, kill_signal);           
 
196
}
 
197
 
 
198
void
 
199
procdialog_create_kill_dialog (ProcData *data, int signal)
 
200
{
 
201
        ProcData *procdata = data;
 
202
        GtkWidget *messagebox1;
 
203
        GtkWidget *dialog_vbox1, *vbox;
 
204
        GtkWidget *hbox1, *hbox2;
 
205
        GtkWidget *checkbutton1;
 
206
        GtkWidget *dialog_action_area;
 
207
        GtkWidget *button;
 
208
        GtkWidget *align;
 
209
        GtkWidget *label;
 
210
        GtkWidget *icon;
 
211
        GtkWidget *image;
 
212
        gchar *text, *title;
 
213
        gchar *header, *message;
 
214
        
 
215
        kill_signal = signal;
 
216
        
 
217
        if (signal == SIGKILL) {
 
218
                header = _("Are you sure you want to kill this process?");
 
219
                message = _("If you kill a process, unsaved data will be lost.");
 
220
                text = _("_Kill Process");
 
221
                        }
 
222
        else {
 
223
                header = _("Are you sure you want to end this process?");
 
224
                message = _("If you end a process, unsaved data will be lost.");
 
225
                text = _("_End Process");
 
226
        }
 
227
 
 
228
        messagebox1 = gtk_dialog_new ();
 
229
        
 
230
        gtk_window_set_title (GTK_WINDOW (messagebox1), "");
 
231
        gtk_window_set_modal (GTK_WINDOW (messagebox1), TRUE);
 
232
        gtk_window_set_resizable (GTK_WINDOW (messagebox1), FALSE);
 
233
  
 
234
        gtk_dialog_set_has_separator (GTK_DIALOG (messagebox1), FALSE);
 
235
        gtk_container_set_border_width (GTK_CONTAINER (messagebox1), 5);
 
236
        
 
237
        dialog_vbox1 = GTK_DIALOG (messagebox1)->vbox;
 
238
        gtk_box_set_spacing (GTK_BOX (dialog_vbox1), 14);
 
239
        
 
240
        hbox1 = gtk_hbox_new (FALSE, 12);
 
241
        gtk_box_pack_start (GTK_BOX (dialog_vbox1), hbox1, FALSE, FALSE, 0);
 
242
        gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
 
243
        gtk_widget_show (hbox1);
 
244
 
 
245
        image = gtk_image_new_from_stock ("gtk-dialog-warning", GTK_ICON_SIZE_DIALOG);
 
246
        gtk_box_pack_start (GTK_BOX (hbox1), image, FALSE, FALSE, 0);
 
247
        gtk_widget_show (image);
 
248
        
 
249
        vbox = gtk_vbox_new (FALSE, 12);
 
250
        gtk_box_pack_start (GTK_BOX (hbox1), vbox, TRUE, TRUE, 0);
 
251
        gtk_widget_show (vbox);
 
252
        
 
253
        title = g_strconcat ("<b>", _(header), "</b>", NULL);
 
254
        label = gtk_label_new (title);  
 
255
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
256
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
 
257
        gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 
258
        gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 
259
        gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
 
260
        gtk_widget_show (label);
 
261
        g_free (title);
 
262
        
 
263
        label = gtk_label_new (_(message));
 
264
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
265
        gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 
266
        gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 
267
        gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
 
268
        gtk_widget_show (label);
 
269
        
 
270
        dialog_action_area = GTK_DIALOG (messagebox1)->action_area;
 
271
        gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area), GTK_BUTTONBOX_END);
 
272
 
 
273
        button = gtk_button_new_from_stock ("gtk-cancel");
 
274
        gtk_widget_show (button);
 
275
        gtk_dialog_add_action_widget (GTK_DIALOG (messagebox1), button, GTK_RESPONSE_CANCEL);
 
276
        GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 
277
 
 
278
        hbox2 = gtk_hbox_new (FALSE, 0);
 
279
        gtk_widget_show (hbox2);
 
280
        gtk_box_pack_end (GTK_BOX (vbox), hbox2, TRUE, TRUE, 0);
 
281
 
 
282
        checkbutton1 = gtk_check_button_new_with_mnemonic (_("_Show this dialog next time"));
 
283
        gtk_widget_show (checkbutton1);
 
284
        gtk_box_pack_end (GTK_BOX (hbox2), checkbutton1, FALSE, FALSE, 0);
 
285
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton1), TRUE);
 
286
 
 
287
        button = gtk_button_new ();
 
288
        GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 
289
                
 
290
        align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 
291
        gtk_container_add (GTK_CONTAINER (button), align);
 
292
                
 
293
        hbox1 = gtk_hbox_new (FALSE, 2);
 
294
        gtk_container_add (GTK_CONTAINER (align), hbox1);
 
295
 
 
296
        icon = gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON);
 
297
        gtk_box_pack_start (GTK_BOX (hbox1), icon, FALSE, FALSE, 0);
 
298
 
 
299
        label = gtk_label_new_with_mnemonic (_(text));
 
300
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), button);
 
301
        gtk_box_pack_end (GTK_BOX (hbox1), label, FALSE, FALSE, 0);
 
302
 
 
303
        gtk_dialog_add_action_widget (GTK_DIALOG (messagebox1), button, 100);
 
304
        gtk_dialog_set_default_response (GTK_DIALOG (messagebox1), 100);        
 
305
                                            
 
306
        g_signal_connect (G_OBJECT (checkbutton1), "toggled",
 
307
                          G_CALLBACK (cb_show_kill_warning_toggled),
 
308
                          procdata);
 
309
        g_signal_connect (G_OBJECT (messagebox1), "response",
 
310
                          G_CALLBACK (kill_dialog_button_pressed), procdata);
 
311
        
 
312
        gtk_widget_show_all (messagebox1);
 
313
        
 
314
        
 
315
}
 
316
 
 
317
static gchar *
 
318
get_nice_level (gint nice)
 
319
{
 
320
        if (nice < -7)
 
321
                return _("(Very High Priority)");
 
322
        else if (nice < -2)
 
323
                return _("(High Priority)");
 
324
        else if (nice < 3)
 
325
                return _("(Normal Priority)");
 
326
        else if (nice < 7)
 
327
                return _("(Low Priority)");
 
328
        else
 
329
                return _("(Very Low Priority)");
 
330
}
 
331
 
 
332
static void
 
333
renice_scale_changed (GtkAdjustment *adj, gpointer data)
 
334
{
 
335
        GtkWidget *label = GTK_WIDGET (data);
 
336
        
 
337
        new_nice_value = adj->value;
 
338
        gtk_label_set_text (GTK_LABEL (label), get_nice_level (new_nice_value));                
 
339
        
 
340
}
 
341
 
 
342
static void
 
343
renice_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
 
344
{
 
345
        ProcData *procdata = data;
 
346
        
 
347
        if (id == 100) {
 
348
                if (new_nice_value == -100)
 
349
                        return;         
 
350
                renice (procdata, -2, new_nice_value);
 
351
        }
 
352
        
 
353
        gtk_widget_destroy (GTK_WIDGET (dialog));
 
354
        renice_dialog = NULL;
 
355
}
 
356
 
 
357
void
 
358
procdialog_create_renice_dialog (ProcData *data)
 
359
{
 
360
        ProcData *procdata = data;
 
361
        ProcInfo *info = procdata->selected_process;
 
362
        GtkWidget *dialog = NULL;
 
363
        GtkWidget *dialog_vbox;
 
364
        GtkWidget *vbox;
 
365
        GtkWidget *hbox;
 
366
        GtkWidget *label;
 
367
        GtkWidget *priority_label;
 
368
        GtkWidget *table;
 
369
        GtkObject *renice_adj;
 
370
        GtkWidget *hscale;
 
371
        GtkWidget *button;
 
372
        GtkWidget *align;
 
373
        GtkWidget *icon;
 
374
        gchar *text;
 
375
 
 
376
        if (renice_dialog)
 
377
                return;
 
378
                
 
379
        if (!info)
 
380
                return;
 
381
                
 
382
        dialog = gtk_dialog_new_with_buttons (_("Change Priority"), NULL,
 
383
                                              GTK_DIALOG_DESTROY_WITH_PARENT,
 
384
                                              GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 
385
                                              NULL);
 
386
        renice_dialog = dialog;
 
387
        gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE);
 
388
        gtk_dialog_set_has_separator (GTK_DIALOG (renice_dialog), FALSE);
 
389
        gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5);
 
390
        
 
391
        button = gtk_button_new ();
 
392
        GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 
393
                
 
394
        align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
 
395
        gtk_container_add (GTK_CONTAINER (button), align);
 
396
                
 
397
        hbox = gtk_hbox_new (FALSE, 2);
 
398
        gtk_container_add (GTK_CONTAINER (align), hbox);
 
399
 
 
400
        icon = gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON);
 
401
        gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
 
402
 
 
403
        label = gtk_label_new_with_mnemonic (_("Change _Priority"));
 
404
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), button);
 
405
        gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
406
 
 
407
        gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100);
 
408
        gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
 
409
        new_nice_value = -100;
 
410
          
 
411
        dialog_vbox = GTK_DIALOG (dialog)->vbox;
 
412
        gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
 
413
        gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
 
414
                
 
415
        vbox = gtk_vbox_new (FALSE, 12);
 
416
        gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0);
 
417
        gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
 
418
        
 
419
        table = gtk_table_new (2, 2, FALSE);
 
420
        gtk_table_set_col_spacings (GTK_TABLE(table), 12);
 
421
        gtk_table_set_row_spacings (GTK_TABLE(table), 6);
 
422
        gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
 
423
        
 
424
        label = gtk_label_new_with_mnemonic (_("_Nice value:"));
 
425
        gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 2,
 
426
                          0, 0, 0, 0);
 
427
        
 
428
        renice_adj = gtk_adjustment_new (info->nice, -20, 20, 1, 1, 0);
 
429
        new_nice_value = 0;
 
430
        hscale = gtk_hscale_new (GTK_ADJUSTMENT (renice_adj));
 
431
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale);
 
432
        gtk_scale_set_digits (GTK_SCALE (hscale), 0);
 
433
        gtk_table_attach (GTK_TABLE (table), hscale, 1, 2, 0, 1,
 
434
                          GTK_EXPAND | GTK_FILL, 0, 0, 0);
 
435
                          
 
436
        priority_label = gtk_label_new (get_nice_level (info->nice));
 
437
        gtk_table_attach (GTK_TABLE (table), priority_label, 1, 2, 1, 2,
 
438
                          GTK_FILL, 0, 0, 0);
 
439
        
 
440
        text = g_strconcat("<small><i><b>", _("Note:"), "</b> ", 
 
441
            _("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."),
 
442
            "</i></small>", NULL); 
 
443
        label = gtk_label_new (_(text));
 
444
        gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 
445
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
 
446
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
447
        g_free (text);
 
448
        
 
449
        g_signal_connect (G_OBJECT (dialog), "response",
 
450
                          G_CALLBACK (renice_dialog_button_pressed), procdata);
 
451
        g_signal_connect (G_OBJECT (renice_adj), "value_changed",
 
452
                            G_CALLBACK (renice_scale_changed), priority_label);
 
453
        
 
454
        gtk_widget_show_all (dialog);
 
455
        
 
456
        
 
457
}
 
458
 
 
459
static void
 
460
prefs_dialog_button_pressed (GtkDialog *dialog, gint id, gpointer data)
 
461
{
 
462
        gtk_widget_destroy (GTK_WIDGET (dialog));
 
463
        
 
464
        prefs_dialog = NULL;
 
465
}
 
466
 
 
467
static void
 
468
show_tree_toggled (GtkToggleButton *button, gpointer data)
 
469
{
 
470
        ProcData *procdata = data;
 
471
        GConfClient *client = procdata->client;
 
472
        gboolean toggled;
 
473
        
 
474
        toggled = gtk_toggle_button_get_active (button);
 
475
        gconf_client_set_bool (client, "/apps/procman/show_tree", toggled, NULL);
 
476
 
 
477
}
 
478
 
 
479
static void
 
480
show_threads_toggled (GtkToggleButton *button, gpointer data)
 
481
{
 
482
        ProcData *procdata = data;
 
483
        GConfClient *client = procdata->client;
 
484
        
 
485
        gboolean toggled;
 
486
        
 
487
        toggled = gtk_toggle_button_get_active (button);
 
488
        
 
489
        gconf_client_set_bool (client, "/apps/procman/show_threads", toggled, NULL);
 
490
                
 
491
}
 
492
 
 
493
static void
 
494
show_kill_dialog_toggled (GtkToggleButton *button, gpointer data)
 
495
{
 
496
        ProcData *procdata = data;
 
497
        GConfClient *client = procdata->client;
 
498
        
 
499
        gboolean toggled;
 
500
        
 
501
        toggled = gtk_toggle_button_get_active (button);
 
502
        
 
503
        gconf_client_set_bool (client, "/apps/procman/kill_dialog", toggled, NULL);
 
504
                
 
505
}
 
506
 
 
507
static void
 
508
show_hide_dialog_toggled (GtkToggleButton *button, gpointer data)
 
509
{
 
510
        ProcData *procdata = data;
 
511
        GConfClient *client = procdata->client;
 
512
        
 
513
        gboolean toggled;
 
514
        
 
515
        toggled = gtk_toggle_button_get_active (button);
 
516
        
 
517
        gconf_client_set_bool (client, "/apps/procman/hide_message", toggled, NULL);
 
518
                
 
519
}
 
520
 
 
521
static gboolean
 
522
update_update_interval (GtkWidget *widget, GdkEventFocus *event, gpointer data)
 
523
{
 
524
        ProcData *procdata = data;
 
525
        GConfClient *client = procdata->client;
 
526
        GtkWidget *spin_button;
 
527
        gdouble value;
 
528
        
 
529
        spin_button = widget;
 
530
        value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin_button));
 
531
        
 
532
        if (1000 * value == procdata->config.update_interval)
 
533
                return FALSE;
 
534
                
 
535
        gconf_client_set_int (client, "/apps/procman/update_interval", value * 1000, NULL);
 
536
        return FALSE;
 
537
}
 
538
 
 
539
static gboolean
 
540
update_graph_update_interval (GtkWidget *widget, GdkEventFocus *event, gpointer data)
 
541
{
 
542
        ProcData *procdata = data;
 
543
        GConfClient *client = procdata->client;
 
544
        GtkWidget *spin_button;
 
545
        gdouble value = 0;
 
546
 
 
547
        spin_button = widget;
 
548
        value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin_button));
 
549
        
 
550
        if (1000 * value == procdata->config.graph_update_interval)
 
551
                return FALSE;
 
552
 
 
553
        gconf_client_set_int (client, "/apps/procman/graph_update_interval", value * 1000, NULL);
 
554
        return FALSE;
 
555
}
 
556
 
 
557
static gboolean
 
558
update_disks_update_interval (GtkWidget *widget, GdkEventFocus *event, gpointer data)
 
559
{
 
560
        ProcData *procdata = data;
 
561
        GConfClient *client = procdata->client;
 
562
        GtkWidget *spin_button;
 
563
        gdouble value;
 
564
 
 
565
        spin_button = widget;
 
566
        value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin_button));
 
567
        
 
568
        if (1000 * value == procdata->config.disks_update_interval)
 
569
                return FALSE;
 
570
                
 
571
        gconf_client_set_int (client, "/apps/procman/disks_interval", value * 1000, NULL);
 
572
        return FALSE;
 
573
}
 
574
 
 
575
 
 
576
static void
 
577
proc_field_toggled (GtkToggleButton *button, gpointer data)
 
578
{
 
579
        GtkTreeViewColumn *column = data;
 
580
        gboolean toggled;
 
581
        
 
582
        toggled = gtk_toggle_button_get_active (button);
 
583
 
 
584
        gtk_tree_view_column_set_visible (column, toggled);
 
585
        
 
586
}
 
587
 
 
588
static void
 
589
field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
 
590
{
 
591
        GtkTreeModel *model = data;
 
592
        GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
 
593
        GtkTreeIter iter;
 
594
        GtkTreeViewColumn *column;
 
595
        gboolean toggled;
 
596
        
 
597
        if (!path)
 
598
                return;
 
599
        
 
600
        gtk_tree_model_get_iter (model, &iter, path);
 
601
        
 
602
        gtk_tree_model_get (model, &iter, 2, &column, -1);
 
603
        toggled = gtk_cell_renderer_toggle_get_active (cell);
 
604
        
 
605
        gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1);
 
606
        gtk_tree_view_column_set_visible (column, !toggled);
 
607
        
 
608
        gtk_tree_path_free (path);
 
609
 
 
610
}
 
611
 
 
612
static GtkWidget *
 
613
create_proc_field_page (ProcData *procdata)
 
614
{
 
615
        GtkWidget *vbox;
 
616
        GtkWidget *scrolled;
 
617
        GtkWidget *tree = procdata->tree, *treeview;
 
618
        GList *columns = NULL;
 
619
        GtkListStore *model;
 
620
        GtkTreeViewColumn *column;
 
621
        GtkCellRenderer *cell;
 
622
 
 
623
        vbox = gtk_vbox_new (FALSE, 6);
 
624
        
 
625
        scrolled = gtk_scrolled_window_new (NULL, NULL);
 
626
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
 
627
                                        GTK_POLICY_AUTOMATIC,
 
628
                                        GTK_POLICY_AUTOMATIC);
 
629
        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
 
630
        gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
 
631
        
 
632
        model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);  
 
633
        
 
634
        treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
 
635
        gtk_container_add (GTK_CONTAINER (scrolled), treeview);
 
636
        g_object_unref (G_OBJECT (model));
 
637
        
 
638
        column = gtk_tree_view_column_new ();
 
639
        
 
640
        cell = gtk_cell_renderer_toggle_new ();
 
641
        gtk_tree_view_column_pack_start (column, cell, FALSE);
 
642
        gtk_tree_view_column_set_attributes (column, cell,
 
643
                                                               "active", 0,
 
644
                                                               NULL);
 
645
        g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (field_toggled), model);
 
646
        gtk_tree_view_column_set_clickable (column, TRUE);
 
647
        gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
 
648
        
 
649
        column = gtk_tree_view_column_new ();
 
650
        
 
651
        cell = gtk_cell_renderer_text_new ();
 
652
        gtk_tree_view_column_pack_start (column, cell, FALSE);
 
653
        gtk_tree_view_column_set_attributes (column, cell,
 
654
                                                               "text", 1,
 
655
                                                                NULL);
 
656
                                                                
 
657
        gtk_tree_view_column_set_title (column, "Not Shown");
 
658
        gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
 
659
        gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
 
660
        
 
661
        columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
 
662
        
 
663
        while (columns) {
 
664
                GtkTreeViewColumn *column = columns->data;
 
665
                GtkTreeIter iter;
 
666
                const gchar *title;
 
667
                gboolean visible;
 
668
                
 
669
                title = gtk_tree_view_column_get_title (column);
 
670
                if (!title) 
 
671
                        title = _("Icon");
 
672
                
 
673
                visible = gtk_tree_view_column_get_visible (column);
 
674
                
 
675
                gtk_list_store_append (model, &iter);
 
676
                gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
 
677
                            
 
678
                
 
679
                columns = g_list_next (columns);
 
680
        }
 
681
                
 
682
 
 
683
        return vbox;
 
684
}
 
685
 
 
686
void
 
687
procdialog_create_preferences_dialog (ProcData *procdata)
 
688
{
 
689
        static GtkWidget *dialog = NULL;
 
690
        GtkWidget *notebook;
 
691
        GtkWidget *proc_box;
 
692
        GtkWidget *sys_box;
 
693
        GtkWidget *main_vbox;
 
694
        GtkWidget *vbox, *vbox2;
 
695
        GtkWidget *hbox, *hbox2, *hbox3;
 
696
        GtkWidget *label;
 
697
        GtkAdjustment *adjustment;
 
698
        GtkWidget *spin_button;
 
699
        GtkWidget *check_button;
 
700
        GtkWidget *tab_label;
 
701
        GtkWidget *color_picker;
 
702
        GtkSizeGroup *size;
 
703
        gfloat update;
 
704
        gchar *tmp;
 
705
        
 
706
        if (prefs_dialog)
 
707
                return;
 
708
                
 
709
        size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
 
710
        
 
711
        dialog = gtk_dialog_new_with_buttons (_("Preferences"), NULL,
 
712
                                              GTK_DIALOG_DESTROY_WITH_PARENT,
 
713
                                              GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
 
714
                                              NULL);
 
715
        gtk_window_set_default_size (GTK_WINDOW (dialog), 400,  375);
 
716
        gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
 
717
        gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
 
718
        prefs_dialog = dialog;
 
719
        
 
720
        main_vbox = GTK_DIALOG (dialog)->vbox;
 
721
        gtk_box_set_spacing (GTK_BOX (main_vbox), 2);
 
722
        
 
723
        notebook = gtk_notebook_new ();
 
724
        gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
 
725
        gtk_box_pack_start (GTK_BOX (main_vbox), notebook, TRUE, TRUE, 0);
 
726
        
 
727
        proc_box = gtk_vbox_new (FALSE, 18);
 
728
        gtk_container_set_border_width (GTK_CONTAINER (proc_box), 12);
 
729
        tab_label = gtk_label_new (_("Process Listing"));
 
730
        gtk_widget_show (tab_label);
 
731
        gtk_notebook_append_page (GTK_NOTEBOOK (notebook), proc_box, tab_label);
 
732
        
 
733
        vbox = gtk_vbox_new (FALSE, 6);
 
734
        gtk_box_pack_start (GTK_BOX (proc_box), vbox, FALSE, FALSE, 0);
 
735
        
 
736
        tmp = g_strdup_printf ("<b>%s</b>", _("Behavior"));
 
737
        label = gtk_label_new (NULL);
 
738
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
739
        gtk_label_set_markup (GTK_LABEL (label), tmp);
 
740
        g_free (tmp);
 
741
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
742
        
 
743
        hbox = gtk_hbox_new (FALSE, 0);
 
744
        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
745
        
 
746
        label = gtk_label_new ("    ");
 
747
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
748
        
 
749
        vbox2 = gtk_vbox_new (FALSE, 6);
 
750
        gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
 
751
                          
 
752
        hbox2 = gtk_hbox_new (FALSE, 12);
 
753
        gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
 
754
        
 
755
        label = gtk_label_new_with_mnemonic (_("_Update interval:"));
 
756
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
757
        gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 
758
        
 
759
        hbox3 = gtk_hbox_new (FALSE, 6);
 
760
        gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
 
761
        
 
762
        update = (gfloat) procdata->config.update_interval;
 
763
        adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 1.0, 
 
764
                                                          100.0, 0.25, 1.0, 1.0);
 
765
        spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
 
766
        gtk_box_pack_start (GTK_BOX (hbox3), spin_button, TRUE, TRUE, 0);
 
767
        g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
 
768
                                   G_CALLBACK (update_update_interval), procdata);
 
769
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
 
770
        
 
771
        label = gtk_label_new_with_mnemonic (_("seconds"));
 
772
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
773
        gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0);
 
774
        
 
775
        hbox2 = gtk_hbox_new (FALSE, 6);
 
776
        gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
 
777
                
 
778
        check_button = gtk_check_button_new_with_mnemonic (_("Show warning dialog when ending or _killing processes"));
 
779
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), 
 
780
                                      procdata->config.show_kill_warning);
 
781
        g_signal_connect (G_OBJECT (check_button), "toggled",
 
782
                            G_CALLBACK (show_kill_dialog_toggled), procdata);
 
783
        gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
 
784
        
 
785
        hbox2 = gtk_hbox_new (FALSE, 6);
 
786
        gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
 
787
        
 
788
        check_button = gtk_check_button_new_with_mnemonic (_("Show warning dialog when _hiding processes"));
 
789
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), 
 
790
                                    procdata->config.show_hide_message);
 
791
        g_signal_connect (G_OBJECT (check_button), "toggled",
 
792
                            G_CALLBACK (show_hide_dialog_toggled), procdata);
 
793
        gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
 
794
        
 
795
        vbox = gtk_vbox_new (FALSE, 6);
 
796
        gtk_box_pack_start (GTK_BOX (proc_box), vbox, TRUE, TRUE, 0);
 
797
        
 
798
        tmp = g_strdup_printf ("<b>%s</b>", _("Process Fields"));
 
799
        label = gtk_label_new (NULL);
 
800
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
801
        gtk_label_set_markup (GTK_LABEL (label), tmp);
 
802
        g_free (tmp);
 
803
        gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
 
804
        
 
805
        hbox = gtk_hbox_new (FALSE, 0);
 
806
        gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 
807
        
 
808
        label = gtk_label_new ("    ");
 
809
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
810
        
 
811
        vbox2 = create_proc_field_page (procdata);
 
812
        gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
 
813
        
 
814
        sys_box = gtk_vbox_new (FALSE, 12);
 
815
        gtk_container_set_border_width (GTK_CONTAINER (sys_box), 12);
 
816
        tab_label = gtk_label_new (_("Resource Monitor"));
 
817
        gtk_widget_show (tab_label);
 
818
        gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label);
 
819
        
 
820
        vbox = gtk_vbox_new (FALSE, 6);
 
821
        gtk_box_pack_start (GTK_BOX (sys_box), vbox, FALSE, FALSE, 0);
 
822
        
 
823
        tmp = g_strdup_printf ("<b>%s</b>", _("Graphs"));
 
824
        label = gtk_label_new (NULL);
 
825
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
826
        gtk_label_set_markup (GTK_LABEL (label), tmp);
 
827
        g_free (tmp);
 
828
        gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
 
829
        
 
830
        hbox = gtk_hbox_new (FALSE, 0);
 
831
        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
832
        
 
833
        label = gtk_label_new ("    ");
 
834
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
835
        
 
836
        vbox2 = gtk_vbox_new (FALSE, 6);
 
837
        gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
 
838
        
 
839
        hbox2 = gtk_hbox_new (FALSE, 12);
 
840
        gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
 
841
                
 
842
        label = gtk_label_new_with_mnemonic (_("_Update interval:"));
 
843
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
844
        gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 
845
        gtk_size_group_add_widget (size, label);
 
846
        
 
847
        hbox3 = gtk_hbox_new (FALSE, 6);
 
848
        gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
 
849
                          
 
850
        update = (gfloat) procdata->config.graph_update_interval;
 
851
        adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25, 
 
852
                                                          100.0, 0.25, 1.0, 1.0);
 
853
        spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
 
854
        g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
 
855
                                   G_CALLBACK (update_graph_update_interval), procdata);
 
856
        gtk_box_pack_start (GTK_BOX (hbox3), spin_button, TRUE, TRUE, 0);
 
857
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
 
858
        
 
859
        label = gtk_label_new_with_mnemonic (_("seconds"));
 
860
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
861
        gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0);
 
862
        
 
863
        hbox2 = gtk_hbox_new (FALSE, 12);
 
864
        gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
 
865
        
 
866
        label = gtk_label_new_with_mnemonic (_("_Background color:"));
 
867
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
868
        gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 
869
        gtk_size_group_add_widget (size, label);
 
870
        
 
871
        color_picker = gnome_color_picker_new ();
 
872
        gnome_color_picker_set_i16 (GNOME_COLOR_PICKER (color_picker), 
 
873
                                    procdata->config.bg_color.red,
 
874
                                    procdata->config.bg_color.green,
 
875
                                    procdata->config.bg_color.blue, 0);
 
876
        g_signal_connect (G_OBJECT (color_picker), "color_set",
 
877
                                  G_CALLBACK (cb_bg_color_changed), procdata);
 
878
        gtk_box_pack_start (GTK_BOX (hbox2), color_picker,TRUE, TRUE, 0);
 
879
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), color_picker);
 
880
        gtk_widget_show (color_picker);
 
881
                
 
882
        hbox2 = gtk_hbox_new (FALSE, 12);
 
883
        gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
 
884
          
 
885
        label = gtk_label_new_with_mnemonic (_("_Grid color:"));
 
886
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
887
        gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 
888
        gtk_size_group_add_widget (size, label);
 
889
        
 
890
        color_picker = gnome_color_picker_new ();
 
891
        gnome_color_picker_set_i16 (GNOME_COLOR_PICKER (color_picker), 
 
892
                                    procdata->config.frame_color.red,
 
893
                                    procdata->config.frame_color.green,
 
894
                                    procdata->config.frame_color.blue, 0);
 
895
        g_signal_connect (G_OBJECT (color_picker), "color_set",
 
896
                            G_CALLBACK (cb_frame_color_changed), procdata);       
 
897
        gtk_box_pack_start (GTK_BOX (hbox2), color_picker, TRUE, TRUE, 0);      
 
898
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), color_picker);
 
899
        gtk_widget_show (color_picker);
 
900
        
 
901
        vbox = gtk_vbox_new (FALSE, 6);
 
902
        gtk_box_pack_start (GTK_BOX (sys_box), vbox, FALSE, FALSE, 0);
 
903
        
 
904
        tmp = g_strdup_printf ("<b>%s</b>", _("Devices"));
 
905
        label = gtk_label_new (NULL);
 
906
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
907
        gtk_label_set_markup (GTK_LABEL (label), tmp);
 
908
        g_free (tmp);
 
909
        gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
 
910
        
 
911
        hbox = gtk_hbox_new (FALSE, 0);
 
912
        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
913
        
 
914
        label = gtk_label_new ("    ");
 
915
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
916
        
 
917
        vbox2 = gtk_vbox_new (FALSE, 6);
 
918
        gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
 
919
        
 
920
        hbox2 = gtk_hbox_new (FALSE, 12);
 
921
        gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
 
922
        
 
923
        label = gtk_label_new_with_mnemonic (_("Update _interval:"));
 
924
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
925
        gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
 
926
        gtk_size_group_add_widget (size, label);
 
927
        
 
928
        hbox3 = gtk_hbox_new (FALSE, 6);
 
929
        gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
 
930
                          
 
931
        update = (gfloat) procdata->config.disks_update_interval;
 
932
        adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0, 
 
933
                                                           100.0, 1.0, 1.0, 1.0);
 
934
        spin_button = gtk_spin_button_new (adjustment, 1.0, 0);
 
935
        gtk_box_pack_start (GTK_BOX (hbox3), spin_button, TRUE, TRUE, 0);
 
936
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
 
937
        g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
 
938
                                  G_CALLBACK (update_disks_update_interval), procdata);
 
939
                
 
940
        label = gtk_label_new_with_mnemonic (_("seconds"));
 
941
        gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
 
942
        gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0);
 
943
        
 
944
        gtk_widget_show_all (dialog);
 
945
        g_signal_connect (G_OBJECT (dialog), "response",
 
946
                                  G_CALLBACK (prefs_dialog_button_pressed), procdata);
 
947
        
 
948
        if (procdata->config.current_tab == 0)
 
949
                gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 0);
 
950
        else
 
951
                gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 1);
 
952
}
 
953
 
 
954
static void
 
955
entry_activate_cb (GtkEntry *entry, gpointer data)
 
956
{
 
957
        GtkDialog *dialog = GTK_DIALOG (data);
 
958
        
 
959
        gtk_dialog_response (dialog, 100);
 
960
        
 
961
}       
 
962
 
 
963
/*
 
964
** type determines whether if dialog is for killing process (type=0) or renice (type=other).
 
965
** extra_value is not used for killing and is priority for renice
 
966
*/
 
967
void procdialog_create_root_password_dialog (gint type, ProcData *procdata, gint pid, 
 
968
                                             gint extra_value, gchar *text)
 
969
{
 
970
        GtkWidget *dialog;
 
971
        GtkWidget *error_dialog;
 
972
        GtkWidget *main_vbox;
 
973
        GtkWidget *hbox;
 
974
        GtkWidget *entry;
 
975
        GtkWidget *label;
 
976
        gchar *title = NULL, *button_label;
 
977
        gchar *command;
 
978
        gchar *password, *blank;
 
979
        gint retval;
 
980
 
 
981
        if (type == 0) {
 
982
                if (extra_value == SIGKILL) {
 
983
                        title = g_strdup (_("Kill Process"));
 
984
                        button_label = g_strdup (_("_Kill Process"));
 
985
                }
 
986
                else {
 
987
                        title = g_strdup (_("End Process"));
 
988
                        button_label = g_strdup (_("_End Process"));
 
989
                }
 
990
        }
 
991
        else {
 
992
                title = g_strdup (_("Change Priority"));
 
993
                button_label = g_strdup (_("Change _Priority"));
 
994
        }
 
995
                
 
996
        dialog = gtk_dialog_new_with_buttons (title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
 
997
                                              GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 
998
                                              button_label, 100,
 
999
                                              NULL);
 
1000
        
 
1001
        main_vbox = GTK_DIALOG (dialog)->vbox;
 
1002
        
 
1003
        label = gtk_label_new (_(text));
 
1004
        gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
 
1005
        gtk_misc_set_padding (GTK_MISC (label), GNOME_PAD, 2 * GNOME_PAD);
 
1006
        gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0);
 
1007
        
 
1008
        hbox = gtk_hbox_new (FALSE, 0);
 
1009
        gtk_container_set_border_width (GTK_CONTAINER (hbox), GNOME_PAD_SMALL);
 
1010
        gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
 
1011
        
 
1012
        label = gtk_label_new (_("Root Password :"));
 
1013
        gtk_misc_set_padding (GTK_MISC (label), GNOME_PAD_SMALL, 0);
 
1014
        gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, FALSE, 0);
 
1015
        
 
1016
        entry = gtk_entry_new ();
 
1017
        gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
 
1018
        gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, FALSE, 0);
 
1019
        g_signal_connect (G_OBJECT (entry), "activate",
 
1020
                          G_CALLBACK (entry_activate_cb), dialog);
 
1021
                
 
1022
        gtk_widget_show_all (main_vbox);
 
1023
        
 
1024
        gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
 
1025
        gtk_widget_grab_focus (entry);
 
1026
                
 
1027
        g_free (title); 
 
1028
        g_free (button_label);
 
1029
        
 
1030
        retval = gtk_dialog_run (GTK_DIALOG (dialog));
 
1031
        gtk_widget_hide (dialog);
 
1032
        
 
1033
        if (retval == 100) {
 
1034
                password = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
 
1035
                
 
1036
                if (!password)
 
1037
                        password = "";
 
1038
                blank = g_strdup (password);
 
1039
                if (strlen (blank))
 
1040
                        memset (blank, ' ', strlen (blank));
 
1041
                        
 
1042
                gtk_entry_set_text (GTK_ENTRY (entry), blank);
 
1043
                gtk_entry_set_text (GTK_ENTRY (entry), "");
 
1044
                g_free (blank);
 
1045
                
 
1046
                if (type == 0)
 
1047
                        command = g_strdup_printf ("kill -s %d %d", extra_value, pid);
 
1048
                else
 
1049
                        command = g_strdup_printf ("renice %d %d", extra_value, pid);
 
1050
                        
 
1051
                if (su_run_with_password (command, password) == -1) {
 
1052
                        error_dialog = gtk_message_dialog_new (NULL,
 
1053
                                                               GTK_DIALOG_DESTROY_WITH_PARENT,
 
1054
                                                               GTK_MESSAGE_ERROR,
 
1055
                                                               GTK_BUTTONS_OK,
 
1056
                                                               "%s",
 
1057
                                                              _("Wrong Password.")); 
 
1058
                        gtk_dialog_run (GTK_DIALOG (error_dialog));
 
1059
                        gtk_widget_destroy (error_dialog);
 
1060
                }
 
1061
                g_free (command);
 
1062
                
 
1063
        }
 
1064
        gtk_widget_destroy (dialog);
 
1065
 
 
1066
}
 
1067