src/ClDayPanel.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file        ClDayPanel.cpp
  19  * @brief       This is the implementation file for the DayPanel class.
  20  */
  21
  22 #include <FSocial.h>
  23 #include <FSystem.h>
  24 #include "ClDayPanel.h"
  25 #include "ClEventListPresentationModel.h"
  26 #include "ClGoToDatePopup.h"
  27 #include "ClMainForm.h"
  28 #include "ClPanningAnimationManager.h"
  29 #include "ClResourceManager.h"
  30 #include "ClTypes.h"
  31
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Base::Collection;
  34 using namespace Tizen::Graphics;
  35 using namespace Tizen::Social;
  36 using namespace Tizen::System;
  37 using namespace Tizen::Ui;
  38 using namespace Tizen::Ui::Animations;
  39 using namespace Tizen::Ui::Controls;
  40 using namespace Tizen::Ui::Scenes;
  41
  42 static const int IDA_DAY_PANEL_ALL_DAY_EVENT_EXPAND = 11411;
  43 static const int IDA_DAY_PANEL_ALL_DAY_EVENT_COLLAPSE = 11412;
  44 static const int IDA_DAY_PANEL_EVENT = 11421;
  45 static const int IDA_DAY_PANEL_EVENT_MORE = 11422;
  46
  47 static const int MIN_H_ALL_DAY_EVENT_LIST_PANEL = 80;
  48 static const int MAX_H_ALL_DAY_EVENT_LIST_PANEL = 400;
  49 static const unsigned int COLOR_ALL_DAY_EVENT_LIST_PANEL_BACKGROUND = Color32<242, 237, 226>::Value;
  50 static const int Y_ALL_DAY_EVENT_LIST = 80;
  51 static const unsigned int COLOR_ALL_DAY_EVENT_LIST_LINE = Color32<169, 169, 169>::Value;
  52 static const int H_ALL_DAY_EVENT_ITEM = 80;
  53 static const int X_ALL_DAY_EVENT = 22;
  54 static const int FONT_SIZE_ALL_DAY_EVENT =  34;
  55 static const unsigned int COLOR_ALL_DAY_EVENT = Color32<0, 0, 0>::Value;
  56 static const unsigned int COLOR_ALL_DAY_EVENT_FOCUS = Color32<249, 249, 249>::Value;
  57 static const int Y_EVENT_COLOR_BAR = 4;
  58 static const int W_EVENT_COLOR_BAR = 7;
  59 static const int H_EVENT_COLOR_BAR = 72;
  60 static const int W_ALL_DAY_EVENT_EXPAND_ICON_MARGIN = 16;
  61 static const int H_ALL_DAY_EVENT_EXPAND = 80;
  62 static const int FONT_SIZE_ALL_DAY_EVENT_EXPAND = 34;
  63 static const int H_EVENT_MIN = 39;
  64 static const int H_EVENT_LIST_ITEM = 80;
  65 static const int Y_EVENT_LIST_WITH_ALL_DAY_EVENTS = 80;
  66 static const int X_CURRENT_TIME_ARROW = 33;
  67 static const int H_CURRENT_TIME_LINE = 2;
  68 static const unsigned int COLOR_CURRENT_TIME_LINE = Color32<233, 83, 30>::Value;
  69 static const int W_TIME_LINE = 42;
  70 static const int H_TIME_LINE = 50;
  71 static const int X_TIME_LINE_AMPM = -19;
  72 static const int W_TIME_LINE_AMPM = 80;
  73 static const int H_TIME_LINE_AMPM = 20;
  74 static const int FONT_SIZE_TIME_LINE_AMPM = 20;
  75 static const unsigned int COLOR_TIME_LINE_AMPM = Color32<171, 171, 171>::Value;
  76 static const int X_TIME_LINE_NUMBER = -9;
  77 static const int W_TIME_LINE_NUMBER = 60;
  78 static const int H_TIME_LINE_NUMBER = 24;
  79 static const int FONT_SIZE_TIME_LINE_NUMBER = 24;
  80 static const unsigned int COLOR_TIME_LINE_NUMBER = Color32<171, 171, 171>::Value;
  81 static const unsigned int COLOR_EVENT_PANEL_BACKGROUND = Color32<0, 0, 0, 0>::Value;
  82 static const int H_1_LINE_EVENT_TEXT = 80;
  83 static const int FONT_SIZE_EVENT = 24;
  84 static const unsigned int COLOR_EVENT = Color32<255, 255, 255>::Value;
  85 static const int H_EVENT_MORE_BUTTON_MIN = 79;
  86 static const unsigned int COLOR_EVENT_MORE_BACKGROUND = Color32<59, 151, 207>::Value;
  87
  88 static const int MAX_COLUMN_COUNT = 8;
  89 static const int MINUTES_FOR_HOUR = 60;
  90 static const int TIME_LINE_COUNT = 24;
  91 static const int AMPM_TIME_COUNT = 12;
  92
  93 class DayPanelTimeLineItemProvider
  94         : public virtual IListViewItemProvider
  95 {
  96 public:
  97         DayPanelTimeLineItemProvider(void);
  98         virtual ~DayPanelTimeLineItemProvider(void);
  99
 100         virtual int GetItemCount(void);
 101         virtual ListItemBase* CreateItem(int index, int itemWidth);
 102         virtual bool DeleteItem(int index, ListItemBase* pItem, int itemWidth);
 103 };
 104
 105 DayPanelTimeLineItemProvider::DayPanelTimeLineItemProvider(void)
 106 {
 107 }
 108
 109 DayPanelTimeLineItemProvider::~DayPanelTimeLineItemProvider(void)
 110 {
 111 }
 112
 113 int
 114 DayPanelTimeLineItemProvider::GetItemCount(void)
 115 {
 116         return TIME_LINE_COUNT;
 117 }
 118
 119 ListItemBase*
 120 DayPanelTimeLineItemProvider::CreateItem(int index, int itemWidth)
 121 {
 122         CustomItem* pItem = new (std::nothrow) CustomItem();
 123         pItem->Construct(Dimension(itemWidth, H_EVENT_LIST_ITEM), LIST_ANNEX_STYLE_NORMAL);
 124
 125         Bitmap* pBackgroundBitmap = ResourceManager::GetBitmapN(IDB_DAY_VIEW_TIME_LINE);
 126         Bitmap* pPressedBackgroundBitmap = ResourceManager::GetBitmapN(IDB_DAY_VIEW_TIME_LINE_PRESS);
 127         if (pBackgroundBitmap != null && pPressedBackgroundBitmap != null)
 128         {
 129                 pItem->AddElement(Rectangle(0, 0, itemWidth, H_EVENT_LIST_ITEM), 0,
 130                                                   *pBackgroundBitmap, pPressedBackgroundBitmap, pPressedBackgroundBitmap);
 131         }
 132         delete pBackgroundBitmap;
 133         delete pPressedBackgroundBitmap;
 134
 135         return pItem;
 136 }
 137
 138 bool
 139 DayPanelTimeLineItemProvider::DeleteItem(int index, ListItemBase* pItem, int itemWidth)
 140 {
 141         delete pItem;
 142         return true;
 143 }
 144
 145 class DayEventButton
 146         : public Button
 147         , public virtual IActionEventListener
 148 {
 149 public:
 150         void Initialize(int x, int width, const CalEventInstance& event, const DateTime& date, const Color calendarColor);
 151         void SetEventActionEventListener(IEventActionEventListener& listener);
 152
 153         DayEventButton(void);
 154         virtual ~DayEventButton(void);
 155
 156         virtual result OnInitializing(void);
 157         virtual result OnTerminating(void);
 158
 159         virtual void OnActionPerformed(const Control& source, int actionId);
 160 private:
 161         const CalEventInstance* __pEvent;
 162         IEventActionEventListener* __pEventActionEventListener;
 163 };
 164
 165 DayEventButton::DayEventButton(void)
 166         : __pEvent(null)
 167         , __pEventActionEventListener(null)
 168 {
 169 }
 170
 171 DayEventButton::~DayEventButton(void)
 172 {
 173 }
 174
 175 void
 176 DayEventButton::Initialize(int x, int width, const CalEventInstance& event, const DateTime& date, const Color calendarColor)
 177 {
 178         __pEvent = &event;
 179
 180         DateTime start = ResourceManager::ConvertUtcTimeToWallTime(__pEvent->GetStartTime());
 181         DateTime end = ResourceManager::ConvertUtcTimeToWallTime(__pEvent->GetEndTime());
 182
 183         int startPosition = 0;
 184         int endPosition = 0;
 185         if (EventListPresentationModel::IsSameDay(start, date))
 186         {
 187                 startPosition = start.GetHour() * H_EVENT_LIST_ITEM + start.GetMinute() * H_EVENT_LIST_ITEM / MINUTES_FOR_HOUR;
 188         }
 189         else
 190         {
 191                 startPosition = 0;
 192         }
 193
 194         if (EventListPresentationModel::IsSameDay(end, date))
 195         {
 196                 endPosition = end.GetHour() * H_EVENT_LIST_ITEM + end.GetMinute() * H_EVENT_LIST_ITEM / MINUTES_FOR_HOUR;
 197         }
 198         else
 199         {
 200                 endPosition = TIME_LINE_COUNT * H_EVENT_LIST_ITEM;
 201         }
 202
 203         int height = endPosition - startPosition - 1;
 204         if (height < H_EVENT_MIN)
 205         {
 206                 height = H_EVENT_MIN;
 207         }
 208         if (__pEvent->GetLocation().IsEmpty())
 209         {
 210                 Construct(Rectangle(x, startPosition, width, height), __pEvent->GetSubject());
 211         }
 212         else
 213         {
 214                 Construct(Rectangle(x, startPosition, width, height),
 215                                 __pEvent->GetSubject() + ((endPosition - startPosition) >= H_1_LINE_EVENT_TEXT ? L"\n" : L", ") + __pEvent->GetLocation());
 216         }
 217
 218         SetColor(BUTTON_STATUS_NORMAL, calendarColor);
 219         SetColor(BUTTON_STATUS_PRESSED, calendarColor);
 220         SetColor(BUTTON_STATUS_HIGHLIGHTED, calendarColor);
 221
 222         SetTextSize(FONT_SIZE_EVENT);
 223         Color textColor(COLOR_EVENT);
 224         SetTextColor(textColor);
 225         SetPressedTextColor(textColor);
 226         SetHighlightedTextColor(textColor);
 227 }
 228
 229 void
 230 DayEventButton::SetEventActionEventListener(IEventActionEventListener& listener)
 231 {
 232         __pEventActionEventListener = &listener;
 233 }
 234
 235 result
 236 DayEventButton::OnInitializing(void)
 237 {
 238         SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 239         SetTextVerticalAlignment(ALIGNMENT_TOP);
 240         SetActionId(IDA_DAY_PANEL_EVENT);
 241         AddActionEventListener(*this);
 242
 243         return E_SUCCESS;
 244 }
 245
 246 result
 247 DayEventButton::OnTerminating(void)
 248 {
 249         return E_SUCCESS;
 250 }
 251
 252 void
 253 DayEventButton::OnActionPerformed(const Control& source, int actionId)
 254 {
 255         if (GetParent()->GetParent()->GetControlAnimator()->GetStatus() == ANIMATOR_STATUS_PLAYING)
 256         {
 257                 // Do nothing
 258                 return;
 259         }
 260
 261         if (actionId == IDA_DAY_PANEL_EVENT && __pEventActionEventListener != null)
 262         {
 263                 __pEventActionEventListener->OnEventActionPerformed(*__pEvent, EVENT_ACTION_SELECTION);
 264         }
 265 }
 266
 267 class DayEventMoreButton
 268         : public Button
 269         , public virtual IActionEventListener
 270 {
 271 public:
 272         void AddEvent(CalEventInstance& event);
 273         void Initialize(int x, int width, const DateTime& date);
 274
 275         DayEventMoreButton(void);
 276         virtual ~DayEventMoreButton(void);
 277
 278         virtual result OnInitializing(void);
 279         virtual result OnTerminating(void);
 280
 281         virtual void OnActionPerformed(const Control& source, int actionId);
 282 private:
 283         DateTime __date;
 284         DateTime __startDate;
 285         DateTime __endDate;
 286         Bitmap* __pBitmapArrow;
 287 };
 288
 289 DayEventMoreButton::DayEventMoreButton(void)
 290         : __startDate(DateTime::GetMaxValue())
 291         , __endDate(DateTime::GetMinValue())
 292         , __pBitmapArrow(null)
 293 {
 294 }
 295
 296 DayEventMoreButton::~DayEventMoreButton(void)
 297 {
 298 }
 299
 300 void
 301 DayEventMoreButton::AddEvent(CalEventInstance& event)
 302 {
 303         DateTime start = ResourceManager::ConvertUtcTimeToWallTime(event.GetStartTime());
 304         DateTime end = ResourceManager::ConvertUtcTimeToWallTime(event.GetEndTime());
 305         if (__startDate > start)
 306         {
 307                 __startDate = start;
 308         }
 309         if (__endDate < end)
 310         {
 311                 __endDate = end;
 312         }
 313
 314         int startPosition = 0;
 315         int endPosition = 0;
 316         if (EventListPresentationModel::IsSameDay(__startDate, __date))
 317         {
 318                 startPosition = start.GetHour() * H_EVENT_LIST_ITEM + start.GetMinute() * H_EVENT_LIST_ITEM / MINUTES_FOR_HOUR;
 319         }
 320         else
 321         {
 322                 startPosition = 0;
 323         }
 324
 325         if (EventListPresentationModel::IsSameDay(__endDate, __date))
 326         {
 327                 endPosition = end.GetHour() * H_EVENT_LIST_ITEM + end.GetMinute() * H_EVENT_LIST_ITEM / MINUTES_FOR_HOUR;
 328         }
 329         else
 330         {
 331                 endPosition = TIME_LINE_COUNT * H_EVENT_LIST_ITEM;
 332         }
 333
 334         int height = endPosition - startPosition - 1;
 335         if (height < H_EVENT_MORE_BUTTON_MIN)
 336         {
 337                 height = H_EVENT_MORE_BUTTON_MIN;
 338         }
 339         SetBounds(GetX(), startPosition, GetWidth(), height);
 340
 341         if (__pBitmapArrow != null)
 342         {
 343                 Point arrowPosition((GetWidth() - __pBitmapArrow->GetWidth()) / 2, (GetHeight() - __pBitmapArrow->GetHeight()) / 2);
 344                 SetNormalBitmap(arrowPosition, *__pBitmapArrow);
 345                 SetPressedBitmap(arrowPosition, *__pBitmapArrow);
 346         }
 347 }
 348
 349 void
 350 DayEventMoreButton::Initialize(int x, int width, const DateTime& date)
 351 {
 352         Construct(Rectangle(x, 0, width, H_EVENT_MORE_BUTTON_MIN), L"");
 353         SetColor(BUTTON_STATUS_NORMAL, Color(COLOR_EVENT_MORE_BACKGROUND));
 354         SetActionId(IDA_DAY_PANEL_EVENT_MORE);
 355         AddActionEventListener(*this);
 356
 357         __date = date;
 358 }
 359
 360 result
 361 DayEventMoreButton::OnInitializing(void)
 362 {
 363         __pBitmapArrow = ResourceManager::GetBitmapN(IDB_DAY_EVENT_MORE_ARROW);
 364         Point arrowPosition((GetWidth() - __pBitmapArrow->GetWidth()) / 2, (GetHeight() - __pBitmapArrow->GetHeight()) / 2);
 365         SetNormalBitmap(arrowPosition, *__pBitmapArrow);
 366         SetPressedBitmap(arrowPosition, *__pBitmapArrow);
 367         return E_SUCCESS;
 368 }
 369
 370 result
 371 DayEventMoreButton::OnTerminating(void)
 372 {
 373         delete __pBitmapArrow;
 374         return E_SUCCESS;
 375 }
 376
 377 void
 378 DayEventMoreButton::OnActionPerformed(const Control& source, int actionId)
 379 {
 380         if (GetParent()->GetParent()->GetControlAnimator()->GetStatus() == ANIMATOR_STATUS_PLAYING)
 381         {
 382                 // Do nothing
 383                 return;
 384         }
 385
 386         if (actionId == IDA_DAY_PANEL_EVENT_MORE)
 387         {
 388                 // Go to DayEventListForm
 389                 LinkedList* pArgs = new (std::nothrow) LinkedList();
 390                 pArgs->Add(new (std::nothrow) DateTime(__startDate));
 391                 pArgs->Add(new (std::nothrow) DateTime(__endDate));
 392                 result r = SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_DAY_EVENT_LIST,
 393                                                                                                                                                                  SCENE_TRANSITION_ANIMATION_TYPE_LEFT), pArgs);
 394                 if (r != E_SUCCESS)
 395                 {
 396                         pArgs->RemoveAll(true);
 397                         delete pArgs;
 398                 }
 399         }
 400 }
 401
 402 class DayEventPanel
 403         : public Panel
 404         , public virtual IActionEventListener
 405         , public virtual IListViewItemEventListener
 406         , public virtual IListViewItemProvider
 407         , public virtual IScrollEventListener
 408 {
 409 public:
 410         const DateTime& GetDate(void) const;
 411         int GetScrollPosition(void) const;
 412         result Initialize(const Rectangle& bounds, const DateTime& date, const EventListPresentationModel& pm);
 413         void SetDate(const DateTime& date);
 414         void SetDateFocusEventListener(IDateFocusEventListener& listener);
 415         void SetEventActionEventListener(IEventActionEventListener& listener);
 416         void SetScrollEventListener(IScrollEventListener& listener);
 417         void SetScrollPosition(int scrollPosition);
 418         void UpdateEvent(void);
 419
 420         DayEventPanel(void);
 421         virtual ~DayEventPanel(void);
 422
 423         virtual void OnClearBackground(void);
 424         virtual result OnInitializing(void);
 425         virtual result OnTerminating(void);
 426
 427         virtual int GetItemCount(void);
 428         virtual ListItemBase* CreateItem(int index, int itemWidth);
 429         virtual bool DeleteItem(int index, ListItemBase* pItem, int itemWidth);
 430
 431         virtual void OnListViewItemStateChanged(ListView& listView, int index, int elementId, ListItemStatus status);
 432         virtual void OnListViewItemSwept(ListView& listView, int index, SweepDirection direction);
 433         virtual void OnListViewContextItemStateChanged(ListView& listView, int index, int elementId, ListContextItemStatus status);
 434         virtual void OnListViewItemLongPressed(ListView& listView, int index, int elementId, bool& invokeListViewItemCallback);
 435         virtual void OnListViewItemReordered(ListView& listView, int indexFrom, int indexTo);
 436
 437         virtual void OnActionPerformed(const Control& source, int actionId);
 438
 439         virtual void OnScrollEndReached(Control& source, ScrollEndEvent type);
 440         virtual void OnScrollPositionChanged(Control& source, int scrollPos);
 441
 442 private:
 443         void ArrangeEvent(void);
 444         result InitializeAllDayEventList(void);
 445         result InitializeTimeLine(void);
 446
 447         result ExpandAllDayEventList(void);
 448         result CollapseAllDayEventList(void);
 449
 450 private:
 451         DateTime __date;
 452         const EventListPresentationModel* __pPm;
 453         IDateFocusEventListener* __pDateFocusEventListener;
 454         IEventActionEventListener* __pEventActionEventListener;
 455         IScrollEventListener* __pScrollEventListener;
 456         Panel* __pPanelAllDayEvents;
 457         ListView* __pListViewAllDayEvents;
 458         Button* __pButtonAllDayEventsPanelExpander;
 459         ScrollPanel* __pPanelDayEvents;
 460         ListView* __pListViewTimeLine;
 461         DayPanelTimeLineItemProvider __timeLineItemProvider;
 462         Label* __pLabelCurrent;
 463         LinkedList __eventButtons;
 464         Label* __pLabelTime[TIME_LINE_COUNT];
 465         Label* __pLabelAm;
 466         Label* __pLabelPm;
 467         bool __is24HourEnabled;
 468 };
 469
 470 DayEventPanel::DayEventPanel(void)
 471         : __pPm(null)
 472         , __pDateFocusEventListener(null)
 473         , __pEventActionEventListener(null)
 474         , __pScrollEventListener(null)
 475         , __pPanelAllDayEvents(null)
 476         , __pListViewAllDayEvents(null)
 477         , __pButtonAllDayEventsPanelExpander(null)
 478         , __pPanelDayEvents(null)
 479         , __pListViewTimeLine(null)
 480         , __pLabelCurrent(null)
 481         , __pLabelAm(null)
 482         , __pLabelPm(null)
 483         , __is24HourEnabled(false)
 484 {
 485         memset((void *)__pLabelTime, 0, sizeof(Label*) * TIME_LINE_COUNT);
 486 }
 487
 488 DayEventPanel::~DayEventPanel(void)
 489 {
 490 }
 491
 492 const DateTime&
 493 DayEventPanel::GetDate(void) const
 494 {
 495         return __date;
 496 }
 497
 498 int
 499 DayEventPanel::GetScrollPosition(void) const
 500 {
 501         return __pPanelDayEvents->GetScrollPosition();
 502 }
 503
 504 result
 505 DayEventPanel::Initialize(const Rectangle& bounds, const DateTime& date, const EventListPresentationModel& pm)
 506 {
 507         __date = date;
 508         __pPm = &pm;
 509
 510         return Construct(bounds);
 511 }
 512
 513 void
 514 DayEventPanel::SetDate(const DateTime& date)
 515 {
 516         AppLogDebug("Enter");
 517         if (EventListPresentationModel::IsSameDay(date, __date) == false)
 518         {
 519                 __date = date;
 520                 UpdateEvent();
 521         }
 522         else
 523         {
 524                 __date = date;
 525         }
 526
 527         int currentPosition = (__date.GetHour() * MINUTES_FOR_HOUR + __date.GetMinute()) * H_EVENT_LIST_ITEM / MINUTES_FOR_HOUR;
 528         __pLabelCurrent->SetPosition(0, currentPosition - H_TIME_LINE / 2);
 529         __pLabelCurrent->Invalidate(false);
 530 }
 531
 532 void
 533 DayEventPanel::SetDateFocusEventListener(IDateFocusEventListener& listener)
 534 {
 535         __pDateFocusEventListener = &listener;
 536 }
 537
 538 void
 539 DayEventPanel::SetEventActionEventListener(IEventActionEventListener& listener)
 540 {
 541         __pEventActionEventListener = &listener;
 542 }
 543
 544 void
 545 DayEventPanel::SetScrollEventListener(IScrollEventListener& listener)
 546 {
 547         __pScrollEventListener = &listener;
 548 }
 549
 550 void
 551 DayEventPanel::SetScrollPosition(int scrollPosition)
 552 {
 553         __pPanelDayEvents->SetScrollPosition(scrollPosition);
 554 }
 555
 556 void
 557 DayEventPanel::UpdateEvent(void)
 558 {
 559         ArrangeEvent();
 560         if (GetItemCount() > 0)
 561         {
 562                 __pPanelAllDayEvents->SetShowState(true);
 563                 if (__pButtonAllDayEventsPanelExpander->GetActionId() == IDA_DAY_PANEL_ALL_DAY_EVENT_COLLAPSE)
 564                 {
 565                         int height = GetItemCount() * H_ALL_DAY_EVENT_ITEM + H_ALL_DAY_EVENT_EXPAND;
 566                         __pPanelAllDayEvents->SetSize(GetWidth(), (height > MAX_H_ALL_DAY_EVENT_LIST_PANEL) ? MAX_H_ALL_DAY_EVENT_LIST_PANEL : height);
 567                 }
 568                 __pPanelAllDayEvents->Invalidate(true);
 569                 __pListViewAllDayEvents->UpdateList();
 570                 __pPanelDayEvents->SetBounds(0, Y_EVENT_LIST_WITH_ALL_DAY_EVENTS, GetWidth(), GetHeight() - Y_EVENT_LIST_WITH_ALL_DAY_EVENTS);
 571                 __pPanelDayEvents->Invalidate(true);
 572         }
 573         else
 574         {
 575                 __pPanelAllDayEvents->SetShowState(false);
 576                 __pPanelDayEvents->SetBounds(0, 0, GetWidth(), GetHeight());
 577                 __pPanelDayEvents->Invalidate(true);
 578         }
 579 }
 580
 581 void
 582 DayEventPanel::OnClearBackground(void)
 583 {
 584         bool is24HourNotationEnabled = false;
 585         SettingInfo::GetValue(KEY_SYSTEM_24_HOUR_NOTATION_ENABLED, is24HourNotationEnabled);
 586
 587         if (is24HourNotationEnabled != __is24HourEnabled)
 588         {
 589                 __is24HourEnabled = is24HourNotationEnabled;
 590                 for (int t = AMPM_TIME_COUNT + 1; t < TIME_LINE_COUNT; ++t)
 591                 {
 592                         String time;
 593                         time.Format(3, L"%02d", (__is24HourEnabled == true) ? t : (t - 1) % AMPM_TIME_COUNT + 1);
 594                         __pLabelTime[t]->SetText(time);
 595                         __pLabelTime[t]->Invalidate(false);
 596                 }
 597                 __pLabelAm->SetShowState(__is24HourEnabled == false);
 598                 __pLabelPm->SetShowState(__is24HourEnabled == false);
 599         }
 600 }
 601
 602 result
 603 DayEventPanel::OnInitializing(void)
 604 {
 605         AppLogDebug("Enter");
 606         RelativeLayout layout;
 607         layout.Construct();
 608         __pPanelAllDayEvents = new (std::nothrow) Panel();
 609         __pPanelAllDayEvents->Construct(layout, Rectangle(0, 0, GetWidth(), MIN_H_ALL_DAY_EVENT_LIST_PANEL));
 610         __pPanelAllDayEvents->SetBackgroundColor(Color(COLOR_ALL_DAY_EVENT_LIST_PANEL_BACKGROUND));
 611         AddControl(__pPanelAllDayEvents);
 612         SetControlAlwaysOnTop(*__pPanelAllDayEvents, true);
 613
 614         InitializeAllDayEventList();
 615
 616         __pPanelDayEvents = new (std::nothrow) ScrollPanel();
 617         __pPanelDayEvents->Construct(Rectangle(0, 0, GetWidth(), GetHeight()));
 618         AddControl(__pPanelDayEvents);
 619         __pPanelDayEvents->SetScrollInputMode(SCROLL_INPUT_MODE_RESTRICT_TO_INITIAL_DIRECTION);
 620         __pPanelDayEvents->AddScrollEventListener(*this);
 621
 622         InitializeTimeLine();
 623
 624         UpdateEvent();
 625         return E_SUCCESS;
 626 }
 627
 628 result
 629 DayEventPanel::OnTerminating(void)
 630 {
 631         AppLogDebug("Enter");
 632         __pPanelDayEvents->RemoveScrollEventListener(*this);
 633         __eventButtons.RemoveAll(false);
 634         return E_SUCCESS;
 635 }
 636
 637 int
 638 DayEventPanel::GetItemCount(void)
 639 {
 640         return __pPm->GetAllDayEventCount(__date);
 641 }
 642
 643 ListItemBase*
 644 DayEventPanel::CreateItem(int index, int itemWidth)
 645 {
 646         const CalEventInstance* pEvent = __pPm->GetAllDayEvent(__date, index);
 647         TryReturn(pEvent != null, null, "[E_FAILURE] Unable to get event.");
 648
 649         CustomItem* pItem = new (std::nothrow) CustomItem();
 650         pItem->Construct(Dimension(itemWidth, H_ALL_DAY_EVENT_ITEM), LIST_ANNEX_STYLE_NORMAL);
 651
 652         Bitmap* pBitmap = new (std::nothrow) Bitmap();
 653         pBitmap->Construct(Dimension(W_EVENT_COLOR_BAR, H_EVENT_COLOR_BAR), BITMAP_PIXEL_FORMAT_ARGB8888);
 654
 655         BufferInfo bufferinfo;
 656         pBitmap->Lock(bufferinfo);
 657
 658         Canvas canvas;
 659         canvas.Construct(bufferinfo);
 660         canvas.SetBackgroundColor(__pPm->GetCalendarColor(pEvent->GetCalendarId()));
 661         canvas.Clear();
 662         pBitmap->Unlock();
 663
 664         pItem->AddElement(Rectangle(0, Y_EVENT_COLOR_BAR, W_EVENT_COLOR_BAR, H_EVENT_COLOR_BAR), 0, *pBitmap);
 665         delete pBitmap;
 666
 667         pItem->AddElement(Rectangle(X_ALL_DAY_EVENT, 0, itemWidth - X_ALL_DAY_EVENT, H_ALL_DAY_EVENT_ITEM), 1, pEvent->GetSubject(),
 668                                           FONT_SIZE_ALL_DAY_EVENT, Color(COLOR_ALL_DAY_EVENT), Color(COLOR_ALL_DAY_EVENT_FOCUS), Color(COLOR_ALL_DAY_EVENT_FOCUS));
 669
 670         return pItem;
 671 }
 672
 673 bool
 674 DayEventPanel::DeleteItem(int index, ListItemBase* pItem, int itemWidth)
 675 {
 676         delete pItem;
 677         return true;
 678 }
 679
 680 void
 681 DayEventPanel::OnListViewItemStateChanged(ListView& listView, int index, int elementId, ListItemStatus status)
 682 {
 683         if (status == LIST_ITEM_STATUS_SELECTED)
 684         {
 685                 if (&listView == __pListViewAllDayEvents)
 686                 {
 687                         if (__pEventActionEventListener != null)
 688                         {
 689                                 const CalEventInstance* pEvent = __pPm->GetAllDayEvent(__date, index);
 690                                 if (pEvent)
 691                                 {
 692                                         __pEventActionEventListener->OnEventActionPerformed(*pEvent, EVENT_ACTION_SELECTION);
 693                                 }
 694                                 else
 695                                 {
 696                                         AppLogException("EventInstance is null");
 697                                 }
 698                         }
 699                 }
 700
 701                 if (&listView == __pListViewTimeLine)
 702                 {
 703                         if (__pDateFocusEventListener != null)
 704                         {
 705                                 DateTime date;
 706                                 date.SetValue(__date.GetYear(), __date.GetMonth(), __date.GetDay(), index);
 707                                 __pDateFocusEventListener->OnDateFocused(date);
 708                         }
 709                 }
 710         }
 711 }
 712
 713 void
 714 DayEventPanel::OnListViewItemSwept(ListView& listView, int index, SweepDirection direction)
 715 {
 716 }
 717
 718 void
 719 DayEventPanel::OnListViewContextItemStateChanged(ListView& listView, int index, int elementId, ListContextItemStatus status)
 720 {
 721 }
 722
 723 void
 724 DayEventPanel::OnListViewItemLongPressed(ListView& listView, int index, int elementId, bool& invokeListViewItemCallback)
 725 {
 726 }
 727
 728 void
 729 DayEventPanel::OnListViewItemReordered(ListView& listView, int indexFrom, int indexTo)
 730 {
 731 }
 732
 733 void
 734 DayEventPanel::OnActionPerformed(const Control& source, int actionId)
 735 {
 736         switch (actionId)
 737         {
 738         case IDA_DAY_PANEL_ALL_DAY_EVENT_EXPAND:
 739                 ExpandAllDayEventList();
 740                 return;
 741         case IDA_DAY_PANEL_ALL_DAY_EVENT_COLLAPSE:
 742                 CollapseAllDayEventList();
 743                 return;
 744         }
 745
 746         if (__pEventActionEventListener != null)
 747         {
 748                 __pEventActionEventListener->OnEventActionPerformed(*__pPm->GetEvent(__date, actionId), EVENT_ACTION_SELECTION);
 749         }
 750 }
 751
 752 void
 753 DayEventPanel::OnScrollEndReached(Control& source, ScrollEndEvent type)
 754 {
 755 }
 756
 757 void
 758 DayEventPanel::OnScrollPositionChanged(Control& source, int scrollPos)
 759 {
 760         if (__pScrollEventListener != null)
 761         {
 762                 __pScrollEventListener->OnScrollPositionChanged(*this, scrollPos);
 763         }
 764 }
 765
 766 void
 767 DayEventPanel::ArrangeEvent(void)
 768 {
 769         while (__eventButtons.GetCount() > 0)
 770         {
 771                 __pPanelDayEvents->RemoveControl(static_cast<Control*>(__eventButtons.GetAt(0)));
 772                 __eventButtons.RemoveAt(0);
 773         }
 774
 775         int groupIndex = __pPm->GetGroupIndex(__date);
 776         int count = __pPm->GetEventCount(groupIndex);
 777         if (count <= 0)
 778         {
 779                 return;
 780         }
 781
 782         // Arrange columns
 783         LinkedList eventColumns[MAX_COLUMN_COUNT + 1];
 784         DateTime bottomTime[MAX_COLUMN_COUNT + 1];
 785         int maxColumns = 0;
 786         for (int i = 0; i < count; ++i)
 787         {
 788                 const CalEventInstance* pEvent = __pPm->GetEvent(groupIndex, i);
 789
 790                 DateTime startTime = ResourceManager::ConvertUtcTimeToWallTime(pEvent->GetStartTime());
 791                 DateTime endTime = ResourceManager::ConvertUtcTimeToWallTime(pEvent->GetEndTime());
 792
 793                 int col = 0;
 794                 while (bottomTime[col] > startTime && col < MAX_COLUMN_COUNT)
 795                 {
 796                         ++col;
 797                 }
 798                 eventColumns[col].Add(*pEvent);
 799
 800                 startTime.AddMinutes(30);
 801                 bottomTime[col] = (startTime > endTime) ? startTime : endTime;
 802                 if (maxColumns <= col)
 803                 {
 804                         maxColumns = col + 1;
 805                 }
 806         }
 807
 808         IEnumerator** pEnum = new (std::nothrow) IEnumerator*[maxColumns];
 809         for (int col = 0; col < maxColumns; ++col)
 810         {
 811                 pEnum[col] = eventColumns[col].GetEnumeratorN();
 812         }
 813
 814         // Create event buttons
 815         int contentWidth = GetWidth() - W_TIME_LINE;
 816         int maxEventColumns = (maxColumns > MAX_COLUMN_COUNT) ? MAX_COLUMN_COUNT : maxColumns;
 817
 818         DateTime startTime;
 819         DateTime endTime;
 820
 821         for (int col = 0; col < maxEventColumns; ++col)
 822         {
 823                 while (pEnum[col]->MoveNext() == E_SUCCESS)
 824                 {
 825                         CalEventInstance* pEvent = static_cast<CalEventInstance*>(pEnum[col]->GetCurrent());
 826
 827                         startTime = ResourceManager::ConvertUtcTimeToWallTime(pEvent->GetStartTime());
 828                         endTime = ResourceManager::ConvertUtcTimeToWallTime(pEvent->GetEndTime());
 829
 830                         int rightColumn = col + 1;
 831                         while (rightColumn < maxColumns)
 832                         {
 833                                 bool compareNextColumn = true;
 834                                 do
 835                                 {
 836                                         CalEventInstance* pRightEvent = static_cast<CalEventInstance*>(pEnum[rightColumn]->GetCurrent());
 837                                         if (pRightEvent != null)
 838                                         {
 839                                                 if (startTime >= ResourceManager::ConvertUtcTimeToWallTime(pRightEvent->GetEndTime()))
 840                                                 {
 841                                                         // do nothing
 842                                                 }
 843                                                 else if (endTime <= ResourceManager::ConvertUtcTimeToWallTime(pRightEvent->GetStartTime()))
 844                                                 {
 845                                                         break;
 846                                                 }
 847                                                 else
 848                                                 {
 849                                                         compareNextColumn = false;
 850                                                         break;
 851                                                 }
 852                                         }
 853                                 } while (pEnum[rightColumn]->MoveNext() == E_SUCCESS);
 854
 855                                 if (compareNextColumn == false)
 856                                 {
 857                                         break;
 858                                 }
 859                                 ++rightColumn;
 860                         }
 861
 862                         DayEventButton* pButton = new (std::nothrow) DayEventButton();
 863                         pButton->Initialize(W_TIME_LINE + col * contentWidth / maxColumns, (rightColumn - col) * contentWidth / maxColumns,
 864                                                                 *pEvent, __date, __pPm->GetCalendarColor(pEvent->GetCalendarId()));
 865                         __pPanelDayEvents->AddControl(pButton);
 866                         __eventButtons.Add(pButton);
 867                         if (__pEventActionEventListener != null)
 868                         {
 869                                 pButton->SetEventActionEventListener(*__pEventActionEventListener);
 870                         }
 871                 }
 872
 873                 if (col + 1 < maxEventColumns)
 874                 {
 875                         pEnum[col + 1]->Reset();
 876                 }
 877                 for (int nextCol = col + 2; nextCol < maxEventColumns; ++nextCol)
 878                 {
 879                         pEnum[nextCol]->Reset();
 880                         pEnum[nextCol]->MoveNext();
 881                 }
 882         }
 883
 884         // Create more button
 885         if (maxColumns > MAX_COLUMN_COUNT)
 886         {
 887                 DayEventMoreButton* pButton = new (std::nothrow) DayEventMoreButton();
 888                 pButton->Initialize(W_TIME_LINE + MAX_COLUMN_COUNT * contentWidth / maxColumns, contentWidth / maxColumns, __date);
 889                 pEnum[MAX_COLUMN_COUNT]->Reset();
 890                 while (pEnum[MAX_COLUMN_COUNT]->MoveNext() == E_SUCCESS)
 891                 {
 892                         pButton->AddEvent(*static_cast<CalEventInstance*>(pEnum[MAX_COLUMN_COUNT]->GetCurrent()));
 893                 }
 894                 __pPanelDayEvents->AddControl(pButton);
 895                 __eventButtons.Add(pButton);
 896         }
 897
 898         for (int col = 0; col < maxColumns; ++col)
 899         {
 900                 delete pEnum[col];
 901                 eventColumns[col].RemoveAll(false);
 902         }
 903         delete [] pEnum;
 904 }
 905
 906 result
 907 DayEventPanel::InitializeAllDayEventList(void)
 908 {
 909         Button* pButton = new (std::nothrow) Button();
 910         pButton->Construct(Rectangle(0, 0, __pPanelAllDayEvents->GetWidth(), H_ALL_DAY_EVENT_EXPAND),
 911                                                 ResourceManager::GetString(IDS_DAY_VIEW_ALL_DAY_EVENT));
 912         pButton->SetActionId(IDA_DAY_PANEL_ALL_DAY_EVENT_EXPAND);
 913         pButton->AddActionEventListener(*this);
 914         pButton->SetNormalBackgroundBitmap(*ResourceManager::GetBlankBitmap());
 915         pButton->SetPressedBackgroundBitmap(*ResourceManager::GetBlankBitmap());
 916         pButton->SetHighlightedBackgroundBitmap(*ResourceManager::GetBlankBitmap());
 917         pButton->SetTextSize(FONT_SIZE_ALL_DAY_EVENT_EXPAND);
 918         pButton->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
 919         pButton->SetTextColor(Color(COLOR_ALL_DAY_EVENT));
 920         pButton->SetPressedTextColor(Color(COLOR_ALL_DAY_EVENT));
 921         pButton->SetHighlightedTextColor(Color(COLOR_ALL_DAY_EVENT));
 922
 923         Bitmap* pBitmap = ResourceManager::GetBitmapN(IDB_ALL_DAY_EVENT_LIST_EXPAND_CLOSED);
 924         if (pBitmap != null)
 925         {
 926                 Point position(pButton->GetWidth() - W_ALL_DAY_EVENT_EXPAND_ICON_MARGIN - pBitmap->GetWidth(),
 927                                                 (H_ALL_DAY_EVENT_EXPAND - pBitmap->GetHeight()) / 2);
 928                 pButton->SetNormalBitmap(position, *pBitmap);
 929                 delete pBitmap;
 930         }
 931         Bitmap* pPressBitmap = ResourceManager::GetBitmapN(IDB_ALL_DAY_EVENT_LIST_EXPAND_CLOSED_PRESS);
 932         if (pPressBitmap != null)
 933         {
 934                 Point position(pButton->GetWidth() - W_ALL_DAY_EVENT_EXPAND_ICON_MARGIN - pPressBitmap->GetWidth(),
 935                                                 (H_ALL_DAY_EVENT_EXPAND - pPressBitmap->GetHeight()) / 2);
 936                 pButton->SetPressedBitmap(position, *pPressBitmap);
 937                 delete pPressBitmap;
 938         }
 939         __pPanelAllDayEvents->AddControl(pButton);
 940         __pButtonAllDayEventsPanelExpander = pButton;
 941
 942         ListView* pListView = new (std::nothrow) ListView();
 943         pListView->Construct(Rectangle(0, Y_ALL_DAY_EVENT_LIST, __pPanelAllDayEvents->GetWidth(), H_ALL_DAY_EVENT_ITEM), true, SCROLL_STYLE_FADE_OUT);
 944         pListView->SetItemProvider(*this);
 945         pListView->SetItemDividerColor(Color(COLOR_ALL_DAY_EVENT_LIST_LINE));
 946         pListView->AddListViewItemEventListener(*this);
 947         __pPanelAllDayEvents->AddControl(pListView);
 948         __pListViewAllDayEvents = pListView;
 949
 950         RelativeLayout* pLayout = dynamic_cast<RelativeLayout*>(__pPanelAllDayEvents->GetLayoutN());
 951         if (pLayout != null)
 952         {
 953                 pLayout->SetHorizontalFitPolicy(*__pButtonAllDayEventsPanelExpander, FIT_POLICY_PARENT);
 954                 pLayout->SetRelation(*__pButtonAllDayEventsPanelExpander, __pPanelAllDayEvents, RECT_EDGE_RELATION_LEFT_TO_LEFT);
 955                 pLayout->SetRelation(*__pButtonAllDayEventsPanelExpander, __pPanelAllDayEvents, RECT_EDGE_RELATION_RIGHT_TO_RIGHT);
 956                 pLayout->SetRelation(*__pButtonAllDayEventsPanelExpander, __pPanelAllDayEvents, RECT_EDGE_RELATION_TOP_TO_TOP);
 957                 pLayout->SetHeight(*__pButtonAllDayEventsPanelExpander, H_ALL_DAY_EVENT_EXPAND);
 958                 pLayout->SetHorizontalFitPolicy(*__pListViewAllDayEvents, FIT_POLICY_PARENT);
 959                 pLayout->SetRelation(*__pListViewAllDayEvents, __pPanelAllDayEvents, RECT_EDGE_RELATION_LEFT_TO_LEFT);
 960                 pLayout->SetRelation(*__pListViewAllDayEvents, __pPanelAllDayEvents, RECT_EDGE_RELATION_RIGHT_TO_RIGHT);
 961                 pLayout->SetRelation(*__pListViewAllDayEvents, __pPanelAllDayEvents, RECT_EDGE_RELATION_BOTTOM_TO_BOTTOM);
 962                 pLayout->SetRelation(*__pListViewAllDayEvents, __pButtonAllDayEventsPanelExpander, RECT_EDGE_RELATION_TOP_TO_BOTTOM);
 963         }
 964
 965         return E_SUCCESS;
 966 }
 967
 968 result
 969 DayEventPanel::InitializeTimeLine(void)
 970 {
 971         SettingInfo::GetValue(KEY_SYSTEM_24_HOUR_NOTATION_ENABLED, __is24HourEnabled);
 972         for (int t = 1; t < TIME_LINE_COUNT; ++t)
 973         {
 974                 String time;
 975                 time.Format(3, L"%02d", (__is24HourEnabled == true) ? t : (t - 1) % AMPM_TIME_COUNT + 1);
 976
 977                 __pLabelTime[t] = new (std::nothrow) Label();
 978                 __pLabelTime[t]->Construct(Rectangle(X_TIME_LINE_NUMBER, H_EVENT_LIST_ITEM * t - H_TIME_LINE_NUMBER / 2, W_TIME_LINE_NUMBER, H_TIME_LINE_NUMBER),
 979                                                  time);
 980                 __pLabelTime[t]->SetTextConfig(FONT_SIZE_TIME_LINE_NUMBER, LABEL_TEXT_STYLE_NORMAL);
 981                 __pLabelTime[t]->SetTextColor(Color(COLOR_TIME_LINE_NUMBER));
 982                 __pPanelDayEvents->AddControl(__pLabelTime[t]);
 983         }
 984
 985         __pLabelAm = new (std::nothrow) Label();
 986         __pLabelAm->Construct(Rectangle(X_TIME_LINE_AMPM, 0, W_TIME_LINE_AMPM, H_TIME_LINE_AMPM),
 987                                                 ResourceManager::GetAmPmString(true));
 988         __pLabelAm->SetTextConfig(FONT_SIZE_TIME_LINE_AMPM, LABEL_TEXT_STYLE_NORMAL);
 989         __pLabelAm->SetTextColor(Color(COLOR_TIME_LINE_AMPM));
 990         __pPanelDayEvents->AddControl(__pLabelAm);
 991         __pLabelAm->SetShowState(__is24HourEnabled == false);
 992
 993         __pLabelPm = new (std::nothrow) Label();
 994         __pLabelPm->Construct(Rectangle(X_TIME_LINE_AMPM, H_EVENT_LIST_ITEM * AMPM_TIME_COUNT + H_TIME_LINE_NUMBER / 2, W_TIME_LINE_AMPM, H_TIME_LINE_AMPM),
 995                                                 ResourceManager::GetAmPmString(false));
 996         __pLabelPm->SetTextConfig(FONT_SIZE_TIME_LINE_AMPM, LABEL_TEXT_STYLE_NORMAL);
 997         __pLabelPm->SetTextColor(Color(COLOR_TIME_LINE_AMPM));
 998         __pPanelDayEvents->AddControl(__pLabelPm);
 999         __pLabelPm->SetShowState(__is24HourEnabled == false);
1000
1001         // Draw current time
1002         Dimension size = GetSize();
1003         size.height = H_TIME_LINE;
1004         Label* pLabelTimeLine = new (std::nothrow) Label();
1005         int currentPosition = (__date.GetHour() * MINUTES_FOR_HOUR + __date.GetMinute()) * H_EVENT_LIST_ITEM / MINUTES_FOR_HOUR;
1006         pLabelTimeLine->Construct(Rectangle(0, currentPosition - size.height / 2, size.width, size.height), L"");
1007
1008         Bitmap* pBitmap = new (std::nothrow) Bitmap();
1009         pBitmap->Construct(size, BITMAP_PIXEL_FORMAT_ARGB8888);
1010
1011         BufferInfo bufferinfo;
1012         pBitmap->Lock(bufferinfo);
1013
1014         Canvas canvas;
1015         canvas.Construct(bufferinfo);
1016         canvas.SetBackgroundColor(Color(COLOR_EVENT_PANEL_BACKGROUND));
1017         canvas.Clear();
1018         canvas.FillRectangle(Color(COLOR_CURRENT_TIME_LINE),
1019                                                  Rectangle(W_TIME_LINE, (size.height - H_CURRENT_TIME_LINE) / 2,
1020                                                                    size.width - W_TIME_LINE, H_CURRENT_TIME_LINE));
1021
1022         Bitmap* pArrowBitmap = ResourceManager::GetBitmapN(IDB_DAY_CURRENT_TIME);
1023         if (pArrowBitmap != null)
1024         {
1025                 canvas.DrawBitmap(Rectangle(X_CURRENT_TIME_ARROW, (size.height - pArrowBitmap->GetHeight()) / 2,
1026                                                                         pArrowBitmap->GetWidth(), pArrowBitmap->GetHeight()), *pArrowBitmap);
1027                 delete pArrowBitmap;
1028         }
1029         pBitmap->Unlock();
1030         pLabelTimeLine->SetBackgroundBitmap(*pBitmap);
1031         delete pBitmap;
1032
1033         __pPanelDayEvents->AddControl(pLabelTimeLine);
1034         __pLabelCurrent = pLabelTimeLine;
1035         __pPanelDayEvents->SetControlAlwaysAtBottom(*__pLabelCurrent, true);
1036         __pPanelDayEvents->SetScrollPosition(currentPosition - __pPanelDayEvents->GetHeight() / 2);
1037
1038         // Create time line
1039         __pListViewTimeLine = new (std::nothrow) ListView();
1040         __pListViewTimeLine->Construct(Rectangle(W_TIME_LINE, 0,
1041                                                                                            GetWidth() - W_TIME_LINE, H_EVENT_LIST_ITEM * TIME_LINE_COUNT),
1042                                                                          false, SCROLL_STYLE_FADE_OUT);
1043         __pListViewTimeLine->SetItemProvider(__timeLineItemProvider);
1044         __pListViewTimeLine->AddListViewItemEventListener(*this);
1045         __pPanelDayEvents->AddControl(__pListViewTimeLine);
1046
1047         return E_SUCCESS;
1048 }
1049
1050 result
1051 DayEventPanel::ExpandAllDayEventList(void)
1052 {
1053         Bitmap* pBitmap = ResourceManager::GetBitmapN(IDB_ALL_DAY_EVENT_LIST_EXPAND_OPENED);
1054         if (pBitmap != null)
1055         {
1056                 Point position(__pButtonAllDayEventsPanelExpander->GetWidth() - W_ALL_DAY_EVENT_EXPAND_ICON_MARGIN - pBitmap->GetWidth(),
1057                                                 (H_ALL_DAY_EVENT_EXPAND - pBitmap->GetHeight()) / 2);
1058                 __pButtonAllDayEventsPanelExpander->SetNormalBitmap(position, *pBitmap);
1059                 delete pBitmap;
1060         }
1061         Bitmap* pPressBitmap = ResourceManager::GetBitmapN(IDB_ALL_DAY_EVENT_LIST_EXPAND_OPENED_PRESS);
1062         if (pPressBitmap != null)
1063         {
1064                 Point position(__pButtonAllDayEventsPanelExpander->GetWidth() - W_ALL_DAY_EVENT_EXPAND_ICON_MARGIN - pPressBitmap->GetWidth(),
1065                                                 (H_ALL_DAY_EVENT_EXPAND - pPressBitmap->GetHeight()) / 2);
1066                 __pButtonAllDayEventsPanelExpander->SetPressedBitmap(position, *pPressBitmap);
1067                 delete pPressBitmap;
1068         }
1069         __pButtonAllDayEventsPanelExpander->SetActionId(IDA_DAY_PANEL_ALL_DAY_EVENT_COLLAPSE);
1070
1071         int height = GetItemCount() * H_ALL_DAY_EVENT_ITEM + H_ALL_DAY_EVENT_EXPAND;
1072         __pPanelAllDayEvents->SetSize(GetWidth(), (height > MAX_H_ALL_DAY_EVENT_LIST_PANEL) ? MAX_H_ALL_DAY_EVENT_LIST_PANEL : height);
1073         __pPanelAllDayEvents->Invalidate(true);
1074         return E_SUCCESS;
1075 }
1076
1077 result
1078 DayEventPanel::CollapseAllDayEventList(void)
1079 {
1080         Bitmap* pBitmap = ResourceManager::GetBitmapN(IDB_ALL_DAY_EVENT_LIST_EXPAND_CLOSED);
1081         if (pBitmap != null)
1082         {
1083                 Point position(__pButtonAllDayEventsPanelExpander->GetWidth() - W_ALL_DAY_EVENT_EXPAND_ICON_MARGIN - pBitmap->GetWidth(),
1084                                                 (H_ALL_DAY_EVENT_EXPAND - pBitmap->GetHeight()) / 2);
1085                 __pButtonAllDayEventsPanelExpander->SetNormalBitmap(position, *pBitmap);
1086                 delete pBitmap;
1087         }
1088         Bitmap* pPressBitmap = ResourceManager::GetBitmapN(IDB_ALL_DAY_EVENT_LIST_EXPAND_CLOSED_PRESS);
1089         if (pPressBitmap != null)
1090         {
1091                 Point position(__pButtonAllDayEventsPanelExpander->GetWidth() - W_ALL_DAY_EVENT_EXPAND_ICON_MARGIN - pPressBitmap->GetWidth(),
1092                                                 (H_ALL_DAY_EVENT_EXPAND - pPressBitmap->GetHeight()) / 2);
1093                 __pButtonAllDayEventsPanelExpander->SetPressedBitmap(position, *pPressBitmap);
1094                 delete pPressBitmap;
1095         }
1096         __pButtonAllDayEventsPanelExpander->SetActionId(IDA_DAY_PANEL_ALL_DAY_EVENT_EXPAND);
1097         __pPanelAllDayEvents->SetSize(GetWidth(), MIN_H_ALL_DAY_EVENT_LIST_PANEL);
1098         __pPanelAllDayEvents->Invalidate(true);
1099         return E_SUCCESS;
1100 }
1101
1102
1103 DayPanel::DayPanel(void)
1104         : __pPm(null)
1105         , __pPanningAnimationManager(null)
1106         , __pGoToDatePopup(null)
1107 {
1108         memset((void *)__pPanelDayEvent, 0, sizeof(Panel*) * VIEW_SCROLL_EFFECT_COUNT);
1109 }
1110
1111 DayPanel::~DayPanel(void)
1112 {
1113 }
1114
1115 result
1116 DayPanel::Initialize(void)
1117 {
1118         static const int _MIN_SIZE = 1;
1119         return Construct(Rectangle(0, 0, _MIN_SIZE, _MIN_SIZE));
1120 }
1121
1122 result
1123 DayPanel::OnInitializing(void)
1124 {
1125         AppLogDebug("Enter");
1126         __pPm = EventListPresentationModel::GetInstance();
1127
1128         Form* pForm = dynamic_cast<Form*>(GetParent());
1129         AppAssertf(pForm != null, "[E_FAILURE] Unable to get Form.");
1130
1131         Rectangle bounds = pForm->GetClientAreaBounds();
1132         bounds.x = 0;
1133         bounds.y = 0;
1134         SetBounds(bounds);
1135
1136         // Create panning animation manager
1137         __pPanningAnimationManager = new (std::nothrow) PanningAnimationManager();
1138         __pPanningAnimationManager->Initialize(bounds, *this);
1139         __pPanningAnimationManager->SetPanningAnimationEventListener(*this);
1140         AddControl(__pPanningAnimationManager);
1141
1142         DayEventPanel* pPanel = new (std::nothrow) DayEventPanel();
1143         pPanel->Initialize(bounds, __pPm->GetCurrentDate(), *__pPm);
1144         pPanel->SetEventActionEventListener(*this);
1145         __pPanningAnimationManager->AddView(*pPanel, VIEW_SCROLL_EFFECT_CURRENT);
1146         pPanel->SetDateFocusEventListener(*this);
1147         pPanel->SetScrollEventListener(*this);
1148         __pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT] = pPanel;
1149
1150         __pGoToDatePopup = new (std::nothrow) GoToDatePopup();
1151         __pGoToDatePopup->Initialize();
1152
1153         return E_SUCCESS;
1154 }
1155
1156 result
1157 DayPanel::OnTerminating(void)
1158 {
1159         AppLogDebug("Enter");
1160         __pPm->RemoveCalendarEventChangedEventListener(*this);
1161         __pPm->RemoveCurrentDateChangedEventListener(*this);
1162
1163         if (__pGoToDatePopup)
1164         {
1165                 __pGoToDatePopup->Destroy();
1166         }
1167
1168         return E_SUCCESS;
1169 }
1170
1171 void
1172 DayPanel::OnUserEventReceivedN(RequestId requestId, IList* pArgs)
1173 {
1174         switch (requestId)
1175         {
1176         case IDA_MAIN_FORM_HEADER_TODAY:
1177                 __pPanningAnimationManager->CancelPanningAnimationEvent();
1178                 __pPm->SetTodayToCurrentDate();
1179                 break;
1180         case IDA_SUB_MENU_GO_TO_DATE:
1181                 __pGoToDatePopup->RequestPopup(__pPm->GetCurrentDate(), this);
1182                 break;
1183         case IDA_MAIN_FORM_FOOTER_CREATE:
1184         {
1185                 LinkedList* pArgs = new (std::nothrow) LinkedList();
1186                 pArgs->Add(new (std::nothrow) DateTime(__pPm->GetCurrentDate()));
1187                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_EVENT_EDITOR,
1188                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT), pArgs);
1189                 break;
1190         }
1191         case IDA_SUB_MENU_DELETE:
1192                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_EVENT_DELETER,
1193                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT));
1194                 break;
1195         case IDA_SUB_MENU_SEARCH:
1196                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_EVENT_SEARCHER,
1197                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT));
1198                 break;
1199         case IDA_SUB_MENU_CALENDARS:
1200                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_CALENDAR_LIST,
1201                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT));
1202                 break;
1203         case IDA_SUB_MENU_SETTING:
1204                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_SETTING,
1205                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT));
1206                 break;
1207         case IDA_VIEW_MENU_YEAR:
1208                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_YEAR,
1209                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT,
1210                                                                                                                                           SCENE_HISTORY_OPTION_NO_HISTORY));
1211                 break;
1212         case IDA_VIEW_MENU_MONTH:
1213                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_MONTH,
1214                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT,
1215                                                                                                                                           SCENE_HISTORY_OPTION_NO_HISTORY));
1216                 break;
1217         case IDA_VIEW_MENU_LIST:
1218                 SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_LIST,
1219                                                                                                                                           SCENE_TRANSITION_ANIMATION_TYPE_LEFT,
1220                                                                                                                                           SCENE_HISTORY_OPTION_NO_HISTORY));
1221                 break;
1222         case IDA_GO_TO_DATE_POPUP_DONE:
1223         {
1224                 DateTime selectedDate = *static_cast<DateTime*>(pArgs->GetAt(0));
1225                 DateTime currentDate = __pPm->GetCurrentDate();
1226                 currentDate.SetValue(selectedDate.GetYear(), selectedDate.GetMonth(), selectedDate.GetDay(), currentDate.GetHour(), currentDate.GetMinute());
1227                 __pPm->SetCurrentDate(currentDate);
1228                 break;
1229         }
1230         }
1231
1232         if (pArgs != null)
1233         {
1234                 pArgs->RemoveAll(true);
1235                 delete pArgs;
1236         }
1237 }
1238
1239 void
1240 DayPanel::OnScrollEndReached(Control& source, ScrollEndEvent type)
1241 {
1242 }
1243
1244 void
1245 DayPanel::OnScrollPositionChanged(Control& source, int scrollPos)
1246 {
1247         for (int i = VIEW_SCROLL_EFFECT_CURRENT; i < VIEW_SCROLL_EFFECT_COUNT; ++i)
1248         {
1249                 if (&source != __pPanelDayEvent[i] && __pPanelDayEvent[i] != null)
1250                 {
1251                         static_cast<DayEventPanel*>(__pPanelDayEvent[i])->SetScrollPosition(scrollPos);
1252                 }
1253         }
1254 }
1255
1256 void
1257 DayPanel::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
1258 {
1259         AppLogDebug("Enter.");
1260         if (pArgs)
1261         {
1262                 pArgs->RemoveAll(true);
1263                 delete pArgs;
1264         }
1265
1266         __pPm->SetViewType(VIEW_TYPE_DAILY);
1267         DayEventPanel* pCurrent = static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT]);
1268         if (EventListPresentationModel::IsSameDay(pCurrent->GetDate(), __pPm->GetCurrentDate()))
1269         {
1270                 pCurrent->UpdateEvent();
1271         }
1272
1273         DateTime maxDateTime = Calendarbook::GetMaxDateTime();
1274         maxDateTime.AddYears(-1);
1275         DateTime minDateTime = Calendarbook::GetMinDateTime();
1276         minDateTime.AddYears(1);
1277         for (int i = VIEW_SCROLL_EFFECT_NEXT; i < VIEW_SCROLL_EFFECT_COUNT; ++i)
1278         {
1279                 if (!__pPanelDayEvent[i])
1280                 {
1281                         DayEventPanel* pPanel = new (std::nothrow) DayEventPanel();
1282                         DateTime date = __pPm->GetCurrentDate();
1283                         switch (i)
1284                         {
1285                         case VIEW_SCROLL_EFFECT_NEXT:
1286                                 date.AddDays(1);
1287                                 if (date > maxDateTime)
1288                                 {
1289                                         DateTime minDate = minDateTime;
1290                                         date.SetValue(minDate.GetYear(), minDate.GetMonth(), minDate.GetDay(), date.GetHour(), date.GetMinute());
1291                                 }
1292                                 pPanel->Initialize(Rectangle(0, 0, GetWidth(), GetHeight()), date, *__pPm);
1293                                 break;
1294                         case VIEW_SCROLL_EFFECT_PREVIEW:
1295                                 date.AddDays(-1);
1296                                 if (date < minDateTime)
1297                                 {
1298                                         DateTime maxDate = maxDateTime;
1299                                         date.SetValue(maxDate.GetYear(), maxDate.GetMonth(), maxDate.GetDay(), date.GetHour(), date.GetMinute());
1300                                 }
1301                                 pPanel->Initialize(Rectangle(0, 0, GetWidth(), GetHeight()), date, *__pPm);
1302                                 break;
1303                         }
1304                         pPanel->SetEventActionEventListener(*this);
1305                         __pPanningAnimationManager->AddView(*pPanel, (ViewScrollEffect)i);
1306                         pPanel->SetDateFocusEventListener(*this);
1307                         pPanel->SetScrollEventListener(*this);
1308                         __pPanelDayEvent[i] = pPanel;
1309                 }
1310                 else
1311                 {
1312                         static_cast<DayEventPanel*>(__pPanelDayEvent[i])->UpdateEvent();
1313                 }
1314         }
1315
1316         __pPm->AddCalendarEventChangedEventListener(*this);
1317         __pPm->AddCurrentDateChangedEventListener(*this);
1318
1319         __pPanningAnimationManager->ResetPosition();
1320         Update(true);
1321
1322         AppLogDebug("Exit.");
1323 }
1324
1325 void
1326 DayPanel::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
1327 {
1328         AppLogDebug("Enter.");
1329         __pPm->RemoveCalendarEventChangedEventListener(*this);
1330         __pPm->RemoveCurrentDateChangedEventListener(*this);
1331
1332         if (nextSceneId == IDSCN_YEAR || nextSceneId == IDSCN_MONTH || nextSceneId == IDSCN_LIST)
1333         {
1334                 __pPanningAnimationManager->RemoveView(VIEW_SCROLL_EFFECT_NEXT);
1335                 __pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT] = null;
1336                 __pPanningAnimationManager->RemoveView(VIEW_SCROLL_EFFECT_PREVIEW);
1337                 __pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW] = null;
1338         }
1339 }
1340
1341 void
1342 DayPanel::OnCalendarEventChanged(void)
1343 {
1344         AppLogDebug("Enter.");
1345         static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT])->UpdateEvent();
1346         static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT])->UpdateEvent();
1347         static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW])->UpdateEvent();
1348 }
1349
1350 void
1351 DayPanel::OnCurrentDateChanged(const DateTime& currentDate, const DateTime& prevDate)
1352 {
1353         AppLogDebug("Enter.");
1354         DateTime currentCalendarDate = static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT])->GetDate();
1355         Update(!EventListPresentationModel::IsSameDay(currentDate, currentCalendarDate));
1356         AppLogDebug("Exit.");
1357 }
1358
1359 void
1360 DayPanel::OnDateFocused(const DateTime& focusedDate)
1361 {
1362         __pPanningAnimationManager->CancelPanningAnimationEvent();
1363         Invalidate(true);
1364
1365         LinkedList* pArgs = new (std::nothrow) LinkedList();
1366         DateTime* pDateTime = new (std::nothrow) DateTime(focusedDate);
1367         pDateTime->AddMinutes(-1);
1368         pArgs->Add(pDateTime);
1369         result r = SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_EVENT_EDITOR,
1370                                                                                                                                                          SCENE_TRANSITION_ANIMATION_TYPE_LEFT), pArgs);
1371         if (r != E_SUCCESS)
1372         {
1373                 pArgs->RemoveAll(true);
1374                 delete pArgs;
1375         }
1376 }
1377
1378 void
1379 DayPanel::OnEventActionPerformed(const CalEventInstance& event, EventAction actionId)
1380 {
1381         if (actionId == EVENT_ACTION_SELECTION)
1382         {
1383                 __pPanningAnimationManager->CancelPanningAnimationEvent();
1384                 Invalidate(true);
1385
1386                 LinkedList* pArgs = new (std::nothrow) LinkedList();
1387                 pArgs->Add(new (std::nothrow) CalEventInstance(event));
1388                 result r = SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_EVENT_DETAILS,
1389                                                                                                                                                                  SCENE_TRANSITION_ANIMATION_TYPE_LEFT), pArgs);
1390                 if (r != E_SUCCESS)
1391                 {
1392                         pArgs->RemoveAll(true);
1393                         delete pArgs;
1394                 }
1395         }
1396 }
1397
1398 Control*
1399 DayPanel::GetCurrentControl(void)
1400 {
1401         return __pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT];
1402 }
1403
1404 Control*
1405 DayPanel::GetNextControl(void)
1406 {
1407         return __pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT];
1408 }
1409
1410 Control*
1411 DayPanel::GetPreviewControl(void)
1412 {
1413         return __pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW];
1414 }
1415
1416 void
1417 DayPanel::OnPanningAnimationEnded(ViewScrollEffect direction)
1418 {
1419         DateTime maxDateTime = Calendarbook::GetMaxDateTime();
1420         maxDateTime.AddYears(-1);
1421         DateTime minDateTime = Calendarbook::GetMinDateTime();
1422         minDateTime.AddYears(1);
1423         if (__pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT] != null && __pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW] != null)
1424         {
1425                 if (direction == VIEW_SCROLL_EFFECT_PREVIEW)
1426                 {
1427                         DayEventPanel* pPanel = static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT]);
1428                         DateTime date = __pPm->GetCurrentDate();
1429                         date.AddDays(-2);
1430                         if (date < minDateTime)
1431                         {
1432                                 DateTime maxDate = maxDateTime;
1433                                 date.SetValue(maxDate.GetYear(), maxDate.GetMonth(), maxDate.GetDay(), date.GetHour(), date.GetMinute());
1434                         }
1435                         pPanel->SetDate(date);
1436                         pPanel->RequestRedraw(false);
1437
1438                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT] = __pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT];
1439                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT] = __pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW];
1440                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW] = pPanel;
1441                 }
1442                 else if (direction == VIEW_SCROLL_EFFECT_NEXT)
1443                 {
1444                         DayEventPanel* pPanel = static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW]);
1445                         DateTime date = __pPm->GetCurrentDate();
1446                         date.AddDays(2);
1447                         if (date > maxDateTime)
1448                         {
1449                                 DateTime minDate = minDateTime;
1450                                 date.SetValue(minDate.GetYear(), minDate.GetMonth(), minDate.GetDay(), date.GetHour(), date.GetMinute());
1451                         }
1452                         pPanel->SetDate(date);
1453                         pPanel->RequestRedraw(false);
1454
1455                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW] = __pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT];
1456                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT] = __pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT];
1457                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT] = pPanel;
1458                 }
1459         }
1460         __pPm->SetCurrentDate(static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT])->GetDate());
1461 }
1462
1463 void
1464 DayPanel::DrawCurrentDate(void)
1465 {
1466         Form* pForm = dynamic_cast<Form*>(GetParent());
1467         if (pForm != null)
1468         {
1469                 Header* pHeader = pForm->GetHeader();
1470                 if (pHeader != null)
1471                 {
1472                         pHeader->SetTitleText(__pPm->GetDateString(__pPm->GetCurrentDate()));
1473                         pHeader->Invalidate(false);
1474                 }
1475         }
1476 }
1477
1478 void
1479 DayPanel::DrawEvents(void)
1480 {
1481         DayEventPanel* pPanel = static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT]);
1482         DateTime date = pPanel->GetDate();
1483         pPanel->SetDate(__pPm->GetCurrentDate());
1484
1485         DateTime maxDateTime = Calendarbook::GetMaxDateTime();
1486         maxDateTime.AddYears(-1);
1487         DateTime minDateTime = Calendarbook::GetMinDateTime();
1488         minDateTime.AddYears(1);
1489
1490         DayEventPanel* pNextPanel = static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT]);
1491         if (pNextPanel != null)
1492         {
1493                 date = pNextPanel->GetDate();
1494                 DateTime nextDate = __pPm->GetCurrentDate();
1495                 nextDate.AddDays(1);
1496                 if (nextDate > maxDateTime)
1497                 {
1498                         DateTime minDate = minDateTime;
1499                         nextDate.SetValue(minDate.GetYear(), minDate.GetMonth(), minDate.GetDay(), nextDate.GetHour(), nextDate.GetMinute());
1500                 }
1501                 pNextPanel->SetDate(nextDate);
1502         }
1503
1504         DayEventPanel* pPrevPanel = static_cast<DayEventPanel*>(__pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW]);
1505         if (pPrevPanel != null)
1506         {
1507                 date = pPrevPanel->GetDate();
1508                 DateTime prevDate = __pPm->GetCurrentDate();
1509                 prevDate.AddDays(-1);
1510                 if (prevDate < minDateTime)
1511                 {
1512                         DateTime maxDate = maxDateTime;
1513                         prevDate.SetValue(maxDate.GetYear(), maxDate.GetMonth(), maxDate.GetDay(), prevDate.GetHour(), prevDate.GetMinute());
1514                 }
1515                 pPrevPanel->SetDate(prevDate);
1516         }
1517 }
1518
1519 void
1520 DayPanel::Update(bool draw)
1521 {
1522         DrawCurrentDate();
1523         DrawEvents();
1524
1525         if (draw == true)
1526         {
1527                 __pPanelDayEvent[VIEW_SCROLL_EFFECT_CURRENT]->Invalidate(true);
1528                 if (__pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT] != null)
1529                 {
1530                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_NEXT]->RequestRedraw(false);
1531                 }
1532                 if (__pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW] != null)
1533                 {
1534                         __pPanelDayEvent[VIEW_SCROLL_EFFECT_PREVIEW]->RequestRedraw(false);
1535                 }
1536         }
1537 }