← Back to branch summary

~ubuntu-branches/ubuntu/wily/baobab/wily

« back to all changes in this revision

Viewing changes to src/baobab-cellrenderers.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher
  • Date: 2012-11-05 18:19:47 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20121105181947-a5c9utsx2buosfmy
Tags: 3.6.2-0ubuntu1
https://launchpad.net/bugs/1020810
* New upstream version:
  - Minor tweaks to the UI
* debian/patches/baobab_about_segfault.patch: 
  - don't segfault when opening the about dialog (lp: #1020810)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/baobab-cellrenderers.c
1
1
/* baobab-cellrenderers.c generated by valac 0.17.4.2-5a035, the Vala compiler
2
2
 * generated from baobab-cellrenderers.vala, do not modify */
3
3
 
4
 
/* -*- indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
4
/* -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
5
5
/* Baobab - disk usage analyzer
6
6
 *
7
7
 * Copyright (C) 2012  Ryan Lortie <desrt@desrt.ca>
28
28
#include <math.h>
29
29
#include <stdlib.h>
30
30
#include <string.h>
31
 
#include <glib/gi18n-lib.h>
32
31
#include <cairo.h>
33
32
#include <gdk/gdk.h>
 
33
#include <glib/gi18n-lib.h>
34
34
 
35
35
 
36
36
#define BAOBAB_TYPE_CELL_RENDERER_PERCENT (baobab_cell_renderer_percent_get_type ())
43
43
typedef struct _BaobabCellRendererPercent BaobabCellRendererPercent;
44
44
typedef struct _BaobabCellRendererPercentClass BaobabCellRendererPercentClass;
45
45
typedef struct _BaobabCellRendererPercentPrivate BaobabCellRendererPercentPrivate;
 
46
 
 
47
#define BAOBAB_SCANNER_TYPE_STATE (baobab_scanner_state_get_type ())
46
48
#define _g_free0(var) (var = (g_free (var), NULL))
47
49
 
 
50
#define BAOBAB_TYPE_CELL_RENDERER_NAME (baobab_cell_renderer_name_get_type ())
 
51
#define BAOBAB_CELL_RENDERER_NAME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BAOBAB_TYPE_CELL_RENDERER_NAME, BaobabCellRendererName))
 
52
#define BAOBAB_CELL_RENDERER_NAME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), BAOBAB_TYPE_CELL_RENDERER_NAME, BaobabCellRendererNameClass))
 
53
#define BAOBAB_IS_CELL_RENDERER_NAME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BAOBAB_TYPE_CELL_RENDERER_NAME))
 
54
#define BAOBAB_IS_CELL_RENDERER_NAME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BAOBAB_TYPE_CELL_RENDERER_NAME))
 
55
#define BAOBAB_CELL_RENDERER_NAME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), BAOBAB_TYPE_CELL_RENDERER_NAME, BaobabCellRendererNameClass))
 
56
 
 
57
typedef struct _BaobabCellRendererName BaobabCellRendererName;
 
58
typedef struct _BaobabCellRendererNameClass BaobabCellRendererNameClass;
 
59
typedef struct _BaobabCellRendererNamePrivate BaobabCellRendererNamePrivate;
 
60
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
61
 
48
62
#define BAOBAB_TYPE_CELL_RENDERER_SIZE (baobab_cell_renderer_size_get_type ())
49
63
#define BAOBAB_CELL_RENDERER_SIZE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), BAOBAB_TYPE_CELL_RENDERER_SIZE, BaobabCellRendererSize))
50
64
#define BAOBAB_CELL_RENDERER_SIZE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), BAOBAB_TYPE_CELL_RENDERER_SIZE, BaobabCellRendererSizeClass))
77
91
typedef struct _BaobabCellRendererProgress BaobabCellRendererProgress;
78
92
typedef struct _BaobabCellRendererProgressClass BaobabCellRendererProgressClass;
79
93
typedef struct _BaobabCellRendererProgressPrivate BaobabCellRendererProgressPrivate;
80
 
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
81
94
 
82
95
struct _BaobabCellRendererPercent {
83
96
        GtkCellRendererText parent_instance;
88
101
        GtkCellRendererTextClass parent_class;
89
102
};
90
103
 
 
104
typedef enum  {
 
105
        BAOBAB_SCANNER_STATE_SCANNING,
 
106
        BAOBAB_SCANNER_STATE_CANCELLED,
 
107
        BAOBAB_SCANNER_STATE_NEED_PERCENT,
 
108
        BAOBAB_SCANNER_STATE_ERROR,
 
109
        BAOBAB_SCANNER_STATE_CHILD_ERROR,
 
110
        BAOBAB_SCANNER_STATE_DONE
 
111
} BaobabScannerState;
 
112
 
 
113
struct _BaobabCellRendererPercentPrivate {
 
114
        BaobabScannerState _state;
 
115
};
 
116
 
 
117
struct _BaobabCellRendererName {
 
118
        GtkCellRendererText parent_instance;
 
119
        BaobabCellRendererNamePrivate * priv;
 
120
};
 
121
 
 
122
struct _BaobabCellRendererNameClass {
 
123
        GtkCellRendererTextClass parent_class;
 
124
};
 
125
 
 
126
struct _BaobabCellRendererNamePrivate {
 
127
        BaobabScannerState _state;
 
128
};
 
129
 
91
130
struct _BaobabCellRendererSize {
92
131
        GtkCellRendererText parent_instance;
93
132
        BaobabCellRendererSizePrivate * priv;
98
137
};
99
138
 
100
139
struct _BaobabCellRendererSizePrivate {
 
140
        BaobabScannerState _state;
101
141
        gboolean _show_allocated_size;
102
142
};
103
143
 
110
150
        GtkCellRendererTextClass parent_class;
111
151
};
112
152
 
 
153
struct _BaobabCellRendererItemsPrivate {
 
154
        BaobabScannerState _state;
 
155
};
 
156
 
113
157
struct _BaobabCellRendererProgress {
114
158
        GtkCellRendererProgress parent_instance;
115
159
        BaobabCellRendererProgressPrivate * priv;
119
163
        GtkCellRendererProgressClass parent_class;
120
164
};
121
165
 
 
166
struct _BaobabCellRendererProgressPrivate {
 
167
        BaobabScannerState _state;
 
168
};
 
169
 
122
170
 
123
171
static gpointer baobab_cell_renderer_percent_parent_class = NULL;
 
172
static gpointer baobab_cell_renderer_name_parent_class = NULL;
124
173
static gpointer baobab_cell_renderer_size_parent_class = NULL;
125
174
static gpointer baobab_cell_renderer_items_parent_class = NULL;
126
175
static gpointer baobab_cell_renderer_progress_parent_class = NULL;
127
176
 
128
177
GType baobab_cell_renderer_percent_get_type (void) G_GNUC_CONST;
 
178
GType baobab_scanner_state_get_type (void) G_GNUC_CONST;
 
179
#define BAOBAB_CELL_RENDERER_PERCENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BAOBAB_TYPE_CELL_RENDERER_PERCENT, BaobabCellRendererPercentPrivate))
129
180
enum  {
130
181
        BAOBAB_CELL_RENDERER_PERCENT_DUMMY_PROPERTY,
 
182
        BAOBAB_CELL_RENDERER_PERCENT_STATE,
131
183
        BAOBAB_CELL_RENDERER_PERCENT_PERCENT
132
184
};
133
185
BaobabCellRendererPercent* baobab_cell_renderer_percent_new (void);
134
186
BaobabCellRendererPercent* baobab_cell_renderer_percent_construct (GType object_type);
 
187
BaobabScannerState baobab_cell_renderer_percent_get_state (BaobabCellRendererPercent* self);
 
188
void baobab_cell_renderer_percent_set_state (BaobabCellRendererPercent* self, BaobabScannerState value);
135
189
void baobab_cell_renderer_percent_set_percent (BaobabCellRendererPercent* self, gdouble value);
 
190
static void baobab_cell_renderer_percent_finalize (GObject* obj);
 
191
static void _vala_baobab_cell_renderer_percent_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
136
192
static void _vala_baobab_cell_renderer_percent_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 
193
GType baobab_cell_renderer_name_get_type (void) G_GNUC_CONST;
 
194
#define BAOBAB_CELL_RENDERER_NAME_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BAOBAB_TYPE_CELL_RENDERER_NAME, BaobabCellRendererNamePrivate))
 
195
enum  {
 
196
        BAOBAB_CELL_RENDERER_NAME_DUMMY_PROPERTY,
 
197
        BAOBAB_CELL_RENDERER_NAME_STATE,
 
198
        BAOBAB_CELL_RENDERER_NAME_NAME
 
199
};
 
200
static void baobab_cell_renderer_name_real_render (GtkCellRenderer* base, cairo_t* cr, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags);
 
201
BaobabScannerState baobab_cell_renderer_name_get_state (BaobabCellRendererName* self);
 
202
BaobabCellRendererName* baobab_cell_renderer_name_new (void);
 
203
BaobabCellRendererName* baobab_cell_renderer_name_construct (GType object_type);
 
204
void baobab_cell_renderer_name_set_state (BaobabCellRendererName* self, BaobabScannerState value);
 
205
void baobab_cell_renderer_name_set_name (BaobabCellRendererName* self, const gchar* value);
 
206
static void baobab_cell_renderer_name_finalize (GObject* obj);
 
207
static void _vala_baobab_cell_renderer_name_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
208
static void _vala_baobab_cell_renderer_name_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
137
209
GType baobab_cell_renderer_size_get_type (void) G_GNUC_CONST;
138
210
#define BAOBAB_CELL_RENDERER_SIZE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BAOBAB_TYPE_CELL_RENDERER_SIZE, BaobabCellRendererSizePrivate))
139
211
enum  {
140
212
        BAOBAB_CELL_RENDERER_SIZE_DUMMY_PROPERTY,
 
213
        BAOBAB_CELL_RENDERER_SIZE_STATE,
141
214
        BAOBAB_CELL_RENDERER_SIZE_SIZE,
142
215
        BAOBAB_CELL_RENDERER_SIZE_ALLOC_SIZE,
143
216
        BAOBAB_CELL_RENDERER_SIZE_SHOW_ALLOCATED_SIZE
144
217
};
145
218
BaobabCellRendererSize* baobab_cell_renderer_size_new (void);
146
219
BaobabCellRendererSize* baobab_cell_renderer_size_construct (GType object_type);
 
220
BaobabScannerState baobab_cell_renderer_size_get_state (BaobabCellRendererSize* self);
 
221
void baobab_cell_renderer_size_set_state (BaobabCellRendererSize* self, BaobabScannerState value);
147
222
void baobab_cell_renderer_size_set_size (BaobabCellRendererSize* self, guint64 value);
148
223
static gboolean baobab_cell_renderer_size_get_show_allocated_size (BaobabCellRendererSize* self);
149
224
void baobab_cell_renderer_size_set_alloc_size (BaobabCellRendererSize* self, guint64 value);
152
227
static void _vala_baobab_cell_renderer_size_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
153
228
static void _vala_baobab_cell_renderer_size_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
154
229
GType baobab_cell_renderer_items_get_type (void) G_GNUC_CONST;
 
230
#define BAOBAB_CELL_RENDERER_ITEMS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BAOBAB_TYPE_CELL_RENDERER_ITEMS, BaobabCellRendererItemsPrivate))
155
231
enum  {
156
232
        BAOBAB_CELL_RENDERER_ITEMS_DUMMY_PROPERTY,
 
233
        BAOBAB_CELL_RENDERER_ITEMS_STATE,
157
234
        BAOBAB_CELL_RENDERER_ITEMS_ITEMS
158
235
};
159
236
BaobabCellRendererItems* baobab_cell_renderer_items_new (void);
160
237
BaobabCellRendererItems* baobab_cell_renderer_items_construct (GType object_type);
 
238
BaobabScannerState baobab_cell_renderer_items_get_state (BaobabCellRendererItems* self);
 
239
void baobab_cell_renderer_items_set_state (BaobabCellRendererItems* self, BaobabScannerState value);
161
240
void baobab_cell_renderer_items_set_items (BaobabCellRendererItems* self, gint value);
 
241
static void baobab_cell_renderer_items_finalize (GObject* obj);
 
242
static void _vala_baobab_cell_renderer_items_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
162
243
static void _vala_baobab_cell_renderer_items_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
163
244
GType baobab_cell_renderer_progress_get_type (void) G_GNUC_CONST;
 
245
#define BAOBAB_CELL_RENDERER_PROGRESS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), BAOBAB_TYPE_CELL_RENDERER_PROGRESS, BaobabCellRendererProgressPrivate))
164
246
enum  {
165
 
        BAOBAB_CELL_RENDERER_PROGRESS_DUMMY_PROPERTY
 
247
        BAOBAB_CELL_RENDERER_PROGRESS_DUMMY_PROPERTY,
 
248
        BAOBAB_CELL_RENDERER_PROGRESS_STATE
166
249
};
167
250
static void baobab_cell_renderer_progress_real_render (GtkCellRenderer* base, cairo_t* cr, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags);
 
251
BaobabScannerState baobab_cell_renderer_progress_get_state (BaobabCellRendererProgress* self);
168
252
BaobabCellRendererProgress* baobab_cell_renderer_progress_new (void);
169
253
BaobabCellRendererProgress* baobab_cell_renderer_progress_construct (GType object_type);
 
254
void baobab_cell_renderer_progress_set_state (BaobabCellRendererProgress* self, BaobabScannerState value);
 
255
static void baobab_cell_renderer_progress_finalize (GObject* obj);
 
256
static void _vala_baobab_cell_renderer_progress_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
257
static void _vala_baobab_cell_renderer_progress_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
170
258
 
171
259
 
172
260
BaobabCellRendererPercent* baobab_cell_renderer_percent_construct (GType object_type) {
181
269
}
182
270
 
183
271
 
 
272
BaobabScannerState baobab_cell_renderer_percent_get_state (BaobabCellRendererPercent* self) {
 
273
        BaobabScannerState result;
 
274
        BaobabScannerState _tmp0_;
 
275
        g_return_val_if_fail (self != NULL, 0);
 
276
        _tmp0_ = self->priv->_state;
 
277
        result = _tmp0_;
 
278
        return result;
 
279
}
 
280
 
 
281
 
 
282
void baobab_cell_renderer_percent_set_state (BaobabCellRendererPercent* self, BaobabScannerState value) {
 
283
        BaobabScannerState _tmp0_;
 
284
        g_return_if_fail (self != NULL);
 
285
        _tmp0_ = value;
 
286
        self->priv->_state = _tmp0_;
 
287
        g_object_notify ((GObject *) self, "state");
 
288
}
 
289
 
 
290
 
184
291
void baobab_cell_renderer_percent_set_percent (BaobabCellRendererPercent* self, gdouble value) {
185
 
        gdouble _tmp0_;
186
 
        gchar* _tmp1_ = NULL;
187
 
        gchar* _tmp2_;
 
292
        gchar* _tmp0_ = NULL;
 
293
        BaobabScannerState _tmp1_;
 
294
        const gchar* _tmp5_;
188
295
        g_return_if_fail (self != NULL);
189
 
        _tmp0_ = value;
190
 
        _tmp1_ = g_strdup_printf ("%.1f %%", _tmp0_);
191
 
        _tmp2_ = _tmp1_;
192
 
        g_object_set ((GtkCellRendererText*) self, "text", _tmp2_, NULL);
193
 
        _g_free0 (_tmp2_);
 
296
        _tmp1_ = self->priv->_state;
 
297
        if (_tmp1_ != BAOBAB_SCANNER_STATE_ERROR) {
 
298
                gdouble _tmp2_;
 
299
                gchar* _tmp3_ = NULL;
 
300
                _tmp2_ = value;
 
301
                _tmp3_ = g_strdup_printf ("%.1f %%", _tmp2_);
 
302
                _g_free0 (_tmp0_);
 
303
                _tmp0_ = _tmp3_;
 
304
        } else {
 
305
                gchar* _tmp4_;
 
306
                _tmp4_ = g_strdup ("");
 
307
                _g_free0 (_tmp0_);
 
308
                _tmp0_ = _tmp4_;
 
309
        }
 
310
        _tmp5_ = _tmp0_;
 
311
        g_object_set ((GtkCellRendererText*) self, "text", _tmp5_, NULL);
 
312
        _g_free0 (_tmp0_);
194
313
        g_object_notify ((GObject *) self, "percent");
195
314
}
196
315
 
197
316
 
198
317
static void baobab_cell_renderer_percent_class_init (BaobabCellRendererPercentClass * klass) {
199
318
        baobab_cell_renderer_percent_parent_class = g_type_class_peek_parent (klass);
 
319
        g_type_class_add_private (klass, sizeof (BaobabCellRendererPercentPrivate));
 
320
        G_OBJECT_CLASS (klass)->get_property = _vala_baobab_cell_renderer_percent_get_property;
200
321
        G_OBJECT_CLASS (klass)->set_property = _vala_baobab_cell_renderer_percent_set_property;
 
322
        G_OBJECT_CLASS (klass)->finalize = baobab_cell_renderer_percent_finalize;
 
323
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_PERCENT_STATE, g_param_spec_enum ("state", "state", "state", BAOBAB_SCANNER_TYPE_STATE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
201
324
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_PERCENT_PERCENT, g_param_spec_double ("percent", "percent", "percent", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE));
202
325
}
203
326
 
204
327
 
205
328
static void baobab_cell_renderer_percent_instance_init (BaobabCellRendererPercent * self) {
 
329
        self->priv = BAOBAB_CELL_RENDERER_PERCENT_GET_PRIVATE (self);
 
330
}
 
331
 
 
332
 
 
333
static void baobab_cell_renderer_percent_finalize (GObject* obj) {
 
334
        BaobabCellRendererPercent * self;
 
335
        self = G_TYPE_CHECK_INSTANCE_CAST (obj, BAOBAB_TYPE_CELL_RENDERER_PERCENT, BaobabCellRendererPercent);
 
336
        G_OBJECT_CLASS (baobab_cell_renderer_percent_parent_class)->finalize (obj);
206
337
}
207
338
 
208
339
 
218
349
}
219
350
 
220
351
 
 
352
static void _vala_baobab_cell_renderer_percent_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
353
        BaobabCellRendererPercent * self;
 
354
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_PERCENT, BaobabCellRendererPercent);
 
355
        switch (property_id) {
 
356
                case BAOBAB_CELL_RENDERER_PERCENT_STATE:
 
357
                g_value_set_enum (value, baobab_cell_renderer_percent_get_state (self));
 
358
                break;
 
359
                default:
 
360
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
361
                break;
 
362
        }
 
363
}
 
364
 
 
365
 
221
366
static void _vala_baobab_cell_renderer_percent_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
222
367
        BaobabCellRendererPercent * self;
223
368
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_PERCENT, BaobabCellRendererPercent);
224
369
        switch (property_id) {
 
370
                case BAOBAB_CELL_RENDERER_PERCENT_STATE:
 
371
                baobab_cell_renderer_percent_set_state (self, g_value_get_enum (value));
 
372
                break;
225
373
                case BAOBAB_CELL_RENDERER_PERCENT_PERCENT:
226
374
                baobab_cell_renderer_percent_set_percent (self, g_value_get_double (value));
227
375
                break;
232
380
}
233
381
 
234
382
 
 
383
static gpointer _g_object_ref0 (gpointer self) {
 
384
        return self ? g_object_ref (self) : NULL;
 
385
}
 
386
 
 
387
 
 
388
static void baobab_cell_renderer_name_real_render (GtkCellRenderer* base, cairo_t* cr, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags) {
 
389
        BaobabCellRendererName * self;
 
390
        GtkWidget* _tmp0_;
 
391
        GtkStyleContext* _tmp1_ = NULL;
 
392
        GtkStyleContext* _tmp2_;
 
393
        GtkStyleContext* context;
 
394
        GtkStyleContext* _tmp3_;
 
395
        BaobabScannerState _tmp4_;
 
396
        cairo_t* _tmp7_;
 
397
        GtkWidget* _tmp8_;
 
398
        GdkRectangle _tmp9_;
 
399
        GdkRectangle _tmp10_;
 
400
        GtkCellRendererState _tmp11_;
 
401
        GtkStyleContext* _tmp12_;
 
402
        self = (BaobabCellRendererName*) base;
 
403
        g_return_if_fail (cr != NULL);
 
404
        g_return_if_fail (widget != NULL);
 
405
        g_return_if_fail (background_area != NULL);
 
406
        g_return_if_fail (cell_area != NULL);
 
407
        _tmp0_ = widget;
 
408
        _tmp1_ = gtk_widget_get_style_context (_tmp0_);
 
409
        _tmp2_ = _g_object_ref0 (_tmp1_);
 
410
        context = _tmp2_;
 
411
        _tmp3_ = context;
 
412
        gtk_style_context_save (_tmp3_);
 
413
        _tmp4_ = self->priv->_state;
 
414
        switch (_tmp4_) {
 
415
                case BAOBAB_SCANNER_STATE_ERROR:
 
416
                {
 
417
                        GtkStyleContext* _tmp5_;
 
418
                        _tmp5_ = context;
 
419
                        gtk_style_context_add_class (_tmp5_, "baobab-cell-error");
 
420
                        break;
 
421
                }
 
422
                case BAOBAB_SCANNER_STATE_CHILD_ERROR:
 
423
                {
 
424
                        GtkStyleContext* _tmp6_;
 
425
                        _tmp6_ = context;
 
426
                        gtk_style_context_add_class (_tmp6_, "baobab-cell-warning");
 
427
                        break;
 
428
                }
 
429
                default:
 
430
                break;
 
431
        }
 
432
        _tmp7_ = cr;
 
433
        _tmp8_ = widget;
 
434
        _tmp9_ = *background_area;
 
435
        _tmp10_ = *cell_area;
 
436
        _tmp11_ = flags;
 
437
        GTK_CELL_RENDERER_CLASS (baobab_cell_renderer_name_parent_class)->render ((GtkCellRenderer*) G_TYPE_CHECK_INSTANCE_CAST (self, GTK_TYPE_CELL_RENDERER_TEXT, GtkCellRendererText), _tmp7_, _tmp8_, &_tmp9_, &_tmp10_, _tmp11_);
 
438
        _tmp12_ = context;
 
439
        gtk_style_context_restore (_tmp12_);
 
440
        _g_object_unref0 (context);
 
441
}
 
442
 
 
443
 
 
444
BaobabCellRendererName* baobab_cell_renderer_name_construct (GType object_type) {
 
445
        BaobabCellRendererName * self = NULL;
 
446
        self = (BaobabCellRendererName*) g_object_new (object_type, NULL);
 
447
        return self;
 
448
}
 
449
 
 
450
 
 
451
BaobabCellRendererName* baobab_cell_renderer_name_new (void) {
 
452
        return baobab_cell_renderer_name_construct (BAOBAB_TYPE_CELL_RENDERER_NAME);
 
453
}
 
454
 
 
455
 
 
456
BaobabScannerState baobab_cell_renderer_name_get_state (BaobabCellRendererName* self) {
 
457
        BaobabScannerState result;
 
458
        BaobabScannerState _tmp0_;
 
459
        g_return_val_if_fail (self != NULL, 0);
 
460
        _tmp0_ = self->priv->_state;
 
461
        result = _tmp0_;
 
462
        return result;
 
463
}
 
464
 
 
465
 
 
466
void baobab_cell_renderer_name_set_state (BaobabCellRendererName* self, BaobabScannerState value) {
 
467
        BaobabScannerState _tmp0_;
 
468
        g_return_if_fail (self != NULL);
 
469
        _tmp0_ = value;
 
470
        self->priv->_state = _tmp0_;
 
471
        g_object_notify ((GObject *) self, "state");
 
472
}
 
473
 
 
474
 
 
475
void baobab_cell_renderer_name_set_name (BaobabCellRendererName* self, const gchar* value) {
 
476
        BaobabScannerState _tmp0_;
 
477
        g_return_if_fail (self != NULL);
 
478
        _tmp0_ = self->priv->_state;
 
479
        switch (_tmp0_) {
 
480
                case BAOBAB_SCANNER_STATE_ERROR:
 
481
                {
 
482
                        const gchar* _tmp1_;
 
483
                        gchar* _tmp2_ = NULL;
 
484
                        gchar* _tmp3_;
 
485
                        _tmp1_ = value;
 
486
                        _tmp2_ = g_strdup_printf ("<b>%s</b>", _tmp1_);
 
487
                        _tmp3_ = _tmp2_;
 
488
                        g_object_set ((GtkCellRendererText*) self, "markup", _tmp3_, NULL);
 
489
                        _g_free0 (_tmp3_);
 
490
                        break;
 
491
                }
 
492
                case BAOBAB_SCANNER_STATE_CHILD_ERROR:
 
493
                {
 
494
                        const gchar* _tmp4_;
 
495
                        gchar* _tmp5_ = NULL;
 
496
                        gchar* _tmp6_;
 
497
                        _tmp4_ = value;
 
498
                        _tmp5_ = g_strdup_printf ("<b>%s</b>", _tmp4_);
 
499
                        _tmp6_ = _tmp5_;
 
500
                        g_object_set ((GtkCellRendererText*) self, "markup", _tmp6_, NULL);
 
501
                        _g_free0 (_tmp6_);
 
502
                        break;
 
503
                }
 
504
                default:
 
505
                {
 
506
                        const gchar* _tmp7_;
 
507
                        _tmp7_ = value;
 
508
                        g_object_set ((GtkCellRendererText*) self, "markup", _tmp7_, NULL);
 
509
                        break;
 
510
                }
 
511
        }
 
512
        g_object_notify ((GObject *) self, "name");
 
513
}
 
514
 
 
515
 
 
516
static void baobab_cell_renderer_name_class_init (BaobabCellRendererNameClass * klass) {
 
517
        baobab_cell_renderer_name_parent_class = g_type_class_peek_parent (klass);
 
518
        g_type_class_add_private (klass, sizeof (BaobabCellRendererNamePrivate));
 
519
        GTK_CELL_RENDERER_CLASS (klass)->render = baobab_cell_renderer_name_real_render;
 
520
        G_OBJECT_CLASS (klass)->get_property = _vala_baobab_cell_renderer_name_get_property;
 
521
        G_OBJECT_CLASS (klass)->set_property = _vala_baobab_cell_renderer_name_set_property;
 
522
        G_OBJECT_CLASS (klass)->finalize = baobab_cell_renderer_name_finalize;
 
523
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_NAME_STATE, g_param_spec_enum ("state", "state", "state", BAOBAB_SCANNER_TYPE_STATE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
 
524
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_NAME_NAME, g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE));
 
525
}
 
526
 
 
527
 
 
528
static void baobab_cell_renderer_name_instance_init (BaobabCellRendererName * self) {
 
529
        self->priv = BAOBAB_CELL_RENDERER_NAME_GET_PRIVATE (self);
 
530
}
 
531
 
 
532
 
 
533
static void baobab_cell_renderer_name_finalize (GObject* obj) {
 
534
        BaobabCellRendererName * self;
 
535
        self = G_TYPE_CHECK_INSTANCE_CAST (obj, BAOBAB_TYPE_CELL_RENDERER_NAME, BaobabCellRendererName);
 
536
        G_OBJECT_CLASS (baobab_cell_renderer_name_parent_class)->finalize (obj);
 
537
}
 
538
 
 
539
 
 
540
GType baobab_cell_renderer_name_get_type (void) {
 
541
        static volatile gsize baobab_cell_renderer_name_type_id__volatile = 0;
 
542
        if (g_once_init_enter (&baobab_cell_renderer_name_type_id__volatile)) {
 
543
                static const GTypeInfo g_define_type_info = { sizeof (BaobabCellRendererNameClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) baobab_cell_renderer_name_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (BaobabCellRendererName), 0, (GInstanceInitFunc) baobab_cell_renderer_name_instance_init, NULL };
 
544
                GType baobab_cell_renderer_name_type_id;
 
545
                baobab_cell_renderer_name_type_id = g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT, "BaobabCellRendererName", &g_define_type_info, 0);
 
546
                g_once_init_leave (&baobab_cell_renderer_name_type_id__volatile, baobab_cell_renderer_name_type_id);
 
547
        }
 
548
        return baobab_cell_renderer_name_type_id__volatile;
 
549
}
 
550
 
 
551
 
 
552
static void _vala_baobab_cell_renderer_name_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
553
        BaobabCellRendererName * self;
 
554
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_NAME, BaobabCellRendererName);
 
555
        switch (property_id) {
 
556
                case BAOBAB_CELL_RENDERER_NAME_STATE:
 
557
                g_value_set_enum (value, baobab_cell_renderer_name_get_state (self));
 
558
                break;
 
559
                default:
 
560
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
561
                break;
 
562
        }
 
563
}
 
564
 
 
565
 
 
566
static void _vala_baobab_cell_renderer_name_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
567
        BaobabCellRendererName * self;
 
568
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_NAME, BaobabCellRendererName);
 
569
        switch (property_id) {
 
570
                case BAOBAB_CELL_RENDERER_NAME_STATE:
 
571
                baobab_cell_renderer_name_set_state (self, g_value_get_enum (value));
 
572
                break;
 
573
                case BAOBAB_CELL_RENDERER_NAME_NAME:
 
574
                baobab_cell_renderer_name_set_name (self, g_value_get_string (value));
 
575
                break;
 
576
                default:
 
577
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
578
                break;
 
579
        }
 
580
}
 
581
 
 
582
 
235
583
BaobabCellRendererSize* baobab_cell_renderer_size_construct (GType object_type) {
236
584
        BaobabCellRendererSize * self = NULL;
237
585
        self = (BaobabCellRendererSize*) g_object_new (object_type, NULL);
244
592
}
245
593
 
246
594
 
 
595
BaobabScannerState baobab_cell_renderer_size_get_state (BaobabCellRendererSize* self) {
 
596
        BaobabScannerState result;
 
597
        BaobabScannerState _tmp0_;
 
598
        g_return_val_if_fail (self != NULL, 0);
 
599
        _tmp0_ = self->priv->_state;
 
600
        result = _tmp0_;
 
601
        return result;
 
602
}
 
603
 
 
604
 
 
605
void baobab_cell_renderer_size_set_state (BaobabCellRendererSize* self, BaobabScannerState value) {
 
606
        BaobabScannerState _tmp0_;
 
607
        g_return_if_fail (self != NULL);
 
608
        _tmp0_ = value;
 
609
        self->priv->_state = _tmp0_;
 
610
        g_object_notify ((GObject *) self, "state");
 
611
}
 
612
 
 
613
 
247
614
void baobab_cell_renderer_size_set_size (BaobabCellRendererSize* self, guint64 value) {
248
615
        gboolean _tmp0_;
249
616
        g_return_if_fail (self != NULL);
250
617
        _tmp0_ = self->priv->_show_allocated_size;
251
618
        if (!_tmp0_) {
252
 
                guint64 _tmp1_;
253
 
                gchar* _tmp2_ = NULL;
254
 
                gchar* _tmp3_;
255
 
                _tmp1_ = value;
256
 
                _tmp2_ = g_format_size_full (_tmp1_, G_FORMAT_SIZE_DEFAULT);
257
 
                _tmp3_ = _tmp2_;
258
 
                g_object_set ((GtkCellRendererText*) self, "text", _tmp3_, NULL);
259
 
                _g_free0 (_tmp3_);
 
619
                gchar* _tmp1_ = NULL;
 
620
                BaobabScannerState _tmp2_;
 
621
                const gchar* _tmp6_;
 
622
                _tmp2_ = self->priv->_state;
 
623
                if (_tmp2_ != BAOBAB_SCANNER_STATE_ERROR) {
 
624
                        guint64 _tmp3_;
 
625
                        gchar* _tmp4_ = NULL;
 
626
                        _tmp3_ = value;
 
627
                        _tmp4_ = g_format_size_full (_tmp3_, G_FORMAT_SIZE_DEFAULT);
 
628
                        _g_free0 (_tmp1_);
 
629
                        _tmp1_ = _tmp4_;
 
630
                } else {
 
631
                        gchar* _tmp5_;
 
632
                        _tmp5_ = g_strdup ("");
 
633
                        _g_free0 (_tmp1_);
 
634
                        _tmp1_ = _tmp5_;
 
635
                }
 
636
                _tmp6_ = _tmp1_;
 
637
                g_object_set ((GtkCellRendererText*) self, "text", _tmp6_, NULL);
 
638
                _g_free0 (_tmp1_);
260
639
        }
261
640
        g_object_notify ((GObject *) self, "size");
262
641
}
267
646
        g_return_if_fail (self != NULL);
268
647
        _tmp0_ = self->priv->_show_allocated_size;
269
648
        if (_tmp0_) {
270
 
                guint64 _tmp1_;
271
 
                gchar* _tmp2_ = NULL;
272
 
                gchar* _tmp3_;
273
 
                _tmp1_ = value;
274
 
                _tmp2_ = g_format_size_full (_tmp1_, G_FORMAT_SIZE_DEFAULT);
275
 
                _tmp3_ = _tmp2_;
276
 
                g_object_set ((GtkCellRendererText*) self, "text", _tmp3_, NULL);
277
 
                _g_free0 (_tmp3_);
 
649
                gchar* _tmp1_ = NULL;
 
650
                BaobabScannerState _tmp2_;
 
651
                const gchar* _tmp6_;
 
652
                _tmp2_ = self->priv->_state;
 
653
                if (_tmp2_ != BAOBAB_SCANNER_STATE_ERROR) {
 
654
                        guint64 _tmp3_;
 
655
                        gchar* _tmp4_ = NULL;
 
656
                        _tmp3_ = value;
 
657
                        _tmp4_ = g_format_size_full (_tmp3_, G_FORMAT_SIZE_DEFAULT);
 
658
                        _g_free0 (_tmp1_);
 
659
                        _tmp1_ = _tmp4_;
 
660
                } else {
 
661
                        gchar* _tmp5_;
 
662
                        _tmp5_ = g_strdup ("");
 
663
                        _g_free0 (_tmp1_);
 
664
                        _tmp1_ = _tmp5_;
 
665
                }
 
666
                _tmp6_ = _tmp1_;
 
667
                g_object_set ((GtkCellRendererText*) self, "text", _tmp6_, NULL);
 
668
                _g_free0 (_tmp1_);
278
669
        }
279
670
        g_object_notify ((GObject *) self, "alloc-size");
280
671
}
305
696
        G_OBJECT_CLASS (klass)->get_property = _vala_baobab_cell_renderer_size_get_property;
306
697
        G_OBJECT_CLASS (klass)->set_property = _vala_baobab_cell_renderer_size_set_property;
307
698
        G_OBJECT_CLASS (klass)->finalize = baobab_cell_renderer_size_finalize;
 
699
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_SIZE_STATE, g_param_spec_enum ("state", "state", "state", BAOBAB_SCANNER_TYPE_STATE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
308
700
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_SIZE_SIZE, g_param_spec_uint64 ("size", "size", "size", 0, G_MAXUINT64, 0U, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE));
309
701
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_SIZE_ALLOC_SIZE, g_param_spec_uint64 ("alloc-size", "alloc-size", "alloc-size", 0, G_MAXUINT64, 0U, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE));
310
702
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_SIZE_SHOW_ALLOCATED_SIZE, g_param_spec_boolean ("show-allocated-size", "show-allocated-size", "show-allocated-size", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE));
339
731
        BaobabCellRendererSize * self;
340
732
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_SIZE, BaobabCellRendererSize);
341
733
        switch (property_id) {
 
734
                case BAOBAB_CELL_RENDERER_SIZE_STATE:
 
735
                g_value_set_enum (value, baobab_cell_renderer_size_get_state (self));
 
736
                break;
342
737
                case BAOBAB_CELL_RENDERER_SIZE_SHOW_ALLOCATED_SIZE:
343
738
                g_value_set_boolean (value, baobab_cell_renderer_size_get_show_allocated_size (self));
344
739
                break;
353
748
        BaobabCellRendererSize * self;
354
749
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_SIZE, BaobabCellRendererSize);
355
750
        switch (property_id) {
 
751
                case BAOBAB_CELL_RENDERER_SIZE_STATE:
 
752
                baobab_cell_renderer_size_set_state (self, g_value_get_enum (value));
 
753
                break;
356
754
                case BAOBAB_CELL_RENDERER_SIZE_SIZE:
357
755
                baobab_cell_renderer_size_set_size (self, g_value_get_uint64 (value));
358
756
                break;
381
779
}
382
780
 
383
781
 
 
782
BaobabScannerState baobab_cell_renderer_items_get_state (BaobabCellRendererItems* self) {
 
783
        BaobabScannerState result;
 
784
        BaobabScannerState _tmp0_;
 
785
        g_return_val_if_fail (self != NULL, 0);
 
786
        _tmp0_ = self->priv->_state;
 
787
        result = _tmp0_;
 
788
        return result;
 
789
}
 
790
 
 
791
 
 
792
void baobab_cell_renderer_items_set_state (BaobabCellRendererItems* self, BaobabScannerState value) {
 
793
        BaobabScannerState _tmp0_;
 
794
        g_return_if_fail (self != NULL);
 
795
        _tmp0_ = value;
 
796
        self->priv->_state = _tmp0_;
 
797
        g_object_notify ((GObject *) self, "state");
 
798
}
 
799
 
 
800
 
384
801
void baobab_cell_renderer_items_set_items (BaobabCellRendererItems* self, gint value) {
385
802
        gchar* _tmp0_ = NULL;
386
 
        gint _tmp1_;
387
 
        const gchar* _tmp7_;
 
803
        gboolean _tmp1_ = FALSE;
 
804
        gint _tmp2_;
 
805
        gboolean _tmp4_;
 
806
        const gchar* _tmp10_;
388
807
        g_return_if_fail (self != NULL);
389
 
        _tmp1_ = value;
390
 
        if (_tmp1_ >= 0) {
391
 
                gint _tmp2_;
392
 
                const gchar* _tmp3_ = NULL;
393
 
                gint _tmp4_;
394
 
                gchar* _tmp5_ = NULL;
395
 
                _tmp2_ = value;
396
 
                _tmp3_ = ngettext ("%d item", "%d items", (gulong) _tmp2_);
397
 
                _tmp4_ = value;
398
 
                _tmp5_ = g_strdup_printf (_tmp3_, _tmp4_);
399
 
                _g_free0 (_tmp0_);
400
 
                _tmp0_ = _tmp5_;
401
 
        } else {
402
 
                gchar* _tmp6_;
403
 
                _tmp6_ = g_strdup ("");
404
 
                _g_free0 (_tmp0_);
405
 
                _tmp0_ = _tmp6_;
406
 
        }
407
 
        _tmp7_ = _tmp0_;
408
 
        g_object_set ((GtkCellRendererText*) self, "text", _tmp7_, NULL);
 
808
        _tmp2_ = value;
 
809
        if (_tmp2_ >= 0) {
 
810
                BaobabScannerState _tmp3_;
 
811
                _tmp3_ = self->priv->_state;
 
812
                _tmp1_ = _tmp3_ != BAOBAB_SCANNER_STATE_ERROR;
 
813
        } else {
 
814
                _tmp1_ = FALSE;
 
815
        }
 
816
        _tmp4_ = _tmp1_;
 
817
        if (_tmp4_) {
 
818
                gint _tmp5_;
 
819
                const gchar* _tmp6_ = NULL;
 
820
                gint _tmp7_;
 
821
                gchar* _tmp8_ = NULL;
 
822
                _tmp5_ = value;
 
823
                _tmp6_ = ngettext ("%d item", "%d items", (gulong) _tmp5_);
 
824
                _tmp7_ = value;
 
825
                _tmp8_ = g_strdup_printf (_tmp6_, _tmp7_);
 
826
                _g_free0 (_tmp0_);
 
827
                _tmp0_ = _tmp8_;
 
828
        } else {
 
829
                gchar* _tmp9_;
 
830
                _tmp9_ = g_strdup ("");
 
831
                _g_free0 (_tmp0_);
 
832
                _tmp0_ = _tmp9_;
 
833
        }
 
834
        _tmp10_ = _tmp0_;
 
835
        g_object_set ((GtkCellRendererText*) self, "text", _tmp10_, NULL);
409
836
        _g_free0 (_tmp0_);
410
837
        g_object_notify ((GObject *) self, "items");
411
838
}
413
840
 
414
841
static void baobab_cell_renderer_items_class_init (BaobabCellRendererItemsClass * klass) {
415
842
        baobab_cell_renderer_items_parent_class = g_type_class_peek_parent (klass);
 
843
        g_type_class_add_private (klass, sizeof (BaobabCellRendererItemsPrivate));
 
844
        G_OBJECT_CLASS (klass)->get_property = _vala_baobab_cell_renderer_items_get_property;
416
845
        G_OBJECT_CLASS (klass)->set_property = _vala_baobab_cell_renderer_items_set_property;
 
846
        G_OBJECT_CLASS (klass)->finalize = baobab_cell_renderer_items_finalize;
 
847
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_ITEMS_STATE, g_param_spec_enum ("state", "state", "state", BAOBAB_SCANNER_TYPE_STATE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
417
848
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_ITEMS_ITEMS, g_param_spec_int ("items", "items", "items", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE));
418
849
}
419
850
 
420
851
 
421
852
static void baobab_cell_renderer_items_instance_init (BaobabCellRendererItems * self) {
 
853
        self->priv = BAOBAB_CELL_RENDERER_ITEMS_GET_PRIVATE (self);
 
854
}
 
855
 
 
856
 
 
857
static void baobab_cell_renderer_items_finalize (GObject* obj) {
 
858
        BaobabCellRendererItems * self;
 
859
        self = G_TYPE_CHECK_INSTANCE_CAST (obj, BAOBAB_TYPE_CELL_RENDERER_ITEMS, BaobabCellRendererItems);
 
860
        G_OBJECT_CLASS (baobab_cell_renderer_items_parent_class)->finalize (obj);
422
861
}
423
862
 
424
863
 
434
873
}
435
874
 
436
875
 
 
876
static void _vala_baobab_cell_renderer_items_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
877
        BaobabCellRendererItems * self;
 
878
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_ITEMS, BaobabCellRendererItems);
 
879
        switch (property_id) {
 
880
                case BAOBAB_CELL_RENDERER_ITEMS_STATE:
 
881
                g_value_set_enum (value, baobab_cell_renderer_items_get_state (self));
 
882
                break;
 
883
                default:
 
884
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
885
                break;
 
886
        }
 
887
}
 
888
 
 
889
 
437
890
static void _vala_baobab_cell_renderer_items_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
438
891
        BaobabCellRendererItems * self;
439
892
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_ITEMS, BaobabCellRendererItems);
440
893
        switch (property_id) {
 
894
                case BAOBAB_CELL_RENDERER_ITEMS_STATE:
 
895
                baobab_cell_renderer_items_set_state (self, g_value_get_enum (value));
 
896
                break;
441
897
                case BAOBAB_CELL_RENDERER_ITEMS_ITEMS:
442
898
                baobab_cell_renderer_items_set_items (self, g_value_get_int (value));
443
899
                break;
448
904
}
449
905
 
450
906
 
451
 
static gpointer _g_object_ref0 (gpointer self) {
452
 
        return self ? g_object_ref (self) : NULL;
453
 
}
454
 
 
455
 
 
456
907
static void baobab_cell_renderer_progress_real_render (GtkCellRenderer* base, cairo_t* cr, GtkWidget* widget, GdkRectangle* background_area, GdkRectangle* cell_area, GtkCellRendererState flags) {
457
908
        BaobabCellRendererProgress * self;
 
909
        BaobabScannerState _tmp0_;
458
910
        gint xpad = 0;
459
911
        gint ypad = 0;
460
 
        gint _tmp0_ = 0;
461
912
        gint _tmp1_ = 0;
462
 
        GdkRectangle _tmp2_;
463
 
        gint _tmp3_;
 
913
        gint _tmp2_ = 0;
 
914
        GdkRectangle _tmp3_;
464
915
        gint _tmp4_;
 
916
        gint _tmp5_;
465
917
        gint x;
466
 
        GdkRectangle _tmp5_;
467
 
        gint _tmp6_;
 
918
        GdkRectangle _tmp6_;
468
919
        gint _tmp7_;
 
920
        gint _tmp8_;
469
921
        gint y;
470
 
        GdkRectangle _tmp8_;
471
 
        gint _tmp9_;
 
922
        GdkRectangle _tmp9_;
472
923
        gint _tmp10_;
 
924
        gint _tmp11_;
473
925
        gint w;
474
 
        GdkRectangle _tmp11_;
475
 
        gint _tmp12_;
 
926
        GdkRectangle _tmp12_;
476
927
        gint _tmp13_;
 
928
        gint _tmp14_;
477
929
        gint h;
478
 
        GtkWidget* _tmp14_;
479
 
        GtkStyleContext* _tmp15_ = NULL;
480
 
        GtkStyleContext* _tmp16_;
481
 
        GtkStyleContext* context;
 
930
        GtkWidget* _tmp15_;
 
931
        GtkStyleContext* _tmp16_ = NULL;
482
932
        GtkStyleContext* _tmp17_;
 
933
        GtkStyleContext* context;
483
934
        GtkStyleContext* _tmp18_;
484
935
        GtkStyleContext* _tmp19_;
485
 
        cairo_t* _tmp20_;
486
 
        gint _tmp21_;
 
936
        GtkStyleContext* _tmp20_;
 
937
        cairo_t* _tmp21_;
487
938
        gint _tmp22_;
488
939
        gint _tmp23_;
489
940
        gint _tmp24_;
490
 
        GtkStyleContext* _tmp25_;
491
 
        cairo_t* _tmp26_;
492
 
        gint _tmp27_;
 
941
        gint _tmp25_;
 
942
        GtkStyleContext* _tmp26_;
 
943
        cairo_t* _tmp27_;
493
944
        gint _tmp28_;
494
945
        gint _tmp29_;
495
946
        gint _tmp30_;
496
 
        GtkStyleContext* _tmp31_;
497
 
        GtkBorder _tmp32_ = {0};
 
947
        gint _tmp31_;
 
948
        GtkStyleContext* _tmp32_;
 
949
        GtkBorder _tmp33_ = {0};
498
950
        GtkBorder border;
499
 
        gint _tmp33_;
500
 
        GtkBorder _tmp34_;
501
 
        gint16 _tmp35_;
502
 
        gint _tmp36_;
503
 
        GtkBorder _tmp37_;
504
 
        gint16 _tmp38_;
505
 
        gint _tmp39_;
506
 
        GtkBorder _tmp40_;
507
 
        gint16 _tmp41_;
508
 
        GtkBorder _tmp42_;
509
 
        gint16 _tmp43_;
510
 
        gint _tmp44_;
511
 
        GtkBorder _tmp45_;
512
 
        gint16 _tmp46_;
513
 
        GtkBorder _tmp47_;
514
 
        gint16 _tmp48_;
515
 
        gint _tmp49_ = 0;
516
 
        gint _tmp50_;
 
951
        gint _tmp34_;
 
952
        GtkBorder _tmp35_;
 
953
        gint16 _tmp36_;
 
954
        gint _tmp37_;
 
955
        GtkBorder _tmp38_;
 
956
        gint16 _tmp39_;
 
957
        gint _tmp40_;
 
958
        GtkBorder _tmp41_;
 
959
        gint16 _tmp42_;
 
960
        GtkBorder _tmp43_;
 
961
        gint16 _tmp44_;
 
962
        gint _tmp45_;
 
963
        GtkBorder _tmp46_;
 
964
        gint16 _tmp47_;
 
965
        GtkBorder _tmp48_;
 
966
        gint16 _tmp49_;
 
967
        gint _tmp50_ = 0;
 
968
        gint _tmp51_;
517
969
        gint percent;
518
 
        gint _tmp51_;
519
970
        gint _tmp52_;
 
971
        gint _tmp53_;
520
972
        gint perc_w;
521
 
        gint _tmp53_;
 
973
        gint _tmp54_;
522
974
        gint x_bar;
523
 
        GtkWidget* _tmp54_;
524
 
        GtkTextDirection _tmp55_ = 0;
525
 
        cairo_t* _tmp59_;
526
 
        gint _tmp60_;
 
975
        GtkWidget* _tmp55_;
 
976
        GtkTextDirection _tmp56_ = 0;
 
977
        GtkStyleContext* _tmp60_;
527
978
        gint _tmp61_;
528
 
        gint _tmp62_;
529
 
        gint _tmp63_;
530
 
        gint _tmp64_;
531
 
        cairo_t* _tmp69_;
532
 
        GtkStyleContext* _tmp70_;
 
979
        GtkStyleContext* _tmp65_;
 
980
        cairo_t* _tmp66_;
 
981
        gint _tmp67_;
 
982
        gint _tmp68_;
 
983
        gint _tmp69_;
 
984
        gint _tmp70_;
 
985
        GtkStyleContext* _tmp71_;
533
986
        self = (BaobabCellRendererProgress*) base;
534
987
        g_return_if_fail (cr != NULL);
535
988
        g_return_if_fail (widget != NULL);
536
989
        g_return_if_fail (background_area != NULL);
537
990
        g_return_if_fail (cell_area != NULL);
538
 
        gtk_cell_renderer_get_padding ((GtkCellRenderer*) self, &_tmp0_, &_tmp1_);
539
 
        xpad = _tmp0_;
540
 
        ypad = _tmp1_;
541
 
        _tmp2_ = *cell_area;
542
 
        _tmp3_ = _tmp2_.x;
543
 
        _tmp4_ = xpad;
544
 
        x = _tmp3_ + _tmp4_;
545
 
        _tmp5_ = *cell_area;
546
 
        _tmp6_ = _tmp5_.y;
547
 
        _tmp7_ = ypad;
548
 
        y = _tmp6_ + _tmp7_;
549
 
        _tmp8_ = *cell_area;
550
 
        _tmp9_ = _tmp8_.width;
551
 
        _tmp10_ = xpad;
552
 
        w = _tmp9_ - (_tmp10_ * 2);
553
 
        _tmp11_ = *cell_area;
554
 
        _tmp12_ = _tmp11_.height;
555
 
        _tmp13_ = ypad;
556
 
        h = _tmp12_ - (_tmp13_ * 2);
557
 
        _tmp14_ = widget;
558
 
        _tmp15_ = gtk_widget_get_style_context (_tmp14_);
559
 
        _tmp16_ = _g_object_ref0 (_tmp15_);
560
 
        context = _tmp16_;
561
 
        _tmp17_ = context;
562
 
        gtk_style_context_save (_tmp17_);
 
991
        _tmp0_ = self->priv->_state;
 
992
        if (_tmp0_ == BAOBAB_SCANNER_STATE_ERROR) {
 
993
                return;
 
994
        }
 
995
        gtk_cell_renderer_get_padding ((GtkCellRenderer*) self, &_tmp1_, &_tmp2_);
 
996
        xpad = _tmp1_;
 
997
        ypad = _tmp2_;
 
998
        _tmp3_ = *cell_area;
 
999
        _tmp4_ = _tmp3_.x;
 
1000
        _tmp5_ = xpad;
 
1001
        x = _tmp4_ + _tmp5_;
 
1002
        _tmp6_ = *cell_area;
 
1003
        _tmp7_ = _tmp6_.y;
 
1004
        _tmp8_ = ypad;
 
1005
        y = _tmp7_ + _tmp8_;
 
1006
        _tmp9_ = *cell_area;
 
1007
        _tmp10_ = _tmp9_.width;
 
1008
        _tmp11_ = xpad;
 
1009
        w = _tmp10_ - (_tmp11_ * 2);
 
1010
        _tmp12_ = *cell_area;
 
1011
        _tmp13_ = _tmp12_.height;
 
1012
        _tmp14_ = ypad;
 
1013
        h = _tmp13_ - (_tmp14_ * 2);
 
1014
        _tmp15_ = widget;
 
1015
        _tmp16_ = gtk_widget_get_style_context (_tmp15_);
 
1016
        _tmp17_ = _g_object_ref0 (_tmp16_);
 
1017
        context = _tmp17_;
563
1018
        _tmp18_ = context;
564
 
        gtk_style_context_add_class (_tmp18_, "baobab-level-cell");
 
1019
        gtk_style_context_save (_tmp18_);
565
1020
        _tmp19_ = context;
566
 
        _tmp20_ = cr;
567
 
        _tmp21_ = x;
568
 
        _tmp22_ = y;
569
 
        _tmp23_ = w;
570
 
        _tmp24_ = h;
571
 
        gtk_render_background (_tmp19_, _tmp20_, (gdouble) _tmp21_, (gdouble) _tmp22_, (gdouble) _tmp23_, (gdouble) _tmp24_);
572
 
        _tmp25_ = context;
573
 
        _tmp26_ = cr;
574
 
        _tmp27_ = x;
575
 
        _tmp28_ = y;
576
 
        _tmp29_ = w;
577
 
        _tmp30_ = h;
578
 
        gtk_render_frame (_tmp25_, _tmp26_, (gdouble) _tmp27_, (gdouble) _tmp28_, (gdouble) _tmp29_, (gdouble) _tmp30_);
579
 
        _tmp31_ = context;
580
 
        gtk_style_context_get_border (_tmp31_, GTK_STATE_FLAG_NORMAL, &_tmp32_);
581
 
        border = _tmp32_;
582
 
        _tmp33_ = x;
583
 
        _tmp34_ = border;
584
 
        _tmp35_ = _tmp34_.left;
585
 
        x = _tmp33_ + _tmp35_;
586
 
        _tmp36_ = y;
587
 
        _tmp37_ = border;
588
 
        _tmp38_ = _tmp37_.top;
589
 
        y = _tmp36_ + _tmp38_;
590
 
        _tmp39_ = w;
591
 
        _tmp40_ = border;
592
 
        _tmp41_ = _tmp40_.left;
593
 
        _tmp42_ = border;
594
 
        _tmp43_ = _tmp42_.right;
595
 
        w = _tmp39_ - (_tmp41_ + _tmp43_);
596
 
        _tmp44_ = h;
597
 
        _tmp45_ = border;
598
 
        _tmp46_ = _tmp45_.top;
599
 
        _tmp47_ = border;
600
 
        _tmp48_ = _tmp47_.bottom;
601
 
        h = _tmp44_ - (_tmp46_ + _tmp48_);
602
 
        g_object_get ((GtkCellRendererProgress*) self, "value", &_tmp49_, NULL);
603
 
        _tmp50_ = _tmp49_;
604
 
        percent = _tmp50_;
605
 
        _tmp51_ = w;
606
 
        _tmp52_ = percent;
607
 
        perc_w = (_tmp51_ * _tmp52_) / 100;
608
 
        _tmp53_ = x;
609
 
        x_bar = _tmp53_;
610
 
        _tmp54_ = widget;
611
 
        _tmp55_ = gtk_widget_get_direction (_tmp54_);
612
 
        if (_tmp55_ == GTK_TEXT_DIR_RTL) {
613
 
                gint _tmp56_;
 
1021
        gtk_style_context_add_class (_tmp19_, "baobab-level-cell");
 
1022
        _tmp20_ = context;
 
1023
        _tmp21_ = cr;
 
1024
        _tmp22_ = x;
 
1025
        _tmp23_ = y;
 
1026
        _tmp24_ = w;
 
1027
        _tmp25_ = h;
 
1028
        gtk_render_background (_tmp20_, _tmp21_, (gdouble) _tmp22_, (gdouble) _tmp23_, (gdouble) _tmp24_, (gdouble) _tmp25_);
 
1029
        _tmp26_ = context;
 
1030
        _tmp27_ = cr;
 
1031
        _tmp28_ = x;
 
1032
        _tmp29_ = y;
 
1033
        _tmp30_ = w;
 
1034
        _tmp31_ = h;
 
1035
        gtk_render_frame (_tmp26_, _tmp27_, (gdouble) _tmp28_, (gdouble) _tmp29_, (gdouble) _tmp30_, (gdouble) _tmp31_);
 
1036
        _tmp32_ = context;
 
1037
        gtk_style_context_get_border (_tmp32_, GTK_STATE_FLAG_NORMAL, &_tmp33_);
 
1038
        border = _tmp33_;
 
1039
        _tmp34_ = x;
 
1040
        _tmp35_ = border;
 
1041
        _tmp36_ = _tmp35_.left;
 
1042
        x = _tmp34_ + _tmp36_;
 
1043
        _tmp37_ = y;
 
1044
        _tmp38_ = border;
 
1045
        _tmp39_ = _tmp38_.top;
 
1046
        y = _tmp37_ + _tmp39_;
 
1047
        _tmp40_ = w;
 
1048
        _tmp41_ = border;
 
1049
        _tmp42_ = _tmp41_.left;
 
1050
        _tmp43_ = border;
 
1051
        _tmp44_ = _tmp43_.right;
 
1052
        w = _tmp40_ - (_tmp42_ + _tmp44_);
 
1053
        _tmp45_ = h;
 
1054
        _tmp46_ = border;
 
1055
        _tmp47_ = _tmp46_.top;
 
1056
        _tmp48_ = border;
 
1057
        _tmp49_ = _tmp48_.bottom;
 
1058
        h = _tmp45_ - (_tmp47_ + _tmp49_);
 
1059
        g_object_get ((GtkCellRendererProgress*) self, "value", &_tmp50_, NULL);
 
1060
        _tmp51_ = _tmp50_;
 
1061
        percent = _tmp51_;
 
1062
        _tmp52_ = w;
 
1063
        _tmp53_ = percent;
 
1064
        perc_w = (_tmp52_ * _tmp53_) / 100;
 
1065
        _tmp54_ = x;
 
1066
        x_bar = _tmp54_;
 
1067
        _tmp55_ = widget;
 
1068
        _tmp56_ = gtk_widget_get_direction (_tmp55_);
 
1069
        if (_tmp56_ == GTK_TEXT_DIR_RTL) {
614
1070
                gint _tmp57_;
615
1071
                gint _tmp58_;
616
 
                _tmp56_ = x_bar;
617
 
                _tmp57_ = w;
618
 
                _tmp58_ = perc_w;
619
 
                x_bar = _tmp56_ + (_tmp57_ - _tmp58_);
 
1072
                gint _tmp59_;
 
1073
                _tmp57_ = x_bar;
 
1074
                _tmp58_ = w;
 
1075
                _tmp59_ = perc_w;
 
1076
                x_bar = _tmp57_ + (_tmp58_ - _tmp59_);
620
1077
        }
621
 
        _tmp59_ = cr;
622
 
        _tmp60_ = x_bar;
623
 
        _tmp61_ = y;
624
 
        _tmp62_ = perc_w;
625
 
        _tmp63_ = h;
626
 
        cairo_rectangle (_tmp59_, (gdouble) _tmp60_, (gdouble) _tmp61_, (gdouble) _tmp62_, (gdouble) _tmp63_);
627
 
        _tmp64_ = percent;
628
 
        if (_tmp64_ <= 33) {
629
 
                cairo_t* _tmp65_;
630
 
                _tmp65_ = cr;
631
 
                cairo_set_source_rgb (_tmp65_, 0x73 / 255.0, 0xd2 / 255.0, 0x16 / 255.0);
 
1078
        _tmp60_ = context;
 
1079
        gtk_style_context_add_class (_tmp60_, "fill-block");
 
1080
        _tmp61_ = percent;
 
1081
        if (_tmp61_ <= 33) {
 
1082
                GtkStyleContext* _tmp62_;
 
1083
                _tmp62_ = context;
 
1084
                gtk_style_context_add_class (_tmp62_, "level-low");
632
1085
        } else {
633
 
                gint _tmp66_;
634
 
                _tmp66_ = percent;
635
 
                if (_tmp66_ <= 66) {
636
 
                        cairo_t* _tmp67_;
637
 
                        _tmp67_ = cr;
638
 
                        cairo_set_source_rgb (_tmp67_, 0xed / 255.0, 0xd4 / 255.0, 0x00 / 255.0);
639
 
                } else {
640
 
                        cairo_t* _tmp68_;
641
 
                        _tmp68_ = cr;
642
 
                        cairo_set_source_rgb (_tmp68_, 0xcc / 255.0, 0x00 / 255.0, 0x00 / 255.0);
 
1086
                gint _tmp63_;
 
1087
                _tmp63_ = percent;
 
1088
                if (_tmp63_ > 66) {
 
1089
                        GtkStyleContext* _tmp64_;
 
1090
                        _tmp64_ = context;
 
1091
                        gtk_style_context_add_class (_tmp64_, "level-high");
643
1092
                }
644
1093
        }
645
 
        _tmp69_ = cr;
646
 
        cairo_fill (_tmp69_);
647
 
        _tmp70_ = context;
648
 
        gtk_style_context_restore (_tmp70_);
 
1094
        _tmp65_ = context;
 
1095
        _tmp66_ = cr;
 
1096
        _tmp67_ = x_bar;
 
1097
        _tmp68_ = y;
 
1098
        _tmp69_ = perc_w;
 
1099
        _tmp70_ = h;
 
1100
        gtk_render_background (_tmp65_, _tmp66_, (gdouble) _tmp67_, (gdouble) _tmp68_, (gdouble) _tmp69_, (gdouble) _tmp70_);
 
1101
        _tmp71_ = context;
 
1102
        gtk_style_context_restore (_tmp71_);
649
1103
        _g_object_unref0 (context);
650
1104
}
651
1105
 
662
1116
}
663
1117
 
664
1118
 
 
1119
BaobabScannerState baobab_cell_renderer_progress_get_state (BaobabCellRendererProgress* self) {
 
1120
        BaobabScannerState result;
 
1121
        BaobabScannerState _tmp0_;
 
1122
        g_return_val_if_fail (self != NULL, 0);
 
1123
        _tmp0_ = self->priv->_state;
 
1124
        result = _tmp0_;
 
1125
        return result;
 
1126
}
 
1127
 
 
1128
 
 
1129
void baobab_cell_renderer_progress_set_state (BaobabCellRendererProgress* self, BaobabScannerState value) {
 
1130
        BaobabScannerState _tmp0_;
 
1131
        g_return_if_fail (self != NULL);
 
1132
        _tmp0_ = value;
 
1133
        self->priv->_state = _tmp0_;
 
1134
        g_object_notify ((GObject *) self, "state");
 
1135
}
 
1136
 
 
1137
 
665
1138
static void baobab_cell_renderer_progress_class_init (BaobabCellRendererProgressClass * klass) {
666
1139
        baobab_cell_renderer_progress_parent_class = g_type_class_peek_parent (klass);
 
1140
        g_type_class_add_private (klass, sizeof (BaobabCellRendererProgressPrivate));
667
1141
        GTK_CELL_RENDERER_CLASS (klass)->render = baobab_cell_renderer_progress_real_render;
 
1142
        G_OBJECT_CLASS (klass)->get_property = _vala_baobab_cell_renderer_progress_get_property;
 
1143
        G_OBJECT_CLASS (klass)->set_property = _vala_baobab_cell_renderer_progress_set_property;
 
1144
        G_OBJECT_CLASS (klass)->finalize = baobab_cell_renderer_progress_finalize;
 
1145
        g_object_class_install_property (G_OBJECT_CLASS (klass), BAOBAB_CELL_RENDERER_PROGRESS_STATE, g_param_spec_enum ("state", "state", "state", BAOBAB_SCANNER_TYPE_STATE, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
668
1146
}
669
1147
 
670
1148
 
671
1149
static void baobab_cell_renderer_progress_instance_init (BaobabCellRendererProgress * self) {
 
1150
        self->priv = BAOBAB_CELL_RENDERER_PROGRESS_GET_PRIVATE (self);
 
1151
}
 
1152
 
 
1153
 
 
1154
static void baobab_cell_renderer_progress_finalize (GObject* obj) {
 
1155
        BaobabCellRendererProgress * self;
 
1156
        self = G_TYPE_CHECK_INSTANCE_CAST (obj, BAOBAB_TYPE_CELL_RENDERER_PROGRESS, BaobabCellRendererProgress);
 
1157
        G_OBJECT_CLASS (baobab_cell_renderer_progress_parent_class)->finalize (obj);
672
1158
}
673
1159
 
674
1160
 
684
1170
}
685
1171
 
686
1172
 
 
1173
static void _vala_baobab_cell_renderer_progress_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
1174
        BaobabCellRendererProgress * self;
 
1175
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_PROGRESS, BaobabCellRendererProgress);
 
1176
        switch (property_id) {
 
1177
                case BAOBAB_CELL_RENDERER_PROGRESS_STATE:
 
1178
                g_value_set_enum (value, baobab_cell_renderer_progress_get_state (self));
 
1179
                break;
 
1180
                default:
 
1181
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
1182
                break;
 
1183
        }
 
1184
}
 
1185
 
 
1186
 
 
1187
static void _vala_baobab_cell_renderer_progress_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
 
1188
        BaobabCellRendererProgress * self;
 
1189
        self = G_TYPE_CHECK_INSTANCE_CAST (object, BAOBAB_TYPE_CELL_RENDERER_PROGRESS, BaobabCellRendererProgress);
 
1190
        switch (property_id) {
 
1191
                case BAOBAB_CELL_RENDERER_PROGRESS_STATE:
 
1192
                baobab_cell_renderer_progress_set_state (self, g_value_get_enum (value));
 
1193
                break;
 
1194
                default:
 
1195
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
1196
                break;
 
1197
        }
 
1198
}
 
1199
 
 
1200
 
687
1201