src/day-time.c

   1 /*
   2   *
   3   *  Copyright 2012  Samsung Electronics Co., Ltd
   4   *
   5   *  Licensed under the Flora License, Version 1.0 (the "License");
   6   *  you may not use this file except in compliance with the License.
   7   *  You may obtain a copy of the License at
   8   *
   9   *       http://floralicense.org/license/
  10   *
  11   *  Unless required by applicable law or agreed to in writing, software
  12   *  distributed under the License is distributed on an "AS IS" BASIS,
  13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14   *  See the License for the specific language governing permissions and
  15   *  limitations under the License.
  16   */
  17
  18 #include <math.h>
  19
  20 #include "view.h"
  21 #include "edit-view.h"
  22 #include "detail-view.h"
  23 #include "view-day-list.h"
  24 #include "day-time.h"
  25 #include "day-expandable-list.h"
  26
  27 static const char *_name = "main/day/time";
  28
  29 typedef struct {
  30
  31         cal_base_time_s base_time;
  32
  33         struct appdata *ad;
  34
  35         Evas_Coord mouse_down_distance;
  36
  37         Ecore_Idler *idler_for_time_block;
  38         Ecore_Idler *idler_for_change;
  39
  40         Ecore_Timer *mouse_clicked_timer;
  41
  42         int flick_direction;
  43
  44         Evas_Coord threshold;
  45
  46         Eina_Bool is_quit_editmode;
  47
  48 } cal_day_time_s;
  49
  50
  51 static cal_base_time_h __cal_day_time_new(void *data);
  52 static void __cal_day_time_state_actions(cal_base_time_h base_time);
  53 static void __cal_day_time_state_transition(cal_base_time_h base_time, enum cal_base_time_input_signal_type input);
  54 static void __cal_day_time_update(cal_base_time_h base_time);
  55 static void __cal_day_time_delete(cal_base_time_h base_time);
  56
  57 cal_base_time_operations day_time_operations = {
  58         __cal_day_time_new,
  59         __cal_day_time_delete,
  60         NULL,
  61         __cal_day_time_state_transition,
  62         __cal_day_time_state_actions,
  63         __cal_day_time_update,
  64 };
  65
  66 extern void cal_day_update_genlist(Evas_Object *ly);
  67
  68 static void __cal_day_time_delete(cal_base_time_h base_time)
  69 {
  70         c_ret_if(!base_time);
  71
  72         cal_day_time_s *p = base_time;
  73
  74         if (p->idler_for_time_block)
  75                 ecore_idler_del(p->idler_for_time_block);
  76
  77         if (p->idler_for_change)
  78                 ecore_idler_del(p->idler_for_change);
  79
  80 }
  81
  82 static cal_base_time_h __cal_day_time_new(void *data)
  83 {
  84         c_retv_if(!data, NULL);
  85
  86         cal_day_time_s *p = NULL;
  87
  88         CAL_CALLOC(p, 1, cal_day_time_s);
  89
  90         ((cal_base_time_s *)p)->name = _name;
  91
  92         p->ad = data;
  93
  94         p->threshold = elm_config_finger_size_get();
  95
  96         return p;
  97
  98 }
  99
 100 static void __cal_day_time_scroll_zoom(cal_base_time_h base_time, Evas *e, Evas_Object *obj, void *ei)
 101 {
 102         c_ret_if(!base_time);
 103
 104         cal_base_time_s *p = base_time;
 105
 106         Evas_Coord_Point sc_xy;
 107         Evas_Coord sc_h;
 108         Evas_Coord_Point base_xy;
 109         Evas_Coord base_h;
 110         Evas_Coord_Rectangle r;
 111         int t_y = 0;
 112
 113         evas_object_geometry_get(p->scroller, &sc_xy.x, &sc_xy.y, NULL, &sc_h);
 114         evas_object_geometry_get(p->base, &base_xy.x, &base_xy.y, NULL, &base_h);
 115
 116         cal_base_time_block_get_geometry(p->base_time_block, &r);
 117
 118         if (r.y > p->base_y) {
 119                 cal_base_time_block_move(p->base_time_block, base_xy.x, p->base_y);
 120         } else {
 121                 if ((r.y+r.h) < (sc_xy.y+sc_h)) {
 122                         if (r.h > sc_h) {
 123                                 t_y = sc_xy.y + sc_h - r.h;
 124                                 cal_base_time_block_move(p->base_time_block, base_xy.x, t_y);
 125                         } else {
 126                                 cal_base_time_block_move(p->base_time_block, base_xy.x, p->base_y);
 127                         }
 128                 }
 129         }
 130 }
 131
 132 static inline void __cal_day_time_double_clicked_callback(cal_base_time_h base_time)
 133 {
 134         c_ret_if(!base_time);
 135
 136         cal_day_time_s *p = base_time;
 137
 138         c_ret_if(p->is_quit_editmode);
 139
 140         if (p->ad->is_magnifying)
 141                 return;
 142
 143         p->ad->is_contracted = !p->ad->is_contracted;
 144
 145         cal_base_time_freeze_scroller(p);
 146
 147         if (!p->ad->is_contracted) {
 148                 cal_day_time_block_resize(((cal_base_time_s *)p)->base_time_block, 0, cal_day_time_block_get_max(((cal_base_time_s *)p)->base_time_block), p->ad->is_contracted);
 149                 cal_day_time_block_resize(((cal_base_time_s *)p)->left_base_time_block, 0, cal_day_time_block_get_max(((cal_base_time_s *)p)->base_time_block), p->ad->is_contracted);
 150                 cal_day_time_block_resize(((cal_base_time_s *)p)->right_base_time_block, 0, cal_day_time_block_get_max(((cal_base_time_s *)p)->base_time_block), p->ad->is_contracted);
 151         } else {
 152                 cal_day_time_block_resize(((cal_base_time_s *)p)->base_time_block, 0, 0, p->ad->is_contracted);
 153                 cal_day_time_block_resize(((cal_base_time_s *)p)->left_base_time_block, 0, 0, p->ad->is_contracted);
 154                 cal_day_time_block_resize(((cal_base_time_s *)p)->right_base_time_block, 0, 0, p->ad->is_contracted);
 155         }
 156
 157         cal_base_time_thaw_scroller(p);
 158
 159         __cal_day_time_scroll_zoom(p, NULL, NULL, NULL);
 160 }
 161
 162 static Eina_Bool __cal_day_time_ug_callback(void *data)
 163 {
 164         c_retv_if(!data, EINA_FALSE);
 165
 166         cal_day_time_s *p = (cal_base_time_s *)data;
 167         c_retv_if(!p->ad, EINA_FALSE);
 168         c_retv_if(!p->ad->main, EINA_FALSE);
 169
 170         p->ad->ug = NULL;
 171
 172         Evas_Object *content = elm_object_part_content_get(p->ad->main, "cont");
 173         c_retv_if(!content, EINA_FALSE);
 174
 175         p->ad->base_tm.tm_hour = p->ad->base_hour;
 176
 177         cal_day_update_genlist(content);
 178
 179         cal_base_time_block_update(((cal_base_time_s *)p)->base_time_block);
 180
 181         cal_base_time_block_move_event_blocks(((cal_base_time_s *)p)->base_time_block);
 182
 183         cal_day_change_content_display_status(content);
 184
 185         cal_main_add_db_changed_callback(p->ad);
 186
 187         return EINA_TRUE;
 188 }
 189
 190 static Eina_Bool __cal_day_time_mouse_hold_timer_callback(void *data)
 191 {
 192         c_retv_if(!data, ECORE_CALLBACK_CANCEL);
 193
 194         cal_base_time_s *p = (cal_base_time_s *)data;
 195         c_retv_if(!p->base_time_block, ECORE_CALLBACK_CANCEL);
 196
 197         switch (p->state_action_type)
 198         {
 199         case STATE_DOWN_FIRST:
 200         case STATE_DOWN_SECOND:
 201                 cal_day_time_block_hint_longpress(p->base_time_block, &p->single_mouse_down);
 202                 break;
 203         default:
 204                 break;
 205         }
 206
 207         return ECORE_CALLBACK_CANCEL;
 208 }
 209
 210 static void __cal_day_time_time_block_clicked_callback(cal_base_time_h base_time, int hour)
 211 {
 212         c_ret_if(!base_time);
 213
 214         cal_day_time_s *p = base_time;
 215
 216         c_ret_if(!p->ad);
 217         c_ret_if(p->is_quit_editmode);
 218
 219         p->ad->base_hour = hour;
 220         p->ad->cid = 0;
 221
 222         calendar_record_h record = NULL;
 223         calendar_error_e error = CALENDAR_ERROR_NONE;
 224
 225         error = calendar_record_create(_calendar_event._uri, &record);
 226         c_retm_if(error != CALENDAR_ERROR_NONE, "calendar_record_create() is failed(%x)", error);
 227
 228         p->ad->base_hour = p->ad->base_tm.tm_hour;
 229         p->ad->base_tm.tm_hour = hour;
 230
 231         cal_main_remove_db_changed_callback(p->ad);
 232
 233         cal_edit_create_view(p->ad, record, __cal_day_time_ug_callback, p);
 234 }
 235
 236 static void __cal_day_time_event_block_clicked_callback(cal_base_time_h base_time, calendar_record_h record)
 237 {
 238         c_ret_if(!base_time);
 239
 240         cal_day_time_s *p = base_time;
 241
 242         c_ret_if(!record);
 243         c_ret_if(!p->ad);
 244         c_ret_if(p->is_quit_editmode);
 245
 246         p->ad->cid = _calendar_get_record_index(record);
 247         p->ad->base_hour = p->ad->base_tm.tm_hour;
 248
 249         cal_main_remove_db_changed_callback(p->ad);
 250
 251         cal_detail_create_view(p->ad, record, __cal_day_time_ug_callback, p);
 252 }
 253
 254 static void __cal_day_time_more_event_block_clicked_callback(cal_base_time_h base_time)
 255 {
 256         c_ret_if(!base_time);
 257
 258         cal_day_time_s *p = base_time;
 259
 260         c_ret_if(!p->ad);
 261         c_ret_if(p->is_quit_editmode);
 262
 263         Evas_Object* ly = cal_day_list_create(p->ad, p->ad->main);
 264         cal_day_list_update_list(ly);
 265 }
 266
 267 static void __cal_day_time_mouse_event_callback(void *data, int event_type, void *ei)
 268 {
 269         c_ret_if(!data);
 270
 271         cal_base_time_s *p = (cal_base_time_s *)data;
 272
 273         switch (event_type) {
 274                 case EVEN_BLOCK_EVENT_CLICEKD:
 275                         p->state_action_type = STATE_START;
 276                         __cal_day_time_event_block_clicked_callback(p, (calendar_record_h)ei);
 277                         break;
 278                 case EVEN_BLOCK_MORE_EVENT_CLICEKD:
 279                         p->state_action_type = STATE_START;
 280                         __cal_day_time_more_event_block_clicked_callback(p);
 281                         break;
 282                 case TIME_BLOCK_SLICE_CLICEKD:
 283                         p->state_action_type = STATE_START;
 284                         __cal_day_time_time_block_clicked_callback(p, (int)ei);
 285                         break;
 286                 case DAY_TIME_DOUBLE_CLICEKD:
 287                         p->state_action_type = STATE_START;
 288                         __cal_day_time_double_clicked_callback(p);
 289                         break;
 290
 291                 default:
 292                         break;
 293         }
 294 }
 295
 296 cal_base_time_h  cal_day_time_create(void *data)
 297 {
 298         return cal_base_time_create(&day_time_operations, data);
 299 }
 300
 301 static Eina_Bool __cal_day_time_move_time_block_to_time_line(void *data)
 302 {
 303         c_retv_if(!data, ECORE_CALLBACK_CANCEL);
 304
 305         cal_day_time_s *p = (cal_day_time_s *)data;
 306
 307         if (p->idler_for_time_block) {
 308                 ecore_idler_del(p->idler_for_time_block);
 309                 p->idler_for_time_block = NULL;
 310         }
 311
 312         cal_base_time_block_move_to_time_line(((cal_base_time_s *)p)->base_time_block);
 313
 314         return ECORE_CALLBACK_CANCEL;
 315 }
 316
 317 static void __cal_day_time_update(cal_base_time_h base_time)
 318 {
 319         CAL_FN_START;
 320
 321         c_ret_if(!base_time);
 322
 323         cal_base_time_s *p = (cal_base_time_s *)base_time;
 324         c_ret_if(!p->base_time_block);
 325
 326         cal_day_time_block_set_callback(p->base_time_block, __cal_day_time_mouse_event_callback, p);
 327
 328         cal_base_time_block_update(p->base_time_block);
 329
 330         if (((cal_day_time_s *)p)->ad->is_magnifying) {
 331                 cal_day_time_block_resize(p->base_time_block, 0, cal_day_time_block_get_current(p->base_time_block), EINA_FALSE);
 332         } else {
 333                 if (((cal_day_time_s *)p)->ad->is_contracted) {
 334                         cal_day_time_block_resize(p->base_time_block, 0, cal_day_time_block_get_max(p->base_time_block), EINA_FALSE);
 335                         cal_day_time_block_resize(p->base_time_block, 0, 0, EINA_TRUE);
 336                 }
 337         }
 338
 339         cal_base_time_attach_scroller(p);
 340
 341
 342         if (!((cal_day_time_s *)p)->idler_for_time_block)
 343                 ((cal_day_time_s *)p)->idler_for_time_block = ecore_idler_add(__cal_day_time_move_time_block_to_time_line, p);
 344
 345         CAL_FN_END;
 346 }
 347
 348 static Eina_Bool  __cal_day_time_mouse_clicked_timer_callback(void *data)
 349 {
 350         c_retv_if(!data, EINA_FALSE);
 351
 352         cal_base_time_s *p = data;
 353
 354         switch (p->state_action_type)
 355         {
 356         case STATE_UP_FIRST:
 357                 cal_day_time_block_hint_clicked(p->base_time_block, &p->single_mouse_down);
 358                 cal_day_change_content_display_status(p->parent);
 359                 p->state_action_type = STATE_START;
 360                 break;
 361         case STATE_UP_SECOND:
 362                 __cal_day_time_mouse_event_callback(p, DAY_TIME_DOUBLE_CLICEKD, NULL);
 363                 p->state_action_type = STATE_START;
 364                 break;
 365         default:
 366                 break;
 367         }
 368
 369         if (((cal_day_time_s *)p)->mouse_clicked_timer) {
 370                 ecore_timer_del(((cal_day_time_s *)p)->mouse_clicked_timer);
 371                 ((cal_day_time_s *)p)->mouse_clicked_timer = NULL;
 372         }
 373
 374         return ECORE_CALLBACK_CANCEL;
 375 }
 376
 377 static void __cal_day_time_state_down_action(cal_base_time_h base_time)
 378 {
 379         c_ret_if(!base_time);
 380
 381         cal_day_time_s *p = base_time;
 382 }
 383
 384 static void __cal_day_time_state_up_action(cal_base_time_h base_time)
 385 {
 386         c_ret_if(!base_time);
 387
 388         cal_day_time_s *p = base_time;
 389
 390
 391         if (!p->mouse_clicked_timer) {
 392                 p->mouse_clicked_timer = ecore_timer_add(DAY_TIME_DOUBLE_CLICK_TIME, __cal_day_time_mouse_clicked_timer_callback, p);
 393         }
 394
 395 }
 396
 397 static Evas_Object* __cal_day_time_create_time_d(cal_base_time_h base_time, int d)
 398 {
 399         c_retv_if(!base_time, NULL);
 400
 401         cal_base_time_s *p = (cal_base_time_s *)base_time;
 402
 403         struct appdata *ad = ((cal_day_time_s *)p)->ad;
 404         c_retv_if(!ad, NULL);
 405
 406         cal_base_time_block_h time_block = NULL;
 407         time_t r = cal_util_update_tm_day(&ad->base_tm, d);
 408         c_retv_if(r < 0, NULL);
 409
 410         if (d < 0) {
 411                 if (!p->left_base_time_block) {
 412                         p->left_base_time_block = cal_base_time_block_new(p->base_type, p->scroller, p->clip, NULL, ((cal_day_time_s *)p)->ad->base_tm.tm_hour, ((cal_day_time_s *)p)->ad);
 413                         time_block = p->left_base_time_block;
 414                 }
 415         } else {
 416                 if (!p->right_base_time_block) {
 417                         p->right_base_time_block = cal_base_time_block_new(p->base_type, p->scroller, p->clip, NULL, ((cal_day_time_s *)p)->ad->base_tm.tm_hour, ((cal_day_time_s *)p)->ad);
 418                         time_block = p->right_base_time_block;
 419                 }
 420         }
 421         r = cal_util_update_tm_day(&ad->base_tm, -d);
 422         c_retv_if(r < 0, NULL);
 423
 424         if (((cal_day_time_s *)p)->ad->is_magnifying) {
 425                 cal_day_time_block_resize(time_block, 0, cal_day_time_block_get_current(p->base_time_block), EINA_FALSE);
 426         } else {
 427                 if (((cal_day_time_s *)p)->ad->is_contracted) {
 428                         cal_day_time_block_resize(time_block, 0, 0, EINA_TRUE);
 429                 }else {
 430                         cal_day_time_block_resize(time_block, 0, cal_day_time_block_get_max(p->base_time_block), EINA_FALSE);
 431                 }
 432         }
 433
 434         return time_block;
 435 }
 436
 437 static void __cal_day_time_state_enable_flick_action(cal_base_time_h base_time)
 438 {
 439         c_ret_if(!base_time);
 440
 441         cal_day_time_s *p = base_time;
 442
 443         cal_base_time_freeze_scroller(p);
 444 }
 445
 446 static void __cal_day_time_state_flicking_action(cal_base_time_h base_time)
 447 {
 448         c_ret_if(!base_time);
 449
 450         cal_base_time_s *p = (cal_base_time_s *)base_time;
 451
 452         Evas_Coord_Rectangle r;
 453
 454         __cal_day_time_create_time_d(p, ((cal_day_time_s *)p)->flick_direction);
 455
 456         Evas_Coord d = p->single_mouse_move.x - p->single_mouse_down.x;
 457
 458         cal_base_time_block_get_geometry(p->base_time_block, &r);
 459
 460         cal_base_time_block_move(p->base_time_block, p->scroller_coord.x + d, r.y);
 461
 462         if (p->left_base_time_block) {
 463                 cal_base_time_block_move(p->left_base_time_block, p->scroller_coord.x + d - r.w, r.y);
 464         }
 465
 466          if (p->right_base_time_block) {
 467                 cal_base_time_block_move(p->right_base_time_block, p->scroller_coord.x + d + r.w, r.y);
 468         }
 469 }
 470
 471 static void __cal_day_time_update_time_block(cal_base_time_h base_time)
 472 {
 473         CAL_FN_START;
 474         c_ret_if(!base_time);
 475
 476         cal_base_time_s *p = (cal_base_time_s *)base_time;
 477
 478         Evas_Coord_Rectangle rect = {0};
 479
 480         cal_base_time_block_get_geometry(p->base_time_block, &rect);
 481
 482         int r = cal_util_update_tm_day(&((cal_day_time_s *)p)->ad->base_tm, ((cal_day_time_s *)p)->flick_direction);
 483         c_retm_if(r < 0, "cal_util_update_tm_day() is returned %d", r);
 484
 485         cal_day_time_block_unset_callback(p->base_time_block);
 486
 487         if (0 < ((cal_day_time_s *)p)->flick_direction) {
 488                 if (p->left_base_time_block){
 489                         cal_base_time_block_delete(p->left_base_time_block);
 490                         p->left_base_time_block = NULL;
 491                 }
 492
 493                 p->left_base_time_block = p->base_time_block;
 494                 p->base_time_block = p->right_base_time_block;
 495                 p->right_base_time_block = __cal_day_time_create_time_d(p, 1);
 496         } else if (((cal_day_time_s *)p)->flick_direction < 0) {
 497                 if (p->right_base_time_block) {
 498                         cal_base_time_block_delete(p->right_base_time_block);
 499                         p->right_base_time_block = NULL;
 500                 }
 501
 502                 p->right_base_time_block = p->base_time_block;
 503                 p->base_time_block = p->left_base_time_block;
 504                 p->left_base_time_block = __cal_day_time_create_time_d(p, -1);
 505         }
 506
 507         cal_day_time_block_set_callback(p->base_time_block, __cal_day_time_mouse_event_callback, p);
 508
 509         cal_base_time_block_move(p->left_base_time_block, p->scroller_coord.x - rect.w, rect.y);
 510         cal_base_time_block_move(p->base_time_block, p->scroller_coord.x, rect.y);
 511         cal_base_time_block_move(p->right_base_time_block, p->scroller_coord.x + rect.w, rect.y);
 512
 513         cal_main_update_title_text(((cal_day_time_s *)p)->ad);
 514
 515         cal_day_update_genlist(p->parent);
 516 }
 517
 518 static void __cal_day_time_state_disable_flick_action(cal_base_time_h base_time)
 519 {
 520         CAL_FN_START;
 521         c_ret_if(!base_time);
 522
 523         cal_base_time_s *p = (cal_base_time_s *)base_time;
 524
 525         Evas_Coord_Rectangle r;
 526         Evas_Coord d;
 527         Evas_Coord_Rectangle rect = {0};
 528
 529         d = p->single_mouse_move.x - p->single_mouse_down.x;
 530
 531         cal_util_get_geometry(&rect, p->scroller);
 532
 533         if ( (rect.w/2) < abs(d)) {
 534                 __cal_day_time_update_time_block(p);
 535         } else {
 536                 cal_base_time_block_get_geometry(p->base_time_block, &r);
 537                 cal_base_time_block_move(p->base_time_block, p->scroller_coord.x, r.y);
 538                 if (p->left_base_time_block) {
 539                         cal_base_time_block_move(p->left_base_time_block, p->scroller_coord.x - r.w, r.y);
 540                 }
 541                 if (p->right_base_time_block) {
 542                         cal_base_time_block_move(p->right_base_time_block, p->scroller_coord.x + r.w, r.y);
 543                 }
 544         }
 545
 546         cal_base_time_thaw_scroller(p);
 547 }
 548
 549 static void __cal_day_time_state_enable_scroll_action(cal_base_time_h base_time)
 550 {
 551         c_ret_if(!base_time);
 552
 553         cal_day_time_s *p = (cal_day_time_s *)base_time;
 554
 555 }
 556
 557 static void __cal_day_time_state_scrolling_action(cal_base_time_h base_time)
 558 {
 559         c_ret_if(!base_time);
 560
 561 }
 562
 563 static void __cal_day_time_state_disable_scroll_action(cal_base_time_h base_time)
 564 {
 565         c_ret_if(!base_time);
 566
 567         cal_base_time_s *p = (cal_base_time_s *)base_time;
 568
 569         p->single_mouse_down.x = -1;
 570         p->single_mouse_down.y = -1;
 571
 572         p->single_mouse_move.x = -1;
 573         p->single_mouse_move.y = -1;
 574 }
 575
 576 static void __cal_day_time_state_enable_moving_event_action(cal_base_time_h base_time)
 577 {
 578         c_ret_if(!base_time);
 579
 580         cal_base_time_freeze_scroller(base_time);
 581 }
 582
 583 static void __cal_day_time_state_event_moving_action(cal_base_time_h base_time)
 584 {
 585         c_ret_if(!base_time);
 586
 587         cal_base_time_s *p = (cal_base_time_s *)base_time;
 588
 589         c_ret_if(-1 == p->single_mouse_down.x);
 590         c_ret_if(-1 == p->single_mouse_down.y);
 591         c_ret_if(-1 == p->single_mouse_move.x);
 592         c_ret_if(-1 == p->single_mouse_move.y);
 593
 594         cal_day_time_block_moving_moveable_event(p->base_time_block, &p->single_mouse_move, &p->single_mouse_down);
 595 }
 596
 597
 598 static void __cal_day_time_state_disable_moving_event_action(cal_base_time_h base_time)
 599 {
 600         c_ret_if(!base_time);
 601
 602         cal_base_time_s *p = (cal_base_time_s *)base_time;
 603
 604         cal_base_time_thaw_scroller(p);
 605
 606         cal_day_time_block_disable_moving_moveable_event(p->base_time_block, &p->single_mouse_move, &p->single_mouse_down);
 607
 608         ((cal_day_time_s *)p)->is_quit_editmode = EINA_TRUE;
 609
 610         cal_base_time_state_transition(p, SINGLE_MOUSE_DOWN);
 611         cal_base_time_state_actions(p);
 612
 613 }
 614
 615 static void __cal_day_time_state_enable_zoom_event_action(cal_base_time_h base_time)
 616 {
 617         c_ret_if(!base_time);
 618
 619         cal_base_time_s *p = (cal_base_time_s *)base_time;
 620
 621         cal_base_time_freeze_scroller(p);
 622
 623         ((cal_day_time_s *)p)->mouse_down_distance = cal_util_get_distance(&p->single_mouse_down, &p->multi_mouse_down);
 624 }
 625
 626 static void __cal_day_time_zoom_callback(cal_base_time_h base_time)
 627 {
 628         c_ret_if(!base_time);
 629
 630         cal_day_time_s *p = (cal_day_time_s *)base_time;
 631
 632         Evas_Coord h;
 633         double rate;
 634
 635         if (p->ad->is_contracted)
 636                 return;
 637
 638         Evas_Coord d = cal_util_get_distance(&((cal_base_time_s *)p)->single_mouse_move, &((cal_base_time_s *)p)->multi_mouse_move);
 639         rate = (double)d/p->mouse_down_distance;
 640
 641         if (p->ad->is_magnifying) {
 642                 h = cal_day_time_block_get_current(((cal_base_time_s *)p)->base_time_block);
 643         } else {
 644                 h = cal_day_time_block_get_max(((cal_base_time_s *)p)->base_time_block);
 645         }
 646
 647         if (rate < 1 && !p->ad->is_magnifying)
 648                 return;
 649
 650         if (p->ad->is_magnifying) {
 651                 cal_day_time_block_resize(((cal_base_time_s *)p)->base_time_block, (((cal_base_time_s *)p)->single_mouse_down.y + ((cal_base_time_s *)p)->multi_mouse_down.y) >> 1, h + cal_day_time_block_get_min() * (rate-1), EINA_FALSE);
 652         } else {
 653                 cal_day_time_block_resize(((cal_base_time_s *)p)->base_time_block, (((cal_base_time_s *)p)->single_mouse_down.y + ((cal_base_time_s *)p)->multi_mouse_down.y) >> 1, h * rate, EINA_FALSE);
 654         }
 655 }
 656
 657 static void __cal_day_time_state_zooming_event_action(cal_base_time_h base_time)
 658 {
 659         c_ret_if(!base_time);
 660
 661         __cal_day_time_zoom_callback(base_time);
 662
 663 }
 664
 665 static Eina_Bool __cal_day_time_change(void *data)
 666 {
 667         c_retv_if(!data, ECORE_CALLBACK_CANCEL);
 668
 669         cal_day_time_s *p = (cal_day_time_s *)data;
 670
 671         if (p->idler_for_time_block) {
 672                 ecore_idler_del(p->idler_for_time_block);
 673                 p->idler_for_time_block = NULL;
 674         }
 675
 676         cal_main_change_view(p->ad->main, CV_WEEK);
 677
 678         return ECORE_CALLBACK_CANCEL;
 679 }
 680
 681
 682 static void __cal_day_time_signal_disable_zoom_callback(cal_base_time_h base_time)
 683 {
 684         c_ret_if(!base_time);
 685
 686         cal_day_time_s *p = (cal_day_time_s *)base_time;
 687
 688         c_ret_if(!p->ad);
 689         c_ret_if(!p->ad->main);
 690         c_ret_if(!((cal_base_time_s *)p)->base_time_block);
 691
 692         Eina_Bool is_magnifying = p->ad->is_magnifying;
 693         int h_cur = cal_day_time_block_get_current(((cal_base_time_s *)p)->base_time_block);
 694         int h_normal = cal_day_time_block_get_max(((cal_base_time_s *)p)->base_time_block);
 695
 696         if (!is_magnifying &&  (h_normal < h_cur)) {
 697                 p->ad->is_magnifying = EINA_TRUE;
 698
 699                 cal_day_time_block_resize(((cal_base_time_s *)p)->left_base_time_block, 0, cal_day_time_block_get_current(((cal_base_time_s *)p)->base_time_block), EINA_FALSE);
 700                 cal_day_time_block_resize(((cal_base_time_s *)p)->right_base_time_block, 0, cal_day_time_block_get_current(((cal_base_time_s *)p)->base_time_block), EINA_FALSE);
 701
 702                 ((cal_base_time_s *)p)->state_action_type = STATE_START;
 703
 704                 cal_base_time_thaw_scroller(p);
 705                 __cal_day_time_scroll_zoom(p, NULL, NULL, NULL);
 706         } else if (is_magnifying) {
 707                 if (h_cur <= h_normal)
 708                         p->ad->is_magnifying = EINA_FALSE;
 709
 710                 cal_day_time_block_resize(((cal_base_time_s *)p)->left_base_time_block, 0, cal_day_time_block_get_current(((cal_base_time_s *)p)->base_time_block), EINA_FALSE);
 711                 cal_day_time_block_resize(((cal_base_time_s *)p)->right_base_time_block, 0, cal_day_time_block_get_current(((cal_base_time_s *)p)->base_time_block), EINA_FALSE);
 712
 713                 ((cal_base_time_s *)p)->state_action_type = STATE_START;
 714
 715                 cal_base_time_thaw_scroller(p);
 716                 __cal_day_time_scroll_zoom(p, NULL, NULL, NULL);
 717         } else {
 718                 int d= 0;
 719                 Evas_Coord th = elm_config_finger_size_get();
 720
 721                 d = cal_util_get_distance(&((cal_base_time_s *)p)->single_mouse_move, &((cal_base_time_s *)p)->multi_mouse_move);
 722
 723                 if (th < abs(d-p->mouse_down_distance)) {
 724                         if (p->idler_for_change)
 725                                 ecore_idler_del(p->idler_for_change);
 726
 727                         p->idler_for_change = ecore_idler_add(__cal_day_time_change, p);
 728                 }
 729         }
 730 }
 731
 732 static void __cal_day_time_state_disable_zoom_event_action(cal_base_time_h base_time)
 733 {
 734         c_ret_if(!base_time);
 735
 736 }
 737
 738 static void __cal_day_time_state_actions(cal_base_time_h base_time)
 739 {
 740         c_ret_if(!base_time);
 741
 742         cal_base_time_s *p = (cal_base_time_s *)base_time;
 743
 744         switch (p->state_action_type)
 745         {
 746         case STATE_DOWN_FIRST:
 747         case STATE_DOWN_SECOND:
 748                 __cal_day_time_state_down_action(p);
 749                 break;
 750         case STATE_UP_FIRST:
 751                 __cal_day_time_state_up_action(p);
 752                 break;
 753         case STATE_ENABLE_FLICK:
 754                 __cal_day_time_state_enable_flick_action(p);
 755                 break;
 756         case STATE_FLICKING:
 757                 __cal_day_time_state_flicking_action(p);
 758                 break;
 759         case STATE_DISABLE_FLICK:
 760                 __cal_day_time_state_disable_flick_action(p);
 761                 break;
 762         case STATE_ENABLE_SCROLL:
 763                 __cal_day_time_state_enable_scroll_action(p);
 764                 break;
 765         case STATE_SCROLLING:
 766                 __cal_day_time_state_scrolling_action(p);
 767                 break;
 768         case STATE_DISABLE_SCROLL:
 769                 __cal_day_time_state_disable_scroll_action(p);
 770                 break;
 771         case STATE_ENABLE_MOVEING_EVENT:
 772                 __cal_day_time_state_enable_moving_event_action(p);
 773                 break;
 774         case STATE_MOVING_EVENT:
 775                 __cal_day_time_state_event_moving_action(p);
 776                 break;
 777         case STATE_DISABLE_MOVEING_EVENT:
 778                 __cal_day_time_state_disable_moving_event_action(p);
 779                 break;
 780         case STATE_ENABLE_ZOOM:
 781                 __cal_day_time_state_enable_zoom_event_action(p);
 782                 break;
 783         case STATE_ZOOMING:
 784                 __cal_day_time_state_zooming_event_action(p);
 785                 break;
 786         case STATE_DISABLE_ZOOM:
 787                 __cal_day_time_state_disable_zoom_event_action(p);
 788                 break;
 789         default:
 790                 break;
 791         }
 792 }
 793
 794 static void __cal_day_time_state_transition(cal_base_time_h base_time, enum cal_base_time_input_signal_type input)
 795 {
 796         c_ret_if(!base_time);
 797
 798         cal_base_time_s *p = (cal_base_time_s *)base_time;
 799
 800         switch (p->state_action_type)
 801         {
 802         case STATE_START:
 803                 if (SINGLE_MOUSE_DOWN == input) {
 804                         ((cal_day_time_s *)p)->is_quit_editmode = EINA_FALSE;
 805                         p->state_action_type = STATE_DOWN_FIRST;
 806                 }
 807                 break;
 808         case STATE_DOWN_FIRST:
 809                 if (SINGLE_MOUSE_UP == input) {
 810                         p->state_action_type = STATE_UP_FIRST;
 811                 } else if (SCROLLER_DRAG_START == input) {
 812                         int width_d = p->single_mouse_move.x - p->single_mouse_down.x;
 813                         int heigt_d = p->single_mouse_move.y - p->single_mouse_down.y;
 814                         if (abs(width_d) < abs(heigt_d)) {
 815                                 p->state_action_type = STATE_ENABLE_SCROLL;
 816                         } else {
 817                                 ((cal_day_time_s *)p)->flick_direction = ((0 < width_d) ? -1 : 1);
 818                                 p->state_action_type = STATE_ENABLE_FLICK;
 819                         }
 820                 } else if (MULTI_MOUSE_DOWN == input) {
 821                         p->state_action_type = STATE_ENABLE_ZOOM;
 822                 }
 823                 break;
 824         case STATE_UP_FIRST:
 825                 if (SINGLE_MOUSE_DOWN == input) {
 826                         p->state_action_type = STATE_DOWN_SECOND;
 827                 }
 828                 break;
 829         case STATE_DOWN_SECOND:
 830                 if (SINGLE_MOUSE_UP == input) {
 831                         p->state_action_type = STATE_UP_SECOND;
 832                 } else if (SCROLLER_DRAG_START == input) {
 833                         int width_d = p->single_mouse_move.x - p->single_mouse_down.x;
 834                         int heigt_d = p->single_mouse_move.y - p->single_mouse_down.y;
 835                         if (abs(width_d) < abs(heigt_d)) {
 836                                 p->state_action_type = STATE_ENABLE_SCROLL;
 837                         } else {
 838                                 ((cal_day_time_s *)p)->flick_direction = ((0 < width_d) ? -1 : 1);
 839                                 p->state_action_type = STATE_ENABLE_FLICK;
 840                         }
 841                 } else if (MULTI_MOUSE_DOWN == input) {
 842                         p->state_action_type = STATE_ENABLE_ZOOM;
 843                 }
 844                 break;
 845         case STATE_ENABLE_FLICK:
 846         case STATE_FLICKING:
 847                 ((cal_day_time_s *)p)->flick_direction = ((0 < (p->single_mouse_move.x - p->single_mouse_down.x) ) ? -1 : 1);
 848                 if (SINGLE_MOUSE_UP == input) {
 849                         p->state_action_type = STATE_DISABLE_FLICK;
 850                 } else if (SINGLE_MOUSE_MOVE == input) {
 851                         p->state_action_type = STATE_FLICKING;
 852                 }
 853                 break;
 854         case STATE_ENABLE_SCROLL:
 855         case STATE_SCROLLING:
 856                 if (SINGLE_MOUSE_UP == input) {
 857                         p->state_action_type = STATE_DISABLE_SCROLL;
 858                 } else if (SINGLE_MOUSE_MOVE == input) {
 859                         p->state_action_type = STATE_SCROLLING;
 860                 }
 861                 break;
 862         case STATE_ENABLE_MOVEING_EVENT:
 863                  if (SINGLE_MOUSE_DOWN == input) {
 864                         Eina_Bool is_quit = cal_day_time_block_hint_quit_event_moveable_state(p->base_time_block, &p->single_mouse_down);
 865                         if (!is_quit) {
 866                                 p->state_action_type = STATE_DISABLE_MOVEING_EVENT;
 867                         }
 868                 } else {
 869                         if (SINGLE_MOUSE_MOVE == input) {
 870                                 p->state_action_type = STATE_MOVING_EVENT;
 871                         }
 872
 873                         if (SINGLE_MOUSE_UP == input) {
 874                                 p->single_mouse_down.x = -1;
 875                                 p->single_mouse_down.y = -1;
 876
 877                                 p->single_mouse_move.x = -1;
 878                                 p->single_mouse_move.y = -1;
 879                         }
 880                 }
 881                 break;
 882         case STATE_MOVING_EVENT:
 883                  if (SINGLE_MOUSE_DOWN == input) {
 884                         Eina_Bool is_quit = cal_day_time_block_hint_quit_event_moveable_state(p->base_time_block, &p->single_mouse_down);
 885                         if (!is_quit) {
 886                                 p->state_action_type = STATE_DISABLE_MOVEING_EVENT;
 887                         }
 888                 } else {
 889                         if (SINGLE_MOUSE_UP == input) {
 890                                 p->single_mouse_down.x = -1;
 891                                 p->single_mouse_down.y = -1;
 892
 893                                 p->single_mouse_move.x = -1;
 894                                 p->single_mouse_move.y = -1;
 895                         }
 896                 }
 897                 break;
 898         case STATE_DISABLE_MOVEING_EVENT:
 899                 p->state_action_type = STATE_START;
 900                 if (SINGLE_MOUSE_DOWN == input) {
 901                         p->state_action_type = STATE_DOWN_FIRST;
 902                 }
 903                 break;
 904         case STATE_ENABLE_ZOOM:
 905                  if (input == SINGLE_MOUSE_UP || input == MULTI_MOUSE_UP) {
 906                         p->state_action_type = STATE_DISABLE_ZOOM;
 907                 } else {
 908                         p->state_action_type = STATE_ZOOMING;
 909                 }
 910                 break;
 911         case STATE_ZOOMING:
 912                 if (input == SINGLE_MOUSE_UP || input == MULTI_MOUSE_UP) {
 913                         p->state_action_type = STATE_DISABLE_ZOOM;
 914                 }
 915                 break;
 916         case STATE_DISABLE_ZOOM:
 917                 if (input == SINGLE_MOUSE_UP || input == MULTI_MOUSE_UP) {
 918                         __cal_day_time_signal_disable_zoom_callback(p);
 919                 }
 920                 break;
 921         case STATE_DISABLE_FLICK:
 922         case STATE_DISABLE_SCROLL:
 923         case STATE_UP_SECOND:
 924                 p->state_action_type = STATE_START;
 925                 if (SINGLE_MOUSE_DOWN == input) {
 926                         ((cal_day_time_s *)p)->is_quit_editmode = EINA_FALSE;
 927                         p->state_action_type = STATE_DOWN_FIRST;
 928                 }
 929                 break;
 930         default:
 931                 break;
 932         }
 933 }