~ubuntu-branches/debian/sid/sqlheavy/sid

« back to all changes in this revision

Viewing changes to gtk/sqlheavy-gtk-model.c

  • Committer: Package Import Robot
  • Author(s): Devid Antonio Filoni
  • Date: 2011-10-23 15:43:22 UTC
  • Revision ID: package-import@ubuntu.com-20111023154322-unzj3fz2aj4g6cl8
Tags: upstream-0.1.0
ImportĀ upstreamĀ versionĀ 0.1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* sqlheavy-gtk-model.c generated by valac 0.12.1, the Vala compiler
 
2
 * generated from sqlheavy-gtk-model.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include "SQLHeavyGTK.h"
 
8
#include <SQLHeavy.h>
 
9
#include <gtk/gtk.h>
 
10
#include <stdlib.h>
 
11
#include <string.h>
 
12
 
 
13
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
14
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
15
#define _g_free0(var) (var = (g_free (var), NULL))
 
16
 
 
17
struct _SQLHeavyGtkModelPrivate {
 
18
        SQLHeavyTable* _table;
 
19
        SQLHeavyQueryable* queryable;
 
20
        gint get_value_calls;
 
21
        gint next_calls;
 
22
};
 
23
 
 
24
 
 
25
static gpointer sql_heavy_gtk_model_parent_class = NULL;
 
26
static GtkTreeModelIface* sql_heavy_gtk_model_gtk_tree_model_parent_iface = NULL;
 
27
 
 
28
#define SQL_HEAVY_GTK_MODEL_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SQL_HEAVY_GTK_TYPE_MODEL, SQLHeavyGtkModelPrivate))
 
29
enum  {
 
30
        SQL_HEAVY_GTK_MODEL_DUMMY_PROPERTY,
 
31
        SQL_HEAVY_GTK_MODEL_TABLE
 
32
};
 
33
static SQLHeavyRow* sql_heavy_gtk_model_get_row_from_iter (SQLHeavyGtkModel* self, GtkTreeIter* iter);
 
34
static GType sql_heavy_gtk_model_real_get_column_type (GtkTreeModel* base, gint index);
 
35
static GtkTreeModelFlags sql_heavy_gtk_model_real_get_flags (GtkTreeModel* base);
 
36
static gboolean sql_heavy_gtk_model_real_get_iter (GtkTreeModel* base, GtkTreeIter* iter, GtkTreePath* path);
 
37
static gint sql_heavy_gtk_model_real_get_n_columns (GtkTreeModel* base);
 
38
static GtkTreePath* sql_heavy_gtk_model_real_get_path (GtkTreeModel* base, GtkTreeIter* iter);
 
39
static void sql_heavy_gtk_model_real_get_value (GtkTreeModel* base, GtkTreeIter* iter, gint column, GValue* value);
 
40
static gboolean sql_heavy_gtk_model_real_iter_children (GtkTreeModel* base, GtkTreeIter* iter, GtkTreeIter* parent);
 
41
static gboolean sql_heavy_gtk_model_real_iter_has_child (GtkTreeModel* base, GtkTreeIter* iter);
 
42
static gint sql_heavy_gtk_model_real_iter_n_children (GtkTreeModel* base, GtkTreeIter* iter);
 
43
static gboolean sql_heavy_gtk_model_real_iter_next (GtkTreeModel* base, GtkTreeIter* iter);
 
44
static gboolean sql_heavy_gtk_model_real_iter_nth_child (GtkTreeModel* base, GtkTreeIter* iter, GtkTreeIter* parent, gint n);
 
45
static gboolean sql_heavy_gtk_model_real_iter_parent (GtkTreeModel* base, GtkTreeIter* iter, GtkTreeIter* child);
 
46
static void sql_heavy_gtk_model_real_ref_node (SQLHeavyGtkModel* self, GtkTreeIter* iter);
 
47
static void sql_heavy_gtk_model_real_unref_node (SQLHeavyGtkModel* self, GtkTreeIter* iter);
 
48
static void sql_heavy_gtk_model_finalize (GObject* obj);
 
49
static void _vala_sql_heavy_gtk_model_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
50
static void _vala_sql_heavy_gtk_model_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
51
 
 
52
 
 
53
static gpointer _g_object_ref0 (gpointer self) {
 
54
        return self ? g_object_ref (self) : NULL;
 
55
}
 
