src/page_scroller.c

   1 /*
   2  * MENU-SCREEN
   3  *
   4  * Copyright (c) 2009-2015 Samsung Electronics Co., Ltd All Rights Reserved
   5  *
   6  * Contact: Jin Yoon <jinny.yoon@samsung.com>
   7  *          Junkyu Han <junkyu.han@samsung.com>
   8
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <Elementary.h>
  24 #include <stdio.h>
  25 #include <vconf.h>
  26
  27 #include "item_badge.h"
  28 #include "conf.h"
  29 #include "index.h"
  30 #include "item.h"
  31 #include "item_event.h"
  32 #include "layout.h"
  33 #include "list.h"
  34 #include "mapbuf.h"
  35 #include "menu_screen.h"
  36 #include "page.h"
  37 #include "page_scroller.h"
  38 #include "pkgmgr.h"
  39 #include "util.h"
  40
  41 #define BUFSZE 1024
  42 #define PAGE_SCROLL_SENSITIVE 0.2
  43 #define PROP_PORTRAIT_HEIGHT (PAGE_PORTRAIT_HEIGHT / BASE_HEIGHT)
  44
  45
  46
  47 HAPI void page_scroller_bring_in(Evas_Object *scroller, int idx)
  48 {
  49         Evas_Object *index;
  50         int w, h;
  51
  52         _D("BRING IN TO %d", idx);
  53
  54         evas_object_data_set(scroller, "current_idx", (void *) idx);
  55
  56         evas_object_geometry_get(scroller, NULL, NULL, &w, &h);
  57         elm_scroller_region_bring_in(scroller, idx * w, 0, w, h);
  58
  59         index = evas_object_data_get(scroller, "index");
  60         if (!index) {
  61                 _E("cannot find index.");
  62         }
  63         _D("page index bring in to %d", idx);
  64         index_bring_in(index, idx);
  65 }
  66
  67
  68
  69 HAPI void page_scroller_show_region(Evas_Object *scroller, int idx)
  70 {
  71         Evas_Object *index;
  72         int w, h;
  73
  74         evas_object_geometry_get(scroller, NULL, NULL, &w, &h);
  75         elm_scroller_region_show(scroller, idx * w, 0, w, h);
  76
  77         index = evas_object_data_get(scroller, "index");
  78         if (!index) {
  79                 _E("cannot find index.");
  80         }
  81         _D("page index bring in to %d", idx);
  82         index_bring_in(index, idx);
  83 }
  84
  85
  86
  87 static void _anim_stop_cb(void *data, Evas_Object *scroller, void *event_info)
  88 {
  89         _D("stop the scroller(%p) animation", scroller);
  90
  91         /* page_scroller_focus & index_bring_in in _drag_stop_cb & _anim_stop_cb */
  92         Evas_Coord x, y, w, h;
  93         elm_scroller_region_get(scroller, &x, &y, &w, &h);
  94
  95         if (x % w) return;
  96
  97         if(evas_object_data_get(scroller, "mouse_wheel_scroller_start")) {
  98                 // "page_scroller_bring_in" was invoked in "_mouse_wheel_cb",
  99                 // so condition cur_idx == idx will be true and "page_scroller_focus" won't be executed
 100                 // so "page_scroller_focus" is executed here.
 101                 evas_object_data_set(scroller, "mouse_wheel_scroller_start", (void *) 0);
 102                 page_scroller_focus(scroller);
 103         }
 104
 105         int cur_idx = page_scroller_get_current_page_no(scroller);
 106         int idx = 0;
 107         if (w) idx = x / w;
 108         if (cur_idx == idx) return;
 109
 110         page_scroller_bring_in(scroller, idx);
 111         page_scroller_focus(scroller);
 112 }
 113
 114
 115
 116 static void _anim_start_cb(void *data, Evas_Object *scroller, void *event_info)
 117 {
 118         _D("start the scroller(%p) animation", scroller);
 119
 120         int drag_start = (int) evas_object_data_get(scroller, "drag_start");
 121         if (drag_start == 0) return;
 122         evas_object_data_set(scroller, "drag_start", (void *) 0);
 123 }
 124
 125
 126
 127
 128
 129
 130 static void _drag_start_cb(void *data, Evas_Object *scroller, void *event_info)
 131 {
 132         int previous_x;
 133
 134         _D("Invoked");
 135
 136         elm_scroller_region_get(scroller, &previous_x, NULL, NULL, NULL);
 137         evas_object_data_set(scroller, "previous_x", (void *) previous_x);
 138         evas_object_data_set(scroller, "drag_start", (void *) 1);
 139 }
 140
 141
 142
 143 static void _drag_stop_cb(void *data, Evas_Object *scroller, void *event_info)
 144 {
 145         Evas_Coord x, y, w, h;
 146         int previous_x;
 147
 148         _D("Invoked");
 149
 150         elm_scroller_region_get(scroller, &x, &y, &w, &h);
 151         previous_x = (int) evas_object_data_get(scroller, "previous_x");
 152         if (x == previous_x) {
 153                 _D("\e[33mHold scroller (previous) %d (current) %d\e[0m", previous_x, x);
 154         }
 155
 156         /* page_scroller_focus & index_bring_in in _drag_stop_cb & _anim_stop_cb */
 157         if (x % w) return;
 158
 159         int cur_idx = page_scroller_get_current_page_no(scroller);
 160         int idx = 0;
 161         if (w) idx = x / w;
 162
 163         if (cur_idx == idx) return;
 164
 165         page_scroller_bring_in(scroller, idx);
 166         page_scroller_focus(scroller);
 167 }
 168
 169
 170 static void _scroll_cb(void *data, Evas_Object *scroller, void *event_info)
 171 {
 172         _drag_stop_cb(data, scroller, event_info);
 173 }
 174
 175
 176
 177 static menu_screen_error_e _find_position_all_page(Evas_Object *scroller, int *candidate_page, int *candidate_pos, void *data)
 178 {
 179         Evas_Object *page;
 180         Evas_Object *item;
 181         register unsigned int page_no;
 182         register unsigned int position_no;
 183         int nr_of_pages;
 184         int page_max_app;
 185
 186         retv_if(NULL == scroller, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 187         retv_if(NULL == candidate_page, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 188         retv_if(NULL == candidate_pos, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 189
 190         *candidate_page = -1;
 191         *candidate_pos = -1;
 192         nr_of_pages = page_scroller_count_page(scroller);
 193         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 194
 195         page = page_scroller_get_page_at(scroller, nr_of_pages-1);
 196         page_no = nr_of_pages-1;
 197         for (position_no = 0; position_no < page_max_app; position_no ++) {
 198                 item = page_get_item_at(page, position_no);
 199                 if (!item) {
 200                         *candidate_page = page_no;
 201                         *candidate_pos = position_no;
 202                         return MENU_SCREEN_ERROR_OK;
 203                 }
 204         }
 205
 206         for (page_no = 0; page_no < nr_of_pages -1; page_no ++) {
 207                 page = page_scroller_get_page_at(scroller, page_no);
 208                 if(!page) {
 209                         return MENU_SCREEN_ERROR_FAIL;
 210                 }
 211
 212                 for (position_no = 0; position_no < page_max_app; position_no ++) {
 213                         item = page_get_item_at(page, position_no);
 214                         if (!item) {
 215                                 *candidate_page = page_no;
 216                                 *candidate_pos = position_no;
 217                                 return MENU_SCREEN_ERROR_OK;
 218                         }
 219                 }
 220         }
 221
 222         return MENU_SCREEN_ERROR_OK;
 223 }
 224
 225
 226
 227 static menu_screen_error_e _find_position_by_default(Evas_Object *scroller, int *candidate_page, int *candidate_pos, void *data)
 228 {
 229         Evas_Object *page;
 230         Evas_Object *item;
 231         register unsigned int page_no;
 232         register unsigned int position_no;
 233         unsigned int nr_of_pages;
 234         int page_max_app;
 235
 236         retv_if(NULL == scroller, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 237         retv_if(NULL == candidate_page, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 238         retv_if(NULL == candidate_pos, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 239
 240         *candidate_page = 0;
 241         *candidate_pos = 0;
 242         nr_of_pages = page_scroller_count_page(scroller);
 243         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 244         for (page_no = 0; page_no < nr_of_pages; page_no ++) {
 245                 page = page_scroller_get_page_at(scroller, page_no);
 246                 if (!page) {
 247                         _D("Page is not found at %d", page_no);
 248                         return MENU_SCREEN_ERROR_FAIL;
 249                 }
 250
 251                 for (position_no = 0; position_no < page_max_app; position_no ++) {
 252                         item = page_get_item_at(page, position_no);
 253                         if (!item) {
 254                                 *candidate_page = page_no;
 255                                 *candidate_pos = position_no;
 256                                 return MENU_SCREEN_ERROR_OK;
 257                         }
 258                 }
 259         }
 260
 261         *candidate_page = page_no;
 262         *candidate_pos = 0;
 263
 264         return MENU_SCREEN_ERROR_OK;
 265 }
 266
 267
 268
 269 static menu_screen_error_e _find_position_by_package(Evas_Object *scroller, int *candidate_page, int *candidate_pos, void *data)
 270 {
 271         Evas_Object *page;
 272         Evas_Object *item;
 273         register int page_no;
 274         register int position_no;
 275         unsigned int nr_of_pages;
 276         int page_max_app;
 277         app_info_t *ai = data;
 278
 279         retv_if(NULL == scroller, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 280         retv_if(NULL == candidate_page, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 281         retv_if(NULL == candidate_pos, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 282         retv_if(NULL == data, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 283         retv_if(NULL == ai->package, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 284
 285         *candidate_page = 0;
 286         *candidate_pos = 0;
 287         nr_of_pages = page_scroller_count_page(scroller);
 288         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 289         for (page_no = 0; page_no < nr_of_pages; page_no ++) {
 290                 page = page_scroller_get_page_at(scroller, page_no);
 291                 if (!page) {
 292                         _D("Page is not found at %d", page_no);
 293                         return MENU_SCREEN_ERROR_FAIL;
 294                 }
 295
 296                 for (position_no = 0; position_no < page_max_app; position_no ++) {
 297                         char *package;
 298
 299                         item = page_get_item_at(page, position_no);
 300                         if (!item) {
 301                                 *candidate_page = page_no;
 302                                 *candidate_pos = position_no;
 303                                 return MENU_SCREEN_ERROR_OK;
 304                         } else if ((package = item_get_package(item)) && strcmp(package, ai->package) > 0) {
 305                                 *candidate_page = page_no;
 306                                 *candidate_pos = position_no;
 307                                 return MENU_SCREEN_ERROR_OK;
 308                         }
 309                 }
 310         }
 311
 312         return MENU_SCREEN_ERROR_OK;
 313 }
 314
 315
 316
 317 static menu_screen_error_e _find_position_by_name(Evas_Object *scroller, int *candidate_page, int *candidate_pos, void *data)
 318 {
 319         Evas_Object *page;
 320         Evas_Object *item;
 321         register int page_no;
 322         register int position_no;
 323         unsigned int nr_of_pages;
 324         int page_max_app;
 325         app_info_t *ai = data;
 326
 327         retv_if(NULL == scroller, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 328         retv_if(NULL == candidate_page, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 329         retv_if(NULL == candidate_pos, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 330         retv_if(NULL == data, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 331         retv_if(NULL == ai->name, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 332
 333         *candidate_page = 0;
 334         *candidate_pos = 0;
 335         nr_of_pages = page_scroller_count_page(scroller);
 336         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 337         for (page_no = 0; page_no < nr_of_pages; page_no ++) {
 338                 page = page_scroller_get_page_at(scroller, page_no);
 339                 if (!page) {
 340                         _D("Page is not found at %d", page_no);
 341                         return MENU_SCREEN_ERROR_FAIL;
 342                 }
 343
 344                 for (position_no = 0; position_no < page_max_app; position_no ++) {
 345                         char *name;
 346
 347                         item = page_get_item_at(page, position_no);
 348                         if (!item) {
 349                                 *candidate_page = page_no;
 350                                 *candidate_pos = position_no;
 351                                 return MENU_SCREEN_ERROR_OK;
 352                         } else if ((name = item_get_name(item)) && strcmp(name, ai->name) > 0) {
 353                                 *candidate_page = page_no;
 354                                 *candidate_pos = position_no;
 355                                 return MENU_SCREEN_ERROR_OK;
 356                         }
 357                 }
 358         }
 359
 360         return MENU_SCREEN_ERROR_OK;
 361 }
 362
 363
 364
 365 static menu_screen_error_e _animated_pack_item(Evas_Object *item, Evas_Object *scroller, Evas_Object *page, int from)
 366 {
 367         Evas_Object *item_out_page = NULL;
 368         char buf[32];
 369         int to;
 370         int page_no;
 371
 372         retv_if(NULL == item, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 373         retv_if(NULL == scroller, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 374         retv_if(NULL == page, MENU_SCREEN_ERROR_INVALID_PARAMETER);
 375
 376         page_no = page_scroller_get_page_no(scroller, page);
 377         do {
 378                 to = page_find_empty_near(page, from);
 379                 if (to < 0) {
 380                         int page_max_app;
 381                         page_max_app = (int) evas_object_data_get(page, "page_max_app");
 382                         to = page_max_app - 1;
 383                         item_out_page = page_unpack_item_at(page, to);
 384                 }
 385
 386                 for (to --; to >= from; to --) {
 387                         Evas_Object *item_in_page;
 388                         item_in_page = page_unpack_item_at(page, to);
 389                         page_pack_item(page, to + 1, item_in_page);
 390                         snprintf(buf, 32, "menu%d", to + 1);
 391                         edje_object_signal_emit(_EDJ(page), STR_MOVE_PREV, buf);
 392                         edje_object_signal_emit(_EDJ(page), STR_ANI_RETURN, buf);
 393                 }
 394
 395                 page_pack_item(page, from, item);
 396
 397                 if (!item_out_page) break;
 398
 399                 page_no ++;
 400                 page = page_scroller_get_page_at(scroller, page_no);
 401                 if (!page) {
 402                         int rotate;
 403                         rotate = (int) evas_object_data_get(scroller, "rotate");
 404                         page = page_create(scroller, page_no, rotate);
 405                         retv_if(NULL == page, MENU_SCREEN_ERROR_FAIL);
 406                         mapbuf_enable(page, 0);
 407                 }
 408
 409                 from = 0;
 410                 item = item_out_page;
 411                 item_out_page = NULL;
 412         } while (page && item);
 413
 414         return MENU_SCREEN_ERROR_OK;
 415 }
 416
 417
 418
 419 HAPI Evas_Object *page_scroller_push_item(Evas_Object *scroller, app_info_t *ai)
 420 {
 421         Evas_Object *page;
 422         Evas_Object *item;
 423         unsigned int nr_of_pages;
 424         int candidate_page = -1;
 425         int candidate_pos = 0;
 426         int sort_type;
 427         register int i;
 428
 429         struct {
 430                 page_scroller_sort_type_e sort_type;
 431                 menu_screen_error_e (*sort_func)(Evas_Object *scroller, int *candidate_page, int *candidate_pos, void *data);
 432         } sort_type_map[] = {
 433                 {
 434                         .sort_type = PAGE_SCROLLER_SORT_BY_DEFAULT,
 435                         .sort_func = _find_position_by_default,
 436                 },
 437                 {
 438                         .sort_type = PAGE_SCROLLER_SORT_BY_PACKAGE,
 439                         .sort_func = _find_position_by_package,
 440                 },
 441                 {
 442                         .sort_type = PAGE_SCROLLER_SORT_BY_NAME,
 443                         .sort_func = _find_position_by_name,
 444                 },
 445                 {
 446                         .sort_type = PAGE_SCROLLER_SORT_MAX,
 447                         .sort_func = NULL,
 448                 },
 449         };
 450
 451         sort_type = (int) evas_object_data_get(scroller, "sort_type");
 452         sort_type_map[sort_type].sort_func(scroller, &candidate_page, &candidate_pos, ai);
 453
 454         nr_of_pages = page_scroller_count_page(scroller);
 455
 456         for (i = nr_of_pages; i <= candidate_page; i ++) {
 457                 Evas_Object *new_page;
 458                 int rotate;
 459
 460                 rotate = (int) evas_object_data_get(scroller, "rotate");
 461                 new_page = page_create(scroller, nr_of_pages, rotate);
 462                 retv_if(NULL == new_page, NULL);
 463                 mapbuf_enable(new_page, 0);
 464         }
 465
 466         item = item_create(scroller, ai);
 467         retv_if(NULL == item, NULL);
 468
 469         page = page_scroller_get_page_at(scroller, candidate_page);
 470         if (!page) {
 471                 _D("Impossible, page is not found");
 472                 item_destroy(item);
 473                 return NULL;
 474         }
 475
 476         retv_if(MENU_SCREEN_ERROR_OK !=
 477                         _animated_pack_item(item, scroller, page, candidate_pos),
 478                         NULL);
 479
 480         return item;
 481 }
 482
 483
 484
 485 HAPI Evas_Object *page_scroller_push_item_by_order(Evas_Object *scroller, app_info_t *ai)
 486 {
 487         int candidate_page = -1;
 488         int candidate_pos = -1;
 489         Evas_Object *item = NULL;
 490
 491         if (MAX_PAGE_NO == page_scroller_count_page(scroller)) {
 492                 _find_position_all_page(scroller, &candidate_page, &candidate_pos, &ai);
 493                 if (-1 != candidate_page || -1 != candidate_pos) {
 494                         item = page_scroller_push_item(scroller, ai);
 495                 }
 496         }
 497         else item = page_scroller_push_item(scroller, ai);
 498
 499         return item;
 500 }
 501
 502
 503
 504 static void _mouse_wheel_cb(void *data, Evas *e, Evas_Object *obj, void *event_info)
 505 {
 506         Evas_Event_Mouse_Wheel *ei = event_info;
 507         Evas_Object *scroller = data;
 508         int x, y, w, h;
 509         int idx = -1;
 510
 511         _D("Wheel's up or down(%d)", ei->z);
 512
 513         elm_scroller_region_get(scroller, &x, &y, &w, &h);
 514         if (ei->z > 0) { // Wheel's up
 515                 idx = x / w;
 516                 idx ++;
 517         } else if (ei->z < 0) { // Wheel's down
 518                 idx = x / w; // Scroller got ECORE events at first, then Menu-screen gets EVAS events.
 519         } else { // Wheel's not moving.
 520                 _D("Wheel's not moving");
 521         }
 522
 523         if (idx >= page_scroller_count_page(scroller) || idx < 0) return;
 524         evas_object_data_set(scroller, "mouse_wheel_scroller_start", (void *) 1);
 525         page_scroller_bring_in(scroller, idx);
 526 }
 527
 528
 529
 530 static inline char *_ltrim(char *str)
 531 {
 532         retv_if(NULL == str, NULL);
 533         while (*str && (*str == ' ' || *str == '\t' || *str == '\n')) str ++;
 534         return str;
 535 }
 536
 537
 538
 539 static inline int _rtrim(char *str)
 540 {
 541         int len;
 542
 543         retv_if(NULL == str, 0);
 544
 545         len = strlen(str);
 546         while (--len >= 0 && (str[len] == ' ' || str[len] == '\n' || str[len] == '\t')) {
 547                 str[len] = '\0';
 548         }
 549
 550         return len;
 551 }
 552
 553
 554
 555 HAPI Evas_Object *page_scroller_create(Evas_Object *tab, Evas_Object *index, page_scroller_sort_type_e sort_type, int rotate)
 556 {
 557         Evas_Object *box;
 558         Evas_Object *scroller;
 559         int width;
 560         int height;
 561
 562         scroller = elm_scroller_add(tab);
 563         retv_if(NULL == scroller, NULL);
 564
 565         elm_scroller_content_min_limit(scroller, EINA_FALSE, EINA_FALSE);
 566         elm_scroller_bounce_set(scroller, EINA_TRUE, EINA_FALSE);
 567         elm_scroller_policy_set(scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
 568
 569         width = menu_screen_get_root_width();
 570         height = (int) ((double) PROP_PORTRAIT_HEIGHT * ((double) menu_screen_get_root_height()));
 571         elm_scroller_page_size_set(scroller, width, height);
 572         elm_scroller_page_scroll_limit_set(scroller, 1, 1);
 573
 574         evas_object_size_hint_weight_set(scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 575         evas_object_size_hint_align_set(scroller, EVAS_HINT_FILL, EVAS_HINT_FILL);
 576         evas_object_size_hint_min_set(scroller, width, height);
 577         evas_object_size_hint_max_set(scroller, width, height);
 578
 579         box = elm_box_add(scroller);
 580         if (!box) {
 581                 _D("Failed to create box");
 582                 evas_object_del(scroller);
 583                 return NULL;
 584         }
 585         elm_box_horizontal_set(box, 1);
 586         evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 587
 588         evas_object_data_set(scroller, "win", evas_object_data_get(tab, "win"));
 589         evas_object_data_set(scroller, "layout", evas_object_data_get(tab, "layout"));
 590         evas_object_data_set(scroller, "controlbar", evas_object_data_get(tab, "controlbar"));
 591         evas_object_data_set(scroller, "tab", tab);
 592         evas_object_data_set(scroller, "page_edje", evas_object_data_get(tab, "page_edje"));
 593         evas_object_data_set(scroller, "page_max_app", evas_object_data_get(tab, "page_max_app"));
 594         evas_object_data_set(scroller, "item_edje", evas_object_data_get(tab, "item_edje"));
 595         evas_object_data_set(scroller, "item_width", evas_object_data_get(tab, "item_width"));
 596         evas_object_data_set(scroller, "item_height", evas_object_data_get(tab, "item_height"));
 597         evas_object_data_set(scroller, "item_enable_long_press", evas_object_data_get(tab, "item_enable_long_press"));
 598         evas_object_data_set(scroller, "item_text_dual_line", evas_object_data_get(tab, "item_text_dual_line"));
 599         evas_object_data_set(scroller, "enable_bg_image", evas_object_data_get(tab, "enable_bg_image"));
 600         evas_object_data_set(scroller, "box", box);
 601         evas_object_data_set(scroller, "drag_start", (void *) 0);
 602         evas_object_data_set(scroller, "previous_x", (void *) 0);
 603         evas_object_data_set(scroller, "index", index);
 604         evas_object_data_set(scroller, "sort_type", (void *) sort_type);
 605         evas_object_data_set(scroller, "install_list", (void *) 0);
 606         evas_object_data_set(scroller, "rotate", (void *) rotate);
 607         evas_object_data_set(scroller, "is_edited", (void *) false);
 608         elm_object_content_set(scroller, box);
 609
 610         evas_object_smart_callback_add(scroller, "scroll,anim,start", _anim_start_cb, NULL);
 611         evas_object_smart_callback_add(scroller, "scroll,anim,stop", _anim_stop_cb, NULL);
 612         evas_object_smart_callback_add(scroller, "scroll,drag,start", _drag_start_cb, NULL);
 613         evas_object_smart_callback_add(scroller, "scroll,drag,stop", _drag_stop_cb, NULL);
 614         evas_object_smart_callback_add(scroller, "scroll", _scroll_cb, NULL);
 615         evas_object_event_callback_add(box, EVAS_CALLBACK_DEL, _evas_object_event_del_cb, "BOX");
 616         evas_object_event_callback_add(scroller, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, scroller);
 617
 618         evas_object_show(box);
 619         evas_object_show(scroller);
 620
 621         item_badge_register_changed_cb(scroller);
 622
 623         return scroller;
 624 }
 625
 626
 627
 628 HAPI void page_scroller_destroy(Evas_Object *scroller)
 629 {
 630         Evas_Object *box;
 631         Evas_Object *page;
 632         Evas_Object *tmp;
 633
 634         const Eina_List *page_list;
 635         const Eina_List *l;
 636         const Eina_List *ln;
 637
 638         ret_if(NULL == scroller);
 639         ret_if(NULL == (box = evas_object_data_get(scroller, "box")));
 640         ret_if(NULL == (page_list = elm_box_children_get(box)));
 641
 642         item_badge_unregister_changed_cb();
 643
 644         EINA_LIST_FOREACH_SAFE(page_list, l, ln, page) {
 645                 int count;
 646
 647                 if (!page) {
 648                         _D("page list contains nil item");
 649                         continue;
 650                 }
 651
 652                 count = eina_list_count(page_list);
 653                 _D("page_list count : %d", count);
 654                 if (count < 1) {
 655                         elm_box_unpack(box, page);
 656                 }
 657
 658                 tmp = mapbuf_get_page(page);
 659                 if (tmp) page = tmp;
 660
 661                 page_destroy(scroller, page);
 662         }
 663
 664         box = elm_object_content_unset(scroller);
 665         evas_object_del(box);
 666
 667         evas_object_data_del(scroller, "win");
 668         evas_object_data_del(scroller, "layout");
 669         evas_object_data_del(scroller, "controlbar");
 670         evas_object_data_del(scroller, "tab");
 671         evas_object_data_del(scroller, "page_edje");
 672         evas_object_data_del(scroller, "page_max_app");
 673         evas_object_data_del(scroller, "item_edje");
 674         evas_object_data_del(scroller, "item_width");
 675         evas_object_data_del(scroller, "item_height");
 676         evas_object_data_del(scroller, "item_enable_long_press");
 677         evas_object_data_del(scroller, "item_text_dual_line");
 678         evas_object_data_del(scroller, "enable_bg_image");
 679         evas_object_data_del(scroller, "box");
 680         evas_object_data_del(scroller, "drag_start");
 681         evas_object_data_del(scroller, "previous_x");
 682         evas_object_data_del(scroller, "index");
 683         evas_object_data_del(scroller, "sort_type");
 684         evas_object_data_del(scroller, "rotate");
 685         evas_object_data_del(scroller, "is_edited");
 686         evas_object_data_del(scroller, "install_list");
 687
 688         evas_object_smart_callback_del(scroller, "scroll,anim,start", _anim_start_cb);
 689         evas_object_smart_callback_del(scroller, "scroll,anim,stop", _anim_stop_cb);
 690         evas_object_smart_callback_del(scroller, "scroll,drag,start", _drag_start_cb);
 691         evas_object_smart_callback_del(scroller, "scroll,drag,stop", _drag_stop_cb);
 692         evas_object_smart_callback_del(scroller, "scroll", _scroll_cb);
 693         evas_object_event_callback_del(box, EVAS_CALLBACK_DEL, _evas_object_event_del_cb);
 694         evas_object_event_callback_del(scroller, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb);
 695
 696         evas_object_del(scroller);
 697
 698 }
 699
 700
 701
 702 HAPI void page_scroller_clean(Evas_Object *scroller)
 703 {
 704         Evas_Object *page;
 705         Evas_Object *item;
 706
 707         register unsigned int i;
 708         unsigned int page_max_app;
 709         unsigned int count;
 710
 711         count = page_scroller_count_page(scroller);
 712         if (count == 0) return;
 713
 714         for (i = 1; i < MAX_PAGE_NO; i++) {
 715                 page = page_scroller_get_page_at(scroller, i);
 716                 if (NULL == page) break;
 717
 718                 page_destroy(scroller, page);
 719         }
 720
 721         page = page_scroller_get_page_at(scroller, 0);
 722         ret_if(NULL == page);
 723
 724         page_max_app = (unsigned int) evas_object_data_get(scroller, "page_max_app");
 725         for (i = 0; i < page_max_app; i++) {
 726                 item = page_get_item_at(page, i);
 727                 if (item) {
 728                         item_destroy(item);
 729                 } else break;
 730         }
 731 }
 732
 733
 734
 735 HAPI Evas_Object *page_scroller_get_page_at(Evas_Object *scroller, unsigned int idx)
 736 {
 737         const Eina_List *page_list;
 738         Evas_Object *item;
 739         Evas_Object *box;
 740
 741         retv_if(idx > MAX_PAGE_NO, NULL);
 742
 743         box = evas_object_data_get(scroller, "box");
 744         retv_if(NULL == box, NULL);
 745
 746         page_list = elm_box_children_get(box);
 747         retv_if(NULL == page_list, NULL);
 748
 749         item = eina_list_nth(page_list, idx);
 750         if (item) {
 751                 item = mapbuf_get_page(item);
 752         }
 753
 754         return item;
 755 }
 756
 757
 758
 759 HAPI unsigned int page_scroller_count_page(Evas_Object *scroller)
 760 {
 761         const Eina_List *page_list;
 762         Evas_Object *box;
 763
 764         box = evas_object_data_get(scroller, "box");
 765         retv_if(NULL == box, 0);
 766
 767         page_list = elm_box_children_get(box);
 768         retv_if(NULL == page_list, 0);
 769
 770         return eina_list_count(page_list);
 771 }
 772
 773
 774
 775 HAPI int page_scroller_get_page_no(Evas_Object* scroller, Evas_Object *page)
 776 {
 777         Evas_Object *item;
 778         Evas_Object *box;
 779         register int idx = 0;
 780         const Eina_List *page_list;
 781         const Eina_List *pos;
 782
 783         box = evas_object_data_get(scroller, "box");
 784         retv_if(NULL == box, 0);
 785
 786         page_list = elm_box_children_get(box);
 787         EINA_LIST_FOREACH(page_list, pos, item) {
 788                 if (!item) {
 789                         _D("page list contains nil item");
 790                         continue;
 791                 }
 792
 793                 item = mapbuf_get_page(item);
 794                 if (item == page) {
 795                         return idx;
 796                 }
 797
 798                 idx ++;
 799         }
 800
 801         return -1;
 802 }
 803
 804
 805
 806 HAPI int page_scroller_get_current_page_no(Evas_Object *scroller)
 807 {
 808         return (int) evas_object_data_get(scroller, "current_idx");
 809 }
 810
 811
 812
 813 HAPI Evas_Object *page_scroller_find_item_by_package(Evas_Object *scroller, const char *package, int *page_no)
 814 {
 815         register int i;
 816         register int j;
 817         Evas_Object *page;
 818         Evas_Object *item;
 819         const char *tmp;
 820         int local_page_no;
 821         int page_max_app;
 822
 823         if (!page_no) page_no = &local_page_no;
 824
 825         retv_if(NULL == package, NULL);
 826
 827         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 828         for (i = 0; i < page_scroller_count_page(scroller); i ++) {
 829                 page = page_scroller_get_page_at(scroller, i);
 830                 if (!page) continue;
 831
 832                 for (j = 0; j < page_max_app; j ++) {
 833                         item = page_get_item_at(page, j);
 834                         if (!item) continue;
 835
 836                         tmp = item_get_package(item);
 837                         if (!tmp) {
 838                                 _D("Something goes wrong, this package has no name?");
 839                                 continue;
 840                         }
 841
 842                         if (!strcmp(tmp, package)) {
 843                                 *page_no = i;
 844                                 return item;
 845                         }
 846                 }
 847         }
 848
 849         return NULL;
 850 }
 851
 852
 853
 854 HAPI void page_scroller_trim_items(Evas_Object *scroller)
 855 {
 856         register unsigned int i;
 857         register unsigned int j;
 858         int page_max_app;
 859         int pos = 0;
 860
 861         Evas_Object *page;
 862         Evas_Object *item;
 863         Eina_List *list = NULL;
 864
 865         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 866         ret_if (page_max_app == 0);
 867
 868         for (i = 0; i < MAX_PAGE_NO; i ++) {
 869                 page = page_scroller_get_page_at(scroller, i);
 870                 if (!page) break;
 871
 872                 for (j = 0; j < page_max_app; j++) {
 873                         item = page_unpack_item_at(page, j);
 874                         if (item) {
 875                                 list = eina_list_append(list, item);
 876                                 _D("LIST APPEND : %s", item_get_package(item));
 877                         }
 878                 }
 879
 880         }
 881
 882         for (i = 0; i < eina_list_count(list); i++) {
 883                 if (i % page_max_app == 0) {
 884                         page = page_scroller_get_page_at(scroller, i / page_max_app);
 885                         _D("PAGE GET : 0x%x", page);
 886                         if (NULL == page) {
 887                                 _E("Cannot get page");
 888                                 break;
 889                         }
 890                 }
 891
 892                 item = eina_list_nth(list, i);
 893                 if (NULL == item) {
 894                         _E("Cannot get item");
 895                         break;
 896                 }
 897                 _D("LIST GET : [%d] %s", pos, item_get_package(item));
 898
 899                 page_pack_item(page, pos % page_max_app, item);
 900                 pos++;
 901         }
 902
 903         for (i = pos / page_max_app; i < MAX_PAGE_NO; i++) {
 904                 int count;
 905
 906                 page = page_scroller_get_page_at(scroller, i);
 907                 if (NULL == page) {
 908                         break;
 909                 }
 910                 count = page_count_item(page);
 911                 if (count == 0) {
 912                         Evas_Coord w;
 913                         Evas_Coord h;
 914
 915                         _D("PAGE IS EMPTY : 0x%x", page);
 916
 917                         page_destroy(scroller, page);
 918                         evas_object_geometry_get(scroller, NULL, NULL, &w, &h);
 919                         elm_scroller_region_show(scroller, 0, 0, w, h);
 920                 }
 921         }
 922         pos --;
 923         eina_list_free(list);
 924 }
 925
 926
 927
 928 HAPI void page_scroller_edit(Evas_Object *scroller)
 929 {
 930         Evas_Object *page;
 931         Evas_Object *item;
 932         register unsigned int page_no;
 933         register unsigned int position_no;
 934         unsigned int nr_of_pages;
 935         int page_max_app;
 936
 937         nr_of_pages = page_scroller_count_page(scroller);
 938         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 939         for (page_no = 0; page_no < nr_of_pages; page_no ++) {
 940                 page = page_scroller_get_page_at(scroller, page_no);
 941                 if(!page) continue;
 942
 943                 for (position_no = 0; position_no < page_max_app; position_no ++) {
 944                         item = page_get_item_at(page, position_no);
 945                         if (!item) {
 946                                 continue;
 947                         }
 948
 949                         item_edit(item);
 950                 }
 951         }
 952         evas_object_data_set(scroller, "is_edited", (void *) true);
 953 }
 954
 955
 956
 957 HAPI void page_scroller_unedit(Evas_Object *scroller)
 958 {
 959         Evas_Object *all_apps;
 960         Evas_Object *page;
 961         Evas_Object *item;
 962         register int page_no;
 963         register unsigned int position_no;
 964         unsigned int nr_of_pages;
 965         int page_max_app;
 966
 967         ret_if(NULL == scroller);
 968
 969         all_apps = evas_object_data_get(scroller, "tab");
 970         ret_if(NULL == all_apps);
 971
 972         nr_of_pages = page_scroller_count_page(scroller);
 973         page_max_app = (int) evas_object_data_get(scroller, "page_max_app");
 974
 975         for (page_no = nr_of_pages - 1; page_no >= 0; page_no --) {
 976                 page = page_scroller_get_page_at(scroller, page_no);
 977                 if(NULL == page) continue;
 978
 979                 page_scroller_trim_items(scroller);
 980
 981                 for (position_no = 0; position_no < page_max_app; position_no ++) {
 982                         item = page_get_item_at(page, position_no);
 983                         if (!item) {
 984                                 break;
 985                         }
 986
 987                         item_unedit(item);
 988                 }
 989         }
 990
 991         evas_object_data_set(scroller, "is_edited", (void *) false);
 992 }
 993
 994
 995
 996 HAPI bool page_scroller_is_edited(Evas_Object *scroller)
 997 {
 998         return (bool) evas_object_data_get(scroller, "is_edited");
 999 }
1000
1001
1002
1003 HAPI void page_scroller_focus(Evas_Object *scroller)
1004 {
1005         int idx = 0;
1006         idx = page_scroller_get_current_page_no(scroller);
1007
1008         Evas_Object *page = NULL;
1009         page = page_scroller_get_page_at(scroller, (unsigned int) idx);
1010         ret_if(NULL == page);
1011
1012         Evas_Object *item = NULL;
1013         item = page_get_item_at(page, 0);
1014         ret_if(NULL == item);
1015
1016         Evas_Object *focus_button = NULL;
1017         focus_button = elm_object_part_content_get(item, "focus");
1018         ret_if(NULL == focus_button);
1019
1020         _D("Focus set scroller(%p), page:%d, item:%s", scroller, idx, item_get_name(item));
1021         elm_object_focus_set(focus_button, EINA_TRUE);
1022 }
1023
1024
1025
1026 HAPI void page_scroller_focus_into_vector(Evas_Object *scroller, int vector)
1027 {
1028         int idx = 0;
1029         idx = page_scroller_get_current_page_no(scroller);
1030         idx += vector;
1031
1032         ret_if(0 > idx);
1033
1034         Evas_Object *page = NULL;
1035         page = page_scroller_get_page_at(scroller, (unsigned int) idx);
1036         ret_if(NULL == page);
1037
1038         Evas_Object *item = NULL;
1039         item = page_get_item_at(page, 0);
1040         ret_if(NULL == item);
1041
1042         Evas_Object *focus_button = NULL;
1043         focus_button = elm_object_part_content_get(item, "focus");
1044         ret_if(NULL == focus_button);
1045
1046         _D("Focus set scroller(%p), page:%d, item:%s", scroller, idx, item_get_name(item));
1047         elm_object_focus_set(focus_button, EINA_TRUE);
1048
1049         page_scroller_bring_in(scroller, idx);
1050 }
1051
1052
1053
1054 // End of a file