← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/memmaps.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/memmaps.cpp
89
89
  };
90
90
 
91
91
 
92
 
  void
93
 
  procman_save_tree_state2(GConfClient *client, GtkWidget *tree, const gchar *cprefix)
94
 
  {
95
 
    const string prefix(cprefix);
96
 
 
97
 
    GtkTreeModel *model;
98
 
    gint sort_col;
99
 
    GtkSortType order;
100
 
 
101
 
    g_assert(tree);
102
 
    g_assert(prefix != "");
103
 
 
104
 
    model = gtk_tree_view_get_model(GTK_TREE_VIEW (tree));
105
 
 
106
 
    if (gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(model), &sort_col, &order)) {
107
 
      gconf_client_set_int(client, (prefix + "/sort_col").c_str(), sort_col, 0);
108
 
      gconf_client_set_int(client, (prefix + "/sort_order").c_str(), order, 0);
109
 
    }
110
 
 
111
 
    GList * const columns = gtk_tree_view_get_columns(GTK_TREE_VIEW(tree));
112
 
 
113
 
    GSList *list = 0;
114
 
 
115
 
    for (GList *it = columns; it; it = it->next)
116
 
      {
117
 
        GtkTreeViewColumn *column;
118
 
        ColumnState cs;
119
 
 
120
 
        column = static_cast<GtkTreeViewColumn*>(it->data);
121
 
        cs.id = gtk_tree_view_column_get_sort_column_id(column);
122
 
        cs.visible = gtk_tree_view_column_get_visible(column);
123
 
        cs.width = gtk_tree_view_column_get_width(column);
124
 
 
125
 
        list = g_slist_append(list, GINT_TO_POINTER(cs.pack()));
126
 
      }
127
 
 
128
 
    g_list_free(columns);
129
 
 
130
 
    GError *error = 0;
131
 
 
132
 
    if (not gconf_client_set_list(client, (prefix + "/columns").c_str(),
133
 
                                  GCONF_VALUE_INT, list,
134
 
                                  &error)) {
135
 
      g_critical("Failed to save tree state %s : %s",
136
 
                 prefix.c_str(),
137
 
                 error->message);
138
 
      g_error_free(error);
139
 
    }
140
 
 
141
 
    g_slist_free(list);
142
 
  }
143
 
 
144
 
 
145
 
  gboolean procman_get_tree_state2(GConfClient *client, GtkWidget *tree, const gchar *cprefix)
146
 
  {
147
 
    const string prefix(cprefix);
148
 
    GtkTreeModel *model;
149
 
 
150
 
    gint sort_col;
151
 
    GtkSortType order;
152
 
 
153
 
    g_assert(tree);
154
 
    g_assert(prefix != "");
155
 
 
156
 
    if (!gconf_client_dir_exists(client, prefix.c_str(), 0))
157
 
      return FALSE;
158
 
 
159
 
    model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree));
160
 
 
161
 
    sort_col = gconf_client_get_int(client, (prefix + "/sort_col").c_str(), 0);
162
 
    sort_order = gconf_client_get_int(client, (prefix + "/sort_order").c_str(), 0);
163
 
 
164
 
    if (sort_col != -1)
165
 
      gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), sort_col, order);
166
 
 
167
 
    proctable_set_columns_order(GTK_TREE_VIEW(tree), order);
168
 
 
169
 
    GSlist *list = gconf_client_get_list(client, (prefix + "/columns").c_str(),
170
 
                                         GCONF_VALUE_INT, 0);
171
 
 
172
 
 
173
 
    for (GSList *it = list; it; it = it->next) {
174
 
      ColumnState cs;
175
 
      cs.unpack(GPOINTER_TO_INT(it->data));
176
 
 
177
 
      GtkTreeViewColumn *column;
178
 
      column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), cs.id);
179
 
 
180
 
      if (!column)
181
 
        continue;
182
 
 
183
 
      gtk_tree_view_column_set_visible(column, cs.visible);
184
 
      if (cs.visible)
185
 
        gtk_tree_view_column_set_fixed_width(column, MAX(10, cs.width));
186
 
    }
187
 
 
188
 
    g_slist_free(list);
189
 
 
190
 
 
191
 
    GList * const columns = gtk_tree_view_get_columns(GTK_TREE_VIEW(tree));
192
 
 
193
 
    for (GList * it = columns; it; it = it->next)
194
 
      {
195
 
        GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
196
 
        unsigned id = gtk_tree_view_column_get_sort_column_id(column);
197
 
 
198
 
        ColumnState &cs(states[id]);
199
 
 
200
 
 
201
 
 
202
 
        key = g_strdup_printf("%s/col_%d_width", prefix, id);
203
 
        value = gconf_client_get (client, key, NULL);
204
 
        g_free (key);
205
 
 
206
 
        if (value != NULL) {
207
 
          width = gconf_value_get_int(value);
208
 
          gconf_value_free (value);
209
 
 
210
 
          key = g_strdup_printf ("%s/col_%d_visible", prefix, id);
211
 
          visible = gconf_client_get_bool (client, key, NULL);
212
 
          g_free (key);
213
 
 
214
 
          column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree), id);
215
 
          if(!column) continue;
216
 
          gtk_tree_view_column_set_visible (column, visible);