56
 
 
57
 
 
58
static SQLHeavyRow* sql_heavy_gtk_model_get_row_from_iter (SQLHeavyGtkModel* self, GtkTreeIter* iter) {
 
59
        SQLHeavyRow* result = NULL;
 
60
        GError * _inner_error_ = NULL;
 
61
        g_return_val_if_fail (self != NULL, NULL);
 
62
        if ((*iter).user_data != NULL) {
 
63
                SQLHeavyRow* _tmp0_;
 
64
                _tmp0_ = _g_object_ref0 (SQL_HEAVY_ROW ((*iter).user_data));
 
65
                result = _tmp0_;
 
66
                return result;
 
67
        } else {
 
68
                SQLHeavyTable* _tmp1_ = NULL;
 
69
                SQLHeavyRow* _tmp2_ = NULL;
 
70
                SQLHeavyRow* row;
 
71
                _tmp1_ = sql_heavy_gtk_model_get_table (self);
 
72
                _tmp2_ = sql_heavy_table_get (_tmp1_, (gint64) (*iter).stamp, &_inner_error_);
 
73
                row = _tmp2_;
 
74
                if (_inner_error_ != NULL) {
 
75
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
76
                                goto __catch0_sql_heavy_error;
 
77
                        }
 
78
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
79
                        g_clear_error (&_inner_error_);
 
80
                        return NULL;
 
81
                }
 
82
                (*iter).user_data = row;
 
83
                g_object_ref ((GObject*) row);
 
84
                result = row;
 
85
                return result;
 
86
                _g_object_unref0 (row);
 
87
                goto __finally0;
 
88
                __catch0_sql_heavy_error:
 
89
                {
 
90
                        GError * e;
 
91
                        e = _inner_error_;
 
92
                        _inner_error_ = NULL;
 
93
                        g_critical ("sqlheavy-gtk-model.vala:36: Unable to get row from iterator: %s", e->message);
 
94
                        result = NULL;
 
95
                        _g_error_free0 (e);
 
96
                        return result;
 
97
                }
 
98
                __finally0:
 
99
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
100
                g_clear_error (&_inner_error_);
 
101
                return NULL;
 
102
        }
 
103
}
 
104
 
 
105
 
 
106
static GType sql_heavy_gtk_model_real_get_column_type (GtkTreeModel* base, gint index) {
 
107
        SQLHeavyGtkModel * self;
 
108
        GType result = 0UL;
 
109
        GError * _inner_error_ = NULL;
 
110
        self = (SQLHeavyGtkModel*) base;
 
111
        if (index == 0) {
 
112
                result = G_TYPE_INT64;
 
113
                return result;
 
114
        } else {
 
115
                SQLHeavyTable* _tmp0_ = NULL;
 
116
                GType _tmp1_;
 
117
                GType _tmp2_;
 
118
                _tmp0_ = sql_heavy_gtk_model_get_table (self);
 
119
                _tmp1_ = sql_heavy_table_field_affinity_type (_tmp0_, index - 1, &_inner_error_);
 
120
                _tmp2_ = _tmp1_;
 
121
                if (_inner_error_ != NULL) {
 
122
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
123
                                goto __catch1_sql_heavy_error;
 
124
                        }
 
125
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
126
                        g_clear_error (&_inner_error_);
 
127
                        return 0UL;
 
128
                }
 
129
                result = _tmp2_;
 
130
                return result;
 
131
        }
 
132
        goto __finally1;
 
133
        __catch1_sql_heavy_error:
 
134
        {
 
135
                GError * e;
 
136
                e = _inner_error_;
 
137
                _inner_error_ = NULL;
 
138
                g_critical ("sqlheavy-gtk-model.vala:51: Unable to determine column affinity (colum" \
 
139
"n #%d): %s", index, e->message);
 
140
                result = G_TYPE_NONE;
 
141
                _g_error_free0 (e);
 
142
                return result;
 
143
        }
 
144
        __finally1:
 
145
        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
146
        g_clear_error (&_inner_error_);
 
147
        return 0UL;
 
148
}
 
149
 
 
150
 
 
151
static GtkTreeModelFlags sql_heavy_gtk_model_real_get_flags (GtkTreeModel* base) {
 
152
        SQLHeavyGtkModel * self;
 
153
        GtkTreeModelFlags result = 0;
 
154
        self = (SQLHeavyGtkModel*) base;
 
155
        result = GTK_TREE_MODEL_LIST_ONLY;
 
156
        return result;
 
157
}
 
158
 
 
159
 
 
160
static const gchar* string_to_string (const gchar* self) {
 
161
        const gchar* result = NULL;
 
162
        g_return_val_if_fail (self != NULL, NULL);
 
163
        result = self;
 
164
        return result;
 
165
}
 
