tests/test-homescreen.c

   1 /*
   2  * Copyright © 2012 Intel Corporation
   3  * Copyright © 2013 TOYOTA MOTOR CORPORATION
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that copyright
   8  * notice and this permission notice appear in supporting documentation, and
   9  * that the name of the copyright holders not be used in advertising or
  10  * publicity pertaining to distribution of the software without specific,
  11  * written prior permission.  The copyright holders make no representations
  12  * about the suitability of this software for any purpose.  It is provided "as
  13  * is" without express or implied warranty.
  14  *
  15  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  17  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  18  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  19  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  20  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  21  * OF THIS SOFTWARE.
  22  */
  23 /**
  24  * @brief   HomeScreen for unit test of Weston(Wayland) IVI plugins
  25  *
  26  * @date    Feb-08-2013
  27  */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <assert.h>
  34 #include <poll.h>
  35 #include <errno.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/ipc.h>
  38 #include <sys/msg.h>
  39 #include <sys/time.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/mman.h>
  43 #include <signal.h>
  44 #include <fcntl.h>
  45 #include <linux/input.h>
  46 #include <wayland-client.h>
  47 #include "ico_window_mgr-client-protocol.h"
  48 #include "ico_input_mgr-client-protocol.h"
  49 #include "ico_input_mgr.h"
  50 #include "test-common.h"
  51
  52 #define MAX_APPID   128
  53 #define SHM_SIZE    (16*1024*1024)
  54 #define MAX_CON_NAME    127
  55 #define MAX_OUTPUT      8
  56
  57 struct surface_name {
  58     struct surface_name *next;
  59     int     surfaceid;
  60     int     pid;
  61     char    appid[MAX_APPID];
  62     int     node;
  63     int     x;
  64     int     y;
  65     int     width;
  66     int     height;
  67     int     visible;
  68 };
  69
  70 struct display {
  71     struct wl_display *display;
  72     struct wl_registry *registry;
  73     struct wl_compositor *compositor;
  74     struct wl_shell *shell;
  75     struct ico_window_mgr *ico_window_mgr;
  76     struct ico_input_mgr_control *ico_input_mgr;
  77     struct ico_input_mgr_device *ico_input_device;
  78     struct ico_exinput *ico_exinput;
  79     struct input *input;
  80     int    num_output;
  81     struct output *output[MAX_OUTPUT];
  82     struct surface *surface;
  83     struct surface_name *surface_name;
  84     struct surface_name *bgsurface_name;
  85     int    bg_created;
  86     int    init_color;
  87     int    init_width;
  88     int    init_height;
  89     int    surface_created;
  90     int    surface_destroyed;
  91     int    prompt;
  92     int    visible_on_create;
  93     char   connect[MAX_CON_NAME+1];
  94 };
  95
  96 struct input {
  97     struct display *display;
  98     struct wl_seat *seat;
  99     struct wl_pointer *pointer;
 100     struct wl_keyboard *keyboard;
 101     struct wl_touch *touch;
 102     float x, y;
 103     uint32_t button_mask;
 104     struct surface *pointer_focus;
 105     struct surface *keyboard_focus;
 106     uint32_t last_key, last_key_state;
 107 };
 108
 109 struct output {
 110     struct display *display;
 111     struct wl_output *output;
 112     int x, y;
 113     int width, height;
 114 };
 115
 116 struct surface {
 117     struct display *display;
 118     struct wl_surface *surface;
 119     struct wl_shell_surface *shell_surface;
 120     struct output *output;
 121     EGLDisplay  dpy;
 122     EGLConfig   conf;
 123     EGLContext  ctx;
 124     EGLSurface  egl_surface;
 125 };
 126
 127 static void clear_surface(struct display *display);
 128
 129 static void
 130 pointer_handle_enter(void *data, struct wl_pointer *pointer,
 131                      uint32_t serial, struct wl_surface *surface,
 132                      wl_fixed_t x, wl_fixed_t y)
 133 {
 134     struct input *input = data;
 135
 136     input->pointer_focus = wl_surface_get_user_data(surface);
 137     input->x = wl_fixed_to_double(x);
 138     input->y = wl_fixed_to_double(y);
 139     print_log("HOMESCREEN: got pointer enter (%d,%d), surface %p",
 140               (int)input->x, (int)input->y, surface);
 141 }
 142
 143 static void
 144 pointer_handle_leave(void *data, struct wl_pointer *pointer,
 145                      uint32_t serial, struct wl_surface *surface)
 146 {
 147     struct input *input = data;
 148
 149     input->pointer_focus = NULL;
 150
 151     print_log("HOMESCREEN: got pointer leave, surface %p", surface);
 152 }
 153
 154 static void
 155 pointer_handle_motion(void *data, struct wl_pointer *pointer,
 156                       uint32_t time, wl_fixed_t x, wl_fixed_t y)
 157 {
 158     struct input *input = data;
 159
 160     input->x = wl_fixed_to_double(x);
 161     input->y = wl_fixed_to_double(y);
 162
 163     print_log("HOMESCREEN: got pointer motion (%d,%d)", (int)input->x, (int)input->y);
 164 }
 165
 166 static void
 167 pointer_handle_button(void *data, struct wl_pointer *pointer,
 168                       uint32_t serial, uint32_t time, uint32_t button, uint32_t state_w)
 169 {
 170     struct input *input = data;
 171     uint32_t bit;
 172     enum wl_pointer_button_state state = state_w;
 173
 174     bit = 1 << (button - BTN_LEFT);
 175     if (state == WL_POINTER_BUTTON_STATE_PRESSED)
 176         input->button_mask |= bit;
 177     else
 178         input->button_mask &= ~bit;
 179     print_log("HOMESCREEN: got pointer button %u %u", button, state_w);
 180 }
 181
 182 static void
 183 pointer_handle_axis(void *data, struct wl_pointer *pointer,
 184                     uint32_t time, uint32_t axis, wl_fixed_t value)
 185 {
 186     print_log("HOMESCREEN: got pointer axis %u %d", axis, value);
 187 }
 188
 189 static void
 190 keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
 191                        uint32_t format, int fd, uint32_t size)
 192 {
 193     close(fd);
 194     print_log("HOMESCREEN: got keyboard keymap");
 195 }
 196
 197 static void
 198 keyboard_handle_enter(void *data, struct wl_keyboard *keyboard,
 199                       uint32_t serial, struct wl_surface *surface, struct wl_array *keys)
 200 {
 201     struct input *input = data;
 202
 203     input->keyboard_focus = wl_surface_get_user_data(surface);
 204     print_log("HOMESCREEN: got keyboard enter, surface %p", surface);
 205 }
 206
 207 static void
 208 keyboard_handle_leave(void *data, struct wl_keyboard *keyboard,
 209                       uint32_t serial, struct wl_surface *surface)
 210 {
 211     struct input *input = data;
 212
 213     input->keyboard_focus = NULL;
 214     print_log("HOMESCREEN: got keyboard leave, surface %p", surface);
 215 }
 216
 217 static void
 218 keyboard_handle_key(void *data, struct wl_keyboard *keyboard,
 219                     uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
 220 {
 221     struct input *input = data;
 222
 223     input->last_key = key;
 224     input->last_key_state = state;
 225
 226     print_log("HOMESCREEN: got keyboard key %u %u", key, state);
 227 }
 228
 229 static void
 230 keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard,
 231                           uint32_t serial, uint32_t mods_depressed,
 232                           uint32_t mods_latched, uint32_t mods_locked, uint32_t group)
 233 {
 234     print_log("HOMESCREEN: got keyboard modifier");
 235 }
 236
 237 static void
 238 touch_handle_down(void *data, struct wl_touch *wl_touch, uint32_t serial, uint32_t time,
 239                   struct wl_surface *surface, int32_t id, wl_fixed_t x, wl_fixed_t y)
 240 {
 241     print_log("HOMESCREEN: got touch down %d (%d,%d)", id, x/256, y/256);
 242 }
 243
 244 static void
 245 touch_handle_up(void *data, struct wl_touch *wl_touch, uint32_t serial, uint32_t time,
 246                 int32_t id)
 247 {
 248     print_log("HOMESCREEN: got touch up %d", id);
 249 }
 250
 251 static void
 252 touch_handle_motion(void *data, struct wl_touch *wl_touch, uint32_t time,
 253                     int32_t id, wl_fixed_t x, wl_fixed_t y)
 254 {
 255     print_log("HOMESCREEN: got touch motion %d (%d,%d)", id, x/256, y/256);
 256 }
 257
 258 static void
 259 touch_handle_frame(void *data, struct wl_touch *wl_touch)
 260 {
 261     print_log("HOMESCREEN: got touch frame");
 262 }
 263
 264 static void
 265 touch_handle_cancel(void *data, struct wl_touch *wl_touch)
 266 {
 267     print_log("HOMESCREEN: got touch cancel");
 268 }
 269
 270 static const struct wl_pointer_listener pointer_listener = {
 271     pointer_handle_enter,
 272     pointer_handle_leave,
 273     pointer_handle_motion,
 274     pointer_handle_button,
 275     pointer_handle_axis,
 276 };
 277
 278 static const struct wl_keyboard_listener keyboard_listener = {
 279     keyboard_handle_keymap,
 280     keyboard_handle_enter,
 281     keyboard_handle_leave,
 282     keyboard_handle_key,
 283     keyboard_handle_modifiers,
 284 };
 285
 286 static const struct wl_touch_listener touch_listener = {
 287     touch_handle_down,
 288     touch_handle_up,
 289     touch_handle_motion,
 290     touch_handle_frame,
 291     touch_handle_cancel
 292 };
 293
 294 static void
 295 seat_handle_capabilities(void *data, struct wl_seat *seat,
 296                          enum wl_seat_capability caps)
 297 {
 298     struct input *input = data;
 299
 300     print_log("HOMESCREEN: seat_handle_capabilities caps=%x", caps);
 301
 302     if ((caps & WL_SEAT_CAPABILITY_POINTER) && !input->pointer) {
 303         input->pointer = wl_seat_get_pointer(seat);
 304         print_log("HOMESCREEN: seat_handle_capabilities add pointer=%x", (int)input->pointer);
 305         wl_pointer_set_user_data(input->pointer, input);
 306         wl_pointer_add_listener(input->pointer, &pointer_listener, input);
 307     }
 308     else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && input->pointer) {
 309         print_log("HOMESCREEN: seat_handle_capabilities delete pointer");
 310         wl_pointer_destroy(input->pointer);
 311         input->pointer = NULL;
 312     }
 313
 314     if ((caps & WL_SEAT_CAPABILITY_KEYBOARD) && !input->keyboard) {
 315         input->keyboard = wl_seat_get_keyboard(seat);
 316         print_log("HOMESCREEN: seat_handle_capabilities add keyboard=%x", (int)input->keyboard);
 317         wl_keyboard_set_user_data(input->keyboard, input);
 318         wl_keyboard_add_listener(input->keyboard, &keyboard_listener, input);
 319     }
 320     else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && input->keyboard) {
 321         print_log("HOMESCREEN: seat_handle_capabilities delete keyboard");
 322         wl_keyboard_destroy(input->keyboard);
 323         input->keyboard = NULL;
 324     }
 325
 326     if ((caps & WL_SEAT_CAPABILITY_TOUCH) && !input->touch) {
 327         input->touch = wl_seat_get_touch(seat);
 328         print_log("HOMESCREEN: seat_handle_capabilities add touch=%x", (int)input->touch);
 329         wl_touch_set_user_data(input->touch, input);
 330         wl_touch_add_listener(input->touch, &touch_listener, input);
 331     }
 332     else if (!(caps & WL_SEAT_CAPABILITY_TOUCH) && input->touch) {
 333         print_log("HOMESCREEN: seat_handle_capabilities delete touch");
 334         wl_touch_destroy(input->touch);
 335         input->touch = NULL;
 336     }
 337 }
 338
 339 static const struct wl_seat_listener seat_listener = {
 340     seat_handle_capabilities,
 341 };
 342
 343 static void
 344 surface_enter(void *data, struct wl_surface *wl_surface, struct wl_output *output)
 345 {
 346     struct surface *surface = data;
 347
 348     surface->output = wl_output_get_user_data(output);
 349
 350     print_log("HOMESCREEN: got surface enter, output %p", surface->output);
 351 }
 352
 353 static void
 354 surface_leave(void *data, struct wl_surface *wl_surface, struct wl_output *output)
 355 {
 356     struct surface *surface = data;
 357
 358     surface->output = NULL;
 359
 360     print_log("HOMESCREEN: got surface leave, output %p",
 361               wl_output_get_user_data(output));
 362 }
 363
 364 static const struct wl_surface_listener surface_listener = {
 365     surface_enter,
 366     surface_leave
 367 };
 368
 369 static void
 370 create_surface(struct display *display, const char *title)
 371 {
 372     struct surface *surface;
 373     int id;
 374
 375     surface = malloc(sizeof *surface);
 376     assert(surface);
 377     surface->display = display;
 378     display->surface = surface;
 379     surface->surface = wl_compositor_create_surface(display->compositor);
 380     wl_surface_add_listener(surface->surface, &surface_listener, surface);
 381
 382     if (display->shell) {
 383         surface->shell_surface =
 384             wl_shell_get_shell_surface(display->shell, surface->surface);
 385         if (surface->shell_surface) {
 386             wl_shell_surface_set_toplevel(surface->shell_surface);
 387             wl_shell_surface_set_title(surface->shell_surface, title);
 388         }
 389     }
 390     wl_display_flush(display->display);
 391
 392     id = wl_proxy_get_id((struct wl_proxy *) surface->surface);
 393     print_log("HOMESCREEN: create surface = %d", id);
 394
 395     poll(NULL, 0, 100); /* Wait for next frame where we'll get events. */
 396
 397     wl_display_roundtrip(display->display);
 398
 399     surface->dpy = opengl_init(display->display, &surface->conf, &surface->ctx);
 400     if (surface->dpy)   {
 401         surface->egl_surface = opengl_create_window(display->display, surface->surface,
 402                                                     surface->dpy, surface->conf,
 403                                                     surface->ctx, display->init_width,
 404                                                     display->init_height,
 405                                                     display->init_color);
 406         clear_surface(display);
 407         print_log("HOMESCREEN: created egl_surface %08x", (int)surface->egl_surface);
 408     }
 409 }
 410
 411 static void
 412 clear_surface(struct display *display)
 413 {
 414     if (! display->surface) {
 415         create_surface(display, "HomeScreen-BG");
 416     }
 417     else    {
 418         opengl_clear_window(display->init_color);
 419         opengl_swap_buffer(display->display,
 420                            display->surface->dpy, display->surface->egl_surface);
 421     }
 422 }
 423
 424 static void
 425 output_handle_geometry(void *data, struct wl_output *wl_output, int x, int y,
 426                        int physical_width, int physical_height, int subpixel,
 427                        const char *make, const char *model, int32_t transform)
 428 {
 429     struct output *output = data;
 430
 431     print_log("HOMESCREEN: Event[handle_geometry] %08x x/y=%d/%d p.w/h=%d/%d trans=%d",
 432               (int)wl_output, x, y, physical_width, physical_height, transform);
 433
 434     output->x = x;
 435     output->y = y;
 436 }
 437
 438 static void
 439 output_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags,
 440                    int width, int height, int refresh)
 441 {
 442     struct output *output = data;
 443
 444     print_log("HOMESCREEN: Event[handle_mode] %08x x/y=%d/%d flags=%08x refresh=%d",
 445               (int)wl_output, width, height, flags, refresh);
 446
 447     if (flags & WL_OUTPUT_MODE_CURRENT) {
 448         struct display  *display = output->display;
 449
 450         output->width = width;
 451         output->height = height;
 452
 453         display->init_width = width;
 454         display->init_height = height;
 455
 456         if (display->bgsurface_name)    {
 457             ico_window_mgr_set_positionsize(display->ico_window_mgr,
 458                                             display->bgsurface_name->surfaceid,
 459                                             0, 0, 0, 0, width, height);
 460         }
 461         else if (display->bg_created == 0)  {
 462             display->bg_created = 9;
 463             create_surface(display, "HomeScreen-BG");
 464         }
 465     }
 466 }
 467
 468 static const struct wl_output_listener output_listener = {
 469     output_handle_geometry,
 470     output_handle_mode
 471 };
 472
 473 static int
 474 search_surface(struct display *display, const char *surfname)
 475 {
 476     struct surface_name     *p;
 477
 478     p = display->surface_name;
 479     while (p)   {
 480         if (strcmp(p->appid, surfname) == 0)    break;
 481         p = p->next;
 482     }
 483
 484     if (p)  {
 485         return p->surfaceid;
 486     }
 487     else    {
 488         if ((strcasecmp(surfname, "all") == 0) ||
 489             (strcasecmp(surfname, "main") == 0))    {
 490             return ICO_WINDOW_MGR_V_MAINSURFACE;
 491         }
 492         return -1;
 493     }
 494 }
 495
 496 static struct surface_name *
 497 search_surfacename(struct display *display, const char *surfname)
 498 {
 499     struct surface_name     *p;
 500
 501     p = display->surface_name;
 502     while (p)   {
 503         if (strcmp(p->appid, surfname) == 0)    break;
 504         p = p->next;
 505     }
 506     if (! p)    {
 507         print_log("HOMESCREEN: app(%s) dose not exist", surfname);
 508     }
 509     return p;
 510 }
 511
 512 static struct surface_name *
 513 search_surfaceid(struct display *display, const int surfaceid)
 514 {
 515     struct surface_name     *p;
 516
 517     p = display->surface_name;
 518     while (p)   {
 519         if (p->surfaceid == surfaceid)  {
 520             return p;
 521         }
 522         p = p->next;
 523     }
 524     return NULL;
 525 }
 526
 527 static void
 528 window_created(void *data, struct ico_window_mgr *ico_window_mgr,
 529                uint32_t surfaceid, const char *winname, int32_t pid,
 530                const char *appid, int32_t layertype)
 531 {
 532     struct display *display = data;
 533     struct surface_name     *p;
 534     struct surface_name     *fp;
 535
 536     display->surface_created = 1;
 537     p = display->surface_name;
 538     fp = NULL;
 539     while (p)   {
 540         if (p->surfaceid == (int)surfaceid) break;
 541         fp = p;
 542         p = p->next;
 543     }
 544     if (p)  {
 545         print_log("HOMESCREEN: Event[window_created] "
 546                   "surface=%08x(app=%s,name=%s,type=%x) exist",
 547                   (int)surfaceid, appid, winname, layertype);
 548     }
 549     else    {
 550         print_log("HOMESCREEN: Event[window_created] "
 551                   "new surface=%08x(app=%s) winname=%s layertype=%x",
 552                   (int)surfaceid, appid, winname, layertype);
 553         p = malloc(sizeof(struct surface_name));
 554         if (! p)    {
 555             return;
 556         }
 557         memset(p, 0, sizeof(struct surface_name));
 558         if (fp) {
 559             fp->next = p;
 560         }
 561         else    {
 562             display->surface_name = p;
 563         }
 564     }
 565     p->surfaceid = surfaceid;
 566     p->pid = pid;
 567     strncpy(p->appid, appid, MAX_APPID-1);
 568
 569     /* Set default size and show        */
 570     if (p->width > 0)   {
 571         ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
 572                                         0, p->x, p->y, p->width, p->height, 0);
 573     }
 574
 575     print_log("HOMESCREEN: Created window[%08x] (app=%s)", (int)surfaceid, appid);
 576
 577     if (strncasecmp(appid, "test-homescreen", 15) == 0) {
 578         display->bgsurface_name = p;
 579         if (display->bg_created == 1)   {
 580             display->bg_created = 9;
 581             ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
 582                                             0, 0, 0,
 583                                             display->init_width, display->init_height, 0);
 584         }
 585         ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid, 1, 0, 0);
 586         print_log("HOMESCREEN: Created window[%08x] (app=%s) Visible",
 587                   (int)surfaceid, appid);
 588         p->visible = 1;
 589     }
 590 }
 591
 592 static void
 593 window_name(void *data, struct ico_window_mgr *ico_window_mgr,
 594             uint32_t surfaceid, const char *winname)
 595 {
 596     print_log("HOMESCREEN: Window Name[%08x] (name=%s)", (int)surfaceid, winname);
 597 }
 598
 599 static void
 600 window_destroyed(void *data, struct ico_window_mgr *ico_window_mgr, uint32_t surfaceid)
 601 {
 602     struct display *display = data;
 603     struct surface_name     *p;
 604     struct surface_name     *fp;
 605
 606     display->surface_destroyed = 1;
 607     p = search_surfaceid(display, (int)surfaceid);
 608     if (! p)    {
 609         print_log("HOMESCREEN: Event[window_destroyed] surface=%08x dose not exist",
 610                   (int)surfaceid);
 611     }
 612     else    {
 613         print_log("HOMESCREEN: Event[window_destroyed] surface=%08x", (int)surfaceid);
 614         if (p == display->surface_name) {
 615             display->surface_name = p->next;
 616         }
 617         else    {
 618             fp = display->surface_name;
 619             while (fp)  {
 620                 if (fp->next == p)  {
 621                     fp->next = p->next;
 622                     break;
 623                 }
 624                 fp = fp->next;
 625             }
 626         }
 627         free(p);
 628     }
 629 }
 630
 631 static void
 632 window_visible(void *data, struct ico_window_mgr *ico_window_mgr,
 633                uint32_t surfaceid, int32_t visible, int32_t raise, int32_t hint)
 634 {
 635     struct display *display = data;
 636     struct surface_name     *p;
 637
 638     p = search_surfaceid(display, (int)surfaceid);
 639     if (! p)    {
 640         print_log("HOMESCREEN: Event[window_visible] surface=%08x dose not exist",
 641                   (int)surfaceid);
 642     }
 643     else    {
 644         print_log("HOMESCREEN: Event[window_visible] surface=%08x "
 645                   "visible=%d raise=%d hint=%d", (int)surfaceid, visible, raise, hint);
 646         p->visible = visible;
 647         if (hint == 1)  {
 648             ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
 649                                        visible, ICO_WINDOW_MGR_V_NOCHANGE, 0);
 650         }
 651     }
 652 }
 653
 654 static void
 655 window_configure(void *data, struct ico_window_mgr *ico_window_mgr,
 656                  uint32_t surfaceid, uint32_t node, int32_t layertype, uint32_t layer,
 657                  int32_t x, int32_t y, int32_t width, int32_t height, int32_t hint)
 658 {
 659     struct display *display = data;
 660     struct surface_name     *p;
 661
 662     print_log("HOMESCREEN: Event[window_configure] surface=%08x "
 663               "node=%x layer=%x.%x x/y=%d/%d w/h=%d/%d hint=%d",
 664               (int)surfaceid, node, layertype, layer, x, y, width, height, hint);
 665
 666     p = search_surfaceid(display, (int)surfaceid);
 667     if (! p)    {
 668         print_log("HOMESCREEN: Event[window_configure] surface=%08x dose not exist",
 669                   (int)surfaceid);
 670     }
 671     else    {
 672         p->node = node;
 673     }
 674 }
 675
 676 static void
 677 window_layer_visible(void *data, struct ico_window_mgr *ico_window_mgr,
 678                      uint32_t layer, int32_t visible)
 679 {
 680     print_log("HOMESCREEN: Event[layer_visible]layer=%x visible=%d",
 681               (int)layer, visible);
 682 }
 683
 684 static void
 685 window_active(void *data, struct ico_window_mgr *ico_window_mgr,
 686               uint32_t surfaceid, const int32_t active)
 687 {
 688     print_log("HOMESCREEN: Event[window_active] surface=%08x acive=%d",
 689               (int)surfaceid, (int)active);
 690     if ((surfaceid & 0x0000ffff) == 0x0001) {
 691         ico_window_mgr_set_visible(ico_window_mgr, surfaceid,
 692                                    ICO_WINDOW_MGR_V_NOCHANGE, 0, 0);
 693     }
 694 }
 695
 696 static void
 697 window_surfaces(void *data, struct ico_window_mgr *ico_window_mgr,
 698                 const char *appid, int32_t pid, struct wl_array *surfaces)
 699 {
 700     print_log("HOMESCREEN: Event[app_surfaces] app=%s pid=%d", appid, pid);
 701 }
 702
 703 static void
 704 window_map(void *data, struct ico_window_mgr *ico_window_mgr,
 705            int32_t event, uint32_t surfaceid, uint32_t type, uint32_t target,
 706            int32_t width, int32_t height, int32_t stride, uint32_t format)
 707 {
 708     char    sevt[16];
 709
 710     switch (event)  {
 711     case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_CONTENTS:
 712         strcpy(sevt, "Contents");   break;
 713     case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_RESIZE:
 714         strcpy(sevt, "Resize"); break;
 715     case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_MAP:
 716         strcpy(sevt, "Map");    break;
 717     case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_UNMAP:
 718         strcpy(sevt, "Unmap");  break;
 719     case ICO_WINDOW_MGR_MAP_SURFACE_EVENT_ERROR:
 720         sprintf(sevt, "Error %d", type);  break;
 721     default:
 722         sprintf(sevt, "??%d??", event); break;
 723     }
 724     print_log("HOMESCREEN: Event[map_surface] ev=%s(%d) surf=%08x type=%d target=%x "
 725               "w/h/s/f=%d/%d/%d/%x",
 726               sevt, event, (int)surfaceid, type, target, width, height, stride, format);
 727 }
 728
 729 static const struct ico_window_mgr_listener window_mgr_listener = {
 730     window_created,
 731     window_name,
 732     window_destroyed,
 733     window_visible,
 734     window_configure,
 735     window_active,
 736     window_layer_visible,
 737     window_surfaces,
 738     window_map
 739 };
 740
 741 static void
 742 cb_input_capabilities(void *data, struct ico_exinput *ico_exinput,
 743                       const char *device, int32_t type, const char *swname, int32_t input,
 744                       const char *codename, int32_t code)
 745 {
 746     print_log("HOMESCREEN: Event[input_capabilities] device=%s type=%d sw=%s input=%d "
 747               "code=%s[%d]", device, type, swname, input, codename, code);
 748 }
 749
 750 static void
 751 cb_input_code(void *data, struct ico_exinput *ico_exinput,
 752               const char *device, int32_t input, const char *codename, int32_t code)
 753 {
 754     print_log("HOMESCREEN: Event[input_code] device=%s input=%d code=%s[%d]",
 755               device, input, codename, code);
 756 }
 757
 758 static void
 759 cb_input_input(void *data, struct ico_exinput *ico_exinput, uint32_t time,
 760                const char *device, int32_t input, int32_t code, int32_t state)
 761 {
 762     print_log("HOMESCREEN: Event[input_input] device=%s input=%d code=%d state=%d",
 763               device, input, code, state);
 764 }
 765
 766 static const struct ico_exinput_listener exinput_listener = {
 767     cb_input_capabilities,
 768     cb_input_code,
 769     cb_input_input
 770 };
 771
 772 static void
 773 cb_input_regions(void *data, struct ico_input_mgr_device *ico_input_mgr_device,
 774                  struct wl_array *regions)
 775 {
 776     struct ico_uifw_input_region    *region;
 777     int     n;
 778     char    schange[16];
 779
 780     n = 0;
 781     if (regions)    {
 782         wl_array_for_each(region, regions)  {
 783             n ++;
 784         }
 785         print_log("HOMESCREEN: Event[input_regions] number of regions=%d", n);
 786         n = 0;
 787         wl_array_for_each(region, regions)  {
 788             n ++;
 789             switch (region->change) {
 790             case ICO_INPUT_MGR_DEVICE_REGION_ADD:
 791                 strcpy(schange, "Add");
 792                 break;
 793             case ICO_INPUT_MGR_DEVICE_REGION_REMOVE:
 794                 strcpy(schange, "Remove");
 795                 break;
 796             case ICO_INPUT_MGR_DEVICE_REGION_REMOVEALL:
 797                 strcpy(schange, "RemoveAll");
 798                 break;
 799             default:
 800                 sprintf(schange, "?%d?", region->change);
 801                 break;
 802             }
 803             print_log("HOMESCREEN:%2d. %s %d.%08x(%d/%d) %d/%d-%d/%d "
 804                       "hot=%d/%d cur=%d/%d-%d/%d attr=%x",
 805                       n, schange, region->node, region->surfaceid, region->surface_x,
 806                       region->surface_y, region->x, region->y, region->width,
 807                       region->height, region->hotspot_x, region->hotspot_y,
 808                       region->cursor_x, region->cursor_y, region->cursor_width,
 809                       region->cursor_height, region->attr);
 810         }
 811     }
 812     else    {
 813         print_log("HOMESCREEN: Event[input_regions] no region");
 814     }
 815 }
 816
 817 static const struct ico_input_mgr_device_listener device_listener = {
 818     cb_input_regions
 819 };
 820
 821
 822 static void
 823 handle_global(void *data, struct wl_registry *registry, uint32_t id,
 824               const char *interface, uint32_t version)
 825 {
 826     struct display *display = data;
 827     struct input *input;
 828     struct output *output;
 829
 830     print_log("HOMESCREEN: handle_global: interface=<%s> id=%d", interface, (int)id);
 831
 832     if (strcmp(interface, "wl_compositor") == 0) {
 833         display->compositor =
 834             wl_registry_bind(display->registry, id, &wl_compositor_interface, 1);
 835     }
 836     else if (strcmp(interface, "wl_seat") == 0) {
 837         input = calloc(1, sizeof *input);
 838         input->display = display;
 839         input->seat = wl_registry_bind(display->registry, id, &wl_seat_interface, 1);
 840         input->pointer_focus = NULL;
 841         input->keyboard_focus = NULL;
 842
 843         wl_seat_add_listener(input->seat, &seat_listener, input);
 844         display->input = input;
 845     }
 846     else if (strcmp(interface, "wl_output") == 0) {
 847         if (display->num_output < MAX_OUTPUT)   {
 848             output = malloc(sizeof *output);
 849             output->display = display;
 850             output->output = wl_registry_bind(display->registry, id, &wl_output_interface, 1);
 851             wl_output_add_listener(output->output, &output_listener, output);
 852             display->output[display->num_output] = output;
 853
 854             print_log("HOMESCREEN: created output[%d] global %p",
 855                       display->num_output, display->output[display->num_output]);
 856             display->num_output ++;
 857         }
 858     }
 859     else if (strcmp(interface, "wl_shell") == 0)    {
 860         display->shell =
 861             wl_registry_bind(display->registry, id, &wl_shell_interface, 1);
 862     }
 863     else if (strcmp(interface, "ico_window_mgr") == 0)  {
 864         display->ico_window_mgr =
 865             wl_registry_bind(display->registry, id, &ico_window_mgr_interface, 1);
 866         ico_window_mgr_add_listener(display->ico_window_mgr, &window_mgr_listener, display);
 867         print_log("HOMESCREEN: created window_mgr global %p", display->ico_window_mgr);
 868
 869         ico_window_mgr_declare_manager(display->ico_window_mgr, 1);
 870     }
 871     else if (strcmp(interface, "ico_input_mgr_control") == 0)   {
 872         display->ico_input_mgr = wl_registry_bind(display->registry, id,
 873                                                   &ico_input_mgr_control_interface, 1);
 874         print_log("HOMESCREEN: created input_mgr global %p", display->ico_input_mgr);
 875     }
 876     else if (strcmp(interface, "ico_input_mgr_device") == 0)   {
 877         display->ico_input_device = wl_registry_bind(display->registry, id,
 878                                                      &ico_input_mgr_device_interface, 1);
 879         ico_input_mgr_device_add_listener(display->ico_input_device,
 880                                           &device_listener, display);
 881         print_log("HOMESCREEN: created input_device global %p", display->ico_input_device);
 882     }
 883     else if (strcmp(interface, "ico_exinput") == 0)   {
 884         display->ico_exinput =
 885             wl_registry_bind(display->registry, id, &ico_exinput_interface, 1);
 886         ico_exinput_add_listener(display->ico_exinput, &exinput_listener, display);
 887         print_log("HOMESCREEN: created exinput global %p", display->ico_exinput);
 888
 889         ico_window_mgr_declare_manager(display->ico_window_mgr, 1);
 890
 891         display->bg_created = 1;
 892         create_surface(display, "HomeScreen-BG");
 893     }
 894 }
 895
 896 static const struct wl_registry_listener registry_listener = {
 897     handle_global
 898 };
 899
 900 static void
 901 launch_app(struct display *display, char *buf)
 902 {
 903     char    sbuf[256];
 904
 905     display->surface_created = 0;
 906     display->surface_destroyed = 0;
 907     snprintf(sbuf, sizeof(sbuf)-1, "%s &", skip_spaces(buf));
 908     if (system(sbuf) < 0)   {
 909         print_log("HOMESCREEN: Can not launch application[%s]", sbuf);
 910     }
 911     else    {
 912         sleep_with_wayland(display->display, 500);
 913     }
 914 }
 915
 916 static void
 917 kill_app(struct display *display, char *buf)
 918 {
 919     char    *args[10];
 920     int     narg;
 921     struct surface_name     *p;
 922     struct surface_name     *fp;
 923
 924     narg = pars_command(buf, args, 10);
 925     if (narg >= 1)  {
 926         p = search_surfacename(display, args[0]);
 927         if (! p)    {
 928             print_log("HOMESCREEN: kill[%s] Application dose not exist", args[0]);
 929         }
 930         else if (kill(p->pid, SIGINT) < 0)   {
 931             print_log("HOMESCREEN: kill[%s.%d] Application dose not exist",
 932                       p->appid, p->pid);
 933         }
 934         else    {
 935             sleep_with_wayland(display->display, 300);
 936             p = search_surfacename(display, args[0]);
 937             if ((p != NULL) && (kill(p->pid, SIGTERM) >= 0))    {
 938                 sleep_with_wayland(display->display, 200);
 939                 p = search_surfacename(display, args[0]);
 940                 if (p)  {
 941                     kill(p->pid, SIGKILL);
 942                     sleep_with_wayland(display->display, 200);
 943                 }
 944             }
 945         }
 946         p = search_surfacename(display, args[0]);
 947         if (p)  {
 948             if (p == display->surface_name) {
 949                 display->surface_name = p->next;
 950             }
 951             else    {
 952                 fp = display->surface_name;
 953                 while (fp)  {
 954                     if (fp->next == p)  {
 955                         fp->next = p->next;
 956                         break;
 957                     }
 958                 }
 959             }
 960             free(p);
 961         }
 962     }
 963     else    {
 964         print_log("HOMESCREEN: kill command[kill appid] has no argument");
 965     }
 966 }
 967
 968 static void
 969 layer_surface(struct display *display, char *buf)
 970 {
 971     char    *args[10];
 972     int     narg;
 973     int     surfaceid;
 974     int     layerid;
 975
 976     narg = pars_command(buf, args, 10);
 977     if (narg >= 2)  {
 978         surfaceid = search_surface(display, args[0]);
 979         layerid = strtol(args[1], (char **)0, 0);
 980         if ((surfaceid >= 0) && (layerid >= 0)) {
 981             print_log("HOMESCREEN: set_window_layer(%s,%08x)",
 982                       args[0], surfaceid, layerid);
 983             ico_window_mgr_set_window_layer(display->ico_window_mgr, surfaceid, layerid);
 984         }
 985         else    {
 986             print_log("HOMESCREEN: Unknown surface(%s) at layer command", args[0]);
 987         }
 988     }
 989     else    {
 990         print_log("HOMESCREEN: layer command[layer appid layerid] has no argument");
 991     }
 992 }
 993
 994 static void
 995 positionsize_surface(struct display *display, char *buf)
 996 {
 997     char    *args[10];
 998     struct surface_name     *p;
 999     int     narg;
1000     int     surfaceid;
1001     int     x, y, width, height;
1002     int     anima = 0;
1003     int     node = 0;
1004
1005     narg = pars_command(buf, args, 10);
1006     if (narg >= 5)  {
1007         surfaceid = search_surface(display, args[0]);
1008         p = search_surfacename(display, args[0]);
1009         x = strtol(args[1], (char **)0, 0);
1010         y = strtol(args[2], (char **)0, 0);
1011         width = strtol(args[3], (char **)0, 0);
1012         height = strtol(args[4], (char **)0, 0);
1013         if (narg >= 6)  {
1014             node = strtol(args[5], (char **)0, 0);
1015             if (p)  {
1016                 p->node = node;
1017             }
1018         }
1019         else if (p) {
1020             node = p->node;
1021         }
1022         if (narg >= 7)  {
1023             anima = strtol(args[6], (char **)0, 0);
1024         }
1025         if ((surfaceid >= 0) && (x >= 0) && (y >=0) && (width >= 0) && (height >=0))    {
1026             print_log("HOMESCREEN: set_positionsize(%s,%08x,%d,%d,%d,%d,%d)",
1027                       args[0], surfaceid, node, x, y, width, height);
1028             ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
1029                                             node, x, y, width, height, anima);
1030         }
1031         else    {
1032             print_log("HOMESCREEN: Unknown surface(%s) at positionsize command", args[0]);
1033         }
1034     }
1035     else    {
1036         print_log("HOMESCREEN: positionsize command"
1037                   "[positionsize appid x y width heigh node anima] has no argument");
1038     }
1039 }
1040
1041 static void
1042 move_surface(struct display *display, char *buf)
1043 {
1044     char    *args[10];
1045     struct surface_name     *p;
1046     int     narg;
1047     int     surfaceid;
1048     int     x, y;
1049     int     anima = 0;
1050     int     node = 0;
1051
1052     narg = pars_command(buf, args, 10);
1053     if (narg >= 3)  {
1054         surfaceid = search_surface(display, args[0]);
1055         p = search_surfacename(display, args[0]);
1056         x = strtol(args[1], (char **)0, 0);
1057         y = strtol(args[2], (char **)0, 0);
1058         if (narg >= 4)  {
1059             node = strtol(args[3], (char **)0, 0);
1060             if (node < 0)   {
1061                 if (p)  node = p->node;
1062                 else    node = 0;
1063             }
1064             if (p)  p->node = node;
1065         }
1066         else if (p) {
1067             node = p->node;
1068         }
1069         if (narg >= 5)  {
1070             anima = strtol(args[4], (char **)0, 0);
1071         }
1072
1073         if ((surfaceid >= 0) && (x >= 0) && (y >=0))    {
1074             print_log("HOMESCREEN: move(%s,%08x,%d.%d,%d anima=%d)", args[0], surfaceid,
1075                       node, x, y, anima);
1076             ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
1077                                             node, x, y,
1078                                             ICO_WINDOW_MGR_V_NOCHANGE,
1079                                             ICO_WINDOW_MGR_V_NOCHANGE, anima);
1080         }
1081         else    {
1082             print_log("HOMESCREEN: Unknown surface(%s) at move command", args[0]);
1083         }
1084     }
1085     else    {
1086         print_log("HOMESCREEN: move command[positionsize appid x y node anima] has no argument");
1087     }
1088 }
1089
1090 static void
1091 resize_surface(struct display *display, char *buf)
1092 {
1093     char    *args[10];
1094     struct surface_name     *p;
1095     int     narg;
1096     int     surfaceid;
1097     int     width, height;
1098     int     anima = 0;
1099     int     node = 0;
1100
1101     narg = pars_command(buf, args, 10);
1102     if (narg >= 3)  {
1103         surfaceid = search_surface(display, args[0]);
1104         p = search_surfacename(display, args[0]);
1105         if (p)  {
1106             node = p->node;
1107         }
1108         width = strtol(args[1], (char **)0, 0);
1109         height = strtol(args[2], (char **)0, 0);
1110         if (narg >= 4)  {
1111             anima = strtol(args[3], (char **)0, 0);
1112         }
1113
1114         if ((surfaceid >= 0) && (width >= 0) && (height >=0))   {
1115             print_log("HOMESCREEN: resize(%s,%08x,%d.%d,%d,anima=%d)",
1116                       args[0], surfaceid, node, width, height, anima);
1117             ico_window_mgr_set_positionsize(display->ico_window_mgr, surfaceid,
1118                                             node, ICO_WINDOW_MGR_V_NOCHANGE,
1119                                             ICO_WINDOW_MGR_V_NOCHANGE, width, height, anima);
1120         }
1121         else    {
1122             print_log("HOMESCREEN: Unknown surface(%s) at resize command", args[0]);
1123         }
1124     }
1125     else    {
1126         print_log("HOMESCREEN: positionsize command"
1127                   "[resize appid width heigh anima] has no argument");
1128     }
1129 }
1130
1131 static void
1132 visible_surface(struct display *display, char *buf)
1133 {
1134     char    *args[10];
1135     int     narg;
1136     int     surfaceid;
1137     int     visible;
1138     int     raise;
1139     int     anima = 0;
1140
1141     narg = pars_command(buf, args, 10);
1142     if (narg >= 3)  {
1143         surfaceid = search_surface(display, args[0]);
1144         visible = strtol(args[1], (char **)0, 0);
1145         raise = strtol(args[2], (char **)0, 0);
1146         if (narg >= 4)  {
1147             anima = strtol(args[3], (char **)0, 0);
1148         }
1149         if ((surfaceid >= 0) && (visible >= 0) && (raise >=0))  {
1150             print_log("HOMESCREEN: visible(%s,%08x,%d,%d,%d)",
1151                       args[0], surfaceid, visible, raise, anima);
1152             ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
1153                                        visible, raise, anima);
1154         }
1155         else    {
1156             print_log("HOMESCREEN: Unknown surface(%s) at visible command", args[0]);
1157         }
1158     }
1159     else    {
1160         print_log("HOMESCREEN: visible command[visible appid visible raise] "
1161                   "has no argument");
1162     }
1163 }
1164
1165 static void
1166 show_surface(struct display *display, char *buf, const int show)
1167 {
1168     char    *args[10];
1169     int     narg;
1170     int     surfaceid;
1171     int     anima = 0;
1172     int     ax = 0;
1173     int     ay = 0;
1174     int     awidth = 1;
1175     int     aheight = 1;
1176
1177     narg = pars_command(buf, args, 10);
1178     if (narg >= 1)  {
1179         surfaceid = search_surface(display, args[0]);
1180         if (narg >= 2)  {
1181             anima = strtol(args[1], (char **)0, 0);
1182             if (anima >= 2) {
1183                 ax = 0;
1184                 ay = 0;
1185                 awidth = 1;
1186                 aheight = 1;
1187                 if (narg >= 3)  ax = strtol(args[2], (char **)0, 0);
1188                 if (narg >= 4)  ay = strtol(args[3], (char **)0, 0);
1189                 if (narg >= 5)  awidth = strtol(args[4], (char **)0, 0);
1190                 if (narg >= 6)  aheight = strtol(args[5], (char **)0, 0);
1191             }
1192         }
1193         if (surfaceid >= 0) {
1194             if (show)   {
1195                 if (anima >= 2) {
1196                     print_log("HOMESCREEN: show anima(%s,%08x,x/y=%d/%d,w/h=%d/%d)",
1197                               args[0], surfaceid, ax, ay, awidth, aheight);
1198                     ico_window_mgr_visible_animation(display->ico_window_mgr, surfaceid,
1199                                                      1, ax, ay, awidth, aheight);
1200                 }
1201                 else    {
1202                     print_log("HOMESCREEN: show(%s,%08x,anima=%d)",
1203                               args[0], surfaceid, anima);
1204                     ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
1205                                                1, ICO_WINDOW_MGR_V_NOCHANGE, anima);
1206                 }
1207             }
1208             else    {
1209                 if (anima >= 2) {
1210                     print_log("HOMESCREEN: hide anima(%s,%08x,x/y=%d/%d,w/h=%d/%d)",
1211                               args[0], surfaceid, ax, ay, awidth, aheight);
1212                     ico_window_mgr_visible_animation(display->ico_window_mgr, surfaceid,
1213                                                      0, ax, ay, awidth, aheight);
1214                 }
1215                 else    {
1216                     print_log("HOMESCREEN: hide(%s,%08x,anima=%d)",
1217                               args[0], surfaceid, anima);
1218                     ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
1219                                                0, ICO_WINDOW_MGR_V_NOCHANGE, anima);
1220                 }
1221             }
1222         }
1223         else    {
1224             print_log("HOMESCREEN: Unknown surface(%s) at show/hide command", args[0]);
1225         }
1226     }
1227     else    {
1228         print_log("HOMESCREEN: show command[show/hide appid anima x y width height]"
1229                   " has no argument");
1230     }
1231 }
1232
1233 static void
1234 raise_surface(struct display *display, char *buf, const int raise)
1235 {
1236     char    *args[10];
1237     int     narg;
1238     int     surfaceid;
1239     int     anima = 0;
1240
1241     narg = pars_command(buf, args, 10);
1242     if (narg >= 1)  {
1243         surfaceid = search_surface(display, args[0]);
1244         if (narg >= 2)  {
1245             anima = strtol(args[1], (char **)0, 0);
1246         }
1247         if (surfaceid >= 0) {
1248             if (raise)  {
1249                 print_log("HOMESCREEN: raise(%s,%08x,anima=%d)", args[0], surfaceid, anima);
1250                 ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
1251                                            ICO_WINDOW_MGR_V_NOCHANGE, 1, anima);
1252             }
1253             else    {
1254                 print_log("HOMESCREEN: lower(%s,%08x,anima=%d)", args[0], surfaceid, anima);
1255                 ico_window_mgr_set_visible(display->ico_window_mgr, surfaceid,
1256                                            ICO_WINDOW_MGR_V_NOCHANGE, 0, anima);
1257             }
1258         }
1259         else    {
1260             print_log("HOMESCREEN: Unknown surface(%s) at raise/lower command", args[0]);
1261         }
1262     }
1263     else    {
1264         print_log("HOMESCREEN: show command[raise/lower appid anima] has no argument");
1265     }
1266 }
1267
1268 static void
1269 active_window(struct display *display, char *buf)
1270 {
1271     char    *args[10];
1272     int     narg;
1273     int     surfaceid;
1274     int     target;
1275
1276     narg = pars_command(buf, args, 10);
1277     if (narg >= 1)  {
1278         surfaceid = search_surface(display, args[0]);
1279         if (narg >= 2)  {
1280             target = strtol(args[1], (char **)0, 0);
1281         }
1282         else    {
1283             target = ICO_WINDOW_MGR_ACTIVE_POINTER | ICO_WINDOW_MGR_ACTIVE_KEYBOARD;
1284         }
1285         if (surfaceid >= 0) {
1286             print_log("HOMESCREEN: active(%s,%08x,target=%x)", args[0], surfaceid, target);
1287             ico_window_mgr_set_active(display->ico_window_mgr, surfaceid, target);
1288         }
1289         else    {
1290             print_log("HOMESCREEN: Unknown surface(%s) at active command", args[0]);
1291         }
1292     }
1293     else    {
1294         print_log("HOMESCREEN: active command[active appid[target]] has no argument");
1295     }
1296 }
1297
1298
1299 static void
1300 animation_surface(struct display *display, char *buf)
1301 {
1302     char    *args[10];
1303     int     narg;
1304     int     surfaceid;
1305     int     time;
1306
1307     narg = pars_command(buf, args, 10);
1308     if (narg >= 2)  {
1309         surfaceid = search_surface(display, args[0]);
1310         if (surfaceid >= 0) {
1311             if (narg >= 3)  {
1312                 time = strtol(args[2], (char **)0, 0);
1313             }
1314             else    {
1315                 time = 0;
1316             }
1317             print_log("HOMESCREEN: animation(%s,%08x,%s,%d)",
1318                       args[0], surfaceid, args[1], time);
1319             ico_window_mgr_set_animation(display->ico_window_mgr, surfaceid, 0x7fffffff,
1320                                          args[1], time);
1321         }
1322         else    {
1323             print_log("HOMESCREEN: Unknown surface(%s) at animation command", args[0]);
1324         }
1325     }
1326     else    {
1327         print_log("HOMESCREEN: animation command"
1328                   "[animation appid animation time] has no argument");
1329     }
1330 }
1331
1332 static void
1333 map_surface(struct display *display, char *buf, int map)
1334 {
1335     char    *args[10];
1336     int     narg;
1337     int     surfaceid;
1338     int     fps;
1339
1340     narg = pars_command(buf, args, 10);
1341     if (narg >= 1)  {
1342         surfaceid = search_surface(display, args[0]);
1343         if (surfaceid >= 0) {
1344             if (narg >= 2)  {
1345                 fps = strtol(args[1], (char **)0, 0);
1346             }
1347             else    {
1348                 fps = 0;
1349             }
1350             if (map)    {
1351                 print_log("HOMESCREEN: map surface(%s,%08x,%d)",
1352                           args[0], surfaceid, fps);
1353                 ico_window_mgr_map_surface(display->ico_window_mgr, surfaceid, fps);
1354             }
1355             else    {
1356                 print_log("HOMESCREEN: unmap surface(%s,%08x)", args[0], surfaceid);
1357                 ico_window_mgr_unmap_surface(display->ico_window_mgr, surfaceid);
1358             }
1359         }
1360         else    {
1361             print_log("HOMESCREEN: Unknown surface(%s) at %s command", args[0],
1362                       map ? "map" : "unmap");
1363         }
1364     }
1365     else    {
1366         if (map)    {
1367             print_log("HOMESCREEN: map surface command"
1368                       "[map surface framerate] has no argument");
1369         }
1370         else    {
1371             print_log("HOMESCREEN: unmap surface command"
1372                       "[unmap surface] has no argument");
1373         }
1374     }
1375 }
1376
1377 static void
1378 visible_layer(struct display *display, char *buf)
1379 {
1380     char    *args[10];
1381     int     narg;
1382     int     layer;
1383     int     visible;
1384
1385     narg = pars_command(buf, args, 10);
1386     if (narg >= 2)  {
1387         layer = strtol(args[0], (char **)0, 0);
1388         visible = strtol(args[1], (char **)0, 0);
1389         ico_window_mgr_set_layer_visible(display->ico_window_mgr, layer, visible);
1390     }
1391     else    {
1392         print_log("HOMESCREEN: layer_visible command"
1393                   "[layer_visible layer visible] has no argument");
1394     }
1395 }
1396
1397 static void
1398 input_add(struct display *display, char *buf)
1399 {
1400     char    *args[10];
1401     int     narg;
1402     int     input;
1403     int     fix;
1404
1405     narg = pars_command(buf, args, 10);
1406     if (narg >= 3)  {
1407         input = strtol(args[1], (char **)0, 0);
1408         if (narg >= 4)  {
1409             fix = strtol(args[3], (char **)0, 0);
1410         }
1411         else    {
1412             fix = 0;
1413         }
1414         if ((input >= 0) && (fix >=0))  {
1415             print_log("HOMESCREEN: input_add(%s.%d to %s[%d])",
1416                       args[0], input, args[2], fix);
1417             ico_input_mgr_control_add_input_app(display->ico_input_mgr,
1418                                                 args[2], args[0], input, fix, 0);
1419         }
1420         else    {
1421             print_log("HOMESCREEN: Unknown input(%s) at input_add command", args[1]);
1422         }
1423     }
1424     else    {
1425         print_log("HOMESCREEN: input_add command[input_add device inputId appid fix] "
1426                   "has no argument");
1427     }
1428 }
1429
1430 static void
1431 input_del(struct display *display, char *buf)
1432 {
1433     char    *args[10];
1434     int     narg;
1435     int     input;
1436     char    wk1[32], wk2[32];
1437
1438     narg = pars_command(buf, args, 10);
1439     if (narg >= 3)  {
1440         input = strtol(args[1], (char **)0, 0);
1441         if (args[0][0] == '@')  {
1442             wk1[0] = 0;
1443             args[0] = wk1;
1444         }
1445         if (args[2][0] == '@')  {
1446             wk2[0] = 0;
1447             args[2] = wk2;
1448         }
1449         print_log("HOMESCREEN: input_del(%s.%d to %s)", args[0], input, args[2]);
1450         ico_input_mgr_control_del_input_app(display->ico_input_mgr,
1451                                             args[2], args[0], input);
1452     }
1453     else    {
1454         print_log("HOMESCREEN: input_del command[input_del device inputId appid] "
1455                   "has no argument");
1456     }
1457 }
1458
1459 static void
1460 input_send(struct display *display, char *buf)
1461 {
1462     char    *args[10];
1463     int     narg;
1464     int     surfaceid;
1465     int     type;
1466     int     no;
1467     int     code;
1468     int     value;
1469     char    appid[64];
1470
1471     narg = pars_command(buf, args, 10);
1472     if (narg >= 5)  {
1473         memset(appid, 0, sizeof(appid));
1474         if (args[0][0] == '@')  {
1475             strncpy(appid, &args[0][1], sizeof(appid)-1);
1476             surfaceid = 0;
1477         }
1478         else    {
1479             surfaceid = search_surface(display, args[0]);
1480         }
1481         if (strcasecmp(args[1], "POINTER") == 0)    {
1482             type = ICO_INPUT_MGR_DEVICE_TYPE_POINTER;
1483         }
1484         else if (strcasecmp(args[1], "KEYBOARD") == 0)  {
1485             type = ICO_INPUT_MGR_DEVICE_TYPE_KEYBOARD;
1486         }
1487         else if (strcasecmp(args[1], "TOUCH") == 0) {
1488             type = ICO_INPUT_MGR_DEVICE_TYPE_TOUCH;
1489         }
1490         else if (strcasecmp(args[1], "SWITCH") == 0)    {
1491             type = ICO_INPUT_MGR_DEVICE_TYPE_SWITCH;
1492         }
1493         else if (strcasecmp(args[1], "HAPTIC") == 0)    {
1494             type = ICO_INPUT_MGR_DEVICE_TYPE_HAPTIC;
1495         }
1496         else    {
1497             type = strtol(args[1], (char **)0, 0);
1498         }
1499         no = strtol(args[2], (char **)0, 0);
1500         if (strcasecmp(args[3], "ABS_X") == 0)  {
1501             code = ABS_X;
1502         }
1503         else if (strcasecmp(args[3], "ABS_Y") == 0) {
1504             code = ABS_Y;
1505         }
1506         else if (strcasecmp(args[3], "ABS_Z") == 0) {
1507             code = ABS_Z;
1508         }
1509         else if (strcasecmp(args[3], "REL_X") == 0) {
1510             code = REL_X | (EV_REL << 16);
1511         }
1512         else if (strcasecmp(args[3], "REL_Y") == 0) {
1513             code = REL_Y | (EV_REL << 16);
1514         }
1515         else if (strcasecmp(args[3], "REL_Z") == 0) {
1516             code = REL_Z | (EV_REL << 16);
1517         }
1518         else if (strcasecmp(args[3], "BTN_TOUCH") == 0) {
1519             code = BTN_TOUCH;
1520         }
1521         else if (strcasecmp(args[3], "BTN_LEFT") == 0)  {
1522             code = BTN_LEFT;
1523         }
1524         else if (strcasecmp(args[3], "BTN_RIGHT") == 0) {
1525             code = BTN_RIGHT;
1526         }
1527         else if (strcasecmp(args[3], "BTN_MIDDLE") == 0)    {
1528             code = BTN_MIDDLE;
1529         }
1530         else if (strcasecmp(args[3], "BTN_RIGHT") == 0) {
1531             code = BTN_RIGHT;
1532         }
1533         else    {
1534             code = strtol(args[3], (char **)0, 0);
1535         }
1536         value = strtol(args[4], (char **)0, 0);
1537         if (narg >= 6)  {
1538             value = (value << 16) + strtol(args[5], (char **)0, 0);
1539         }
1540         print_log("HOMESCREEN: input_send(%s.%x,%d,%d,%x,%d)",
1541                   appid, surfaceid, type, no, code, value);
1542         ico_input_mgr_control_send_input_event(display->ico_input_mgr,
1543                                                appid, surfaceid, type, no, 0, code, value);
1544     }
1545     else    {
1546         print_log("HOMESCREEN: input_send command[input_send {@app/serface} type no code "
1547                   "value [value2]] has no argument");
1548     }
1549 }
1550
1551 static void
1552 input_conf(struct display *display, char *buf)
1553 {
1554     char    *args[10];
1555     int     narg;
1556     int     type;
1557     int     input;
1558     int     code;
1559     char    wk1[32], wk2[32];
1560
1561     narg = pars_command(buf, args, 10);
1562     if (narg >= 4)  {
1563         type = strtol(args[1], (char **)0, 0);
1564         input = strtol(args[3], (char **)0, 0);
1565         if (narg >= 6)  {
1566             code = strtol(args[5], (char **)0, 0);
1567         }
1568         else    {
1569             code = 0;
1570             args[4] = wk1;
1571             strcpy(wk1, args[2]);
1572             args[5] = wk2;
1573             strcpy(wk2, "0");
1574         }
1575         if ((type >= 0) && (input >= 0) && (code >=0))  {
1576             ico_input_mgr_device_configure_input(display->ico_input_device, args[0], type,
1577                                                  args[2], input, args[4], code);
1578         }
1579         else    {
1580             print_log("HOMESCREEN: Unknown type(%s),input(%s) or code(%s) "
1581                       "at input_conf command", args[1], args[3], args[5]);
1582         }
1583     }
1584     else    {
1585         print_log("HOMESCREEN: input_conf command[input_conf device type swname input "
1586                   "codename code] has no argument");
1587     }
1588 }
1589
1590 static void
1591 input_code(struct display *display, char *buf)
1592 {
1593     char    *args[10];
1594     int     narg;
1595     int     input;
1596     int     code;
1597
1598     narg = pars_command(buf, args, 10);
1599     if (narg >= 4)  {
1600         input = strtol(args[1], (char **)0, 0);
1601         code = strtol(args[3], (char **)0, 0);
1602         if ((input >= 0) && (code >= 0))    {
1603             ico_input_mgr_device_configure_code(display->ico_input_device, args[0], input,
1604                                                 args[2], code);
1605         }
1606         else    {
1607             print_log("HOMESCREEN: Unknown input(%s) or code(%s) "
1608                       "at input_code command", args[1], args[3]);
1609         }
1610     }
1611     else    {
1612         print_log("HOMESCREEN: input_conf command[input_code device input codename code] "
1613                   "has no argument");
1614     }
1615 }
1616
1617 static void
1618 input_sw(struct display *display, char *buf)
1619 {
1620     char    *args[10];
1621     int     narg;
1622     int     timems;
1623     int     input;
1624     int     code;
1625     int     state;
1626     struct timeval  stv;
1627
1628     narg = pars_command(buf, args, 10);
1629     if (narg >= 4)  {
1630         input = strtol(args[1], (char **)0, 0);
1631         code = strtol(args[2], (char **)0, 0);
1632         state = strtol(args[3], (char **)0, 0);
1633         if ((input >= 0) && (state >= 0))   {
1634             gettimeofday(&stv, (struct timezone *)NULL);
1635             timems = (stv.tv_sec % 1000) * 1000 + (stv.tv_usec / 1000);
1636             ico_input_mgr_device_input_event(display->ico_input_device,
1637                                              timems, args[0], input, code, state);
1638         }
1639         else    {
1640             print_log("HOMESCREEN: Unknown input(%s),code(%s) or state(%s) "
1641                       "at input_sw command", args[1], args[2], args[3]);
1642         }
1643     }
1644     else    {
1645         print_log("HOMESCREEN: input_sw command[input_sw device input code, state] "
1646                   "has no argument");
1647     }
1648 }
1649
1650 static void
1651 send_event(const char *cmd)
1652 {
1653     static int  nmqinfo = 0;
1654     static struct   {
1655         int     mqkey;
1656         int     mqid;
1657     }           mqinfo[10];
1658     int     mqkey;
1659     int     mqid;
1660     struct {
1661         long    mtype;
1662         char    buf[240];
1663     }       mqbuf;
1664     int     pt, i;
1665
1666     if (cmd == NULL)    {
1667         return;
1668     }
1669     mqkey = 0;
1670     for (pt = 0; cmd[pt]; pt++) {
1671         if ((cmd[pt] >= '0') && (cmd[pt] <= '9'))   {
1672             mqkey = mqkey * 10 + cmd[pt] - '0';
1673         }
1674         else    {
1675             break;
1676         }
1677     }
1678     for (; cmd[pt] == ' '; pt++)    ;
1679
1680     if (mqkey <= 0) {
1681         mqkey = 5551;
1682         pt = 0;
1683     }
1684     for (i = 0; i < nmqinfo; i++)   {
1685         if (mqinfo[i].mqkey == mqkey)   {
1686             mqid = mqinfo[i].mqid;
1687             break;
1688         }
1689     }
1690     if (i >= nmqinfo)   {
1691         if (nmqinfo >= 10)  {
1692             fprintf(stderr, "HOMESCREEN: message queue(%d) overflow\n", mqkey);
1693             return;
1694         }
1695         mqid = msgget(mqkey, 0);
1696         if (mqid < 0)   {
1697             fprintf(stderr, "HOMESCREEN: message queue(%d(0x%x)) get error[%d]\n",
1698                     mqkey, mqkey, errno);
1699             return;
1700         }
1701         mqinfo[nmqinfo].mqkey = mqkey;
1702         mqinfo[nmqinfo].mqid = mqid;
1703         nmqinfo ++;
1704     }
1705
1706     memset(&mqbuf, 0, sizeof(mqbuf));
1707     mqbuf.mtype = 1;
1708     strncpy(mqbuf.buf, &cmd[pt], sizeof(mqbuf)-sizeof(long));
1709
1710     if (msgsnd(mqid, &mqbuf, sizeof(mqbuf)-sizeof(long), 0) < 0)    {
1711         fprintf(stderr, "HOMESCREEN: message queue(%d(0x%x)) send error[%d]\n",
1712                 mqkey, mqkey, errno);
1713         return;
1714     }
1715 }
1716
1717 static void
1718 set_region(struct display *display, char *buf)
1719 {
1720     char    *args[10];
1721     int     narg;
1722     int     x, y, width, height;
1723     int     hot_x, hot_y;
1724     int     c_x, c_y, c_width, c_height;
1725
1726     narg = pars_command(buf, args, 10);
1727     if (narg >= 5)  {
1728         x = strtol(args[1], (char **)0, 0);
1729         y = strtol(args[2], (char **)0, 0);
1730         width = strtol(args[3], (char **)0, 0);
1731         height = strtol(args[4], (char **)0, 0);
1732         hot_x = x + (width / 2);
1733         hot_y = y + (height / 2);
1734         c_x = x + 5;
1735         c_y = y + 5;
1736         c_width = width - 10;
1737         if (c_width <= 0)   c_width = 2;
1738         c_height = height - 10;
1739         if (c_height <= 0)  c_height = 2;
1740         print_log("HOMESCREEN: ico_exinput_set_input_region(%s,%d,%d-%d,%d,"
1741                   "hot=%d,%d,cur=%d,%d-%d,%d,attr=0)",
1742                   args[0] ? args[0] : "(null)", x, y, width, height,
1743                   hot_x, hot_y, c_x, c_y, c_width, c_height);
1744         if (strcasecmp(args[0], "NULL") == 0)   {
1745             ico_exinput_set_input_region(display->ico_exinput, "", x, y,
1746                                          width, height, hot_x, hot_y, c_x, c_y,
1747                                          c_width, c_height, 0);
1748         }
1749         else    {
1750             ico_exinput_set_input_region(display->ico_exinput, args[0], x, y,
1751                                          width, height, hot_x, hot_y, c_x, c_y,
1752                                          c_width, c_height, 0);
1753         }
1754     }
1755     else    {
1756         print_log("HOMESCREEN: set_region command[set_region winname@appid x y "
1757                   "width height] has no argument");
1758     }
1759 }
1760
1761 static void
1762 unset_region(struct display *display, char *buf)
1763 {
1764     char    *args[10];
1765     int     narg;
1766     int     x, y, width, height;
1767
1768     narg = pars_command(buf, args, 10);
1769     if (narg >= 1)  {
1770         if (narg >= 5) {
1771             x = strtol(args[1], (char **)0, 0);
1772             y = strtol(args[2], (char **)0, 0);
1773             width = strtol(args[3], (char **)0, 0);
1774             height = strtol(args[4], (char **)0, 0);
1775         }
1776         else    {
1777             x = 0;
1778             y = 0;
1779             width = 0;
1780             height = 0;
1781         }
1782         print_log("HOMESCREEN: ico_exinput_unset_input_region(%s,08x,%d,%d-%d,%d)",
1783                   args[0] ? args[0] : "(null)", x, y, width, height);
1784         if (strcasecmp(args[0], "NULL") == 0)   {
1785             ico_exinput_unset_input_region(display->ico_exinput, "", x, y,
1786                                            width, height);
1787         }
1788         else    {
1789             ico_exinput_unset_input_region(display->ico_exinput, args[0],
1790                                            x, y, width, height);
1791         }
1792     }
1793     else    {
1794         print_log("HOMESCREEN: unset_region command[unset_region winname@appid x y "
1795                   "width height] has no argument");
1796     }
1797 }
1798
1799 /*
1800  * Main Program
1801  *
1802  *   usage:
1803  *     test-homescreen < test-case-data-file > test-result-output
1804  */
1805 int main(int argc, char *argv[])
1806 {
1807     struct display *display;
1808     char buf[256];
1809     int ret, fd;
1810     int msec;
1811 #if 1           /* use mkostemp */
1812     extern int  mkostemp(char *template, int flags);
1813 #else           /* use mkostemp */
1814     long flags;
1815 #endif          /* use mkostemp */
1816
1817     display = malloc(sizeof *display);
1818     assert(display);
1819     memset((char *)display, 0, sizeof *display);
1820
1821     display->init_width = 640;
1822     display->init_height = 480;
1823     display->init_color = 0xFF304010;
1824
1825     for (fd = 1; fd < argc; fd++)   {
1826         if (argv[fd][0] == '-') {
1827             if (strncasecmp(argv[fd], "-visible=", 9) == 0) {
1828                 display->visible_on_create = argv[fd][9] & 1;
1829             }
1830             else if (strncasecmp(argv[fd], "-display=", 9) == 0)    {
1831                 strncpy(display->connect, &argv[fd][9], MAX_CON_NAME);
1832             }
1833             else if (strncasecmp(argv[fd], "-prompt=", 8) == 0) {
1834                 display->prompt = argv[fd][8] & 1;
1835             }
1836         }
1837     }
1838
1839     if (display->connect[0])    {
1840         display->display = wl_display_connect(display->connect);
1841     }
1842     else    {
1843         display->display = wl_display_connect(NULL);
1844     }
1845     assert(display->display);
1846
1847     display->registry = wl_display_get_registry(display->display);
1848     wl_registry_add_listener(display->registry, &registry_listener, display);
1849     wl_display_dispatch(display->display);
1850
1851     fd = 0;
1852
1853     while (1) {
1854         sleep_with_wayland(display->display, 20);
1855         if (display->prompt)    {
1856             printf("HOMESCREEN> "); fflush(stdout);
1857         }
1858         ret = getdata(display->ico_window_mgr, "HOMESCREEN> ", fd, buf, sizeof(buf));
1859         if (ret < 0) {
1860             fprintf(stderr, "HOMESCREEN: read error: fd %d, %m\n", fd);
1861             return -1;
1862         }
1863         if (ret == 0)   continue;
1864         wl_display_flush(display->display);
1865
1866         if ((strncasecmp(buf, "bye", 3) == 0) ||
1867             (strncasecmp(buf, "quit", 4) == 0) ||
1868             (strncasecmp(buf, "end", 3) == 0))  {
1869             /* Exit, end of test            */
1870             return 0;
1871         }
1872         else if (strncasecmp(buf, "launch", 6) == 0) {
1873             /* Launch test application      */
1874             launch_app(display, &buf[6]);
1875         }
1876         else if (strncasecmp(buf, "kill", 4) == 0) {
1877             /* Launch test application      */
1878             kill_app(display, &buf[4]);
1879         }
1880         else if (strncasecmp(buf, "layer_visible", 13) == 0) {
1881             /* Change layer visiblety       */
1882             visible_layer(display, &buf[13]);
1883         }
1884         else if (strncasecmp(buf, "layer", 5) == 0) {
1885             /* layer change surface window  */
1886             layer_surface(display, &buf[5]);
1887         }
1888         else if (strncasecmp(buf, "positionsize", 12) == 0) {
1889             /* Move and Ressize surface window*/
1890             positionsize_surface(display, &buf[12]);
1891         }
1892         else if (strncasecmp(buf, "move", 4) == 0) {
1893             /* Move surface window          */
1894             move_surface(display, &buf[4]);
1895         }
1896         else if (strncasecmp(buf, "resize", 6) == 0) {
1897             /* Resize surface window        */
1898             resize_surface(display, &buf[6]);
1899         }
1900         else if (strncasecmp(buf, "visible", 7) == 0) {
1901             /* Visible and Raise surface window*/
1902             visible_surface(display, &buf[7]);
1903         }
1904         else if (strncasecmp(buf, "show", 4) == 0) {
1905             /* Show/Hide surface window     */
1906             show_surface(display, &buf[4], 1);
1907         }
1908         else if (strncasecmp(buf, "hide", 4) == 0) {
1909             /* Show/Hide surface window     */
1910             show_surface(display, &buf[4], 0);
1911         }
1912         else if (strncasecmp(buf, "raise", 5) == 0) {
1913             /* Raise/Lower surface window   */
1914             raise_surface(display, &buf[5], 1);
1915         }
1916         else if (strncasecmp(buf, "lower", 5) == 0) {
1917             /* Raise/Lower surface window   */
1918             raise_surface(display, &buf[5], 0);
1919         }
1920         else if (strncasecmp(buf, "active", 6) == 0) {
1921             /* Active surface window        */
1922             active_window(display, &buf[6]);
1923         }
1924         else if (strncasecmp(buf, "animation", 9) == 0) {
1925             /* Set animation surface window */
1926             animation_surface(display, &buf[9]);
1927         }
1928         else if (strncasecmp(buf, "map", 3) == 0) {
1929             /* map surface                  */
1930             map_surface(display, &buf[3], 1);
1931         }
1932         else if (strncasecmp(buf, "unmap", 5) == 0) {
1933             /* unmap surface                */
1934             map_surface(display, &buf[5], 0);
1935         }
1936         else if (strncasecmp(buf, "input_add", 9) == 0) {
1937             /* Set input switch to application */
1938             input_add(display, &buf[9]);
1939         }
1940         else if (strncasecmp(buf, "input_del", 9) == 0) {
1941             /* Reset input switch to application*/
1942             input_del(display, &buf[9]);
1943         }
1944         else if (strncasecmp(buf, "input_send", 10) == 0) {
1945             /* Input event send to application*/
1946             input_send(display, &buf[10]);
1947         }
1948         else if (strncasecmp(buf, "input_conf", 10) == 0) {
1949             /* input switch configuration       */
1950             input_conf(display, &buf[10]);
1951         }
1952         else if (strncasecmp(buf, "input_code", 10) == 0) {
1953             /* input code configuration         */
1954             input_code(display, &buf[10]);
1955         }
1956         else if (strncasecmp(buf, "input_sw", 8) == 0) {
1957             /* input switch event               */
1958             input_sw(display, &buf[8]);
1959         }
1960         else if (strncasecmp(buf, "set_region", 10) == 0) {
1961             /* set input region                 */
1962             set_region(display, &buf[10]);
1963         }
1964         else if (strncasecmp(buf, "unset_region", 12) == 0) {
1965             /* unset input region               */
1966             unset_region(display, &buf[12]);
1967         }
1968         else if (strncasecmp(buf, "input_sw", 8) == 0) {
1969             /* input switch event               */
1970             input_sw(display, &buf[8]);
1971         }
1972         else if (strncasecmp(buf, "sleep", 5) == 0) {
1973             /* Sleep                            */
1974             msec = sec_str_2_value(&buf[6]);
1975             sleep_with_wayland(display->display, msec);
1976         }
1977         else if (strncasecmp(buf, "waitcreate", 10) == 0) {
1978             /* Wait surface create              */
1979             msec = sec_str_2_value(&buf[11]);
1980             wait_with_wayland(display->display, msec, &display->surface_created);
1981         }
1982         else if (strncasecmp(buf, "waitdestroy", 11) == 0) {
1983             /* Wait surface destrpy             */
1984             msec = sec_str_2_value(&buf[12]);
1985             wait_with_wayland(display->display, msec, &display->surface_destroyed);
1986         }
1987         else if (strncasecmp(buf, "event", 5) == 0) {
1988             /* Send touch panel event to Weston */
1989             send_event(&buf[6]);
1990         }
1991         else {
1992             print_log("HOMESCREEN: unknown command[%s]", buf);
1993             return -1;
1994         }
1995     }
1996
1997     print_log("HOMESCREEN: end");
1998
1999     send_event(NULL);
2000
2001     return 0;
2002 }
2003