← Back to branch summary

~ubuntu-branches/ubuntu/maverick/evolution-data-server/maverick-proposed

« back to all changes in this revision

Viewing changes to servers/exchange/storage/exchange-folder-size.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-05-17 17:02:06 UTC
  • mfrom: (1.1.79 upstream) (1.6.12 experimental)
  • Revision ID: james.westby@ubuntu.com-20100517170206-4ufr52vwrhh26yh0
Tags: 2.30.1-1ubuntu1
https://launchpad.net/bugs/42199
https://launchpad.net/bugs/229669
https://launchpad.net/bugs/173703
https://launchpad.net/bugs/360344
https://launchpad.net/bugs/508494
* Merge from debian experimental. Remaining change:
  (LP: #42199, #229669, #173703, #360344, #508494)
  + debian/control:
    - add Vcs-Bzr tag
    - don't use libgnome
    - Use Breaks instead of Conflicts against evolution 2.25 and earlier.
  + debian/evolution-data-server.install,
    debian/patches/45_libcamel_providers_version.patch:
    - use the upstream versioning, not a Debian-specific one 
  + debian/libedata-book1.2-dev.install, debian/libebackend-1.2-dev.install,
    debian/libcamel1.2-dev.install, debian/libedataserverui1.2-dev.install:
    - install html documentation
  + debian/rules:
    - don't build documentation it's shipped with the tarball

Show diffs side-by-side

added added

removed removed

Lines of Context:
servers/exchange/storage/exchange-folder-size.c
1
 
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2
 
 
3
 
/* Copyright (C) 2002-2004 Novell, Inc.
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or
6
 
 * modify it under the terms of version 2 of the GNU Lesser General Public
7
 
 * License as published by the Free Software Foundation.
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 GNU
12
 
 * General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU Lesser General Public
15
 
 * License along with this program; if not, write to the
16
 
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17
 
 * Boston, MA 02110-1301, USA.
18
 
 */
19
 
 
20
 
/* ExchangeFolderSize: Display the folder tree with the folder sizes */
21
 
 
22
 
#ifdef HAVE_CONFIG_H
23
 
#include <config.h>
24
 
#endif
25
 
 
26
 
#include <string.h>
27
 
 
28
 
#include <glade/glade-xml.h>
29
 
#include <gtk/gtk.h>
30
 
 
31
 
#include "exchange-hierarchy-webdav.h"
32
 
#include "e-folder-exchange.h"
33
 
#include "exchange-folder-size.h"
34
 
 
35
 
#define PARENT_TYPE G_TYPE_OBJECT
36
 
static GObjectClass *parent_class = NULL;
37
 
 
38
 
G_DEFINE_TYPE (ExchangeFolderSize, exchange_folder_size, G_TYPE_OBJECT)
39
 
 
40
 
typedef struct {
41
 
        gchar *folder_name;
42
 
        gdouble folder_size;
43
 
} folder_info;
44
 
 
45
 
struct _ExchangeFolderSizePrivate {
46
 
 
47
 
        GHashTable *table;
48
 
        GtkListStore *model;
49
 
        GHashTable *row_refs;
50
 
};
51
 
 
52
 
enum {
53
 
        COLUMN_NAME,
54
 
        COLUMN_SIZE,
55
 
        NUM_COLUMNS
56
 
};
57
 
 
58
 
static gboolean
59
 
free_fgsizeable (gpointer key, gpointer value, gpointer data)
60
 
{
61
 
        folder_info *f_info = (folder_info *) value;
62
 
 
63
 
        g_free (key);
64
 
        g_free (f_info->folder_name);
65
 
        g_free (f_info);
66
 
        return TRUE;
67
 
}
68
 
 
69
 
static gboolean
70
 
free_row_refs (gpointer key, gpointer value, gpointer user_data)
71
 
{
72
 
        g_free (key);
73
 
        gtk_tree_row_reference_free (value);
74
 
        return TRUE;
75
 
}
76
 
 
77
 
static void
78
 
finalize (GObject *object)
79
 
{
80
 
        ExchangeFolderSize *fsize = EXCHANGE_FOLDER_SIZE (object);
81
 
 
82
 
        g_hash_table_foreach_remove (fsize->priv->table, free_fgsizeable, NULL);
83
 
        g_hash_table_destroy (fsize->priv->table);
84
 
        g_hash_table_foreach_remove (fsize->priv->row_refs, free_row_refs, NULL);
85
 
        g_hash_table_destroy (fsize->priv->row_refs);
86
 
        if (fsize->priv->model)
87
 
                g_object_unref (fsize->priv->model);
88
 
        g_free (fsize->priv);
89
 
 
90
 
        G_OBJECT_CLASS (parent_class)->finalize (object);
91
 
}
92
 
 
93
 
static void
94
 
dispose (GObject *object)
95
 
{
96
 
        G_OBJECT_CLASS (parent_class)->dispose (object);
97
 
}
98
 
 
99
 
static void
100
 
exchange_folder_size_class_init (ExchangeFolderSizeClass *class)
101
 
{
102
 
        GObjectClass *object_class;
103
 
        parent_class = g_type_class_ref (PARENT_TYPE);
104
 
 
105
 
        object_class = G_OBJECT_CLASS (class);
106
 
 
107
 
        /* override virtual methods */
108
 
        object_class->dispose = dispose;
109
 
        object_class->finalize = finalize;
110
 
 
111
 
}
112
 
 
113
 
static void
114
 
exchange_folder_size_init (ExchangeFolderSize *fsize)
115
 
{
116
 
        fsize->priv = g_new0 (ExchangeFolderSizePrivate, 1);
117
 
        fsize->priv->table = g_hash_table_new (g_str_hash, g_str_equal);
118
 
        fsize->priv->model = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_DOUBLE);
119
 
        fsize->priv->row_refs = g_hash_table_new (g_str_hash, g_str_equal);
120
 
}
121
 
 
122
 