166
 
 
167
 
 
168
static gboolean sql_heavy_gtk_model_real_get_iter (GtkTreeModel* base, GtkTreeIter* iter, GtkTreePath* path) {
 
169
        SQLHeavyGtkModel * self;
 
170
        GtkTreeIter _iter = {0};
 
171
        gboolean result = FALSE;
 
172
        gint64 offset;
 
173
        gint* _tmp0_ = NULL;
 
174
        gint* indices;
 
175
        gint indices_length1;
 
176
        gint _indices_size_;
 
177
        SQLHeavyTable* _tmp1_ = NULL;
 
178
        const gchar* _tmp2_ = NULL;
 
179
        gchar* _tmp3_ = NULL;
 
180
        gchar* _tmp4_;
 
181
        const gchar* _tmp5_ = NULL;
 
182
        gchar* _tmp6_ = NULL;
 
183
        gchar* _tmp7_;
 
184
        gchar* _tmp8_ = NULL;
 
185
        gchar* _tmp9_;
 
186
        SQLHeavyQuery* _tmp10_ = NULL;
 
187
        SQLHeavyQuery* _tmp11_;
 
188
        SQLHeavyQuery* _tmp12_;
 
189
        SQLHeavyQuery* _tmp13_;
 
190
        SQLHeavyQueryResult* _tmp14_ = NULL;
 
191
        SQLHeavyQueryResult* _tmp15_;
 
192
        SQLHeavyQueryResult* res;
 
193
        gboolean _tmp16_;
 
194
        gint _tmp17_;
 
195
        gint _tmp18_;
 
196
        GError * _inner_error_ = NULL;
 
197
        self = (SQLHeavyGtkModel*) base;
 
198
        g_return_val_if_fail (path != NULL, FALSE);
 
199
        offset = (gint64) 0;
 
200
        _tmp0_ = gtk_tree_path_get_indices (path);
 
201
        indices = _tmp0_;
 
202
        indices_length1 = -1;
 
203
        _indices_size_ = -1;
 
204
        if (indices_length1 == (-1)) {
 
205
                offset = (gint64) 0;
 
206
        } else {
 
207
                if (indices_length1 == 1) {
 
208
                        offset = (gint64) indices[0];
 
209
                } else {
 
210
                        result = FALSE;
 
211
                        if (iter) {
 
212
                                *iter = _iter;
 
213
                        }
 
214
                        return result;
 
215
                }
 
216
        }
 
217
        _tmp1_ = sql_heavy_gtk_model_get_table (self);
 
218
        _tmp2_ = sql_heavy_table_get_name (_tmp1_);
 
219
        _tmp3_ = sql_heavy_escape_string (_tmp2_);
 
220
        _tmp4_ = _tmp3_;
 
221
        _tmp5_ = string_to_string (_tmp4_);
 
222
        _tmp6_ = g_strdup_printf ("%i", indices[0]);
 
223
        _tmp7_ = _tmp6_;
 
224
        _tmp8_ = g_strconcat ("SELECT `ROWID` FROM `", _tmp5_, "` ORDER BY `ROWID` ASC LIMIT ", _tmp7_, ",1;", NULL);
 
225
        _tmp9_ = _tmp8_;
 
226
        _tmp10_ = sql_heavy_queryable_prepare (self->priv->queryable, _tmp9_, &_inner_error_);
 
227
        _tmp11_ = _tmp10_;
 
228
        _g_free0 (_tmp9_);
 
229
        _g_free0 (_tmp7_);
 
230
        _g_free0 (_tmp4_);
 
231
        _tmp12_ = _tmp11_;
 
232
        if (_inner_error_ != NULL) {
 
233
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
234
                        goto __catch2_sql_heavy_error;
 
235
                }
 
236
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
237
                g_clear_error (&_inner_error_);
 
238
                return FALSE;
 
239
        }
 
240
        _tmp13_ = _tmp12_;
 
241
        _tmp14_ = sql_heavy_query_execute (_tmp13_, NULL, &_inner_error_, NULL);
 
242
        _tmp15_ = _tmp14_;
 
243
        _g_object_unref0 (_tmp13_);
 
244
        res = _tmp15_;
 
245
        if (_inner_error_ != NULL) {
 
246
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
247
                        goto __catch2_sql_heavy_error;
 
248
                }
 
249
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
250
                g_clear_error (&_inner_error_);
 
251
                return FALSE;
 
252
        }
 
253
        _tmp16_ = sql_heavy_query_result_get_finished (res);
 
254
        if (_tmp16_) {
 
255
                result = FALSE;
 
256
                _g_object_unref0 (res);
 
257
                if (iter) {
 
258
                        *iter = _iter;
 
259
                }
 
260
                return result;
 
261
        }
 
262
        _tmp17_ = sql_heavy_record_fetch_int ((SQLHeavyRecord*) res, 0, &_inner_error_);
 
263
        _tmp18_ = _tmp17_;
 
264
        if (_inner_error_ != NULL) {
 
265
                _g_object_unref0 (res);
 
266
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
267
                        goto __catch2_sql_heavy_error;
 
268
                }
 
269
                _g_object_unref0 (res);
 
270
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
271
                g_clear_error (&_inner_error_);
 
272
                return FALSE;
 
273
        }
 
274
        _iter.stamp = _tmp18_;
 
275
        result = TRUE;
 
276
        _g_object_unref0 (res);
 
277
        if (iter) {
 
278
                *iter = _iter;
 
279
        }
 
280
        return result;
 
281
        _g_object_unref0 (res);
 
282
        goto __finally2;
 
283
        __catch2_sql_heavy_error:
 
284
        {
 
285
                GError * e;
 
286
                e = _inner_error_;
 
287
                _inner_error_ = NULL;
 
288
                g_critical ("sqlheavy-gtk-model.vala:77: Unable to get row ID for iterator: %s", e->message);
 
289
                result = FALSE;
 
290
                _g_error_free0 (e);
 
291
                if (iter) {
 
292
                        *iter = _iter;
 
293
                }
 
294
                return result;
 
295
        }
 
296
        __finally2:
 
297
        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
298
        g_clear_error (&_inner_error_);
 
299
        return FALSE;
 
300
}
 
301
 
 
302
 
 
303
static gint sql_heavy_gtk_model_real_get_n_columns (GtkTreeModel* base) {
 
304
        SQLHeavyGtkModel * self;
 
305
        gint result = 0;
 
306
        SQLHeavyTable* _tmp0_ = NULL;
 
307
        gint _tmp1_;
 
308
        self = (SQLHeavyGtkModel*) base;
 
309
        _tmp0_ = sql_heavy_gtk_model_get_table (self);
 
310
        _tmp1_ = sql_heavy_table_get_field_count (_tmp0_);
 
311
        result = _tmp1_ + 1;
 
312
        return result;
 
313
}
 
