source/frmSearch.cpp

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