217
 
          if (visible) {
218
 
            /* ensure column is really visible */
219
 
            width = MAX(width, 10);
220
 
            gtk_tree_view_column_set_fixed_width(column, width);
221
 
          }
222
 
        }
223
 
      }
224
 
 
225
 
    g_list_free(columns);
226
 
 
227
 
    return TRUE;
228
 
  }
229
 
 
230
92
 
231
93
 
232
94
#endif
294
156
  public:
295
157
    guint timer;
296
158
    GtkWidget *tree;
297
 
    GConfClient *client;
 
159
    GSettings *settings;
298
160
    ProcInfo *info;
299
161
    OffsetFormater format;
300
162
    mutable InodeDevices devices;
301
 
    const char * const key;
 
163
    const char * const schema;
302
164
 
303
 
    MemMapsData(GtkWidget *a_tree, GConfClient *a_client)
 
165
    MemMapsData(GtkWidget *a_tree, GSettings *a_settings)
304
166
      : tree(a_tree),
305
 
        client(a_client),
306
 
        key("/apps/procman/memmapstree2")
 
167
        settings(a_settings),
 
168
        schema("memmapstree")
307
169
    {
308
 
      procman_get_tree_state(this->client, this->tree, this->key);
 
170
        procman_get_tree_state(this->settings, this->tree, this->schema);
309
171
    }
310
172
 
311
173
    ~MemMapsData()
312
174
    {
313
 
      procman_save_tree_state(this->client, this->tree, this->key);
 
175
        procman_save_tree_state(this->settings, this->tree, this->schema);
314
176
    }
315
177
  };
316
178
}
454
316
 
455
317
 
456
318
 
457
 
static gboolean window_delete_event(GtkWidget *, GdkEvent *, gpointer data)
 
319
static void
 
320
dialog_response (GtkDialog * dialog, gint response_id, gpointer data)
458
321
{
459
322
        MemMapsData * const mmdata = static_cast<MemMapsData*>(data);
460
323
 
461
324
        g_source_remove (mmdata->timer);
462
325
 
463
326
        delete mmdata;
464
 
        return FALSE;
 
327
        gtk_widget_destroy (GTK_WIDGET (dialog));
465
328
}
466
329
 
467
330
 
562
425
                }
563
426
        }
564
427
 
565
 
        return new MemMapsData(tree, procdata->client);
 
428
        return new MemMapsData(tree, procdata->settings);
566
429
}
567
430
 
568
431
 
601
464
        mmdata = create_memmapsdata (procdata);
602
465
        mmdata->info = info;
603
466
 
604
 
        memmapsdialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
605
 
        gtk_window_set_transient_for(GTK_WINDOW(memmapsdialog), GTK_WINDOW(procdata->app));
606
 
        gtk_window_set_destroy_with_parent(GTK_WINDOW(memmapsdialog), TRUE);
607
 
        // gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
608
 
        gtk_window_set_title(GTK_WINDOW(memmapsdialog), _("Memory Maps"));
 
467
        memmapsdialog = gtk_dialog_new_with_buttons (_("Memory Maps"), GTK_WINDOW (procdata->app),
 
468
                                                     GTK_DIALOG_DESTROY_WITH_PARENT,
 
469
                                                     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
 
470
                                                     NULL);
609
471
        gtk_window_set_resizable(GTK_WINDOW(memmapsdialog), TRUE);
610
472
        gtk_window_set_default_size(GTK_WINDOW(memmapsdialog), 575, 400);
611
 
        // gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
612
 
        gtk_container_set_border_width(GTK_CONTAINER(memmapsdialog), 12);
613
 
 
614
 
        GtkWidget *mainbox = gtk_vbox_new(FALSE, 12);
615
 
        gtk_container_add(GTK_CONTAINER(memmapsdialog), mainbox);
616
 
 
617
 
        vbox = mainbox;
618
 
        gtk_box_set_spacing (GTK_BOX (vbox), 2);
619
 
        gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
620
 
 
621
 
        dialog_vbox = gtk_vbox_new (FALSE, 6);
 
473
        gtk_container_set_border_width(GTK_CONTAINER(memmapsdialog), 5);
 
474
 
 
475
        dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG(memmapsdialog));
622
476
        gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
623
 
        gtk_box_pack_start (GTK_BOX (vbox), dialog_vbox, TRUE, TRUE, 0);
624
 
 
625
477
 
626
478
        label = procman_make_label_for_mmaps_or_ofiles (
627
479
                _("_Memory maps for process \"%s\" (PID %u):"),
643
495
 
644
496
        gtk_box_pack_start (GTK_BOX (dialog_vbox), scrolled, TRUE, TRUE, 0);
645
497
 
646
 
        gtk_widget_show_all (memmapsdialog);
647
 
 
648
 
        g_signal_connect(G_OBJECT(memmapsdialog), "delete-event",
649
 
                         G_CALLBACK(window_delete_event), mmdata);
650
 
 
 
498
        g_signal_connect(G_OBJECT(memmapsdialog), "response",
 
499
                         G_CALLBACK(dialog_response), mmdata);
 
500
 
 
501
        gtk_widget_show_all (memmapsdialog);
651
502
        mmdata->timer = g_timeout_add_seconds (5, memmaps_timer, mmdata);
652
503
 
653
504
        update_memmaps_dialog (mmdata);