314
 
 
315
 
 
316
static GtkTreePath* sql_heavy_gtk_model_real_get_path (GtkTreeModel* base, GtkTreeIter* iter) {
 
317
        SQLHeavyGtkModel * self;
 
318
        GtkTreePath* result = NULL;
 
319
        SQLHeavyTable* _tmp0_ = NULL;
 
320
        const gchar* _tmp1_ = NULL;
 
321
        gchar* _tmp2_ = NULL;
 
322
        gchar* _tmp3_;
 
323
        const gchar* _tmp4_ = NULL;
 
324
        gchar* _tmp5_ = NULL;
 
325
        gchar* _tmp6_;
 
326
        SQLHeavyQuery* _tmp7_ = NULL;
 
327
        SQLHeavyQuery* _tmp8_;
 
328
        SQLHeavyQuery* _tmp9_;
 
329
        SQLHeavyQuery* _tmp10_;
 
330
        SQLHeavyQueryResult* _tmp11_ = NULL;
 
331
        SQLHeavyQueryResult* _tmp12_;
 
332
        SQLHeavyQueryResult* res;
 
333
        gint _tmp13_;
 
334
        gint _tmp14_;
 
335
        GtkTreePath* _tmp15_ = NULL;
 
336
        GError * _inner_error_ = NULL;
 
337
        self = (SQLHeavyGtkModel*) base;
 
338
        _tmp0_ = sql_heavy_gtk_model_get_table (self);
 
339
        _tmp1_ = sql_heavy_table_get_name (_tmp0_);
 
340
        _tmp2_ = sql_heavy_escape_string (_tmp1_);
 
341
        _tmp3_ = _tmp2_;
 
342
        _tmp4_ = string_to_string (_tmp3_);
 
343
        _tmp5_ = g_strconcat ("SELECT COUNT(*) FROM `", _tmp4_, "` WHERE `ROWID` < :rid ORDER BY `ROWID` ASC LIMIT 1", NULL);
 
344
        _tmp6_ = _tmp5_;
 
345
        _tmp7_ = sql_heavy_queryable_prepare (self->priv->queryable, _tmp6_, &_inner_error_);
 
346
        _tmp8_ = _tmp7_;
 
347
        _g_free0 (_tmp6_);
 
348
        _g_free0 (_tmp3_);
 
349
        _tmp9_ = _tmp8_;
 
350
        if (_inner_error_ != NULL) {
 
351
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
352
                        goto __catch3_sql_heavy_error;
 
353
                }
 
354
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
355
                g_clear_error (&_inner_error_);
 
356
                return NULL;
 
357
        }
 
358
        _tmp10_ = _tmp9_;
 
359
        _tmp11_ = sql_heavy_query_execute (_tmp10_, ":rid", &_inner_error_, G_TYPE_INT, (*iter).stamp, NULL);
 
360
        _tmp12_ = _tmp11_;
 
361
        _g_object_unref0 (_tmp10_);
 
362
        res = _tmp12_;
 
363
        if (_inner_error_ != NULL) {
 
364
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
365
                        goto __catch3_sql_heavy_error;
 
366
                }
 
367
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
368
                g_clear_error (&_inner_error_);
 
369
                return NULL;
 
370
        }
 
371
        _tmp13_ = sql_heavy_record_fetch_int ((SQLHeavyRecord*) res, 0, &_inner_error_);
 
372
        _tmp14_ = _tmp13_;
 
373
        if (_inner_error_ != NULL) {
 
374
                _g_object_unref0 (res);
 
375
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
376
                        goto __catch3_sql_heavy_error;
 
377
                }
 
378
                _g_object_unref0 (res);
 
379
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
380
                g_clear_error (&_inner_error_);
 
381
                return NULL;
 
382
        }
 
383
        _tmp15_ = gtk_tree_path_new_from_indices (_tmp14_, -1);
 
384
        result = _tmp15_;
 
385
        _g_object_unref0 (res);
 
386
        return result;
 
387
        _g_object_unref0 (res);
 
388
        goto __finally3;
 
389
        __catch3_sql_heavy_error:
 
390
        {
 
391
                GError * e;
 
392
                e = _inner_error_;
 
393
                _inner_error_ = NULL;
 
394
                g_critical ("sqlheavy-gtk-model.vala:91: Unable to get path from iterator: %s", e->message);
 
395
                result = (gpointer) NULL;
 
396
                _g_error_free0 (e);
 
397
                return result;
 
398
        }
 
399
        __finally3:
 
400
        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
401
        g_clear_error (&_inner_error_);
 
402
        return NULL;
 
403
}
 
