src/ClEventEditorForm.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        ClEventEditorForm.cpp
  19  * @brief       This is the implementation file for the EventEditorForm class.
  20  */
  21
  22 #include <FBase.h>
  23 #include <FSystem.h>
  24 #include "ClCalendarApp.h"
  25 #include "ClCalendarSelectorPopup.h"
  26 #include "ClEventEditorForm.h"
  27 #include "ClEventPresentationModel.h"
  28 #include "ClResourceManager.h"
  29 #include "ClTypes.h"
  30
  31 using namespace Tizen::App;
  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 enum
  43 {
  44         GROUP_TITLE_CONTENT = 0,
  45         GROUP_DATE_SELECTOR,
  46         GROUP_INFORMATION_CONTENT,
  47         GROUP_ADDITIONAL_CONTENT,
  48         GROUP_SAVE_TO,
  49         GROUP_COUNT,
  50
  51         TITLE_CONTENT_ITEM_TITLE = 0,
  52         TITLE_CONTENT_ITEM_COUNT,
  53
  54         FROM_DATE_SELECTOR_ITEM_START = 0,
  55         TO_DATE_SELECTOR_ITEM_END,
  56 //      DATE_SELECTOR_ITEM_TIME_ZONE = 0,
  57         DATE_SELECTOR_ITEM_ALL_DAY_EVENT,
  58         DATE_SELECTOR_ITEM_COUNT,
  59
  60         INFORMATION_CONTENT_ITEM_DESCRIPTION = 0,
  61         INFORMATION_CONTENT_ITEM_LOCATION,
  62         INFORMATION_CONTENT_ITEM_COUNT,
  63
  64         ADDITIONAL_CONTENT_ITEM_REMINDER = 0,
  65         ADDITIONAL_CONTENT_ITEM_REMINDER2,
  66         ADDITIONAL_CONTENT_ITEM_REMINDER3,
  67         ADDITIONAL_CONTENT_ITEM_REMINDER4,
  68         ADDITIONAL_CONTENT_ITEM_REMINDER5,
  69         ADDITIONAL_CONTENT_ITEM_REPEAT,
  70         ADDITIONAL_CONTENT_ITEM_COUNT,
  71
  72         SAVE_TO_ITEM_SAVE_TO = 0,
  73         SAVE_TO_ITEM_COUNT
  74 };
  75
  76 static const int IDA_EVENT_EDITOR_FORM_SAVE = 20001;
  77 static const int IDA_EVENT_EDITOR_FORM_CANCEL = 20002;
  78 static const int IDA_EVENT_EDITOR_FORM_ADD_REMINDER = 20100;
  79 static const int IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER = 20101;
  80 static const int IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER2 = 20102;
  81 static const int IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER3 = 20103;
  82 static const int IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER4 = 20104;
  83 static const int IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER5 = 20105;
  84
  85 static const int H_ITEM = 112;
  86 static const int H_ITEM_2LINE = 136;
  87 static const int Y_ITEM_CONTENT01 = 22;
  88 static const int H_ITEM_CONTENT01 = 38;
  89 static const int Y_ITEM_CONTENT02 = 60;
  90 static const int H_ITEM_CONTENT02 = 54;
  91 static const int X_DATE_SELECTOR = 340;
  92 static const int Y_DATE_SELECTOR = 0;
  93 static const int H_DESCRIPTION = 80;
  94 static const int W_REMINDER_ADD_BUTTON = 74;
  95 static const int W_REMINDER_ADD_BUTTON_MARGIN = 94;
  96 static const int H_REMINDER_ADD_BUTTON = 74;
  97 static const int W_REMINDER_DELETE_BUTTON = 74;
  98 static const int W_REMINDER_DELETE_BUTTON_MARGIN = 184;
  99 static const int H_REMINDER_DELETE_BUTTON = 74;
 100 static const int FONT_SIZE_DETAIL02 = 32;
 101 static const unsigned int COLOR_DETAIL02 = Color32<128, 128, 128>::Value;
 102 static const int FONT_SIZE_DETAIL03 = 44;
 103 static const unsigned int COLOR_DISABLE = Color32<58, 58, 58, 77>::Value;
 104
 105 static const int EXPANDABLE_EDIT_MAX_LINE = 10;
 106 static const int EDITFIELD_LIMIT_LENGTH = 500;
 107
 108 EventEditorForm::EventEditorForm(void)
 109         : __pPm(null)
 110         , __style(EDIT_EVENT_FORM_STYLE_CREATE)
 111         , __pTableView(null)
 112         , __pEditFieldTitle(null)
 113         , __pEditFieldLocation(null)
 114         , __pEditDateStartDate(null)
 115         , __pEditTimeStartTime(null)
 116         , __pEditDateEndDate(null)
 117         , __pEditTimeEndTime(null)
 118 //      , __pLabelTimeZone(null)
 119         , __pLabelRepeat(null)
 120         , __pTableViewItemNote(null)
 121         , __pExpandableEditAreaNote(null)
 122         , __pLabelSaveTo(null)
 123         , __pButtonAddReminer(null)
 124         , __pButtonDeleteReminder(null)
 125         , __pCalendarSelectorPopup(null)
 126 {
 127         memset(__pLabelReminder, 0, sizeof(Label*) * MAX_COUNT_OF_REMINDER);
 128         memset(__pItemReminder, 0, sizeof(TableViewItem*) * MAX_COUNT_OF_REMINDER);
 129 }
 130
 131 EventEditorForm::~EventEditorForm(void)
 132 {
 133 }
 134
 135 result
 136 EventEditorForm::Initialize(void)
 137 {
 138         return Construct(L"IDL_EVENT_EDITOR_FORM");
 139 }
 140
 141 result
 142 EventEditorForm::OnInitializing(void)
 143 {
 144         __pPm = new (std::nothrow) EventPresentationModel();
 145         __pPm->Construct();
 146
 147         Footer* pFooter = GetFooter();
 148         pFooter->AddActionEventListener(*this);
 149
 150         SetFormBackEventListener(this);
 151
 152         __pTableView = dynamic_cast<SectionTableView*>(GetControl(L"IDC_SECTIONTABLEVIEW"));
 153         TryReturn(__pTableView != null, E_FAILURE, "[E_FAILURE] Unable to get sectiontableview.");
 154         __pTableView->SetItemProvider(this);
 155         __pTableView->AddSectionTableViewItemEventListener(*this);
 156         __pTableView->SetGroupedLookEnabled(true);
 157
 158         __pCalendarSelectorPopup = new (std::nothrow) CalendarSelectorPopup();
 159         __pCalendarSelectorPopup->Initialize();
 160
 161         return E_SUCCESS;
 162 }
 163
 164 result
 165 EventEditorForm::OnTerminating(void)
 166 {
 167         delete __pPm;
 168         if (__pCalendarSelectorPopup != null)
 169         {
 170                 __pCalendarSelectorPopup->Destroy();
 171         }
 172         return E_SUCCESS;
 173 }
 174
 175 void
 176 EventEditorForm::OnUserEventReceivedN(RequestId requestId, Tizen::Base::Collection::IList* pArgs)
 177 {
 178         switch (requestId)
 179         {
 180         case IDA_CALENDAR_SELECTOR_POPUP_DONE:
 181                 if (pArgs != null)
 182                 {
 183                         __pPm->SetCalendar(static_cast<Integer*>(pArgs->GetAt(0))->value);
 184                         __pTableView->RefreshItem(GROUP_SAVE_TO, SAVE_TO_ITEM_SAVE_TO, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 185                 }
 186                 break;
 187         }
 188
 189         if (pArgs != null)
 190         {
 191                 pArgs->RemoveAll(true);
 192                 delete pArgs;
 193         }
 194 }
 195
 196 void
 197 EventEditorForm::OnFormBackRequested(Form& source)
 198 {
 199         SetFocus();
 200
 201         CalendarApp* pApp = static_cast<CalendarApp*>(UiApp::GetInstance());
 202         if (pApp != null)
 203         {
 204                 if (pApp->GetOperationType() != OPERATION_TYPE_MAIN)
 205                 {
 206                         result r = SendAppControlResult(APP_CTRL_RESULT_CANCELED);
 207                         AppLogDebugIf(r != E_SUCCESS, "[%s] Unable to return result.", GetErrorMessage(r));
 208
 209                         pApp->Terminate();
 210                         return;
 211                 }
 212         }
 213
 214         SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_RIGHT));
 215 }
 216
 217 void
 218 EventEditorForm::OnExpandableEditAreaLineAdded(ExpandableEditArea& source, int newLineCount)
 219 {
 220         __pTableView->RefreshItem(GROUP_INFORMATION_CONTENT, INFORMATION_CONTENT_ITEM_DESCRIPTION, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 221 }
 222
 223 void
 224 EventEditorForm::OnExpandableEditAreaLineRemoved(ExpandableEditArea& source, int newLineCount)
 225 {
 226         __pTableView->RefreshItem(GROUP_INFORMATION_CONTENT, INFORMATION_CONTENT_ITEM_DESCRIPTION, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 227 }
 228
 229 int
 230 EventEditorForm::GetSectionCount(void)
 231 {
 232         return GROUP_COUNT;
 233 }
 234
 235 int
 236 EventEditorForm::GetItemCount(int sectionIndex)
 237 {
 238         switch (sectionIndex)
 239         {
 240         case GROUP_TITLE_CONTENT:
 241                 return TITLE_CONTENT_ITEM_COUNT;
 242         case GROUP_DATE_SELECTOR:
 243                 return DATE_SELECTOR_ITEM_COUNT;
 244         case GROUP_INFORMATION_CONTENT:
 245                 return INFORMATION_CONTENT_ITEM_COUNT;
 246         case GROUP_ADDITIONAL_CONTENT:
 247                 return ADDITIONAL_CONTENT_ITEM_COUNT;
 248         case GROUP_SAVE_TO:
 249                 return SAVE_TO_ITEM_COUNT;
 250         }
 251
 252         return 0;
 253 }
 254
 255 TableViewItem*
 256 EventEditorForm::CreateItem(int sectionIndex, int itemIndex, int itemWidth)
 257 {
 258         TableViewItem* pItem = null;
 259         switch (sectionIndex)
 260         {
 261         case GROUP_TITLE_CONTENT:
 262                 switch (itemIndex)
 263                 {
 264                 case TITLE_CONTENT_ITEM_TITLE:
 265                         pItem = CreateTitleItemN(itemWidth, __pPm->GetSubject());
 266                         break;
 267                 }
 268                 break;
 269         case GROUP_DATE_SELECTOR:
 270                 switch (itemIndex)
 271                 {
 272                 case FROM_DATE_SELECTOR_ITEM_START:
 273                         pItem = CreateStartTimeItemN(itemWidth, __pPm->GetStartTime(), __pPm->IsAllDayEvent());
 274                         break;
 275                 case TO_DATE_SELECTOR_ITEM_END:
 276                         pItem = CreateEndTimeItemN(itemWidth, __pPm->GetEndTime(), __pPm->IsAllDayEvent());
 277                         break;
 278 //              case DATE_SELECTOR_ITEM_TIME_ZONE:
 279 //                      pItem = CreateTimeZoneTimeN(itemWidth, __pPm->GetTimezone());
 280 //                      break;
 281                 case DATE_SELECTOR_ITEM_ALL_DAY_EVENT:
 282                         pItem = CreateAllDayEventItemN(itemWidth);
 283                         break;
 284                 }
 285                 break;
 286         case GROUP_INFORMATION_CONTENT:
 287                 switch (itemIndex)
 288                 {
 289                 case INFORMATION_CONTENT_ITEM_DESCRIPTION:
 290                         pItem = CreateDescriptionItemN(itemWidth, __pPm->GetDescription());
 291                         break;
 292                 case INFORMATION_CONTENT_ITEM_LOCATION:
 293                         pItem = CreateLocationItemN(itemWidth, __pPm->GetLocation());
 294                         break;
 295                 }
 296                 break;
 297         case GROUP_ADDITIONAL_CONTENT:
 298                 switch (itemIndex)
 299                 {
 300                 case ADDITIONAL_CONTENT_ITEM_REMINDER:
 301                         pItem = CreateReminderItemN(itemWidth, H_ITEM_2LINE, __pPm->GetReminderString(itemIndex), itemIndex, true, true);
 302                         if (__pPm->GetCountReminder() <= 0)
 303                         {
 304                                 __pButtonAddReminer->SetShowState(false);
 305                                 __pButtonDeleteReminder->SetShowState(false);
 306                         }
 307                         else if (__pPm->GetCountReminder() >= 5)
 308                         {
 309                                 __pButtonAddReminer->SetShowState(false);
 310                         }
 311                         break;
 312                 case ADDITIONAL_CONTENT_ITEM_REMINDER2:
 313                         // fall through
 314                 case ADDITIONAL_CONTENT_ITEM_REMINDER3:
 315                         // fall through
 316                 case ADDITIONAL_CONTENT_ITEM_REMINDER4:
 317                         // fall through
 318                 case ADDITIONAL_CONTENT_ITEM_REMINDER5:
 319                         if (itemIndex < __pPm->GetCountReminder())
 320                         {
 321                                 pItem = CreateReminderItemN(itemWidth, H_ITEM_2LINE, __pPm->GetReminderString(itemIndex), itemIndex);
 322                         }
 323                         else
 324                         {
 325                                 pItem = CreateReminderItemN(itemWidth, 0, __pPm->GetReminderString(itemIndex), itemIndex, false);
 326                         }
 327                         break;
 328                 case ADDITIONAL_CONTENT_ITEM_REPEAT:
 329                         pItem = CreateRepeatItemN(itemWidth, __pPm->GetRecurrenceString());
 330                         break;
 331                 }
 332                 break;
 333         case GROUP_SAVE_TO:
 334                 if (itemIndex == SAVE_TO_ITEM_SAVE_TO)
 335                 {
 336                         const Bitmap* pIcon = __pPm->GetCalendarIconN();
 337                         pItem = CreateSaveToItemN(itemWidth, __pPm->GetCalendarName(), pIcon);
 338                         delete pIcon;
 339                 }
 340                 break;
 341         }
 342
 343         return pItem;
 344 }
 345
 346 bool
 347 EventEditorForm::DeleteItem(int sectionIndex, int itemIndex, TableViewItem* pItem)
 348 {
 349         switch (sectionIndex)
 350         {
 351         case GROUP_TITLE_CONTENT:
 352                 switch (itemIndex)
 353                 {
 354                 case TITLE_CONTENT_ITEM_TITLE:
 355                         if (__pEditFieldTitle != null)
 356                         {
 357                                 __pPm->SetSubject(__pEditFieldTitle->GetText());
 358                                 __pEditFieldTitle = null;
 359                         }
 360                         break;
 361                 }
 362                 break;
 363         case GROUP_DATE_SELECTOR:
 364                 switch (itemIndex)
 365                 {
 366                 case FROM_DATE_SELECTOR_ITEM_START:
 367                         if (__pPm->IsAllDayEvent())
 368                         {
 369                                 if (__pEditDateStartDate)
 370                                 {
 371                                         DateTime start;
 372                                         start.SetValue(__pEditDateStartDate->GetYear(), __pEditDateStartDate->GetMonth(), __pEditDateStartDate->GetDay());
 373                                         __pPm->SetStartTime(start);
 374                                 }
 375                         }
 376                         else
 377                         {
 378                                 if (__pEditDateStartDate && __pEditTimeStartTime)
 379                                 {
 380                                         DateTime start;
 381                                         start.SetValue(__pEditDateStartDate->GetYear(), __pEditDateStartDate->GetMonth(), __pEditDateStartDate->GetDay(),
 382                                                                    __pEditTimeStartTime->GetHour(), __pEditTimeStartTime->GetMinute());
 383                                         __pPm->SetStartTime(start);
 384                                 }
 385                         }
 386                         __pEditDateStartDate = null;
 387                         __pEditTimeStartTime = null;
 388                         break;
 389                 case TO_DATE_SELECTOR_ITEM_END:
 390                         if (__pPm->IsAllDayEvent())
 391                         {
 392                                 if (__pEditDateEndDate)
 393                                 {
 394                                         DateTime end;
 395                                         end.SetValue(__pEditDateEndDate->GetYear(), __pEditDateEndDate->GetMonth(), __pEditDateEndDate->GetDay());
 396                                         __pPm->SetEndTime(end);
 397                                 }
 398                         }
 399                         else
 400                         {
 401                                 if (__pEditDateEndDate && __pEditTimeEndTime)
 402                                 {
 403                                         DateTime end;
 404                                         end.SetValue(__pEditDateEndDate->GetYear(), __pEditDateEndDate->GetMonth(), __pEditDateEndDate->GetDay(),
 405                                                                  __pEditTimeEndTime->GetHour(), __pEditTimeEndTime->GetMinute());
 406                                         __pPm->SetEndTime(end);
 407                                 }
 408                         }
 409                         __pEditDateEndDate = null;
 410                         __pEditTimeEndTime = null;
 411                         break;
 412 //              case DATE_SELECTOR_ITEM_TIME_ZONE:
 413 //                      __pLabelTimeZone = null;
 414 //                      break;
 415                 case DATE_SELECTOR_ITEM_ALL_DAY_EVENT:
 416                         break;
 417                 }
 418                 break;
 419         case GROUP_INFORMATION_CONTENT:
 420                 switch (itemIndex)
 421                 {
 422                 case INFORMATION_CONTENT_ITEM_LOCATION:
 423                         if (__pEditFieldLocation != null)
 424                         {
 425                                 __pPm->SetLocation(__pEditFieldLocation->GetText());
 426                                 __pEditFieldLocation = null;
 427                         }
 428                         break;
 429                 case INFORMATION_CONTENT_ITEM_DESCRIPTION:
 430                         if (__pExpandableEditAreaNote != null)
 431                         {
 432                                 __pPm->SetDescription(__pExpandableEditAreaNote->GetText());
 433                                 __pExpandableEditAreaNote = null;
 434                         }
 435                         break;
 436                 }
 437                 break;
 438         case GROUP_ADDITIONAL_CONTENT:
 439                 switch (itemIndex)
 440                 {
 441                 case ADDITIONAL_CONTENT_ITEM_REMINDER:
 442                         __pButtonAddReminer = null;
 443                         __pButtonDeleteReminder = null;
 444                         // fall through
 445                 case ADDITIONAL_CONTENT_ITEM_REMINDER2:
 446                         // fall through
 447                 case ADDITIONAL_CONTENT_ITEM_REMINDER3:
 448                         // fall through
 449                 case ADDITIONAL_CONTENT_ITEM_REMINDER4:
 450                         // fall through
 451                 case ADDITIONAL_CONTENT_ITEM_REMINDER5:
 452                         __pLabelReminder[itemIndex] = null;
 453                         __pItemReminder[itemIndex] = null;
 454                         break;
 455                 case ADDITIONAL_CONTENT_ITEM_REPEAT:
 456                         __pLabelRepeat = null;
 457                         break;
 458                 }
 459                 break;
 460         case GROUP_SAVE_TO:
 461                 __pLabelSaveTo = null;
 462                 break;
 463         default:
 464                 break;
 465         }
 466         delete pItem;
 467         return true;
 468 }
 469
 470 void
 471 EventEditorForm::UpdateItem(int sectionIndex, int itemIndex, TableViewItem* pItem)
 472 {
 473         switch (sectionIndex)
 474         {
 475         case GROUP_DATE_SELECTOR:
 476                 if (itemIndex == FROM_DATE_SELECTOR_ITEM_START)
 477                 {
 478                         bool is24HourNotationEnabled = false;
 479                         SettingInfo::GetValue(KEY_SYSTEM_24_HOUR_NOTATION_ENABLED, is24HourNotationEnabled);
 480                         __pEditTimeStartTime->Set24HourNotationEnabled(is24HourNotationEnabled);
 481                         __pEditTimeStartTime->Invalidate(true);
 482                 }
 483                 else if (itemIndex == TO_DATE_SELECTOR_ITEM_END)
 484                 {
 485                         bool is24HourNotationEnabled = false;
 486                         SettingInfo::GetValue(KEY_SYSTEM_24_HOUR_NOTATION_ENABLED, is24HourNotationEnabled);
 487                         __pEditTimeEndTime->Set24HourNotationEnabled(is24HourNotationEnabled);
 488                         __pEditTimeEndTime->Invalidate(true);
 489                 }
 490                 break;
 491         case GROUP_INFORMATION_CONTENT:
 492                 if (itemIndex == INFORMATION_CONTENT_ITEM_DESCRIPTION)
 493                 {
 494                         pItem->SetSize(pItem->GetWidthF(), __pExpandableEditAreaNote->GetHeightF());
 495                 }
 496                 break;
 497         case GROUP_ADDITIONAL_CONTENT:
 498                 switch (itemIndex)
 499                 {
 500                 case ADDITIONAL_CONTENT_ITEM_REMINDER:
 501                         __pLabelReminder[itemIndex]->SetText(__pPm->GetReminderString(itemIndex));
 502                         __pLabelReminder[itemIndex]->Invalidate(false);
 503                         if (__pPm->GetCountReminder() <= 0)
 504                         {
 505                                 __pButtonAddReminer->SetShowState(false);
 506                                 __pButtonDeleteReminder->SetShowState(false);
 507                         }
 508                         else if (__pPm->GetCountReminder() >= 5)
 509                         {
 510                                 __pButtonAddReminer->SetShowState(false);
 511                                 __pButtonDeleteReminder->SetShowState(true);
 512                         }
 513                         else
 514                         {
 515                                 __pButtonAddReminer->SetShowState(true);
 516                                 __pButtonDeleteReminder->SetShowState(true);
 517                         }
 518                         break;
 519                 case ADDITIONAL_CONTENT_ITEM_REMINDER2:
 520                         // fall through
 521                 case ADDITIONAL_CONTENT_ITEM_REMINDER3:
 522                         // fall through
 523                 case ADDITIONAL_CONTENT_ITEM_REMINDER4:
 524                         // fall through
 525                 case ADDITIONAL_CONTENT_ITEM_REMINDER5:
 526                         __pLabelReminder[itemIndex]->SetText(__pPm->GetReminderString(itemIndex));
 527                         __pLabelReminder[itemIndex]->Invalidate(false);
 528                         if (itemIndex < __pPm->GetCountReminder())
 529                         {
 530                                 pItem->SetSize(pItem->GetWidth(), H_ITEM_2LINE);
 531                                 pItem->SetShowState(true);
 532                         }
 533                         else
 534                         {
 535                                 pItem->SetSize(pItem->GetWidth(), 0);
 536                                 pItem->SetShowState(false);
 537                         }
 538
 539                         // Reminder Max_Count is 5
 540                         if (__pPm->GetCountReminder() > 4)
 541                         {
 542                                 __pButtonAddReminer->SetShowState(false);
 543                         }
 544                         else
 545                         {
 546                                 __pButtonAddReminer->SetShowState(true);
 547                         }
 548                         break;
 549                 case ADDITIONAL_CONTENT_ITEM_REPEAT:
 550                         __pLabelRepeat->SetText(__pPm->GetRecurrenceString());
 551                         pItem->SetEnabled(__pPm->IsEditableRecurrence());
 552                         pItem->Invalidate(true);
 553                         break;
 554                 }
 555                 break;
 556         case GROUP_SAVE_TO:
 557                 if (itemIndex == SAVE_TO_ITEM_SAVE_TO)
 558                 {
 559                         __pLabelSaveTo->SetText(__pPm->GetCalendarName());
 560                         pItem->SetEnabled(__pPm->IsEditableRecurrence());
 561                         pItem->Invalidate(true);
 562                 }
 563                 break;
 564         }
 565 }
 566
 567 String
 568 EventEditorForm::GetSectionHeader(int sectionIndex)
 569 {
 570         return L"";
 571 }
 572
 573 bool
 574 EventEditorForm::HasSectionHeader(int sectionIndex)
 575 {
 576         if (sectionIndex == 0)
 577         {
 578                 return false;
 579         }
 580         return true;
 581 }
 582
 583 String
 584 EventEditorForm::GetSectionFooter(int sectionIndex)
 585 {
 586         return L"";
 587 }
 588
 589 bool
 590 EventEditorForm::HasSectionFooter(int sectionIndex)
 591 {
 592         return false;
 593 }
 594
 595 int
 596 EventEditorForm::GetDefaultItemHeight(void)
 597 {
 598         return 0;
 599 }
 600
 601 void
 602 EventEditorForm::OnSectionTableViewItemStateChanged(SectionTableView& tableView, int sectionIndex, int itemIndex,
 603                                                                                                                  TableViewItem* pItem, TableViewItemStatus status)
 604 {
 605         //pItem->SetFocus();
 606         LinkedList* pList = null;
 607         switch (sectionIndex)
 608         {
 609         case GROUP_DATE_SELECTOR:
 610 //              if (itemIndex == DATE_SELECTOR_ITEM_TIME_ZONE)
 611 //              {
 612 //                      // Call Settings application.
 613 //                      UpdatePm();
 614 //              }
 615                 if (itemIndex == DATE_SELECTOR_ITEM_ALL_DAY_EVENT)
 616                 {
 617                         if (status == TABLE_VIEW_ITEM_STATUS_CHECKED)
 618                         {
 619                                 __pPm->SetAllDayEvent(true);
 620
 621                                 if (__pEditTimeStartTime)
 622                                 {
 623                                         __pEditTimeStartTime->SetShowState(false);
 624                                 }
 625
 626                                 if (__pEditTimeEndTime)
 627                                 {
 628                                         __pEditTimeEndTime->SetShowState(false);
 629                                 }
 630                         }
 631                         else if (status == TABLE_VIEW_ITEM_STATUS_UNCHECKED)
 632                         {
 633                                 __pPm->SetAllDayEvent(false);
 634
 635                                 if (__pEditTimeStartTime)
 636                                 {
 637                                         __pEditTimeStartTime->SetShowState(true);
 638                                 }
 639
 640                                 if (__pEditTimeEndTime)
 641                                 {
 642                                         __pEditTimeEndTime->SetShowState(true);
 643                                 }
 644                         }
 645                 }
 646                 break;
 647         case GROUP_ADDITIONAL_CONTENT:
 648                 // Call ReminderForm
 649                 switch (itemIndex)
 650                 {
 651                 case ADDITIONAL_CONTENT_ITEM_REMINDER:
 652                         // fall through
 653                 case ADDITIONAL_CONTENT_ITEM_REMINDER2:
 654                         // fall through
 655                 case ADDITIONAL_CONTENT_ITEM_REMINDER3:
 656                         // fall through
 657                 case ADDITIONAL_CONTENT_ITEM_REMINDER4:
 658                         // fall through
 659                 case ADDITIONAL_CONTENT_ITEM_REMINDER5:
 660                         if (__pPm->GetReminder(itemIndex) != null)
 661                         {
 662                                 UpdatePm();
 663                                 pList = new (std::nothrow) LinkedList(SingleObjectDeleter);
 664                                 pList->Add(new (std::nothrow) Reminder(*__pPm->GetReminder(itemIndex)));
 665                                 pList->Add(new (std::nothrow) Integer(itemIndex));
 666                         }
 667                         SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_REMINDER,
 668                                                                                                   SCENE_TRANSITION_ANIMATION_TYPE_LEFT), pList);
 669                 break;
 670                 }
 671
 672                 if (itemIndex == ADDITIONAL_CONTENT_ITEM_REPEAT)
 673                 {
 674                         // Call RepeatForm
 675                         UpdatePm();
 676                         pList = new (std::nothrow) LinkedList(SingleObjectDeleter);
 677                         pList->Add(new (std::nothrow) DateTime(__pPm->GetStartTime()));
 678                         if (__pPm->GetRecurrence())
 679                         {
 680                                 pList->Add(new (std::nothrow) Recurrence(*__pPm->GetRecurrence()));
 681                         }
 682
 683                         SceneManager::GetInstance()->GoForward(ForwardSceneTransition(IDSCN_REPEAT,
 684                                                                                                                                                   SCENE_TRANSITION_ANIMATION_TYPE_LEFT), pList);
 685                 }
 686                 break;
 687         case GROUP_SAVE_TO:
 688                 if (itemIndex == SAVE_TO_ITEM_SAVE_TO)
 689                 {
 690                         __pCalendarSelectorPopup->RequestCalendar(CALENDAR_SELECTOR_POPUP_STYLE_EVENT, this);
 691                 }
 692                 break;
 693         }
 694 }
 695
 696 void
 697 EventEditorForm::OnSectionTableViewContextItemActivationStateChanged(SectionTableView& tableView, int sectionIndex, int itemIndex,
 698                                                                                                                                                    TableViewContextItem* pContextItem, bool activated)
 699 {
 700 }
 701
 702 void
 703 EventEditorForm::OnSceneActivatedN(const SceneId& previousSceneId, const SceneId& currentSceneId, IList* pArgs)
 704 {
 705         AppLogDebug("Enter.");
 706         if (previousSceneId == IDSCN_REMINDER)
 707         {
 708                 int index = 0;
 709                 if (pArgs)
 710                 {
 711                         Integer* pIndex = dynamic_cast<Integer*>(pArgs->GetAt(0));
 712                         if (pIndex)
 713                         {
 714                                 index = pIndex->ToInt();
 715                         }
 716                         Reminder* pReminder = dynamic_cast<Reminder*>(pArgs->GetAt(1));
 717                         if (pReminder)
 718                         {
 719                                 if (index < __pPm->GetCountReminder())
 720                                 {
 721                                         __pPm->SetReminderAt(*pReminder, index);
 722                                 }
 723                                 else
 724                                 {
 725                                         __pPm->AddReminder(*pReminder);
 726                                 }
 727                                 __pTableView->RefreshItem(GROUP_ADDITIONAL_CONTENT, index, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 728                         }
 729                         else
 730                         {
 731                                 int count = __pPm->GetCountReminder();
 732                                 __pPm->RemoveReminderAt(index);
 733                                 while (index < count)
 734                                 {
 735                                         __pTableView->RefreshItem(GROUP_ADDITIONAL_CONTENT, index++, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 736                                 }
 737                         }
 738                 }
 739         }
 740         else if (previousSceneId == IDSCN_REPEAT)
 741         {
 742                 Recurrence* pRecurrence = null;
 743                 if (pArgs != null)
 744                 {
 745                         pRecurrence = dynamic_cast<Recurrence*>(pArgs->GetAt(0));
 746                 }
 747
 748                 result r = E_FAILURE;
 749                 if (!pRecurrence)
 750                 {
 751                         r = __pPm->SetRecurrence(null);
 752                 }
 753                 else if (pRecurrence->GetCounts() > 0)
 754                 {
 755                         r = __pPm->SetRecurrence(pRecurrence);
 756                 }
 757                 else if (pRecurrence->GetUntil())
 758                 {
 759                         DateTime untilDateChecker = __pPm->GetStartTime();
 760                         switch (pRecurrence->GetFrequency())
 761                         {
 762                         case FREQ_DAILY:
 763                                 untilDateChecker.AddDays(pRecurrence->GetInterval());
 764                                 break;
 765                         case FREQ_WEEKLY:
 766                                 untilDateChecker.AddDays(7 * pRecurrence->GetInterval());
 767                                 break;
 768                         case FREQ_MONTHLY:
 769                                 untilDateChecker.AddMonths(pRecurrence->GetInterval());
 770                                 break;
 771                         case FREQ_YEARLY:
 772                                 untilDateChecker.AddYears(pRecurrence->GetInterval());
 773                                 break;
 774                         }
 775
 776                         if (*pRecurrence->GetUntil() >= untilDateChecker)
 777                         {
 778                                 r = __pPm->SetRecurrence(pRecurrence);
 779                         }
 780                 }
 781
 782                 if (r == E_SUCCESS)
 783                 {
 784                         __pTableView->RefreshItem(GROUP_ADDITIONAL_CONTENT, ADDITIONAL_CONTENT_ITEM_REPEAT, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 785                         __pTableView->RefreshItem(GROUP_DATE_SELECTOR, FROM_DATE_SELECTOR_ITEM_START, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 786                         __pTableView->RefreshItem(GROUP_DATE_SELECTOR, TO_DATE_SELECTOR_ITEM_END, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 787                 }
 788                 else
 789                 {
 790                         MessageBox msgBox;
 791                         msgBox.Construct(L"", ResourceManager::GetString(IDS_CLD_BODY_REPEAT_WARNING), MSGBOX_STYLE_OK);
 792                         int modalResult;
 793                         msgBox.ShowAndWait(modalResult);
 794                 }
 795         }
 796         else
 797         {
 798                 CalendarApp* pApp = static_cast<CalendarApp*>(UiApp::GetInstance());
 799                 if (pApp->GetOperationType() == OPERATION_TYPE_MAIN)
 800                 {
 801                         if (pArgs)
 802                         {
 803                                 CalEventInstance* pEvent = dynamic_cast<CalEventInstance*>(pArgs->GetAt(0));
 804                                 DateTime* pStartTime = null;
 805
 806                                 if (pEvent)
 807                                 {
 808                                         bool allEventEditing = true;
 809                                         Boolean* pAllEventEditing = dynamic_cast<Boolean*>(pArgs->GetAt(1));
 810                                         if (pAllEventEditing)
 811                                         {
 812                                                 allEventEditing = pAllEventEditing->value;
 813                                         }
 814
 815                                         result r = __pPm->SetEventInstance(*pEvent, allEventEditing);
 816                                         if (r != E_SUCCESS)
 817                                         {
 818                                                 AppLogDebug("[%s] Unable to get event.", GetErrorMessage(r));
 819                                                 SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_LEFT));
 820                                                 AppLogDebug("Enter.");
 821                                                 return;
 822                                         }
 823                                         if(pEvent->IsAllDayEvent() == true)
 824                                         {
 825                                                 DateTime startTime;
 826                                                 SystemTime::GetCurrentTime(TIME_MODE_WALL, startTime);
 827                                                 startTime.SetValue(__pPm->GetStartTime().GetYear(),__pPm->GetStartTime().GetMonth(),__pPm->GetStartTime().GetDay(),
 828                                                                 startTime.GetHour(),startTime.GetMinute(),      startTime.GetSecond());
 829                                                 startTime.AddHours(1);
 830                                                 startTime.AddMinutes(-startTime.GetMinute());
 831                                                 startTime.AddSeconds(-startTime.GetSecond());
 832                                                 DateTime end;
 833                                                 end.SetValue(__pPm->GetEndTime().GetYear(),__pPm->GetEndTime().GetMonth(),__pPm->GetEndTime().GetDay(),
 834                                                                 startTime.GetHour(),startTime.GetMinute(),startTime.GetSecond());
 835                                                 end.AddHours(1);
 836                                                 __pPm->SetStartTime(startTime);
 837                                                 __pPm->SetEndTime(end);
 838
 839                                         }
 840                                         SetStyle(EDIT_EVENT_FORM_STYLE_EDIT);
 841                                 }
 842
 843                                 pStartTime = dynamic_cast<DateTime*>(pArgs->GetAt(0));
 844                                 if (pStartTime)
 845                                 {
 846                                         pStartTime->AddHours(1);
 847                                         pStartTime->AddMinutes(-pStartTime->GetMinute());
 848                                         pStartTime->AddSeconds(-pStartTime->GetSecond());
 849                                         DateTime end = *pStartTime;
 850                                         end.AddHours(1);
 851                                         __pPm->SetStartTime(*pStartTime);
 852                                         __pPm->SetEndTime(end);
 853
 854                                         SetStyle(EDIT_EVENT_FORM_STYLE_CREATE);
 855                                         //Fix for N_SE-52137
 856                                         /*if (__pEditFieldTitle)
 857                                         {
 858                                                 __pEditFieldTitle->SetFocus();
 859                                         }*/
 860                                 }
 861                         }
 862                 }
 863                 else
 864                 {
 865                         //AppControl
 866                         CalendarApp* pApp = static_cast<CalendarApp*>(UiApp::GetInstance());
 867                         if (pApp->GetOperationType() == OPERATION_TYPE_EDIT)
 868                         {
 869                                 const String* pItemType = pApp->GetArgument(KEY_SOCIAL_ITEM_TYPE);
 870                                 const String* pEventId = pApp->GetArgument(KEY_SOCIAL_ITEM_ID);
 871                                 if (pItemType != null && pItemType->Equals(VALUE_CALENDAR_EVENT_TYPE, false) == true && pEventId != null)
 872                                 {
 873                                         RecordId eventId = INVALID_RECORD_ID;
 874                                         Integer::Parse(*pEventId, eventId);
 875                                         result r = __pPm->SetEventId(eventId);
 876                                         if (r == E_SUCCESS)
 877                                         {
 878                                                 SetStyle(EDIT_EVENT_FORM_STYLE_EDIT);
 879                                         }
 880                                         else
 881                                         {
 882                                                 r = SendAppControlResult(APP_CTRL_RESULT_FAILED);
 883                                                 AppLogDebugIf(r != E_SUCCESS, "[%s] Unable to return result.", GetErrorMessage(r));
 884
 885                                                 pApp->Terminate();
 886                                         }
 887                                 }
 888                         }
 889                 }
 890         }
 891
 892         __pTableView->SetItemChecked(GROUP_DATE_SELECTOR, DATE_SELECTOR_ITEM_ALL_DAY_EVENT, __pPm->IsAllDayEvent());
 893         __pPm->AddCalendarEventChangedEventListener(*this);
 894
 895         if (pArgs)
 896         {
 897                 pArgs->RemoveAll(true);
 898                 delete pArgs;
 899         }
 900
 901         AppLogDebug("Exit.");
 902 }
 903
 904 void
 905 EventEditorForm::OnSceneDeactivated(const SceneId& currentSceneId, const SceneId& nextSceneId)
 906 {
 907         AppLogDebug("Enter.");
 908         AppLogDebug("Exit.");
 909 }
 910
 911 void
 912 EventEditorForm::OnActionPerformed(const Control& source, int actionId)
 913 {
 914         AppLogDebug("Enter.");
 915
 916         result r = E_SUCCESS;
 917         switch (actionId)
 918         {
 919         case IDA_EVENT_EDITOR_FORM_SAVE:
 920                 UpdatePm();
 921                 r = __pPm->Update();
 922                 if (r == E_SUCCESS)
 923                 {
 924                         CalendarApp* pApp = static_cast<CalendarApp*>(UiApp::GetInstance());
 925                         if (pApp && pApp->GetOperationType() != OPERATION_TYPE_MAIN)
 926                         {
 927                                 result r = SendAppControlResult(APP_CTRL_RESULT_SUCCEEDED);
 928                                 AppLogDebugIf(r != E_SUCCESS, "[%s] Unable to return result.", GetErrorMessage(r));
 929
 930                                 pApp->Terminate();
 931                                 return;
 932                         }
 933
 934                         CalEventInstance* pEventInstance = __pPm->GetEventInstance();
 935                         if (pEventInstance)
 936                         {
 937                                 LinkedList* pList = new (std::nothrow) LinkedList(SingleObjectDeleter);
 938                                 pList->Add(new (std::nothrow) CalEventInstance(*pEventInstance));
 939                                 SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_RIGHT), pList);
 940                         }
 941                         else
 942                         {
 943                                 if (SceneManager::GetInstance()->IsSceneAlive(IDSCN_EVENT_DETAILS))
 944                                 {
 945                                         SceneId backSceneId = IDSCN_MONTH;
 946                                         IListT<SceneId>* pHistory = SceneManager::GetInstance()->GetSceneHistoryN();
 947                                         if (pHistory)
 948                                         {
 949                                                 int index = 0;
 950                                                 if (pHistory->IndexOf(SceneId(IDSCN_EVENT_DETAILS), index) == E_SUCCESS)
 951                                                 {
 952                                                         pHistory->GetAt(index - 1, backSceneId);
 953                                                 }
 954                                         }
 955                                         delete pHistory;
 956
 957                                         SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(backSceneId, SCENE_TRANSITION_ANIMATION_TYPE_RIGHT));
 958                                         SceneManager::GetInstance()->DestroyScene(IDSCN_EVENT_DETAILS);
 959                                 }
 960                                 else
 961                                 {
 962                                         SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_RIGHT));
 963                                 }
 964                         }
 965                 }
 966                 else
 967                 {
 968                         UpdatePm();
 969                         String msgString;
 970                         switch (r)
 971                         {
 972                         case E_REJECTED:
 973                                 msgString = ResourceManager::GetString(IDS_CLD_POP_INVALID_TIME);
 974                                 break;
 975                         case E_INVALID_CONDITION:
 976                                 msgString = ResourceManager::GetString(IDS_CLD_BODY_REPEAT_WARNING);
 977                                 break;
 978                         default:
 979                                 msgString = ResourceManager::GetString(IDS_COM_POP_SAVING_FAILED);
 980                                 break;
 981                         }
 982
 983                         MessageBox msgBox;
 984                         msgBox.Construct(L"", msgString, MSGBOX_STYLE_OK,300000);
 985                         int modalResult;
 986                         msgBox.ShowAndWait(modalResult);
 987                         return;
 988                 }
 989                 break;
 990         case IDA_EVENT_EDITOR_FORM_CANCEL:
 991                 SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(SCENE_TRANSITION_ANIMATION_TYPE_RIGHT));
 992                 break;
 993         case IDA_EVENT_EDITOR_FORM_ADD_REMINDER:
 994         {
 995                 Reminder reminder;
 996                 __pPm->AddReminder(reminder);
 997
 998                 __pTableView->RefreshItem(GROUP_ADDITIONAL_CONTENT, __pPm->GetCountReminder() - 1, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
 999                 break;
1000         }
1001         case IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER:
1002                 // fall through
1003         case IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER2:
1004                 // fall through
1005         case IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER3:
1006                 // fall through
1007         case IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER4:
1008                 // fall through
1009         case IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER5:
1010         {
1011                 int index = actionId - IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER;
1012                 int count = __pPm->GetCountReminder();
1013                 __pPm->RemoveReminderAt(index);
1014
1015                 while (index < count)
1016                 {
1017                         __pTableView->RefreshItem(GROUP_ADDITIONAL_CONTENT, index++, TABLE_VIEW_REFRESH_TYPE_ITEM_MODIFY);
1018                 }
1019                 break;
1020         }
1021         }
1022         SetFocus();
1023 }
1024
1025 void
1026 EventEditorForm::OnCalendarEventChanged(void)
1027 {
1028         if(__style == EDIT_EVENT_FORM_STYLE_EDIT && __pPm->IsEventValid() == false)
1029         {
1030                 Tizen::Base::Collection::IListT<SceneId> *ptr = SceneManager::GetInstance()->GetSceneHistoryN();
1031                 SceneId original;
1032                 ptr->GetAt(0,original);
1033                 SceneManager::GetInstance()->GoBackward(BackwardSceneTransition(original));
1034         }
1035
1036 }
1037 TableViewItem*
1038 EventEditorForm::CreateTitleItemN(int itemWidth, const String& title)
1039 {
1040         CardLayout layout;
1041         layout.Construct();
1042
1043         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1044
1045         EditField* pTitle = null;
1046         pItem->Construct(layout, Dimension(itemWidth, H_ITEM));
1047
1048         pTitle = new (std::nothrow) EditField();
1049         pTitle->Construct(Rectangle(0, 0, itemWidth, H_ITEM), EDIT_FIELD_STYLE_NORMAL, INPUT_STYLE_OVERLAY,
1050                                         false, EDITFIELD_LIMIT_LENGTH);
1051         pTitle->SetColor(EDIT_STATUS_NORMAL, Color(0, 0, 0, 0));
1052         pItem->AddControl(pTitle);
1053         pItem->SetIndividualSelectionEnabled(pTitle, true);
1054
1055         if (title.GetLength() > EDITFIELD_LIMIT_LENGTH)
1056         {
1057                 String subString;
1058                 title.SubString(0, EDITFIELD_LIMIT_LENGTH, subString);
1059                 pTitle->SetText(subString);
1060         }
1061         else
1062         {
1063                 pTitle->SetText(title);
1064         }
1065         pTitle->SetGuideText(ResourceManager::GetString(IDS_CLD_BODY_TITLE));
1066         pTitle->AddActionEventListener(*this);
1067
1068         __pEditFieldTitle = pTitle;
1069
1070         return pItem;
1071 }
1072
1073 TableViewItem*
1074 EventEditorForm::CreateStartTimeItemN(int itemWidth, const DateTime& start, bool isAllDayEvent)
1075 {
1076         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1077         pItem->Construct(Dimension(itemWidth, H_ITEM));
1078
1079         EditDate* pStartDate = new (std::nothrow) EditDate();
1080         pStartDate->Construct(Point(0, Y_DATE_SELECTOR), ResourceManager::GetString(IDS_EVENT_EDITOR_FROM));
1081         pItem->AddControl(pStartDate);
1082
1083         pStartDate->SetYearRange(Calendarbook::GetMinDateTime().GetYear() + 1, Calendarbook::GetMaxDateTime().GetYear() - 1);
1084         pStartDate->SetDate(start);
1085         pItem->SetIndividualSelectionEnabled(pStartDate, true);
1086
1087         __pEditDateStartDate = pStartDate;
1088
1089         EditTime* pStartTime = new (std::nothrow) EditTime();
1090         pStartTime->Construct(Point(X_DATE_SELECTOR, Y_DATE_SELECTOR), L" ");
1091
1092         pItem->AddControl(pStartTime);
1093
1094         pStartTime->SetTime(start);
1095         pItem->SetIndividualSelectionEnabled(pStartTime, true);
1096
1097         __pEditTimeStartTime = pStartTime;
1098
1099         if (isAllDayEvent)
1100         {
1101                 __pEditTimeStartTime->SetShowState(false);
1102         }
1103
1104         return pItem;
1105 }
1106
1107 TableViewItem*
1108 EventEditorForm::CreateEndTimeItemN(int itemWidth, const DateTime& end, bool isAllDayEvent)
1109 {
1110         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1111
1112         EditDate* pEndDate = null;
1113         EditTime* pEndTime = null;
1114
1115         pItem->Construct(Dimension(itemWidth, H_ITEM));
1116
1117         pEndDate = new (std::nothrow) EditDate();
1118         pEndDate->Construct(Point(0, Y_DATE_SELECTOR), ResourceManager::GetString(IDS_EVENT_EDITOR_TO));
1119
1120         pItem->AddControl(pEndDate);
1121
1122         pEndDate->SetYearRange(Calendarbook::GetMinDateTime().GetYear() + 1, Calendarbook::GetMaxDateTime().GetYear() - 1);
1123         pEndDate->SetDate(end);
1124         pItem->SetIndividualSelectionEnabled(pEndDate, true);
1125
1126         __pEditDateEndDate = pEndDate;
1127
1128         pEndTime = new (std::nothrow) EditTime();
1129         pEndTime->Construct(Point(X_DATE_SELECTOR, Y_DATE_SELECTOR), L" ");
1130
1131         pItem->AddControl(pEndTime);
1132
1133         pEndTime->SetTime(end);
1134         pItem->SetIndividualSelectionEnabled(pEndTime, true);
1135
1136         __pEditTimeEndTime = pEndTime;
1137
1138         if (isAllDayEvent == true)
1139         {
1140                 __pEditTimeEndTime->SetShowState(false);
1141         }
1142
1143         return pItem;
1144 }
1145
1146 //TableViewItem*
1147 //EventEditorForm::CreateTimeZoneTimeN(int itemWidth, const String& timeZone)
1148 //{
1149 //      TableViewItem* pItem = new (std::nothrow) TableViewItem();
1150 //
1151 //      Label* pLabel = null;
1152 //      Label* pContentLabel = null;
1153 //
1154 //      pItem->Construct(Dimension(itemWidth, H_ITEM_2LINE));
1155 //      pItem->SetBackgroundColor(Color(COLOR_ITEM_BACKGROUND), TABLE_VIEW_ITEM_DRAWING_STATUS_NORMAL);
1156 //
1157 //      pLabel = new (std::nothrow) Label();
1158 //      pLabel->Construct(Rectangle(0, Y_ITEM_CONTENT01, itemWidth, H_ITEM_CONTENT01),
1159 //                                                ResourceManager::GetString(IDS_EVENT_EDITOR_TIME_ZONE));
1160 //
1161 //      pItem->AddControl(pLabel);
1162 //
1163 //      pLabel->SetTextColor(Color(COLOR_DETAIL02));
1164 //      pLabel->SetTextConfig(FONT_SIZE_DETAIL02, LABEL_TEXT_STYLE_NORMAL);
1165 //      pLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1166 //
1167 //      pContentLabel = new (std::nothrow) Label();
1168 //      pContentLabel->Construct(Rectangle(0, Y_ITEM_CONTENT02, itemWidth, H_ITEM_CONTENT02), timeZone);
1169 //
1170 //      pItem->AddControl(pContentLabel);
1171 //
1172 //      pContentLabel->SetTextColor(Color(COLOR_ADDITIONAL_CONTENT));
1173 //      pContentLabel->SetTextConfig(FONT_SIZE_DETAIL03, LABEL_TEXT_STYLE_NORMAL);
1174 //      pContentLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1175 //
1176 //      __pLabelTimeZone = pContentLabel;
1177 //
1178 //      return pItem;
1179 //}
1180
1181 TableViewItem*
1182 EventEditorForm::CreateAllDayEventItemN(int itemWidth)
1183 {
1184         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1185
1186         Label* pLabel = null;
1187
1188         pItem->Construct(Dimension(itemWidth, H_ITEM), TABLE_VIEW_ANNEX_STYLE_ONOFF_SLIDING);
1189
1190         pLabel = new (std::nothrow) Label();
1191         pLabel->Construct(Rectangle(0, 0, itemWidth, H_ITEM), ResourceManager::GetString(IDS_CLD_BODY_ALL_DAY_EVENT));
1192         pLabel->SetTextConfig(FONT_SIZE_DETAIL03, LABEL_TEXT_STYLE_NORMAL);
1193         pLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1194
1195         pItem->AddControl(pLabel);
1196
1197         return pItem;
1198 }
1199
1200 TableViewItem*
1201 EventEditorForm::CreateDescriptionItemN(int itemWidth, const String& description)
1202 {
1203         CardLayout layout;
1204         layout.Construct();
1205
1206         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1207         pItem->Construct(layout, Dimension(itemWidth, H_ITEM));
1208
1209         __pExpandableEditAreaNote = new (std::nothrow) ExpandableEditArea();
1210         __pExpandableEditAreaNote->Construct(Rectangle(0, 0, itemWidth, H_DESCRIPTION),
1211                                                                 EXPANDABLE_EDIT_AREA_STYLE_NORMAL, EXPANDABLE_EDIT_AREA_TITLE_STYLE_NONE, EXPANDABLE_EDIT_MAX_LINE);
1212         __pExpandableEditAreaNote->SetColor(EDIT_STATUS_NORMAL, Color(0, 0, 0, 0));
1213         __pExpandableEditAreaNote->AddExpandableEditAreaEventListener(*this);
1214         __pExpandableEditAreaNote->SetText(description);
1215         __pExpandableEditAreaNote->SetGuideText(ResourceManager::GetString(IDS_CLD_BODY_CREATE_DESCRIPTION));
1216         pItem->AddControl(__pExpandableEditAreaNote);
1217         pItem->SetIndividualSelectionEnabled(__pExpandableEditAreaNote, true);
1218
1219         return pItem;
1220 }
1221
1222 TableViewItem*
1223 EventEditorForm::CreateLocationItemN(int itemWidth, const String& location)
1224 {
1225         CardLayout layout;
1226         layout.Construct();
1227
1228         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1229         pItem->Construct(layout, Dimension(itemWidth, H_ITEM));
1230
1231         EditField* pLocation = new (std::nothrow) EditField();
1232         pLocation->Construct(Rectangle(0, 0, itemWidth, H_ITEM), EDIT_FIELD_STYLE_NORMAL, INPUT_STYLE_OVERLAY,
1233                                         false, EDITFIELD_LIMIT_LENGTH);
1234         pLocation->SetColor(EDIT_STATUS_NORMAL, Color(0, 0, 0, 0));
1235         pItem->AddControl(pLocation);
1236         pItem->SetIndividualSelectionEnabled(pLocation, true);
1237
1238         if (location.GetLength() > EDITFIELD_LIMIT_LENGTH)
1239         {
1240                 String subString;
1241                 location.SubString(0, EDITFIELD_LIMIT_LENGTH, subString);
1242                 pLocation->SetText(subString);
1243         }
1244         else
1245         {
1246                 pLocation->SetText(location);
1247         }
1248         pLocation->SetGuideText(ResourceManager::GetString(IDS_CLD_BODY_LOCATION));
1249         pLocation->AddActionEventListener(*this);
1250
1251         __pEditFieldLocation = pLocation;
1252
1253         return pItem;
1254 }
1255
1256 TableViewItem*
1257 EventEditorForm::CreateReminderItemN(int itemWidth, int itemHeight, const String& reminder, int index, bool showItem, bool hasAddButton)
1258 {
1259         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1260         pItem->Construct(Dimension(itemWidth, itemHeight));
1261         Label* pLabel = new (std::nothrow) Label();
1262         pLabel->Construct(Rectangle(0, Y_ITEM_CONTENT01, itemWidth - W_REMINDER_DELETE_BUTTON_MARGIN, H_ITEM_CONTENT01),
1263                                                   ResourceManager::GetString(IDS_CLD_BODY_REMINDER));
1264
1265         pItem->AddControl(pLabel);
1266
1267         pLabel->SetTextColor(Color(COLOR_DETAIL02));
1268         pLabel->SetTextConfig(FONT_SIZE_DETAIL02, LABEL_TEXT_STYLE_NORMAL);
1269         pLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1270
1271         Label* pContentLabel = new (std::nothrow) Label();
1272         pContentLabel->Construct(Rectangle(0, Y_ITEM_CONTENT02, itemWidth - W_REMINDER_DELETE_BUTTON_MARGIN, H_ITEM_CONTENT02), reminder);
1273
1274         pItem->AddControl(pContentLabel);
1275
1276         pContentLabel->SetTextConfig(FONT_SIZE_DETAIL03, LABEL_TEXT_STYLE_NORMAL);
1277         pContentLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1278
1279         // Add delete button
1280         Button* pButtonDeleteReminder = new (std::nothrow) Button();
1281         pButtonDeleteReminder->Construct(Rectangle(itemWidth - W_REMINDER_DELETE_BUTTON_MARGIN,
1282                         (H_ITEM_2LINE - H_REMINDER_DELETE_BUTTON) / 2, W_REMINDER_DELETE_BUTTON, H_REMINDER_DELETE_BUTTON), L"");
1283
1284         pItem->AddControl(pButtonDeleteReminder);
1285         pItem->SetIndividualSelectionEnabled(pButtonDeleteReminder, true);
1286         pButtonDeleteReminder->SetActionId(IDA_EVENT_EDITOR_FORM_REMOVE_REMINDER + index);
1287         pButtonDeleteReminder->AddActionEventListener(*this);
1288         if (index == ADDITIONAL_CONTENT_ITEM_REMINDER)
1289         {
1290                 __pButtonDeleteReminder = pButtonDeleteReminder;
1291         }
1292
1293         Bitmap* pBitmapBgDelete = ResourceManager::GetBitmapN(IDB_CIRCLE_BUTTON_DELETE);
1294         if (pBitmapBgDelete != null)
1295         {
1296                 pButtonDeleteReminder->SetNormalBackgroundBitmap(*pBitmapBgDelete);
1297                 delete pBitmapBgDelete;
1298         }
1299         Bitmap* pBitmapBgDeletePressed = ResourceManager::GetBitmapN(IDB_CIRCLE_BUTTON_DELETE_PRESS);
1300         if (pBitmapBgDeletePressed != null)
1301         {
1302                 pButtonDeleteReminder->SetPressedBackgroundBitmap(*pBitmapBgDeletePressed);
1303                 delete pBitmapBgDeletePressed;
1304         }
1305         Bitmap* pBitmapMinus = ResourceManager::GetBitmapN(IDB_BUTTON_MINUS);
1306         if (pBitmapMinus != null)
1307         {
1308                 pButtonDeleteReminder->SetNormalBitmap(Point(0, 0), *pBitmapMinus);
1309                 delete pBitmapMinus;
1310         }
1311         Bitmap* pBitmapMinusPressed = ResourceManager::GetBitmapN(IDB_BUTTON_MINUS_PRESS);
1312         if (pBitmapMinusPressed != null)
1313         {
1314                 pButtonDeleteReminder->SetPressedBitmap(Point(0, 0), *pBitmapMinusPressed);
1315                 delete pBitmapMinusPressed;
1316         }
1317
1318         // Add add button
1319         if (hasAddButton == true)
1320         {
1321                 Button* pButtonAddReminder = new (std::nothrow) Button();
1322                 pButtonAddReminder->Construct(Rectangle(itemWidth - W_REMINDER_ADD_BUTTON_MARGIN,
1323                                 (H_ITEM_2LINE - H_REMINDER_ADD_BUTTON) / 2, W_REMINDER_ADD_BUTTON, H_REMINDER_ADD_BUTTON), L"");
1324
1325                 pItem->AddControl(pButtonAddReminder);
1326                 pItem->SetIndividualSelectionEnabled(pButtonAddReminder, true);
1327                 pButtonAddReminder->SetActionId(IDA_EVENT_EDITOR_FORM_ADD_REMINDER);
1328                 pButtonAddReminder->AddActionEventListener(*this);
1329                 __pButtonAddReminer = pButtonAddReminder;
1330
1331                 Bitmap* pBitmapBgButton = ResourceManager::GetBitmapN(IDB_CIRCLE_BUTTON);
1332                 if (pBitmapBgButton != null)
1333                 {
1334                         pButtonAddReminder->SetNormalBackgroundBitmap(*pBitmapBgButton);
1335                         delete pBitmapBgButton;
1336                 }
1337                 Bitmap* pBitmapBgButtonPressed = ResourceManager::GetBitmapN(IDB_CIRCLE_BUTTON_PRESS);
1338                 if (pBitmapBgButtonPressed != null)
1339                 {
1340                         pButtonAddReminder->SetPressedBackgroundBitmap(*pBitmapBgButtonPressed);
1341                         delete pBitmapBgButtonPressed;
1342                 }
1343                 Bitmap* pBitmapPlus = ResourceManager::GetBitmapN(IDB_BUTTON_PLUS);
1344                 if (pBitmapPlus != null)
1345                 {
1346                         pButtonAddReminder->SetNormalBitmap(Point(0, 0), *pBitmapPlus);
1347                         delete pBitmapPlus;
1348                 }
1349                 Bitmap* pBitmapPlusPressed = ResourceManager::GetBitmapN(IDB_BUTTON_PLUS_PRESS);
1350                 if (pBitmapPlusPressed != null)
1351                 {
1352                         pButtonAddReminder->SetPressedBitmap(Point(0, 0), *pBitmapPlusPressed);
1353                         delete pBitmapPlusPressed;
1354                 }
1355         }
1356
1357         pItem->SetShowState(showItem);
1358         __pLabelReminder[index] = pContentLabel;
1359         __pItemReminder[index] = pItem;
1360
1361         return pItem;
1362 }
1363
1364 TableViewItem*
1365 EventEditorForm::CreateRepeatItemN(int itemWidth, const String& repeat)
1366 {
1367         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1368
1369         Label* pLabel = null;
1370         Label* pContentLabel = null;
1371
1372         pItem->Construct(Dimension(itemWidth, H_ITEM_2LINE));
1373
1374         pLabel = new (std::nothrow) Label();
1375         pLabel->Construct(Rectangle(0, Y_ITEM_CONTENT01, itemWidth, H_ITEM_CONTENT01),
1376                                                   ResourceManager::GetString(IDS_CLD_BODY_REPEAT));
1377
1378         pItem->AddControl(pLabel);
1379
1380         pLabel->SetTextColor(Color(COLOR_DETAIL02));
1381         pLabel->SetTextConfig(FONT_SIZE_DETAIL02, LABEL_TEXT_STYLE_NORMAL);
1382         pLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1383
1384         pContentLabel = new (std::nothrow) Label();
1385         pContentLabel->Construct(Rectangle(0, Y_ITEM_CONTENT02, itemWidth, H_ITEM_CONTENT02), repeat);
1386
1387         pItem->AddControl(pContentLabel);
1388
1389         pContentLabel->SetTextConfig(FONT_SIZE_DETAIL03, LABEL_TEXT_STYLE_NORMAL);
1390         pContentLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1391
1392         __pLabelRepeat = pContentLabel;
1393
1394         if (!__pPm->IsEditableRecurrence())
1395         {
1396                 pItem->SetEnabled(false);
1397                 pLabel->SetTextColor(Color(COLOR_DISABLE));
1398                 pContentLabel->SetTextColor(Color(COLOR_DISABLE));
1399         }
1400
1401         return pItem;
1402 }
1403
1404 TableViewItem*
1405 EventEditorForm::CreateSaveToItemN(int itemWidth, const String& calendarName, const Bitmap* pCalendarIcon)
1406 {
1407         TableViewItem* pItem = new (std::nothrow) TableViewItem();
1408
1409         Label* pLabel = null;
1410         Label* pContentLabel = null;
1411
1412         pItem->Construct(Dimension(itemWidth, H_ITEM_2LINE));
1413
1414         pLabel = new (std::nothrow) Label();
1415         pLabel->Construct(Rectangle(0, Y_ITEM_CONTENT01, itemWidth, H_ITEM_CONTENT01),
1416                                                   ResourceManager::GetString(IDS_ST_BODY_SAVE_TO));
1417
1418         pItem->AddControl(pLabel);
1419
1420         pLabel->SetTextColor(Color(COLOR_DETAIL02));
1421         pLabel->SetTextConfig(FONT_SIZE_DETAIL02, LABEL_TEXT_STYLE_NORMAL);
1422         pLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1423
1424         pContentLabel = new (std::nothrow) Label();
1425         pContentLabel->Construct(Rectangle(0, Y_ITEM_CONTENT02, itemWidth, H_ITEM_CONTENT02), calendarName);
1426
1427         pItem->AddControl(pContentLabel);
1428
1429         pContentLabel->SetTextConfig(FONT_SIZE_DETAIL03, LABEL_TEXT_STYLE_NORMAL);
1430         pContentLabel->SetTextHorizontalAlignment(ALIGNMENT_LEFT);
1431
1432         __pLabelSaveTo = pContentLabel;
1433
1434         if (!__pPm->IsEditableRecurrence())
1435         {
1436                 pItem->SetEnabled(false);
1437                 pLabel->SetTextColor(Color(COLOR_DISABLE));
1438                 pContentLabel->SetTextColor(Color(COLOR_DISABLE));
1439         }
1440
1441         return pItem;
1442 }
1443
1444 result
1445 EventEditorForm::SetStyle(EditEventFormStyle style)
1446 {
1447         Header* pHeader = GetHeader();
1448         if (style == EDIT_EVENT_FORM_STYLE_CREATE)
1449         {
1450                 pHeader->SetTitleText(ResourceManager::GetString(IDS_CLD_HEADER_CREATE_EVENT));
1451         }
1452         else
1453         {
1454                 pHeader->SetTitleText(ResourceManager::GetString(IDS_CLD_HEADER_EDIT_EVENT));
1455         }
1456         pHeader->Invalidate(false);
1457
1458         if (__pTableView != null)
1459         {
1460                 __pEditFieldTitle = null;
1461                 __pEditFieldLocation = null;
1462                 __pEditDateStartDate = null;
1463                 __pEditTimeStartTime = null;
1464                 __pEditDateEndDate = null;
1465                 __pEditTimeEndTime = null;
1466                 __pExpandableEditAreaNote = null;
1467                 __pTableView->UpdateTableView();
1468         }
1469
1470         __style = style;
1471
1472         if (__pPm->GetSubject().GetLength() > EDITFIELD_LIMIT_LENGTH
1473                 || __pPm->GetLocation().GetLength() > EDITFIELD_LIMIT_LENGTH)
1474         {
1475                 MessageBox msgBox;
1476                 msgBox.Construct(L"", ResourceManager::GetString(IDS_IMGE_POP_TEXT_TOO_LONG),
1477                                                 MSGBOX_STYLE_NONE, MESSAGE_BOX_TIME_OUT);
1478
1479                 int modalResult;
1480                 msgBox.ShowAndWait(modalResult);
1481         }
1482
1483         return E_SUCCESS;
1484 }
1485
1486 result
1487 EventEditorForm::SendAppControlResult(AppCtrlResult appControlResult)
1488 {
1489         CalendarApp* pApp = static_cast<CalendarApp*>(UiApp::GetInstance());
1490         TryReturn(pApp != null, E_FAILURE, "[E_FAILURE] Unable to get app instance.");
1491
1492         result r = AppControlProviderManager::GetInstance()->SendAppControlResult(pApp->GetRequestId(), appControlResult, null);
1493         AppLogDebugIf(r != E_SUCCESS, "[%s] Unable to return result.", GetErrorMessage(r));
1494
1495         return r;
1496 }
1497
1498 result
1499 EventEditorForm::UpdatePm(void)
1500 {
1501         if (__pEditFieldTitle)
1502         {
1503                 __pPm->SetSubject(__pEditFieldTitle->GetText());
1504         }
1505
1506         DateTime startTime;
1507         DateTime endTime;
1508         if (__pEditDateStartDate && __pEditTimeStartTime)
1509         {
1510                 startTime.SetValue(__pEditDateStartDate->GetYear(), __pEditDateStartDate->GetMonth(), __pEditDateStartDate->GetDay(),
1511                                 __pEditTimeStartTime->GetHour(), __pEditTimeStartTime->GetMinute());
1512         }
1513         if (__pEditDateEndDate && __pEditTimeEndTime)
1514         {
1515                 endTime.SetValue(__pEditDateEndDate->GetYear(), __pEditDateEndDate->GetMonth(), __pEditDateEndDate->GetDay(),
1516                                 __pEditTimeEndTime->GetHour(), __pEditTimeEndTime->GetMinute());
1517         }
1518
1519         __pPm->SetStartTime(startTime);
1520         __pPm->SetEndTime(endTime);
1521
1522         if (__pExpandableEditAreaNote)
1523         {
1524                 __pPm->SetDescription(__pExpandableEditAreaNote->GetText());
1525         }
1526
1527         if (__pEditFieldLocation)
1528         {
1529                 __pPm->SetLocation(__pEditFieldLocation->GetText());
1530         }
1531
1532         return E_SUCCESS;
1533 }