1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* e-table-memory.c: a Table Model implementation that the programmer builds in memory.
*
* Author:
* Chris Toshok (toshok@ximian.com)
* Chris Lahey <clahey@ximian.com>
*
* Adapted from the gtable code and ETableModel.
*
* (C) 2000, 2001 Ximian, Inc.
*/
#include <config.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <gnome-xml/parser.h>
#include <gnome-xml/xmlmemory.h>
#include <gtk/gtksignal.h>
#include <stdlib.h>
#include "gal/util/e-util.h"
#include "gal/util/e-xml-utils.h"
#include "e-table-memory.h"
#define PARENT_TYPE E_TABLE_MODEL_TYPE
static ETableModel *parent_class;
struct ETableMemoryPriv {
gpointer *data;
int num_rows;
gint frozen;
};
/* virtual methods */
static void
etmm_destroy (GtkObject *object)
{
ETableMemory *etmm = E_TABLE_MEMORY (object);
ETableMemoryPriv *priv = etmm->priv;
/* XXX lots of stuff to free here */
g_free (priv->data);
g_free (priv);
GTK_OBJECT_CLASS (parent_class)->destroy (object);
}
static int
etmm_row_count (ETableModel *etm)
{
ETableMemory *etmm = E_TABLE_MEMORY (etm);
return etmm->priv->num_rows;
}
static void
e_table_memory_class_init (GtkObjectClass *klass)
{
ETableModelClass *table_class = (ETableModelClass *) klass;
parent_class = gtk_type_class (PARENT_TYPE);
klass->destroy = etmm_destroy;
table_class->row_count = etmm_row_count;
}
static void
e_table_memory_init (GtkObject *object)
{
ETableMemory *etmm = (ETableMemory *)object;
ETableMemoryPriv *priv;
priv = g_new0 (ETableMemoryPriv, 1);
etmm->priv = priv;
priv->data = NULL;
priv->num_rows = 0;
priv->frozen = 0;
}
E_MAKE_TYPE(e_table_memory, "ETableMemory", ETableMemory, e_table_memory_class_init, e_table_memory_init, PARENT_TYPE)
/**
* e_table_memory_construct:
* @etable:
*
*
**/
void
e_table_memory_construct (ETableMemory *etmm)
{
}
/**
* e_table_memory_new
*
* XXX docs here.
*
* return values: a newly constructed ETableMemory.
*/
ETableMemory *
e_table_memory_new (void)
{
ETableMemory *etmm;
etmm = gtk_type_new (e_table_memory_get_type ());
e_table_memory_construct(etmm);
return etmm;
}
/**
* e_table_memory_node_get_data:
* @etmm:
* @node:
*
*
*
* Return value:
**/
gpointer
e_table_memory_get_data (ETableMemory *etmm, int row)
{
g_return_val_if_fail(row < 0, NULL);
g_return_val_if_fail(row >= etmm->priv->num_rows, NULL);
return etmm->priv->data[row];
}
/**
* e_table_memory_node_set_data:
* @etmm:
* @node:
* @node_data:
*
*
**/
void
e_table_memory_set_data (ETableMemory *etmm, int row, gpointer node_data)
{
g_return_if_fail(row < 0);
g_return_if_fail(row > etmm->priv->num_rows);
etmm->priv->data[row] = node_data;
}
/**
* e_table_memory_node_insert:
* @table_model:
* @parent_path:
* @position:
* @node_data:
*
*
*
* Return value:
**/
void
e_table_memory_node_insert (ETableMemory *etmm,
int row,
gpointer node_data)
{
g_return_if_fail(row < 0);
g_return_if_fail(row > etmm->priv->num_rows);
if (!etmm->priv->frozen)
e_table_model_pre_change(E_TABLE_MODEL(etmm));
etmm->priv->data = g_renew(gpointer, etmm->priv->data, etmm->priv->num_rows + 1);
memmove(etmm->priv->data + row + 1, etmm->priv->data + row, (etmm->priv->num_rows - row) * sizeof (gpointer));
etmm->priv->data[row] = node_data;
etmm->priv->num_rows ++;
if (!etmm->priv->frozen)
e_table_model_row_inserted(E_TABLE_MODEL(etmm), row);
}
/**
* e_table_memory_node_remove:
* @etable:
* @path:
*
*
*
* Return value:
**/
gpointer
e_table_memory_node_remove (ETableMemory *etmm, int row)
{
gpointer ret;
g_return_val_if_fail(row < 0, NULL);
g_return_val_if_fail(row >= etmm->priv->num_rows, NULL);
if (!etmm->priv->frozen)
e_table_model_pre_change(E_TABLE_MODEL(etmm));
ret = etmm->priv->data[row];
memmove(etmm->priv->data + row, etmm->priv->data + row + 1, (etmm->priv->num_rows - row - 1) * sizeof (gpointer));
etmm->priv->num_rows --;
if (!etmm->priv->frozen)
e_table_model_row_deleted(E_TABLE_MODEL(etmm), row);
return ret;
}
/**
* e_table_memory_freeze:
* @etmm: the ETableModel to freeze.
*
* This function prepares an ETableModel for a period of much change.
* All signals regarding changes to the table are deferred until we
* thaw the table.
*
**/
void
e_table_memory_freeze(ETableMemory *etmm)
{
ETableMemoryPriv *priv = etmm->priv;
if (priv->frozen == 0)
e_table_model_pre_change(E_TABLE_MODEL(etmm));
priv->frozen ++;
}
/**
* e_table_memory_thaw:
* @etmm: the ETableMemory to thaw.
*
* This function thaws an ETableMemory. All the defered signals can add
* up to a lot, we don't know - so we just emit a model_changed
* signal.
*
**/
void
e_table_memory_thaw(ETableMemory *etmm)
{
ETableMemoryPriv *priv = etmm->priv;
if (priv->frozen > 0)
priv->frozen --;
if (priv->frozen == 0) {
e_table_model_changed(E_TABLE_MODEL(etmm));
}
}
|