/**
123
 
 * exchange_folder_size_new:
124
 
 *
125
 
 * Return value: a foldersize object with the table initialized
126
 
 **/
127
 
ExchangeFolderSize *
128
 
exchange_folder_size_new (void)
129
 
{
130
 
        ExchangeFolderSize *fsize;
131
 
 
132
 
        fsize = g_object_new (EXCHANGE_TYPE_FOLDER_SIZE, NULL);
133
 
 
134
 
        return fsize;
135
 
}
136
 
 
137
 
void
138
 
exchange_folder_size_update (ExchangeFolderSize *fsize,
139
 
                                const gchar *folder_name,
140
 
                                gdouble folder_size)
141
 
{
142
 
        folder_info *f_info, *cached_info;
143
 
        ExchangeFolderSizePrivate *priv;
144
 
        GHashTable *folder_gsizeable;
145
 
        GtkTreeRowReference *row;
146
 
        GtkTreeIter iter;
147
 
        GtkTreePath *path;
148
 
 
149
 
        g_return_if_fail (EXCHANGE_IS_FOLDER_SIZE (fsize));
150
 
 
151
 
        priv = fsize->priv;
152
 
        folder_gsizeable = priv->table;
153
 
 
154
 
        cached_info = g_hash_table_lookup (folder_gsizeable, folder_name);
155
 
        if (cached_info) {
156
 
                if (cached_info->folder_size == folder_size) {
157
 
                        return;
158
 
                } else {
159
 
                        cached_info->folder_size = folder_size;
160
 
                        row = g_hash_table_lookup (priv->row_refs, folder_name);
161
 
                        path = gtk_tree_row_reference_get_path (row);
162
 
                        if (gtk_tree_model_get_iter (GTK_TREE_MODEL (fsize->priv->model), &iter, path)) {
163
 
                                gtk_list_store_set (fsize->priv->model, &iter,
164
 
                                                      COLUMN_NAME, cached_info->folder_name,
165
 
                                                      COLUMN_SIZE, cached_info->folder_size,
166
 
                                                      -1);
167
 
                        }
168
 
                        gtk_tree_path_free (path);
169
 
                        return;
170
 
                }
171
 
        } else {
172
 
                f_info = g_new0(folder_info, 1);
173
 
                f_info->folder_name = g_strdup (folder_name);
174
 
                f_info->folder_size = folder_size;
175
 
                g_hash_table_insert (folder_gsizeable, f_info->folder_name, f_info);
176
 
 
177
 
                gtk_list_store_append (fsize->priv->model, &iter);
178
 
                gtk_list_store_set (fsize->priv->model, &iter,
179
 
                                      COLUMN_NAME, f_info->folder_name,
180
 
                                      COLUMN_SIZE, f_info->folder_size,
181
 
                                      -1);
182
 
 
183
 
                path = gtk_tree_model_get_path (GTK_TREE_MODEL (fsize->priv->model), &iter);
184
 
                row = gtk_tree_row_reference_new (GTK_TREE_MODEL (fsize->priv->model), path);
185
 
                gtk_tree_path_free (path);
186
 
 
187
 
                g_hash_table_insert (fsize->priv->row_refs, g_strdup (folder_name), row);
188
 
        }
189
 
}
190
 
 
191
 
