src/homescreen/CicoHSMenuTile.cpp

   1 /*
   2  * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
   3  *
   4  * This program is licensed under the terms and conditions of the
   5  * Apache License, version 2.0.  The full text of the Apache License is at
   6  * http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  */
   9 /**
  10  * @brief   tile in menu
  11  *
  12  * @date    Aug-08-2013
  13  */
  14 #include "CicoHSMenuTile.h"
  15 #include "CicoHSMenuTouch.h"
  16 #include <stdio.h>
  17 #include <unistd.h>
  18 #include <sys/mman.h>
  19 #include <sys/stat.h>
  20 #include <fcntl.h>
  21 #include <ico_window_mgr.h>
  22
  23 /*============================================================================*/
  24 /* functions                                                                  */
  25 /*============================================================================*/
  26 /*--------------------------------------------------------------------------*/
  27 /**
  28  * @brief   CicoHSMenuTile::CicoHSMenuTile
  29  *          Constractor
  30  *
  31  * @param[in]   appid
  32  * @param[in]   icon_image_path
  33  * @param[in]   page
  34  * @param[in]   position
  35  * @param[in]   width
  36  * @param[in]   height
  37  * @return      none
  38  */
  39 /*--------------------------------------------------------------------------*/
  40 CicoHSMenuTile::CicoHSMenuTile(const char *appid,
  41                                const char *icon_image_path,
  42                                int page, int subpage,
  43                                int position, int width, int height)
  44 {
  45     ICO_TRA("CicoHSMenuTile::CicoHSMenuTile Enter");
  46
  47     if (appid != NULL) {
  48         strncpy(this->appid, appid, ICO_HS_MAX_PROCESS_NAME);
  49     }
  50     if ((icon_image_path != NULL) && (strlen(icon_image_path) != 0)) {
  51         strncpy(this->icon_image_path,icon_image_path,ICO_HS_MAX_PATH_BUFF_LEN);
  52     }
  53     else {
  54         strncpy(this->icon_image_path,ICO_HS_MENUTILE_DEFAULT_ICON_PATH,
  55                 ICO_HS_MAX_PATH_BUFF_LEN);
  56     }
  57     ICO_DBG("CicoHSMenuTile::CicoHSMenuTile:image_path %s:%s",
  58             appid, this->icon_image_path);
  59     thumb.surface = 0;
  60     thumb.fbcount = 0;
  61     thumb.pixel_data = NULL;
  62     this->page = page;
  63     this->subpage = subpage;
  64     this->position = position;
  65     this->width = width;
  66     this->height = height;
  67     pos_x = GetPositionX();
  68     pos_y = GetPositionY();
  69
  70     (void) mkdir(ICO_HS_THUMB_ICODIR, 0755);
  71     (void) mkdir(ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR, 0755);
  72
  73     ICO_TRA("CicoHSMenuTile::CicoHSMenuTile Leave");
  74 }
  75
  76 /*--------------------------------------------------------------------------*/
  77 /**
  78  * @brief   CicoHSMenuTile::CicoHSMenuTile
  79  *          Destractor
  80  *
  81  * @param[in]   none
  82  * @return      none
  83  */
  84 /*--------------------------------------------------------------------------*/
  85 CicoHSMenuTile::~CicoHSMenuTile(void)
  86 {
  87 }
  88
  89 /*--------------------------------------------------------------------------*/
  90 /**
  91  * @brief   CicoHSMenuTile::CreateObject
  92  *          create tile object
  93  *
  94  * @param[in]   evas
  95  * @return      none
  96  */
  97 /*--------------------------------------------------------------------------*/
  98 void
  99 CicoHSMenuTile::CreateObject(Evas *evas)
 100 {
 101     ICO_DBG("CicoHSMenuTile::CreateObject Enter(appid=%08x<%s>)", (int)this->appid, appid);
 102
 103     /*initial vaule*/
 104     menu_evas = evas;
 105     menu_show = false;
 106     app_running = false;
 107     thumb_tile = NULL;
 108     small_icon = NULL;
 109     thumb_reduce_x = ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX;
 110     thumb_reduce_y = ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX;
 111
 112     /*tile*/
 113     tile = evas_object_image_filled_add(evas);
 114     evas_object_image_file_set(tile, icon_image_path, NULL);
 115     evas_object_move(tile, pos_x, pos_y);
 116     evas_object_resize(tile, width, height);
 117     evas_object_event_callback_add(tile, EVAS_CALLBACK_MOUSE_DOWN,
 118                                    CicoHSMenuTouch::TouchDownMenu, appid);
 119     evas_object_event_callback_add(tile, EVAS_CALLBACK_MOUSE_UP,
 120                                    CicoHSMenuTouch::TouchUpMenu, appid);
 121     icon = tile;
 122     evas_object_show(icon);
 123
 124     /*term Icon*/
 125     term_icon = evas_object_image_filled_add(evas);
 126     evas_object_image_file_set(term_icon, ICO_HS_MENUTILE_TERM_ICON_PATH, NULL);
 127     evas_object_move(term_icon, pos_x + width - ICO_HS_MENUTILE_TERM_ICON_WIDTH, pos_y);
 128     evas_object_resize(term_icon, ICO_HS_MENUTILE_TERM_ICON_WIDTH,
 129                        ICO_HS_MENUTILE_TERM_ICON_HEIGHT);
 130     evas_object_event_callback_add(term_icon, EVAS_CALLBACK_MOUSE_DOWN,
 131                                    CicoHSMenuTouch::TouchDownTerm, appid);
 132     evas_object_event_callback_add(term_icon, EVAS_CALLBACK_MOUSE_UP,
 133                                    CicoHSMenuTouch::TouchUpTerm, appid);
 134     ICO_DBG("CicoHSMenuTile::CreateObject Leave(%s Tile=(%d,%d) w/h=%d/%d",
 135             appid, pos_x, pos_y, width, height);
 136 }
 137
 138 /*--------------------------------------------------------------------------*/
 139 /**
 140  * @brief   CicoHSMenuTile::ShowTermIcon
 141  *          showing term icon
 142  *
 143  * @param[in]   none
 144  * @return      none
 145  */
 146 /*--------------------------------------------------------------------------*/
 147 void
 148 CicoHSMenuTile::ShowTermIcon()
 149 {
 150     evas_object_raise(term_icon);
 151     evas_object_show(term_icon);
 152 }
 153
 154 /*--------------------------------------------------------------------------*/
 155 /**
 156  * @brief   CicoHSMenuTile::HideTermIcon
 157  *          hiding term icon
 158  *
 159  * @param[in]   none
 160  * @return      none
 161  */
 162 /*--------------------------------------------------------------------------*/
 163 void
 164 CicoHSMenuTile::HideTermIcon(void)
 165 {
 166     evas_object_hide(term_icon);
 167 }
 168
 169 /*--------------------------------------------------------------------------*/
 170 /**
 171  * @brief   CicoHSMenuTile::FreeObject
 172  *          free tile object
 173  *
 174  * @param[in]   none
 175  * @return      none
 176  */
 177 /*--------------------------------------------------------------------------*/
 178 void
 179 CicoHSMenuTile::FreeObject(void)
 180 {
 181     char    sWork[80];
 182
 183     ICO_DBG("CicoHSMenuTile::FreeObject(appid=%08x<%s>)", (int)this->appid, appid);
 184
 185     if (thumb.surface)  {
 186         sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 187                 thumb.surface);
 188         (void) unlink(sWork);
 189         ico_syc_unmap_thumb(thumb.surface);
 190         thumb.surface = 0;
 191     }
 192     if (tile != NULL){
 193         evas_object_del(tile);
 194         tile = NULL;
 195     }
 196     if (small_icon != NULL){
 197         evas_object_del(small_icon);
 198         small_icon = NULL;
 199     }
 200     if (thumb_tile != NULL)  {
 201         evas_object_del(thumb_tile);
 202         thumb_tile = NULL;
 203     }
 204     if (term_icon != NULL)  {
 205         evas_object_del(term_icon);
 206         term_icon = NULL;
 207     }
 208 }
 209
 210 /*--------------------------------------------------------------------------*/
 211 /**
 212  * @brief   CicoHSMenuTile::Resize
 213  *          resize tile(currently unused)
 214  *
 215  * @param[in]   width         width
 216  * @param[in]   height        height
 217  * @return      none
 218  */
 219 /*--------------------------------------------------------------------------*/
 220 void
 221 CicoHSMenuTile::Resize(int width, int height)
 222 {
 223     ICO_DBG("CicoHSMenuTile::Resize (%d,%d)-(%d,%d) Unused",
 224             this->width, this->height, width, height);
 225 }
 226
 227 /*--------------------------------------------------------------------------*/
 228 /**
 229  * @brief   CicoHSMenuTile::MovePosition
 230  *          move tile base position
 231  *
 232  * @param[in]   page        page
 233  * @param[in]   position    position of tile
 234  * @return      none
 235  */
 236 /*--------------------------------------------------------------------------*/
 237 void
 238 CicoHSMenuTile::MovePosition(int page, int position)
 239 {
 240     this->page = page;
 241     this->position= position;
 242     pos_x = GetPositionX();
 243     pos_y = GetPositionY();
 244
 245     ICO_DBG("CicoHSMenuTile::MovePosition(appid=%08x<%s> tile=(%d,%d))",
 246             (int)this->appid, appid, pos_x, pos_y);
 247
 248     evas_object_move(tile, pos_x, pos_y);
 249     if (thumb_tile) {
 250         evas_object_move(thumb_tile, pos_x + thumb_reduce_x, pos_y + thumb_reduce_y);
 251     }
 252     if (small_icon) {
 253         evas_object_move(small_icon,
 254                          pos_x + thumb_reduce_x - ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2,
 255                          pos_y + height - thumb_reduce_y - height
 256                              / ICO_HS_MENUTILE_THUMBNAIL_REDUCTION
 257                              + ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2);
 258     }
 259     evas_object_move(term_icon, pos_x + width - ICO_HS_MENUTILE_TERM_ICON_WIDTH, pos_y);
 260 }
 261
 262 /*--------------------------------------------------------------------------*/
 263 /**
 264  * @brief   CicoHSMenuTile::OffsetMove
 265  *          move from base position
 266  *
 267  * @param[in]   offset_x    offset_x from base position
 268  * @param[in]   offset_y    offset_y from base position
 269  * @return      none
 270  */
 271 /*--------------------------------------------------------------------------*/
 272 void
 273 CicoHSMenuTile::OffsetMove(int offset_x, int offset_y)
 274 {
 275     pos_x = GetPositionX() + offset_x;
 276     pos_y = GetPositionY() + offset_y;
 277
 278     ICO_DBG("CicoHSMenuTile::OffsetMove(appid=%08x<%s> offset=%d,%d tile=(%d,%d) obj=%08x %08x %08x)",
 279             (int)this->appid, appid, offset_x, offset_y, pos_x, pos_y,
 280             (int)this->icon, (int)this->tile, (int)this->thumb_tile);
 281
 282     evas_object_move(tile, pos_x, pos_y);
 283     if (thumb_tile) {
 284         evas_object_move(thumb_tile, pos_x + thumb_reduce_x, pos_y + thumb_reduce_y);
 285     }
 286     if (small_icon) {
 287         evas_object_move(small_icon,
 288                          pos_x + thumb_reduce_x - ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2,
 289                          pos_y + height - thumb_reduce_y - height
 290                              / ICO_HS_MENUTILE_THUMBNAIL_REDUCTION
 291                              + ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2);
 292     }
 293     evas_object_move(term_icon, pos_x + width - ICO_HS_MENUTILE_TERM_ICON_WIDTH, pos_y);
 294 }
 295
 296 /*--------------------------------------------------------------------------*/
 297 /**
 298  * @brief   CicoHSMenuTile::GetImagePath
 299  *          get icon image path
 300  *
 301  * @param[in]   none
 302  * @return      icon image path
 303  */
 304 /*--------------------------------------------------------------------------*/
 305 const char*
 306 CicoHSMenuTile::GetImagePath(void)
 307 {
 308     return icon_image_path;
 309 }
 310
 311 /*--------------------------------------------------------------------------*/
 312 /**
 313  * @brief   CicoHSMenuTile::GetAppId
 314  *          get application id
 315  *
 316  * @param[in]   none
 317  * @return      application id
 318  */
 319 /*--------------------------------------------------------------------------*/
 320 const char*
 321 CicoHSMenuTile::GetAppId(void)
 322 {
 323     return appid;
 324 }
 325
 326 /*--------------------------------------------------------------------------*/
 327 /**
 328  * @brief   CicoHSMenuTile::GetWidth
 329  *          get width
 330  *
 331  * @param[in]   none
 332  * @return      width
 333  */
 334 /*--------------------------------------------------------------------------*/
 335 int
 336 CicoHSMenuTile::GetWidth(void)
 337 {
 338     return width;
 339 }
 340
 341 /*--------------------------------------------------------------------------*/
 342 /**
 343  * @brief   CicoHSMenuTile::GetHeight
 344  *          get height
 345  *
 346  * @param[in]   none
 347  * @return      height
 348  */
 349 /*--------------------------------------------------------------------------*/
 350 int
 351 CicoHSMenuTile::GetHeight(void)
 352 {
 353     return height;
 354 }
 355
 356 /*--------------------------------------------------------------------------*/
 357 /**
 358  * @brief   CicoHSMenuTile::GetPosition
 359  *          get position
 360  *
 361  * @param[in]   none
 362  * @return      position
 363  */
 364 /*--------------------------------------------------------------------------*/
 365 int
 366 CicoHSMenuTile::GetPosition(void)
 367 {
 368     return position;
 369 }
 370
 371 /*--------------------------------------------------------------------------*/
 372 /**
 373  * @brief   CicoHSMenuTile::GetPage
 374  *          get page
 375  *
 376  * @param[in]   none
 377  * @return      page
 378  */
 379 /*--------------------------------------------------------------------------*/
 380 int
 381 CicoHSMenuTile::GetPage(void)
 382 {
 383     return page;
 384 }
 385
 386 /*--------------------------------------------------------------------------*/
 387 /**
 388  * @brief   CicoHSMenuTile::GetSubPage
 389  *          get sub page
 390  *
 391  * @param[in]   none
 392  * @return      page
 393  */
 394 /*--------------------------------------------------------------------------*/
 395 int
 396 CicoHSMenuTile::GetSubPage(void)
 397 {
 398     return subpage;
 399 }
 400
 401 /*--------------------------------------------------------------------------*/
 402 /**
 403  * @brief   CicoHSMenuTile::GetPositionX
 404  *          get position x
 405  *
 406  * @param[in]   none
 407  * @return      position x
 408  */
 409 /*--------------------------------------------------------------------------*/
 410 int
 411 CicoHSMenuTile::GetPositionX(void)
 412 {
 413     int ret = 0;
 414
 415     if ((position == ICO_HS_MENUTILE_POSITION_0) ||
 416         (position == ICO_HS_MENUTILE_POSITION_3) ||
 417         (position == ICO_HS_MENUTILE_POSITION_6) ||
 418         (position == ICO_HS_MENUTILE_POSITION_9))   {
 419         ret = ICO_HS_MENUTILE_START_POS_X;
 420     }
 421     else if ((position == ICO_HS_MENUTILE_POSITION_1) ||
 422              (position == ICO_HS_MENUTILE_POSITION_4) ||
 423              (position == ICO_HS_MENUTILE_POSITION_7) ||
 424              (position == ICO_HS_MENUTILE_POSITION_10)) {
 425         ret = ICO_HS_MENUTILE_START_POS_X +
 426               (CicoHSMenuWindow::Tile_Width() + ICO_HS_MENUTILE_SPACE_TILE_AND_TILE);
 427     }
 428     else if ((position == ICO_HS_MENUTILE_POSITION_2) ||
 429              (position == ICO_HS_MENUTILE_POSITION_5) ||
 430              (position == ICO_HS_MENUTILE_POSITION_8) ||
 431              (position == ICO_HS_MENUTILE_POSITION_11)) {
 432         ret = ICO_HS_MENUTILE_START_POS_X +
 433               ((CicoHSMenuWindow::Tile_Width() + ICO_HS_MENUTILE_SPACE_TILE_AND_TILE) * 2);
 434     }
 435     return ret;
 436 }
 437
 438 /*--------------------------------------------------------------------------*/
 439 /**
 440  * @brief   CicoHSMenuTile::GetPositionY
 441  *          get position y
 442  *
 443  * @param[in]   none
 444  * @return      position y
 445  */
 446 /*--------------------------------------------------------------------------*/
 447 int
 448 CicoHSMenuTile::GetPositionY(void)
 449 {
 450     int ret = 0;
 451
 452     if ((position == ICO_HS_MENUTILE_POSITION_0) ||
 453         (position == ICO_HS_MENUTILE_POSITION_1) ||
 454         (position == ICO_HS_MENUTILE_POSITION_2))   {
 455         ret = ICO_HS_MENUTILE_START_POS_Y;
 456     }
 457     else if ((position == ICO_HS_MENUTILE_POSITION_3) ||
 458              (position == ICO_HS_MENUTILE_POSITION_4) ||
 459              (position == ICO_HS_MENUTILE_POSITION_5))  {
 460         ret = ICO_HS_MENUTILE_START_POS_Y +
 461               (CicoHSMenuWindow::Tile_Height() + ICO_HS_MENUTILE_SPACE_TILE_AND_TILE);
 462     }
 463     else if ((position == ICO_HS_MENUTILE_POSITION_6) ||
 464              (position == ICO_HS_MENUTILE_POSITION_7) ||
 465              (position == ICO_HS_MENUTILE_POSITION_8))  {
 466         ret = ICO_HS_MENUTILE_START_POS_Y +
 467               ((CicoHSMenuWindow::Tile_Height() + ICO_HS_MENUTILE_SPACE_TILE_AND_TILE) * 2);
 468     }
 469     else if ((position == ICO_HS_MENUTILE_POSITION_9) ||
 470              (position == ICO_HS_MENUTILE_POSITION_10) ||
 471              (position == ICO_HS_MENUTILE_POSITION_11)) {
 472         ret = ICO_HS_MENUTILE_START_POS_Y +
 473               ((CicoHSMenuWindow::Tile_Height() + ICO_HS_MENUTILE_SPACE_TILE_AND_TILE) * 3);
 474     }
 475     return ret;
 476 }
 477
 478 /*--------------------------------------------------------------------------*/
 479 /**
 480  * @brief   CicoHSMenuTile::ValidMenuIcon
 481  *          tile is icon(app terminated)
 482  *
 483  * @param[in]   none
 484  * @return      none
 485  */
 486 /*--------------------------------------------------------------------------*/
 487 void
 488 CicoHSMenuTile::ValidMenuIcon(void)
 489 {
 490     if (app_running)    {
 491         ICO_DBG("CicoHSMenuTile::ValidMenuIcon: %s show icon", appid);
 492         app_running = false;
 493         if (thumb.pixel_data)   {
 494             free(thumb.pixel_data);
 495             thumb.pixel_data = NULL;
 496         }
 497         if (icon == thumb_tile) {
 498             icon = tile;
 499             if (thumb_tile) {
 500                 evas_object_hide(thumb_tile);
 501             }
 502             if (tile)   {
 503                 evas_object_show(tile);
 504             }
 505         }
 506         if (small_icon) {
 507             evas_object_hide(small_icon);
 508         }
 509     }
 510 }
 511
 512 /*--------------------------------------------------------------------------*/
 513 /**
 514  * @brief   CicoHSMenuTile::ValidThumbnail
 515  *          tile is thumbnail(app started)
 516  *
 517  * @param[in]   surface   surface
 518  * @return      none
 519  */
 520 /*--------------------------------------------------------------------------*/
 521 void
 522 CicoHSMenuTile::ValidThumbnail(int surface)
 523 {
 524     char    sWork[80];
 525
 526     ICO_DBG("CicoHSMenuTile::ValidThumbnail(appid=%08x<%s>) run=%d surf=%08x",
 527             (int)this->appid, appid, app_running, surface);
 528
 529     if ((! app_running) || (surface == 0))  {
 530         if (thumb.surface != 0) {
 531             sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 532                     thumb.surface);
 533             (void) unlink(sWork);
 534             ico_syc_unmap_thumb(thumb.surface);
 535             // delete image and texture
 536             if ((surface == 0) && (thumb.pixel_data))   {
 537                 free(thumb.pixel_data);
 538                 thumb.pixel_data = NULL;
 539             }
 540         }
 541         thumb.surface = surface;
 542         if (surface)    {
 543             app_running = true;
 544             sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 545                     thumb.surface);
 546             (void) unlink(sWork);
 547             ico_syc_map_thumb(thumb.surface,
 548                               menu_show ? ICO_HS_MENUTILE_THUMBNAIL_FPS_SHOW :
 549                                           ICO_HS_MENUTILE_THUMBNAIL_FPS_HIDE, sWork);
 550             if (! small_icon)   {
 551                 small_icon = evas_object_image_filled_add(menu_evas);
 552                 evas_object_image_file_set(small_icon, icon_image_path, NULL);
 553                 evas_object_move(small_icon,
 554                                  pos_x + thumb_reduce_x
 555                                      - ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2,
 556                                  pos_y + height - thumb_reduce_y - height
 557                                      / ICO_HS_MENUTILE_THUMBNAIL_REDUCTION
 558                                      + ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2);
 559                 evas_object_resize(small_icon, width / ICO_HS_MENUTILE_THUMBNAIL_REDUCTION,
 560                                    height / ICO_HS_MENUTILE_THUMBNAIL_REDUCTION);
 561                 evas_object_event_callback_add(small_icon, EVAS_CALLBACK_MOUSE_DOWN,
 562                                                CicoHSMenuTouch::TouchDownMenu, appid);
 563                 evas_object_event_callback_add(small_icon, EVAS_CALLBACK_MOUSE_UP,
 564                                                CicoHSMenuTouch::TouchUpMenu, appid);
 565                 evas_object_raise(small_icon);
 566                 evas_object_raise(term_icon);
 567             }
 568             evas_object_show(small_icon);
 569             ICO_DBG("CicoHSMenuTile::ValidThumbnail: %s(%08x) show small icon",
 570                     appid, surface);
 571         }
 572         else    {
 573             app_running = false;
 574             if (icon == thumb_tile) {
 575                 ICO_DBG("CicoHSMenuTile::ValidThumbnail: %s change thumb->icon", appid);
 576                 icon = tile;
 577                 if (thumb_tile) {
 578                     evas_object_hide(thumb_tile);
 579                 }
 580                 evas_object_show(tile);
 581             }
 582             if (small_icon) {
 583                 evas_object_hide(small_icon);
 584             }
 585             ICO_DBG("CicoHSMenuTile::ValidThumbnail: %s(%08x) hide small icon",
 586                     appid, surface);
 587         }
 588     }
 589 }
 590
 591 /*--------------------------------------------------------------------------*/
 592 /**
 593  * @brief   CicoHSMenuTile::SetThumbnail
 594  *          tile is thumbnail
 595  *
 596  * @param[in]   info      thumbnail information, if NULL reset thumbnail
 597  * @return      none
 598  */
 599 /*--------------------------------------------------------------------------*/
 600 void
 601 CicoHSMenuTile::SetThumbnail(ico_syc_thumb_info_t *info)
 602 {
 603     Evas_Object         *old_icon = icon;
 604     struct ico_uifw_image_buffer *pixelbuf = NULL;
 605     int                 svx, svy;
 606     int                 unmap;
 607     int                 fd;
 608     char                sWork[80];
 609
 610     ICO_DBG("CicoHSMenuTile::SetThumbnail(appid=%08x<%s>) info=%08x surf=%08x",
 611             (int)this->appid, appid, (int)info, info ? info->surface : 0);
 612
 613     if ((info == NULL) || (info->surface == 0)) {
 614         unmap = 1;
 615     }
 616     else    {
 617         unmap = 0;
 618         if (thumb.surface != info->surface) {
 619             if (thumb.surface != 0) {
 620                 ICO_DBG("CicoHSMenuTile::SetThumbnail: surface change(%08x->%08x)",
 621                         thumb.surface, info->surface);
 622                 ico_syc_unmap_thumb(thumb.surface);
 623                 sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 624                         thumb.surface);
 625                 (void) unlink(sWork);
 626             }
 627             thumb.surface = info->surface;
 628             sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 629                     thumb.surface);
 630             (void) unlink(sWork);
 631             ico_syc_map_thumb(thumb.surface,
 632                               menu_show ? ICO_HS_MENUTILE_THUMBNAIL_FPS_SHOW :
 633                                           ICO_HS_MENUTILE_THUMBNAIL_FPS_HIDE, sWork);
 634         }
 635         else    {
 636             sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 637                     thumb.surface);
 638         }
 639         thumb.type = info->type;
 640         thumb.width = info->width;
 641         thumb.height = info->height;
 642         thumb.stride = info->stride;
 643         thumb.format = info->format;
 644 #if 0       /* too many log */
 645         ICO_DBG("CicoHSMenuTile::SetThumbnail: make thumbnail %s(%08x) "
 646                 "type=%d w/h/s=%d/%d/%d tile w/h=%d/%d",
 647                 appid, thumb.surface, thumb.type,
 648                 thumb.width, thumb.height, thumb.stride, width, height);
 649 #endif
 650         if ((info->width <= 1) || (info->height <= 1))  {
 651             ICO_DBG("CicoHSMenuTile::SetThumbnail: small surface(%d,%d) skip",
 652                     info->width, info->height);
 653         }
 654         else    {
 655             // create thumbnail image
 656             svx = thumb_reduce_x;
 657             svy = thumb_reduce_y;
 658             if (thumb.width > (thumb.height + 64))  {
 659                 thumb_reduce_x = ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX;
 660                 thumb_reduce_y = height / ICO_HS_MENUTILE_THUMBNAIL_REDUCE_RATE;
 661             }
 662             else if (thumb.width < (thumb.height - 64)) {
 663                 thumb_reduce_y = ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX;
 664                 thumb_reduce_x = width / ICO_HS_MENUTILE_THUMBNAIL_REDUCE_RATE;
 665             }
 666             else    {
 667                 thumb_reduce_x = ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX;
 668                 thumb_reduce_y = ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX;
 669             }
 670             if (! thumb_tile)   {
 671                 thumb_tile = evas_object_image_filled_add(menu_evas);
 672                 evas_object_resize(thumb_tile, width - thumb_reduce_x * 2,
 673                                                height - thumb_reduce_y * 2);
 674                 evas_object_move(thumb_tile, pos_x + thumb_reduce_x,
 675                                  pos_y + thumb_reduce_y);
 676                 evas_object_event_callback_add(thumb_tile, EVAS_CALLBACK_MOUSE_DOWN,
 677                                                CicoHSMenuTouch::TouchDownMenu, appid);
 678                 evas_object_event_callback_add(thumb_tile, EVAS_CALLBACK_MOUSE_UP,
 679                                                CicoHSMenuTouch::TouchUpMenu, appid);
 680                 ICO_DBG("CicoHSMenuTile::SetThumbnail: create thumb_tile %s "
 681                         "tile=(%d+%d,%d+%d)", appid,
 682                         pos_x, thumb_reduce_x, pos_y, thumb_reduce_y);
 683                 if (small_icon) {
 684                     evas_object_move(small_icon,
 685                                      pos_x + thumb_reduce_x
 686                                          - ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2,
 687                                      pos_y + height - thumb_reduce_y - height
 688                                          / ICO_HS_MENUTILE_THUMBNAIL_REDUCTION
 689                                          + ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2);
 690                     evas_object_raise(small_icon);
 691                 }
 692                 evas_object_raise(term_icon);
 693             }
 694             else if ((svx != thumb_reduce_x) || (svy != thumb_reduce_y))    {
 695                 evas_object_resize(thumb_tile, width - thumb_reduce_x * 2,
 696                                                height - thumb_reduce_y * 2);
 697                 evas_object_move(thumb_tile, pos_x + thumb_reduce_x,
 698                                  pos_y + thumb_reduce_y);
 699                 if (small_icon) {
 700                     evas_object_move(small_icon,
 701                                      pos_x + thumb_reduce_x
 702                                          - ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2,
 703                                      pos_y + height - thumb_reduce_y - height
 704                                          / ICO_HS_MENUTILE_THUMBNAIL_REDUCTION
 705                                          + ICO_HS_MENUTILE_THUMBNAIL_REDUCE_PIX2);
 706                 }
 707             }
 708             /* read surface image pixel         */
 709             int bufsize = ((thumb.width * thumb.height * 4 + 4096 - 1) / 4096) * 4095;
 710             if ((! thumb.pixel_data) || (bufsize > thumb.pixel_bufsize))    {
 711                 if (thumb.pixel_data)   free(thumb.pixel_data);
 712                 thumb.pixel_data = (char *)malloc(bufsize);
 713                 thumb.pixel_bufsize = bufsize;
 714             }
 715             if (thumb.pixel_data)   {
 716                 fd = open(sWork, O_RDONLY, 0644);
 717                 if ((fd < 0) ||
 718                     (read(fd, thumb.pixel_data, bufsize) <= 0)) {
 719                     ICO_ERR("CicoHSMenuTile::SetThumbnail: can not read pixel file(%s)", sWork);
 720                     unmap = 1;
 721                 }
 722                 if (fd >= 0)    {
 723                     close(fd);
 724                     (void) unlink(sWork);
 725                 }
 726                 if (unmap == 0) {
 727                     evas_object_image_data_update_add(
 728                                     thumb_tile, 0, 0, thumb.width, thumb.height);
 729                     icon = thumb_tile;
 730                     evas_object_image_size_set(thumb_tile, thumb.width, thumb.height);
 731                     evas_object_image_data_set(thumb_tile, thumb.pixel_data);
 732                     evas_object_image_filled_set(thumb_tile, EINA_TRUE);
 733                     evas_object_resize(thumb_tile, width - thumb_reduce_x * 2,
 734                                        height - thumb_reduce_y * 2);
 735                     evas_object_move(thumb_tile,
 736                                      pos_x + thumb_reduce_x, pos_y + thumb_reduce_y);
 737                 }
 738             }
 739             else    {
 740                 ICO_ERR("CicoHSMenuTile::SetThumbnail: can not malloc pixel buffer");
 741                 unmap = 1;
 742             }
 743         }
 744     }
 745
 746     if (unmap > 0)  {
 747         ICO_DBG("CicoHSMenuTile::SetThumbnail: unmap thumbnail %08x", thumb.surface);
 748         if (thumb.surface)  {
 749             sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 750                     thumb.surface);
 751             (void) unlink(sWork);
 752             ico_syc_unmap_thumb(thumb.surface);
 753             thumb.surface = 0;
 754         }
 755         if (thumb.pixel_data)   {
 756             free(thumb.pixel_data);
 757             thumb.pixel_data = NULL;
 758         }
 759         icon = tile;
 760     }
 761
 762     if (icon != old_icon)   {
 763         if (old_icon)   {
 764             evas_object_hide(old_icon);
 765         }
 766         evas_object_show(icon);
 767         if (small_icon) {
 768             if (icon == thumb_tile) {
 769                 evas_object_show(small_icon);
 770                 // remake thumbnail for first build image
 771                 CicoHSMenuTile::SetThumbnail(info);
 772             }
 773             else    {
 774                 evas_object_hide(small_icon);
 775             }
 776         }
 777     }
 778     if (pixelbuf != NULL)   {
 779         // free shared memory pixel buffer
 780         pixelbuf->reftime = pixelbuf->settime;
 781     }
 782 }
 783
 784 /*--------------------------------------------------------------------------*/
 785 /**
 786  * @brief   CicoHSMenuTile::ShowMenu
 787  *          change menu show/hide for live thumbnail update cycle
 788  *
 789  * @param[in]   show    surface
 790  * @return      nonmenu show(true)/fide(false)
 791  */
 792 /*--------------------------------------------------------------------------*/
 793 void
 794 CicoHSMenuTile::ShowMenu(bool show)
 795 {
 796     char    sWork[80];
 797     menu_show = show;
 798     if ((thumb_tile) && (thumb.surface != 0)) {
 799         sprintf(sWork, "%s/%08x.pixel", ICO_HS_THUMB_ICODIR ICO_HS_THUMB_FILEDIR,
 800                 thumb.surface);
 801         (void) unlink(sWork);
 802         ico_syc_map_thumb(thumb.surface,
 803                           menu_show ? ICO_HS_MENUTILE_THUMBNAIL_FPS_SHOW :
 804                                       ICO_HS_MENUTILE_THUMBNAIL_FPS_HIDE, sWork);
 805     }
 806 }
 807 // vim: set expandtab ts=4 sw=4: