source/frmSearch.cpp

   1 #include "frmSearch.h"
   2 #include "frmMain.h"
   3 #include "frmContact.h"
   4 #include "search/XABSearchPanel.h"
   5 #include "search/frmSearchAccounts.h"
   6 #include "common/preferences.h"
   7 #include "common/dirs.h"
   8 #include "vcard/vcard.h"
   9
  10 #include <thread>
  11 #include <wx/fs_mem.h>
  12 /*#include <boost/filesystem.hpp>
  13 #include <boost/filesystem/fstream.hpp>
  14 #include <boost/filesystem/path.hpp>*/
  15 #include <wx/tokenzr.h>
  16 #include <wx/dir.h>
  17
  18 DEFINE_EVENT_TYPE(SE_ADDSEARCHSETTING);
  19 DEFINE_EVENT_TYPE(SE_REMOVESEARCHSETTING);
  20 DEFINE_EVENT_TYPE(SE_RELOADACCOUNTS);
  21 DEFINE_EVENT_TYPE(SE_ADDRESULT);
  22 DEFINE_EVENT_TYPE(SE_SBUPDATE);
  23 DEFINE_EVENT_TYPE(SE_SEARCHFINISHED);
  24 DEFINE_EVENT_TYPE(SE_UPDATERESULT);
  25 DEFINE_EVENT_TYPE(SE_DELETERESULT);
  26 DEFINE_EVENT_TYPE(SE_OPENCONTACT);
  27 DEFINE_EVENT_TYPE(SE_EDITCONTACT);
  28 DEFINE_EVENT_TYPE(SE_REVEALCONTACT);
  29
  30 BEGIN_EVENT_TABLE(frmSearch, wxFrame)
  31   EVT_COMMAND(wxID_ANY, SE_ADDSEARCHSETTING, frmSearch::AddSearchSetting)
  32   EVT_COMMAND(wxID_ANY, SE_REMOVESEARCHSETTING, frmSearch::RemoveSearchSetting)
  33   EVT_COMMAND(wxID_ANY, SE_RELOADACCOUNTS, frmSearch::ReloadAccountList)
  34   EVT_COMMAND(wxID_ANY, SE_ADDRESULT, frmSearch::AddResult)
  35   EVT_COMMAND(wxID_ANY, SE_SBUPDATE, frmSearch::SearchBarUpdate)
  36   EVT_COMMAND(wxID_ANY, SE_SEARCHFINISHED, frmSearch::SearchFinished)
  37   EVT_COMMAND(wxID_ANY, SE_UPDATERESULT, frmSearch::UpdateResult)
  38   EVT_COMMAND(wxID_ANY, SE_DELETERESULT, frmSearch::DeleteResult)
  39   EVT_COMMAND(wxID_ANY, SE_OPENCONTACT, frmSearch::OpenContact)
  40   EVT_COMMAND(wxID_ANY, SE_EDITCONTACT, frmSearch::EditContact)
  41   EVT_COMMAND(wxID_ANY, SE_REVEALCONTACT, frmSearch::RevealContact)
  42 END_EVENT_TABLE()
  43
  44 //namespace boostfs = boost::filesystem;
  45
  46 frmSearch::frmSearch( wxWindow* parent )
  47 :
  48 frmSearchADT( parent )
  49 {
  50
  51         XABSearchPanel *InitPanel = new XABSearchPanel( tabSearch );
  52         InitPanel->EnableButtons(TRUE, FALSE);
  53         InitPanel->SetupPointers(this);
  54         InitPanel->SetupInteger(ScrollGen);
  55         szrSearch->Add(InitPanel, 1, wxEXPAND, 0);
  56         szrSearch->Fit(tabSearch);
  57         SearchFrames.insert(std::make_pair(ScrollGen, InitPanel));
  58         ScrollGen++;
  59
  60         // Get the list of accounts and mark them as true.
  61
  62         wxString preffilename = GetUserPrefDir();
  63
  64         XABPreferences preferences(preffilename);
  65
  66         wxString AccDir;
  67         wxString AccDirFull;
  68         wxString AccDirFullSfx;
  69
  70         for (int i = 0; i < preferences.accounts.GetCount(); i++){
  71                 AccDir = preferences.accounts.GetAccountDirectory(i);
  72                 AccDirFull = preferences.accounts.GetAccountDirectory(i);
  73                 AccDirFull.Trim();
  74                 AccDirFull.Append(wxT("."));
  75                 AccDirFullSfx.Append(preferences.accounts.GetAccountType(i));
  76                 AccDirFullSfx.LowerCase();
  77                 AccDirFullSfx.Trim();
  78                 AccDirFull.Append(AccDirFullSfx);
  79                 SearchAccountsPaths.insert(std::make_pair(AccDir, AccDirFull));
  80                 SearchAccounts.insert(std::make_pair(AccDir, TRUE));
  81                 SearchAccountsNames.insert(std::make_pair(AccDir,
  82                         preferences.accounts.GetAccountName(i)));
  83                 AccDirFull.clear();
  84                 AccDirFullSfx.clear();
  85                 AccDir.clear();
  86         }
  87
  88         // Setup the columns.
  89
  90         wxListItem item;
  91         item.SetId(0);
  92         item.SetText(_("Name"));
  93         item.SetWidth(228);
  94
  95         lstResults->InsertColumn(0, item);
  96
  97         item.SetId(1);
  98         item.SetText(_("Nickname"));
  99         item.SetWidth(128);
 100
 101         lstResults->InsertColumn(1, item);
 102
 103         item.SetId(2);
 104         item.SetText(_("Account"));
 105         item.SetWidth(128);
 106
 107         lstResults->InsertColumn(2, item);
 108
 109 }
 110
 111 void frmSearch::SelectAccounts( wxCommandEvent& event )
 112 {
 113
 114         // Create the form and display as modal.
 115
 116         frmSearchAccounts *frameSAccount = new frmSearchAccounts ( this );
 117         frameSAccount->LoadSearchAccounts(&SearchAccounts, &SearchAccountsNames);
 118         frameSAccount->ShowModal();
 119         delete frameSAccount;
 120         frameSAccount = NULL;
 121
 122 }
 123
 124 void frmSearch::SearchContactsThread(){
 125
 126         // Go through each account and find contacts based on the
 127         // matched settings.
 128
 129         std::map<wxString,bool>::iterator SAiter;
 130         std::map<wxString,wxString>::iterator SAPiter;
 131         int intResultFound = 0;
 132
 133         for (std::map<wxString, wxString>::iterator SALiter = SearchAccountsNames.begin();
 134                 SALiter != SearchAccountsNames.end();
 135                 SALiter++){
 136
 137                 // Double check that we are searching in this account.
 138                 // If not, skip to the next one.
 139
 140                 SAiter = SearchAccounts.find(SALiter->first);
 141                 SAPiter = SearchAccountsPaths.find(SAiter->first);
 142
 143
 144                 if (SAiter->second == FALSE){
 145
 146                         // Not looking in this account. Go to next account.
 147
 148                         continue;
 149
 150                 }
 151
 152                 wxCommandEvent sbupdate (SE_SBUPDATE);
 153
 154                 wxString *SBData = new wxString;
 155                 *SBData = _("Searching ") + SALiter->second + _("...");
 156
 157                 sbupdate.SetClientData(SBData);
 158                 wxPostEvent(this, sbupdate);
 159
 160                 if (StopMode == FALSE){
 161
 162                         wxCommandEvent sbstop (SE_SBUPDATE);
 163
 164                         wxString *SBStopStr = new wxString;
 165                         *SBStopStr = _("Search stopped.");
 166
 167                         sbstop.SetClientData(SBStopStr);
 168                         wxPostEvent(this, sbstop);
 169                         return;
 170
 171                 }
 172
 173                 // Get the list of contact files and process each
 174                 // one of them.
 175
 176                 wxString AccountDir = GetAccountDir(SAPiter->second, FALSE);
 177
 178                 //boostfs::path vcarddir(AccountDir.c_str());
 179                 //boostfs::directory_iterator dir_end;
 180
 181                 //boostfs::path vcardfilename;
 182                 wxString vcardfilenamewxs;
 183                 wxStringTokenizer vcardfileline;
 184                 //std::string l;
 185                 wxString lwxs;
 186                 wxString setname, setvalue;
 187                 long ContactIndex = 1;
 188                 long ContactSeekPoint = 0;
 189                 wxString vCardFilename;
 190                 wxString vCardFilenameFull;
 191
 192                 //if (boostfs::exists(vcarddir)){
 193                 if (wxDirExists(AccountDir)){
 194
 195                         wxDir vcardaccdir(AccountDir);
 196
 197                         bool ProcFiles = vcardaccdir.GetFirst(&vCardFilename, wxEmptyString, wxDIR_FILES);
 198                         while(ProcFiles){
 199                         //for (boostfs::directory_iterator vcarddir_iter(vcarddir);
 200                         //     vcarddir_iter != dir_end ; ++vcarddir_iter){
 201
 202                                 if (StopMode == FALSE){
 203
 204                                         wxCommandEvent sbstop(SE_SBUPDATE);
 205
 206                                         wxString *SBStopStr = new wxString;
 207                                         *SBStopStr = _("Search stopped.");
 208
 209                                         sbstop.SetClientData(SBStopStr);
 210                                         wxPostEvent(this, sbstop);
 211                                         return;
 212
 213                                 }
 214
 215                                 if (vCardFilename.Right(4) == wxT(".vcf") ||
 216                                         vCardFilename.Right(4) == wxT(".VCF") ||
 217                                         vCardFilename.Right(5) == wxT(".vcard") ||
 218                                         vCardFilename.Right(5) == wxT(".VCARD")){
 219
 220                                         vCard Person;
 221                                         vCardFilenameFull.Append(AccountDir);
 222                                         vCardFilenameFull.Append(vCardFilename);
 223
 224
 225                                         Person.LoadFile(vCardFilenameFull);
 226
 227                                     /*if (boostfs::path(vcarddir_iter->path()).extension() == ".vcf" ||
 228                                         boostfs::path(vcarddir_iter->path()).extension() == ".VCF" ||
 229                                         boostfs::path(vcarddir_iter->path()).extension() == ".vcard" ||
 230                                         boostfs::path(vcarddir_iter->path()).extension() == ".VCARD"){*/
 231
 232                                         vcardfilenamewxs = vCardFilenameFull;
 233
 234                                         /*vCard Person;
 235                                         std::fstream vcardfile;
 236
 237                                         vcardfilename = boostfs::path(vcarddir_iter->path()).filename();
 238                                         vcardfilenamewxs.Append(AccountDir);
 239                                         vcardfilenamewxs.Append(wxString::FromUTF8(vcardfilename.c_str()));
 240
 241                                         // Open the vCard file up and get the setting names and values from the
 242                                         // file.
 243
 244                                         vcardfile.open(vcardfilenamewxs.mb_str(), std::ios::in);
 245
 246                                         while(getline(vcardfile, l)){
 247
 248                                             lwxs.Clear();
 249                                             setname.Clear();
 250                                             setvalue.Clear();
 251                                             lwxs.Append(wxString::FromUTF8(l.c_str()));
 252                                             vcardfileline.SetString(lwxs, wxT(":"));
 253                                             setname = vcardfileline.GetNextToken();
 254                                             setvalue = vcardfileline.GetString();
 255
 256                                             Person.Add(setname, setvalue, TRUE);
 257
 258                                         }
 259
 260                                         vcardfile.close();*/
 261
 262                                         // Check if file has version 4.0, first name (FN)
 263                                         // begin and end vCard portions.
 264
 265                                         // Don't search unless these conditions have been met.
 266
 267                                         if (Person.MeetBaseSpecification()){
 268
 269                                                 // Go through each of the search settings and check
 270                                                 // if they match with contact details.
 271
 272                                                 // If it matches then add to the search results.
 273
 274                                                 int SelOpt = 0;
 275                                                 bool chkOpt = FALSE;
 276                                                 wxString StrOpt;
 277                                                 int StrOptLen = 0;
 278                                                 ArrayvCardOutData ArrayData;
 279                                                 ArrayvCardOutData NicknameArrayData;
 280                                                 vCardName NameArray = Person.GetName();
 281                                                 wxString ContactFinalNickname;
 282                                                 NicknameArrayData = Person.GetByPartial(wxT("NICKNAME"));
 283
 284                                                 if (NicknameArrayData.PropCount != 0){
 285                                                         ContactFinalNickname = NicknameArrayData.PropValues[0];
 286                                                 }
 287
 288                                                 for (std::map<int, void*>::iterator siter = SearchFrames.begin();
 289                                                 siter != SearchFrames.end(); siter++){
 290
 291                                                         // Get the settings from the form.
 292
 293                                                         XABSearchPanel *XABSPPtr = static_cast<XABSearchPanel*>(siter->second);
 294
 295                                                         // Get Selected Option and Setting.
 296
 297                                                         SelOpt = XABSPPtr->GetSelectionOption();
 298
 299                                                         if (SelOpt < 12){
 300
 301                                                                 StrOpt = XABSPPtr->GetStringSetting();
 302                                                                 StrOptLen = StrOpt.Len();
 303
 304                                                                 if (SelOpt == 0 || SelOpt == 4 || SelOpt == 8){
 305
 306                                                                         // Matching string that beings with...
 307
 308                                                                         // Double check the std::map inserts for each section.
 309
 310                                                                         if (SelOpt == 0){
 311
 312                                                                                 // Get the forename from the first N.
 313
 314                                                                                 if (NameArray.Forename.Mid(0, StrOptLen) == StrOpt){
 315
 316                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 317                                                                                                 SAPiter->second,
 318                                                                                                 &SearchResultAccount,
 319                                                                                                 &SearchResultFilename) == TRUE){
 320
 321                                                                                                 SelOpt = 0;
 322                                                                                                 chkOpt = FALSE;
 323                                                                                                 StrOpt.Clear();
 324                                                                                                 StrOptLen = 0;
 325                                                                                                 ArrayData.PropData.Clear();
 326                                                                                                 ArrayData.PropValues.Clear();
 327                                                                                                 ArrayData.PropCount = 0;
 328                                                                                                 continue;
 329
 330                                                                                         }
 331
 332                                                                                         SRNotif *sradd = new SRNotif;
 333                                                                                         sradd->ContactName = NameArray;
 334                                                                                         sradd->ContactNickname = ContactFinalNickname;
 335                                                                                         sradd->ContactAccount = SAPiter->second;
 336                                                                                         sradd->ContactAccountName = SALiter->second;
 337                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 338                                                                                         sradd->SearchResultID = intResultFound;
 339
 340                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 341                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 342
 343                                                                                         intResultFound++;
 344
 345                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 346                                                                                         sraddenv.SetClientData(sradd);
 347                                                                                         wxPostEvent(this, sraddenv);
 348
 349                                                                                 }
 350
 351                                                                         } else if (SelOpt == 4){
 352
 353                                                                                 if (NameArray.Surname.Mid(0, StrOptLen) == StrOpt){
 354
 355                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 356                                                                                                 SAPiter->second,
 357                                                                                                 &SearchResultAccount,
 358                                                                                                 &SearchResultFilename) == TRUE){
 359
 360                                                                                                 SelOpt = 0;
 361                                                                                                 chkOpt = FALSE;
 362                                                                                                 StrOpt.Clear();
 363                                                                                                 StrOptLen = 0;
 364                                                                                                 ArrayData.PropData.Clear();
 365                                                                                                 ArrayData.PropValues.Clear();
 366                                                                                                 ArrayData.PropCount = 0;
 367                                                                                                 continue;
 368
 369                                                                                         }
 370
 371                                                                                         SRNotif *sradd = new SRNotif;
 372                                                                                         sradd->ContactName = NameArray;
 373                                                                                         sradd->ContactNickname = ContactFinalNickname;
 374                                                                                         sradd->ContactAccount = SAPiter->second;
 375                                                                                         sradd->ContactAccountName = SALiter->second;
 376                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 377                                                                                         sradd->SearchResultID = intResultFound;
 378
 379                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 380                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 381
 382                                                                                         intResultFound++;
 383
 384                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 385                                                                                         sraddenv.SetClientData(sradd);
 386                                                                                         wxPostEvent(this, sraddenv);
 387
 388                                                                                 }
 389
 390                                                                         } else if (SelOpt == 8){
 391
 392                                                                                 wxString NicknameData;
 393
 394                                                                                 for (int i = 0; i < NicknameArrayData.PropCount; i++){
 395
 396                                                                                         NicknameData = NicknameArrayData.PropValues[i];
 397
 398                                                                                         if (NicknameData.Mid(0, StrOptLen) == StrOpt){
 399
 400                                                                                                 if (CheckDuplicate(vcardfilenamewxs,
 401                                                                                                         SAPiter->second,
 402                                                                                                         &SearchResultAccount,
 403                                                                                                         &SearchResultFilename) == TRUE){
 404
 405                                                                                                         SelOpt = 0;
 406                                                                                                         chkOpt = FALSE;
 407                                                                                                         StrOpt.Clear();
 408                                                                                                         StrOptLen = 0;
 409                                                                                                         ArrayData.PropData.Clear();
 410                                                                                                         ArrayData.PropValues.Clear();
 411                                                                                                         ArrayData.PropCount = 0;
 412                                                                                                         continue;
 413
 414                                                                                                 }
 415
 416                                                                                                 SRNotif *sradd = new SRNotif;
 417                                                                                                 sradd->ContactName = NameArray;
 418                                                                                                 sradd->ContactNickname = ContactFinalNickname;
 419                                                                                                 sradd->ContactAccount = SAPiter->second;
 420                                                                                                 sradd->ContactAccountName = SALiter->second;
 421                                                                                                 sradd->ContactFullFilename = vcardfilenamewxs;
 422                                                                                                 sradd->SearchResultID = intResultFound;
 423
 424                                                                                                 SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 425                                                                                                 SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 426
 427                                                                                                 intResultFound++;
 428
 429                                                                                                 wxCommandEvent sraddenv(SE_ADDRESULT);
 430                                                                                                 sraddenv.SetClientData(sradd);
 431                                                                                                 wxPostEvent(this, sraddenv);
 432
 433                                                                                                 break;
 434
 435                                                                                         }
 436
 437                                                                                 }
 438
 439                                                                         }
 440
 441                                                                 } else if (SelOpt == 1 || SelOpt == 5 || SelOpt == 9){
 442
 443                                                                         // Matching string that ends with...
 444
 445                                                                         if (SelOpt == 1){
 446
 447                                                                                 // Check the forename.
 448
 449                                                                                 if (NameArray.Forename.Right(StrOptLen) == StrOpt){
 450
 451                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 452                                                                                                 SAPiter->second,
 453                                                                                                 &SearchResultAccount,
 454                                                                                                 &SearchResultFilename) == TRUE){
 455
 456                                                                                                 SelOpt = 0;
 457                                                                                                 chkOpt = FALSE;
 458                                                                                                 StrOpt.Clear();
 459                                                                                                 StrOptLen = 0;
 460                                                                                                 ArrayData.PropData.Clear();
 461                                                                                                 ArrayData.PropValues.Clear();
 462                                                                                                 ArrayData.PropCount = 0;
 463                                                                                                 continue;
 464
 465                                                                                         }
 466
 467                                                                                         SRNotif *sradd = new SRNotif;
 468                                                                                         sradd->ContactName = NameArray;
 469                                                                                         sradd->ContactNickname = ContactFinalNickname;
 470                                                                                         sradd->ContactAccount = SAPiter->second;
 471                                                                                         sradd->ContactAccountName = SALiter->second;
 472                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 473                                                                                         sradd->SearchResultID = intResultFound;
 474
 475                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 476                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 477
 478                                                                                         intResultFound++;
 479
 480                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 481                                                                                         sraddenv.SetClientData(sradd);
 482                                                                                         wxPostEvent(this, sraddenv);
 483
 484                                                                                 }
 485
 486                                                                         } else if (SelOpt == 5){
 487
 488                                                                                 if (NameArray.Surname.Right(StrOptLen) == StrOpt){
 489
 490                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 491                                                                                                 SAPiter->second,
 492                                                                                                 &SearchResultAccount,
 493                                                                                                 &SearchResultFilename) == TRUE){
 494
 495                                                                                                 SelOpt = 0;
 496                                                                                                 chkOpt = FALSE;
 497                                                                                                 StrOpt.Clear();
 498                                                                                                 StrOptLen = 0;
 499                                                                                                 ArrayData.PropData.Clear();
 500                                                                                                 ArrayData.PropValues.Clear();
 501                                                                                                 ArrayData.PropCount = 0;
 502                                                                                                 continue;
 503
 504                                                                                         }
 505
 506                                                                                         SRNotif *sradd = new SRNotif;
 507                                                                                         sradd->ContactName = NameArray;
 508                                                                                         sradd->ContactNickname = ContactFinalNickname;
 509                                                                                         sradd->ContactAccount = SAPiter->second;
 510                                                                                         sradd->ContactAccountName = SALiter->second;
 511                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 512                                                                                         sradd->SearchResultID = intResultFound;
 513
 514                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 515                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 516
 517                                                                                         intResultFound++;
 518
 519                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 520                                                                                         sraddenv.SetClientData(sradd);
 521                                                                                         wxPostEvent(this, sraddenv);
 522
 523                                                                                 }
 524
 525                                                                         } else if (SelOpt == 9){
 526
 527                                                                                 wxString NicknameData;
 528
 529                                                                                 for (int i = 0; i < NicknameArrayData.PropCount; i++){
 530
 531                                                                                         NicknameData = NicknameArrayData.PropValues[i];
 532                                                                                         NicknameData.Trim();
 533
 534                                                                                         if (NicknameData.Right(StrOptLen) == StrOpt){
 535
 536                                                                                                 if (CheckDuplicate(vcardfilenamewxs,
 537                                                                                                         SAPiter->second,
 538                                                                                                         &SearchResultAccount,
 539                                                                                                         &SearchResultFilename) == TRUE){
 540
 541                                                                                                         SelOpt = 0;
 542                                                                                                         chkOpt = FALSE;
 543                                                                                                         StrOpt.Clear();
 544                                                                                                         StrOptLen = 0;
 545                                                                                                         ArrayData.PropData.Clear();
 546                                                                                                         ArrayData.PropValues.Clear();
 547                                                                                                         ArrayData.PropCount = 0;
 548                                                                                                         continue;
 549
 550                                                                                                 }
 551
 552                                                                                                 SRNotif *sradd = new SRNotif;
 553                                                                                                 sradd->ContactName = NameArray;
 554                                                                                                 sradd->ContactNickname = ContactFinalNickname;
 555                                                                                                 sradd->ContactAccount = SAPiter->second;
 556                                                                                                 sradd->ContactAccountName = SALiter->second;
 557                                                                                                 sradd->ContactFullFilename = vcardfilenamewxs;
 558                                                                                                 sradd->SearchResultID = intResultFound;
 559
 560                                                                                                 SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 561                                                                                                 SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 562
 563                                                                                                 intResultFound++;
 564
 565                                                                                                 wxCommandEvent sraddenv(SE_ADDRESULT);
 566                                                                                                 sraddenv.SetClientData(sradd);
 567                                                                                                 wxPostEvent(this, sraddenv);
 568
 569                                                                                                 break;
 570
 571                                                                                         }
 572
 573                                                                                 }
 574
 575                                                                         }
 576
 577                                                                 } else if (SelOpt == 2 || SelOpt == 6 || SelOpt == 10){
 578
 579                                                                         // Matching string that contains...
 580
 581                                                                         if (SelOpt == 2){
 582
 583                                                                                 if (NameArray.Forename.Find(StrOpt) != wxNOT_FOUND){
 584
 585                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 586                                                                                                 SAPiter->second,
 587                                                                                                 &SearchResultAccount,
 588                                                                                                 &SearchResultFilename) == TRUE){
 589
 590                                                                                                 SelOpt = 0;
 591                                                                                                 chkOpt = FALSE;
 592                                                                                                 StrOpt.Clear();
 593                                                                                                 StrOptLen = 0;
 594                                                                                                 ArrayData.PropData.Clear();
 595                                                                                                 ArrayData.PropValues.Clear();
 596                                                                                                 ArrayData.PropCount = 0;
 597                                                                                                 continue;
 598
 599                                                                                         }
 600
 601                                                                                         SRNotif *sradd = new SRNotif;
 602                                                                                         sradd->ContactName = NameArray;
 603                                                                                         sradd->ContactNickname = ContactFinalNickname;
 604                                                                                         sradd->ContactAccount = SAPiter->second;
 605                                                                                         sradd->ContactAccountName = SALiter->second;
 606                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 607                                                                                         sradd->SearchResultID = intResultFound;
 608
 609                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 610                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 611
 612                                                                                         intResultFound++;
 613
 614                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 615                                                                                         sraddenv.SetClientData(sradd);
 616                                                                                         wxPostEvent(this, sraddenv);
 617
 618                                                                                 }
 619
 620                                                                         } else if (SelOpt == 6){
 621
 622                                                                                 if (NameArray.Surname.Find(StrOpt) != wxNOT_FOUND){
 623
 624                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 625                                                                                                 SAPiter->second,
 626                                                                                                 &SearchResultAccount,
 627                                                                                                 &SearchResultFilename) == TRUE){
 628
 629                                                                                                 SelOpt = 0;
 630                                                                                                 chkOpt = FALSE;
 631                                                                                                 StrOpt.Clear();
 632                                                                                                 StrOptLen = 0;
 633                                                                                                 ArrayData.PropData.Clear();
 634                                                                                                 ArrayData.PropValues.Clear();
 635                                                                                                 ArrayData.PropCount = 0;
 636                                                                                                 continue;
 637
 638                                                                                         }
 639
 640                                                                                         SRNotif *sradd = new SRNotif;
 641                                                                                         sradd->ContactName = NameArray;
 642                                                                                         sradd->ContactNickname = ContactFinalNickname;
 643                                                                                         sradd->ContactAccount = SAPiter->second;
 644                                                                                         sradd->ContactAccountName = SALiter->second;
 645                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 646                                                                                         sradd->SearchResultID = intResultFound;
 647
 648                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 649                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 650
 651                                                                                         intResultFound++;
 652
 653                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 654                                                                                         sraddenv.SetClientData(sradd);
 655                                                                                         wxPostEvent(this, sraddenv);
 656
 657                                                                                 }
 658
 659                                                                         } else if (SelOpt == 10){
 660
 661                                                                                 wxString NicknameData;
 662
 663                                                                                 for (int i = 0; i < NicknameArrayData.PropCount; i++){
 664
 665                                                                                         NicknameData = NicknameArrayData.PropValues[i];
 666                                                                                         NicknameData.Trim();
 667
 668                                                                                         if (NicknameData.Find(StrOpt) != wxNOT_FOUND){
 669
 670                                                                                                 if (CheckDuplicate(vcardfilenamewxs,
 671                                                                                                         SAPiter->second,
 672                                                                                                         &SearchResultAccount,
 673                                                                                                         &SearchResultFilename) == TRUE){
 674
 675                                                                                                         SelOpt = 0;
 676                                                                                                         chkOpt = FALSE;
 677                                                                                                         StrOpt.Clear();
 678                                                                                                         StrOptLen = 0;
 679                                                                                                         ArrayData.PropData.Clear();
 680                                                                                                         ArrayData.PropValues.Clear();
 681                                                                                                         ArrayData.PropCount = 0;
 682                                                                                                         continue;
 683
 684                                                                                                 }
 685
 686                                                                                                 SRNotif *sradd = new SRNotif;
 687                                                                                                 sradd->ContactName = NameArray;
 688                                                                                                 sradd->ContactNickname = ContactFinalNickname;
 689                                                                                                 sradd->ContactAccount = SAPiter->second;
 690                                                                                                 sradd->ContactAccountName = SALiter->second;
 691                                                                                                 sradd->ContactFullFilename = vcardfilenamewxs;
 692                                                                                                 sradd->SearchResultID = intResultFound;
 693
 694                                                                                                 SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 695                                                                                                 SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 696
 697                                                                                                 intResultFound++;
 698
 699                                                                                                 wxCommandEvent sraddenv(SE_ADDRESULT);
 700                                                                                                 sraddenv.SetClientData(sradd);
 701                                                                                                 wxPostEvent(this, sraddenv);
 702
 703                                                                                                 break;
 704
 705                                                                                         }
 706
 707                                                                                 }
 708
 709                                                                         }
 710
 711                                                                 } else if (SelOpt == 3 || SelOpt == 7 || SelOpt == 11){
 712
 713                                                                         // Matching String that doesn't contain...
 714
 715                                                                         if (SelOpt == 3){
 716
 717                                                                                 // Process the nickname data.
 718
 719                                                                                 if (NameArray.Forename.Find(StrOpt) == wxNOT_FOUND){
 720
 721                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 722                                                                                                 SAPiter->second,
 723                                                                                                 &SearchResultAccount,
 724                                                                                                 &SearchResultFilename) == TRUE){
 725
 726                                                                                                 SelOpt = 0;
 727                                                                                                 chkOpt = FALSE;
 728                                                                                                 StrOpt.Clear();
 729                                                                                                 StrOptLen = 0;
 730                                                                                                 ArrayData.PropData.Clear();
 731                                                                                                 ArrayData.PropValues.Clear();
 732                                                                                                 ArrayData.PropCount = 0;
 733                                                                                                 continue;
 734
 735                                                                                         }
 736
 737                                                                                         SRNotif *sradd = new SRNotif;
 738                                                                                         sradd->ContactName = NameArray;
 739                                                                                         sradd->ContactNickname = ContactFinalNickname;
 740                                                                                         sradd->ContactAccount = SAPiter->second;
 741                                                                                         sradd->ContactAccountName = SALiter->second;
 742                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 743                                                                                         sradd->SearchResultID = intResultFound;
 744
 745                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 746                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 747
 748                                                                                         intResultFound++;
 749
 750                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 751                                                                                         sraddenv.SetClientData(sradd);
 752                                                                                         wxPostEvent(this, sraddenv);
 753
 754                                                                                 }
 755
 756                                                                         } else if (SelOpt == 7){
 757
 758                                                                                 if (!NameArray.Surname.Find(StrOpt) == wxNOT_FOUND){
 759
 760                                                                                         if (CheckDuplicate(vcardfilenamewxs,
 761                                                                                                 SAPiter->second,
 762                                                                                                 &SearchResultAccount,
 763                                                                                                 &SearchResultFilename) == TRUE){
 764
 765                                                                                                 SelOpt = 0;
 766                                                                                                 chkOpt = FALSE;
 767                                                                                                 StrOpt.Clear();
 768                                                                                                 StrOptLen = 0;
 769                                                                                                 ArrayData.PropData.Clear();
 770                                                                                                 ArrayData.PropValues.Clear();
 771                                                                                                 ArrayData.PropCount = 0;
 772                                                                                                 continue;
 773
 774                                                                                         }
 775
 776                                                                                         SRNotif *sradd = new SRNotif;
 777                                                                                         sradd->ContactName = NameArray;
 778                                                                                         sradd->ContactNickname = ContactFinalNickname;
 779                                                                                         sradd->ContactAccount = SAPiter->second;
 780                                                                                         sradd->ContactAccountName = SALiter->second;
 781                                                                                         sradd->ContactFullFilename = vcardfilenamewxs;
 782                                                                                         sradd->SearchResultID = intResultFound;
 783
 784                                                                                         SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 785                                                                                         SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 786
 787                                                                                         intResultFound++;
 788
 789                                                                                         wxCommandEvent sraddenv(SE_ADDRESULT);
 790                                                                                         sraddenv.SetClientData(sradd);
 791                                                                                         wxPostEvent(this, sraddenv);
 792
 793                                                                                 }
 794
 795                                                                         } else if (SelOpt == 11){
 796
 797                                                                                 wxString NicknameData;
 798
 799                                                                                 for (int i = 0; i < NicknameArrayData.PropCount; i++){
 800
 801                                                                                         NicknameData = NicknameArrayData.PropValues[i];
 802                                                                                         NicknameData.Trim();
 803
 804                                                                                         if (NicknameData.Find(StrOpt) == wxNOT_FOUND){
 805
 806                                                                                                 if (CheckDuplicate(vcardfilenamewxs,
 807                                                                                                         SAPiter->second,
 808                                                                                                         &SearchResultAccount,
 809                                                                                                         &SearchResultFilename) == TRUE){
 810
 811                                                                                                         SelOpt = 0;
 812                                                                                                         chkOpt = FALSE;
 813                                                                                                         StrOpt.Clear();
 814                                                                                                         StrOptLen = 0;
 815                                                                                                         ArrayData.PropData.Clear();
 816                                                                                                         ArrayData.PropValues.Clear();
 817                                                                                                         ArrayData.PropCount = 0;
 818                                                                                                         continue;
 819
 820                                                                                                 }
 821
 822                                                                                                 SRNotif *sradd = new SRNotif;
 823                                                                                                 sradd->ContactName = NameArray;
 824                                                                                                 sradd->ContactNickname = ContactFinalNickname;
 825                                                                                                 sradd->ContactAccount = SAPiter->second;
 826                                                                                                 sradd->ContactAccountName = SALiter->second;
 827                                                                                                 sradd->ContactFullFilename = vcardfilenamewxs;
 828                                                                                                 sradd->SearchResultID = intResultFound;
 829
 830                                                                                                 SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 831                                                                                                 SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 832
 833                                                                                                 intResultFound++;
 834
 835                                                                                                 wxCommandEvent sraddenv(SE_ADDRESULT);
 836                                                                                                 sraddenv.SetClientData(sradd);
 837                                                                                                 wxPostEvent(this, sraddenv);
 838
 839                                                                                                 break;
 840
 841                                                                                         }
 842
 843                                                                                 }
 844
 845                                                                         }
 846
 847                                                                 }
 848
 849                                                         } else {
 850
 851                                                                 chkOpt = XABSPPtr->GetCheckboxSetting();
 852
 853                                                                 if (SelOpt == 12){
 854
 855                                                                         // Search should check if it has a photo or not.
 856
 857                                                                         ArrayData = Person.GetByPartial(wxT("PHOTO"));
 858
 859                                                                         if ((ArrayData.PropCount >= 1 &&
 860                                                                         chkOpt == TRUE) ||
 861                                                                         (ArrayData.PropCount == 0 &&
 862                                                                         chkOpt == FALSE)){
 863
 864                                                                                 if (CheckDuplicate(vcardfilenamewxs,
 865                                                                                         SAPiter->second,
 866                                                                                         &SearchResultAccount,
 867                                                                                         &SearchResultFilename) == TRUE){
 868
 869                                                                                         SelOpt = 0;
 870                                                                                         chkOpt = FALSE;
 871                                                                                         StrOpt.Clear();
 872                                                                                         StrOptLen = 0;
 873                                                                                         ArrayData.PropData.Clear();
 874                                                                                         ArrayData.PropValues.Clear();
 875                                                                                         ArrayData.PropCount = 0;
 876                                                                                         continue;
 877
 878                                                                                 }
 879
 880                                                                                 SRNotif *sradd = new SRNotif;
 881
 882                                                                                 sradd->ContactName = NameArray;
 883                                                                                 sradd->ContactNickname = ContactFinalNickname;
 884                                                                                 sradd->ContactAccount = SAPiter->second;
 885                                                                                 sradd->ContactAccountName = SALiter->second;
 886                                                                                 sradd->ContactFullFilename = vcardfilenamewxs;
 887                                                                                 sradd->SearchResultID = intResultFound;
 888
 889                                                                                 SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 890                                                                                 SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 891
 892                                                                                 intResultFound++;
 893
 894                                                                                 wxCommandEvent sraddenv(SE_ADDRESULT);
 895                                                                                 sraddenv.SetClientData(sradd);
 896                                                                                 wxPostEvent(this, sraddenv);
 897
 898                                                                         }
 899
 900                                                                 } else if (SelOpt == 13){
 901
 902                                                                         // Search should check if it has a logo or not.
 903
 904                                                                         ArrayData = Person.GetByPartial(wxT("LOGO"));
 905
 906                                                                         if ((ArrayData.PropCount >= 1 &&
 907                                                                         chkOpt == TRUE) ||
 908                                                                         (ArrayData.PropCount == 0 &&
 909                                                                         chkOpt == FALSE)){
 910
 911                                                                                 if (CheckDuplicate(vcardfilenamewxs,
 912                                                                                         SAPiter->second,
 913                                                                                         &SearchResultAccount,
 914                                                                                         &SearchResultFilename) == TRUE){
 915
 916                                                                                         SelOpt = 0;
 917                                                                                         chkOpt = FALSE;
 918                                                                                         StrOpt.Clear();
 919                                                                                         StrOptLen = 0;
 920                                                                                         ArrayData.PropData.Clear();
 921                                                                                         ArrayData.PropValues.Clear();
 922                                                                                         ArrayData.PropCount = 0;
 923                                                                                         continue;
 924
 925                                                                                 }
 926
 927                                                                                 SRNotif *sradd = new SRNotif;
 928
 929                                                                                 sradd->ContactName = NameArray;
 930                                                                                 sradd->ContactNickname = ContactFinalNickname;
 931                                                                                 sradd->ContactAccount = SAPiter->second;
 932                                                                                 sradd->ContactAccountName = SALiter->second;
 933                                                                                 sradd->ContactFullFilename = vcardfilenamewxs;
 934                                                                                 sradd->SearchResultID = intResultFound;
 935
 936                                                                                 SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 937                                                                                 SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 938
 939                                                                                 intResultFound++;
 940
 941                                                                                 wxCommandEvent sraddenv(SE_ADDRESULT);
 942                                                                                 sraddenv.SetClientData(sradd);
 943                                                                                 wxPostEvent(this, sraddenv);
 944
 945                                                                         }
 946
 947                                                                 } else if (SelOpt == 14){
 948
 949                                                                         // Search should check if it has sound or not.
 950
 951                                                                         ArrayData = Person.GetByPartial(wxT("SOUND"));
 952
 953                                                                         if ((ArrayData.PropCount >= 1 &&
 954                                                                         chkOpt == TRUE) ||
 955                                                                         (ArrayData.PropCount == 0 &&
 956                                                                         chkOpt == FALSE)){
 957
 958                                                                                 if (CheckDuplicate(vcardfilenamewxs,
 959                                                                                         SAPiter->second,
 960                                                                                         &SearchResultAccount,
 961                                                                                         &SearchResultFilename) == TRUE){
 962
 963                                                                                         SelOpt = 0;
 964                                                                                         chkOpt = FALSE;
 965                                                                                         StrOpt.Clear();
 966                                                                                         StrOptLen = 0;
 967                                                                                         ArrayData.PropData.Clear();
 968                                                                                         ArrayData.PropValues.Clear();
 969                                                                                         ArrayData.PropCount = 0;
 970                                                                                         continue;
 971
 972                                                                                 }
 973
 974                                                                                 SRNotif *sradd = new SRNotif;
 975
 976                                                                                 sradd->ContactName = NameArray;
 977                                                                                 sradd->ContactNickname = ContactFinalNickname;
 978                                                                                 sradd->ContactAccount = SAPiter->second;
 979                                                                                 sradd->ContactAccountName = SALiter->second;
 980                                                                                 sradd->ContactFullFilename = vcardfilenamewxs;
 981                                                                                 sradd->SearchResultID = intResultFound;
 982
 983                                                                                 SearchResultAccount.insert(std::make_pair(sradd->SearchResultID, sradd->ContactAccount));
 984                                                                                 SearchResultFilename.insert(std::make_pair(sradd->SearchResultID, sradd->ContactFullFilename));
 985
 986                                                                                 intResultFound++;
 987
 988                                                                                 wxCommandEvent sraddenv(SE_ADDRESULT);
 989                                                                                 sraddenv.SetClientData(sradd);
 990                                                                                 wxPostEvent(this, sraddenv);
 991
 992                                                                         }
 993
 994                                                                 }
 995
 996                                                         }
 997
 998                                                         SelOpt = 0;
 999                                                         chkOpt = FALSE;
