source/frmMain.cpp

   1 // frmMain.cpp - Main window form.
   2 //
   3 // (c) 2012-2015 Xestia Software Development.
   4 //
   5 // This file is part of Xestia Address Book.
   6 //
   7 // Xestia Address Book 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 Address Book 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 Address Book. If not, see <http://www.gnu.org/licenses/>
  18
  19 #include <iostream>
  20 #include <algorithm>
  21 #include <vector>
  22 #include <thread>
  23
  24 #include <wx/wx.h>
  25 #include <wx/tokenzr.h>
  26 #include <wx/icon.h>
  27 #include <wx/mstream.h>
  28 #include <wx/fs_mem.h>
  29 #include <wx/ffile.h>
  30 #include <wx/filesys.h>
  31 #include <wx/dir.h>
  32 #include <wx/stdpaths.h>
  33 #include <wx/fileconf.h>
  34 #include <wx/gdicmn.h>
  35
  36 // Include the forms.
  37
  38 #include "frmMain.h"
  39 #include "frmAbout.h"
  40 #include "frmPreferences.h"
  41 #include "frmNewAccount.h"
  42 #include "frmActivityMgr.h"
  43 #include "frmContact.h"
  44 #include "frmConflictResolution.h"
  45 #include "frmInvalidSSLCertificate.h"
  46 #include "frmSearch.h"
  47 #include "frmSSLCertificate.h"
  48 #include "frmUpdate.h"
  49 #include "import/frmImportResults.h"
  50 #include "bitmaps.h"
  51
  52 #include "common/preferences.h"
  53 #include "common/getcontactinfo.h"
  54 #include "common/events.h"
  55 #include "common/dirs.h"
  56 #include "vcard/vcard.h"
  57 #include "carddav/carddav.h"
  58 #include "contacteditor/frmContactEditor.h"
  59 #include "import/import.h"
  60 #include "export/export.h"
  61 #include "widgets/XABContactMenu.h"
  62 #include "widgets/XABAccountView.h"
  63
  64 #include "version.h"
  65
  66 //extern const wxEventType MyHaremEvent = wxNewEventType();
  67
  68 //#define CE_UPDATECONTACTLIST 7700
  69 //#define CE_UPDATEACCOUNTLIST 7701
  70
  71 DEFINE_EVENT_TYPE(CE_UPDATECONTACTLIST);
  72 DEFINE_EVENT_TYPE(CE_UPDATEACCOUNTLIST);
  73 DEFINE_EVENT_TYPE(SE_UPDATECONTACTNOTIF);
  74 DEFINE_EVENT_TYPE(CE_OPENCONTACT);
  75 DEFINE_EVENT_TYPE(CE_OPENCONTACTLIST);
  76 DEFINE_EVENT_TYPE(CE_NEWCONTACT);
  77 DEFINE_EVENT_TYPE(CE_EDITCONTACT);
  78 DEFINE_EVENT_TYPE(CE_DELETECONTACT);
  79 DEFINE_EVENT_TYPE(CE_REVEALCONTACT);
  80 DEFINE_EVENT_TYPE(CE_REMOVECONTACT);
  81 DEFINE_EVENT_TYPE(CE_REMOVESEARCH);
  82 DEFINE_EVENT_TYPE(SYNC_EMPTYSERVER);
  83 DEFINE_EVENT_TYPE(ACTMGR_START);
  84 DEFINE_EVENT_TYPE(ACTMGR_SHUFFLE);
  85 DEFINE_EVENT_TYPE(ACTMGR_STOP);
  86 DEFINE_EVENT_TYPE(WINDOW_ADD);
  87 DEFINE_EVENT_TYPE(WINDOW_EDIT);
  88 DEFINE_EVENT_TYPE(WINDOW_CLOSE);
  89 DEFINE_EVENT_TYPE(CONNSTAT_UPDATE);
  90 DEFINE_EVENT_TYPE(INVALIDSSLCERT);
  91 DEFINE_EVENT_TYPE(GETSELECTEDLIST);
  92 DEFINE_EVENT_TYPE(SYNCACCOUNT);
  93 DEFINE_EVENT_TYPE(IMPORT_RESULTSSHOW);
  94 DEFINE_EVENT_TYPE(RELOADCONTACTLIST);
  95 DEFINE_EVENT_TYPE(REFRESHADDRESSBOOK);
  96
  97 BEGIN_EVENT_TABLE(frmMain, wxFrame)
  98 EVT_COMMAND(wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, frmMain::ConflictResolution)
  99 EVT_COMMAND(wxID_ANY, CE_UPDATECONTACTLIST, frmMain::UpdateContactList)
 100 EVT_COMMAND(wxID_ANY, CE_UPDATEACCOUNTLIST, frmMain::UpdateAccountList)
 101 EVT_COMMAND(wxID_ANY, SE_UPDATECONTACTNOTIF, frmMain::UpdateSearchContactLists)
 102 EVT_COMMAND(wxID_ANY, CE_OPENCONTACT, frmMain::OpenContactInfo)
 103 EVT_COMMAND(wxID_ANY, CE_OPENCONTACTLIST, frmMain::OpenContactInfoList)
 104 EVT_COMMAND(wxID_ANY, CE_NEWCONTACT, frmMain::ShowContactEditorNew)
 105 EVT_COMMAND(wxID_ANY, CE_EDITCONTACT, frmMain::ShowContactEditorEdit)
 106 EVT_COMMAND(wxID_ANY, CE_DELETECONTACT, frmMain::DeleteContact)
 107 EVT_COMMAND(wxID_ANY, CE_REVEALCONTACT, frmMain::RevealContact)
 108 EVT_COMMAND(wxID_ANY, CE_REMOVESEARCH, frmMain::RemoveContactsWindowPointer)
 109 EVT_COMMAND(wxID_ANY, SYNC_EMPTYSERVER, frmMain::EmptyServerDialog)
 110 EVT_COMMAND(wxID_ANY, ACTMGR_START, frmMain::ActivityIconStart)
 111 EVT_COMMAND(wxID_ANY, ACTMGR_SHUFFLE, frmMain::ActivityIconShuffle)
 112 EVT_COMMAND(wxID_ANY, ACTMGR_STOP, frmMain::ActivityIconStop)
 113 EVT_COMMAND(wxID_ANY, WINDOW_ADD, frmMain::WindowAdd)
 114 EVT_COMMAND(wxID_ANY, WINDOW_EDIT, frmMain::WindowEdit)
 115 EVT_COMMAND(wxID_ANY, WINDOW_CLOSE, frmMain::WindowDelete)
 116 EVT_COMMAND(wxID_ANY, CONNSTAT_UPDATE, frmMain::UpdateConnectionStatus)
 117 EVT_COMMAND(wxID_ANY, INVALIDSSLCERT, frmMain::InvalidSSLCertificate)
 118 EVT_COMMAND(wxID_ANY, GETSELECTEDLIST, frmMain::GetSelectedList)
 119 EVT_COMMAND(wxID_ANY, SYNCACCOUNT, frmMain::SyncAccount)
 120 EVT_COMMAND(wxID_ANY, IMPORT_RESULTSSHOW, frmMain::ShowImportResults)
 121 EVT_COMMAND(wxID_ANY, RELOADCONTACTLIST, frmMain::ReloadContactList)
 122 EVT_COMMAND(wxID_ANY, REFRESHADDRESSBOOK, frmMain::RefreshAddressBook)
 123 END_EVENT_TABLE()
 124
 125 frmMain::frmMain( wxWindow* parent )
 126 :
 127 frmMainADT( parent )
 128 {
 129
 130     // Setup the account icons.
 131
 132     wxMemoryInputStream astream(icons_accinet_png, sizeof(icons_accinet_png));
 133     wxMemoryInputStream bstream(icons_acclocal_png, sizeof(icons_acclocal_png));
 134     wxMemoryInputStream cstream(icons_accgroup_png, sizeof(icons_accgroup_png));
 135     wxMemoryInputStream dstream(icons_accnone_png, sizeof(icons_accnone_png));
 136
 137     wxImage icons_accinet_png(astream, wxBITMAP_TYPE_PNG);
 138     wxBitmap AccInet(icons_accinet_png, -1);
 139     wxIcon wxIAccInet;
 140     wxIAccInet.CopyFromBitmap(AccInet);
 141
 142     wxImage icons_acclocal_png(bstream, wxBITMAP_TYPE_PNG);
 143     wxBitmap AccNIcon(icons_acclocal_png, -1);
 144     wxIcon wxIAccNIcon;
 145     wxIAccNIcon.CopyFromBitmap(AccNIcon);
 146
 147     wxImage icons_accgroup_png(cstream, wxBITMAP_TYPE_PNG);
 148     wxBitmap AccGrp(icons_accgroup_png, -1);
 149     wxIcon wxIAccGrp;
 150     wxIAccGrp.CopyFromBitmap(AccGrp);
 151
 152     wxImage icons_accnone_png(dstream, wxBITMAP_TYPE_PNG);
 153     wxBitmap AccNone(icons_accnone_png, -1);
 154     wxIcon wxIAccNone;
 155     wxIAccNone.CopyFromBitmap(AccNone);
 156
 157     AccountID = AccImgList->Add(wxIAccNIcon);
 158     AccountNetID = AccImgList->Add(wxIAccInet);
 159     AccountGrpID = AccImgList->Add(wxIAccGrp);
 160     AccountNoneID = AccImgList->Add(wxIAccNone);
 161
 162     bmpIcon->SetIcon(AccImgList->GetIcon(AccountNoneID));
 163
 164     // Setup the status bar icons.
 165
 166     // SSL icons.
 167
 168     wxMemoryInputStream sslstream(icons_ssl_png, sizeof(icons_ssl_png));
 169     wxMemoryInputStream sslwarningstream(icons_sslwarning_png, sizeof(icons_sslwarning_png));
 170     wxMemoryInputStream nosslstream(icons_nossl_png, sizeof(icons_nossl_png));
 171
 172     wxImage icons_ssl_png(sslstream, wxBITMAP_TYPE_PNG);
 173     imgSSL = new wxBitmap(icons_ssl_png, -1);
 174
 175     wxImage icons_sslwarning_png(sslwarningstream, wxBITMAP_TYPE_PNG);
 176     imgSSLWarning = new wxBitmap(icons_sslwarning_png, -1);
 177
 178     wxImage icons_nossl_png(nosslstream, wxBITMAP_TYPE_PNG);
 179     imgNoSSL = new wxBitmap(icons_nossl_png, -1);
 180
 181     // Activity Icon.
 182
 183     wxMemoryInputStream act1(icons_act1_png, sizeof(icons_act1_png));
 184     wxMemoryInputStream act2(icons_act2_png, sizeof(icons_act2_png));
 185     wxMemoryInputStream act3(icons_act3_png, sizeof(icons_act3_png));
 186     wxMemoryInputStream act4(icons_act4_png, sizeof(icons_act4_png));
 187     wxMemoryInputStream actsleep(icons_actsleep_png, sizeof(icons_actsleep_png));
 188
 189     wxImage icons_actsleep_png(actsleep, wxBITMAP_TYPE_PNG);
 190     imgActIconSleep = new wxBitmap (icons_actsleep_png, -1);
 191
 192     wxImage icons_act1_png(act1, wxBITMAP_TYPE_PNG);
 193     imgActIcon1 = new wxBitmap (icons_act1_png, -1);
 194     wxIcon wxIAct1icon;
 195     wxIAct1icon.CopyFromBitmap(*imgActIcon1);
 196
 197     wxImage icons_act2_png(act2, wxBITMAP_TYPE_PNG);
 198     imgActIcon2 = new wxBitmap (icons_act2_png, -1);
 199     wxIcon wxIAct2icon;
 200     wxIAct2icon.CopyFromBitmap(*imgActIcon2);
 201
 202     wxImage icons_act3_png(act3, wxBITMAP_TYPE_PNG);
 203     imgActIcon3 = new wxBitmap (icons_act3_png, -1);
 204     wxIcon wxIAct3icon;
 205     wxIAct3icon.CopyFromBitmap(*imgActIcon3);
 206
 207     wxImage icons_act4_png(act4, wxBITMAP_TYPE_PNG);
 208     imgActIcon4 = new wxBitmap (icons_act4_png, -1);
 209     wxIcon wxIAct4icon;
 210     wxIAct4icon.CopyFromBitmap(*imgActIcon4);
 211
 212     // Online/Offline icons.
 213
 214     wxMemoryInputStream onlinestream(icons_online_png, sizeof(icons_online_png));
 215     wxMemoryInputStream offlinestream(icons_offline_png, sizeof(icons_offline_png));
 216
 217     wxImage icons_online_png(onlinestream, wxBITMAP_TYPE_PNG);
 218     imgOnline = new wxBitmap(icons_online_png, -1);
 219
 220     wxImage icons_offline_png(offlinestream, wxBITMAP_TYPE_PNG);
 221     imgOffline = new wxBitmap(icons_offline_png, -1);
 222
 223     // Setup the account view.
 224
 225     AccCtrl->SetPopupControl(treAccounts);
 226     AccCtrl->SetPopupMaxHeight(175);
 227     AccCtrl->SetPopupMinWidth(250);
 228     treAccounts->AssignImageList(AccImgList);
 229     //bmpIcon->Hide();
 230
 231     /*wxStaticBitmap* BeepBoop = new wxStaticBitmap(AccCtrl, wxID_ANY, wxNullBitmap, wxPoint(AccTextCtrlSize.GetX() + 3, AccTextCtrlSize.GetY() + 2), wxDefaultSize, 0);
 232
 233      icons_accgroup_png.SetMask(new wxMask(icons_accgroup_png, wxSystemSettings::GetColour(wxSYS_COLOUR_BACKGROUND)));
 234
 235      BeepBoop->SetBackgroundColour(AccCtrl->GetBackgroundColour());
 236      BeepBoop->SetBitmap(icons_accgroup_png);*/
 237
 238     //szrContactList->Insert(0, XABV2, 1, wxEXPAND | wxALL, 0);
 239
 240     /*AccControl->UseAltPopupWindow();
 241      AccControl->SetPopupControl(treAccounts);
 242      AccControl->SetPopupMaxHeight(175);
 243
 244      treAccounts->AssignImageList(AccImgList);
 245      szrContactList->Insert(0, AccControl, 1, wxEXPAND|wxALL, 0);
 246      szrAccList->Add(AccIcon, 0, wxLEFT|wxTOP|wxEXPAND, 3);
 247
 248      */
 249
 250     //szrContactList->Layout();
 251     //szrContactList->RecalcSizes();
 252
 253     wxListItem ColumnData;
 254     ColumnData.SetId(0);
 255     ColumnData.SetText(wxT("Name0"));
 256     ColumnData.SetWidth(320);
 257     lstContacts->InsertColumn(0, ColumnData);
 258
 259     //Connect(wxID_ANY, ContactConflictCmdEnv,
 260     //  ContactConflictEventHandler(frmMain::ConflictResolution), NULL, this);
 261
 262     //Connect(wxID_ANY, MyFooCommandEvent,
 263     //  MyFooEventHandler(frmMain::DoSomething), NULL, this);
 264
 265     //Bind(ContactConflictCmdEnv, ContactConflictEventHandler(frmMain::ConflictResolution), this, wxID_ANY);
 266
 267     treAccounts->Connect(wxEVT_LEFT_DCLICK, wxTreeEventHandler(frmMain::LoadContactList), NULL, this);
 268     treAccounts->Connect(wxEVT_TREE_SEL_CHANGED, wxTreeEventHandler(frmMain::LoadContactList), NULL, this);
 269
 270 #if defined(__HAIKU__)
 271
 272 #elif defined(__WIN32__)
 273
 274     int stbBottomData [4] = { -1, 8, 8, 8 };
 275
 276 #else
 277
 278     int stbBottomData [4] = { -1, 20, 20, 20 };
 279
 280 #endif
 281
 282     stbBottom->SetFieldsCount(4, stbBottomData);
 283     stbBottom->SetMinHeight(16);
 284
 285     wxRect rectOnline;
 286     wxRect rectSSL;
 287     wxRect rectActivity;
 288     stbBottom->GetFieldRect(1, rectOnline);
 289     stbBottom->GetFieldRect(2, rectSSL);
 290     stbBottom->GetFieldRect(3, rectActivity);
 291
 292     SSLToolTip = new wxToolTip(wxT(""));
 293
 294     imgConnStatus = new wxStaticBitmap(stbBottom, wxID_ANY, wxNullBitmap, wxPoint((rectOnline.GetX()),(rectOnline.GetY())), wxDefaultSize, 0 );
 295     imgConnStatus->SetBitmap(*imgOnline);
 296     imgConnStatus->Connect( wxEVT_LEFT_DCLICK, wxCommandEventHandler( frmMain::ToggleConnectionStatus ), NULL, this );
 297
 298     imgSSLStatus = new wxStaticBitmap(stbBottom, wxID_ANY, wxNullBitmap, wxPoint((rectSSL.GetX()),(rectSSL.GetY())), wxDefaultSize, 0 );
 299     imgSSLStatus->SetBitmap(*imgNoSSL);
 300     imgSSLStatus->SetToolTip(SSLToolTip);
 301     imgSSLStatus->Connect( wxEVT_LEFT_DCLICK, wxCommandEventHandler( frmMain::ShowSSLCertificates ), NULL, this );
 302
 303     imgActivityStatus = new wxStaticBitmap(stbBottom, wxID_ANY, wxNullBitmap, wxPoint((rectActivity.GetX()),(rectActivity.GetY())), wxDefaultSize, 0);
 304     imgActivityStatus->SetBitmap(*imgActIconSleep);
 305     imgActivityStatus->Connect( wxEVT_LEFT_DCLICK, wxCommandEventHandler( frmMain::ShowActivityWindow ), NULL, this );
 306
 307     // Setup the window menu.
 308
 309     // By default should be:
 310
 311     // Contact windows:
 312     // (none)
 313     // (horizontal line)
 314     // Contact editor windows:
 315     // (none)
 316     // (horizontal line)
 317     // Search windows:
 318     // (none)
 319
 320     mnuContactWindows = new wxMenuItem( mnuManage, wxID_ANY, wxString( _("Contact windows:") ), wxEmptyString, wxITEM_NORMAL );
 321     mnuWindow->Append( mnuContactWindows );
 322
 323     mnuWindow->AppendSeparator();
 324
 325     mnuContactEditorWindows = new wxMenuItem( mnuManage, wxID_ANY, wxString( _("Contact editor windows:") ), wxEmptyString, wxITEM_NORMAL );
 326     mnuWindow->Append( mnuContactEditorWindows );
 327
 328     mnuWindow->AppendSeparator();
 329
 330     mnuSearchWindows = new wxMenuItem( mnuManage, wxID_ANY, wxString( wxT("Search windows:") ), wxEmptyString, wxITEM_NORMAL );
 331     mnuWindow->Append( mnuSearchWindows );
 332
 333 #if defined(__WIN32__)
 334
 335     wxFont fontstyle;
 336     fontstyle.Bold();
 337
 338     mnuContactWindows->SetFont(fontstyle);
 339     mnuContactEditorWindows->SetFont(fontstyle);
 340     mnuSearchWindows->SetFont(fontstyle);
 341
 342 #else
 343
 344     mnuContactWindows->Enable(FALSE);
 345     mnuContactEditorWindows->Enable(FALSE);
 346     mnuSearchWindows->Enable(FALSE);
 347
 348 #endif
 349
 350     // Hide unimplemented functions.
 351
 352     mnuMain->Remove(3);
 353
 354 }
 355
 356 void frmMain::QuitApp( wxCloseEvent& event )
 357 {
 358
 359     QuitApp();
 360
 361 }
 362
 363 void frmMain::QuitApp( wxCommandEvent& event )
 364 {
 365
 366     QuitApp();
 367
 368 }
 369
 370 void frmMain::QuitApp()
 371 {
 372     //-------------------------------------------------------------------
 373     // frmMain::QuitApp: Quits the application by simply closing this
 374     // window which causes the exit as frmMain is the main window.
 375     //
 376     // wxCommandEvent   Accepts a referenced event command.
 377     //-------------------------------------------------------------------
 378
 379      //-------------------------------------------------------------------
 380     // frmMain::QuitApp: Quits the application by simply closing this
 381     // window which causes the exit as frmMain is the main window.
 382     //
 383     // wxCommandEvent   Accepts a referenced event command.
 384     //-------------------------------------------------------------------
 385
 386     //Go through the windows and close each one (be it search
 387     //or contact editor). Abort if user wants to cancel.
 388
 389     // Close the contact editor windows.
 390
 391     // Close the contact windows.
 392
 393     // Close the search windows.
 394
 395     // Write out the ETag databases.
 396
 397     // Save Preferences: Save the window position if that option is enabled.
 398
 399     wxString SetFilename = GetUserPrefDir();
 400
 401 #if defined(__HAIKU__)
 402
 403
 404
 405 #elif defined(__WIN32__)
 406
 407     SetFilename.Append(wxT("settings"));
 408
 409 #else
 410
 411     // *nix OSes
 412
 413     SetFilename.Append(wxT("settings"));
 414
 415 #endif
 416
 417     wxFileConfig *cfgfile = new wxFileConfig("", "", SetFilename);
 418
 419     bool SaveWindowPos = FALSE;
 420     wxString SaveWindowInc;
 421     cfgfile->Read(wxT("SaveWindowPosition"), &SaveWindowInc);
 422
 423     if (SaveWindowInc == wxT("true")){
 424
 425         SaveWindowPos = TRUE;
 426
 427     }
 428
 429     if (SaveWindowPos == TRUE){
 430
 431         wxRect frmMainPos = this->GetRect();
 432
 433         cfgfile->Write(wxT("WindowPositionX"), frmMainPos.GetX());
 434         cfgfile->Write(wxT("WindowPositionY"), frmMainPos.GetY());
 435         cfgfile->Write(wxT("WindowPositionHeight"), frmMainPos.GetHeight());
 436         cfgfile->Write(wxT("WindowPositionWidth"), frmMainPos.GetWidth());
 437
 438
 439     }
 440
 441     delete cfgfile;
 442     cfgfile = NULL;
 443
 444     //Everything closed... exit.
 445
 446     std::exit(0);
 447
 448     Close();
 449
 450 }
 451
 452 void frmMain::ShowActivityWindow( wxCommandEvent& event )
 453 {
 454
 455     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
 456     frameActMgr->OpenWindow();
 457     frameActMgr->Show();
 458
 459 }
 460
 461 void frmMain::ShowAboutWindow( wxCommandEvent& event )
 462 {
 463     //-------------------------------------------------------------------
 464     // frmMain::ShowAboutWindow: Shows the About window as a modal
 465     // dialog and then cleans up when finished.
 466     //
 467     // wxCommandEvent   Accepts a referenced event command.
 468     //-------------------------------------------------------------------
 469
 470     frmAbout *frameAbout = new frmAbout ( this );
 471     frameAbout->SetupAboutWindow();
 472     frameAbout->ShowModal();
 473     delete frameAbout;
 474     frameAbout = NULL;
 475
 476 }
 477
 478 void frmMain::OpenPreferences( wxCommandEvent& event)
 479 {
 480     //-------------------------------------------------------------------
 481     // frmMain::ShowAboutWindow: Opens the Preferences window as a modal
 482     // dialog and then cleans up when finished.
 483     //
 484     // wxCommandEvent   Accepts a referenced event command.
 485     //-------------------------------------------------------------------
 486
 487     ReloadAccounts = FALSE;
 488
 489     frmPreferences *framePreferences = new frmPreferences ( this );
 490     framePreferences->SetupPointers(&ReloadAccounts);
 491     framePreferences->ShowModal();
 492     delete framePreferences;
 493     framePreferences = NULL;
 494
 495     if (ReloadAccounts == TRUE){
 496
 497         // Reload the accounts as a change has been made within
 498         // the application.
 499
 500         this->LoadPreferences();
 501
 502     }
 503
 504 }
 505
 506 void frmMain::OpenNewABDialog( wxCommandEvent& event)
 507 {
 508     //-------------------------------------------------------------------
 509     // frmMain::ShowAboutWindow: Opens the Preferences window as a modal
 510     // dialog and then cleans up when finished.
 511     //
 512     // wxCommandEvent   Accepts a referenced event command.
 513     //-------------------------------------------------------------------
 514
 515     ReloadAccounts = FALSE;
 516
 517     frmNewAccount *frameNewAccount = new frmNewAccount ( this );
 518     frameNewAccount->SetupPointers(&ReloadAccounts);
 519     frameNewAccount->ShowModal();
 520     delete frameNewAccount;
 521     frameNewAccount = NULL;
 522
 523     if (ReloadAccounts == TRUE){
 524
 525         // Reload the accounts as a change has been made within
 526         // the application.
 527
 528         this->LoadPreferences();
 529
 530     }
 531
 532 }
 533
 534 void frmMain::LoadContactList( wxTreeEvent& event )
 535 {
 536
 537     // Clear all existing variables.
 538
 539     lstContacts->DeleteAllItems();
 540
 541     treAccounts->SetAccount();
 542
 543     wxTreeItemIdValue cookie;
 544     wxTreeItemId next = treAccounts->GetRootItem();
 545     wxString AccountName;
 546     wxString AccountDir, AccountType, AccountDirFinal, AccountTypeFinal;
 547     wxString AccountDirCmb;
 548     long selectedaccount = 0;
 549
 550     wxTreeItemId selectedChild = treAccounts->GetSelection();
 551     wxTreeItemId nextChild;
 552
 553     wxTreeItemId ActiveItemId = treAccounts->GetFocusedItem();
 554     int ActiveItemIcon = treAccounts->GetItemImage(ActiveItemId, wxTreeItemIcon_Normal);
 555
 556     int SCImg = treAccounts->GetItemImage(selectedChild);
 557     int AccountIndex = 0;
 558
 559     bmpIcon->SetIcon(AccImgList->GetIcon(SCImg));
 560
 561     for (int i = 0; i < prefaccounts.GetCount(); i++){
 562
 563         if (ActiveItemIcon == 2){
 564
 565             std::multimap<wxTreeItemId, int>::iterator AGTiter = AccountGroupTreeId.find(ActiveItemId);
 566             std::multimap<int, int>::iterator AGLiter = AccountGroupList.find(AGTiter->second);
 567             int ActiveAccountG = AGLiter->second;
 568
 569             if (i == ActiveAccountG){
 570
 571                 AccountDir.Append(prefaccounts.GetAccountDirectory(i));
 572                 AccountType.Append(prefaccounts.GetAccountType(i));
 573
 574                 AccountDir.Trim();
 575                 AccountType.Trim();
 576
 577                 if (AccountType == wxT("CardDAV")){
 578                     AccountTypeFinal.Append(wxT("carddav"));
 579                 }
 580                 else if (AccountType == wxT("Local")){
 581                     imgSSLStatus->SetBitmap(*imgOffline);
 582                     SSLToolTip->SetTip(wxT("SSL status is not applicable for this account"));
 583                     AccountTypeFinal.Append(wxT("local"));
 584                 }
 585
 586                 AccountIndex = i;
 587                 break;
 588
 589             }
 590
 591         }
 592
 593         if (!nextChild){
 594             nextChild = treAccounts->GetFirstChild(next, cookie);
 595         }
 596         else {
 597             nextChild = treAccounts->GetNextSibling(nextChild);
 598         }
 599
 600         AccountName = treAccounts->GetItemText(nextChild);
 601
 602         if (nextChild == selectedChild){
 603             AccountDir.Append(prefaccounts.GetAccountDirectory(i));
 604             AccountType.Append(prefaccounts.GetAccountType(i));
 605
 606             AccountDir.Trim();
 607             AccountType.Trim();
 608
 609             if (AccountType == wxT("CardDAV")){
 610                 AccountTypeFinal.Append(wxT("carddav"));
 611             }
 612             else if (AccountType == wxT("Local")){
 613                 SSLToolTip->SetTip(wxT("SSL status is not applicable for this account"));
 614                 AccountTypeFinal.Append(wxT("local"));
 615             }
 616
 617             AccountIndex = i;
 618
 619         }
 620
 621     }
 622
 623     if (selectedaccount >= prefaccounts.GetCount()){
 624
 625         // The account selected isn't there so return.
 626
 627         RevealWait = FALSE;
 628
 629         return;
 630
 631     }
 632
 633     // Open the directory and get the list of .vcf files
 634     // in that directory.
 635
 636     ActiveAccount = AccountDir + wxT(".") + AccountTypeFinal;
 637     ActiveAccountType = AccountType;
 638
 639     SetupSSLStatus(AccountIndex);
 640
 641     AccountDirFinal.Clear();
 642     AccountDirFinal = GetAccountDir(AccountDir + wxT(".") + AccountTypeFinal, FALSE);
 643
 644     ContactsFileIndex.Clear();
 645
 646     //wxString vcardfilenamewxs;
 647     wxString vCardFilename;
 648     wxString vCardFilenameFull;
 649     wxString vCardDataString;
 650     wxStringTokenizer vcardfileline;
 651     wxString lwxs;
 652     wxString setname, setvalue;
 653     //vCardNames = new std::map<wxString, wxString, std::greater<wxString>>;
 654     std::multimap<wxString, wxString, std::greater<wxString>> vCardNamesAsc;
 655     std::multimap<wxString, wxString, std::less<wxString>> vCardNamesDsc;
 656     long ContactIndex = 1;
 657     long ContactSeekPoint = 0;
 658
 659     wxDir vcardaccdir(AccountDirFinal);
 660
 661     // Get the wxTreeItemId and image icon and compare it to the list.
 662
 663     if (ActiveItemIcon == AccountGrpID){
 664
 665         // It's a group so load the file containing the group and
 666         // get the members of the group.
 667
 668         vCard Group;
 669         wxString UIDCode;
 670
 671         std::multimap<wxTreeItemId, int>::iterator AGTiter = AccountGroupTreeId.find(ActiveItemId);
 672         std::multimap<int, wxString>::iterator AGFiter = AccountGroupFilename.find(AGTiter->second);
 673         //std::multimap<wxTreeItemId, int>::iterator AGFiter = AccountGroupTreeId.find(ActiveItemId);
 674
 675         Group.LoadFile(AGFiter->second);
 676
 677         ArrayvCardOutData vCardMember = Group.GetByPartial(wxT("MEMBER"));
 678
 679         for (int i = 0; i < vCardMember.PropCount; i++){
 680
 681             vCardMember.PropValues[i].Trim();
 682             if (vCardMember.PropValues[i].Left(9) == wxT("urn:uuid:")){
 683
 684                 wxString NewPropValue;
 685                 NewPropValue = vCardMember.PropValues[i].Mid(9, wxString::npos);
 686                 vCardMember.PropValues[i] = NewPropValue;
 687
 688             }
 689
 690
 691         }
 692
 693         bool ProcFiles = vcardaccdir.GetFirst(&vCardFilename, wxEmptyString, wxDIR_FILES);
 694         while(ProcFiles){
 695
 696             if (vCardFilename.Right(4) == wxT(".vcf") ||
 697                 vCardFilename.Right(4) == wxT(".VCF") ||
 698                 vCardFilename.Right(5) == wxT(".vcard") ||
 699                 vCardFilename.Right(5) == wxT(".VCARD")){
 700
 701                 vCard Person;
 702                 bool FoundMember = FALSE;
 703
 704                 vCardFilenameFull.Append(AccountDirFinal);
 705                 vCardFilenameFull.Append(wxT("/"));
 706                 vCardFilenameFull.Append(vCardFilename);
 707
 708                 Person.LoadFile(vCardFilenameFull);
 709
 710                 UIDCode = Person.Get(wxT("UID"));
 711
 712                 for (int i = 0; i < vCardMember.PropCount; i++){
 713
 714                     if (vCardMember.PropValues[i] == UIDCode){
 715
 716                         FoundMember = TRUE;
 717
 718                     }
 719
 720                 }
 721
 722                 if (FoundMember == FALSE){
 723
 724                     vCardFilename.Clear();
 725                     vCardFilenameFull.Clear();
 726                     vCardDataString.Clear();
 727                     ProcFiles = vcardaccdir.GetNext(&vCardFilename);
 728                     continue;
 729
 730                 }
 731
 732                 if (Person.MeetBaseSpecification()){
 733
 734                     if (SortMode == 1){
 735
 736                         // Split the name into sections.
 737
 738                         vCardDataString = Person.Get(wxT("N"));
 739
 740                         vCardName NameData = Person.GetName();
 741
 742                         vCardDataString = NameData.Forename + wxT(" ") + NameData.Surname;
 743
 744                     } else if (SortMode == 2){
 745
 746                         // Split the name into sections.
 747
 748                         vCardName NameData = Person.GetName();
 749
 750                         vCardDataString = NameData.Surname + wxT(", ") + NameData.Forename;
 751
 752                     } else if (SortMode == 3){
 753
 754                         // Check and make sure that the top most nickname is used.
 755
 756                         vCardDataString = Person.Get(wxT("NICKNAME"));
 757
 758                         if (vCardDataString.IsEmpty()){
 759
 760                             vCardDataString = wxT("(no nickname)");
 761
 762                         }
 763
 764                     } else if (SortMode == 4){
 765
 766                         vCardDataString = Person.Get(wxT("FN"));
 767
 768                     }
 769
 770                     if (AscendingMode == TRUE){
 771                         vCardNamesAsc.insert(std::make_pair(vCardDataString, vCardFilenameFull));
 772                     } else {
 773                         vCardNamesDsc.insert(std::make_pair(vCardDataString, vCardFilenameFull));
 774                     }
 775
 776                 } else {
 777
 778                 }
 779
 780             }
 781
 782             vCardFilename.Clear();
 783             vCardFilenameFull.Clear();
 784             vCardDataString.Clear();
 785             ProcFiles = vcardaccdir.GetNext(&vCardFilename);
 786         }
 787
 788     } else {
 789
 790         bool ProcFiles = vcardaccdir.GetFirst(&vCardFilename, wxEmptyString, wxDIR_FILES);
 791         while(ProcFiles){
 792
 793             if (vCardFilename.Right(4) == wxT(".vcf") ||
 794                 vCardFilename.Right(4) == wxT(".VCF") ||
 795                 vCardFilename.Right(5) == wxT(".vcard") ||
 796                 vCardFilename.Right(5) == wxT(".VCARD")){
 797
 798                 vCard Person;
 799
 800                 vCardFilenameFull.Append(AccountDirFinal);
 801                 vCardFilenameFull.Append(vCardFilename);
 802
 803                 Person.LoadFile(vCardFilenameFull);
 804
 805                 if (Person.MeetBaseSpecification()){
 806
 807                     if (SortMode == 1){
 808
 809                         // Split the name into sections.
 810
 811                         vCardDataString = Person.Get(wxT("N"));
 812
 813                         vCardName NameData = Person.GetName();
 814
 815                         vCardDataString = NameData.Forename + wxT(" ") + NameData.Surname;
 816
 817                     } else if (SortMode == 2){
 818
 819                         // Split the name into sections.
 820
 821                         vCardName NameData = Person.GetName();
 822
 823                         vCardDataString = NameData.Surname + wxT(", ") + NameData.Forename;
 824
 825                     } else if (SortMode == 3){
 826
 827                         // Check and make sure that the top most nickname is used.
 828
 829                         vCardDataString = Person.Get(wxT("NICKNAME"));
 830
 831                         if (vCardDataString.IsEmpty()){
 832
 833                             vCardDataString = wxT("(no nickname)");
 834
 835                         }
 836
 837                     } else if (SortMode == 4){
 838
 839                         vCardDataString = Person.Get(wxT("FN"));
 840
 841                     }
 842
 843                     if (AscendingMode == TRUE){
 844                         vCardNamesAsc.insert(std::make_pair(vCardDataString, vCardFilenameFull));
 845                     } else {
 846                         vCardNamesDsc.insert(std::make_pair(vCardDataString, vCardFilenameFull));
 847                     }
 848
 849                 } else {
 850
 851                 }
 852
 853             }
 854
 855             vCardFilename.Clear();
 856             vCardFilenameFull.Clear();
 857             vCardDataString.Clear();
 858             ProcFiles = vcardaccdir.GetNext(&vCardFilename);
 859         }
 860
 861     }
 862
 863     // Sort the data.
 864
 865     // Insert the data into the control.
 866
 867     if (AscendingMode == TRUE){
 868         for (std::map<wxString, wxString>::iterator iter = vCardNamesAsc.begin();
 869              iter != vCardNamesAsc.end(); ++iter){
 870
 871             wxListItem ContactInfo;
 872
 873             ContactInfo.SetId(0);
 874             ContactInfo.SetText(_("Mooo"));
 875             ContactInfo.SetData(ContactSeekPoint);
 876             ContactIndex = lstContacts->InsertItem(ContactInfo);
 877
 878             lstContacts->SetItem(ContactIndex, 0, iter->first);
 879             ContactsFileIndex.Insert(iter->second, ContactSeekPoint);
 880             ContactSeekPoint++;
 881
 882         }
 883
 884     } else {
 885
 886         for (std::map<wxString, wxString>::iterator iter = vCardNamesDsc.begin();
 887              iter != vCardNamesDsc.end(); ++iter){
 888
 889             wxListItem ContactInfo;
 890
 891             ContactInfo.SetId(0);
 892             ContactInfo.SetText(_("Mooo"));
 893             ContactInfo.SetData(ContactSeekPoint);
 894             ContactIndex = lstContacts->InsertItem(ContactInfo);
 895
 896             lstContacts->SetItem(ContactIndex, 0, iter->first);
 897             ContactsFileIndex.Insert(iter->second, ContactSeekPoint);
 898             ContactSeekPoint++;
 899
 900         }
 901
 902     }
 903
 904 }
 905
 906 void frmMain::ShowContactInfo( wxListEvent& event )
 907 {
 908
 909     long intSelected = -1;
 910     long ContactSeekNum = -1;
 911
 912     //    intSelected = lstContacts->GetSelection();
 913
 914     // Check if several contacts have been selected.
 915
 916     int ContactTotal = 0;
 917
 918     for (;;){
 919
 920         intSelected = lstContacts->GetNextItem(intSelected,
 921                                                wxLIST_NEXT_ALL,
 922                                                wxLIST_STATE_SELECTED);
 923
 924         if (intSelected == -1){
 925
 926             break;
 927
 928         }
 929
 930         ContactTotal++;
 931
 932     }
 933
 934     if (ContactTotal == 0){
 935         htmContactData->SetPage(wxT(""));
 936         return;
 937     }
 938
 939     if (ContactTotal > 1){
 940
 941         htmContactData->SetPage(wxString::Format(wxT("%i contacts selected."), ContactTotal));
 942         ActiveFilename.Clear();
 943         return;
 944
 945     }
 946
 947     intSelected = lstContacts->GetNextItem(intSelected,
 948                                            wxLIST_NEXT_ALL,
 949                                            wxLIST_STATE_SELECTED);
 950
 951     ContactSeekNum = lstContacts->GetItemData(intSelected);
 952
 953     wxFFile ContactFile;
 954     wxString wxSContactString;
 955     wxString ContactLine;
 956     vCard Person;
 957
 958     size_t ContactLineLen;
 959     bool ExtraLineSeek = FALSE;
 960     int QuoteBreakPoint = 0;
 961
 962     bool PropertyFind = FALSE;
 963     bool QuoteMode = FALSE;
 964
 965     wxString wxSPropertyNextLine;
 966     wxString wxSProperty;
 967     wxString wxSPropertySeg1;
 968     wxString wxSPropertySeg2;
 969
 970     // Check if we are using wxWidgets version 2.8 or less and
 971     // execute the required command accordingly.
 972
 973 #if wxABI_VERSION < 20900
 974     ContactFile.Open(ContactsFileIndex[ContactSeekNum].c_str(), wxT("r"));
 975 #else
 976     ContactFile.Open(ContactsFileIndex[ContactSeekNum], wxT("r"));
 977 #endif
 978
 979     if (ContactFile.IsOpened() == FALSE){
 980
 981         return;
 982
 983     }
 984
 985     ContactFile.ReadAll(&wxSContactString, wxConvAuto());
 986
 987     // Split the lines.
 988
 989     std::map<int, wxString> ContactFileLines;
 990     std::map<int, wxString>::iterator striter;
 991
 992     wxStringTokenizer wSTContactFileLines(wxSContactString, wxT("\r\n"));
 993
 994     int ContactLineSeek = 0;
 995
 996     while (wSTContactFileLines.HasMoreTokens() == TRUE){
 997
 998         ContactLine = wSTContactFileLines.GetNextToken();
 999         ContactFileLines.insert(std::make_pair(ContactLineSeek, ContactLine));
1000         ContactLineSeek++;
1001
1002     }
1003
1004     if (ContactSeekNum < 0){
1005         return;
1006     }
1007
1008     for (std::map<int, wxString>::iterator iter = ContactFileLines.begin();
1009          iter != ContactFileLines.end(); ++iter){
1010
1011         // Find the colon which splits the start bit from the data part.
1012
1013         ContactLine = iter->second;
1014
1015         while (ExtraLineSeek == TRUE){
1016
1017             // Check if there is extra data on the next line
1018             // (indicated by space or tab at the start) and add data.
1019
1020             iter++;
1021
1022             if (iter == ContactFileLines.end()){
1023
1024                 iter--;
1025                 break;
1026
1027             }
1028
1029             wxSPropertyNextLine = iter->second;
1030
1031
1032             if (wxSPropertyNextLine.Mid(0, 1) == wxT(" ") || wxSPropertyNextLine.Mid(0, 1) == wxT("\t")){
1033
1034                 wxSPropertyNextLine.Remove(0, 1);
1035                 //wxSPropertyNextLine.Trim(FALSE);
1036                 //ContactLine.Trim();
1037                 ContactLine.Append(wxSPropertyNextLine);
1038
1039             } else {
1040
1041                 iter--;
1042                 ExtraLineSeek = FALSE;
1043
1044             }
1045
1046         }
1047
1048         ContactLineLen = ContactLine.Len();
1049
1050         // Make sure we are not in quotation mode.
1051         // Make sure colon does not have \ or \\ before it.
1052
1053         for (int i = 0; i <= ContactLineLen; i++){
1054
1055             if ((ContactLine.Mid(i, 1) == wxT(";") || ContactLine.Mid(i, 1) == wxT(":")) && PropertyFind == TRUE){
1056
1057                 PropertyFind = FALSE;
1058
1059             } else if (PropertyFind == TRUE){
1060
1061                 wxSProperty.Append(ContactLine.Mid(i, 1));
1062
1063             }
1064
1065             if (ContactLine.Mid(i, 1) == wxT("\"")){
1066
1067                 if (QuoteMode == TRUE){
1068
1069                     QuoteMode = FALSE;
1070
1071                 } else {
1072
1073                     QuoteMode = TRUE;
1074
1075                 }
1076
1077             }
1078
1079             if (ContactLine.Mid(i, 1) == wxT(":") && ContactLine.Mid((i - 1), 1) != wxT("\\") && QuoteMode == FALSE){
1080
1081                 QuoteBreakPoint = i;
1082                 break;
1083
1084             }
1085
1086         }
1087
1088         // Split that line at the point into two variables (ignore the colon).
1089
1090         wxSPropertySeg1 = ContactLine.Mid(0, QuoteBreakPoint);
1091         wxSPropertySeg2 = ContactLine.Mid((QuoteBreakPoint + 1));
1092
1093         // Insert both into the vCard data file.
1094
1095         Person.AddRaw(wxSPropertySeg1, wxSPropertySeg2);
1096
1097         QuoteMode = FALSE;
1098         PropertyFind = TRUE;
1099         ExtraLineSeek = TRUE;
1100         ContactLineLen = 0;
1101         QuoteBreakPoint = 0;
1102         ContactLine.Clear();
1103         wxSProperty.Clear();
1104
1105     }
1106
1107     OldSessionID = SessionID;
1108     SessionID = wxString::Format(wxT("%i"), rand() % 32768);
1109     LoadContactData(&Person, htmContactData, SessionID, OldSessionID, &MemoryFileList);
1110     ActiveFilename = ContactsFileIndex[ContactSeekNum];
1111
1112 }
1113
1114 void frmMain::ShowContactEditorNew( wxCommandEvent& event )
1115 {
1116
1117     // Check if there is an account selected and if not
1118     // return immediately.
1119
1120     if (ActiveAccount.IsEmpty()){
1121
1122         return;
1123
1124     }
1125
1126     // Add Pointer to SetupPointers for the ETagDB.
1127
1128     wxMemoryInputStream istream(bigimgs_contactpersonicon48_png, sizeof(bigimgs_contactpersonicon48_png));
1129     wxImage bigimgs_contactpersonicon48i(istream, wxBITMAP_TYPE_PNG);
1130     wxBitmap contacticonbmp(bigimgs_contactpersonicon48i, -1);
1131     wxIcon contacticon;
1132     contacticon.CopyFromBitmap(contacticonbmp);
1133
1134     frmContactEditor *ContactEditor = new frmContactEditor( this );
1135
1136     WindowMenuItemID++;
1137
1138     ContactEditor->SetUID(WindowMenuItemID);
1139
1140     WindowData *WData = new WindowData;
1141
1142     WData->DataType = 1;
1143     WData->WindowPointer = (void*)ContactEditor;
1144     WData->WindowID = WindowMenuItemID;
1145
1146     wxCommandEvent addevent(WINDOW_ADD);
1147     addevent.SetClientData(WData);
1148     wxPostEvent(this, addevent);
1149
1150     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
1151     ContactEditor->SetupHeaders();
1152     ContactEditor->SetupContact(ActiveAccount);
1153     ContactEditor->SetIcon(contacticon);
1154     ContactEditor->SetupPointers(frameActMgr, &ETagProcTimer, this);
1155     ContactEditor->Show(true);
1156
1157 }
1158
1159 void frmMain::ShowContactEditorEdit( wxCommandEvent& event )
1160 {
1161
1162     // Check if there is an account selected and if not
1163     // return immediately.
1164
1165     int DataCheck = event.GetInt();
1166
1167     if (ActiveAccount.IsEmpty() && DataCheck == 0){
1168
1169         return;
1170
1171     }
1172
1173     wxMemoryInputStream istream(bigimgs_contactpersonicon48_png, sizeof(bigimgs_contactpersonicon48_png));
1174     wxImage bigimgs_contactpersonicon48i(istream, wxBITMAP_TYPE_PNG);
1175     wxBitmap contacticonbmp(bigimgs_contactpersonicon48i, -1);
1176     wxIcon contacticon;
1177     contacticon.CopyFromBitmap(contacticonbmp);
1178
1179     // Check if a contact has been selected.
1180
1181     long intSelected = -1;
1182     long intContactSeekNum = -1;
1183
1184     //    intSelected = lstContacts->GetSelection();
1185
1186     intSelected = lstContacts->GetNextItem(intSelected,
1187                                            wxLIST_NEXT_ALL,
1188                                            wxLIST_STATE_SELECTED);
1189
1190     if (intSelected == -1){
1191         return;
1192     }
1193
1194     intContactSeekNum = lstContacts->GetItemData(intSelected);
1195
1196     // Get the filename of the selected contact.
1197
1198     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
1199     frmContactEditor *ContactEditor = new frmContactEditor( this );
1200
1201     WindowMenuItemID++;
1202
1203     ContactEditor->SetUID(WindowMenuItemID);
1204
1205     WindowData *WData = new WindowData;
1206
1207     WData->DataType = 1;
1208     WData->WindowPointer = (void*)ContactEditor;
1209     WData->WindowID = WindowMenuItemID;
1210
1211     wxCommandEvent addevent(WINDOW_ADD);
1212     addevent.SetClientData(WData);
1213     wxPostEvent(this, addevent);
1214
1215     ContactEditor->SetupPointers(frameActMgr, &ETagProcTimer, this);
1216     ContactEditor->SetupHeaders();
1217
1218     // Check if pointer is NULL (not from the search forms) or not.
1219
1220     if (DataCheck == 0){
1221
1222         ContactEditor->LoadContact(ContactsFileIndex[intContactSeekNum]);
1223         ContactEditor->SetupContact(ActiveAccount);
1224
1225     } else {
1226
1227         UCNotif *uc = (UCNotif*)event.GetClientData();
1228
1229         if (!uc){
1230
1231             ContactEditor->SetupContact(ActiveAccount);
1232             ContactEditor->LoadContact(ContactsFileIndex[intContactSeekNum]);
1233
1234         } else {
1235
1236             ContactEditor->SetupContact(uc->ContactAccount);
1237             ContactEditor->LoadContact(uc->ContactFilename);
1238
1239             delete uc;
1240             uc = NULL;
1241
1242
1243         }
1244
1245     }
1246
1247     ContactEditor->SetIcon(contacticon);
1248     ContactEditor->Show(true);
1249
1250 }
1251
1252 void frmMain::RefreshAddressBook( wxCommandEvent& event ){
1253
1254     // Check if ActiveAccount is empty. If not then check if
1255     // account type is not local otherwise continue.
1256
1257     if (!ActiveAccount.IsEmpty()){
1258
1259         if (ActiveAccountType != wxT("Local")){
1260
1261                 // Account type is not local.
1262
1263                 frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
1264                 frameActMgr->AddTask(3, wxT(""), ActiveAccount,
1265                                      wxT(""), wxT(""), wxT(""), wxT(""));
1266
1267         } else {
1268
1269                 wxMessageBox(_("The refresh address book command is not supported with this type of account."), wxT("Not supported for this type of account"));
1270
1271         }
1272
1273     }
1274
1275 }
1276
1277 void frmMain::OpenContactInfoList( wxListEvent& event )
1278 {
1279
1280     wxStringTokenizer vcardfileline;
1281     std::string l;
1282     wxString lwxs;
1283     wxString setname, setvalue;
1284     vCard Person;
1285     wxString nextchar;
1286
1287     long intSelected = -1;
1288     long intContactSeekNum = -1;
1289
1290     intSelected = lstContacts->GetNextItem(intSelected,
1291                                            wxLIST_NEXT_ALL,
1292                                            wxLIST_STATE_SELECTED);
1293
1294     intContactSeekNum = lstContacts->GetItemData(intSelected);
1295
1296     if (intContactSeekNum == -1){
1297         return;
1298     }
1299
1300     Person.LoadFile(ContactsFileIndex[intContactSeekNum]);
1301
1302     wxMemoryInputStream istream(bigimgs_contactpersonicon48_png, sizeof(bigimgs_contactpersonicon48_png));
1303     wxImage bigimgs_contactpersonicon48i(istream, wxBITMAP_TYPE_PNG);
1304     wxBitmap contacticonbmp(bigimgs_contactpersonicon48i, -1);
1305     wxIcon contacticon;
1306     contacticon.CopyFromBitmap(contacticonbmp);
1307
1308     frmContact *Contact = new frmContact( this );
1309
1310     // Add to window list.
1311
1312     WindowMenuItemID++;
1313
1314     Contact->SetUID(WindowMenuItemID);
1315
1316     WindowData *WData = new WindowData;
1317
1318     WData->DataType = 0;
1319     WData->WindowPointer = (void*)Contact;
1320     WData->WindowID = WindowMenuItemID;
1321
1322     wxCommandEvent addevent(WINDOW_ADD);
1323     addevent.SetClientData(WData);
1324     wxPostEvent(this, addevent);
1325
1326     Contact->SetupPointers(&MemoryFileList);
1327     Contact->SetupContactData(&Person);
1328
1329     Contact->SetIcon(contacticon);
1330     Contact->Show(true);
1331
1332 }
1333
1334 void frmMain::OpenContactInfoList( wxCommandEvent& event ){
1335
1336         wxListEvent pevent;
1337         OpenContactInfoList(pevent);
1338
1339 }
1340
1341 void frmMain::OpenContactInfo( wxCommandEvent& event )
1342 {
1343
1344     UCNotif *uc = (UCNotif*)event.GetClientData();
1345
1346     wxStringTokenizer vcardfileline;
1347     std::string l;
1348     wxString lwxs;
1349     wxString setname, setvalue;
1350     vCard Person;
1351     wxString nextchar;
1352     //std::fstream vcardfile;
1353
1354     Person.LoadFile(uc->ContactFilename);
1355
1356     wxMemoryInputStream istream(bigimgs_contactpersonicon48_png, sizeof(bigimgs_contactpersonicon48_png));
1357     wxImage bigimgs_contactpersonicon48i(istream, wxBITMAP_TYPE_PNG);
1358     wxBitmap contacticonbmp(bigimgs_contactpersonicon48i, -1);
1359     wxIcon contacticon;
1360     contacticon.CopyFromBitmap(contacticonbmp);
1361
1362     frmContact *Contact = new frmContact( this );
1363
1364     // Add to window list.
1365
1366     WindowMenuItemID++;
1367
1368     Contact->SetUID(WindowMenuItemID);
1369
1370     WindowData *WData = new WindowData;
1371
1372     WData->DataType = 0;
1373     WData->WindowPointer = (void*)Contact;
1374     WData->WindowID = WindowMenuItemID;
1375
1376     wxCommandEvent addevent(WINDOW_ADD);
1377     addevent.SetClientData(WData);
1378     wxPostEvent(this, addevent);
1379
1380     Contact->SetupPointers(&MemoryFileList);
1381     Contact->SetupContactData(&Person);
1382
1383     Contact->SetIcon(contacticon);
1384     Contact->Show(true);
1385
1386 }
1387
1388
1389 void frmMain::LoadPreferences( wxActivateEvent& event)
1390 {
1391     this->LoadPreferences();
1392 }
1393
1394 void frmMain::LoadPreferences(){
1395
1396     // Load the preferences.
1397
1398     wxString preffilename = GetUserPrefDir();
1399
1400     XABPreferences preferences(preffilename);
1401
1402     // Setup the main window position (if needed).
1403
1404     bool SaveWindowPos = preferences.GetBoolData(wxT("SaveWindowPosition"));
1405     bool HideLocalABs = preferences.GetBoolData(wxT("HideLocalAddressBooks"));
1406
1407     if (SaveWindowPos == TRUE){
1408
1409         this->SetSize(preferences.GetMainWindowData());
1410
1411     }
1412
1413     treAccounts->DeleteAllItems();
1414
1415     wxTreeItemId RootNode = treAccounts->AddRoot(wxT("Root Item"), AccountNoneID);
1416
1417     // Stop all account timers and remove the accounts.
1418
1419     for (std::map<wxString, wxAccountSyncTimer*>::iterator iter = AccountSyncTimers.begin();
1420          iter != AccountSyncTimers.end(); iter++){
1421
1422         wxAccountSyncTimer *AccTmrPtr = iter->second;
1423         AccTmrPtr->Stop();
1424
1425         delete AccTmrPtr;
1426         AccTmrPtr = NULL;
1427
1428     }
1429
1430     AccountSyncTimers.clear();
1431
1432     /*
1433      for (int i = (preferences.accounts.GetCount() - 1); i > 0; --i){
1434      treAccounts->AppendItem(RootNode, preferences.accounts.GetAccountName(i));
1435      }
1436      */
1437
1438     wxString AccDir;
1439     wxString AccDirFull;
1440     wxString AccDirFullSfx;
1441     wxString AccName;
1442     wxString AccDirFinal;
1443     AccountAccDirList.clear();
1444     AccountGroupList.clear();
1445     AccountGroupFilename.clear();
1446     AccountGroupTreeId.clear();
1447     wxTreeItemId AccountTreeId;
1448     wxTreeItemId GroupTreeId;
1449     int intGroupID = 0;
1450
1451     for (int i = 0; i < preferences.accounts.GetCount(); i++){
1452
1453         if ((preferences.accounts.GetAccountType(i) == wxT("Local") ||
1454              preferences.accounts.GetAccountType(i) == wxT("local")) && HideLocalABs == TRUE){
1455
1456             continue;
1457
1458         }
1459
1460         if (preferences.accounts.GetAccountDirectory(i).IsEmpty()){
1461
1462             continue;
1463
1464         }
1465
1466         AccDir = preferences.accounts.GetAccountDirectory(i);
1467         AccDirFull = preferences.accounts.GetAccountDirectory(i);
1468         AccDirFull.Trim();
1469         AccDirFull.Append(wxT("."));
1470         AccDirFullSfx.Append(preferences.accounts.GetAccountType(i));
1471         AccDirFullSfx.LowerCase();
1472         AccDirFullSfx.Trim();
1473         AccDirFull.Append(AccDirFullSfx);
1474         AccName = preferences.accounts.GetAccountName(i);
1475         AccName.Trim();
1476         AccountAccDirList.insert(std::make_pair(i, AccDirFull));
1477
1478         if (preferences.accounts.GetAccountType(i) == wxT("CardDAV") ||
1479             preferences.accounts.GetAccountType(i) == wxT("carddav")){
1480
1481             // Check if the directory exists before doing anything.
1482
1483
1484
1485             // Add a new timer using the existing account details.
1486
1487             wxAccountSyncTimer *ActTmrPtr = new wxAccountSyncTimer;
1488
1489             ActTmrPtr->SetupData(AccDirFull, AccName);
1490             ActTmrPtr->SetupPointers(this, ActMgrPtr, ETagProcTimer.GetPointer(AccDirFull));
1491             ActTmrPtr->Start((int)(preferences.accounts.GetAccountRefresh(i) * 1000));
1492             ActTmrPtr->SetOwner(this);
1493             ActTmrPtr->Notify();
1494
1495             // Add the timer to the list of timers.
1496
1497             AccountSyncTimers.insert(std::make_pair(AccDirFull, ActTmrPtr));
1498
1499             AccountTreeId = treAccounts->AppendItem(RootNode, preferences.accounts.GetAccountName(i), AccountNetID, -1);
1500
1501         } else {
1502
1503             AccountTreeId = treAccounts->AppendItem(RootNode, preferences.accounts.GetAccountName(i), AccountID, -1);
1504
1505         }
1506
1507         // Go through the account directory and find contact files with
1508         // 'KIND:group' set and add them to the list of groups for the account.
1509
1510         AccDirFinal = GetAccountDir(AccDirFull, FALSE);
1511
1512         wxDir vcardaccdir(AccDirFinal);
1513
1514         wxString vCardFilename;
1515         wxString vCardDataString;
1516         wxString vCardFilenameFull;
1517         //bool ProcFiles = FALSE;
1518
1519         bool ProcFiles = vcardaccdir.GetFirst(&vCardFilename, wxEmptyString, wxDIR_FILES);
1520         while(ProcFiles){
1521
1522             if (vCardFilename.Right(4) == wxT(".vcf") ||
1523                 vCardFilename.Right(4) == wxT(".VCF") ||
1524                 vCardFilename.Right(5) == wxT(".vcard") ||
1525                 vCardFilename.Right(5) == wxT(".VCARD")){
1526
1527                 vCard Person;
1528
1529                 vCardFilenameFull.Append(AccDirFinal);
1530                 vCardFilenameFull.Append(wxT("/"));
1531                 vCardFilenameFull.Append(vCardFilename);
1532
1533                 Person.LoadFile(vCardFilenameFull);
1534
1535                 if (Person.MeetBaseSpecification()){
1536
1537                     vCardDataString = Person.Get(wxT("KIND"));
1538
1539                     if (vCardDataString == wxT("group")){
1540
1541                         // The vCard kind is a group. Add to the account's group list.
1542
1543                         GroupTreeId = treAccounts->AppendItem(AccountTreeId, Person.Get(wxT("FN")), AccountGrpID, -1);
1544                         treAccounts->SetItemHasChildren(AccountTreeId, TRUE);
1545                         AccountGroupList.insert(std::make_pair(intGroupID, i));
1546                         AccountGroupFilename.insert(std::make_pair(intGroupID, vCardFilenameFull));
1547                         AccountGroupTreeId.insert(std::make_pair(GroupTreeId, intGroupID));
1548
1549                     }
1550
1551                     intGroupID++;
1552
1553                 } else {
1554
1555                 }
1556
1557             }
1558
1559             vCardFilename.Clear();
1560             vCardFilenameFull.Clear();
1561             vCardDataString.Clear();
1562             ProcFiles = vcardaccdir.GetNext(&vCardFilename);
1563
1564         }
1565
1566         // Clearup for next account.
1567
1568         AccDir.clear();
1569         AccDirFull.clear();
1570         AccDirFullSfx.clear();
1571         AccDirFinal.clear();
1572         AccName.clear();
1573
1574     }
1575
1576     // Load the account settings as they are needed for connecting
1577     // to the servers.
1578
1579     prefaccounts = preferences.accounts;
1580
1581 }
1582
1583 void frmMain::ConflictResolution(wxCommandEvent& event){
1584
1585     frmConflictResolution *frameCR = new frmConflictResolution ( this );
1586     vCardConflictObj *vCardConfObj = (vCardConflictObj*)event.GetClientData();
1587     vCard *ClientDataPtr = vCardConfObj->vCardLocalData;
1588     vCard *ServerDataPtr = vCardConfObj->vCardServerData;
1589     //vCard *ServerDataPtr = vCardConfObj->vCardServerData;
1590     //wxString Moo = ClientDataPtr->WriteString();
1591     //vCard *ServerDataPtr = vCardConfObj->vCardServerData;
1592     frameCR->LoadData(ClientDataPtr, ServerDataPtr, &MemoryFileList);
1593     //frameCR->LoadData(vCardConfObj->vCardLocalData, vCardConfObj->vCardServerData, &MemoryFileList);
1594     frameCR->ShowModal();
1595
1596     int FinalConflictResult = frameCR->GetResult();
1597
1598     wxCommandEvent event2(ACTMGR_RESUMEPROC);
1599     event2.SetClientData(vCardConfObj->QRNotifData);
1600     event2.SetInt(FinalConflictResult);
1601
1602     delete frameCR;
1603     frameCR = NULL;
1604
1605     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
1606     wxPostEvent(frameActMgr, event2);
1607
1608 }
1609
1610 void frmMain::UpdateContactList(wxCommandEvent& event){
1611
1612     UCNotif *ucd = (UCNotif*)event.GetClientData();
1613
1614     // Check if the active account is being displayed in the
1615     // main window. If not, skip and delete the data.
1616
1617     long longSelected = -1;
1618     int intSelectedData = 0;
1619
1620     if (ActiveAccount == ucd->ContactAccount){
1621
1622         // Look at the list of contacts and if it matches the
1623         // filename then update the name.
1624
1625         for (;;){
1626
1627             longSelected = lstContacts->GetNextItem(longSelected,
1628                                                     wxLIST_NEXT_ALL,
1629                                                     wxLIST_STATE_DONTCARE);
1630
1631             if (longSelected == -1){
1632
1633                 break;
1634
1635             }
1636
1637             intSelectedData = (int)lstContacts->GetItemData(longSelected);
1638
1639             if (ucd->ContactFilename == ContactsFileIndex[intSelectedData]){
1640
1641                 // Work out which sorting mode we are in.
1642
1643                 if (SortMode == 1){
1644
1645                     // First Name, Last Name.
1646
1647                     lstContacts->SetItem(longSelected, 0, ucd->ContactNameArray.Forename + wxT(" ") + ucd->ContactNameArray.Surname);
1648
1649                 } else if (SortMode == 2){
1650
1651                     // Last Name, First Name.
1652
1653                     lstContacts->SetItem(longSelected, 0, ucd->ContactNameArray.Surname + wxT(", ") + ucd->ContactNameArray.Forename);
1654
1655                 } else if (SortMode == 3){
1656
1657                     // Nickname.
1658
1659                     lstContacts->SetItem(longSelected, 0, ucd->ContactNickname);
1660
1661                 } else if (SortMode == 4){
1662
1663                     // Display As.
1664
1665                     lstContacts->SetItem(longSelected, 0, ucd->ContactName);
1666
1667                 }
1668
1669
1670             }
1671
1672             // If the filename is the one loaded into the
1673             // browser control, then update this too.
1674
1675             if (ActiveFilename == ContactsFileIndex[intSelectedData]){
1676
1677                 wxListEvent nullevent;
1678                 ShowContactInfo(nullevent);
1679
1680             }
1681
1682         }
1683
1684     }
1685
1686     for (std::map<int, void*>::iterator WindowIter = WindowListPointers.begin();
1687          WindowIter != WindowListPointers.end(); WindowIter++){
1688
1689         if (WindowListType[WindowIter->first] != 0){
1690
1691             continue;
1692
1693         }
1694
1695         frmContact *frmContactPtr = static_cast<frmContact*>(WindowIter->second);
1696
1697         if (frmContactPtr->GetFilename() == ucd->ContactFilename){
1698
1699             vCard UpdatedPerson;
1700             UpdatedPerson.LoadFile(ucd->ContactFilename);
1701             frmContactPtr->SetupContactData(&UpdatedPerson);
1702
1703         }
1704
1705     }
1706
1707     // Send message to search window controller subroutine and
1708     // pass that notification onto the search windows.
1709
1710     // Setup the new pointer to use the existing UCNotif without
1711     // deleting it.
1712
1713     UCNotif *ucd2 = ucd;
1714
1715     wxCommandEvent sup(SE_UPDATECONTACTNOTIF);
1716     sup.SetClientData(ucd2);
1717     wxPostEvent(this, sup);
1718
1719     // Clear up the unused pointer.
1720
1721     ucd = NULL;
1722
1723 }
1724
1725 void frmMain::UpdateAccountList(wxCommandEvent& event){
1726
1727 }
1728
1729 void frmMain::SetupPointers(void *ActMgrPtrInc){
1730
1731     ActMgrPtr = ActMgrPtrInc;
1732
1733 }
1734
1735 void frmMain::SetupForm(){
1736
1737     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
1738     frameActMgr->SetupPointers(&ETagProcTimer, this);
1739
1740     // Setup the contact information icons for later.
1741
1742     wxFileSystem::AddHandler(new wxMemoryFSHandler);
1743     wxImage ciicon_png;
1744     //wxBitmap ciicon;
1745
1746     wxMemoryInputStream ciptostream(icons_cipto_png, sizeof(icons_cipto_png));
1747     ciicon_png.LoadFile(ciptostream, wxBITMAP_TYPE_PNG);
1748     wxMemoryFSHandler::AddFile(wxT("cipto.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1749
1750     wxMemoryInputStream cilogstream(icons_cilog_png, sizeof(icons_cilog_png));
1751     ciicon_png.LoadFile(cilogstream, wxBITMAP_TYPE_PNG);
1752     wxMemoryFSHandler::AddFile(wxT("cilog.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1753
1754     wxMemoryInputStream cisndstream(icons_cisnd_png, sizeof(icons_cisnd_png));
1755     ciicon_png.LoadFile(cisndstream, wxBITMAP_TYPE_PNG);
1756     wxMemoryFSHandler::AddFile(wxT("cisnd.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1757
1758     wxMemoryInputStream cikeystream(icons_cikey_png, sizeof(icons_cikey_png));
1759     ciicon_png.LoadFile(cikeystream, wxBITMAP_TYPE_PNG);
1760     wxMemoryFSHandler::AddFile(wxT("cikey.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1761
1762     wxMemoryInputStream civenstream(icons_civen_png, sizeof(icons_civen_png));
1763     ciicon_png.LoadFile(civenstream, wxBITMAP_TYPE_PNG);
1764     wxMemoryFSHandler::AddFile(wxT("civen.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1765
1766     wxMemoryInputStream ciextstream(icons_ciext_png, sizeof(icons_ciext_png));
1767     ciicon_png.LoadFile(ciextstream, wxBITMAP_TYPE_PNG);
1768     wxMemoryFSHandler::AddFile(wxT("ciext.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1769
1770     LoadPreferences();
1771
1772 }
1773
1774 void frmMain::UpdateSearchContactLists(wxCommandEvent& event){
1775
1776     // Go through each of the search windows and
1777     // send the required notification to update the
1778     // contact information.
1779
1780     // Get the event notification data.
1781
1782     UCNotif *ucd = (UCNotif*)event.GetClientData();
1783
1784     // Process each search window giving the new details.
1785
1786     for (std::map<void*,wxString>::iterator switer = SearchWindowList.begin();
1787          switer != SearchWindowList.end(); switer++){
1788
1789         // Duplicate the event notification data.
1790
1791         UCNotif *ucd2 = new UCNotif;
1792
1793         ucd2->ContactAccount = ucd->ContactAccount;
1794         ucd2->ContactFilename = ucd->ContactFilename;
1795         ucd2->ContactName = ucd->ContactName;
1796         ucd2->ContactNickname = ucd->ContactNickname;
1797         ucd2->ContactNameArray = ucd->ContactNameArray;
1798
1799         // Pass the data to the search window for processing.
1800
1801         frmSearch *frameSCH = static_cast<frmSearch*>(switer->first);
1802         wxCommandEvent schupdate(SE_UPDATERESULT);
1803         schupdate.SetClientData(ucd2);
1804         wxPostEvent(frameSCH, schupdate);
1805
1806         // Clear up the pointer prior to variable deletion.
1807
1808         frameSCH = NULL;
1809
1810     }
1811
1812     delete ucd;
1813     ucd = NULL;
1814
1815 }
1816
1817 void frmMain::OpenFindContactsWindow(wxCommandEvent& event){
1818
1819     WindowMenuItemID++;
1820
1821     frmSearch *frameSCH = new frmSearch ( this );
1822     frameSCH->SetUID(WindowMenuItemID);
1823     frameSCH->Show(true);
1824
1825     WindowData *WData = new WindowData;
1826
1827     WData->DataType = 2;
1828     WData->WindowPointer = (void*)frameSCH;
1829     WData->WindowID = WindowMenuItemID;
1830
1831     wxCommandEvent addevent(WINDOW_ADD);
1832     addevent.SetClientData(WData);
1833     wxPostEvent(this, addevent);
1834
1835     // Add pointer to the list of open search windows.
1836
1837     SearchWindowList.insert(std::make_pair(frameSCH, wxT("Search")));
1838
1839     WData = NULL;
1840
1841 }
1842
1843 void frmMain::RemoveContactsWindowPointer(wxCommandEvent& event){
1844
1845     //frmSearch *frameSCH = static_cast<frmSearch*>(ActMgrPtr);
1846     void *frameSCH = (void*)event.GetClientData();
1847
1848     SearchWindowList.erase(frameSCH);
1849
1850     frameSCH = NULL;
1851
1852 }
1853
1854 void frmMain::RemoveContactEditorWindowPointer(wxCommandEvent& event){
1855
1856     void *frameSCH = (void*)event.GetClientData();
1857
1858     SearchWindowList.erase(frameSCH);
1859
1860     frameSCH = NULL;
1861
1862 }
1863
1864 void frmMain::UpdateWindowList(wxCommandEvent& event){
1865
1866     // Update the Window List.
1867
1868     // Delete the existing items in the window menu.
1869
1870     // Get the list of contacts.
1871
1872     // Insert a separator.
1873
1874     // Get the list of search windows.
1875
1876 }
1877
1878 void frmMain::RevealContact(wxCommandEvent& event){
1879
1880     UCNotif *uc = (UCNotif*)event.GetClientData();
1881
1882     // Switch the account to the one passed.
1883
1884     wxTreeItemIdValue cookie;
1885     wxTreeItemId next = treAccounts->GetRootItem();
1886     wxTreeItemId nextChild;
1887
1888     for (int i = 0; i < prefaccounts.GetCount(); i++){
1889
1890         if (!nextChild){
1891             nextChild = treAccounts->GetFirstChild(next, cookie);
1892         } else {
1893             nextChild = treAccounts->GetNextSibling(nextChild);
1894         }
1895
1896         //AccountName = treAccounts->GetItemText(nextChild);
1897
1898         if (uc->ContactAccount == AccountAccDirList[i]){
1899
1900             //AccControl->();
1901             treAccounts->SelectItem(nextChild, TRUE);
1902             AccCtrl->SetText(treAccounts->GetItemText(nextChild));
1903
1904         }
1905
1906     }
1907
1908     // Switch the contact to the one passed.
1909
1910     long longSelected = -1;
1911     int intSelectedData = 0;
1912
1913     for (;;){
1914
1915         longSelected = lstContacts->GetNextItem(longSelected,
1916                                                 wxLIST_NEXT_ALL,
1917                                                 wxLIST_STATE_DONTCARE);
1918
1919         if (longSelected == -1){
1920
1921             break;
1922
1923         }
1924
1925         intSelectedData = (int)lstContacts->GetItemData(longSelected);
1926
1927         // Compare the filename with the one received.
1928         // If they match then select it.
1929
1930         if (ContactsFileIndex[intSelectedData] == uc->ContactFilename){
1931
1932             // Select.
1933
1934             lstContacts->SetItemState(longSelected, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
1935             lstContacts->EnsureVisible(longSelected);
1936
1937         } else {
1938
1939             lstContacts->SetItemState(longSelected, 0, wxLIST_STATE_SELECTED);
1940
1941         }
1942
1943     }
1944
1945 }
1946
1947 void frmMain::DeleteContact(wxCommandEvent& event){
1948
1949     // Check if a contact is selected.
1950
1951     long intSelected = -1;
1952     long intContactSeekNum = -1;
1953     wxString wxSContactName;
1954
1955     intSelected = lstContacts->GetNextItem(intSelected,
1956                                            wxLIST_NEXT_ALL,
1957                                            wxLIST_STATE_SELECTED);
1958
1959     if (intSelected == -1){
1960         return;
1961     }
1962
1963     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
1964
1965     // Get the item data of the contact.
1966
1967     intContactSeekNum = lstContacts->GetItemData(intSelected);
1968
1969     // Get the name of the contact.
1970
1971     wxSContactName = lstContacts->GetItemText(intSelected);
1972
1973     // Display a message confirming if the contact should
1974     // be deleted.
1975
1976     int QuestionResponse;
1977
1978     QuestionResponse = wxMessageBox(_("Are you sure you want to delete this contact?"), _("Delete contact"), wxYES_NO, this);
1979
1980     if (QuestionResponse == wxNO){
1981
1982         // Exit the subroutine
1983
1984         return;
1985
1986     }
1987
1988     // Delete the contact.
1989
1990     if (!wxRemoveFile(ContactsFileIndex[intContactSeekNum])){
1991
1992         wxMessageBox(_("Unable to delete the contact."), _("Cannot delete contact"), wxOK, this);
1993         return;
1994
1995     }
1996
1997     // Remove the contact from the list.
1998
1999     lstContacts->DeleteItem(intSelected);
2000
2001     // Update the search windows, removing the deleted
2002     // contact.
2003
2004     UCNotif *ucd = new UCNotif;
2005
2006     ucd->ContactAccount = ActiveAccount;
2007     ucd->ContactFilename = ContactsFileIndex[intContactSeekNum];
2008
2009     for (std::map<void*,wxString>::iterator switer = SearchWindowList.begin();
2010          switer != SearchWindowList.end(); switer++){
2011
2012         // Duplicate the event notification data.
2013
2014         UCNotif *ucd2 = new UCNotif;
2015
2016         ucd2->ContactAccount = ucd->ContactAccount;
2017         ucd2->ContactFilename = ucd->ContactFilename;
2018
2019         // Pass the data to the search window for processing.
2020
2021         frmSearch *frameSCH = static_cast<frmSearch*>(switer->first);
2022         wxCommandEvent schdelete(SE_DELETERESULT);
2023         schdelete.SetClientData(ucd2);
2024         wxPostEvent(frameSCH, schdelete);
2025
2026         // Clear up the pointer prior to variable deletion.
2027
2028         frameSCH = NULL;
2029         ucd2 = NULL;
2030
2031     }
2032
2033     // Clear the wxHTMLWindow.
2034
2035     wxString EmptyPage = wxT("");
2036
2037     htmContactData->SetPage(EmptyPage);
2038
2039     wxStringTokenizer wSTFilename(ContactsFileIndex[intContactSeekNum], wxT("/"));
2040
2041     wxString wxSplitFilename;
2042     wxString wxSDataURL;
2043
2044     while(wSTFilename.HasMoreTokens()){
2045
2046         wxSplitFilename = wSTFilename.GetNextToken();
2047
2048     }
2049
2050     if (ActiveAccountType == wxT("CardDAV") || ActiveAccountType == wxT("carddav")){
2051
2052         // Update the ETagDB and mark it as deleted.
2053
2054         ETagDB *ETagDBPtr = ETagProcTimer.GetPointer(ActiveAccount);
2055
2056         ETagDBPtr->UpdateETag(wxSplitFilename, wxT("DELETED"));
2057
2058         // Get the Data URL.
2059
2060         wxTreeItemIdValue cookie;
2061         wxTreeItemId next = treAccounts->GetRootItem();
2062
2063         wxTreeItemId selectedChild = treAccounts->GetSelection();
2064         wxTreeItemId nextChild;
2065
2066         for (int i = 0; i < prefaccounts.GetCount(); i++){
2067
2068             if (!nextChild){
2069                 nextChild = treAccounts->GetFirstChild(next, cookie);
2070             }
2071             else {
2072                 nextChild = treAccounts->GetNextSibling(nextChild);
2073             }
2074
2075             if (nextChild == selectedChild){
2076                 wxSDataURL = prefaccounts.GetAccountDirPrefix(i) + wxT("/") + wxSplitFilename;
2077
2078             }
2079
2080         }
2081
2082         // Add task to the activity monitor to delete the contact.
2083
2084         frameActMgr->AddTask(2, wxSContactName, ActiveAccount, wxSDataURL, wxSplitFilename, ContactsFileIndex[intContactSeekNum], wxT(""));
2085
2086     }
2087
2088     // Clear the variable. Don't delete as it will mess things up.
2089
2090     ContactsFileIndex[intContactSeekNum] = wxT("");
2091
2092     delete ucd;
2093     ucd = NULL;
2094
2095 }
2096
2097 void frmMain::EmptyServerDialog(wxCommandEvent& event){
2098
2099     QRNotif *qrn = (QRNotif *)event.GetClientData();
2100
2101     int QResponse = wxMessageBox(_("The list of contacts on the server is empty. Upload all locally stored contacts for this account now?"), _("No contacts on server"), wxYES_NO, this);
2102
2103     if (QResponse == wxNO){
2104
2105         return;
2106
2107     }
2108
2109     wxCommandEvent event2(ACTMGR_RESUMEPROC);
2110     event2.SetInt(*qrn->QResponse);
2111     event2.SetClientData(qrn->PausePtr);
2112
2113     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
2114
2115     wxPostEvent(frameActMgr, event2);
2116
2117 }
2118
2119 void frmMain::DeleteContactSync(wxString &Account, wxString &Filename){
2120
2121     // Remove the contact from the window after syncronising.
2122
2123     // Check which account is currently active in the window.
2124     // If it is different from the one passed to this subroutine then
2125     // exit from the subroutine.
2126
2127     if (Account != ActiveAccount){
2128         return;
2129     }
2130
2131     long longSelected = -1;
2132     int intSelectedData = 0;
2133
2134     for (;;){
2135
2136         longSelected = lstContacts->GetNextItem(longSelected,
2137                                                 wxLIST_NEXT_ALL,
2138                                                 wxLIST_STATE_DONTCARE);
2139
2140         if (longSelected == -1){
2141
2142             break;
2143
2144         }
2145
2146         intSelectedData = (int)lstContacts->GetItemData(longSelected);
2147
2148         // Compare the filename with the one received.
2149         // If they match then select it.
2150
2151         if (ContactsFileIndex[intSelectedData] == Filename){
2152
2153             // Remove the contact from the window.
2154
2155             lstContacts->DeleteItem(intSelectedData);
2156
2157             // Check if contact is the selected contact in the HTML window and
2158             // if it is then clear the window.
2159
2160             if (ActiveFilename == Filename){
2161
2162                 wxString EmptyPage = wxT("");
2163                 htmContactData->SetPage(EmptyPage);
2164
2165             }
2166
2167             break;
2168
2169         }
2170
2171     }
2172
2173 }
2174
2175
2176
2177 void frmMain::SortFNLN( wxCommandEvent& event ) {
2178
2179     wxTreeEvent NullEvent;
2180     SortMode = 1;
2181     LoadContactList(NullEvent);
2182
2183 }
2184
2185 void frmMain::SortLNFN( wxCommandEvent& event ) {
2186
2187     wxTreeEvent NullEvent;
2188     SortMode = 2;
2189     LoadContactList(NullEvent);
2190
2191 }
2192
2193 void frmMain::SortNickname( wxCommandEvent& event ) {
2194
2195     wxTreeEvent NullEvent;
2196     SortMode = 3;
2197     LoadContactList(NullEvent);
2198
2199 }
2200
2201 void frmMain::SortDisplayAs( wxCommandEvent& event ) {
2202
2203     wxTreeEvent NullEvent;
2204     SortMode = 4;
2205     LoadContactList(NullEvent);
2206
2207 }
2208
2209 void frmMain::SortAscending( wxCommandEvent& event ) {
2210
2211     wxTreeEvent NullEvent;
2212     AscendingMode = TRUE;
2213     LoadContactList(NullEvent);
2214
2215 }
2216
2217 void frmMain::SortDescending( wxCommandEvent& event ) {
2218
2219     wxTreeEvent NullEvent;
2220     AscendingMode = FALSE;
2221     LoadContactList(NullEvent);
2222
2223 }
2224
2225 void frmMain::ToggleStatusBar( wxCommandEvent& event ) {
2226
2227     if (stbBottom->IsShown() == TRUE){
2228
2229         stbBottom->Hide();
2230
2231     } else {
2232
2233         stbBottom->Show();
2234
2235     }
2236
2237     this->Layout();
2238
2239 }
2240
2241 void frmMain::ActivityIconStart( wxCommandEvent& event ){
2242
2243     // Display the activity icon.
2244
2245     imgActivityStatus->SetBitmap(*imgActIcon1);
2246     ActivityIconStatus = 0;
2247
2248 }
2249
2250 void frmMain::ActivityIconShuffle( wxCommandEvent& event ){
2251
2252     switch (ActivityIconStatus){
2253
2254         case 0:
2255             imgActivityStatus->SetBitmap(*imgActIcon1);
2256             ActivityIconStatus = 1;
2257             break;
2258         case 1:
2259             imgActivityStatus->SetBitmap(*imgActIcon2);
2260             ActivityIconStatus = 2;
2261             break;
2262         case 2:
2263             imgActivityStatus->SetBitmap(*imgActIcon3);
2264             ActivityIconStatus = 3;
2265             break;
2266         case 3:
2267             imgActivityStatus->SetBitmap(*imgActIcon4);
2268             ActivityIconStatus = 0;
2269             break;
2270         default:
2271             ActivityIconStatus = 0;
2272
2273     }
2274
2275 }
2276
2277 void frmMain::ActivityIconStop( wxCommandEvent& event ){
2278
2279     // Display the sleep icon.
2280
2281     imgActivityStatus->SetBitmap(*imgActIconSleep);
2282
2283 }
2284
2285 void frmMain::UpdateSBIconPlacement( wxSizeEvent& event ){
2286
2287     if (imgConnStatus == 0 || imgSSLStatus == 0 || imgActivityStatus == 0){
2288
2289         return;
2290
2291     }
2292
2293     wxRect rectOnline;
2294     wxRect rectSSL;
2295     wxRect rectActivity;
2296     stbBottom->GetFieldRect(1, rectOnline);
2297     stbBottom->GetFieldRect(2, rectSSL);
2298     stbBottom->GetFieldRect(3, rectActivity);
2299
2300     imgConnStatus->Move(rectOnline.GetX(),rectOnline.GetY());
2301     imgSSLStatus->Move(rectSSL.GetX(),rectSSL.GetY());
2302     imgActivityStatus->Move(rectActivity.GetX(),rectActivity.GetY());
2303
2304 }
2305
2306 XABViewMode frmMain::GetViewMode(){
2307
2308     XABViewMode xvm;
2309
2310     xvm.SortMode = SortMode;
2311     xvm.AscendingMode = AscendingMode;
2312
2313     return xvm;
2314
2315 }
2316
2317 void frmMain::WindowAdd( wxCommandEvent &event ){
2318
2319     WindowData *WData = (WindowData*)event.GetClientData();
2320
2321     size_t pos;
2322
2323     if (WData->DataType == 0){
2324
2325         // Contact Window
2326
2327         int intID = mnuContactWindows->GetId();
2328
2329         mnuWindow->FindChildItem(intID, &pos);
2330         wxMenuItem *mnuNewItem = new wxMenuItem(NULL, WData->WindowID, wxT("Contact Window #") + wxString::Format(wxT("%i"), WData->WindowID), wxEmptyString, wxITEM_NORMAL, NULL);
2331         mnuNewItem->SetId(WData->WindowID);
2332         WindowListPointersMenu.insert(std::make_pair(WData->WindowID, mnuNewItem));
2333         WindowListPointers.insert(std::make_pair(WData->WindowID, WData->WindowPointer));
2334         WindowListType.insert(std::make_pair(WData->WindowID, 0));
2335         mnuWindow->Insert((pos + 1), mnuNewItem);
2336         this->Connect(mnuNewItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(frmMain::ShowContactWindow));
2337
2338     } else if (WData->DataType == 1){
2339
2340         // Contact Editor Window
2341
2342         int intID = mnuContactEditorWindows->GetId();
2343
2344         mnuWindow->FindChildItem(intID, &pos);
2345         wxMenuItem *mnuNewItem = new wxMenuItem(NULL, WData->WindowID, wxT("Contact Editor Window #") + wxString::Format(wxT("%i"), WData->WindowID), wxEmptyString, wxITEM_NORMAL, NULL);
2346         mnuNewItem->SetId(WData->WindowID);
2347         WindowListPointersMenu.insert(std::make_pair(WData->WindowID, mnuNewItem));
2348         WindowListPointers.insert(std::make_pair(WData->WindowID, WData->WindowPointer));
2349         WindowListType.insert(std::make_pair(WData->WindowID, 1));
2350         mnuWindow->Insert((pos + 1), mnuNewItem);
2351         this->Connect(mnuNewItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(frmMain::ShowContactEditorWindow));
2352
2353     } else if (WData->DataType == 2){
2354
2355         // Search Window
2356
2357         int intID = mnuSearchWindows->GetId();
2358
2359         mnuWindow->FindChildItem(intID, &pos);
2360         wxMenuItem *mnuNewItem = new wxMenuItem(NULL, WData->WindowID, wxT("Search Window #") + wxString::Format(wxT("%i"), WData->WindowID), wxEmptyString, wxITEM_NORMAL, NULL);
2361         mnuNewItem->SetId(WData->WindowID);
2362         WindowListPointersMenu.insert(std::make_pair(WData->WindowID, mnuNewItem));
2363         WindowListPointers.insert(std::make_pair(WData->WindowID, WData->WindowPointer));
2364         WindowListType.insert(std::make_pair(WData->WindowID, 2));
2365         mnuWindow->Insert((pos + 1), mnuNewItem);
2366         this->Connect(mnuNewItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(frmMain::ShowSearchWindow));
2367
2368     }
2369
2370     delete WData;
2371     WData = NULL;
2372
2373 }
2374
2375 void frmMain::WindowEdit( wxCommandEvent &event ){
2376
2377     WindowData *WData = (WindowData*)event.GetClientData();
2378
2379     if (WData->DataType == 0){
2380
2381         // Get the window title and use that.
2382
2383         frmContact *frmContactPtr = static_cast<frmContact*>(WData->WindowPointer);
2384
2385         wxString WindowTitle = frmContactPtr->GetTitle();
2386
2387         std::map<int, wxMenuItem*>::iterator MenuIter = WindowListPointersMenu.find(WData->WindowID);
2388
2389         MenuIter->second->SetItemLabel(WindowTitle);
2390
2391         //mnuWindow->FindChildItem(intID, &pos);
2392         //wxMenuItem *mnuNewItem = new wxMenuItem(NULL, WData->WindowID, WindowTitle, WData->WindowID), wxEmptyString, wxITEM_NORMAL, NULL);
2393         //mnuNewItem->SetId(WData->WindowID);
2394         //ContactWindowListPointersMenu.insert(std::make_pair(WData->WindowID, mnuNewItem));
2395         //ContactWindowListPointers.insert(std::make_pair(WData->WindowID, WData->WindowPointer));
2396         //mnuWindow->Insert((pos + 1), mnuNewItem);
2397         //this->Connect(mnuNewItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(frmMain::ShowContactWindow));
2398
2399     } else if (WData->DataType == 1){
2400
2401         // Get the window title and use that.
2402
2403         frmContactEditor *frmCEPtr = static_cast<frmContactEditor*>(WData->WindowPointer);
2404
2405         wxString WindowTitle = frmCEPtr->GetTitle();
2406
2407         std::map<int, wxMenuItem*>::iterator MenuIter = WindowListPointersMenu.find(WData->WindowID);
2408
2409         if (WindowTitle.IsEmpty()){
2410
2411             MenuIter->second->SetItemLabel(_("Unnamed Contact"));
2412
2413         } else {
2414
2415             MenuIter->second->SetItemLabel(WindowTitle);
2416
2417         }
2418
2419         //mnuWindow->FindChildItem(intID, &pos);
2420         //wxMenuItem *mnuNewItem = new wxMenuItem(NULL, WData->WindowID, WindowTitle, WData->WindowID), wxEmptyString, wxITEM_NORMAL, NULL);
2421         //mnuNewItem->SetId(WData->WindowID);
2422         //ContactEditorWindowListPointersMenu.insert(std::make_pair(WData->WindowID, mnuNewItem));
2423         //ContactEditorWindowListPointers.insert(std::make_pair(WData->WindowID, WData->WindowPointer));
2424         //mnuWindow->Insert((pos + 1), mnuNewItem);
2425         //this->Connect(mnuNewItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(frmMain::ShowContactEditorWindow));
2426
2427     }
2428
2429     delete WData;
2430     WData = NULL;
2431
2432 }
2433
2434 void frmMain::WindowDelete( wxCommandEvent &event ){
2435
2436     WindowData *WData = (WindowData*)event.GetClientData();
2437
2438     std::map<int, wxMenuItem*>::iterator MenuIter = WindowListPointersMenu.find(WData->WindowID);
2439
2440     mnuWindow->Remove(MenuIter->second);
2441
2442     delete MenuIter->second;
2443     MenuIter->second = NULL;
2444
2445     WindowListPointersMenu.erase(WData->WindowID);
2446     WindowListPointers.erase(WData->WindowID);
2447     WindowListType.erase(WData->WindowID);
2448
2449     delete WData;
2450     WData = NULL;
2451
2452 }
2453
2454 void frmMain::ShowContactWindow( wxCommandEvent &event ){
2455
2456     std::map<int, void*>::iterator WindowIter = WindowListPointers.find(event.GetId());
2457
2458     frmContact *frmContactPtr = static_cast<frmContact*>(WindowIter->second);
2459
2460     frmContactPtr->Show();
2461     frmContactPtr->Raise();
2462
2463 }
2464
2465 void frmMain::ShowContactEditorWindow( wxCommandEvent &event ){
2466
2467     std::map<int, void*>::iterator WindowIter = WindowListPointers.find(event.GetId());
2468
2469     frmContactEditor *frmCEPtr = static_cast<frmContactEditor*>(WindowIter->second);
2470
2471     frmCEPtr->Show();
2472     frmCEPtr->Raise();
2473
2474 }
2475
2476 void frmMain::ShowSearchWindow( wxCommandEvent &event ){
2477
2478     // Look through the Search Window List Pointers, grab the
2479     // window point and show the window.
2480
2481     std::map<int, void*>::iterator WindowIter = WindowListPointers.find(event.GetId());
2482
2483     frmSearch *frmSearchPtr = static_cast<frmSearch*>(WindowIter->second);
2484
2485     frmSearchPtr->Show();
2486     frmSearchPtr->Raise();
2487
2488 }
2489
2490 void frmMain::ToggleConnectionStatus( wxCommandEvent &event ){
2491
2492     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
2493     wxCommandEvent toggconn(ACTMGR_TOGGLECONN);
2494     wxPostEvent(frameActMgr, toggconn);
2495
2496 }
2497
2498 void frmMain::ShowSSLCertificates( wxCommandEvent &event ){
2499
2500     // Check the account type before continuing.
2501
2502     wxString SeekAccount;
2503     wxString AccTypeLower;
2504     wxString AccType;
2505     bool AccountSSL;
2506     std::map<int, SSLCertCollection>::iterator SSLColIter;
2507
2508     for (int i = 0; i < prefaccounts.GetCount(); i++){
2509
2510         SeekAccount.Append(prefaccounts.GetAccountDirectory(i));
2511         AccType.Append(prefaccounts.GetAccountType(i));
2512         AccountSSL = prefaccounts.GetAccountSSL(i);
2513         AccTypeLower = AccType.MakeLower();
2514         SeekAccount.Append(wxT("."));
2515         SeekAccount.Append(AccTypeLower);
2516
2517         if (SeekAccount == ActiveAccount){
2518
2519             if (AccTypeLower == wxT("local")){
2520
2521                 return;
2522
2523             }
2524
2525             if (AccountSSL == false){
2526
2527                 return;
2528
2529             }
2530
2531             SSLColIter = AccountSSLData.find(i);
2532
2533             SSLCertCollection SSLCertInfo = SSLColIter->second;
2534
2535             frmSSLCertificate *frameSSLCert = new frmSSLCertificate ( this );
2536             frameSSLCert->StartCertFrom(0);
2537             frameSSLCert->SetupCerts(SSLCertInfo);
2538             frameSSLCert->ShowModal();
2539
2540             delete frameSSLCert;
2541             frameSSLCert = NULL;
2542
2543         }
2544
2545         SeekAccount.Clear();
2546         AccTypeLower.Clear();
2547         AccType.clear();
2548
2549     }
2550
2551 }
2552
2553 void frmMain::ShowSSLInfo( wxCommandEvent &event ){
2554
2555     // Check the account type before continuing.
2556
2557 }
2558
2559 void frmMain::HideSSLInfo( wxCommandEvent &event ){
2560
2561     // Check the account type before continuing.
2562
2563 }
2564
2565 void frmMain::UpdateConnectionStatus( wxCommandEvent &event ){
2566
2567     if (event.GetInt() == 0){
2568
2569         imgConnStatus->SetBitmap(*imgOnline);
2570
2571     } else {
2572
2573         imgConnStatus->SetBitmap(*imgOffline);
2574
2575     }
2576
2577 }
2578
2579 void frmMain::SetupSSLStatus( int AccountID ){
2580
2581     // Check if account ID given is
2582     // the active account and if not, do nothing.
2583
2584     wxString AccType;
2585     wxString AccTypeLower;
2586
2587     AccType = prefaccounts.GetAccountType(AccountID);
2588     AccTypeLower = AccType.MakeLower();
2589
2590     wxString AccountIDName = prefaccounts.GetAccountDirectory(AccountID) + wxT(".") +
2591                                 AccTypeLower;
2592
2593     if (AccountIDName != ActiveAccount){
2594
2595         return;
2596
2597     }
2598
2599     // Check if the account has SSL enabled.
2600
2601     bool SSLInUse = prefaccounts.GetAccountSSL(AccountID);
2602
2603     if (SSLInUse == FALSE){
2604
2605         SSLToolTip->SetTip(wxT("SSL is not enabled for this account"));
2606         imgSSLStatus->SetBitmap(*imgNoSSL);
2607
2608     } else {
2609
2610         // Get the SSL Collection Data.
2611
2612         std::map<int,int>::iterator SSLResultIter = AccountSSLResult.find(AccountID);
2613
2614         if (SSLResultIter->second == 1){
2615
2616             imgSSLStatus->SetBitmap(*imgSSLWarning);
2617             SSLToolTip->SetTip(wxT("Invalid certificate(s) received for '") +
2618                                prefaccounts.GetAccountName(AccountID) +
2619                                wxT("' (Connection denied by user)\n\nDouble click for more information."));
2620
2621
2622         } else if (SSLResultIter->second == 0){
2623
2624             imgSSLStatus->SetBitmap(*imgSSL);
2625             SSLToolTip->SetTip(wxT("Account '") +
2626                                prefaccounts.GetAccountName(AccountID) +
2627                                wxT("' secured using SSL\n\nDouble click for more information."));
2628
2629         }
2630
2631     }
2632
2633 }
2634
2635 void frmMain::InvalidSSLCertificate( wxCommandEvent &event ){
2636
2637     frmInvalidSSLCertificate *frameISC = new frmInvalidSSLCertificate ( this );
2638     SSLInvalidCertNotifObj *SSLICNObj = (SSLInvalidCertNotifObj*)event.GetClientData();
2639     SSLCertCollection SSLCCData = SSLICNObj->CertCollection;
2640     wxString AccountName = SSLICNObj->AccountName;
2641     frameISC->LoadData(SSLCCData, AccountName);
2642     frameISC->ShowModal();
2643
2644     int FinalConflictResult = frameISC->GetResult();
2645
2646     wxCommandEvent event2(ACTMGR_RESUMEPROC);
2647     event2.SetClientData(SSLICNObj->QRNotifData);
2648     event2.SetInt(FinalConflictResult);
2649
2650     delete frameISC;
2651     frameISC = NULL;
2652
2653     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
2654     wxPostEvent(frameActMgr, event2);
2655 }
2656
2657 void frmMain::PauseAllTimers(){
2658
2659     for (std::map<wxString, wxAccountSyncTimer*>::iterator ASTiter = AccountSyncTimers.begin();
2660          ASTiter != AccountSyncTimers.end(); ASTiter++){
2661
2662         ASTiter->second->Stop();
2663
2664     }
2665
2666 }
2667
2668 void frmMain::ResumeAllTimers(){
2669
2670     for (std::map<wxString, wxAccountSyncTimer*>::iterator ASTiter = AccountSyncTimers.begin();
2671          ASTiter != AccountSyncTimers.end(); ASTiter++){
2672
2673         ASTiter->second->Start();
2674
2675     }
2676
2677 }
2678
2679 void frmMain::UpdateSSLAccountStatus(int AccountID, int SSLStatus, SSLCertCollection SSLCertInc){
2680
2681     // Delete existing data.
2682
2683     AccountSSLData.erase(AccountID);
2684     AccountSSLResult.erase(AccountID);
2685
2686     // Insert new data.
2687
2688     AccountSSLData.insert(std::make_pair(AccountID, SSLCertInc));
2689     AccountSSLResult.insert(std::make_pair(AccountID, SSLStatus));
2690
2691 }
2692
2693 void frmMain::CheckUpdates( wxCommandEvent& event ){
2694
2695     frmUpdate *frameUpdate = new frmUpdate ( this );
2696     frameUpdate->FetchData();
2697     frameUpdate->ShowModal();
2698
2699 }
2700
2701 void frmMain::OpenImportDialog( wxCommandEvent& event ){
2702
2703     // Run the import contacts system.
2704
2705     ImportRun(this);
2706
2707 }
2708
2709 void frmMain::OpenExportDialog( wxCommandEvent& event ){
2710
2711     // Check if an account and at least one contact is selected
2712     // before continuing.
2713
2714     wxArrayString ArrData;
2715
2716     if (ActiveAccount.IsEmpty()){
2717
2718         return;
2719
2720     }
2721
2722     int ContactSelected = 0;
2723     int ContactsCollected = 0;
2724     long longSelected = -1;
2725
2726     for (;;){
2727
2728         longSelected = lstContacts->GetNextItem(longSelected,
2729                                                 wxLIST_NEXT_ALL,
2730                                                 wxLIST_STATE_SELECTED);
2731
2732         if (longSelected == -1){
2733
2734             break;
2735
2736         }
2737
2738         int FileID = (int)lstContacts->GetItemData(longSelected);
2739
2740         ArrData.Insert(ContactsFileIndex[FileID],
2741                        ContactsCollected, 1);
2742
2743         ContactSelected++;
2744
2745     }
2746
2747     if (ContactSelected == 0){
2748
2749         return;
2750
2751     }
2752
2753     // Run the export contacts system.
2754
2755     ExportRun(this, &ArrData);
2756
2757 }
2758
2759 void frmMain::GetListControl(wxListCtrl *lstContactsPtr,
2760                              wxArrayString *ContactsFileIndexPtr){
2761
2762     lstContactsPtr = lstContacts;
2763     ContactsFileIndexPtr = &ContactsFileIndex;
2764
2765 }
2766
2767 void frmMain::GetSelectedList( wxCommandEvent& event ){
2768
2769     // Get the array of contact filenames.
2770
2771     wxArrayString *ArrData = (wxArrayString*)event.GetClientData();
2772
2773     // Process them into an array of files.
2774
2775     long longSelected = -1;
2776     int ContactsCollected = 0;
2777     wxString ContactFilename;
2778
2779     for (;;){
2780
2781         longSelected = lstContacts->GetNextItem(longSelected,
2782                                                 wxLIST_NEXT_ALL,
2783                                                 wxLIST_STATE_SELECTED);
2784
2785         if (longSelected == -1){
2786
2787             break;
2788
2789         }
2790
2791         // Get the file information and add to the list.
2792
2793         int FileID = (int)lstContacts->GetItemData(longSelected);
2794
2795         ArrData->Insert(ContactsFileIndex[FileID],
2796                         ContactsCollected, 1);
2797
2798         ContactsCollected++;
2799         ContactFilename.Clear();
2800
2801     }
2802
2803     event.SetInt(1);
2804
2805 }
2806
2807 void frmMain::SyncAccount( wxCommandEvent& event ){
2808
2809     wxString AccNameInc = event.GetString();
2810
2811     frmActivityMgr *frameActMgr = static_cast<frmActivityMgr*>(ActMgrPtr);
2812     frameActMgr->AddTask(3, wxT(""), AccNameInc,
2813                          wxT(""), wxT(""), wxT(""), wxT(""));
2814
2815 }
2816
2817 void frmMain::ShowHelp( wxCommandEvent& event ){
2818
2819     // Based on the operating system, work out where
2820     // the documentation should be.
2821
2822     //#ifdef __APPLE__
2823
2824 #if defined(__HAIKU__)
2825
2826 #elif defined(__WIN32__)
2827
2828
2829
2830 #else
2831
2832     if (wxFileExists("/usr/share/doc/xestiaab/index.html")){
2833
2834         wxLaunchDefaultBrowser(wxT("file:///usr/share/doc/xestiaab/index.html"));
2835         return;
2836
2837 #if XSDAB_RELEASE == 0
2838
2839     } else if (wxFileExists("/usr/local/share/doc/xestiaab/index.html")){
2840
2841         wxLaunchDefaultBrowser(wxT("file:///usr/local/share/doc/xestiaab/index.html"));
2842         return;
2843
2844 #endif
2845
2846     }
2847
2848 #endif
2849
2850 #if XSDAB_RELEASE == 0
2851
2852     wxMessageBox(_("The help documentation is not available.\n\nYou can view the documentation that came with your source package."), _("Help documentation missing!"));
2853
2854 #else
2855
2856     wxMessageBox(_("The help documentation is not available in the usual locations on the system. Please visit http://documentation.xestia.co.uk/xestiaab/ for documentation"), _("Help documentation missing!"));
2857
2858 #endif
2859
2860 }
2861
2862 void frmMain::ShowImportResults( wxCommandEvent &event ){
2863
2864         std::map<int,wxString> *ResultData = (std::map<int,wxString>*)event.GetClientData();
2865
2866         frmImportResults *frmIR = new frmImportResults(this);
2867         frmIR->LoadData(ResultData, event.GetInt(), (int)event.GetExtraLong());
2868         frmIR->ShowModal();
2869
2870         delete frmIR;
2871         frmIR = NULL;
2872
2873         delete ResultData;
2874         ResultData = NULL;
2875
2876 }
2877
2878 void frmMain::ReloadContactList( wxCommandEvent &event ){
2879
2880         // Check if the account name given is the current
2881         // account selected.
2882
2883         if (ActiveAccount == event.GetString()){
2884
2885                 wxTreeEvent NullEvent;
2886                 LoadContactList(NullEvent);
2887
2888         }
2889
2890 }
2891
2892 void frmMain::ShowContactMenu( wxMouseEvent& event ){
2893
2894         bool EnableRefresh = FALSE;
2895
2896         if (!ActiveAccount.IsEmpty()){
2897
2898                 EnableRefresh = TRUE;
2899
2900         }
2901
2902         ContactMenu->SetupPointers(this, lstContacts, EnableRefresh);
2903
2904         this->PopupMenu(ContactMenu->MenuPointer(), wxDefaultPosition);
2905
2906 }