elm: Removed trailing whitespaces.
[framework/uifw/elementary.git] / src / bin / test_glview.c
1 #include <Elementary.h>
2 #ifdef HAVE_CONFIG_H
3 # include "elementary_config.h"
4 #endif
5 #ifndef ELM_LIB_QUICKLAUNCH
6
7 #ifndef M_PI
8 #define M_PI 3.14159265
9 #endif
10
11 typedef struct _Gear Gear;
12 typedef struct _GLData GLData;
13 struct _Gear
14 {
15    GLfloat *vertices;
16    GLuint vbo;
17    int count;
18 };
19
20 // GL related data here..
21 struct _GLData
22 {
23    Evas_GL_API *glapi;
24    GLuint       program;
25    GLuint       vtx_shader;
26    GLuint       fgmt_shader;
27    int          initialized : 1;
28    int          mouse_down : 1;
29
30    // Gear Stuff
31    GLfloat      view_rotx;
32    GLfloat      view_roty;
33    GLfloat      view_rotz;
34
35    Gear        *gear1;
36    Gear        *gear2;
37    Gear        *gear3;
38
39    GLfloat      angle;
40
41    GLuint       proj_location;
42    GLuint       light_location;
43    GLuint       color_location;
44
45    GLfloat      proj[16];
46    GLfloat      light[3];
47 };
48
49 static void gears_init(GLData *gld);
50 static void free_gear(Gear *gear);
51 static void gears_reshape(GLData *gld, int width, int height);
52 static void render_gears(GLData *gld);
53
54 //--------------------------------//
55 // Gear Stuff....
56 static GLfloat *
57 vert(GLfloat *p, GLfloat x, GLfloat y, GLfloat z, GLfloat *n)
58 {
59    p[0] = x;
60    p[1] = y;
61    p[2] = z;
62    p[3] = n[0];
63    p[4] = n[1];
64    p[5] = n[2];
65
66    return p + 6;
67 }
68
69 /*  Draw a gear wheel.  You'll probably want to call this function when
70  *  building a display list since we do a lot of trig here.
71  *
72  *  Input:  inner_radius - radius of hole at center
73  *          outer_radius - radius at center of teeth
74  *          width - width of gear
75  *          teeth - number of teeth
76  *          tooth_depth - depth of tooth
77  */
78 static Gear *
79 make_gear(GLData *gld, GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
80           GLint teeth, GLfloat tooth_depth)
81 {
82    GLint i;
83    GLfloat r0, r1, r2;
84    GLfloat da;
85    GLfloat *v;
86    Gear *gear;
87    double s[5], c[5];
88    GLfloat normal[3];
89    const int tris_per_tooth = 20;
90    Evas_GL_API *gl = gld->glapi;
91
92    gear = (Gear*)malloc(sizeof(Gear));
93    if (gear == NULL)
94      return NULL;
95
96    r0 = inner_radius;
97    r1 = outer_radius - tooth_depth / 2.0;
98    r2 = outer_radius + tooth_depth / 2.0;
99
100    da = 2.0 * M_PI / teeth / 4.0;
101
102    gear->vertices = calloc(teeth * tris_per_tooth * 3 * 6,
103                            sizeof *gear->vertices);
104    s[4] = 0;
105    c[4] = 1;
106    v = gear->vertices;
107    for (i = 0; i < teeth; i++)
108      {
109         s[0] = s[4];
110         c[0] = c[4];
111         s[1] = sin(i * 2.0 * M_PI / teeth + da);
112         c[1] = cos(i * 2.0 * M_PI / teeth + da);
113         s[2] = sin(i * 2.0 * M_PI / teeth + da * 2);
114         c[2] = cos(i * 2.0 * M_PI / teeth + da * 2);
115         s[3] = sin(i * 2.0 * M_PI / teeth + da * 3);
116         c[3] = cos(i * 2.0 * M_PI / teeth + da * 3);
117         s[4] = sin(i * 2.0 * M_PI / teeth + da * 4);
118         c[4] = cos(i * 2.0 * M_PI / teeth + da * 4);
119
120         normal[0] = 0.0;
121         normal[1] = 0.0;
122         normal[2] = 1.0;
123
124         v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
125
126         v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
127         v = vert(v, r2 * c[2], r2 * s[2], width * 0.5, normal);
128         v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
129         v = vert(v, r1 * c[3], r1 * s[3], width * 0.5, normal);
130         v = vert(v, r0 * c[0], r0 * s[0], width * 0.5, normal);
131         v = vert(v, r1 * c[4], r1 * s[4], width * 0.5, normal);
132         v = vert(v, r0 * c[4], r0 * s[4], width * 0.5, normal);
133
134         v = vert(v, r0 * c[4], r0 * s[4], width * 0.5, normal);
135         v = vert(v, r0 * c[0], r0 * s[0], width * 0.5, normal);
136         v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
137         v = vert(v, r0 * c[0], r0 * s[0], -width * 0.5, normal);
138
139         normal[0] = 0.0;
140         normal[1] = 0.0;
141         normal[2] = -1.0;
142
143         v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
144
145         v = vert(v, r0 * c[4], r0 * s[4], -width * 0.5, normal);
146         v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
147         v = vert(v, r0 * c[0], r0 * s[0], -width * 0.5, normal);
148         v = vert(v, r1 * c[3], r1 * s[3], -width * 0.5, normal);
149         v = vert(v, r1 * c[0], r1 * s[0], -width * 0.5, normal);
150         v = vert(v, r2 * c[2], r2 * s[2], -width * 0.5, normal);
151         v = vert(v, r2 * c[1], r2 * s[1], -width * 0.5, normal);
152
153         v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
154
155         v = vert(v, r1 * c[0], r1 * s[0], width * 0.5, normal);
156         v = vert(v, r1 * c[0], r1 * s[0], -width * 0.5, normal);
157         v = vert(v, r2 * c[1], r2 * s[1], width * 0.5, normal);
158         v = vert(v, r2 * c[1], r2 * s[1], -width * 0.5, normal);
159         v = vert(v, r2 * c[2], r2 * s[2], width * 0.5, normal);
160         v = vert(v, r2 * c[2], r2 * s[2], -width * 0.5, normal);
161         v = vert(v, r1 * c[3], r1 * s[3], width * 0.5, normal);
162         v = vert(v, r1 * c[3], r1 * s[3], -width * 0.5, normal);
163         v = vert(v, r1 * c[4], r1 * s[4], width * 0.5, normal);
164         v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
165
166         v = vert(v, r1 * c[4], r1 * s[4], -width * 0.5, normal);
167      }
168
169    gear->count = (v - gear->vertices) / 6;
170
171    gl->glGenBuffers(1, &gear->vbo);
172    gl->glBindBuffer(GL_ARRAY_BUFFER, gear->vbo);
173    gl->glBufferData(GL_ARRAY_BUFFER, gear->count * 6 * 4,
174                     gear->vertices, GL_STATIC_DRAW);
175
176
177    return gear;
178 }
179
180 static void
181 free_gear(Gear *gear)
182 {
183     free(gear->vertices);
184     free(gear);
185     gear = NULL;
186 }
187
188 static void
189 multiply(GLfloat *m, const GLfloat *n)
190 {
191    GLfloat tmp[16];
192    const GLfloat *row, *column;
193    div_t d;
194    int i, j;
195
196    for (i = 0; i < 16; i++)
197      {
198         tmp[i] = 0;
199         d = div(i, 4);
200         row = n + d.quot * 4;
201         column = m + d.rem;
202         for (j = 0; j < 4; j++)
203           tmp[i] += row[j] * column[j * 4];
204      }
205    memcpy(m, &tmp, sizeof tmp);
206 }
207
208 static void
209 rotate(GLfloat *m, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
210 {
211    double s, c;
212
213    s = sin(angle);
214    c = cos(angle);
215    GLfloat r[16] =
216      {
217         x * x * (1 - c) + c,     y * x * (1 - c) + z * s, x * z * (1 - c) - y * s, 0,
218         x * y * (1 - c) - z * s, y * y * (1 - c) + c,     y * z * (1 - c) + x * s, 0,
219         x * z * (1 - c) + y * s, y * z * (1 - c) - x * s, z * z * (1 - c) + c,     0,
220         0, 0, 0, 1
221      };
222
223    multiply(m, r);
224 }
225
226 static void
227 translate(GLfloat *m, GLfloat x, GLfloat y, GLfloat z)
228 {
229    GLfloat t[16] = { 1, 0, 0, 0,  0, 1, 0, 0,  0, 0, 1, 0,  x, y, z, 1 };
230
231    multiply(m, t);
232 }
233
234 static void
235 draw_gear(GLData *gld, Gear *gear, GLfloat *m,
236           GLfloat x, GLfloat y, GLfloat angle, const GLfloat *color)
237 {
238    Evas_GL_API *gl = gld->glapi;
239    GLfloat tmp[16];
240
241    memcpy(tmp, m, sizeof tmp);
242    translate(tmp, x, y, 0);
243    rotate(tmp, 2 * M_PI * angle / 360.0, 0, 0, 1);
244    gl->glUniformMatrix4fv(gld->proj_location, 1, GL_FALSE, tmp);
245    gl->glUniform3fv(gld->light_location, 1, gld->light);
246    gl->glUniform4fv(gld->color_location, 1, color);
247
248    gl->glBindBuffer(GL_ARRAY_BUFFER, gear->vbo);
249
250    gl->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,
251                              6 * sizeof(GLfloat), NULL);
252    gl->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
253                              6 * sizeof(GLfloat), (GLfloat *) 0 + 3);
254    gl->glEnableVertexAttribArray(0);
255    gl->glEnableVertexAttribArray(1);
256    gl->glDrawArrays(GL_TRIANGLE_STRIP, 0, gear->count);
257 }
258
259 static void
260 gears_draw(GLData *gld)
261 {
262    Evas_GL_API *gl = gld->glapi;
263
264    static const GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
265    static const GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
266    static const GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
267    GLfloat m[16];
268
269    gl->glClearColor(0.8, 0.8, 0.1, 0.5);
270    gl->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
271
272    memcpy(m, gld->proj, sizeof m);
273    rotate(m, 2 * M_PI * gld->view_rotx / 360.0, 1, 0, 0);
274    rotate(m, 2 * M_PI * gld->view_roty / 360.0, 0, 1, 0);
275    rotate(m, 2 * M_PI * gld->view_rotz / 360.0, 0, 0, 1);
276
277    draw_gear(gld, gld->gear1, m, -3.0, -2.0, gld->angle, red);
278    draw_gear(gld, gld->gear2, m, 3.1, -2.0, -2 * gld->angle - 9.0, green);
279    draw_gear(gld, gld->gear3, m, -3.1, 4.2, -2 * gld->angle - 25.0, blue);
280 }
281
282 static void render_gears(GLData *gld)
283 {
284    gears_draw(gld);
285
286    gld->angle += 2.0;
287 }
288
289 /* new window size or exposure */
290 static void
291 gears_reshape(GLData *gld, int width, int height)
292 {
293    Evas_GL_API *gl = gld->glapi;
294
295    GLfloat ar, m[16] = {
296       1.0, 0.0, 0.0, 0.0,
297       0.0, 1.0, 0.0, 0.0,
298       0.0, 0.0, 0.1, 0.0,
299       0.0, 0.0, 0.0, 1.0
300    };
301
302    if (width < height)
303      ar = width;
304    else
305      ar = height;
306
307    m[0] = 0.1 * ar / width;
308    m[5] = 0.1 * ar / height;
309    memcpy(gld->proj, m, sizeof gld->proj);
310    gl->glViewport(0, 0, (GLint) width, (GLint) height);
311 }
312
313 static const char vertex_shader[] =
314    "uniform mat4 proj;\n"
315    "attribute vec4 position;\n"
316    "attribute vec4 normal;\n"
317    "varying vec3 rotated_normal;\n"
318    "varying vec3 rotated_position;\n"
319    "vec4 tmp;\n"
320    "void main()\n"
321    "{\n"
322    "   gl_Position = proj * position;\n"
323    "   rotated_position = gl_Position.xyz;\n"
324    "   tmp = proj * normal;\n"
325    "   rotated_normal = tmp.xyz;\n"
326    "}\n";
327
328  static const char fragment_shader[] =
329    "precision mediump float;\n"
330    "uniform vec4 color;\n"
331    "uniform vec3 light;\n"
332    "varying vec3 rotated_normal;\n"
333    "varying vec3 rotated_position;\n"
334    "vec3 light_direction;\n"
335    "vec4 white = vec4(0.5, 0.5, 0.5, 1.0);\n"
336    "void main()\n"
337    "{\n"
338    "   light_direction = normalize(light - rotated_position);\n"
339    "   gl_FragColor = color + white * dot(light_direction, rotated_normal);\n"
340    "}\n";
341
342
343 static void
344 gears_init(GLData *gld)
345 {
346    Evas_GL_API *gl = gld->glapi;
347
348    const char *p;
349    char msg[512];
350
351    gl->glEnable(GL_CULL_FACE);
352    gl->glEnable(GL_DEPTH_TEST);
353
354    p = vertex_shader;
355    gld->vtx_shader = gl->glCreateShader(GL_VERTEX_SHADER);
356    gl->glShaderSource(gld->vtx_shader, 1, &p, NULL);
357    gl->glCompileShader(gld->vtx_shader);
358    gl->glGetShaderInfoLog(gld->vtx_shader, sizeof msg, NULL, msg);
359    printf("vertex shader info: %s\n", msg);
360
361    p = fragment_shader;
362    gld->fgmt_shader = gl->glCreateShader(GL_FRAGMENT_SHADER);
363    gl->glShaderSource(gld->fgmt_shader, 1, &p, NULL);
364    gl->glCompileShader(gld->fgmt_shader);
365    gl->glGetShaderInfoLog(gld->fgmt_shader, sizeof msg, NULL, msg);
366    printf("fragment shader info: %s\n", msg);
367
368    gld->program = gl->glCreateProgram();
369    gl->glAttachShader(gld->program, gld->vtx_shader);
370    gl->glAttachShader(gld->program, gld->fgmt_shader);
371    gl->glBindAttribLocation(gld->program, 0, "position");
372    gl->glBindAttribLocation(gld->program, 1, "normal");
373
374    gl->glLinkProgram(gld->program);
375    gl->glGetProgramInfoLog(gld->program, sizeof msg, NULL, msg);
376    printf("info: %s\n", msg);
377
378    gl->glUseProgram(gld->program);
379    gld->proj_location  = gl->glGetUniformLocation(gld->program, "proj");
380    gld->light_location = gl->glGetUniformLocation(gld->program, "light");
381    gld->color_location = gl->glGetUniformLocation(gld->program, "color");
382
383    /* make the gears */
384    gld->gear1 = make_gear(gld, 1.0, 4.0, 1.0, 20, 0.7);
385    gld->gear2 = make_gear(gld, 0.5, 2.0, 2.0, 10, 0.7);
386    gld->gear3 = make_gear(gld, 1.3, 2.0, 0.5, 10, 0.7);
387 }
388
389
390 static void
391 gldata_init(GLData *gld)
392 {
393    gld->initialized = 0;
394    gld->mouse_down = 0;
395
396    gld->view_rotx = -20.0;
397    gld->view_roty = -30.0;
398    gld->view_rotz = 0.0;
399    gld->angle = 0.0;
400
401    gld->light[0] = 1.0;
402    gld->light[1] = 1.0;
403    gld->light[2] = -5.0;
404 }
405
406
407 //-------------------------//
408
409 static void
410 _init_gl(Evas_Object *obj)
411 {
412    GLData *gld = evas_object_data_get(obj, "gld");
413
414    gears_init(gld);
415 }
416
417 static void
418 _del_gl(Evas_Object *obj)
419 {
420    GLData *gld = evas_object_data_get(obj, "gld");
421    if (!gld)
422      {
423         printf("Unable to get GLData. \n");
424         return;
425      }
426    Evas_GL_API *gl = gld->glapi;
427
428    gl->glDeleteShader(gld->vtx_shader);
429    gl->glDeleteShader(gld->fgmt_shader);
430    gl->glDeleteProgram(gld->program);
431    gl->glDeleteBuffers(1, &gld->gear1->vbo);
432    gl->glDeleteBuffers(1, &gld->gear2->vbo);
433    gl->glDeleteBuffers(1, &gld->gear3->vbo);
434
435    free_gear(gld->gear1);
436    free_gear(gld->gear2);
437    free_gear(gld->gear3);
438
439    evas_object_data_del((Evas_Object*)obj, "..gld");
440    free(gld);
441 }
442
443
444 static void
445 _resize_gl(Evas_Object *obj)
446 {
447    int w, h;
448    GLData *gld = evas_object_data_get(obj, "gld");
449
450    elm_glview_size_get(obj, &w, &h);
451
452    // GL Viewport stuff. you can avoid doing this if viewport is all the
453    // same as last frame if you want
454    gears_reshape(gld, w,h);
455 }
456
457
458
459 static void
460 _draw_gl(Evas_Object *obj)
461 {
462    Evas_GL_API *gl = elm_glview_gl_api_get(obj);
463    GLData *gld = evas_object_data_get(obj, "gld");
464    if (!gld) return;
465
466    render_gears(gld);
467    gl->glFinish();
468 }
469
470 static Eina_Bool
471 _anim(void *data)
472 {
473    elm_glview_changed_set(data);
474    return EINA_TRUE;
475 }
476
477 static void
478 _on_done(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
479 {
480    evas_object_del((Evas_Object*)data);
481 }
482
483
484 static void
485 _del(void *data __UNUSED__, Evas *evas __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
486 {
487    Ecore_Animator *ani = evas_object_data_get(obj, "ani");
488    ecore_animator_del(ani);
489 }
490
491
492 static void
493 _key_down(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info)
494 {
495    Evas_Event_Key_Down *ev;
496    ev = (Evas_Event_Key_Down *)event_info;
497    GLData *gld = evas_object_data_get(obj, "gld");
498
499    if (strcmp(ev->keyname, "Left") == 0)
500      {
501         gld->view_roty += 5.0;
502         return;
503      }
504
505    if (strcmp(ev->keyname, "Right") == 0)
506      {
507         gld->view_roty -= 5.0;
508         return;
509      }
510
511    if (strcmp(ev->keyname, "Up") == 0)
512      {
513         gld->view_rotx += 5.0;
514         return;
515      }
516
517    if (strcmp(ev->keyname, "Down") == 0)
518      {
519         gld->view_rotx -= 5.0;
520         return;
521      }
522    if ((strcmp(ev->keyname, "Escape") == 0) ||
523        (strcmp(ev->keyname, "Return") == 0))
524      {
525         //_on_done(data, obj, event_info);
526         return;
527      }
528 }
529
530 static void
531 _mouse_down(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
532 {
533    GLData *gld = evas_object_data_get(obj, "gld");
534    gld->mouse_down = 1;
535 }
536
537 static void
538 _mouse_move(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
539 {
540    Evas_Event_Mouse_Move *ev;
541    ev = (Evas_Event_Mouse_Move *)event_info;
542    GLData *gld = evas_object_data_get(obj, "gld");
543    float dx = 0, dy = 0;
544
545    if (gld->mouse_down)
546      {
547         dx = ev->cur.canvas.x - ev->prev.canvas.x;
548         dy = ev->cur.canvas.y - ev->prev.canvas.y;
549
550         gld->view_roty += -1.0 * dx;
551         gld->view_rotx += -1.0 * dy;
552      }
553 }
554
555 static void
556 _mouse_up(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
557 {
558    GLData *gld = evas_object_data_get(obj, "gld");
559    gld->mouse_down = 0;
560 }
561
562
563 void
564 test_glview(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
565 {
566    Evas_Object *win, *bg, *bx, *bt, *gl;
567    Ecore_Animator *ani;
568    GLData *gld = NULL;
569
570    // alloc a data struct to hold our relevant gl info in
571    if (!(gld = calloc(1, sizeof(GLData)))) return;
572    gldata_init(gld);
573
574    // new window - do the usual and give it a name, title and delete handler
575    win = elm_win_add(NULL, "glview", ELM_WIN_BASIC);
576    elm_win_title_set(win, "GLView");
577    elm_win_autodel_set(win, 1);
578
579
580    // add a standard bg
581    bg = elm_bg_add(win);
582    evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
583    elm_win_resize_object_add(win, bg);
584    evas_object_show(bg);
585
586    bx = elm_box_add(win);
587    evas_object_size_hint_weight_set(bx, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
588    elm_win_resize_object_add(win, bx);
589    evas_object_show(bx);
590
591    // Add a GLView
592    gl = elm_glview_add(win);
593    evas_object_size_hint_align_set(gl, EVAS_HINT_FILL, EVAS_HINT_FILL);
594    evas_object_size_hint_weight_set(gl, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
595    elm_glview_mode_set(gl, ELM_GLVIEW_ALPHA|ELM_GLVIEW_DEPTH);
596    elm_glview_resize_policy_set(gl, ELM_GLVIEW_RESIZE_POLICY_RECREATE);
597    elm_glview_render_policy_set(gl, ELM_GLVIEW_RENDER_POLICY_ALWAYS);
598    elm_glview_init_func_set(gl, _init_gl);
599    elm_glview_del_func_set(gl, _del_gl);
600    elm_glview_resize_func_set(gl, _resize_gl);
601    elm_glview_render_func_set(gl, (Elm_GLView_Func)_draw_gl);
602    elm_box_pack_end(bx, gl);
603    evas_object_show(gl);
604
605    // Add Mouse/Key Event Callbacks
606    elm_object_focus(gl);
607    evas_object_event_callback_add(gl, EVAS_CALLBACK_KEY_DOWN, _key_down, gl);
608    evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, gl);
609    evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_UP, _mouse_up, gl);
610    evas_object_event_callback_add(gl, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move, gl);
611
612
613    // Animator and other vars
614    ani = ecore_animator_add(_anim, gl);
615    gld->glapi = elm_glview_gl_api_get(gl);
616    evas_object_data_set(gl, "ani", ani);
617    evas_object_data_set(gl, "gld", gld);
618    evas_object_event_callback_add(gl, EVAS_CALLBACK_DEL, _del, gl);
619
620
621    /* add an ok button */
622    bt = elm_button_add(win);
623    elm_object_text_set(bt, "OK");
624    evas_object_size_hint_align_set(bt, EVAS_HINT_FILL, EVAS_HINT_FILL);
625    evas_object_size_hint_weight_set(bt, EVAS_HINT_EXPAND, 0.0);
626    elm_box_pack_end(bx, bt);
627    evas_object_show(bt);
628    evas_object_smart_callback_add(bt, "clicked", _on_done, win);
629
630    evas_object_resize(win, 320, 480);
631    evas_object_show(win);
632 }
633 #endif