src/clipdrawer.c

   1 #include "common.h"
   2 #include "cbhm_main.h"
   3 #include "storage.h"
   4 #include "xcnphandler.h"
   5 #include "clipdrawer.h"
   6
   7 #define DELETE_ICON_PATH "/usr/share/icon/cbhm/05_delete.png"
   8 #define IM      "/usr/share/icon/cbhm/"
   9 static const char *g_images_path[] = {
  10         IM"cbhm_default_img.png",
  11 /*
  12         IM"2_photo.jpg",
  13         IM"3_photo.jpg",
  14         IM"4_photo.jpg",
  15         IM"5_photo.jpg",
  16         IM"6_photo.jpg",
  17 */
  18 };
  19 #define N_IMAGES (1)
  20
  21 #define GRID_ITEM_SPACE_W 6
  22 #define GRID_ITEM_SINGLE_W 187
  23 #define GRID_ITEM_SINGLE_H 151
  24 #define GRID_ITEM_W (GRID_ITEM_SINGLE_W+(GRID_ITEM_SPACE_W*2))
  25 #define GRID_ITEM_H (GRID_ITEM_SINGLE_H)
  26 #define GRID_IMAGE_LIMIT_W 91
  27 #define GRID_IMAGE_LIMIT_H 113
  28
  29 // 0 - select mode, 1 - delete mode
  30 static int g_clipdrawer_mode = 0;
  31 // gic should live at gengrid callback functions
  32 Elm_Gengrid_Item_Class gic;
  33
  34 typedef struct tag_griditem
  35 {
  36         Elm_Gengrid_Item *item;
  37         const char *ipathdata;
  38         Eina_Strbuf* istrdata;
  39         int itype;
  40         Evas_Object *delbtn;
  41 } griditem_t;
  42
  43 static int toggle_clipdrawer_mode()
  44 {
  45         g_clipdrawer_mode = !g_clipdrawer_mode;
  46         return g_clipdrawer_mode;
  47 }
  48
  49 static int get_clipdrawer_mode()
  50 {
  51         return g_clipdrawer_mode;
  52 }
  53
  54 static void _list_click_paste(void *data, Evas_Object *obj, void *event_info)
  55 {
  56         struct appdata *ad = data;
  57     Elm_List_Item *it = (Elm_List_Item *) elm_list_selected_item_get(obj);
  58         if (it == NULL)
  59                 return;
  60
  61     elm_list_item_selected_set(it, 0);
  62
  63         Elm_List_Item *item;
  64         Eina_List *n;
  65         int hc = 0;
  66         EINA_LIST_FOREACH(elm_list_items_get(ad->txtlist), n, item)
  67         {
  68                 if (item == it)
  69                         break;
  70                 hc++;
  71         }
  72
  73         fprintf(stderr, "## this c = %d, %d\n", hc, get_current_history_position());
  74
  75 //      int pos = get_current_history_position() - hc;
  76
  77         int     pos = get_current_history_position()-hc;
  78         if (pos < 0)
  79                 pos = pos+(HISTORY_QUEUE_MAX_ITEMS);
  80
  81         fprintf(stderr, "## pos = %d, %s\n", pos, get_item_contents_by_pos(pos));
  82         char *p = strdup(get_item_contents_by_pos(pos));
  83
  84         elm_selection_set(1, obj, /*ELM_SEL_FORMAT_TEXT*/1, p);
  85
  86 /*
  87         char *p = NULL;
  88         int cplen;
  89
  90         char *cpdata = NULL;
  91         cpdata = elm_entry_utf8_to_markup(elm_list_item_label_get(it));
  92         if (cpdata == NULL)
  93                 return;
  94         cplen = strlen(cpdata);
  95         p = malloc(cplen + 1);
  96         snprintf(p, cplen+1, "%s", cpdata);
  97 */
  98 //      elm_selection_set(1, obj, /*ELM_SEL_FORMAT_TEXT*/1, p);
  99 //      elm_selection_set(1, obj, /*ELM_SEL_FORMAT_MARKUP*/2, p);
 100
 101 //      clipdrawer_lower_view(ad);
 102 }
 103
 104 int clipdrawer_update_contents(void *data)
 105 {
 106         struct appdata *ad = data;
 107         int i, pos;
 108         char *unesc = NULL;
 109
 110         // if delete mode, then back to normal mode
 111 //      if (get_clipdrawer_mode())
 112 //              clipdrawer_change_mode(ad);
 113
 114         for (i = 0; i < HISTORY_QUEUE_MAX_ITEMS; i++)
 115         {
 116                 pos = get_current_history_position() - i;
 117                 if (pos < 0)
 118                         pos = pos+HISTORY_QUEUE_MAX_ITEMS;
 119
 120                 if (get_item_contents_by_pos(pos) != NULL && strlen(get_item_contents_by_pos(pos)) > 0)
 121                 {
 122                         unesc = clipdrawer_get_plain_string_from_escaped(get_item_contents_by_pos(pos));
 123                         unesc = unesc ? unesc : "";
 124                         elm_list_item_append(ad->txtlist, unesc, NULL, NULL, NULL, ad);
 125                         free(unesc);
 126                 }
 127         }
 128
 129         /* FIXME : sometimes when list update, screen isn't updated */
 130
 131         return 0;
 132 }
 133
 134 const char* clipdrawer_get_plain_string_from_escaped(char *escstr)
 135 {
 136         /* TODO : is it should be here? besides, remove dependency for entry */
 137         /* NOTE : return string should be freed */
 138         return elm_entry_markup_to_utf8(escstr);
 139 }
 140
 141 static void
 142 _grid_item_ly_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
 143 {
 144         struct appdata *ad = data;
 145
 146         fprintf(stderr, "## gi clicked = %s\n", source);
 147 }
 148
 149 static void
 150 _grid_item_check_changed(void *data, Evas_Object *obj, void *event_info)
 151 {
 152         griditem_t *ti = (griditem_t *)data;
 153
 154         fprintf(stderr, "## item clicked\n");
 155 }
 156
 157 Evas_Object* _grid_icon_get(const void *data, Evas_Object *obj, const char *part)
 158 {
 159         int delete_mode = get_clipdrawer_mode();
 160         griditem_t *ti = (griditem_t *)data;
 161
 162         if (!strcmp(part, "elm.swallow.icon"))
 163         {
 164                 if (ti->itype == GI_TEXT)
 165                 {
 166                         Evas_Object *layout = elm_layout_add (obj);
 167                         elm_layout_theme_set(layout, "gengrid", "widestyle", "horizontal_layout");
 168                         edje_object_signal_callback_add(elm_layout_edje_get(layout), "mouse,up,1", "*", _grid_item_ly_clicked, g_get_main_appdata());
 169                         Evas_Object *rect = evas_object_rectangle_add(evas_object_evas_get(obj));
 170                         evas_object_resize(rect, GRID_ITEM_W, GRID_ITEM_H);
 171                         evas_object_color_set(rect, 242, 233, 183, 255);
 172                         evas_object_show(rect);
 173                         elm_layout_content_set(layout, "elm.swallow.icon", rect);
 174
 175                         Evas_Object *ientry = elm_scrolled_entry_add(obj);
 176                         evas_object_size_hint_weight_set(ientry, 0, 0);
 177                         Eina_Strbuf *strent = NULL;
 178                         char *strdata = eina_strbuf_string_get(ti->istrdata);
 179                         int i, skipflag, strcnt;
 180
 181                         strent = eina_strbuf_new();
 182                         skipflag = 0;
 183                         strcnt = 0;
 184                         for (i = 0; i < eina_strbuf_length_get(ti->istrdata); i++)
 185                         {
 186                                 switch (strdata[i])
 187                                 {
 188                                         case '>':
 189                                                 skipflag = 0;
 190                                                 break;
 191                                         case '<':
 192                                                 skipflag = 1;
 193                                                 break;
 194                                         default:
 195                                                 if (!skipflag)
 196                                                         strcnt++;
 197                                                 break;
 198                                 }
 199                                 if (strcnt > 100)
 200                                         break;
 201                         }
 202                         eina_strbuf_append_n(strent, strdata, i);
 203 //                      eina_strbuf_append(strent, strdata);
 204                         eina_strbuf_replace_all(strent, " absize=240x180 ", " absize=52x39 ");
 205                         if (strcnt > 100)
 206                                 eina_strbuf_append(strent, "...");
 207
 208                         elm_scrolled_entry_entry_set(ientry, eina_strbuf_string_get(strent));
 209                         elm_scrolled_entry_editable_set(ientry, EINA_FALSE);
 210                         elm_scrolled_entry_context_menu_disabled_set(ientry, EINA_TRUE);
 211                         evas_object_show(ientry);
 212                         elm_layout_content_set(layout, "elm.swallow.inner", ientry);
 213
 214                         eina_strbuf_free(strent);
 215
 216                         return layout;
 217                 }
 218                 else// if (ti->itype == GI_IMAGE)
 219                 {
 220                         Evas_Object *layout = elm_layout_add (obj);
 221                         elm_layout_theme_set(layout, "gengrid", "widestyle", "horizontal_layout");
 222                         edje_object_signal_callback_add(elm_layout_edje_get(layout), "mouse,up,1", "*", _grid_item_ly_clicked, g_get_main_appdata());
 223                         Evas_Object *sicon;
 224                         sicon = evas_object_image_add(evas_object_evas_get(obj));
 225                         evas_object_image_load_size_set(sicon, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 226                         evas_object_image_file_set(sicon, ti->ipathdata, NULL);
 227                         evas_object_image_fill_set(sicon, 0, 0, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 228                         evas_object_resize(sicon, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 229                         elm_layout_content_set(layout, "elm.swallow.icon", sicon);
 230
 231                         return layout;
 232
 233 /*
 234                         Evas_Object *icon = elm_icon_add(obj);
 235                         elm_icon_file_set(icon, ti->ipathdata, NULL);
 236                         evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 237                         evas_object_show(icon);
 238 */
 239
 240 /*
 241                         Ecore_Evas *my_ee;
 242                         Evas *my_e;
 243                         Evas_Object *fgimg;
 244                         Evas_Object *bgrect;
 245                         Evas_Object *delbtn;
 246                         Evas_Object *icon;
 247                         my_ee = ecore_evas_buffer_new(GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 248                         my_e = ecore_evas_get(my_ee);
 249
 250                         bgrect = evas_object_rectangle_add(my_e);
 251                         evas_object_color_set(bgrect, 255, 255, 255, 255);
 252                         evas_object_resize(bgrect, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 253                         evas_object_move(bgrect, 0, 0);
 254                         evas_object_show(bgrect);
 255
 256 #define BORDER_SIZE 1
 257                         fgimg = evas_object_image_add(my_e);
 258                         evas_object_image_load_size_set(fgimg, GRID_ITEM_SINGLE_W-BORDER_SIZE*2, GRID_ITEM_SINGLE_H-BORDER_SIZE*2);
 259                         evas_object_image_file_set(fgimg, ti->ipathdata, NULL);
 260                         evas_object_image_fill_set(fgimg, 0, 0, GRID_ITEM_SINGLE_W-BORDER_SIZE*2, GRID_ITEM_SINGLE_H-BORDER_SIZE*2);
 261                         evas_object_image_filled_set(fgimg, 1);
 262                         int x,y;
 263                         evas_object_image_size_get(fgimg, &x, &y);
 264                         //fprintf(stderr, "## img x = %d, y = %d\n", x, y);
 265                         evas_object_resize(fgimg, GRID_ITEM_SINGLE_W-BORDER_SIZE*2, GRID_ITEM_SINGLE_H-BORDER_SIZE*2);
 266                         evas_object_move(fgimg, BORDER_SIZE, BORDER_SIZE);
 267                         evas_object_show(fgimg);
 268
 269                         icon = evas_object_image_add(evas_object_evas_get(obj));
 270
 271                         evas_object_image_data_set(icon, NULL);
 272                         evas_object_image_size_set(icon, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 273                         evas_object_image_fill_set(icon, 0, 0, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 274                         evas_object_image_filled_set(icon, EINA_TRUE);
 275                         evas_object_image_data_copy_set(icon, (int *)ecore_evas_buffer_pixels_get(my_ee));
 276                         evas_object_image_data_update_add(icon, 0, 0, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 277
 278                         evas_object_del(bgrect);
 279                         evas_object_del(fgimg);
 280                         ecore_evas_free(my_ee);
 281
 282                         return icon;
 283 */
 284                 }
 285
 286 //              return icon;
 287         }
 288 /*
 289         else if (!strcmp(part, "elm.swallow.end"))
 290         {
 291                 ti->delbtn = elm_check_add(obj);
 292                 elm_object_style_set(ti->delbtn, "extended/itemcheck");
 293                 //evas_object_propagate_events_set(ti->delbtn, 0);
 294                 elm_check_state_set(ti->delbtn, tcm);
 295                 evas_object_smart_callback_add(ti->delbtn, "changed", _grid_item_check_changed, data);
 296                 evas_object_show(ti->delbtn);
 297                 return ti->delbtn;
 298         }
 299 */
 300
 301         return NULL;
 302 }
 303
 304 static void _grid_longpress(void *data, Evas_Object *obj, void *event_info)
 305 {
 306         struct appdata *ad = data;
 307         clipdrawer_change_mode(ad);
 308 }
 309
 310 static void _grid_click_paste(void *data, Evas_Object *obj, void *event_info)
 311 {
 312         struct appdata *ad = data;
 313         char *file, *p;
 314         int len;
 315         Elm_Gengrid_Item *sgobj = NULL;
 316         sgobj = elm_gengrid_selected_item_get(ad->hig);
 317         griditem_t *ti = NULL;
 318         ti = elm_gengrid_item_data_get(sgobj);
 319
 320         if (!sgobj || !ti)
 321         {
 322                 DTRACE("ERR: cbhm can't get the selected image\n");
 323                 return;
 324         }
 325         if (ti->itype == GI_TEXT)
 326         {
 327                 char *p = strdup(eina_strbuf_string_get(ti->istrdata));
 328
 329                 elm_selection_set(1, obj, /*ELM_SEL_FORMAT_TEXT*/1, p);
 330
 331                 elm_gengrid_item_selected_set(sgobj, EINA_FALSE);
 332         }
 333         else //if (ti->itype == GI_IMAGE)
 334         {
 335                 len = strlen(ti->ipathdata);
 336                 p = malloc(len + 10);
 337                 snprintf(p,len+10, "file:///%s", ti->ipathdata);
 338
 339                 elm_selection_set(/*secondary*/1,obj,/*ELM_SEL_FORMAT_IMAGE*/4,p);
 340
 341                 elm_gengrid_item_selected_set(sgobj, EINA_FALSE);
 342         }
 343 }
 344
 345 static void _grid_del_response_cb(void *data, Evas_Object *obj, void *event_info)
 346 {
 347         Elm_Gengrid_Item *it = (Elm_Gengrid_Item *)data;
 348         evas_object_del(obj);
 349
 350         if((int)event_info == ELM_POPUP_RESPONSE_OK)
 351                 elm_gengrid_item_del(it);
 352 }
 353
 354 static void _grid_click_delete(void *data, Evas_Object *obj, void *event_info)
 355 {
 356         struct appdata *ad = data;
 357         Elm_Gengrid_Item *sgobj = NULL;
 358         sgobj = elm_gengrid_selected_item_get(ad->hig);
 359         griditem_t *ti = NULL;
 360         ti = elm_gengrid_item_data_get(sgobj);
 361
 362         if (!sgobj || !ti)
 363         {
 364                 DTRACE("ERR: cbhm can't get the clicked del image\n");
 365                 return;
 366         }
 367
 368         Evas_Object *popup = elm_popup_add(ad->win_main);
 369         elm_popup_timeout_set(popup, 5);
 370         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 371         elm_popup_desc_set(popup, "Are you sure delete this?");
 372         elm_popup_buttons_add(popup, 2,
 373                                                   "Yes", ELM_POPUP_RESPONSE_OK,
 374                                                   "No", ELM_POPUP_RESPONSE_CANCEL,
 375                                                   NULL);
 376         evas_object_smart_callback_add(popup, "response", _grid_del_response_cb, sgobj);
 377         evas_object_show(popup);
 378 }
 379
 380 void _grid_del(const void *data, Evas_Object *obj)
 381 {
 382         griditem_t *ti = (griditem_t *)data;
 383         if (ti->itype == GI_IMAGE)
 384                 eina_stringshare_del(ti->ipathdata);
 385         else
 386                 eina_strbuf_free(ti->istrdata);
 387         free(ti);
 388 }
 389
 390 int clipdrawer_refresh_history_item(void *data, int delete_mode)
 391 {
 392         struct appdata *ad = data;
 393         Eina_List *oldlist = NULL;
 394         const Eina_List *l;
 395         Elm_Gengrid_Item *lgrid;
 396         griditem_t *lgitem;
 397         Evas_Object *ngg;
 398         Evas_Object *oldgg;
 399
 400         oldlist = elm_gengrid_items_get(ad->hig);
 401         elm_layout_content_unset(ad->ly_main, "imagehistory/list");
 402         ngg = elm_gengrid_add(ad->win_main);
 403         elm_layout_content_set(ad->ly_main, "imagehistory/list", ngg);
 404         oldgg = ad->hig;
 405         ad->hig = ngg;
 406         elm_gengrid_item_size_set(ad->hig, GRID_ITEM_W, GRID_ITEM_H);
 407         elm_gengrid_align_set(ad->hig, 0.5, 0.5);
 408 //      elm_gengrid_horizontal_set(ad->hig, EINA_TRUE);
 409         elm_gengrid_bounce_set(ad->hig, EINA_TRUE, EINA_FALSE);
 410         elm_gengrid_multi_select_set(ad->hig, EINA_FALSE);
 411         if (delete_mode)
 412                 evas_object_smart_callback_add(ad->hig, "selected", _grid_click_delete, ad);
 413         else
 414                 evas_object_smart_callback_add(ad->hig, "selected", _grid_click_paste, ad);
 415         evas_object_smart_callback_add(ad->hig, "longpressed", _grid_longpress, ad);
 416         evas_object_size_hint_weight_set(ad->hig, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 417
 418         gic.item_style = "default_grid";
 419         gic.func.label_get = NULL;
 420         gic.func.icon_get = _grid_icon_get;
 421         gic.func.state_get = NULL;
 422         gic.func.del = _grid_del;
 423
 424         EINA_LIST_REVERSE_FOREACH(oldlist, l, lgrid)
 425         {
 426                 lgitem = elm_gengrid_item_data_get(lgrid);
 427                 clipdrawer_add_item(lgitem->ipathdata, GI_IMAGE);
 428         }
 429
 430         evas_object_show (ad->hig);
 431
 432         elm_gengrid_clear(oldgg);
 433         evas_object_hide(oldgg);
 434         evas_object_del(oldgg);
 435
 436         return 0;
 437 }
 438
 439 int clipdrawer_change_mode(void *data)
 440 {
 441         struct appdata *ad = data;
 442
 443         toggle_clipdrawer_mode();
 444
 445         DTRACE("clipdrawer delete mode = %d\n", get_clipdrawer_mode());
 446
 447         clipdrawer_refresh_history_item(ad, get_clipdrawer_mode());
 448
 449         return 0;
 450 }
 451
 452 // FIXME: how to remove calling g_get_main_appdata()?
 453 //        it's mainly used at 'clipdrawer_image_item'
 454 int clipdrawer_add_item(char *idata, int type)
 455 {
 456         struct appdata *ad = g_get_main_appdata();
 457         griditem_t *newgi = NULL;
 458         Eina_List *igl = NULL;
 459         unsigned int igl_counter = 0;
 460
 461         // if delete mode, then back to normal mode
 462 //      if (get_clipdrawer_mode())
 463 //              clipdrawer_change_mode(ad);
 464
 465
 466         newgi = malloc(sizeof(griditem_t));
 467         newgi->itype = type;
 468         igl = elm_gengrid_items_get(ad->hig);
 469         igl_counter = eina_list_count(igl);
 470
 471         fprintf(stderr, "## add - %d : %s\n", newgi->itype, idata);
 472         if (type == GI_TEXT)
 473         {
 474                 newgi->istrdata = eina_strbuf_new();
 475                 eina_strbuf_append(newgi->istrdata, idata);
 476         }
 477         else //if (type == GI_IMAGE)
 478         {
 479                 Eina_List *l;
 480                 Elm_Gengrid_Item *item;
 481                 griditem_t *ti = NULL;
 482
 483                 if (!check_regular_file(idata))
 484                 {
 485                         DTRACE("Error : it isn't normal file = %s\n", idata);
 486                         return -1;
 487                 }
 488
 489                 EINA_LIST_FOREACH(igl, l, item)
 490                 {
 491                         ti = elm_gengrid_item_data_get(item);
 492                         if ((ti->itype == type) && !strcmp(ti->ipathdata, idata))
 493                         {
 494                                 DTRACE("Error : duplicated file path = %s\n", idata);
 495                                 return -1;
 496                         }
 497                 }
 498
 499                 newgi->ipathdata = eina_stringshare_add(idata);
 500         }
 501
 502         if (igl_counter >= HISTORY_QUEUE_MAX_ITEMS)
 503         {
 504                 // FIXME: add routine that is removing its elements
 505                 elm_gengrid_item_del(eina_list_data_get(eina_list_last(igl)));
 506         }
 507
 508         newgi->item = elm_gengrid_item_prepend(ad->hig, &gic, newgi, NULL, NULL);
 509
 510         return TRUE;
 511 }
 512
 513 static void
 514 clipdrawer_ly_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
 515 {
 516         struct appdata *ad = data;
 517
 518         fprintf(stderr, "## clicked = %s\n", source);
 519
 520         #define EDJE_CLOSE_PART_PREFIX "background/close"
 521         if (!strncmp(source, EDJE_CLOSE_PART_PREFIX, strlen(EDJE_CLOSE_PART_PREFIX)))
 522         {
 523                 clipdrawer_lower_view(ad);
 524         }
 525 }
 526
 527 int clipdrawer_init(void *data)
 528 {
 529         struct appdata *ad = data;
 530         double cdy, cdw;
 531
 532         // for elm_check
 533         elm_theme_extension_add(NULL, APP_EDJ_FILE);
 534
 535         cdy = (1.0*CLIPDRAWER_HEIGHT/SCREEN_HEIGHT)*ad->root_h;
 536         cdw = (1.0*CLIPDRAWER_POS_Y/SCREEN_HEIGHT)*ad->root_h;
 537
 538         evas_object_resize(ad->win_main, ad->root_w, (int)cdy);
 539         evas_object_move(ad->win_main, CLIPDRAWER_POS_X, (int)cdw);
 540         evas_object_resize(ad->ly_main, ad->root_w, (int)cdy);
 541         evas_object_move(ad->ly_main, CLIPDRAWER_POS_X, (int)cdw);
 542
 543         edje_object_signal_callback_add(elm_layout_edje_get(ad->ly_main), "mouse,up,1", "*", clipdrawer_ly_clicked, ad);
 544
 545         ad->hig = NULL;
 546         ad->hig = elm_gengrid_add(ad->win_main);
 547         elm_layout_content_set(ad->ly_main, "historyitems", ad->hig);
 548         elm_gengrid_item_size_set(ad->hig, GRID_ITEM_W+2, GRID_ITEM_H);
 549         elm_gengrid_align_set(ad->hig, 0.5, 0.5);
 550         elm_gengrid_horizontal_set(ad->hig, EINA_TRUE);
 551         elm_gengrid_bounce_set(ad->hig, EINA_TRUE, EINA_FALSE);
 552         elm_gengrid_multi_select_set(ad->hig, EINA_FALSE);
 553         evas_object_smart_callback_add(ad->hig, "selected", _grid_click_paste, ad);
 554 //      evas_object_smart_callback_add(ad->hig, "longpressed", _grid_longpress, ad);
 555         evas_object_size_hint_weight_set(ad->hig, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 556
 557         elm_gengrid_clear(ad->hig);
 558
 559         gic.item_style = "default_grid";
 560         gic.func.label_get = NULL;
 561         gic.func.icon_get = _grid_icon_get;
 562         gic.func.state_get = NULL;
 563         gic.func.del = _grid_del;
 564
 565         int i;
 566         griditem_t *newgi;
 567
 568         for (i = 0; i < N_IMAGES; i++)
 569         {
 570                 clipdrawer_add_item(g_images_path[0], GI_IMAGE);
 571         }
 572
 573         clipdrawer_add_item("clipboard history", GI_TEXT);
 574
 575         evas_object_show (ad->hig);
 576
 577 // for debugging, calc history pos
 578 /*
 579    Evas_Coord x, y, w, h;
 580    Evas_Coord vx, vy, vw, vh;
 581
 582    edje_object_part_geometry_get(elm_layout_edje_get(ad->ly_main),"imagehistory/list",&x,&y,&w,&h);
 583    evas_object_geometry_get (ad->hig, &vx,&vy,&vw,&vh);
 584    fprintf(stderr, "## x = %d, y = %d, w = %d, h = %d\n", x, y, w, h);
 585    fprintf(stderr, "## vx = %d, vy = %d, vw = %d, vh = %d\n", vx, vy, vw, vh);
 586 */
 587
 588 //      if (get_item_counts() != 0)
 589 //              clipdrawer_update_contents(ad);
 590
 591         return 0;
 592 }
 593
 594 int clipdrawer_create_view(void *data)
 595 {
 596         struct appdata *ad = data;
 597
 598         clipdrawer_init(ad);
 599
 600         // for debug
 601         // at starting, showing app view
 602         clipdrawer_activate_view(ad);
 603
 604         return 0;
 605 }
 606
 607 void clipdrawer_activate_view(void *data)
 608 {
 609         struct appdata *ad = data;
 610
 611         if (ad->win_main)
 612         {
 613                 evas_object_show(ad->win_main);
 614                 elm_win_activate(ad->win_main);
 615         }
 616 }
 617
 618 void clipdrawer_lower_view(void *data)
 619 {
 620         struct appdata *ad = data;
 621
 622         if (ad->win_main)
 623         {
 624                 evas_object_hide(ad->win_main);
 625                 elm_win_lower(ad->win_main);
 626
 627                 // if delete mode, then back to normal mode
 628                 if (get_clipdrawer_mode())
 629                         clipdrawer_change_mode(ad);
 630         }
 631 }