← 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.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl
  • Date: 2011-06-21 16:49:23 UTC
  • mto: (2.1.7 sid) (1.1.59 upstream)
  • mto: This revision was merged to the branch mainline in revision 78.
  • Revision ID: james.westby@ubuntu.com-20110621164923-o6titd2srek1uh84
Tags: upstream-3.0.1
Import upstream version 3.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/procdialogs.cpp
31
31
#include "procactions.h"
32
32
#include "util.h"
33
33
#include "load-graph.h"
34
 
#include "gconf-keys.h"
 
34
#include "settings-keys.h"
35
35
#include "procman_gnomesu.h"
36
36
#include "procman_gksu.h"
37
37
 
128
128
{
129
129
        GtkWidget *label = GTK_WIDGET (data);
130
130
        
131
 
        new_nice_value = int(adj->value);
 
131
        new_nice_value = int(gtk_adjustment_get_value (adj));
132
132
        gtk_label_set_text (GTK_LABEL (label), get_nice_level (new_nice_value));                
133
133
        
134
134
}
159
159
        GtkWidget *label;
160
160
        GtkWidget *priority_label;
161
161
        GtkWidget *table;
162
 
        GtkObject *renice_adj;
 
162
        GtkAdjustment *renice_adj;
163
163
        GtkWidget *hscale;
164
164
        GtkWidget *button;
165
165
        GtkWidget *align;
178
178
                                              NULL);
179
179
        renice_dialog = dialog;
180
180
        gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE);
181
 
        gtk_dialog_set_has_separator (GTK_DIALOG (renice_dialog), FALSE);
182
181
        gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5);
183
182
        
184
183
        button = gtk_button_new ();
185
 
        GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 
184
        gtk_widget_set_can_default (button, TRUE);
186
185
                
187
186
        align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
188
187
        gtk_container_add (GTK_CONTAINER (button), align);
201
200
        gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
202
201
        new_nice_value = -100;
203
202
          
204
 
        dialog_vbox = GTK_DIALOG (dialog)->vbox;
 
203
        dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
205
204
        gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
206
205
        gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
207
206
                
220
219
        
221
220
        renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0);
222
221
        new_nice_value = 0;
223
 
        hscale = gtk_hscale_new (GTK_ADJUSTMENT (renice_adj));
 
222
        hscale = gtk_hscale_new (renice_adj);
224
223
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale);
225
224
        gtk_scale_set_digits (GTK_SCALE (hscale), 0);
226
225
        gtk_table_attach (GTK_TABLE (table), hscale, 1, 2, 0, 1,
262
261
show_kill_dialog_toggled (GtkToggleButton *button, gpointer data)
263
262
{
264
263
        ProcData *procdata = static_cast<ProcData*>(data);
265
 
        GConfClient *client = procdata->client;
266
 
        
 
264
        GSettings *settings = procdata->settings;
 
265
 
267
266
        gboolean toggled;
268
267
        
269
268
        toggled = gtk_toggle_button_get_active (button);
270
269
        
271
 
        gconf_client_set_bool (client, "/apps/procman/kill_dialog", toggled, NULL);
272
 
                
 
270
        g_settings_set_boolean (settings, "kill-dialog", toggled);
273
271
}
274
272
 
275
273
 
278
276
solaris_mode_toggled(GtkToggleButton *button, gpointer data)
279
277
{
280
278
        ProcData *procdata = static_cast<ProcData*>(data);
281
 
        GConfClient *client = procdata->client;
 
279
        GSettings *settings = procdata->settings;
 
280
 
282
281
        gboolean toggled;
283
282
        toggled = gtk_toggle_button_get_active(button);
284
 
        gconf_client_set_bool(client, procman::gconf::solaris_mode.c_str(), toggled, NULL);
 
283
        g_settings_set_boolean(settings, procman::settings::solaris_mode.c_str(), toggled);
285
284
}
286
285
 
287
286
 
289
288
network_in_bits_toggled(GtkToggleButton *button, gpointer data)
290
289
{
291
290
        ProcData *procdata = static_cast<ProcData*>(data);
292
 
        GConfClient *client = procdata->client;
 
291
        GSettings *settings = procdata->settings;
 
292
 
293
293
        gboolean toggled;
294
294
        toggled = gtk_toggle_button_get_active(button);
295
 
        gconf_client_set_bool(client, procman::gconf::network_in_bits.c_str(), toggled, NULL);
 
295
        g_settings_set_boolean(settings, procman::settings::network_in_bits.c_str(), toggled);
296
296
}
297
297
 
298
298
 
301
301
smooth_refresh_toggled(GtkToggleButton *button, gpointer data)
302
302
{
303
303
        ProcData *procdata = static_cast<ProcData*>(data);
304
 
        GConfClient *client = procdata->client;
305
 
 
 
304
        GSettings *settings = procdata->settings;
 
305
        
306
306
        gboolean toggled;
307
307
 
308
308
        toggled = gtk_toggle_button_get_active(button);
309
309
 
310
 
        gconf_client_set_bool(client, SmoothRefresh::KEY.c_str(), toggled, NULL);
 
310
        g_settings_set_boolean(settings, SmoothRefresh::KEY.c_str(), toggled);
311
311
}
312
312
 
313
313
 
316
316
show_all_fs_toggled (GtkToggleButton *button, gpointer data)
317
317
{
318
318
        ProcData *procdata = static_cast<ProcData*>(data);
319
 
        GConfClient *client = procdata->client;
320
 
 
 
319
        GSettings *settings = procdata->settings;
 
320
        
321
321
        gboolean toggled;
322
322
 
323
323
        toggled = gtk_toggle_button_get_active (button);
324
324
 
325
 
        gconf_client_set_bool (client, "/apps/procman/show_all_fs", toggled, NULL);
 
325
        g_settings_set_boolean (settings, "show-all-fs", toggled);
326
326
}
327
327
 
328
328
 
329
329
class SpinButtonUpdater
330
330
{
331
331
public:
332
 
  SpinButtonUpdater(const string& gconf_key)
333
 
    : gconf_key(gconf_key)
 
332
  SpinButtonUpdater(const string& key)
 
333
    : key(key)
334
334
  { }
335
335
 
336
336
  static gboolean callback(GtkWidget *widget, GdkEventFocus *event, gpointer data)
345
345
  void update(GtkSpinButton* spin)
346
346
  {
347
347
    int new_value = int(1000 * gtk_spin_button_get_value(spin));
348
 
    GError* e = 0;
349
 
 
350
 
    if (not gconf_client_set_int(ProcData::get_instance()->client,
351
 
                                 this->gconf_key.c_str(), new_value,
352
 
                                 &e)) {
353
 
      g_warning("Failed to gconf_client_set_int %s %d : %s\n",
354
 
                this->gconf_key.c_str(), new_value, e->message);
355
 
      g_error_free(e);
356
 
    }
357
 
 
358
 
    procman_debug("set %s to %d", this->gconf_key.c_str(), new_value);
 
348
 
 
349
    g_settings_set_int(ProcData::get_instance()->settings,
 
350
                       this->key.c_str(), new_value);
 
351
 
 
352
    procman_debug("set %s to %d", this->key.c_str(), new_value);
359
353
  }
360
354
 
361
 
  const string gconf_key;
 
355
  const string key;
362
356
};
363
357
 
364
358
 
474
468
 
475
469
        typedef SpinButtonUpdater SBU;
476
470
 
477
 
        static SBU interval_updater("/apps/procman/update_interval");
478
 
        static SBU graph_interval_updater("/apps/procman/graph_update_interval");
479
 
        static SBU disks_interval_updater("/apps/procman/disks_interval");
 
471
        static SBU interval_updater("update-interval");
 
472
        static SBU graph_interval_updater("graph-update-interval");
 
473
        static SBU disks_interval_updater("disks-interval");
480
474
 
481
475
        GtkWidget *notebook;
482
476
        GtkWidget *proc_box;
510
504
        /* any function to set list height by contents/items inside it. */
511
505
        gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 420);
512
506
        gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
513
 
        gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
514
507
        prefs_dialog = dialog;
515
508
        
516
 
        main_vbox = GTK_DIALOG (dialog)->vbox;
 
509
        main_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
517
510
        gtk_box_set_spacing (GTK_BOX (main_vbox), 2);
518
511
        
519
512
        notebook = gtk_notebook_new ();
561
554
                                                          MAX_UPDATE_INTERVAL / 1000,
562
555
                                                          0.25,
563
556
                                                          1.0,
564
 
                                                          1.0);
 
557
                                                          0);
565
558
 
566
559
        spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
567
560
        gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
575
568
 
576
569
        smooth_button = gtk_check_button_new_with_mnemonic(_("Enable _smooth refresh"));
577
570
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(smooth_button),
578
 
                                     gconf_client_get_bool(procdata->client,
579
 
                                                           SmoothRefresh::KEY.c_str(),
580
 
                                                           NULL));
 
571
                                     g_settings_get_boolean(procdata->settings,
 
572
                                                           SmoothRefresh::KEY.c_str()));
581
573
        g_signal_connect(G_OBJECT(smooth_button), "toggled",
582
574
                         G_CALLBACK(smooth_refresh_toggled), procdata);
583
575
        gtk_box_pack_start(GTK_BOX(hbox2), smooth_button, TRUE, TRUE, 0);
592
584
                                      procdata->config.show_kill_warning);
593
585
        g_signal_connect (G_OBJECT (check_button), "toggled",
594
586
                            G_CALLBACK (show_kill_dialog_toggled), procdata);
595
 
        gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
596
 
        
 
587
        gtk_box_pack_start (GTK_BOX (hbox2), check_button, TRUE, TRUE, 0);
 
588
 
597
589
 
598
590
 
599
591
 
603
595
        GtkWidget *solaris_button;
604
596
        solaris_button = gtk_check_button_new_with_mnemonic(_("Solaris mode"));
605
597
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(solaris_button),
606
 
                                     gconf_client_get_bool(procdata->client,
607
 
                                                           procman::gconf::solaris_mode.c_str(),
608
 
                                                           NULL));
 
598
                                     g_settings_get_boolean(procdata->settings,
 
599
                                                           procman::settings::solaris_mode.c_str()));
609
600
        g_signal_connect(G_OBJECT(solaris_button), "toggled",
610
601
                         G_CALLBACK(solaris_mode_toggled), procdata);
611
602
        gtk_box_pack_start(GTK_BOX(hbox2), solaris_button, TRUE, TRUE, 0);
673
664
                          
674
665
        update = (gfloat) procdata->config.graph_update_interval;
675
666
        adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25, 
676
 
                                                          100.0, 0.25, 1.0, 1.0);
 
667
                                                          100.0, 0.25, 1.0, 0);
677
668
        spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
678
669
        g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
679
670
                          G_CALLBACK(SBU::callback),
685
676
        GtkWidget *bits_button;
686
677
        bits_button = gtk_check_button_new_with_mnemonic(_("Show network speed in bits"));
687
678
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bits_button),
688
 
                                     gconf_client_get_bool(procdata->client,
689
 
                                                           procman::gconf::network_in_bits.c_str(),
690
 
                                                           NULL));
 
679
                                     g_settings_get_boolean(procdata->settings,
 
680
                                                           procman::settings::network_in_bits.c_str()));
691
681
        g_signal_connect(G_OBJECT(bits_button), "toggled",
692
682
                         G_CALLBACK(network_in_bits_toggled), procdata);
693
683
        gtk_box_pack_start(GTK_BOX(vbox2), bits_button, TRUE, TRUE, 0);
734
724
                          
735
725
        update = (gfloat) procdata->config.disks_update_interval;
736
726
        adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0, 
737
 
                                                           100.0, 1.0, 1.0, 1.0);
 
727
                                                           100.0, 1.0, 1.0, 0);
738
728
        spin_button = gtk_spin_button_new (adjustment, 1.0, 0);
739
729
        gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
740
730
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);