← Back to branch summary

~ubuntu-branches/debian/jessie/sqlheavy/jessie

« back to all changes in this revision

Viewing changes to examples/browser.c

  • Committer: Package Import Robot
  • Author(s): Devid Antonio Filoni
  • Date: 2012-05-17 09:47:17 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120517094717-ue17pqaud5tywjj5
Tags: 0.1.1-1
http://bugs.debian.org/663320
* New upstream release (Closes: #663320).
* Fix debug-package-should-be-priority-extra lintian warning.
* debian/control: switch to vala-0.16 in Build-Depends field.
* debian/libsqlheavy-dev.install, debian/libsqlheavygtk-dev.install:
  install files in vala-0.16 dir.
* Update libsqlheavy0.1-0.symbols.amd64 file.
* debian/rules: update override_dh_makeshlibs target.
* Bump Standards-Version to 3.9.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/browser.c
1
 
/* browser.c generated by valac 0.12.1, the Vala compiler
 
1
/* browser.c generated by valac 0.16.0, the Vala compiler
2
2
 * generated from browser.vala, do not modify */
3
3
 
4
4
 
28
28
 
29
29
gint _vala_main (gchar** args, int args_length1) {
30
30
        gint result = 0;
31
 
        SQLHeavyDatabase* _tmp0_ = NULL;
32
 
        SQLHeavyDatabase* db;
33
 
        GtkWindow* _tmp1_ = NULL;
34
 
        GtkWindow* window;
35
 
        SQLHeavyTable* _tmp2_ = NULL;
36
 
        SQLHeavyTable* table;
37
 
        SQLHeavyGtkModel* _tmp3_ = NULL;
38
 
        SQLHeavyGtkModel* model;
39
 
        GtkScrolledWindow* _tmp4_ = NULL;
40
 
        GtkScrolledWindow* scroll;
41
 
        GtkTreeView* _tmp5_ = NULL;
42
 
        GtkTreeView* view;
 
31
        gchar** _tmp0_;
 
32
        gint _tmp0__length1;
43
33
        GError * _inner_error_ = NULL;
44
34
        gtk_init (&args_length1, &args);
45
 
        if (args_length1 != 3) {
46
 
                fprintf (stderr, "Usage: %s database table\n", args[0]);
 
35
        _tmp0_ = args;
 
36
        _tmp0__length1 = args_length1;
 
37
        if (_tmp0__length1 != 3) {
 
38
                FILE* _tmp1_;
 
39
                gchar** _tmp2_;
 
40
                gint _tmp2__length1;
 
41
                const gchar* _tmp3_;
 
42
                _tmp1_ = stderr;
 
43
                _tmp2_ = args;
 
44
                _tmp2__length1 = args_length1;
 
45
                _tmp3_ = _tmp2_[0];
 
46
                fprintf (_tmp1_, "Usage: %s database table\n", _tmp3_);
47
47
                result = -1;
48
48
                return result;
49
49
        }
50
 
        _tmp0_ = sql_heavy_database_new (args[1], (SQL_HEAVY_FILE_MODE_READ | SQL_HEAVY_FILE_MODE_WRITE) | SQL_HEAVY_FILE_MODE_CREATE, &_inner_error_);
51
 
        db = _tmp0_;
52
 
        if (_inner_error_ != NULL) {
53
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
54
 
                        goto __catch0_sql_heavy_error;
55
 
                }
56
 
                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);
57
 
                g_clear_error (&_inner_error_);
58
 
                return 0;
59
 
        }
60
 
        _tmp1_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL);
61
 
        window = g_object_ref_sink (_tmp1_);
62
 
        gtk_window_set_title (window, "SQLHeavy Database Browser");
63
 
        g_signal_connect ((GtkObject*) window, "destroy", (GCallback) _gtk_main_quit_gtk_object_destroy, NULL);
64
 
        _tmp2_ = sql_heavy_database_get_table (db, args[2], &_inner_error_);
65
 
        table = _tmp2_;
66
 
        if (_inner_error_ != NULL) {
67
 
                _g_object_unref0 (window);
68
 
                _g_object_unref0 (db);
69
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
70
 
                        goto __catch0_sql_heavy_error;
71
 
                }
72
 
                _g_object_unref0 (window);
