← Back to branch summary

~ubuntu-branches/ubuntu/precise/gnome-games/precise-proposed

« back to all changes in this revision

Viewing changes to glchess/src/chess-view-2d.c

  • Committer: Package Import Robot
  • Author(s): Rodrigo Moya
  • Date: 2011-05-30 13:32:04 UTC
  • mfrom: (1.3.4)
  • mto: (163.1.3 precise)
  • mto: This revision was merged to the branch mainline in revision 143.
  • Revision ID: package-import@ubuntu.com-20110530133204-celaq1v1dsxc48q1
Tags: upstream-3.0.2
Import upstream version 3.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
glchess/src/chess-view-2d.c
 
1
/* chess-view-2d.c generated by valac 0.12.0, the Vala compiler
 
2
 * generated from chess-view-2d.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include <gtk/gtk.h>
 
8
#include <cairo.h>
 
9
#include <stdlib.h>
 
10
#include <string.h>
 
11
#include <gdk/gdk.h>
 
12
#include <math.h>
 
13
#include <float.h>
 
14
#include <librsvg/rsvg.h>
 
15
#include <config.h>
 
16
#include <stdio.h>
 
17
 
 
18
 
 
19
#define TYPE_CHESS_VIEW (chess_view_get_type ())
 
20
#define CHESS_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CHESS_VIEW, ChessView))
 
21
#define CHESS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CHESS_VIEW, ChessViewClass))
 
22
#define IS_CHESS_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CHESS_VIEW))
 
23
#define IS_CHESS_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CHESS_VIEW))
 
24
#define CHESS_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CHESS_VIEW, ChessViewClass))
 
25
 
 
26
typedef struct _ChessView ChessView;
 
27
typedef struct _ChessViewClass ChessViewClass;
 
28
typedef struct _ChessViewPrivate ChessViewPrivate;
 
29
 
 
30
#define TYPE_CHESS_VIEW2_D (chess_view2_d_get_type ())
 
31
#define CHESS_VIEW2_D(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CHESS_VIEW2_D, ChessView2D))
 
32
#define CHESS_VIEW2_D_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CHESS_VIEW2_D, ChessView2DClass))
 
33
#define IS_CHESS_VIEW2_D(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CHESS_VIEW2_D))
 
34
#define IS_CHESS_VIEW2_D_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CHESS_VIEW2_D))
 
35
#define CHESS_VIEW2_D_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CHESS_VIEW2_D, ChessView2DClass))
 
36
 
 
37
typedef struct _ChessView2D ChessView2D;
 
38
typedef struct _ChessView2DClass ChessView2DClass;
 
39
typedef struct _ChessView2DPrivate ChessView2DPrivate;
 
40
#define _cairo_surface_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_surface_destroy (var), NULL)))
 
41
#define _g_free0(var) (var = (g_free (var), NULL))
 
42
 
 
43
#define TYPE_CHESS_SCENE (chess_scene_get_type ())
 
44
#define CHESS_SCENE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CHESS_SCENE, ChessScene))
 
45
#define CHESS_SCENE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CHESS_SCENE, ChessSceneClass))
 
46
#define IS_CHESS_SCENE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CHESS_SCENE))
 
47
#define IS_CHESS_SCENE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CHESS_SCENE))
 
48
#define CHESS_SCENE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CHESS_SCENE, ChessSceneClass))
 
49
 
 
50
typedef struct _ChessScene ChessScene;
 
51
typedef struct _ChessSceneClass ChessSceneClass;
 
52
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
53
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
54
#define _cairo_destroy0(var) ((var == NULL) ? NULL : (var = (cairo_destroy (var), NULL)))
 
55
typedef struct _ChessScenePrivate ChessScenePrivate;
 
56
 
 
57
#define TYPE_CHESS_MODEL (chess_model_get_type ())
 
58
#define CHESS_MODEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CHESS_MODEL, ChessModel))
 
59
#define CHESS_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CHESS_MODEL, ChessModelClass))
 
60
#define IS_CHESS_MODEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CHESS_MODEL))
 
61
#define IS_CHESS_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CHESS_MODEL))
 
62
#define CHESS_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CHESS_MODEL, ChessModelClass))
 
63
 
 
64
typedef struct _ChessModel ChessModel;
 
65
typedef struct _ChessModelClass ChessModelClass;
 
66
typedef struct _ChessModelPrivate ChessModelPrivate;
 
67
 
 
68
#define TYPE_CHESS_PIECE (chess_piece_get_type ())
 
69
#define CHESS_PIECE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CHESS_PIECE, ChessPiece))
 
70
#define CHESS_PIECE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CHESS_PIECE, ChessPieceClass))
 
71
#define IS_CHESS_PIECE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CHESS_PIECE))
 
72
#define IS_CHESS_PIECE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CHESS_PIECE))
 
73
#define CHESS_PIECE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CHESS_PIECE, ChessPieceClass))
 
74
 
 
75
typedef struct _ChessPiece ChessPiece;
 
76
typedef struct _ChessPieceClass ChessPieceClass;
 
77
#define _chess_model_unref0(var) ((var == NULL) ? NULL : (var = (chess_model_unref (var), NULL)))
 
78
#define _chess_piece_unref0(var) ((var == NULL) ? NULL : (var = (chess_piece_unref (var), NULL)))
 
79
 
 
80
#define TYPE_COLOR (color_get_type ())
 
81
typedef struct _ChessPiecePrivate ChessPiecePrivate;
 
82
 
 
83
#define TYPE_CHESS_PLAYER (chess_player_get_type ())
 
84
#define CHESS_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CHESS_PLAYER, ChessPlayer))
 
85
#define CHESS_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CHESS_PLAYER, ChessPlayerClass))
 
86
#define IS_CHESS_PLAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CHESS_PLAYER))
 
87
#define IS_CHESS_PLAYER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CHESS_PLAYER))
 
88
#define CHESS_PLAYER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CHESS_PLAYER, ChessPlayerClass))
 
89
 
 
90
typedef struct _ChessPlayer ChessPlayer;
 
91
typedef struct _ChessPlayerClass ChessPlayerClass;
 
92
 
 
93
#define TYPE_PIECE_TYPE (piece_type_get_type ())
 
94
 
 
95
#define TYPE_CHESS_GAME (chess_game_get_type ())
 
96
#define CHESS_GAME(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CHESS_GAME, ChessGame))
 
97
#define CHESS_GAME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CHESS_GAME, ChessGameClass))
 
98
#define IS_CHESS_GAME(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CHESS_GAME))
 
99
#define IS_CHESS_GAME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CHESS_GAME))
 
100
#define CHESS_GAME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CHESS_GAME, ChessGameClass))
 
101
 
 
102
typedef struct _ChessGame ChessGame;
 
103
typedef struct _ChessGameClass ChessGameClass;
 
104
 
 
105
struct _ChessView {
 
106
        GtkDrawingArea parent_instance;
 
107
        ChessViewPrivate * priv;
 
108
};
 
109
 
 
110
struct _ChessViewClass {
 
111
        GtkDrawingAreaClass parent_class;
 
112
};
 
113
 
 
114
struct _ChessView2D {
 
115
        ChessView parent_instance;
 
116
        ChessView2DPrivate * priv;
 
117
};
 
118
 
 
119
struct _ChessView2DClass {
 
120
        ChessViewClass parent_class;
 
121
};
 
122
 
 
123
struct _ChessView2DPrivate {
 
124
        gint border;
 
125
        gint square_size;
 
126
        gint selected_square_size;
 
127
        cairo_surface_t* model_surface;
 
128
        cairo_surface_t* selected_model_surface;
 
129
        gchar* loaded_theme_name;
 
130
};
 
131
 
 
132
struct _ChessScene {
 
133
        GObject parent_instance;
 
134
        ChessScenePrivate * priv;
 
135
        GList* pieces;
 
136
        gboolean animating;
 
137
        gint selected_rank;
 
138
        gint selected_file;
 
139
};
 
140
 
 
141
struct _ChessSceneClass {
 
142
        GObjectClass parent_class;
 
143
};
 
144
 
 
145
struct _ChessModel {
 
146
        GTypeInstance parent_instance;
 
147
        volatile int ref_count;
 
148
        ChessModelPrivate * priv;
 
149
        ChessPiece* piece;
 
150
        gdouble x;
 
151
        gdouble y;
 
152
        gdouble target_x;
 
153
        gdouble target_y;
 
154
        gboolean under_threat;
 
155
        gboolean is_selected;
 
156
};
 
157
 
 
158
struct _ChessModelClass {
 
159
        GTypeClass parent_class;
 
160
        void (*finalize) (ChessModel *self);
 
161
};
 
162
 
 
163
typedef enum  {
 
164
        COLOR_WHITE,
 
165
        COLOR_BLACK
 
166
} Color;
 
167
 
 
168
typedef enum  {
 
169
        PIECE_TYPE_PAWN,
 
170
        PIECE_TYPE_ROOK,
 
171
        PIECE_TYPE_KNIGHT,
 
172
        PIECE_TYPE_BISHOP,
 
173
        PIECE_TYPE_QUEEN,
 
174
        PIECE_TYPE_KING
 
175
} PieceType;
 
176
 
 
177
struct _ChessPiece {
 
178
        GTypeInstance parent_instance;
 
179
        volatile int ref_count;
 
180
        ChessPiecePrivate * priv;
 
181
        ChessPlayer* player;
 
182
        PieceType type;
 
183
};
 
184
 
 
185
struct _ChessPieceClass {
 
186
        GTypeClass parent_class;
 
187
        void (*finalize) (ChessPiece *self);
 
188
};
 
189
 
 
190
 
 
191
static gpointer chess_view2_d_parent_class = NULL;
 
192
 
 
193
GType chess_view_get_type (void) G_GNUC_CONST;
 
194
GType chess_view2_d_get_type (void) G_GNUC_CONST;
 
195
#define CHESS_VIEW2_D_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_CHESS_VIEW2_D, ChessView2DPrivate))
 
196
enum  {
 
197
        CHESS_VIEW2_D_DUMMY_PROPERTY
 
198
};
 
199
ChessView2D* chess_view2_d_new (void);
 
200
ChessView2D* chess_view2_d_construct (GType object_type);
 
201
ChessView* chess_view_new (void);
 
202
ChessView* chess_view_construct (GType object_type);
 
203
static gboolean chess_view2_d_real_configure_event (GtkWidget* base, GdkEventConfigure* event);
 
204
static void chess_view2_d_render_piece (ChessView2D* self, cairo_t* c1, cairo_t* c2, const gchar* name, gint offset);
 
205
GType chess_scene_get_type (void) G_GNUC_CONST;
 
206
ChessScene* chess_view_get_scene (ChessView* self);
 
207
const gchar* chess_scene_get_theme_name (ChessScene* self);
 
208
static void chess_view2_d_load_theme (ChessView2D* self);
 
209
static gboolean chess_view2_d_real_draw (GtkWidget* base, cairo_t* c);
 
210
gdouble chess_scene_get_board_angle (ChessScene* self);
 
211
static gdouble chess_view2_d_get_border_size (ChessView2D* self);
 
212
gboolean chess_scene_get_show_numbering (ChessScene* self);
 
213
gpointer chess_model_ref (gpointer instance);
 
214
void chess_model_unref (gpointer instance);
 
215
GParamSpec* param_spec_chess_model (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 
216
void value_set_chess_model (GValue* value, gpointer v_object);
 
217
void value_take_chess_model (GValue* value, gpointer v_object);
 
218
gpointer value_get_chess_model (const GValue* value);
 
219
GType chess_model_get_type (void) G_GNUC_CONST;
 
220
gpointer chess_piece_ref (gpointer instance);
 
221
void chess_piece_unref (gpointer instance);
 
222
GParamSpec* param_spec_chess_piece (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 
223
void value_set_chess_piece (GValue* value, gpointer v_object);
 
224
void value_take_chess_piece (GValue* value, gpointer v_object);
 
225
gpointer value_get_chess_piece (const GValue* value);
 
226
GType chess_piece_get_type (void) G_GNUC_CONST;
 
227
gboolean chess_scene_get_show_move_hints (ChessScene* self);
 
228
static void chess_view2_d_draw_piece (ChessView2D* self, cairo_t* c, cairo_surface_t* surface, ChessPiece* piece, gdouble alpha);
 
229
gboolean chess_scene_can_move (ChessScene* self, gint rank, gint file);
 
230
ChessPiece* chess_scene_get_selected_piece (ChessScene* self);
 
231
const gchar* chess_scene_get_board_side (ChessScene* self);
 
232
GType color_get_type (void) G_GNUC_CONST;
 
233
Color chess_piece_get_color (ChessPiece* self);
 
234
GType chess_player_get_type (void) G_GNUC_CONST;
 
235
GType piece_type_get_type (void) G_GNUC_CONST;
 
236
static gboolean chess_view2_d_real_button_press_event (GtkWidget* base, GdkEventButton* event);
 
237
gpointer chess_game_ref (gpointer instance);
 
238
void chess_game_unref (gpointer instance);
 
239
GParamSpec* param_spec_chess_game (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 
240
void value_set_chess_game (GValue* value, gpointer v_object);
 
241
void value_take_chess_game (GValue* value, gpointer v_object);
 
242
gpointer value_get_chess_game (const GValue* value);
 
243
GType chess_game_get_type (void) G_GNUC_CONST;
 
244
ChessGame* chess_scene_get_game (ChessScene* self);
 
245
void chess_scene_select_square (ChessScene* self, gint file, gint rank);
 
246
static void chess_view2_d_finalize (GObject* obj);
 
247
static void _vala_chess_view2_d_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 
248
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
249
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 
250
 
 
251
 
 
252
ChessView2D* chess_view2_d_construct (GType object_type) {
 
253
        ChessView2D * self = NULL;
 
254
        self = (ChessView2D*) chess_view_construct (object_type);
 
255
        gtk_widget_add_events ((GtkWidget*) self, (gint) GDK_BUTTON_PRESS_MASK);
 
256
        return self;
 
257
}
 
258
 
 
259
 
 
260
ChessView2D* chess_view2_d_new (void) {
 
261
        return chess_view2_d_construct (TYPE_CHESS_VIEW2_D);
 
262
}
 
263
 
 
264
 
 
265
static gboolean chess_view2_d_real_configure_event (GtkWidget* base, GdkEventConfigure* event) {
 
266
        ChessView2D * self;
 
267
        gboolean result = FALSE;
 
268
        gint _tmp0_;
 
269
        gint _tmp1_;
 
270
        gint _tmp2_;
 
271
        gint short_edge;
 
272
        gdouble _tmp3_;
 
273
        gdouble extra;
 
274
        self = (ChessView2D*) base;
 
275
        _tmp0_ = gtk_widget_get_allocated_width ((GtkWidget*) self);
 
276
        _tmp1_ = gtk_widget_get_allocated_height ((GtkWidget*) self);
 
277
        _tmp2_ = MIN (_tmp0_, _tmp1_);
 
278
        short_edge = _tmp2_;
 
279
        _tmp3_ = floor ((short_edge - (2 * self->priv->border)) / 9.0);
 
280
        self->priv->square_size = (gint) _tmp3_;
 
281
        extra = self->priv->square_size * 0.1;
 
282
        if (extra < 3) {
 
283
                extra = (gdouble) 3;
 
284
        }
 
285
        self->priv->selected_square_size = self->priv->square_size + (2 * ((gint) (extra + 0.5)));
 
286
        result = TRUE;
 
287
        return result;
 
288
}
 
289
 
 
290
 
 
291
static void chess_view2_d_render_piece (ChessView2D* self, cairo_t* c1, cairo_t* c2, const gchar* name, gint offset) {
 
292
        RsvgHandle* handle = NULL;
 
293
        ChessScene* _tmp0_ = NULL;
 
294
        const gchar* _tmp1_ = NULL;
 
295
        gchar* _tmp2_;
 
296
        gchar* _tmp3_;
 
297
        gchar* _tmp4_ = NULL;
 
298
        gchar* _tmp5_;
 
299
        RsvgHandle* _tmp6_ = NULL;
 
300
        RsvgHandle* _tmp7_;
 
301
        RsvgHandle* _tmp8_;
 
302
        gint _tmp9_;
 
303
        gint _tmp10_;
 
304
        gint _tmp11_;
 
305
        gint _tmp12_;
 
306
        GError * _inner_error_ = NULL;
 
307
        g_return_if_fail (self != NULL);
 
308
        g_return_if_fail (c1 != NULL);
 
309
        g_return_if_fail (c2 != NULL);
 
310
        g_return_if_fail (name != NULL);
 
311
        _tmp0_ = chess_view_get_scene ((ChessView*) self);
 
312
        _tmp1_ = chess_scene_get_theme_name (_tmp0_);
 
313
        _tmp2_ = g_strconcat (name, ".svg", NULL);
 
314
        _tmp3_ = _tmp2_;
 
315
        _tmp4_ = g_build_filename (PKGDATADIR, "pieces", _tmp1_, _tmp3_, NULL, NULL);
 
316
        _tmp5_ = _tmp4_;
 
317
        _tmp6_ = rsvg_handle_new_from_file (_tmp5_, &_inner_error_);
 
318
        _tmp7_ = _tmp6_;
 
319
        _g_free0 (_tmp5_);
 
320
        _g_free0 (_tmp3_);
 
321
        _tmp8_ = _tmp7_;
 
322
        if (_inner_error_ != NULL) {
 
323
                goto __catch12_g_error;
 
324
        }
 
325
        _g_object_unref0 (handle);
 
326
        handle = _tmp8_;
 
327
        goto __finally12;
 
328
        __catch12_g_error:
 
329
        {
 
330
                GError * e;
 
331
                e = _inner_error_;
 
332
                _inner_error_ = NULL;
 
333
                fprintf (stderr, "Failed to load piece svg: %s", e->message);
 
334
                _g_error_free0 (e);
 
335
                _g_object_unref0 (handle);
 
336
                return;
 
337
        }
 
338
        __finally12:
 
339
        if (_inner_error_ != NULL) {
 
340
                _g_object_unref0 (handle);
 
341
                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);
 
342
                g_clear_error (&_inner_error_);
 
343
                return;
 
344
        }
 
345
        cairo_save (c1);
 
346
        cairo_translate (c1, (gdouble) (self->priv->square_size * offset), (gdouble) 0);
 
347
        g_object_get (handle, "width", &_tmp9_, NULL);
 
348
        g_object_get (handle, "height", &_tmp10_, NULL);
 
349
        cairo_scale (c1, ((gdouble) self->priv->square_size) / _tmp9_, ((gdouble) self->priv->square_size) / _tmp10_);
 
350
        rsvg_handle_render_cairo (handle, c1);
 
351
        cairo_restore (c1);
 
352
        cairo_save (c2);
 
353
        cairo_translate (c2, (gdouble) (self->priv->selected_square_size * offset), (gdouble) 0);
 
354
        g_object_get (handle, "width", &_tmp11_, NULL);
 
355
        g_object_get (handle, "height", &_tmp12_, NULL);
 
356
        cairo_scale (c2, ((gdouble) self->priv->selected_square_size) / _tmp11_, ((gdouble) self->priv->selected_square_size) / _tmp12_);
 
357
        rsvg_handle_render_cairo (handle, c2);
 
358
        cairo_restore (c2);
 
359
        _g_object_unref0 (handle);
 
360
}
 
361
 
 
362
 
 
363
static void chess_view2_d_load_theme (ChessView2D* self) {
 
364
        gboolean _tmp0_ = FALSE;
 
365
        gboolean _tmp1_ = FALSE;
 
366
        ChessScene* _tmp2_ = NULL;
 
367
        const gchar* _tmp3_ = NULL;
 
368
        cairo_surface_t* _tmp5_ = NULL;
 
369
        cairo_surface_t* _tmp6_ = NULL;
 
370
        cairo_t* _tmp7_ = NULL;
 
371
        cairo_t* c1;
 
372
        cairo_t* _tmp8_ = NULL;
 
373
        cairo_t* c2;
 
374
        ChessScene* _tmp9_ = NULL;
 
375
        const gchar* _tmp10_ = NULL;
 
376
        gchar* _tmp11_;
 
377
        g_return_if_fail (self != NULL);
 
378
        _tmp2_ = chess_view_get_scene ((ChessView*) self);
 
379
        _tmp3_ = chess_scene_get_theme_name (_tmp2_);
 
380
        if (g_strcmp0 (_tmp3_, self->priv->loaded_theme_name) == 0) {
 
381
                _tmp1_ = self->priv->model_surface != NULL;
 
382
        } else {
 
383
                _tmp1_ = FALSE;
 
384
        }
 
385
        if (_tmp1_) {
 
386
                gint _tmp4_;
 
387
                _tmp4_ = cairo_image_surface_get_height (self->priv->model_surface);
 
388
                _tmp0_ = self->priv->square_size == _tmp4_;
 
389
        } else {
 
390
                _tmp0_ = FALSE;
 
391
        }
 
392
        if (_tmp0_) {
 
393
                return;
 
394
        }
 
395
        _tmp5_ = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 12 * self->priv->square_size, self->priv->square_size);
 
396
        _cairo_surface_destroy0 (self->priv->model_surface);
 
397
        self->priv->model_surface = _tmp5_;
 
398
        _tmp6_ = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 12 * self->priv->selected_square_size, self->priv->selected_square_size);
 
399
        _cairo_surface_destroy0 (self->priv->selected_model_surface);
 
400
        self->priv->selected_model_surface = _tmp6_;
 
401
        _tmp7_ = cairo_create (self->priv->model_surface);
 
402
        c1 = _tmp7_;
 
403
        _tmp8_ = cairo_create (self->priv->selected_model_surface);
 
404
        c2 = _tmp8_;
 
405
        chess_view2_d_render_piece (self, c1, c2, "whitePawn", 0);
 
406
        chess_view2_d_render_piece (self, c1, c2, "whiteRook", 1);
 
407
        chess_view2_d_render_piece (self, c1, c2, "whiteKnight", 2);
 
408
        chess_view2_d_render_piece (self, c1, c2, "whiteBishop", 3);
 
409
        chess_view2_d_render_piece (self, c1, c2, "whiteQueen", 4);
 
410
        chess_view2_d_render_piece (self, c1, c2, "whiteKing", 5);
 
411
        chess_view2_d_render_piece (self, c1, c2, "blackPawn", 6);
 
412
        chess_view2_d_render_piece (self, c1, c2, "blackRook", 7);
 
413
        chess_view2_d_render_piece (self, c1, c2, "blackKnight", 8);
 
414
        chess_view2_d_render_piece (self, c1, c2, "blackBishop", 9);
 
415
        chess_view2_d_render_piece (self, c1, c2, "blackQueen", 10);
 
416
        chess_view2_d_render_piece (self, c1, c2, "blackKing", 11);
 
417
        _tmp9_ = chess_view_get_scene ((ChessView*) self);
 
418
        _tmp10_ = chess_scene_get_theme_name (_tmp9_);
 
419
        _tmp11_ = g_strdup (_tmp10_);
 
420
        _g_free0 (self->priv->loaded_theme_name);
 
421
        self->priv->loaded_theme_name = _tmp11_;
 
422
        _cairo_destroy0 (c2);
 
423
        _cairo_destroy0 (c1);
 
424
}
 
425
 
 
426
 
 
427
static gpointer _chess_model_ref0 (gpointer self) {
 
428
        return self ? chess_model_ref (self) : NULL;
 
429
}
 
430
 
 
431
 
 
432
static gboolean chess_view2_d_real_draw (GtkWidget* base, cairo_t* c) {
 
433
        ChessView2D * self;
 
434
        gboolean result = FALSE;
 
435
        gint _tmp0_;
 
436
        gint _tmp1_;
 
437
        ChessScene* _tmp2_ = NULL;
 
438
        gdouble _tmp3_;
 
439
        gdouble _tmp4_;
 
440
        gdouble _tmp5_;
 
441
        gint board_size;
 
442
        ChessScene* _tmp8_ = NULL;
 
443
        gboolean _tmp9_;
 
444
        ChessScene* _tmp37_ = NULL;
 
445
        self = (ChessView2D*) base;
 
446
        g_return_val_if_fail (c != NULL, FALSE);
 
447
        chess_view2_d_load_theme (self);
 
448
        _tmp0_ = gtk_widget_get_allocated_width ((GtkWidget*) self);
 
449
        _tmp1_ = gtk_widget_get_allocated_height ((GtkWidget*) self);
 
450
        cairo_translate (c, (gdouble) (_tmp0_ / 2), (gdouble) (_tmp1_ / 2));
 
451
        _tmp2_ = chess_view_get_scene ((ChessView*) self);
 
452
        _tmp3_ = chess_scene_get_board_angle (_tmp2_);
 
453
        cairo_rotate (c, (G_PI * _tmp3_) / 180.0);
 
454
        _tmp4_ = chess_view2_d_get_border_size (self);
 
455
        _tmp5_ = ceil ((self->priv->square_size * 4) + _tmp4_);
 
456
        board_size = (gint) _tmp5_;
 
457
        cairo_set_source_rgb (c, 0x2e / 255.0, 0x34 / 255.0, 0x36 / 255.0);
 
458
        cairo_rectangle (c, (gdouble) (-board_size), (gdouble) (-board_size), (gdouble) (board_size * 2), (gdouble) (board_size * 2));
 
459
        cairo_fill (c);
 
460
        {
 
461
                gint file;
 
462
                file = 0;
 
463
                {
 
464
                        gboolean _tmp6_;
 
465
                        _tmp6_ = TRUE;
 
466
                        while (TRUE) {
 
467
                                if (!_tmp6_) {
 
468
                                        file++;
 
469
                                }
 
470
                                _tmp6_ = FALSE;
 
471
                                if (!(file < 8)) {
 
472
                                        break;
 
473
                                }
 
474
                                {
 
475
                                        gint rank;
 
476
                                        rank = 0;
 
477
                                        {
 
478
                                                gboolean _tmp7_;
 
479
                                                _tmp7_ = TRUE;
 
480
                                                while (TRUE) {
 
481
                                                        gint x;
 
482
                                                        gint y;
 
483
                                                        if (!_tmp7_) {
 
484
                                                                rank++;
 
485
                                                        }
 
486
                                                        _tmp7_ = FALSE;
 
487
                                                        if (!(rank < 8)) {
 
488
                                                                break;
 
489
                                                        }
 
490
                                                        x = (gint) ((file - 4) * self->priv->square_size);
 
491
                                                        y = (gint) ((3 - rank) * self->priv->square_size);
 
492
                                                        cairo_rectangle (c, (gdouble) x, (gdouble) y, (gdouble) self->priv->square_size, (gdouble) self->priv->square_size);
 
493
                                                        if (((file + rank) % 2) == 0) {
 
494
                                                                cairo_set_source_rgb (c, 0xba / 255.0, 0xbd / 255.0, 0xb6 / 255.0);
 
495
                                                        } else {
 
496
                                                                cairo_set_source_rgb (c, 0xee / 255.0, 0xee / 255.0, 0xec / 255.0);
 
497
                                                        }
 
498
                                                        cairo_fill (c);
 
499
                                                }
 
500
                                        }
 
501
                                }
 
502
                        }
 
503
                }
 
504
        }
 
505
        _tmp8_ = chess_view_get_scene ((ChessView*) self);
 
506
        _tmp9_ = chess_scene_get_show_numbering (_tmp8_);
 
507
        if (_tmp9_) {
 
508
                gchar* _tmp10_;
 
509
                gchar* _tmp11_;
 
510
                gchar* _tmp12_;
 
511
                gchar* _tmp13_;
 
512
                gchar* _tmp14_;
 
513
                gchar* _tmp15_;
 
514
                gchar* _tmp16_;
 
515
                gchar* _tmp17_;
 
516
                gchar** _tmp18_ = NULL;
 
517
                gchar** files;
 
518
                gint files_length1;
 
519
                gint _files_size_;
 
520
                gchar* _tmp19_;
 
521
                gchar* _tmp20_;
 
522
                gchar* _tmp21_;
 
523
                gchar* _tmp22_;
 
524
                gchar* _tmp23_;
 
525
                gchar* _tmp24_;
 
526
                gchar* _tmp25_;
 
527
                gchar* _tmp26_;
 
528
                gchar** _tmp27_ = NULL;
 
529
                gchar** ranks;
 
530
                gint ranks_length1;
 
531
                gint _ranks_size_;
 
532
                gdouble _tmp28_;
 
533
                cairo_text_extents_t extents = {0};
 
534
                cairo_text_extents_t _tmp29_ = {0};
 
535
                gdouble y_offset;
 
536
                gdouble top;
 
537
                gdouble _tmp30_;
 
538
                gdouble bottom;
 
539
                gdouble file_offset;
 
540
                gdouble rank_offset;
 
541
                _tmp10_ = g_strdup ("a");
 
542
                _tmp11_ = g_strdup ("b");
 
543
                _tmp12_ = g_strdup ("c");
 
544
                _tmp13_ = g_strdup ("d");
 
545
                _tmp14_ = g_strdup ("e");
 
546
                _tmp15_ = g_strdup ("f");
 
547
                _tmp16_ = g_strdup ("g");
 
548
                _tmp17_ = g_strdup ("h");
 
549
                _tmp18_ = g_new0 (gchar*, 8 + 1);
 
550
                _tmp18_[0] = _tmp10_;
 
551
                _tmp18_[1] = _tmp11_;
 
552
                _tmp18_[2] = _tmp12_;
 
553
                _tmp18_[3] = _tmp13_;
 
554
                _tmp18_[4] = _tmp14_;
 
555
                _tmp18_[5] = _tmp15_;
 
556
                _tmp18_[6] = _tmp16_;
 
557
                _tmp18_[7] = _tmp17_;
 
558
                files = _tmp18_;
 
559
                files_length1 = 8;
 
560
                _files_size_ = 8;
 
561
                _tmp19_ = g_strdup ("8");
 
562
                _tmp20_ = g_strdup ("7");
 
563
                _tmp21_ = g_strdup ("6");
 
564
                _tmp22_ = g_strdup ("5");
 
565
                _tmp23_ = g_strdup ("4");
 
566
                _tmp24_ = g_strdup ("3");
 
567
                _tmp25_ = g_strdup ("2");
 
568
                _tmp26_ = g_strdup ("1");
 
569
                _tmp27_ = g_new0 (gchar*, 8 + 1);
 
570
                _tmp27_[0] = _tmp19_;
 
571
                _tmp27_[1] = _tmp20_;
 
572
                _tmp27_[2] = _tmp21_;
 
573
                _tmp27_[3] = _tmp22_;
 
574
                _tmp27_[4] = _tmp23_;
 
575
                _tmp27_[5] = _tmp24_;
 
576
                _tmp27_[6] = _tmp25_;
 
577
                _tmp27_[7] = _tmp26_;
 
578
                ranks = _tmp27_;
 
579
                ranks_length1 = 8;
 
580
                _ranks_size_ = 8;
 
581
                cairo_set_source_rgb (c, 0x88 / 255.0, 0x8a / 255.0, 0x85 / 255.0);
 
582
                _tmp28_ = chess_view2_d_get_border_size (self);
 
583
                cairo_set_font_size (c, _tmp28_ * 0.6);
 
584
                cairo_select_font_face (c, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
 
585
                cairo_text_extents (c, "abcdefgh", &_tmp29_);
 
586
                extents = _tmp29_;
 
587
                y_offset = ((((self->priv->square_size / 2) - extents.height) / 2) + extents.height) + extents.y_bearing;
 
588
                top = -((self->priv->square_size * 4) + y_offset);
 
589
                _tmp30_ = chess_view2_d_get_border_size (self);
 
590
                bottom = ((self->priv->square_size * 4) + _tmp30_) - y_offset;
 
591
                file_offset = -(self->priv->square_size * 3.5);
 
592
                rank_offset = -(self->priv->square_size * 3.5);
 
593
                {
 
594
                        gint i;
 
595
                        i = 0;
 
596
                        {
 
597
                                gboolean _tmp31_;
 
598
                                _tmp31_ = TRUE;
 
599
                                while (TRUE) {
 
600
                                        cairo_text_extents_t _tmp32_ = {0};
 
601
                                        cairo_text_extents_t _tmp33_ = {0};
 
602
                                        gdouble _tmp34_;
 
603
                                        gdouble _tmp35_;
 
604
                                        gdouble _tmp36_;
 
605
                                        if (!_tmp31_) {
 
606
                                                i++;
 
607
                                        }
 
608
                                        _tmp31_ = FALSE;
 
609
                                        if (!(i < 8)) {
 
610
                                                break;
 
611
                                        }
 
612
                                        cairo_text_extents (c, ranks[i], &_tmp32_);
 
613
                                        extents = _tmp32_;
 
614
                                        cairo_save (c);
 
615
                                        cairo_move_to (c, file_offset - (extents.width / 2), top);
 
616
                                        cairo_show_text (c, files[i]);
 
617
                                        cairo_restore (c);
 
618
                                        cairo_save (c);
 
619
                                        cairo_move_to (c, file_offset - (extents.width / 2), bottom);
 
620
                                        cairo_show_text (c, files[i]);
 
621
                                        cairo_restore (c);
 
622
                                        cairo_text_extents (c, ranks[i], &_tmp33_);
 
623
                                        extents = _tmp33_;
 
624
                                        y_offset = -(extents.y_bearing + (extents.height / 2));
 
625
                                        cairo_save (c);
 
626
                                        _tmp34_ = chess_view2_d_get_border_size (self);
 
627
                                        _tmp35_ = chess_view2_d_get_border_size (self);
 
628
                                        cairo_move_to (c, -(((((gdouble) self->priv->square_size) * 4) + _tmp34_) - ((_tmp35_ - extents.width) / 2)), rank_offset + y_offset);
 
629
                                        cairo_show_text (c, ranks[i]);
 
630
                                        cairo_restore (c);
 
631
                                        cairo_save (c);
 
632
                                        _tmp36_ = chess_view2_d_get_border_size (self);
 
633
                                        cairo_move_to (c, (((gdouble) self->priv->square_size) * 4) + ((_tmp36_ - extents.width) / 2), rank_offset + y_offset);
 
634
                                        cairo_show_text (c, ranks[i]);
 
635
                                        cairo_restore (c);
 
636
                                        file_offset = file_offset + ((gdouble) self->priv->square_size);
 
637
                                        rank_offset = rank_offset + ((gdouble) self->priv->square_size);
 
638
                                }
 
639
                        }
 
640
                }
 
641
                ranks = (_vala_array_free (ranks, ranks_length1, (GDestroyNotify) g_free), NULL);
 
642
                files = (_vala_array_free (files, files_length1, (GDestroyNotify) g_free), NULL);
 
643
        }
 
644
        _tmp37_ = chess_view_get_scene ((ChessView*) self);
 
645
        {
 
646
                GList* model_collection;
 
647
                GList* model_it;
 
648
                model_collection = _tmp37_->pieces;
 
649
                for (model_it = model_collection; model_it != NULL; model_it = model_it->next) {
 
650
                        ChessModel* _tmp38_;
 
651
                        ChessModel* model;
 
652
                        _tmp38_ = _chess_model_ref0 ((ChessModel*) model_it->data);
 
653
                        model = _tmp38_;
 
654
                        {
 
655
                                ChessScene* _tmp39_ = NULL;
 
656
                                gdouble _tmp40_;
 
657
                                cairo_surface_t* _tmp41_ = NULL;
 
658
                                gdouble _tmp42_ = 0.0;
 
659
                                gboolean _tmp43_ = FALSE;
 
660
                                cairo_save (c);
 
661
                                cairo_translate (c, (model->x - 4) * self->priv->square_size, (3 - model->y) * self->priv->square_size);
 
662
                                cairo_translate (c, (gdouble) (self->priv->square_size / 2), (gdouble) (self->priv->square_size / 2));
 
663
                                _tmp39_ = chess_view_get_scene ((ChessView*) self);
 
664
                                _tmp40_ = chess_scene_get_board_angle (_tmp39_);
 
665
                                cairo_rotate (c, ((-G_PI) * _tmp40_) / 180.0);
 
666
                                if (model->is_selected) {
 
667
                                        _tmp41_ = self->priv->selected_model_surface;
 
668
                                } else {
 
669
                                        _tmp41_ = self->priv->model_surface;
 
670
                                }
 
671
                                if (model->under_threat) {
 
672
                                        ChessScene* _tmp44_ = NULL;
 
673
                                        gboolean _tmp45_;
 
674
                                        _tmp44_ = chess_view_get_scene ((ChessView*) self);
 
675
                                        _tmp45_ = chess_scene_get_show_move_hints (_tmp44_);
 
676
                                        _tmp43_ = _tmp45_;
 
677
                                } else {
 
678
                                        _tmp43_ = FALSE;
 
679
                                }
 
680
                                if (_tmp43_) {
 
681
                                        _tmp42_ = 0.8;
 
682
                                } else {
 
683
                                        _tmp42_ = 1.0;
 
684
                                }
 
685
                                chess_view2_d_draw_piece (self, c, _tmp41_, model->piece, _tmp42_);
 
686
                                cairo_restore (c);
 
687
                                _chess_model_unref0 (model);
 
688
                        }
 
689
                }
 
690
        }
 
691
        {
 
692
                gint rank;
 
693
                rank = 0;
 
694
                {
 
695
                        gboolean _tmp46_;
 
696
                        _tmp46_ = TRUE;
 
697
                        while (TRUE) {
 
698
                                if (!_tmp46_) {
 
699
                                        rank++;
 
700
                                }
 
701
                                _tmp46_ = FALSE;
 
702
                                if (!(rank < 8)) {
 
703
                                        break;
 
704
                                }
 
705
                                {
 
706
                                        gint file;
 
707
                                        file = 0;
 
708
                                        {
 
709
                                                gboolean _tmp47_;
 
710
                                                _tmp47_ = TRUE;
 
711
                                                while (TRUE) {
 
712
                                                        gboolean _tmp48_ = FALSE;
 
713
                                                        ChessScene* _tmp49_ = NULL;
 
714
                                                        gboolean _tmp50_;
 
715
                                                        if (!_tmp47_) {
 
716
                                                                file++;
 
717
                                                        }
 
718
                                                        _tmp47_ = FALSE;
 
719
                                                        if (!(file < 8)) {
 
720
                                                                break;
 
721
                                                        }
 
722
                                                        _tmp49_ = chess_view_get_scene ((ChessView*) self);
 
723
                                                        _tmp50_ = chess_scene_get_show_move_hints (_tmp49_);
 
724
                                                        if (_tmp50_) {
 
725
                                                                ChessScene* _tmp51_ = NULL;
 
726
                                                                gboolean _tmp52_;
 
727
                                                                _tmp51_ = chess_view_get_scene ((ChessView*) self);
 
728
                                                                _tmp52_ = chess_scene_can_move (_tmp51_, rank, file);
 
729
                                                                _tmp48_ = _tmp52_;
 
730
                                                        } else {
 
731
                                                                _tmp48_ = FALSE;
 
732
                                                        }
 
733
                                                        if (_tmp48_) {
 
734
                                                                ChessScene* _tmp53_ = NULL;
 
735
                                                                gdouble _tmp54_;
 
736
                                                                ChessScene* _tmp55_ = NULL;
 
737
                                                                ChessPiece* _tmp56_ = NULL;
 
738
                                                                ChessPiece* _tmp57_;
 
739
                                                                cairo_save (c);
 
740
                                                                cairo_translate (c, (gdouble) ((file - 4) * self->priv->square_size), (gdouble) ((3 - rank) * self->priv->square_size));
 
741
                                                                cairo_translate (c, (gdouble) (self->priv->square_size / 2), (gdouble) (self->priv->square_size / 2));
 
742
                                                                _tmp53_ = chess_view_get_scene ((ChessView*) self);
 
743
                                                                _tmp54_ = chess_scene_get_board_angle (_tmp53_);
 
744
                                                                cairo_rotate (c, ((-G_PI) * _tmp54_) / 180.0);
 
745
                                                                _tmp55_ = chess_view_get_scene ((ChessView*) self);
 
746
                                                                _tmp56_ = chess_scene_get_selected_piece (_tmp55_);
 
747
                                                                _tmp57_ = _tmp56_;
 
748
                                                                chess_view2_d_draw_piece (self, c, self->priv->model_surface, _tmp57_, 0.1);
 
749
                                                                _chess_piece_unref0 (_tmp57_);
 
750
                                                                cairo_restore (c);
 
751
                                                        }
 
752
                                                }
 
753
                                        }
 
754
                                }
 
755
                        }
 
756
                }
 
757
        }
 
758
        result = TRUE;
 
759
        return result;
 
760
}
 
761
 
 
762
 
 
763
static void chess_view2_d_draw_piece (ChessView2D* self, cairo_t* c, cairo_surface_t* surface, ChessPiece* piece, gdouble alpha) {
 
764
        gboolean _tmp0_ = FALSE;
 
765
        ChessScene* _tmp1_ = NULL;
 
766
        const gchar* _tmp2_ = NULL;
 
767
        gint _tmp4_;
 
768
        gint size;
 
769
        gint offset;
 
770
        Color _tmp5_;
 
771
        g_return_if_fail (self != NULL);
 
772
        g_return_if_fail (c != NULL);
 
773
        g_return_if_fail (surface != NULL);
 
774
        g_return_if_fail (piece != NULL);
 
775
        _tmp1_ = chess_view_get_scene ((ChessView*) self);
 
776
        _tmp2_ = chess_scene_get_board_side (_tmp1_);
 
777
        if (g_strcmp0 (_tmp2_, "facetoface") == 0) {
 
778
                Color _tmp3_;
 
779
                _tmp3_ = chess_piece_get_color (piece);
 
780
                _tmp0_ = _tmp3_ == COLOR_BLACK;
 
781
        } else {
 
782
                _tmp0_ = FALSE;
 
783
        }
 
784
        if (_tmp0_) {
 
785
                cairo_rotate (c, G_PI);
 
786
        }
 
787
        _tmp4_ = cairo_image_surface_get_height (surface);
 
788
        size = _tmp4_;
 
789
        cairo_translate (c, (gdouble) ((-size) / 2), (gdouble) ((-size) / 2));
 
790
        offset = (gint) piece->type;
 
791
        _tmp5_ = chess_piece_get_color (piece);
 
792
        if (_tmp5_ == COLOR_BLACK) {
 
793
                offset = offset + 6;
 
794
        }
 
795
        cairo_set_source_surface (c, surface, (gdouble) ((-offset) * size), (gdouble) 0);
 
796
        cairo_rectangle (c, (gdouble) 0, (gdouble) 0, (gdouble) size, (gdouble) size);
 
797
        cairo_clip (c);
 
798
        cairo_paint_with_alpha (c, alpha);
 
799
}
 
800
 
 
801
 
 
802
static gboolean chess_view2_d_real_button_press_event (GtkWidget* base, GdkEventButton* event) {
 
803
        ChessView2D * self;
 
804
        gboolean result = FALSE;
 
805
        gboolean _tmp0_ = FALSE;
 
806
        ChessScene* _tmp1_ = NULL;
 
807
        ChessGame* _tmp2_ = NULL;
 
808
        gint _tmp3_;
 
809
        gdouble _tmp4_;
 
810
        gint file;
 
811
        gint _tmp5_;
 
812
        gdouble _tmp6_;
 
813
        gint rank;
 
814
        ChessScene* _tmp7_ = NULL;
 
815
        gdouble _tmp8_;
 
816
        gboolean _tmp9_ = FALSE;
 
817
        gboolean _tmp10_ = FALSE;
 
818
        gboolean _tmp11_ = FALSE;
 
819
        ChessScene* _tmp12_ = NULL;
 
820
        self = (ChessView2D*) base;
 
821
        _tmp1_ = chess_view_get_scene ((ChessView*) self);
 
822
        _tmp2_ = chess_scene_get_game (_tmp1_);
 
823
        if (_tmp2_ == NULL) {
 
824
                _tmp0_ = TRUE;
 
825
        } else {
 
826
                _tmp0_ = (*event).button != 1;
 
827
        }
 
828
        if (_tmp0_) {
 
829
                result = FALSE;
 
830
                return result;
 
831
        }
 
832
        _tmp3_ = gtk_widget_get_allocated_width ((GtkWidget*) self);
 
833
        _tmp4_ = floor ((((*event).x - (0.5 * _tmp3_)) + (self->priv->square_size * 4)) / self->priv->square_size);
 
834
        file = (gint) _tmp4_;
 
835
        _tmp5_ = gtk_widget_get_allocated_height ((GtkWidget*) self);
 
836
        _tmp6_ = floor ((((*event).y - (0.5 * _tmp5_)) + (self->priv->square_size * 4)) / self->priv->square_size);
 
837
        rank = 7 - ((gint) _tmp6_);
 
838
        _tmp7_ = chess_view_get_scene ((ChessView*) self);
 
839
        _tmp8_ = chess_scene_get_board_angle (_tmp7_);
 
840
        if (_tmp8_ == 180.0) {
 
841
                rank = 7 - rank;
 
842
                file = 7 - file;
 
843
        }
 
844
        if (file < 0) {
 
845
                _tmp11_ = TRUE;
 
846
        } else {
 
847
                _tmp11_ = file >= 8;
 
848
        }
 
849
        if (_tmp11_) {
 
850
                _tmp10_ = TRUE;
 
851
        } else {
 
852
                _tmp10_ = rank < 0;
 
853
        }
 
854
        if (_tmp10_) {
 
855
                _tmp9_ = TRUE;
 
856
        } else {
 
857
                _tmp9_ = rank >= 8;
 
858
        }
 
859
        if (_tmp9_) {
 
860
                result = FALSE;
 
861
                return result;
 
862
        }
 
863
        _tmp12_ = chess_view_get_scene ((ChessView*) self);
 
864
        chess_scene_select_square (_tmp12_, file, rank);
 
865
        result = TRUE;
 
866
        return result;
 
867
}
 
868
 
 
869
 
 
870
static gdouble chess_view2_d_get_border_size (ChessView2D* self) {
 
871
        gdouble result;
 
872
        g_return_val_if_fail (self != NULL, 0.0);
 
873
        result = (gdouble) (self->priv->square_size / 2);
 
874
        return result;
 
875
}
 
876
 
 
877
 
 
878
static void chess_view2_d_class_init (ChessView2DClass * klass) {
 
879
        chess_view2_d_parent_class = g_type_class_peek_parent (klass);
 
880
        g_type_class_add_private (klass, sizeof (ChessView2DPrivate));
 
881
        GTK_WIDGET_CLASS (klass)->configure_event = chess_view2_d_real_configure_event;
 
882
        GTK_WIDGET_CLASS (klass)->draw = chess_view2_d_real_draw;
 
883
        GTK_WIDGET_CLASS (klass)->button_press_event = chess_view2_d_real_button_press_event;
 
884
        G_OBJECT_CLASS (klass)->get_property = _vala_chess_view2_d_get_property;
 
885
        G_OBJECT_CLASS (klass)->finalize = chess_view2_d_finalize;
 
886
}
 
887
 
 
888
 
 
889
static void chess_view2_d_instance_init (ChessView2D * self) {
 
890
        gchar* _tmp0_;
 
891
        self->priv = CHESS_VIEW2_D_GET_PRIVATE (self);
 
892
        self->priv->border = 6;
 
893
        _tmp0_ = g_strdup ("");
 
894
        self->priv->loaded_theme_name = _tmp0_;
 
895
}
 
896
 
 
897
 
 
898
static void chess_view2_d_finalize (GObject* obj) {
 
899
        ChessView2D * self;
 
900
        self = CHESS_VIEW2_D (obj);
 
901
        _cairo_surface_destroy0 (self->priv->model_surface);
 
902
        _cairo_surface_destroy0 (self->priv->selected_model_surface);
 
903
        _g_free0 (self->priv->loaded_theme_name);
 
904
        G_OBJECT_CLASS (chess_view2_d_parent_class)->finalize (obj);
 
905
}
 
906
 
 
907
 
 
908
GType chess_view2_d_get_type (void) {
 
909
        static volatile gsize chess_view2_d_type_id__volatile = 0;
 
910
        if (g_once_init_enter (&chess_view2_d_type_id__volatile)) {
 
911
                static const GTypeInfo g_define_type_info = { sizeof (ChessView2DClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) chess_view2_d_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ChessView2D), 0, (GInstanceInitFunc) chess_view2_d_instance_init, NULL };
 
912
                GType chess_view2_d_type_id;
 
913
                chess_view2_d_type_id = g_type_register_static (TYPE_CHESS_VIEW, "ChessView2D", &g_define_type_info, 0);
 
914
                g_once_init_leave (&chess_view2_d_type_id__volatile, chess_view2_d_type_id);
 
915
        }
 
916
        return chess_view2_d_type_id__volatile;
 
917
}
 
918
 
 
919
 
 
920
static void _vala_chess_view2_d_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
 
921
        ChessView2D * self;
 
922
        self = CHESS_VIEW2_D (object);
 
923
        switch (property_id) {
 
924
                default:
 
925
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
926
                break;
 
927
        }
 
928
}
 
929
 
 
930
 
 
931
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
932
        if ((array != NULL) && (destroy_func != NULL)) {
 
933
                int i;
 
934
                for (i = 0; i < array_length; i = i + 1) {
 
935
                        if (((gpointer*) array)[i] != NULL) {
 
936
                                destroy_func (((gpointer*) array)[i]);
 
937
                        }
 
938
                }
 
939
        }
 
940
}
 
941
 
 
942
 
 
943
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
 
944
        _vala_array_destroy (array, array_length, destroy_func);
 
945
        g_free (array);
 
946
}
 
947
 
 
948
 
 
949