source/frmSearch.cpp

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