source/forms/main/frmMain.cpp

   1 // frmMain.h - frmMain form functions
   2 //
   3 // (c) 2016-2017 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Calendar.
   6 //
   7 // Xestia Calendar is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU General Public License as published by the
   9 // Free Software Foundation, version 3 of the license.
  10 //
  11 // Xestia Calendar is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License along
  17 // with Xestia Calendar. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include "frmMain.h"
  20
  21 frmMain::frmMain( wxWindow* parent )
  22 :
  23 frmMainADT( parent )
  24 {
  25
  26         // Setup the default settings if they don't
  27         // exist.
  28
  29         // Setup the preferences.
  30         wxString prefDirectory = GetUserPrefDir();
  31         preferences = new XCALPreferences(prefDirectory);
  32
  33         // Load the settings.
  34
  35         wxString fullPrefPath;
  36
  37         fullPrefPath.Append(prefDirectory);
  38         fullPrefPath.Append(wxT("settings"));
  39
  40         wxFileConfig *settingfile = new wxFileConfig("", "", fullPrefPath);
  41
  42         wxString ValueInc;
  43         settingfile->Read(wxT("SaveWindowPosition"), &ValueInc);
  44
  45         if (ValueInc == wxT("true")){
  46
  47                 wxRect windowPosition;
  48
  49                 long posX, posY, posH, posW = 0;
  50
  51                 bool posXValid, posYValid, posHValid, posWValid = false;
  52
  53                 posXValid = settingfile->Read(wxT("WindowPositionX"), &posX);
  54                 posYValid = settingfile->Read(wxT("WindowPositionY"), &posY);
  55                 posHValid = settingfile->Read(wxT("WindowPositionHeight"), &posH);
  56                 posWValid = settingfile->Read(wxT("WindowPositionWidth"), &posW);
  57
  58                 if (posXValid == true && posYValid == true && posHValid == true && posWValid == true){
  59
  60                         this->SetSize(posX, posY, posH, posW);
  61
  62                 } else {
  63
  64                         this->SetSize(-1, -1, 800, 600);
  65
  66                 }
  67
  68         }
  69
  70         // Load the account data.
  71
  72         LoadAccountData();
  73
  74         // Setup the form control.
  75
  76         mainCalendarCtrl = new XCCalendarCtrl(this, &calendarData);
  77         szrMain->Add(mainCalendarCtrl, 1, wxEXPAND, 5);
  78         szrMain->Layout();
  79
  80         Connect(ID_PROCESSCALENDAR, XCMAIN_PROCESSCALENDAR, wxCommandEventHandler(frmMain::ProcessCalendar));
  81         Connect(ID_EDITCALENDAR, XCMAIN_EDITCALENDAR, wxCommandEventHandler(frmMain::EditCalendar));
  82         Connect(ID_DELETECALENDAR, XCMAIN_DELETECALENDAR, wxCommandEventHandler(frmMain::DeleteCalendar));
  83         Connect(ID_DELETEEVENT, XCMAIN_DELETEEVENT, wxCommandEventHandler(frmMain::DeleteEvent));
  84         Connect(ID_ADDENTRY, XCMAIN_ADDEVENT, wxCommandEventHandler(frmMain::AddEvent));
  85         Connect(ID_UPDATEENTRY, XCMAIN_UPDATEEVENT, wxCommandEventHandler(frmMain::UpdateEvent));
  86         Connect(ID_EDITEVENT, XCMAIN_EDITEVENT, wxCommandEventHandler(frmMain::EditEvent));
  87
  88         Connect(ID_ADDWINDOW, XCMAIN_ADDWINDOWINFO, wxCommandEventHandler(frmMain::WindowAdd));
  89         Connect(ID_UPDATEWINDOW, XCMAIN_UPDATEWINDOWINFO, wxCommandEventHandler(frmMain::WindowUpdate));
  90         Connect(ID_DELETEWINDOW, XCMAIN_DELETEWINDOWINFO, wxCommandEventHandler(frmMain::WindowDelete));
  91
  92 }
  93
  94 void frmMain::QuitApp( wxCloseEvent& event )
  95 {
  96
  97         // Run the QuitApp function.
  98
  99         QuitApp();
 100
 101 }
 102
 103 void frmMain::QuitApp( wxCommandEvent& event )
 104 {
 105
 106         // Run the QuitApp function.
 107
 108         QuitApp();
 109
 110 }
 111
 112 void frmMain::QuitApp()
 113 {
 114
 115         // Function to run when quitting.
 116
 117         //Go through the windows and close each one (be it search
 118         //or contact editor). Abort if user wants to cancel.
 119
 120         // Close the contact editor windows.
 121
 122         // Close the contact windows.
 123
 124         // Close the search windows.
 125
 126         // Write out the ETag databases.
 127
 128         // Save Preferences: Save the window position if that option is enabled.
 129
 130         wxString SetFilename = GetUserPrefDir();
 131
 132 #if defined(__HAIKU__)
 133
 134
 135
 136 #elif defined(__WIN32__)
 137
 138         SetFilename.Append(wxT("settings"));
 139
 140 #else
 141
 142         // *nix OSes
 143
 144         SetFilename.Append(wxT("settings"));
 145
 146 #endif
 147
 148         wxFileConfig *cfgfile = new wxFileConfig("", "", SetFilename);
 149
 150         bool SaveWindowPos = false;
 151         wxString SaveWindowInc;
 152         cfgfile->Read(wxT("SaveWindowPosition"), &SaveWindowInc);
 153
 154         if (SaveWindowInc == wxT("true")){
 155
 156                 SaveWindowPos = true;
 157
 158         }
 159
 160         if (SaveWindowPos == true){
 161
 162                 wxRect frmMainPos = this->GetRect();
 163
 164                 cfgfile->Write(wxT("WindowPositionX"), frmMainPos.GetX());
 165                 cfgfile->Write(wxT("WindowPositionY"), frmMainPos.GetY());
 166                 cfgfile->Write(wxT("WindowPositionHeight"), frmMainPos.GetHeight());
 167                 cfgfile->Write(wxT("WindowPositionWidth"), frmMainPos.GetWidth());
 168
 169         }
 170
 171         delete cfgfile;
 172         cfgfile = nullptr;
 173
 174         //Everything closed... exit.
 175
 176         std::exit(0);
 177
 178         Close();
 179
 180 }
 181
 182 void frmMain::LoadAccountData(){
 183
 184         // Get the list of accounts and put into the calendar data storage.
 185
 186         int accountCount = preferences->accounts.GetCount();
 187
 188         for (int accountSeek = 0; accountSeek < accountCount; accountSeek++){
 189
 190                 CDSAccountResult addResult = calendarData.AddAccount(string(preferences->accounts.GetAccountName(accountSeek).mb_str()), accountSeek);
 191
 192         }
 193
 194         // Get the list of calendars and put them into the calendar data storage.
 195
 196         for (int accountSeek = 0; accountSeek < accountCount; accountSeek++){
 197
 198                 CDSGetAccountInfo accountInfo = calendarData.GetAccount(string(preferences->accounts.GetAccountName(accountSeek).mb_str()));
 199
 200                 // Build the path.
 201
 202                 string calendarListFilename = string(GetUserDir().mb_str());
 203                 calendarListFilename += "accounts/";
 204                 calendarListFilename += string(preferences->accounts.GetAccountDirectory(accountSeek).mb_str());
 205                 calendarListFilename += ".";
 206                 calendarListFilename += string(preferences->accounts.GetAccountType(accountSeek).mb_str());
 207
 208                 // Get the list of calendars.
 209
 210                 XCAccountCalendarList calendarList(calendarListFilename);
 211
 212                 // Add the calendar and set the calendar ID for it.
 213
 214                 for (int calendarSeek = 0; calendarSeek < calendarList.calendarShortName.size(); calendarSeek++){
 215
 216                         // Add the calendar.
 217
 218                         CDSCalendarResult calendarAddResult = calendarData.AddCalendar(accountInfo.accountID,
 219                                 calendarList.calendarName[calendarSeek],
 220                                 calendarList.calendarShortName[calendarSeek],
 221                                 calendarList.calendarColour[calendarSeek],
 222                                 calendarList.calendarDescription[calendarSeek]);
 223
 224                         // Set the calendar ID.
 225
 226                         CDSGetCalendarInfo calendarInfo = calendarData.GetCalendar(string(preferences->accounts.GetAccountName(accountSeek).mb_str()), calendarList.calendarShortName[calendarSeek]);
 227                         calendarList.calendarStorageID[calendarSeek] = calendarInfo.calendarID;
 228
 229                         // Find the entries and load each entry.
 230
 231                         string calendarListDirectory = calendarListFilename;
 232                         calendarListDirectory += "/";
 233                         calendarListDirectory += calendarList.calendarShortName[calendarSeek];
 234                         calendarListDirectory += "/";
 235
 236                         wxDir entryListDirectory(calendarListDirectory);
 237                         wxString entryListFilename;
 238
 239                         bool continueProcessing = entryListDirectory.GetFirst(&entryListFilename, "*.ics", wxDIR_NO_FOLLOW|wxDIR_FILES);
 240
 241                         while (continueProcessing){
 242
 243                                 string entryListFullFilename;
 244                                 entryListFullFilename += calendarListDirectory;
 245                                 entryListFullFilename += string(entryListFilename.mb_str());
 246
 247                                 continueProcessing = entryListDirectory.GetNext(&entryListFilename);
 248                                 CDSAddEntryResult addEventResult = calendarData.AddEvent(calendarInfo.calendarID, entryListFullFilename);
 249
 250                         }
 251
 252                 }
 253
 254         }
 255
 256 }
 257
 258 void frmMain::ShowPreferencesWindow( wxCommandEvent& event )
 259 {
 260
 261         // Close all windows first.
 262
 263         if (CloseAllWindows() == false)
 264         {
 265                 return;
 266         }
 267
 268         // Open the preferences window.
 269
 270         reloadAccounts = FALSE;
 271
 272         frmPreferences *framePreferences = new frmPreferences ( this );
 273         framePreferences->SetupPointers(&reloadAccounts);
 274         framePreferences->ShowModal();
 275         delete framePreferences;
 276         framePreferences = NULL;
 277
 278         // Reload the preferences.
 279
 280         if (reloadAccounts == true){
 281
 282                 // Reload the accounts as a change has been made within
 283                 // the application.
 284
 285                 wxString prefDirectory = GetUserPrefDir();
 286                 XCALPreferences *oldPreferences = preferences;
 287                 preferences = new XCALPreferences(prefDirectory);
 288
 289                 delete oldPreferences;
 290                 oldPreferences = nullptr;
 291
 292                 // Clear all of the data from the calendar data storage.
 293
 294                 calendarData.Clear();
 295                 LoadAccountData();
 296
 297                 // Politely ask the calendar control to reload it's view.
 298
 299                 wxCommandEvent updateGrid(XCCALENDARCTRL_CHANGEGRID);
 300                 updateGrid.SetId(ID_CHANGEGRID);
 301                 wxPostEvent(mainCalendarCtrl, updateGrid);
 302
 303         }
 304
 305 }
 306
 307 void frmMain::ShowAboutWindow( wxCommandEvent& event )
 308 {
 309
 310         // Show the about window.
 311
 312         frmAbout *frameAbout = new frmAbout ( this );
 313         frameAbout->SetupAboutWindow();
 314         frameAbout->ShowModal();
 315         delete frameAbout;
 316         frameAbout = NULL;
 317
 318 }
 319
 320 void frmMain::ShowUpdateWindow( wxCommandEvent& event )
 321 {
 322
 323         frmUpdate *frameUpdate = new frmUpdate ( this );
 324         frameUpdate->FetchData();
 325         frameUpdate->ShowModal();
 326         delete frameUpdate;
 327         frameUpdate = NULL;
 328
 329 }
 330
 331 void frmMain::OpenNewAccountDialog( wxCommandEvent& event )
 332 {
 333
 334         // Open the new account dialog.
 335
 336         reloadAccounts = false;
 337
 338         frmNewAccount *frameNewAccount = new frmNewAccount ( this );
 339         frameNewAccount->SetupPointers(&reloadAccounts, &calendarData);
 340         frameNewAccount->ShowModal();
 341         delete frameNewAccount;
 342         frameNewAccount = NULL;
 343
 344         // Reload the preferences.
 345
 346         if (reloadAccounts == true){
 347
 348                 // Reload the accounts as a change has been made within
 349                 // the application.
 350
 351                 wxString prefDirectory = GetUserPrefDir();
 352                 XCALPreferences *oldPreferences = preferences;
 353                 preferences = new XCALPreferences(prefDirectory);
 354
 355                 delete oldPreferences;
 356                 oldPreferences = nullptr;
 357
 358                 // Clear all of the data from the calendar data storage.
 359
 360                 calendarData.Clear();
 361                 LoadAccountData();
 362
 363                 // Politely ask the calendar control to reload it's view.
 364
 365                 wxCommandEvent updateGrid(XCCALENDARCTRL_CHANGEGRID);
 366                 updateGrid.SetId(ID_CHANGEGRID);
 367                 wxPostEvent(mainCalendarCtrl, updateGrid);
 368
 369         }
 370
 371 }
 372
 373 void frmMain::CreateNewCalendar( wxCommandEvent& event )
 374 {
 375
 376         frmCalendarEditor *frameNewCalendar = new frmCalendarEditor ( this );
 377         frameNewCalendar->SetMode(false);
 378         frameNewCalendar->SetupAccounts(preferences);
 379         frameNewCalendar->ShowModal();
 380         delete frameNewCalendar;
 381         frameNewCalendar = nullptr;
 382
 383 }
 384
 385 void frmMain::EditCalendar( wxCommandEvent& event )
 386 {
 387
 388         // Close all windows first.
 389
 390         if (CloseAllWindows() == false)
 391         {
 392                 return;
 393         }
 394
 395         // Get the calendar data.
 396
 397         CDSGetCalendarInfo calendarInfo = calendarData.GetCalendar(event.GetInt());
 398
 399         frmCalendarEditor *frameNewCalendar = new frmCalendarEditor ( this );
 400         frameNewCalendar->SetMode(true);
 401         frameNewCalendar->SetupAccounts(preferences);
 402         frameNewCalendar->SetData(event.GetInt(), calendarInfo.accountName, calendarInfo.calendarName, calendarInfo.calendarDescription, calendarInfo.calendarColour);
 403         frameNewCalendar->ShowModal();
 404         delete frameNewCalendar;
 405         frameNewCalendar = nullptr;
 406
 407 }
 408
 409 void frmMain::DeleteCalendar( wxCommandEvent& event )
 410 {
 411
 412         // Close all windows first.
 413
 414         if (CloseAllWindows() == false)
 415         {
 416                 return;
 417         }
 418
 419         CalendarProperties *calendarEventInfo = (CalendarProperties*)event.GetClientData();
 420
 421         // Get the calendar data.
 422
 423         CDSGetCalendarInfo calendarInfo = calendarData.GetCalendar(calendarEventInfo->calendarID);
 424
 425         if (wxMessageBox(wxString::Format("Are you sure you want to delete the calendar %s from the %s account?", calendarInfo.calendarName, calendarInfo.accountName), "Delete calendar", wxYES_NO|wxICON_QUESTION) == wxNO){
 426                 return;
 427         }
 428
 429         // Go through the grid and delete each calendar entry widget that
 430         // is associated with the calendar.
 431
 432         wxCommandEvent deleteCalendar(XCCALENDARCTRL_DELETECALENDARENTRIES);
 433         deleteCalendar.SetId(ID_DELETECALENDARENTRIES);
 434         deleteCalendar.SetInt(calendarInfo.calendarID);
 435         wxPostEvent(mainCalendarCtrl, deleteCalendar);
 436
 437         // Get the account configuration file and delete the calendar information.
 438
 439         CDSGetAccountInfo accountInfo = calendarData.GetAccount(calendarInfo.accountName);
 440
 441         string accountDirectoryPath = string(GetUserDir().mb_str());
 442         accountDirectoryPath += "accounts/";
 443         accountDirectoryPath += string(preferences->accounts.GetAccountDirectory(calendarEventInfo->accountPreferencesID).mb_str());
 444         accountDirectoryPath += ".";
 445         accountDirectoryPath += string(preferences->accounts.GetAccountType(calendarEventInfo->accountPreferencesID).mb_str());
 446         accountDirectoryPath += "/";
 447
 448         string calendarListFilenameFull = accountDirectoryPath;
 449         calendarListFilenameFull += "calendarlist.db";
 450
 451         string calendarDirectoryPath = accountDirectoryPath;
 452         calendarDirectoryPath += calendarInfo.calendarTextID;
 453
 454         wxFileConfig *calendarListFile = new wxFileConfig("", "", wxString(calendarListFilenameFull));
 455
 456         //calendarListFile->SetPath(wxString(calendarInfo.calendarTextID));
 457         calendarListFile->DeleteGroup(wxString(calendarInfo.calendarTextID));
 458
 459         // Delete the calendar directory.
 460
 461         wxDir entryListDirectory((wxString)calendarDirectoryPath.c_str());
 462         wxString entryListFilename;
 463
 464         bool continueProcessing = entryListDirectory.GetFirst(&entryListFilename, "*", wxDIR_NO_FOLLOW|wxDIR_FILES);
 465
 466         while (continueProcessing){
 467
 468                 string entryListFullFilename;
 469                 entryListFullFilename += calendarDirectoryPath;
 470                 entryListFullFilename += "/";
 471                 entryListFullFilename += string(entryListFilename.mb_str());
 472
 473                 wxRemoveFile(wxString(entryListFullFilename.c_str()));
 474
 475                 continueProcessing = entryListDirectory.GetNext(&entryListFilename);
 476
 477         }
 478
 479         wxRmdir(calendarDirectoryPath);
 480
 481         // Delete the calendar from the calendar data storage.
 482
 483         calendarData.DeleteCalendar(calendarEventInfo->calendarID);
 484
 485         delete calendarListFile;
 486         calendarListFile = nullptr;
 487
 488         delete calendarEventInfo;
 489         calendarEventInfo = nullptr;
 490
 491 }
 492
 493 void frmMain::CreateNewEvent( wxCommandEvent& event ){
 494
 495         frmEventEditor *frameNewEvent = new frmEventEditor ( this );
 496         frameNewEvent->SetupForm(&calendarData, preferences);
 497         frameNewEvent->SetWindowMenuItemID(++WindowMenuItemID);
 498
 499         // Add the window to the window list.
 500
 501         WindowData *newWindowData = new WindowData;
 502
 503         newWindowData->DataType = 1;
 504         newWindowData->WindowPointer = (void*)frameNewEvent;
 505         newWindowData->WindowID = WindowMenuItemID;
 506
 507         wxCommandEvent addevent(XCMAIN_ADDWINDOWINFO);
 508         addevent.SetId(ID_ADDWINDOW);
 509         addevent.SetClientData(newWindowData);
 510         wxPostEvent(this, addevent);
 511
 512         frameNewEvent->Show();
 513
 514 }
 515
 516 void frmMain::EditEvent( wxCommandEvent& event ){
 517
 518         frmEventEditor *frameEditEvent = new frmEventEditor ( this );
 519         frameEditEvent->SetEventID(event.GetInt());
 520         frameEditEvent->SetEditMode(true);
 521         frameEditEvent->SetWindowMenuItemID(++WindowMenuItemID);
 522         frameEditEvent->SetupForm(&calendarData, preferences);
 523
 524         // Add the window to the window list.
 525
 526         WindowData *newWindowData = new WindowData;
 527
 528         newWindowData->DataType = 1;
 529         newWindowData->WindowPointer = (void*)frameEditEvent;
 530         newWindowData->WindowID = WindowMenuItemID;
 531
 532         wxCommandEvent addevent(XCMAIN_ADDWINDOWINFO);
 533         addevent.SetId(ID_ADDWINDOW);
 534         addevent.SetClientData(newWindowData);
 535         wxPostEvent(this, addevent);
 536
 537         // Setup the form and display it.
 538
 539         frameEditEvent->Show();
 540
 541 }
 542
 543 void frmMain::DeleteEvent( wxCommandEvent& event ){
 544
 545         EventProperties *eventInfo = (EventProperties*)event.GetClientData();
 546
 547         // Get the event information.
 548
 549         CDSGetCalendarEntryInfo eventDeleteData = calendarData.GetEvent(eventInfo->eventID);
 550         CDSGetCalendarInfo calendarDeleteData = calendarData.GetCalendar(eventInfo->calendarID);
 551
 552         if (wxMessageBox(wxString::Format("Are you sure you want to delete the event %s from the %s calendar?", eventDeleteData.entryName, calendarDeleteData.calendarName), "Delete event", wxYES_NO|wxICON_QUESTION) == wxNO){
 553                 return;
 554         }
 555
 556         // Go through the grid and delete the entry from the GUI.
 557
 558         wxCommandEvent deleteEvent(XCCALENDARCTRL_DELETEENTRY);
 559         deleteEvent.SetId(ID_DELETEENTRY);
 560         deleteEvent.SetInt(eventInfo->eventID);
 561         wxPostEvent(mainCalendarCtrl, deleteEvent);
 562
 563         // Get the filename and delete the entry.
 564
 565         wxRemoveFile(wxString(eventDeleteData.entryFilename.c_str()));
 566
 567         // Delete the entry from the calendar data storage.
 568
 569         calendarData.DeleteEvent(eventInfo->eventID);
 570
 571         delete eventInfo;
 572         eventInfo = nullptr;
 573
 574 }
 575
 576 void frmMain::AddEvent( wxCommandEvent& event )
 577 {
 578
 579         EventProperties *eventInfo = (EventProperties*)event.GetClientData();
 580
 581         wxCommandEvent addEvent(XCCALENDARCTRL_ADDENTRY);
 582         addEvent.SetId(ID_ADDENTRY);
 583         addEvent.SetClientData(eventInfo);
 584         wxPostEvent(mainCalendarCtrl, addEvent);
 585
 586 }
 587
 588 void frmMain::UpdateEvent( wxCommandEvent& event )
 589 {
 590
 591         EventProperties *eventInfo = (EventProperties*)event.GetClientData();
 592
 593         wxCommandEvent updateEvent(XCCALENDARCTRL_UPDATEENTRY);
 594         updateEvent.SetId(ID_UPDATEENTRY);
 595         updateEvent.SetClientData(eventInfo);
 596         wxPostEvent(mainCalendarCtrl, updateEvent);
 597
 598 }
 599
 600 void frmMain::ProcessCalendar( wxCommandEvent& event )
 601 {
 602
 603         CalendarProperties *calendarInfo = (CalendarProperties*)event.GetClientData();
 604
 605         // Get the account name.
 606
 607         CDSGetAccountInfo accountInfo = calendarData.GetAccount(calendarInfo->accountName);
 608
 609         // Build the account directory path.
 610
 611         string accountDirectoryPath = string(GetUserDir().mb_str());
 612         accountDirectoryPath += "accounts/";
 613         accountDirectoryPath += string(preferences->accounts.GetAccountDirectory(calendarInfo->accountPreferencesID).mb_str());
 614         accountDirectoryPath += ".";
 615         accountDirectoryPath += string(preferences->accounts.GetAccountType(calendarInfo->accountPreferencesID).mb_str());
 616         accountDirectoryPath += "/";
 617
 618         // Generate a UUID for the new calendar.
 619
 620         string calendarPath = accountDirectoryPath;
 621
 622         string calendarUUID = "";
 623
 624         if (calendarInfo->editMode == false){
 625
 626                 calendarUUID = GenerateUUID();
 627                 calendarPath += calendarUUID;
 628
 629         } else {
 630
 631                 calendarUUID = calendarData.GetCalendar(calendarInfo->calendarID).calendarTextID;
 632                 calendarPath += calendarPath;
 633
 634         }
 635
 636         calendarPath += "/";
 637
 638         // Open the account's calendar file and add to the list of calendars.
 639
 640         string calendarListFilenameFull = accountDirectoryPath;
 641         calendarListFilenameFull += "calendarlist.db";
 642
 643         wxFileConfig *calendarListFile = new wxFileConfig("", "", wxString(calendarListFilenameFull));
 644
 645         wxString calendarDescription = wxString(calendarInfo->calendarDescription);
 646
 647         calendarDescription.Replace("\n", "\\n", true);
 648
 649         // Create the directory for the calendar entries if
 650         // not editing a calendar.
 651
 652         calendarListFile->SetPath(wxString(calendarUUID));
 653         calendarListFile->Write(wxT("name"), wxString(calendarInfo->calendarName));
 654         calendarListFile->Write(wxT("description"), calendarDescription);
 655         calendarListFile->Write(wxT("colour"), wxString(calendarInfo->calendarColour));
 656
 657         if (calendarInfo->editMode == false){
 658
 659                 wxMkDir(wxString(calendarPath), wxS_DIR_DEFAULT);
 660                 calendarData.AddCalendar(accountInfo.accountID, calendarInfo->calendarName, calendarUUID, calendarInfo->calendarColour, calendarInfo->calendarDescription);
 661
 662         } else {
 663
 664                 calendarData.UpdateCalendar(calendarInfo->calendarID, calendarInfo->calendarName, calendarInfo->calendarColour, calendarInfo->calendarDescription);
 665
 666                 // Post event to update the colour in the calendar entries.
 667
 668                 updateColourData.calendarID = calendarInfo->calendarID;
 669                 updateColourData.newColour.red = calendarInfo->calendarColour.red;
 670                 updateColourData.newColour.green = calendarInfo->calendarColour.green;
 671                 updateColourData.newColour.blue = calendarInfo->calendarColour.blue;
 672                 updateColourData.newColour.alpha = calendarInfo->calendarColour.alpha;
 673
 674                 wxCommandEvent updateColour(XCCALENDARCTRL_UPDATECALENDARCOLOUR);
 675                 updateColour.SetClientData(&updateColourData);
 676                 updateColour.SetId(ID_UPDATECOLOUR);
 677                 wxPostEvent(mainCalendarCtrl, updateColour);
 678
 679         }
 680
 681         // Add the calendar to the calendar data storage.
 682
 683         delete calendarListFile;
 684         calendarListFile = nullptr;
 685
 686         delete calendarInfo;
 687         calendarInfo = nullptr;
 688
 689 }
 690
 691 void frmMain::ShowHelp( wxCommandEvent& event )
 692 {
 693
 694         wxMessageBox(_("The help documentation will be implemented in a future version of Xestia Calendar."), _("Unimplemented"));
 695
 696 }