404
 
 
405
 
 
406
static void sql_heavy_gtk_model_real_get_value (GtkTreeModel* base, GtkTreeIter* iter, gint column, GValue* value) {
 
407
        SQLHeavyGtkModel * self;
 
408
        GValue _value = {0};
 
409
        SQLHeavyRow* _tmp0_ = NULL;
 
410
        SQLHeavyRow* row;
 
411
        GValue _tmp1_ = {0};
 
412
        GValue _tmp2_ = {0};
 
413
        GValue _tmp3_;
 
414
        gboolean _tmp4_;
 
415
        GError * _inner_error_ = NULL;
 
416
        self = (SQLHeavyGtkModel*) base;
 
417
        _tmp0_ = sql_heavy_gtk_model_get_row_from_iter (self, iter);
 
418
        row = _tmp0_;
 
419
        sql_heavy_record_fetch ((SQLHeavyRecord*) row, column - 1, &_tmp1_, &_inner_error_);
 
420
        _tmp2_ = _tmp1_;
 
421
        _tmp3_ = _tmp2_;
 
422
        if (_inner_error_ != NULL) {
 
423
                _g_object_unref0 (row);
 
424
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
425
                        goto __catch4_sql_heavy_error;
 
426
                }
 
427
                _g_object_unref0 (row);
 
428
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
429
                g_clear_error (&_inner_error_);
 
430
                return;
 
431
        }
 
432
        G_IS_VALUE (&_value) ? (g_value_unset (&_value), NULL) : NULL;
 
433
        _value = _tmp3_;
 
434
        _tmp4_ = G_VALUE_HOLDS (&_value, G_TYPE_POINTER);
 
435
        if (_tmp4_) {
 
436
                GValue _tmp5_ = {0};
 
437
                GValue _tmp6_ = {0};
 
438
                g_value_init (&_tmp5_, G_TYPE_STRING);
 
439
                _tmp6_ = _tmp5_;
 
440
                G_IS_VALUE (&_value) ? (g_value_unset (&_value), NULL) : NULL;
 
441
                _value = _tmp6_;
 
442
        }
 
443
        _g_object_unref0 (row);
 
444
        goto __finally4;
 
445
        __catch4_sql_heavy_error:
 
446
        {
 
447
                GError * e;
 
448
                e = _inner_error_;
 
449
                _inner_error_ = NULL;
 
450
                g_critical ("sqlheavy-gtk-model.vala:104: Unable to get value: %s", e->message);
 
451
                _g_error_free0 (e);
 
452
        }
 
453
        __finally4:
 
454
        if (_inner_error_ != NULL) {
 
455
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
456
                g_clear_error (&_inner_error_);
 
457
                return;
 
458
        }
 
459
        if (value) {
 
460
                *value = _value;
 
461
        } else {
 
462
                G_IS_VALUE (&_value) ? (g_value_unset (&_value), NULL) : NULL;
 
463
        }
 
464
}
 
465
 
 
466
 
 
467
static gboolean sql_heavy_gtk_model_real_iter_children (GtkTreeModel* base, GtkTreeIter* iter, GtkTreeIter* parent) {
 
468
        SQLHeavyGtkModel * self;
 
469
        GtkTreeIter _iter = {0};
 
470
        gboolean result = FALSE;
 
471
        self = (SQLHeavyGtkModel*) base;
 
472
        result = FALSE;
 
473
        if (iter) {
 
474
                *iter = _iter;
 
475
        }
 
476
        return result;
 
477
}
 
478
 
 
479
 
 
480
static gboolean sql_heavy_gtk_model_real_iter_has_child (GtkTreeModel* base, GtkTreeIter* iter) {
 
481
        SQLHeavyGtkModel * self;
 
482
        gboolean result = FALSE;
 
483
        self = (SQLHeavyGtkModel*) base;
 
484
        result = FALSE;
 
485
        return result;
 
486
}
 
487
 
 
488
 
 
489
static gint sql_heavy_gtk_model_real_iter_n_children (GtkTreeModel* base, GtkTreeIter* iter) {
 
490
        SQLHeavyGtkModel * self;
 
491
        gint result = 0;
 
492
        self = (SQLHeavyGtkModel*) base;
 
493
        result = 0;
 
494
        return result;
 
495
}
 
496
 
 
497
 
 
498
static gboolean sql_heavy_gtk_model_real_iter_next (GtkTreeModel* base, GtkTreeIter* iter) {
 
499
        SQLHeavyGtkModel * self;
 
500
        gboolean result = FALSE;
 
501
        SQLHeavyTable* _tmp0_ = NULL;
 
502
        const gchar* _tmp1_ = NULL;
 
503
        gchar* _tmp2_ = NULL;
 
504
        gchar* _tmp3_;
 
505
        const gchar* _tmp4_ = NULL;
 
506
        gchar* _tmp5_ = NULL;
 
507
        gchar* _tmp6_;
 
508
        gchar* _tmp7_ = NULL;
 
509
        gchar* _tmp8_;
 
510
        SQLHeavyQuery* _tmp9_ = NULL;
 
511
        SQLHeavyQuery* _tmp10_;
 
512
        SQLHeavyQuery* _tmp11_;
 
513
        SQLHeavyQuery* _tmp12_;
 
514
        SQLHeavyQueryResult* _tmp13_ = NULL;
 
515
        SQLHeavyQueryResult* _tmp14_;
 
516
        SQLHeavyQueryResult* res;
 
517
        gboolean _tmp15_;
 
518
        GError * _inner_error_ = NULL;
 
519
        self = (SQLHeavyGtkModel*) base;
 
520
        _tmp0_ = sql_heavy_gtk_model_get_table (self);
 
521
        _tmp1_ = sql_heavy_table_get_name (_tmp0_);
 
522
        _tmp2_ = sql_heavy_escape_string (_tmp1_);
 
523
        _tmp3_ = _tmp2_;
 
524
        _tmp4_ = string_to_string (_tmp3_);
 
525
        _tmp5_ = g_strdup_printf ("%i", (*iter).stamp);
 
526
        _tmp6_ = _tmp5_;
 
527
        _tmp7_ = g_strconcat ("SELECT `ROWID` FROM `", _tmp4_, "` WHERE `ROWID` > ", _tmp6_, " ORDER BY `ROWID` ASC LIMIT 1", NULL);
 
528
        _tmp8_ = _tmp7_;
 
529
        _tmp9_ = sql_heavy_queryable_prepare (self->priv->queryable, _tmp8_, &_inner_error_);
 
530
        _tmp10_ = _tmp9_;
 
531
        _g_free0 (_tmp8_);
 
532
        _g_free0 (_tmp6_);
 
533
        _g_free0 (_tmp3_);
 
534
        _tmp11_ = _tmp10_;
 
535
        if (_inner_error_ != NULL) {
 
536
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
537
                        goto __catch5_sql_heavy_error;
 
538
                }
 
539
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
540
                g_clear_error (&_inner_error_);
 
541
                return FALSE;
 
542
        }
 