1000                                                         StrOpt.Clear();
1001                                                         StrOptLen = 0;
1002                                                         ArrayData.PropData.Clear();
1003                                                         ArrayData.PropValues.Clear();
1004                                                         ArrayData.PropCount = 0;
1005
1006                                                 }
1007
1008                                         } else {
1009
1010                                         }
1011
1012                                 }
1013
1014                                 vCardFilename.Clear();
1015                                 vCardFilenameFull.Clear();
1016                                 ProcFiles = vcardaccdir.GetNext(&vCardFilename);
1017
1018                         }
1019
1020                 } else {
1021
1022                 }
1023
1024         }
1025
1026         // Finished searching... clear up.
1027
1028         wxCommandEvent sbfinstr (SE_SBUPDATE);
1029
1030         wxString *SBFinish = new wxString;
1031
1032         if (intResultFound == 0){
1033
1034                 *SBFinish = _("No contacts found.");
1035
1036         } else if (intResultFound == 1){
1037
1038                 *SBFinish = _("1 contact found.");
1039
1040         } else {
1041
1042                 *SBFinish = wxString::Format(wxT("%i"), intResultFound) + _(" contacts found.");
1043
1044         }
1045
1046         sbfinstr.SetClientData(SBFinish);
1047         wxPostEvent(this, sbfinstr);
1048
1049         wxCommandEvent sbfinish (SE_SEARCHFINISHED);
1050         wxPostEvent(this, sbfinish);
1051
1052 }
1053
1054 void frmSearch::SearchContacts( wxCommandEvent& event )
1055 {
1056
1057         // Change the button to stop.
1058
1059         if (StopMode == FALSE){
1060
1061                 // Clear the list of search results.
1062
1063                 lstResults->DeleteAllItems();
1064                 SearchResultAccount.clear();
1065                 SearchResultFilename.clear();
1066
1067                 // Button clicked on as 'Search'.
1068
1069                 DisableAllSearchSettings(TRUE);
1070                 StopMode = TRUE;
1071                 btnSearch->SetLabel(_("Stop"));
1072
1073                 // Spawn a thread so that searching can proceed
1074                 // without blocking the GUI (and allow the
1075                 // search to stop when needed).
1076
1077                 std::thread SearchThread(&frmSearch::SearchContactsThread, this);
1078                 SearchThread.detach();
1079
1080         } else {
1081
1082                 // Button clicked on as 'Stop'.
1083
1084                 StopMode = FALSE;
1085                 btnSearch->SetLabel(_("Search"));
1086                 DisableAllSearchSettings(FALSE);
1087
1088         }
1089
1090 }
1091
1092 void frmSearch::ResetContacts( wxCommandEvent& event )
1093 {
1094
1095         // Clear all the search settings.
1096
1097         for (std::map<int,void*>::iterator iter = SearchFrames.begin();
1098          iter != SearchFrames.end(); ++iter){
1099
1100                 XABSearchPanel *XABSPPtr;
1101
1102                 XABSPPtr = static_cast<XABSearchPanel*>(iter->second);
1103                 szrSearch->Detach(XABSPPtr);
1104
1105                 // Remove the frame from the memory and the list.
1106
1107                 delete XABSPPtr;
1108                 XABSPPtr = NULL;
1109
1110                 SearchFrames.erase(iter->first);
1111
1112         }
1113
1114         // Clear the list of search results.
1115
1116         lstResults->DeleteAllItems();
1117
1118         // Clear the account settings.
1119
1120         for (std::map<wxString, bool>::iterator iter = SearchAccounts.begin();
1121                 iter != SearchAccounts.end(); iter++){
1122
1123                 iter->second = TRUE;
1124
1125         }
1126
1127         // Add a search settings with the default things.
1128
1129         ScrollGen = 0;
1130
1131         XABSearchPanel *NewPanel = new XABSearchPanel( tabSearch );
1132         NewPanel->EnableButtons(TRUE, FALSE);
1133         NewPanel->SetupPointers(this);
1134         NewPanel->SetupInteger(ScrollGen);
1135         szrSearch->Add(NewPanel, 1, wxEXPAND, 0);
1136         szrSearch->Fit(tabSearch);
1137         SearchFrames.insert(std::make_pair(ScrollGen, NewPanel));
1138         ScrollGen++;
1139
1140 }
1141
1142 void frmSearch::AddSearchSetting( wxCommandEvent& event )
1143 {
1144
1145         // Add a search setting frame to the list.
1146
1147         XABSearchPanel *NewPanel = new XABSearchPanel( tabSearch );
1148         NewPanel->EnableButtons(TRUE, TRUE);
1149         NewPanel->SetupPointers(this);
1150         NewPanel->SetupInteger(ScrollGen);
1151         szrSearch->Add(NewPanel, 1, wxEXPAND|wxGROW, 5);
1152         //szrSearch->Fit(tabSearch);
1153         szrSearch->FitInside(tabSearch);
1154         szrSearch->Layout();
1155         szrSearch->RecalcSizes();
1156         tabSearch->Layout();
1157         SearchFrames.insert(std::make_pair(ScrollGen, NewPanel));
1158         ScrollGen++;
1159
1160         // Check if number of search settings is 15 (or over).
1161         // If it is, disable the option of adding extra settings
1162         // for all frames until one is removed.
1163
1164         XABSearchPanel *XABSPPtr;
1165
1166         if (SearchFrames.size() >= 15){
1167
1168                 for (std::map<int,void*>::iterator iter = SearchFrames.begin();
1169                 iter != SearchFrames.end(); ++iter){
1170
1171                         XABSPPtr = static_cast<XABSearchPanel*>(iter->second);
1172
1173                         XABSPPtr->EnableButtons(FALSE, TRUE);
1174
1175                 }
1176
1177         } else if (SearchFrames.size() >= 2){
1178
1179                 for (std::map<int,void*>::iterator iter = SearchFrames.begin();
1180                 iter != SearchFrames.end(); ++iter){
1181
1182                         XABSPPtr = static_cast<XABSearchPanel*>(iter->second);
1183
1184                         XABSPPtr->EnableButtons(TRUE, TRUE);
1185
1186                 }
1187
1188         }
1189
1190         //tabSearch->SetScrollbar(wxVERTICAL, 32768, 25, 32768, false);
1191         tabSearch->Update();
1192         //tabSearch->ScrollToLine(tabSearch->GetLineCount());
1193
1194 }
1195
1196 void frmSearch::RemoveSearchSetting( wxCommandEvent& event )
1197 {
1198
1199         // Get the integer from the event.
1200
1201         std::map<int,void*>::iterator iter;
1202         iter = SearchFrames.find(event.GetInt());
1203
1204         // Remove a search setting frame from the list.
1205
1206         XABSearchPanel *XABSPPtr;
1207         XABSPPtr = static_cast<XABSearchPanel*>(iter->second);
1208
1209         szrSearch->Detach(XABSPPtr);
1210
1211         // Remove the frame from the memory and the list.
1212
1213         SearchFrames.erase(event.GetInt());
1214
1215         delete XABSPPtr;
1216         XABSPPtr = NULL;
1217
1218         //szrSearch->Fit(tabSearch);
1219
1220         if (SearchFrames.size() < 15 && SearchFrames.size() > 1){
1221
1222                 for (std::map<int,void*>::iterator iter = SearchFrames.begin();
1223                 iter != SearchFrames.end(); ++iter){
1224
1225                         XABSPPtr = static_cast<XABSearchPanel*>(iter->second);
1226
1227                         XABSPPtr->EnableButtons(TRUE, TRUE);
1228
1229                 }
1230
1231         } else if (SearchFrames.size() == 1){
1232
1233                 for (std::map<int,void*>::iterator iter = SearchFrames.begin();
1234                 iter != SearchFrames.end(); ++iter){
1235
1236                         XABSPPtr = static_cast<XABSearchPanel*>(iter->second);
1237
1238                         XABSPPtr->EnableButtons(TRUE, FALSE);
1239
1240                 }
1241
1242         }
1243
1244         szrSearch->FitInside(tabSearch);
1245         szrSearch->Layout();
1246         szrSearch->RecalcSizes();
1247         tabSearch->Layout();
1248
1249 }
1250
1251 void frmSearch::ReloadAccountList( wxCommandEvent& event ){
1252
1253         // Currently unimplemented.
1254
1255 }
1256
1257 void frmSearch::AddResult( wxCommandEvent& event ){
1258
1259         SRNotif *srnotif = (SRNotif*)event.GetClientData();
1260
1261         // Process Data and add to the list of results.
1262
1263         wxListItem item;
1264
1265         // Setup the contact name.
1266
1267         wxString ContactNameFinal;
1268
1269         if (!srnotif->ContactName.Title.IsEmpty()){
1270
1271                 ContactNameFinal.append(srnotif->ContactName.Title);
1272                 ContactNameFinal.Trim();
1273                 ContactNameFinal.append(wxT(" "));
1274
1275         }
1276
1277         if (!srnotif->ContactName.Forename.IsEmpty()){
1278
1279                 ContactNameFinal.append(srnotif->ContactName.Forename);
1280                 ContactNameFinal.Trim();
1281                 ContactNameFinal.append(wxT(" "));
1282
1283         }
1284
1285         if (!srnotif->ContactName.Surname.IsEmpty()){
1286
1287                 ContactNameFinal.append(srnotif->ContactName.Surname);
1288                 ContactNameFinal.Trim();
1289                 ContactNameFinal.append(wxT(" "));
1290
1291         }
1292
1293         if (!srnotif->ContactName.Suffix.IsEmpty()){
1294
1295                 ContactNameFinal.append(srnotif->ContactName.Suffix);
1296                 ContactNameFinal.Trim();
1297
1298         }
1299
1300         item.SetId(0);
1301         item.SetText(ContactNameFinal);
1302         item.SetData(srnotif->SearchResultID);
1303
1304         long ListCtrlIndex = lstResults->InsertItem(item);
1305
1306         //SearchResultAccount.insert(std::make_pair(srnotif->SearchResultID, srnotif->ContactAccount));
1307         //SearchResultFilename.insert(std::make_pair(srnotif->SearchResultID, srnotif->ContactFullFilename));
1308
1309         srnotif->ContactNickname.Trim();
1310
1311         lstResults->SetItem(ListCtrlIndex, 1, srnotif->ContactNickname);
1312         lstResults->SetItem(ListCtrlIndex, 2, srnotif->ContactAccountName);
1313
1314         delete srnotif;
1315         srnotif = NULL;
1316
1317 }
1318
1319 void frmSearch::SearchBarUpdate( wxCommandEvent& event ){
1320
1321         wxString *SBData = (wxString*)event.GetClientData();
1322
1323         stbBottom->SetStatusText(*SBData, 0);
1324
1325         delete SBData;
1326         SBData = NULL;
1327
1328 }
1329
1330 void frmSearch::SearchFinished( wxCommandEvent& event ){
1331
1332         StopMode = FALSE;
1333         btnSearch->SetLabel(_("Search"));
1334         DisableAllSearchSettings(FALSE);
1335
1336 }
1337
1338 void frmSearch::DisableAllSearchSettings(bool Enable){
1339
1340         for (std::map<int, void*>::iterator siter = SearchFrames.begin();
1341                 siter != SearchFrames.end(); siter++){
1342
1343                 XABSearchPanel *XABSPPtr = static_cast<XABSearchPanel*>(siter->second);
1344
1345                 if (Enable == FALSE){
1346
1347                         wxCommandEvent enboxes(XABSP_ENABLECONTROLS);
1348                         wxPostEvent(XABSPPtr, enboxes);
1349
1350                 } else if (Enable == TRUE){
1351
1352                         wxCommandEvent disboxes(XABSP_DISABLECONTROLS);
1353                         wxPostEvent(XABSPPtr, disboxes);
1354
1355                 }
1356
1357         }
1358
1359 }
1360
1361 void frmSearch::OpenContact( wxCommandEvent& event ){
1362
1363         // Check if a contact has been selected.
1364
1365         long intSelected = -1;
1366         int intSelectedData = 0;
1367         long intContactSeekNum = -1;
1368
1369         intSelected = lstResults->GetNextItem(intSelected,
1370                 wxLIST_NEXT_ALL,
1371                 wxLIST_STATE_SELECTED);
1372
1373         if (intSelected == -1){
1374                 return;
1375         }
1376
1377         intContactSeekNum = lstResults->GetItemData(intSelected);
1378
1379         if (SearchMode == TRUE){
1380
1381                 wxMessageBox(SearchResultFilename[intContactSeekNum]);
1382
1383                 vCard Person;
1384
1385                 Person.LoadFile(SearchResultFilename[intContactSeekNum]);
1386
1387                 wxMemoryInputStream istream(bigimgs_contactpersonicon48_png, sizeof(bigimgs_contactpersonicon48_png));
1388                 wxImage bigimgs_contactpersonicon48i(istream, wxBITMAP_TYPE_PNG);
1389                 wxBitmap contacticonbmp(bigimgs_contactpersonicon48i, -1);
1390                 wxIcon contacticon;
1391                 contacticon.CopyFromBitmap(contacticonbmp);
1392
1393                 frmContact *Contact = new frmContact( this );
1394
1395                 Contact->SetupPointers(&SearchModeMemoryFSPtr);
1396                 Contact->SetupContactData(&Person);
1397
1398                 Contact->SetIcon(contacticon);
1399                 Contact->Show(true);
1400
1401         } else {
1402
1403                 UCNotif *uc = new UCNotif;
1404
1405                 uc->ContactAccount = SearchResultAccount[intContactSeekNum];
1406                 uc->ContactFilename = SearchResultFilename[intContactSeekNum];
1407
1408                 wxCommandEvent oc(CE_OPENCONTACT);
1409                 oc.SetClientData(uc);
1410                 wxPostEvent(this->GetParent(), oc);
1411
1412         }
1413
1414 }
1415
1416 void frmSearch::EditContact( wxCommandEvent& event ){
1417
1418         // Check if a contact has been selected.
1419
1420         long intSelected = -1;
1421         int intSelectedData = 0;
1422         long intContactSeekNum = -1;
1423
1424         intSelected = lstResults->GetNextItem(intSelected,
1425                 wxLIST_NEXT_ALL,
1426                 wxLIST_STATE_SELECTED);
1427
1428         if (intSelected == -1){
1429                 return;
1430         }
1431
1432         intContactSeekNum = lstResults->GetItemData(intSelected);
1433
1434         UCNotif *uc = new UCNotif;
1435
1436         uc->ContactAccount = SearchResultAccount[intContactSeekNum];
1437         uc->ContactFilename = SearchResultFilename[intContactSeekNum];
1438
1439         wxCommandEvent ec(CE_EDITCONTACT);
1440         ec.SetClientData(uc);
1441         ec.SetInt(1);
1442         wxPostEvent(this->GetParent(), ec);
1443
1444 }
1445
1446 void frmSearch::RevealContact( wxCommandEvent& event ){
1447
1448         // Check if a contact has been selected.
1449
1450         long intSelected = -1;
1451         int intSelectedData = 0;
1452         long intContactSeekNum = -1;
1453
1454         intSelected = lstResults->GetNextItem(intSelected,
1455                 wxLIST_NEXT_ALL,
1456                 wxLIST_STATE_SELECTED);
1457
1458         if (intSelected == -1){
1459                 return;
1460         }
1461
1462         intContactSeekNum = lstResults->GetItemData(intSelected);
1463
1464         UCNotif *uc = new UCNotif;
1465
1466         uc->ContactAccount = SearchResultAccount[intContactSeekNum];
1467         uc->ContactFilename = SearchResultFilename[intContactSeekNum];
1468
1469         wxCommandEvent rc(CE_REVEALCONTACT);
1470         rc.SetClientData(uc);
1471         rc.SetInt(1);
1472         wxPostEvent(this->GetParent(), rc);
1473
1474 }
1475
1476 void frmSearch::CloseWindow( wxCloseEvent& event ){
1477
1478         // Hide the window so users don't panic
1479         // whilst clearing up.
1480
1481         this->Hide();
1482
1483         // Clear up.
1484
1485         for (std::map<int,void*>::iterator iter = SearchFrames.begin();
1486          iter != SearchFrames.end(); ++iter){
1487
1488                 XABSearchPanel *XABSPPtr;
1489
1490                 XABSPPtr = static_cast<XABSearchPanel*>(iter->second);
1491                 szrSearch->Detach(XABSPPtr);
1492
1493                 // Remove the frame from the memory and the list.
1494
1495                 delete XABSPPtr;
1496                 XABSPPtr = NULL;
1497
1498         }
1499
1500         SearchFrames.clear();
1501
1502         // Close window.
1503
1504         WindowData *WData = new WindowData;
1505
1506         WData->DataType = 2;
1507         WData->WindowPointer = this;
1508         WData->WindowID = SearchUID;
1509
1510         wxCommandEvent delevent(WINDOW_CLOSE);
1511         delevent.SetClientData(WData);
1512         wxPostEvent(GetParent(), delevent);
1513
1514         wxCommandEvent rs(CE_REMOVESEARCH);
1515         wxPostEvent(this, rs);
1516
1517         WData = NULL;
1518
1519         this->Destroy();
1520
1521 }
1522
1523 void frmSearch::CloseWindow( wxCommandEvent& event ){
1524
1525         this->Close();
1526
1527 }
1528
1529 void frmSearch::UpdateResult( wxCommandEvent& event ){
1530
1531         UCNotif *uc = (UCNotif*)event.GetClientData();
1532
1533         long longSelected = -1;
1534         int intSelectedData = 0;
1535
1536         for (;;){
1537
1538                 longSelected = lstResults->GetNextItem(longSelected,
1539                         wxLIST_NEXT_ALL,
1540                         wxLIST_STATE_DONTCARE);
1541
1542                 if (longSelected == -1){
1543
1544                         break;
1545
1546                 }
1547
1548                 // Get the filename/ID information.
1549
1550                 intSelectedData = lstResults->GetItemData(longSelected);
1551
1552                 if (uc->ContactFilename == SearchResultFilename[intSelectedData]){
1553
1554                         // Process the contact name
1555
1556                         wxString ContactNameFinal;
1557
1558                         if (!uc->ContactNameArray.Title.IsEmpty()){
1559
1560                                 ContactNameFinal.append(uc->ContactNameArray.Title);
1561                                 ContactNameFinal.Trim();
1562                                 ContactNameFinal.append(wxT(" "));
1563
1564                         }
1565
1566                         if (!uc->ContactNameArray.Forename.IsEmpty()){
1567
1568                                 ContactNameFinal.append(uc->ContactNameArray.Forename);
1569                                 ContactNameFinal.Trim();
1570                                 ContactNameFinal.append(wxT(" "));
1571
1572                         }
1573
1574                         if (!uc->ContactNameArray.Surname.IsEmpty()){
1575
1576                                 ContactNameFinal.append(uc->ContactNameArray.Surname);
1577                                 ContactNameFinal.Trim();
1578                                 ContactNameFinal.append(wxT(" "));
1579
1580                         }
1581
1582                         if (!uc->ContactNameArray.Suffix.IsEmpty()){
1583
1584                                 ContactNameFinal.append(uc->ContactNameArray.Suffix);
1585                                 ContactNameFinal.Trim();
1586
1587                         }
1588
1589                         lstResults->SetItem(longSelected, 0, ContactNameFinal);
1590                         lstResults->SetItem(longSelected, 1, uc->ContactNickname);
1591
1592                 }
1593
1594         }
1595
1596         delete uc;
1597         uc = NULL;
1598
1599 }
1600
1601 bool frmSearch::CheckDuplicate(wxString Filename,
1602         wxString Account,
1603         std::map<long,wxString> *SRAcc,
1604         std::map<long,wxString> *SRFN){
1605
1606         std::map<long,wxString>::iterator fniter;
1607
1608         // Check comparison code.
1609
1610         for (std::map<long,wxString>::iterator aciter = SRAcc->begin();
1611                 aciter != SRAcc->end(); aciter++){
1612
1613                 fniter = SRFN->find(aciter->first);
1614
1615                 if (Filename == fniter->second &&
1616                         Account == aciter->second){
1617
1618                         return TRUE;
1619
1620                 }
1621
1622         }
1623
1624         return FALSE;
1625
1626 }
1627
1628 void frmSearch::DeleteResult(wxCommandEvent &event){
1629
1630         UCNotif *uc = (UCNotif*)event.GetClientData();
1631
1632         long longSelected = -1;
1633         int intSelectedData = 0;
1634
1635         for (;;){
1636
1637                 longSelected = lstResults->GetNextItem(longSelected,
1638                         wxLIST_NEXT_ALL,
1639                         wxLIST_STATE_DONTCARE);
1640
1641                 if (longSelected == -1){
1642
1643                         break;
1644
1645                 }
1646
1647                 // Get the filename/ID information.
1648
1649                 intSelectedData = lstResults->GetItemData(longSelected);
1650
1651                 if (uc->ContactFilename == SearchResultFilename[intSelectedData]){
1652
1653                         // Delete the result from the search list and
1654                         // update the total search results.
1655
1656                         // Remove DeleteResultEvent and find out where the uc
1657                         // data is still being used as it crashes on delete.
1658
1659                         lstResults->DeleteItem(longSelected);
1660
1661                         // Update the number of search results.
1662
1663                         wxCommandEvent sbu(SE_SBUPDATE);
1664                         wxString *SBUpdate = new wxString;
1665
1666                         // Get the number of results.
1667
1668                         int intResultFound = lstResults->GetItemCount();
1669
1670                         // Prepare the status bar message.
1671
1672                         if (intResultFound == 0){
1673
1674                                 *SBUpdate = _("No contacts found.");
1675
1676                         } else if (intResultFound == 1){
1677
1678                                 *SBUpdate = _("1 contact found.");
1679
1680                         } else {
1681
1682                                 *SBUpdate = wxString::Format(wxT("%i"), intResultFound) + _(" contacts found.");
1683
1684                         }
1685
1686                         sbu.SetClientData(SBUpdate);
1687                         wxPostEvent(this, sbu);
1688
1689                         break;
1690
1691                 }
1692
1693         }
1694
1695         delete uc;
1696         uc = NULL;
1697
1698 }
1699
1700 void frmSearch::SetUID(int UID){
1701
1702         SearchUID = UID;
1703
1704 }
1705
1706 void frmSearch::SetSearchMode(bool SearchModeIn){
1707
1708         SearchMode = SearchModeIn;
1709
1710         if (SearchMode == TRUE){
1711
1712                 mnuContactEdit->Enable(FALSE);
1713                 mnuContactReveal->Enable(FALSE);
1714
1715                 wxFileSystem::AddHandler(new wxMemoryFSHandler);
1716                 wxImage ciicon_png;
1717
1718                 wxMemoryInputStream ciptostream(icons_cipto_png, sizeof(icons_cipto_png));
1719                 ciicon_png.LoadFile(ciptostream, wxBITMAP_TYPE_PNG);
1720                 wxMemoryFSHandler::AddFile(wxT("cipto.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1721
1722                 wxMemoryInputStream cilogstream(icons_cilog_png, sizeof(icons_cilog_png));
1723                 ciicon_png.LoadFile(cilogstream, wxBITMAP_TYPE_PNG);
1724                 wxMemoryFSHandler::AddFile(wxT("cilog.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1725
1726                 wxMemoryInputStream cisndstream(icons_cisnd_png, sizeof(icons_cisnd_png));
1727                 ciicon_png.LoadFile(cisndstream, wxBITMAP_TYPE_PNG);
1728                 wxMemoryFSHandler::AddFile(wxT("cisnd.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1729
1730                 wxMemoryInputStream cikeystream(icons_cikey_png, sizeof(icons_cikey_png));
1731                 ciicon_png.LoadFile(cikeystream, wxBITMAP_TYPE_PNG);
1732                 wxMemoryFSHandler::AddFile(wxT("cikey.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1733
1734                 wxMemoryInputStream civenstream(icons_civen_png, sizeof(icons_civen_png));
1735                 ciicon_png.LoadFile(civenstream, wxBITMAP_TYPE_PNG);
1736                 wxMemoryFSHandler::AddFile(wxT("civen.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1737
1738                 wxMemoryInputStream ciextstream(icons_ciext_png, sizeof(icons_ciext_png));
1739                 ciicon_png.LoadFile(ciextstream, wxBITMAP_TYPE_PNG);
1740                 wxMemoryFSHandler::AddFile(wxT("ciext.png"), ciicon_png, wxBITMAP_TYPE_PNG);
1741
1742         } else {
1743
1744                 mnuContactEdit->Enable(TRUE);
1745                 mnuContactReveal->Enable(TRUE);
1746
1747         }
1748
1749 }
1750
1751 void frmSearch::ShowContactMenu( wxMouseEvent& event ){
1752
1753         ContactMenu->SetupPointers(this, lstResults);
1754
1755         PopupMenu(ContactMenu->MenuPointer(), wxDefaultPosition);
1756
1757 }