73
 
                _g_object_unref0 (db);
74
 
                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);
75
 
                g_clear_error (&_inner_error_);
76
 
                return 0;
77
 
        }
78
 
        _tmp3_ = sql_heavy_gtk_model_new (table);
79
 
        model = _tmp3_;
80
 
        _tmp4_ = (GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL);
81
 
        scroll = g_object_ref_sink (_tmp4_);
82
 
        gtk_container_add ((GtkContainer*) window, (GtkWidget*) scroll);
83
 
        _tmp5_ = (GtkTreeView*) gtk_tree_view_new_with_model ((GtkTreeModel*) model);
84
 
        view = g_object_ref_sink (_tmp5_);
85
 
        gtk_container_add ((GtkContainer*) scroll, (GtkWidget*) view);
86
50
        {
87
 
                gint i;
88
 
                i = 0;
 
51
                gchar** _tmp4_;
 
52
                gint _tmp4__length1;
 
53
                const gchar* _tmp5_;
 
54
                SQLHeavyDatabase* _tmp6_;
 
55
                SQLHeavyDatabase* db;
 
56
                GtkWindow* _tmp7_;
 
57
                GtkWindow* _tmp8_;
 
58
                GtkWindow* window;
 
59
                GtkWindow* _tmp9_;
 
60
                GtkWindow* _tmp10_;
 
61
                SQLHeavyDatabase* _tmp11_;
 
62
                gchar** _tmp12_;
 
63
                gint _tmp12__length1;
 
64
                const gchar* _tmp13_;
 
65
                SQLHeavyTable* _tmp14_ = NULL;
 
66
                SQLHeavyTable* table;
 
67
                SQLHeavyTable* _tmp15_;
 
68
                SQLHeavyGtkModel* _tmp16_;
 
69
                SQLHeavyGtkModel* model;
 
70
                GtkScrolledWindow* _tmp17_;
 
71
                GtkScrolledWindow* _tmp18_;
 
72
                GtkScrolledWindow* scroll;
 
73
                GtkWindow* _tmp19_;
 
74
                GtkScrolledWindow* _tmp20_;
 
75
                SQLHeavyGtkModel* _tmp21_;
 
76
                GtkTreeView* _tmp22_;
 
77
                GtkTreeView* _tmp23_;
 
78
                GtkTreeView* view;
 
79
                GtkScrolledWindow* _tmp24_;
 
80
                GtkTreeView* _tmp25_;
 
81
                GtkWindow* _tmp42_;
 
82
                _tmp4_ = args;
 
83
                _tmp4__length1 = args_length1;
 
84
                _tmp5_ = _tmp4_[1];
 
85
                _tmp6_ = sql_heavy_database_new (_tmp5_, (SQL_HEAVY_FILE_MODE_READ | SQL_HEAVY_FILE_MODE_WRITE) | SQL_HEAVY_FILE_MODE_CREATE, &_inner_error_);
 
86
                db = _tmp6_;
 
87
                if (_inner_error_ != NULL) {
 
88
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
89
                                goto __catch0_sql_heavy_error;
 
90
                        }
 
91
                        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);
 
92
                        g_clear_error (&_inner_error_);
 
93
                        return 0;
 
94
                }
 
95
                _tmp7_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
96
                _tmp8_ = g_object_ref_sink (_tmp7_);
 
97
                window = _tmp8_;
 
98
                _tmp9_ = window;
 
99
                gtk_window_set_title (_tmp9_, "SQLHeavy Database Browser");
 
100
                _tmp10_ = window;
 
101
                g_signal_connect ((GtkObject*) _tmp10_, "destroy", (GCallback) _gtk_main_quit_gtk_object_destroy, NULL);
 
102
                _tmp11_ = db;
 
103
                _tmp12_ = args;
 
104
                _tmp12__length1 = args_length1;
 
105
                _tmp13_ = _tmp12_[2];
 
106
                _tmp14_ = sql_heavy_database_get_table (_tmp11_, _tmp13_, &_inner_error_);
 
107
                table = _tmp14_;
 
108
                if (_inner_error_ != NULL) {
 
109
                        _g_object_unref0 (window);
 
110
                        _g_object_unref0 (db);
 
111
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
112
                                goto __catch0_sql_heavy_error;
 
113
                        }
 
