// timers.cpp - Timers subroutines.
//
// (c) 2012-2015 Xestia Software Development.
//
// This file is part of Xestia Address Book.
//
// Xestia Address Book is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by the
// Free Software Foundation, version 3 of the license.
//
// Xestia Address Book is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with Xestia Address Book. If not, see
#include "timers.h"
void wxActTimer::Notify(){
// Notify function for wxActTimer.
frmMain *frmMainPtrProc = static_cast(frmMainPtr);
wxCommandEvent shuffleevent(ACTMGR_SHUFFLE);
if (intActivityProgress == 0){
wxMemoryInputStream istream(misc_activity1_png, sizeof(misc_activity1_png));
wxImage misc_activity1_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity1_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 1){
wxMemoryInputStream istream(misc_activity2_png, sizeof(misc_activity2_png));
wxImage misc_activity2_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity2_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 2){
wxMemoryInputStream istream(misc_activity3_png, sizeof(misc_activity3_png));
wxImage misc_activity3_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity3_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 3){
wxMemoryInputStream istream(misc_activity4_png, sizeof(misc_activity4_png));
wxImage misc_activity4_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity4_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 4){
wxMemoryInputStream istream(misc_activity5_png, sizeof(misc_activity5_png));
wxImage misc_activity5_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity5_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 5){
wxMemoryInputStream istream(misc_activity6_png, sizeof(misc_activity6_png));
wxImage misc_activity6_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity6_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 6){
wxMemoryInputStream istream(misc_activity7_png, sizeof(misc_activity7_png));
wxImage misc_activity7_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity7_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 7){
wxMemoryInputStream istream(misc_activity8_png, sizeof(misc_activity8_png));
wxImage misc_activity8_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity8_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 8){
wxMemoryInputStream istream(misc_activity9_png, sizeof(misc_activity9_png));
wxImage misc_activity9_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity9_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 9){
wxMemoryInputStream istream(misc_activity10_png, sizeof(misc_activity10_png));
wxImage misc_activity10_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity10_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 10){
wxMemoryInputStream istream(misc_activity11_png, sizeof(misc_activity11_png));
wxImage misc_activity11_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity11_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress++;
} else if (intActivityProgress == 11){
wxMemoryInputStream istream(misc_activity12_png, sizeof(misc_activity12_png));
wxImage misc_activity12_pngi(istream, wxBITMAP_TYPE_PNG);
wxBitmap activityiconbmp(misc_activity12_pngi, -1);
bmpActivity->SetBitmap(activityiconbmp);
intActivityProgress = 0;
}
wxPostEvent(frmMainPtrProc, shuffleevent);
}
void wxActTimer::SetBitmap(wxStaticBitmap *bitmap)
{
// Set the bitmap for wxActTimer.
bmpActivity = bitmap;
}
void wxActTimer::SetSleepBitmap(wxBitmap *SleepBitmap)
{
// Set the sleep bitmap for wxActTimer.
SleepBitmapPtr = SleepBitmap;
}
void wxActTimer::StopAnimation()
{
// Stop the icon animation.
frmMain *frmMainPtrProc = static_cast(frmMainPtr);
wxCommandEvent actstop(ACTMGR_STOP);
wxPostEvent(frmMainPtrProc, actstop);
this->Stop();
bmpActivity->SetBitmap(*SleepBitmapPtr);
}
void wxActTimer::StartAnimation()
{
frmMain *frmMainPtrProc = static_cast(frmMainPtr);
wxCommandEvent actstart(ACTMGR_START);
wxPostEvent(frmMainPtrProc, actstart);
this->ResetBitmap();
this->Start(50, FALSE);
}
void wxActTimer::ResetBitmap()
{
// Reset the bitmap for wxActTimer.
intActivityProgress = 0;
}
void wxActTimer::SetupPointer(void *frmMainPtrIn)
{
// Setup the pointer for wxActTimer.
frmMainPtr = frmMainPtrIn;
}
void wxActProcessTimer::Notify()
{
// Notify function for wxActProcessTimer.
// Pause the timer whilst processing to avoid problems.
this->Stop();
// Process Tasks.
frmActivityMgr *ActMgrPtrProc = static_cast(ActMgrPtr);
ActMgrPtrProc->ProcessTasks();
}
void wxActProcessTimer::SetupPointers(void *ActMgr){
// Setup pointers for the wxActProcessTimer.
ActMgrPtr = ActMgr;
}
void wxActListProcTimer::Notify(){
// Notify function for wxActListProcTimer.
// Setup Label and get task data (update SetupPointers subroutine).
this->Stop();
for (std::map::iterator iter = ActListPtr->begin();
iter != ActListPtr->end(); ++iter){
// Check for any queued tasks and start one.
// 0 = Queued.
// 1 = Processing.
// 2 = Failed.
// 3 = Stopped.
// 4 = Completed.
// 5 = Failed (UI Updated).
// 6 = Stopped (UI Updated).
// 7 = (Reserved) (UI Updated).
// 8 = Completed. (UI Updated).
std::map::iterator LongIter = ActListUIPtr->find(iter->first);
if (iter->second > 4){
continue;
}
std::map::iterator DetailIter = ActListDetailPtr->find(iter->first);
wxCommandEvent uevent(ACTMGR_UPDATESTATUSLABEL);
ActivityMgrLabelUpdate *ueventdata = new ActivityMgrLabelUpdate;
uevent.SetClientData(ueventdata);
if (iter->second == 1){
ueventdata->ItemIndex = LongIter->second;
ueventdata->ItemLabel = _("Processing...");
wxPostEvent(static_cast(ActMgrPtr), uevent);
} else if (iter->second == 2){
ueventdata->ItemIndex = LongIter->second;
ueventdata->ItemLabel = _("Failed");
wxPostEvent(static_cast(ActMgrPtr), uevent);
iter->second = 5;
} else if (iter->second == 3){
ueventdata->ItemIndex = LongIter->second;
ueventdata->ItemLabel = _("Stopped");
wxPostEvent(static_cast(ActMgrPtr), uevent);
iter->second = 6;
} else if (iter->second == 4){
ueventdata->ItemIndex = LongIter->second;
ueventdata->ItemLabel = _("Completed");
wxPostEvent(static_cast(ActMgrPtr), uevent);
iter->second = 8;
}
// Delete the connection object if finished.
if (iter->second > 4){
std::map::iterator ConnObjectIter = ActListConnObjectsPtr->find(iter->first);
delete ConnObjectIter->second;
ConnObjectIter->second = nullptr;
}
// Insert a finish date.
wxDateTime adt;
adt = adt.Now();
ActListFinDTPtr->insert(std::make_pair(iter->first, adt));
}
if (ClearupProcessed == TRUE){
// Clear up processed items.
// Delete the processed items.
ClearupProcessed = FALSE;
}
if (*TasksActivePtr == FALSE){
ActTimerPtr->StopAnimation();
lblDetailsPtr->SetLabel(_("No activity."));
} else {
this->Start();
}
}
void wxActListProcTimer::SetupPointers(std::map *ActList, std::map *ActListUI,
std::map *ActListDetail, bool *TasksActive,
wxListCtrl *lstActivity, wxStaticText *lblDetails, wxGauge *GauProgress,
void *ActMgr, wxActTimer *ActTimer, wxActProcessTimer *ActProcessTimer,
std::map *ActListFinDT, std::map *ActListConnObjects){
// Setup the pointers for wxActListProcTimer.
ActListPtr = ActList;
ActListUIPtr = ActListUI;
ActListDetailPtr = ActListDetail;
TasksActivePtr = TasksActive;
lstActivityPtr = lstActivity;
lblDetailsPtr = lblDetails;
GauProgressPtr = GauProgress;
ActMgrPtr = ActMgr;
ActTimerPtr = ActTimer;
ActProcessTimerPtr = ActProcessTimer;
ActListFinDTPtr = ActListFinDT;
ActListConnObjectsPtr = ActListConnObjects;
}
void wxActListProcTimer::EnableClearup(){
// Enable clearup of the wxActListProcTimer.
ClearupProcessed = TRUE;
}
void wxETagProcessTimer::Notify(){
// Notify function for wxETagProcessTimer.
// Check each ETagDB and see if writing to file is required.
std::map::iterator ETagIter;
for (ETagIter = ETagDBList.begin();
ETagIter != ETagDBList.end(); ++ETagIter){
if (ETagIter->second.GetWriteStatus() == TRUE){
ETagIter->second.WriteETagDB();
}
}
}
void wxETagProcessTimer::ReloadAccounts(){
// Get the account preferences file and setup each database accordingly.
ReloadLock.lock();
// Stop the timer.
this->Stop();
ETagDBList.clear();
wxString PrefFilename = GetUserPrefDir();
XABPreferences PrefData(PrefFilename);
wxString AccountName;
wxString AccountDir;
wxString AccountAddress;
wxString AccountUsername;
wxString AccountPassword;
wxString AccountPrefix;
wxString AccountType;
// Look for the account and get the friendly name for the account.
for (int i = 0; i < PrefData.accounts.GetCount(); i++){
AccountDir = PrefData.accounts.GetAccountDirectory(i);
AccountType = PrefData.accounts.GetAccountType(i);
if (AccountDir.IsEmpty()){
continue;
}
if (AccountType != wxT("CardDAV") && AccountType != wxT("carddav")){
continue;
}
AccountDir.Trim();
AccountDir.Append(wxT(".carddav"));
ETagDB AccountDB;
AccountDB.SetupDB(AccountDir);
ETagDBList.insert(std::make_pair(AccountDir, AccountDB));
AccountDir.clear();
}
ReloadLock.unlock();
this->Start(15000);
}
ETagDB* wxETagProcessTimer::GetPointer(wxString AccountName){
// Get the pointer of the ETag Database.
ETagDB *ETagDBPtr = NULL;
std::map::iterator ETagIter;
ETagIter = ETagDBList.find(AccountName);
if (ETagIter != ETagDBList.end()){
ETagDBPtr = &ETagIter->second;
}
return ETagDBPtr;
}
void wxContactFileMonitorTimer::Notify(){
// Notify function for wxContactFileMonitorTimer.
if (Filename.IsEmpty()){
return;
}
wxFileName FileCheck(Filename);
wxDateTime CurrentDateTime;
CurrentDateTime = FileCheck.GetModificationTime();
if (FileDateTime != CurrentDateTime){
// The dates & times of the file are different.
// Send an event to notify the user of this change.
wxCommandEvent dateevent(wxEVT_COMMAND_BUTTON_CLICKED);
wxPostEvent(frmCEPtr, dateevent);
}
}
void wxContactFileMonitorTimer::SetFilename(wxString FilenameInc){
// Set the filename for the wxContactFileMonitorTimer object.
Filename = FilenameInc;
wxFileName FileCheck(Filename);
FileDateTime = FileCheck.GetModificationTime();
}
void wxContactFileMonitorTimer::SetupPointers(frmContactEditor *frmCEPtrInc){
// Setup the pointers for the wxContactFileMonitorTimer object.
frmCEPtr = frmCEPtrInc;
}
void wxContactFileMonitorTimer::UpdateTimestamp(){
// Update the timestamp for the wxContactFileMonitorTimer object.
wxFileName FileCheck(Filename);
FileDateTime = FileCheck.GetModificationTime();
}
void wxContactWindowMonitor::Notify(){
// Notify function for the wxContactWindowMonitor object.
}
void wxContactWindowMonitor::SetupPointers(std::map *ContactWindowListPtrInc){
// Setup pointers for the wxContactWindowMonitor.
ContactWindowListPtr = ContactWindowListPtrInc;
}
void wxAccountSyncTimer::Notify(){
// Notify function for the wxAccountSyncTimer.
frmActivityMgr *ActMgrPtrProc = static_cast(frmActMgrPtr);
// Disable the timer. (Don't go updating unless needed).
this->Stop();
if (ActMgrPtrProc->GetTaskStatus(intTaskID) < 2){
this->Start();
return;
}
// Add task to the activity manager.
intTaskID = ActMgrPtrProc->AddTask(3, wxT(""), AccName,
wxT(""), wxT(""), wxT(""), wxT(""));
// Go to sleep and wait for the task to be completed.
// Enable the timer as we are now finished syncronising.
this->Start();
}
void wxAccountSyncTimer::SetupData(wxString AccNameInc,
wxString AccNameFullInc){
// Setup the data for the wxAccountSyncTimer object.
// Set the account name.
AccName = AccNameInc;
AccNameFull = AccNameFullInc;
}
void wxAccountSyncTimer::SetupPointers(void *frmMainPtrInc,
void *frmActMgrPtrInc, ETagDB *ETagDBPtrInc){
// Setup the pointers for the wxAccountSyncTimer object.
frmMainPtr = frmMainPtrInc;
frmActMgrPtr = frmActMgrPtrInc;
ETagDBPtr = ETagDBPtrInc;
}
void SleepFor(unsigned long longSleepNanoSecs){
// Sleep for specified nano seconds.
#ifdef __WIN32__
::Sleep((longSleepNanoSecs / 1000000));
#elif __HAIKU__
#else
timespec n1, n2;
n1.tv_sec = 0;
n1.tv_nsec = longSleepNanoSecs;
nanosleep(&n1, &n2);
#endif
}