void
192
 
exchange_folder_size_remove (ExchangeFolderSize *fsize,
193
 
                                const gchar *folder_name)
194
 
{
195
 
        ExchangeFolderSizePrivate *priv;
196
 
        GHashTable *folder_gsizeable;
197
 
        folder_info *cached_info;
198
 
        GtkTreeRowReference *row;
199
 
        GtkTreeIter iter;
200
 
        GtkTreePath *path;
201
 
 
202
 
        g_return_if_fail (EXCHANGE_IS_FOLDER_SIZE (fsize));
203
 
        g_return_if_fail (folder_name != NULL);
204
 
 
205
 
        priv = fsize->priv;
206
 
        folder_gsizeable = priv->table;
207
 
 
208
 
        cached_info = g_hash_table_lookup (folder_gsizeable, folder_name);
209
 
        if (cached_info)  {
210
 
                row = g_hash_table_lookup (priv->row_refs, folder_name);
211
 
                path = gtk_tree_row_reference_get_path (row);
212
 
                g_hash_table_remove (folder_gsizeable, folder_name);
213
 
                if (gtk_tree_model_get_iter (GTK_TREE_MODEL (fsize->priv->model), &iter, path)) {
214
 
                        gtk_list_store_remove (fsize->priv->model, &iter);
215
 
                }
216
 
                g_hash_table_remove (priv->row_refs, row);
217
 
                gtk_tree_path_free (path);
218
 
        }
219
 
}
220
 
 
221
 
gdouble
222
 
exchange_folder_size_get (ExchangeFolderSize *fsize,
223
 
                          const gchar *folder_name)
224
 
{
225
 
        ExchangeFolderSizePrivate *priv;
226
 
        GHashTable *folder_gsizeable;
227
 
        folder_info *cached_info;
228
 
 
229
 
        g_return_val_if_fail (EXCHANGE_IS_FOLDER_SIZE (fsize), -1);
230
 
 
231
 
        priv = fsize->priv;
232
 
        folder_gsizeable = priv->table;
233
 
 
234
 
        cached_info = g_hash_table_lookup (folder_gsizeable, folder_name);
235
 
        if (cached_info)  {
236
 
                return cached_info->folder_size;
237
 
        }
238
 
        return -1;
239
 
}
240
 
 
241
 
GtkListStore *
242
 
exchange_folder_size_get_model (ExchangeFolderSize *fsize)
243
 
{
244
 
        ExchangeFolderSizePrivate *priv;
245
 
 
246
 
        priv = fsize->priv;
247
 
 
248
 
        if (!g_hash_table_size (priv->table))
249
 
                return NULL;
250
 
 
251
 
        return priv->model;
252
 
}