114
                        _g_object_unref0 (window);
 
115
                        _g_object_unref0 (db);
 
116
                        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);
 
117
                        g_clear_error (&_inner_error_);
 
118
                        return 0;
 
119
                }
 
120
                _tmp15_ = table;
 
121
                _tmp16_ = sql_heavy_gtk_model_new (_tmp15_);
 
122
                model = _tmp16_;
 
123
                _tmp17_ = (GtkScrolledWindow*) gtk_scrolled_window_new (NULL, NULL);
 
124
                _tmp18_ = g_object_ref_sink (_tmp17_);
 
125
                scroll = _tmp18_;
 
126
                _tmp19_ = window;
 
127
                _tmp20_ = scroll;
 
128
                gtk_container_add ((GtkContainer*) _tmp19_, (GtkWidget*) _tmp20_);
 
129
                _tmp21_ = model;
 
130
                _tmp22_ = (GtkTreeView*) gtk_tree_view_new_with_model ((GtkTreeModel*) _tmp21_);
 
131
                _tmp23_ = g_object_ref_sink (_tmp22_);
 
132
                view = _tmp23_;
 
133
                _tmp24_ = scroll;
 
134
                _tmp25_ = view;
 
135
                gtk_container_add ((GtkContainer*) _tmp24_, (GtkWidget*) _tmp25_);
89
136
                {
90
 
                        gboolean _tmp6_;
91
 
                        _tmp6_ = TRUE;
92
 
                        while (TRUE) {
93
 
                                gint _tmp7_;
94
 
                                gchar* _tmp8_ = NULL;
95
 
                                gchar* _tmp9_;
96
 
                                gchar* _tmp10_;
97
 
                                GtkCellRendererText* _tmp11_ = NULL;
98
 
                                GtkCellRendererText* _tmp12_;
99
 
                                if (!_tmp6_) {
100
 
                                        i++;
101
 
                                }
102
 
                                _tmp6_ = FALSE;
103
 
                                _tmp7_ = sql_heavy_table_get_field_count (table);
104
 
                                if (!(i < _tmp7_)) {
105
 
                                        break;
106
 
                                }
107
 
                                _tmp8_ = sql_heavy_table_field_name (table, i, &_inner_error_);
108
 
                                _tmp9_ = _tmp8_;
109
 
                                if (_inner_error_ != NULL) {
110
 
                                        _g_object_unref0 (view);
111
 
                                        _g_object_unref0 (scroll);
112
 
                                        _g_object_unref0 (model);
113
 
                                        _g_object_unref0 (table);
114
 
                                        _g_object_unref0 (window);
115
 
                                        _g_object_unref0 (db);
116
 
                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
117
 
                                                goto __catch0_sql_heavy_error;
118
 
                                        }
119
 
                                        _g_object_unref0 (view);
120
 
                                        _g_object_unref0 (scroll);
121
 
                                        _g_object_unref0 (model);
122
 
                                        _g_object_unref0 (table);
123
 
                                        _g_object_unref0 (window);
124
 
                                        _g_object_unref0 (db);
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 0;
128
 
                                }
129
 
                                _tmp10_ = _tmp9_;
130
 
                                _tmp11_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
131
 
                                _tmp12_ = g_object_ref_sink (_tmp11_);
132
 
                                gtk_tree_view_insert_column_with_attributes (view, -1, _tmp10_, (GtkCellRenderer*) _tmp12_, "text", i + 1, NULL);
133
 
                                _g_object_unref0 (_tmp12_);
134
 
                                _g_free0 (_tmp10_);
 
137
                        gint i;
 
138
                        i = 0;
 
139
                        {
 
140
                                gboolean _tmp26_;
 
141
                                _tmp26_ = TRUE;
 
142
                                while (TRUE) {
 
143
                                        gboolean _tmp27_;
 
144
                                        gint _tmp29_;
 
145
                                        SQLHeavyTable* _tmp30_;
 
146
                                        gint _tmp31_;
 
147
                                        gint _tmp32_;
 
148
                                        SQLHeavyTable* _tmp33_;
 
149
                                        gint _tmp34_;
 
150
                                        gchar* _tmp35_ = NULL;
 
151
                                        gchar* _tmp36_;
 
152
                                        GtkTreeView* _tmp37_;
 
153
                                        gchar* _tmp38_;
 
154
                                        GtkCellRendererText* _tmp39_;
 
155
                                        GtkCellRendererText* _tmp40_;
 
156
                                        gint _tmp41_;
 
157
                                        _tmp27_ = _tmp26_;
 
158
                                        if (!_tmp27_) {
 
159
                                                gint _tmp28_;
 
160
                                                _tmp28_ = i;
 
161
                                                i = _tmp28_ + 1;
 
162
                                        }
 
163
                                        _tmp26_ = FALSE;
 
164
                                        _tmp29_ = i;
 
165
                                        _tmp30_ = table;
 
166
                                        _tmp31_ = sql_heavy_table_get_field_count (_tmp30_);
 
167
                                        _tmp32_ = _tmp31_;
 
168
                                        if (!(_tmp29_ < _tmp32_)) {
 
169
                                                break;
 
170
                                        }
 
171
                                        _tmp33_ = table;
 
172
                                        _tmp34_ = i;
 
173
                                        _tmp35_ = sql_heavy_table_field_name (_tmp33_, _tmp34_, &_inner_error_);
 
174
                                        _tmp36_ = _tmp35_;
 
175
                                        if (_inner_error_ != NULL) {
 
176
                                                _g_object_unref0 (view);
 
177
                                                _g_object_unref0 (scroll);
 
178
                                                _g_object_unref0 (model);
 
179
                                                _g_object_unref0 (table);
 
180
                                                _g_object_unref0 (window);
 
181
                                                _g_object_unref0 (db);
 
182
                                                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
183
                                                        goto __catch0_sql_heavy_error;
 
184
                                                }
 
185
                                                _g_object_unref0 (view);
 
186
                                                _g_object_unref0 (scroll);
 
187
                                                _g_object_unref0 (model);
 
188
                                                _g_object_unref0 (table);
 
189
                                                _g_object_unref0 (window);
 
190
                                                _g_object_unref0 (db);
 
191
                                                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);
 
192
                                                g_clear_error (&_inner_error_);
 
193
                                                return 0;
 
194
                                        }
 
195
                                        _tmp37_ = view;
 
196
                                        _tmp38_ = _tmp36_;
 
197
                                        _tmp39_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
 
198
                                        _tmp40_ = g_object_ref_sink (_tmp39_);
 
199
                                        _tmp41_ = i;
 
200
                                        gtk_tree_view_insert_column_with_attributes (_tmp37_, -1, _tmp38_, (GtkCellRenderer*) _tmp40_, "text", _tmp41_ + 1, NULL);
 
201
                                        _g_object_unref0 (_tmp40_);
 
202
                                        _g_free0 (_tmp38_);
 
203
                                }
