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_TXT_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_TXT_ITEMS; i++)
 115         {
 116                 pos = get_current_history_position() - i;
 117                 if (pos < 0)
 118                         pos = pos+HISTORY_QUEUE_MAX_TXT_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 Evas_Object* _grid_icon_get(const void *data, Evas_Object *obj, const char *part)
 142 {
 143         int delete_mode = get_clipdrawer_mode();
 144         griditem_t *ti = (griditem_t *)data;
 145
 146         if (!strcmp(part, "elm.swallow.icon"))
 147         {
 148                 if (ti->itype == GI_TEXT)
 149                 {
 150                         Evas_Object *layout = elm_layout_add (obj);
 151                         elm_layout_theme_set(layout, "gengrid", "widestyle", "horizontal_layout");
 152                         Evas_Object *rect = evas_object_rectangle_add(evas_object_evas_get(obj));
 153                         evas_object_resize(rect, GRID_ITEM_W, GRID_ITEM_H);
 154                         evas_object_color_set(rect, 242, 233, 183, 255);
 155                         evas_object_show(rect);
 156                         elm_layout_content_set(layout, "elm.swallow.icon", rect);
 157
 158                         Evas_Object *ientry = elm_scrolled_entry_add(obj);
 159                         evas_object_size_hint_weight_set(ientry, 0, 0);
 160                         Eina_Strbuf *strent = NULL;
 161                         char *strdata = eina_strbuf_string_get(ti->istrdata);
 162                         int i, skipflag, strcnt;
 163
 164                         strent = eina_strbuf_new();
 165                         skipflag = 0;
 166                         strcnt = 0;
 167                         for (i = 0; i < eina_strbuf_length_get(ti->istrdata); i++)
 168                         {
 169                                 switch (strdata[i])
 170                                 {
 171                                         case '>':
 172                                                 skipflag = 0;
 173                                                 break;
 174                                         case '<':
 175                                                 skipflag = 1;
 176                                                 break;
 177                                         default:
 178                                                 if (!skipflag)
 179                                                         strcnt++;
 180                                                 break;
 181                                 }
 182                                 if (strcnt > 100)
 183                                         break;
 184                         }
 185                         eina_strbuf_append_n(strent, strdata, i);
 186 //                      eina_strbuf_append(strent, strdata);
 187                         eina_strbuf_replace_all(strent, " absize=240x180 ", " absize=52x39 ");
 188                         if (strcnt > 100)
 189                                 eina_strbuf_append(strent, "...");
 190
 191                         elm_scrolled_entry_entry_set(ientry, eina_strbuf_string_get(strent));
 192                         elm_scrolled_entry_editable_set(ientry, EINA_FALSE);
 193                         elm_scrolled_entry_context_menu_disabled_set(ientry, EINA_TRUE);
 194                         evas_object_show(ientry);
 195                         elm_layout_content_set(layout, "elm.swallow.inner", ientry);
 196
 197                         eina_strbuf_free(strent);
 198
 199                         return layout;
 200                 }
 201                 else// if (ti->itype == GI_IMAGE)
 202                 {
 203                         Evas_Object *layout = elm_layout_add (obj);
 204                         elm_layout_theme_set(layout, "gengrid", "widestyle", "horizontal_layout");
 205                         Evas_Object *sicon;
 206                         sicon = evas_object_image_add(evas_object_evas_get(obj));
 207                         evas_object_image_load_size_set(sicon, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 208                         evas_object_image_file_set(sicon, ti->ipathdata, NULL);
 209                         evas_object_image_fill_set(sicon, 0, 0, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 210                         evas_object_resize(sicon, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 211                         elm_layout_content_set(layout, "elm.swallow.icon", sicon);
 212
 213                         return layout;
 214
 215 /*
 216                         Evas_Object *icon = elm_icon_add(obj);
 217                         elm_icon_file_set(icon, ti->ipathdata, NULL);
 218                         evas_object_size_hint_aspect_set(icon, EVAS_ASPECT_CONTROL_VERTICAL, 1, 1);
 219                         evas_object_show(icon);
 220 */
 221
 222 /*
 223                         Ecore_Evas *my_ee;
 224                         Evas *my_e;
 225                         Evas_Object *fgimg;
 226                         Evas_Object *bgrect;
 227                         Evas_Object *delbtn;
 228                         Evas_Object *icon;
 229                         my_ee = ecore_evas_buffer_new(GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 230                         my_e = ecore_evas_get(my_ee);
 231
 232                         bgrect = evas_object_rectangle_add(my_e);
 233                         evas_object_color_set(bgrect, 255, 255, 255, 255);
 234                         evas_object_resize(bgrect, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 235                         evas_object_move(bgrect, 0, 0);
 236                         evas_object_show(bgrect);
 237
 238 #define BORDER_SIZE 1
 239                         fgimg = evas_object_image_add(my_e);
 240                         evas_object_image_load_size_set(fgimg, GRID_ITEM_SINGLE_W-BORDER_SIZE*2, GRID_ITEM_SINGLE_H-BORDER_SIZE*2);
 241                         evas_object_image_file_set(fgimg, ti->ipathdata, NULL);
 242                         evas_object_image_fill_set(fgimg, 0, 0, GRID_ITEM_SINGLE_W-BORDER_SIZE*2, GRID_ITEM_SINGLE_H-BORDER_SIZE*2);
 243                         evas_object_image_filled_set(fgimg, 1);
 244                         int x,y;
 245                         evas_object_image_size_get(fgimg, &x, &y);
 246                         //fprintf(stderr, "## img x = %d, y = %d\n", x, y);
 247                         evas_object_resize(fgimg, GRID_ITEM_SINGLE_W-BORDER_SIZE*2, GRID_ITEM_SINGLE_H-BORDER_SIZE*2);
 248                         evas_object_move(fgimg, BORDER_SIZE, BORDER_SIZE);
 249                         evas_object_show(fgimg);
 250
 251                         icon = evas_object_image_add(evas_object_evas_get(obj));
 252
 253                         evas_object_image_data_set(icon, NULL);
 254                         evas_object_image_size_set(icon, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 255                         evas_object_image_fill_set(icon, 0, 0, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 256                         evas_object_image_filled_set(icon, EINA_TRUE);
 257                         evas_object_image_data_copy_set(icon, (int *)ecore_evas_buffer_pixels_get(my_ee));
 258                         evas_object_image_data_update_add(icon, 0, 0, GRID_ITEM_SINGLE_W, GRID_ITEM_SINGLE_H);
 259
 260                         evas_object_del(bgrect);
 261                         evas_object_del(fgimg);
 262                         ecore_evas_free(my_ee);
 263
 264                         return icon;
 265 */
 266                 }
 267
 268 //              return icon;
 269         }
 270 /*
 271         else if (!strcmp(part, "elm.swallow.end") && delete_mode)
 272         {
 273                 ti->delbtn = elm_check_add(obj);
 274                 elm_object_style_set(ti->delbtn, "extended/imagegrid");
 275                 elm_check_state_set(ti->delbtn, EINA_TRUE);
 276                 evas_object_show(ti->delbtn);
 277                 return ti->delbtn;
 278         }
 279 */
 280
 281         return NULL;
 282 }
 283
 284 static void _grid_longpress(void *data, Evas_Object *obj, void *event_info)
 285 {
 286         struct appdata *ad = data;
 287         clipdrawer_change_mode(ad);
 288 }
 289
 290 static void _grid_click_paste(void *data, Evas_Object *obj, void *event_info)
 291 {
 292         struct appdata *ad = data;
 293         char *file, *p;
 294         int len;
 295         Elm_Gengrid_Item *sgobj = NULL;
 296         sgobj = elm_gengrid_selected_item_get(ad->hig);
 297         griditem_t *ti = NULL;
 298         ti = elm_gengrid_item_data_get(sgobj);
 299
 300         if (!sgobj || !ti)
 301         {
 302                 DTRACE("ERR: cbhm can't get the selected image\n");
 303                 return;
 304         }
 305         if (ti->itype == GI_TEXT)
 306         {
 307                 char *p = strdup(eina_strbuf_string_get(ti->istrdata));
 308
 309                 elm_selection_set(1, obj, /*ELM_SEL_FORMAT_TEXT*/1, p);
 310
 311                 elm_gengrid_item_selected_set(sgobj, EINA_FALSE);
 312         }
 313         else //if (ti->itype == GI_IMAGE)
 314         {
 315                 len = strlen(ti->ipathdata);
 316                 p = malloc(len + 10);
 317                 snprintf(p,len+10, "file:///%s", ti->ipathdata);
 318
 319                 elm_selection_set(/*secondary*/1,obj,/*ELM_SEL_FORMAT_IMAGE*/4,p);
 320
 321                 elm_gengrid_item_selected_set(sgobj, EINA_FALSE);
 322         }
 323 }
 324
 325 static void _grid_del_response_cb(void *data, Evas_Object *obj, void *event_info)
 326 {
 327         Elm_Gengrid_Item *it = (Elm_Gengrid_Item *)data;
 328         evas_object_del(obj);
 329
 330         if((int)event_info == ELM_POPUP_RESPONSE_OK)
 331                 elm_gengrid_item_del(it);
 332 }
 333
 334 static void _grid_click_delete(void *data, Evas_Object *obj, void *event_info)
 335 {
 336         struct appdata *ad = data;
 337         Elm_Gengrid_Item *sgobj = NULL;
 338         sgobj = elm_gengrid_selected_item_get(ad->hig);
 339         griditem_t *ti = NULL;
 340         ti = elm_gengrid_item_data_get(sgobj);
 341
 342         if (!sgobj || !ti)
 343         {
 344                 DTRACE("ERR: cbhm can't get the clicked del image\n");
 345                 return;
 346         }
 347
 348         Evas_Object *popup = elm_popup_add(ad->win_main);
 349         elm_popup_timeout_set(popup, 5);
 350         evas_object_size_hint_weight_set(popup, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 351         elm_popup_desc_set(popup, "Are you sure delete this?");
 352         elm_popup_buttons_add(popup, 2,
 353                                                   "Yes", ELM_POPUP_RESPONSE_OK,
 354                                                   "No", ELM_POPUP_RESPONSE_CANCEL,
 355                                                   NULL);
 356         evas_object_smart_callback_add(popup, "response", _grid_del_response_cb, sgobj);
 357         evas_object_show(popup);
 358 }
 359
 360 void _grid_del(const void *data, Evas_Object *obj)
 361 {
 362         griditem_t *ti = (griditem_t *)data;
 363         if (ti->itype == GI_IMAGE)
 364                 eina_stringshare_del(ti->ipathdata);
 365         else
 366                 eina_strbuf_free(ti->istrdata);
 367         free(ti);
 368 }
 369
 370 int clipdrawer_refresh_history_item(void *data, int delete_mode)
 371 {
 372         struct appdata *ad = data;
 373         Eina_List *oldlist = NULL;
 374         const Eina_List *l;
 375         Elm_Gengrid_Item *lgrid;
 376         griditem_t *lgitem;
 377         Evas_Object *ngg;
 378         Evas_Object *oldgg;
 379
 380         oldlist = elm_gengrid_items_get(ad->hig);
 381         elm_layout_content_unset(ad->ly_main, "imagehistory/list");
 382         ngg = elm_gengrid_add(ad->win_main);
 383         elm_layout_content_set(ad->ly_main, "imagehistory/list", ngg);
 384         oldgg = ad->hig;
 385         ad->hig = ngg;
 386         elm_gengrid_item_size_set(ad->hig, GRID_ITEM_W, GRID_ITEM_H);
 387         elm_gengrid_align_set(ad->hig, 0.5, 0.5);
 388 //      elm_gengrid_horizontal_set(ad->hig, EINA_TRUE);
 389         elm_gengrid_bounce_set(ad->hig, EINA_TRUE, EINA_FALSE);
 390         elm_gengrid_multi_select_set(ad->hig, EINA_FALSE);
 391         if (delete_mode)
 392                 evas_object_smart_callback_add(ad->hig, "selected", _grid_click_delete, ad);
 393         else
 394                 evas_object_smart_callback_add(ad->hig, "selected", _grid_click_paste, ad);
 395         evas_object_smart_callback_add(ad->hig, "longpressed", _grid_longpress, ad);
 396         evas_object_size_hint_weight_set(ad->hig, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 397
 398         gic.item_style = "default_grid";
 399         gic.func.label_get = NULL;
 400         gic.func.icon_get = _grid_icon_get;
 401         gic.func.state_get = NULL;
 402         gic.func.del = _grid_del;
 403
 404         EINA_LIST_REVERSE_FOREACH(oldlist, l, lgrid)
 405         {
 406                 lgitem = elm_gengrid_item_data_get(lgrid);
 407                 clipdrawer_add_item(lgitem->ipathdata, GI_IMAGE);
 408         }
 409
 410         evas_object_show (ad->hig);
 411
 412         elm_gengrid_clear(oldgg);
 413         evas_object_hide(oldgg);
 414         evas_object_del(oldgg);
 415
 416         return 0;
 417 }
 418
 419 int clipdrawer_change_mode(void *data)
 420 {
 421         struct appdata *ad = data;
 422
 423         toggle_clipdrawer_mode();
 424
 425         DTRACE("clipdrawer delete mode = %d\n", get_clipdrawer_mode());
 426
 427         clipdrawer_refresh_history_item(ad, get_clipdrawer_mode());
 428
 429         return 0;
 430 }
 431
 432 // FIXME: how to remove calling g_get_main_appdata()?
 433 //        it's mainly used at 'clipdrawer_image_item'
 434 int clipdrawer_add_item(char *idata, int type)
 435 {
 436         struct appdata *ad = g_get_main_appdata();
 437         griditem_t *newgi = NULL;
 438         char* filepath = NULL;
 439         Eina_List *igl = NULL;
 440         unsigned int igl_counter = 0;
 441
 442         // if delete mode, then back to normal mode
 443 //      if (get_clipdrawer_mode())
 444 //              clipdrawer_change_mode(ad);
 445
 446 /*
 447         if (!check_regular_file(imagepath))
 448         {
 449                 DTRACE("Error : it isn't normal file = %s\n", imagepath);
 450                 return -1;
 451         }
 452
 453         igl = elm_gengrid_items_get(ad->hig);
 454         igl_counter = eina_list_count(igl);
 455
 456         Eina_List *l;
 457         Elm_Gengrid_Item *item;
 458         griditem_t *ti = NULL;
 459
 460         EINA_LIST_FOREACH(igl, l, item)
 461         {
 462                 ti = elm_gengrid_item_data_get(item);
 463                 if (!strcmp(ti->path, imagepath))
 464                 {
 465                         DTRACE("Error : duplicated file path = %s\n", imagepath);
 466                         return -1;
 467                 }
 468         }
 469
 470         if (igl_counter >= HISTORY_QUEUE_MAX_IMG_ITEMS)
 471         {
 472                 elm_gengrid_item_del(eina_list_data_get(eina_list_last(igl)));
 473         }
 474
 475         newgi = malloc(sizeof(griditem_t));
 476         newgi->itype = GI_IMAGE;
 477         newgi->idata = eina_stringshare_add(imagepath);
 478         newgi->item = elm_gengrid_item_prepend(ad->hig, &gic, newgi, NULL, NULL);
 479 */
 480
 481 /*
 482         static int testmode = 0;
 483         testmode++;
 484
 485         newgi = malloc(sizeof(griditem_t));
 486         if (testmode % 3)
 487         {
 488         newgi->itype = GI_IMAGE;
 489         newgi->idata = eina_stringshare_add(imagepath);
 490         }
 491         else
 492         {
 493         newgi->itype = GI_TEXT;
 494         newgi->idata = eina_strbuf_new();
 495         eina_strbuf_append(newgi->idata, "hello!! <item absize=40x30 href=file:///usr/share/icon/cbhm/cbhm_default_img.png></item>");
 496
 497         }
 498         newgi->item = elm_gengrid_item_append(ad->hig, &gic, newgi, NULL, NULL);
 499 */
 500
 501         newgi = malloc(sizeof(griditem_t));
 502         newgi->itype = type;
 503
 504         fprintf(stderr, "## add - %d : %s\n", newgi->itype, idata);
 505         if (type == GI_TEXT)
 506         {
 507                 newgi->istrdata = eina_strbuf_new();
 508                 eina_strbuf_append(newgi->istrdata, idata);
 509         }
 510         else //if (type == GI_IMAGE)
 511         {
 512                 newgi->ipathdata = eina_stringshare_add(idata);
 513         }
 514         newgi->item = elm_gengrid_item_prepend(ad->hig, &gic, newgi, NULL, NULL);
 515
 516         return TRUE;
 517 }
 518
 519 static void
 520 clipdrawer_ly_clicked(void *data, Evas_Object *obj, const char *emission, const char *source)
 521 {
 522         struct appdata *ad = data;
 523
 524         #define EDJE_CLOSE_PART_PREFIX "background/close"
 525         if (!strncmp(source, EDJE_CLOSE_PART_PREFIX, strlen(EDJE_CLOSE_PART_PREFIX)))
 526         {
 527                 clipdrawer_lower_view(ad);
 528         }
 529 }
 530
 531 int clipdrawer_init(void *data)
 532 {
 533         struct appdata *ad = data;
 534         double cdy, cdw;
 535
 536         // for elm_check
 537         elm_theme_extension_add(NULL, APP_EDJ_FILE);
 538
 539         cdy = (1.0*CLIPDRAWER_HEIGHT/SCREEN_HEIGHT)*ad->root_h;
 540         cdw = (1.0*CLIPDRAWER_POS_Y/SCREEN_HEIGHT)*ad->root_h;
 541
 542         evas_object_resize(ad->win_main, ad->root_w, (int)cdy);
 543         evas_object_move(ad->win_main, CLIPDRAWER_POS_X, (int)cdw);
 544         evas_object_resize(ad->ly_main, ad->root_w, (int)cdy);
 545         evas_object_move(ad->ly_main, CLIPDRAWER_POS_X, (int)cdw);
 546
 547         edje_object_signal_callback_add(elm_layout_edje_get(ad->ly_main), "mouse,up,1", "*", clipdrawer_ly_clicked, ad);
 548
 549         ad->hig = NULL;
 550         ad->hig = elm_gengrid_add(ad->win_main);
 551         elm_layout_content_set(ad->ly_main, "historyitems", ad->hig);
 552         elm_gengrid_item_size_set(ad->hig, GRID_ITEM_W+2, GRID_ITEM_H);
 553         elm_gengrid_align_set(ad->hig, 0.5, 0.5);
 554         elm_gengrid_horizontal_set(ad->hig, EINA_TRUE);
 555         elm_gengrid_bounce_set(ad->hig, EINA_TRUE, EINA_FALSE);
 556         elm_gengrid_multi_select_set(ad->hig, EINA_FALSE);
 557         evas_object_smart_callback_add(ad->hig, "selected", _grid_click_paste, ad);
 558 //      evas_object_smart_callback_add(ad->hig, "longpressed", _grid_longpress, ad);
 559         evas_object_size_hint_weight_set(ad->hig, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 560
 561         elm_gengrid_clear(ad->hig);
 562
 563         gic.item_style = "default_grid";
 564         gic.func.label_get = NULL;
 565         gic.func.icon_get = _grid_icon_get;
 566         gic.func.state_get = NULL;
 567         gic.func.del = _grid_del;
 568
 569         int i;
 570         griditem_t *newgi;
 571
 572         for (i = 0; i < N_IMAGES; i++)
 573         {
 574                 clipdrawer_add_item(g_images_path[0], GI_IMAGE);
 575         }
 576
 577         clipdrawer_add_item("clipboard history", GI_TEXT);
 578
 579         evas_object_show (ad->hig);
 580
 581 // for debugging, calc history pos
 582 /*
 583    Evas_Coord x, y, w, h;
 584    Evas_Coord vx, vy, vw, vh;
 585
 586    edje_object_part_geometry_get(elm_layout_edje_get(ad->ly_main),"imagehistory/list",&x,&y,&w,&h);
 587    evas_object_geometry_get (ad->hig, &vx,&vy,&vw,&vh);
 588    fprintf(stderr, "## x = %d, y = %d, w = %d, h = %d\n", x, y, w, h);
 589    fprintf(stderr, "## vx = %d, vy = %d, vw = %d, vh = %d\n", vx, vy, vw, vh);
 590 */
 591
 592 //      if (get_item_counts() != 0)
 593 //              clipdrawer_update_contents(ad);
 594
 595         return 0;
 596 }
 597
 598 int clipdrawer_create_view(void *data)
 599 {
 600         struct appdata *ad = data;
 601
 602         clipdrawer_init(ad);
 603
 604         // for debug
 605         // at starting, showing app view
 606         // clipdrawer_activate_view(ad);
 607
 608         return 0;
 609 }
 610
 611 void clipdrawer_activate_view(void *data)
 612 {
 613         struct appdata *ad = data;
 614
 615         if (ad->win_main)
 616         {
 617                 evas_object_show(ad->win_main);
 618                 elm_win_activate(ad->win_main);
 619         }
 620 }
 621
 622 void clipdrawer_lower_view(void *data)
 623 {
 624         struct appdata *ad = data;
 625
 626         if (ad->win_main)
 627         {
 628                 evas_object_hide(ad->win_main);
 629                 elm_win_lower(ad->win_main);
 630
 631                 // if delete mode, then back to normal mode
 632                 if (get_clipdrawer_mode())
 633                         clipdrawer_change_mode(ad);
 634         }
 635 }