543
        _tmp12_ = _tmp11_;
 
544
        _tmp13_ = sql_heavy_query_execute (_tmp12_, NULL, &_inner_error_, NULL);
 
545
        _tmp14_ = _tmp13_;
 
546
        _g_object_unref0 (_tmp12_);
 
547
        res = _tmp14_;
 
548
        if (_inner_error_ != NULL) {
 
549
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
550
                        goto __catch5_sql_heavy_error;
 
551
                }
 
552
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
553
                g_clear_error (&_inner_error_);
 
554
                return FALSE;
 
555
        }
 
556
        _tmp15_ = sql_heavy_query_result_get_finished (res);
 
557
        if (_tmp15_) {
 
558
                result = FALSE;
 
559
                _g_object_unref0 (res);
 
560
                return result;
 
561
        } else {
 
562
                gint _tmp16_;
 
563
                gint _tmp17_;
 
564
                _tmp16_ = sql_heavy_record_fetch_int ((SQLHeavyRecord*) res, 0, &_inner_error_);
 
565
                _tmp17_ = _tmp16_;
 
566
                if (_inner_error_ != NULL) {
 
567
                        _g_object_unref0 (res);
 
568
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
569
                                goto __catch5_sql_heavy_error;
 
570
                        }
 
571
                        _g_object_unref0 (res);
 
572
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
573
                        g_clear_error (&_inner_error_);
 
574
                        return FALSE;
 
575
                }
 
576
                (*iter).stamp = _tmp17_;
 
577
                (*iter).user_data = NULL;
 
578
                result = TRUE;
 
579
                _g_object_unref0 (res);
 
580
                return result;
 
581
        }
 
582
        _g_object_unref0 (res);
 
583
        goto __finally5;
 
584
        __catch5_sql_heavy_error:
 
585
        {
 
586
                GError * e;
 
587
                e = _inner_error_;
 
588
                _inner_error_ = NULL;
 
589
                g_critical ("sqlheavy-gtk-model.vala:133: Unable to determine next row id: %s", e->message);
 
590
                result = FALSE;
 
591
                _g_error_free0 (e);
 
592
                return result;
 
593
        }
 
594
        __finally5:
 
595
        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
596
        g_clear_error (&_inner_error_);
 
597
        return FALSE;
 
598
}
 
599
 
 
600
 
 
601
static gboolean sql_heavy_gtk_model_real_iter_nth_child (GtkTreeModel* base, GtkTreeIter* iter, GtkTreeIter* parent, gint n) {
 
602
        SQLHeavyGtkModel * self;
 
603
        GtkTreeIter _iter = {0};
 
604
        gboolean result = FALSE;
 
605
        self = (SQLHeavyGtkModel*) base;
 
606
        result = FALSE;
 
607
        if (iter) {
 
608
                *iter = _iter;
 
609
        }
 
610
        return result;
 
611
}
 
612
 
 
613
 
 
614
static gboolean sql_heavy_gtk_model_real_iter_parent (GtkTreeModel* base, GtkTreeIter* iter, GtkTreeIter* child) {
 
615
        SQLHeavyGtkModel * self;
 
616
        GtkTreeIter _iter = {0};
 
617
        gboolean result = FALSE;
 
618
        self = (SQLHeavyGtkModel*) base;
 
619
        result = FALSE;
 
620
        if (iter) {
 
621
                *iter = _iter;
 
622
        }
 
623
        return result;
 
624
}
 
625
 
 
626
 
 
627
static void sql_heavy_gtk_model_real_ref_node (SQLHeavyGtkModel* self, GtkTreeIter* iter) {
 
628
        g_return_if_fail (self != NULL);
 
629
        if ((*iter).user_data != NULL) {
 
630
                g_object_ref ((GObject*) SQL_HEAVY_ROW ((*iter).user_data));
 
631
        }
 
632
}
 
633
 
 
634
 
 
635
void sql_heavy_gtk_model_ref_node (SQLHeavyGtkModel* self, GtkTreeIter* iter) {
 
636
        SQL_HEAVY_GTK_MODEL_GET_CLASS (self)->ref_node (self, iter);
 
637
}
 
638
 
 
639
 
 
640
static void sql_heavy_gtk_model_real_unref_node (SQLHeavyGtkModel* self, GtkTreeIter* iter) {
 
641
        g_return_if_fail (self != NULL);
 
642
        if ((*iter).user_data != NULL) {
 
643
                g_object_unref ((GObject*) SQL_HEAVY_ROW ((*iter).user_data));
 
644
        }
 
645
}
 
646
 
 
647
 
 
648
void sql_heavy_gtk_model_unref_node (SQLHeavyGtkModel* self, GtkTreeIter* iter) {
 
649
        SQL_HEAVY_GTK_MODEL_GET_CLASS (self)->unref_node (self, iter);
 
650
}
 
651
 
 
652
 
 
653
/**
 
654
     * Create a new Model
 
655
     *
 
656
     * @param table the table this model is based on
 
657
     * @see table
 
658
     */
 
659
SQLHeavyGtkModel* sql_heavy_gtk_model_construct (GType object_type, SQLHeavyTable* table) {
 
660
        SQLHeavyGtkModel * self = NULL;
 
661
        g_return_val_if_fail (table != NULL, NULL);
 
662
        self = (SQLHeavyGtkModel*) g_object_new (object_type, "table", table, NULL);
 
663
        return self;
 
664
}
 
665
 
 
666
 
 
667
SQLHeavyGtkModel* sql_heavy_gtk_model_new (SQLHeavyTable* table) {
 
668
        return sql_heavy_gtk_model_construct (SQL_HEAVY_GTK_TYPE_MODEL, table);
 
669
}
 
670
 
 
671
 
 
672
SQLHeavyTable* sql_heavy_gtk_model_get_table (SQLHeavyGtkModel* self) {
 
673
        SQLHeavyTable* result;
 
674
        g_return_val_if_fail (self != NULL, NULL);
 
675
        result = self->priv->_table;
 
676
        return result;
 
677
}
 
678
 
 
679
 
 
680
static void sql_heavy_gtk_model_set_table (SQLHeavyGtkModel* self, SQLHeavyTable* value) {
 
681
        SQLHeavyTable* _tmp0_;
 
682
        SQLHeavyTable* _tmp1_ = NULL;
 
683
        SQLHeavyQueryable* _tmp2_ = NULL;
 
684
        SQLHeavyQueryable* _tmp3_;
 
685
        g_return_if_fail (self != NULL);
 
686
        _tmp0_ = _g_object_ref0 (value);
 
687
        _g_object_unref0 (self->priv->_table);
 
688
        self->priv->_table = _tmp0_;
 
689
        _tmp1_ = sql_heavy_gtk_model_get_table (self);
 
690
        _tmp2_ = sql_heavy_table_get_queryable (_tmp1_);
 
691
        _tmp3_ = _g_object_ref0 (_tmp2_);
 
692
        _g_object_unref0 (self->priv->queryable);
 
693
        self->priv->queryable = _tmp3_;
 
694
        g_object_notify ((GObject *) self, "table");
 
695
}
 
696
 
 
697
 
 
698
static void sql_heavy_gtk_model_class_init (SQLHeavyGtkModelClass * klass) {
 
699
        sql_heavy_gtk_model_parent_class = g_type_class_peek_parent (klass);
 
700
        g_type_class_add_private (klass, sizeof (SQLHeavyGtkModelPrivate));
 
701
        SQL_HEAVY_GTK_MODEL_CLASS (klass)->ref_node = sql_heavy_gtk_model_real_ref_node;
 
702
        SQL_HEAVY_GTK_MODEL_CLASS (klass)->unref_node = sql_heavy_gtk_model_real_unref_node;
 
703
        G_OBJECT_CLASS (klass)->get_property = _vala_sql_heavy_gtk_model_get_property;
 
704
        G_OBJECT_CLASS (klass)->set_property = _vala_sql_heavy_gtk_model_set_property;
 
705
        G_OBJECT_CLASS (klass)->finalize = sql_heavy_gtk_model_finalize;
 
706
        /**
 
707
             * The table that this model is based on
 
708
             */
 
709
        g_object_class_install_property (G_OBJECT_CLASS (klass), SQL_HEAVY_GTK_MODEL_TABLE, g_param_spec_object ("table", "table", "table", SQL_HEAVY_TYPE_TABLE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
 
710
}
 
711
 
 
712
 
 
713
static void sql_heavy_gtk_model_gtk_tree_model_interface_init (GtkTreeModelIface * iface) {
 
714
        sql_heavy_gtk_model_gtk_tree_model_parent_iface = g_type_interface_peek_parent (iface);
 
715
        iface->get_column_type = (GType (*)(GtkTreeModel* ,gint)) sql_heavy_gtk_model_real_get_column_type;
 
716
        iface->get_flags = (GtkTreeModelFlags (*)(GtkTreeModel*)) sql_heavy_gtk_model_real_get_flags;
 
717
        iface->get_iter = (gboolean (*)(GtkTreeModel* ,GtkTreeIter* ,GtkTreePath*)) sql_heavy_gtk_model_real_get_iter;
 
718
        iface->get_n_columns = (gint (*)(GtkTreeModel*)) sql_heavy_gtk_model_real_get_n_columns;
 
719
        iface->get_path = (GtkTreePath* (*)(GtkTreeModel* ,GtkTreeIter*)) sql_heavy_gtk_model_real_get_path;
 
720
        iface->get_value = (void (*)(GtkTreeModel* ,GtkTreeIter* ,gint ,GValue*)) sql_heavy_gtk_model_real_get_value;
 
721
        iface->iter_children = (gboolean (*)(GtkTreeModel* ,GtkTreeIter* ,GtkTreeIter*)) sql_heavy_gtk_model_real_iter_children;
 
722
        iface->iter_has_child = (gboolean (*)(GtkTreeModel* ,GtkTreeIter*)) sql_heavy_gtk_model_real_iter_has_child;
 
723
        iface->iter_n_children = (gint (*)(GtkTreeModel* ,GtkTreeIter*)) sql_heavy_gtk_model_real_iter_n_children;
 
724
        iface->iter_next = (gboolean (*)(GtkTreeModel* ,GtkTreeIter*)) sql_heavy_gtk_model_real_iter_next;
 
725
        iface->iter_nth_child = (gboolean (*)(GtkTreeModel* ,GtkTreeIter* ,GtkTreeIter* ,gint)) sql_heavy_gtk_model_real_iter_nth_child;
 
726
        iface->iter_parent = (gboolean (*)(GtkTreeModel* ,GtkTreeIter* ,GtkTreeIter*)) sql_heavy_gtk_model_real_iter_parent;
 
727
        iface->ref_node = (void (*)(GtkTreeModel* ,GtkTreeIter*)) sql_heavy_gtk_model_ref_node;
 
728
        iface->unref_node = (void (*)(GtkTreeModel* ,GtkTreeIter*)) sql_heavy_gtk_model_unref_node;
 
729
}
 
730
 
 
731
 
 
732
static void sql_heavy_gtk_model_instance_init (SQLHeavyGtkModel * self) {
 
733
        self->priv = SQL_HEAVY_GTK_MODEL_GET_PRIVATE (self);
 
734
        self->priv->get_value_calls = 0;
 
735
        self->priv->next_calls = 0;
 
736
}
 
737
 
 
738
 
 
739
static void sql_heavy_gtk_model_finalize (GObject* obj) {
 
740
        SQLHeavyGtkModel * self;
 
741
        self = SQL_HEAVY_GTK_MODEL (obj);
 
742
        _g_object_unref0 (self->priv->_table);
 
743
        _g_object_unref0 (self->priv->queryable);
 
744
        G_OBJECT_CLASS (sql_heavy_gtk_model_parent_class)->finalize (obj);
 
745
}
 
746
 
 
747
 
 
748
/**
 
749
   * Gtk.TreeModel implementation
 
750
   */
 
751
GType sql_heavy_gtk_model_get_type (void) {
 
752
        static volatile gsize sql_heavy_gtk_model_type_id__volatile = 0;
 
753
        if (g_once_init_enter (&sql_heavy_gtk_model_type_id__volatile)) {
 
754
                static const GTypeInfo g_define_type_info = { sizeof (SQLHeavyGtkModelClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) sql_heavy_gtk_model_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SQLHeavyGtkModel), 0, (GInstanceInitFunc) sql_heavy_gtk_model_instance_init, NULL };
 
755
                static const GInterfaceInfo gtk_tree_model_info = { (GInterfaceInitFunc) sql_heavy_gtk_model_gtk_tree_model_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
 
756
                GType sql_heavy_gtk_model_type_id;
 
757
                sql_heavy_gtk_model_type_id = g_type_register_static (G_TYPE_OBJECT, "SQLHeavyGtkModel", &g_define_type_info, 0);
 
758
                g_type_add_interface_static (sql_heavy_gtk_model_type_id, GTK_TYPE_TREE_MODEL, &gtk_tree_model_info);
 
759
                g_once_init_leave (&sql_heavy_gtk_model_type_id__volatile, sql_heavy_gtk_model_type_id);
 
760
        }
 
761
        return sql_heavy_gtk_model_type_id__volatile;
 
762
}
 
763
 
 
764
 
 
765
static void _vala_sql_heavy_gtk_model_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
766
        SQLHeavyGtkModel * self;
 
767
        self = SQL_HEAVY_GTK_MODEL (object);
 
768
        switch (property_id) {
 
769
                case SQL_HEAVY_GTK_MODEL_TABLE:
 
770
                g_value_set_object (value, sql_heavy_gtk_model_get_table (self));
 
771
                break;
 
772
                default:
 
773
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
774
                break;
 
775
        }
 
776
}
 
777
 
 
778
 
 
779
static void _vala_sql_heavy_gtk_model_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
780
        SQLHeavyGtkModel * self;
 
781
        self = SQL_HEAVY_GTK_MODEL (object);
 
782
        switch (property_id) {
 
783
                case SQL_HEAVY_GTK_MODEL_TABLE:
 
784
                sql_heavy_gtk_model_set_table (self, g_value_get_object (value));
 
785
                break;
 
786
                default:
 
787
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
788
                break;
 
789
        }
 
790
}
 
791
 
 
792
 
 
793