135
204
                        }
136
205
                }
 
206
                _tmp42_ = window;
 
207
                gtk_widget_show_all ((GtkWidget*) _tmp42_);
 
208
                gtk_main ();
 
209
                _g_object_unref0 (view);
 
210
                _g_object_unref0 (scroll);
 
211
                _g_object_unref0 (model);
 
212
                _g_object_unref0 (table);
 
213
                _g_object_unref0 (window);
 
214
                _g_object_unref0 (db);
137
215
        }
138
 
        gtk_widget_show_all ((GtkWidget*) window);
139
 
        gtk_main ();
140
 
        _g_object_unref0 (view);
141
 
        _g_object_unref0 (scroll);
142
 
        _g_object_unref0 (model);
143
 
        _g_object_unref0 (table);
144
 
        _g_object_unref0 (window);
145
 
        _g_object_unref0 (db);
146
216
        goto __finally0;
147
217
        __catch0_sql_heavy_error:
148
218
        {
149
 
                GError * e;
 
219
                GError* e = NULL;
 
220
                const gchar* _tmp43_;
150
221
                e = _inner_error_;
151
222
                _inner_error_ = NULL;
152
 
                g_error ("browser.vala:32: %s", e->message);
 
223
                _tmp43_ = e->message;
 
224
                g_error ("browser.vala:32: %s", _tmp43_);
153
225
                _g_error_free0 (e);
154
226
        }
155
227
        __finally0: