taskfile.cpp

来自「管理项目进度工具的原代码」· C++ 代码 · 共 1,983 行 · 第 1/4 页
CPP
1,983 行
	}

	return FALSE;
}

BOOL CTaskFile::SetTaskCreationDate(HTASKITEM hTask, const COleDateTime& date, BOOL bISO)
{
	if (SetTaskDate(hTask, TDL_TASKCREATIONDATE, date, FALSE))
	{
		SetTaskCChar(hTask, TDL_TASKCREATIONDATESTRING, CDateHelper::FormatDate(date, bISO));
		return true;
	}

	return FALSE;
}

BOOL CTaskFile::SetTaskDoneDate(HTASKITEM hTask, const COleDateTime& date, BOOL bISO)
{
	if (SetTaskDate(hTask, TDL_TASKDONEDATE, date, FALSE))
	{
		SetTaskCChar(hTask, TDL_TASKDONEDATESTRING, CDateHelper::FormatDate(date, bISO));
		return true;
	}

	return FALSE;
}

BOOL CTaskFile::SetTaskDueDate(HTASKITEM hTask, const COleDateTime& date, BOOL bISO)
{
	if (SetTaskDate(hTask, TDL_TASKDUEDATE, date, FALSE))
	{
		SetTaskCChar(hTask, TDL_TASKDUEDATESTRING, CDateHelper::FormatDate(date, bISO));
		return true;
	}

	return FALSE;
}

BOOL CTaskFile::SetTaskStartDate(HTASKITEM hTask, const COleDateTime& date, BOOL bISO)
{
	if (SetTaskDate(hTask, TDL_TASKSTARTDATE, date, FALSE))
	{
		SetTaskCChar(hTask, TDL_TASKSTARTDATESTRING, CDateHelper::FormatDate(date, bISO));
		return true;
	}

	return FALSE;
}

BOOL CTaskFile::SetTaskRecurrence(HTASKITEM hTask, const TDIRECURRENCE& tr, LPCTSTR szRegularity)
{
	if (SetTaskRecurrence(hTask, (int)tr.nRegularity, tr.dwSpecific1, tr.dwSpecific2, tr.bRecalcFromDue))
	{
		SetTaskCChar(hTask, TDL_TASKRECURRENCE, szRegularity); // set human readable
		return true;
	}

	return false;
}

bool CTaskFile::SetTaskRecurrence(HTASKITEM hTask, int nRegularity, DWORD dwSpecific1, 
									DWORD dwSpecific2, BOOL bRecalcFromDue)
{
	CXmlItem* pXI = TaskFromHandle(hTask);

	if (pXI)
	{
		CXmlItem* pXIRecur = pXI->GetItem(TDL_TASKRECURRENCE);

		if (!pXIRecur)
			pXIRecur = pXI->AddItem(TDL_TASKRECURRENCE);
		
		pXIRecur->SetItemValue(TDL_TASKRECURRENCEREG, nRegularity);
		pXIRecur->SetItemValue(TDL_TASKRECURRENCESPEC1, (int)dwSpecific1);
		pXIRecur->SetItemValue(TDL_TASKRECURRENCESPEC2, (int)dwSpecific2);

		if (bRecalcFromDue)
			pXIRecur->SetItemValue(TDL_TASKRECURRENCEFROMDUE, TRUE);
		else
			pXIRecur->DeleteItem(TDL_TASKRECURRENCEFROMDUE);

		return true;
	}

	return false;
}

bool CTaskFile::SetTaskVersion(HTASKITEM hTask, const char* szVersion)
{
	return SetTaskCChar(hTask, TDL_TASKVERSION, szVersion);
}

BOOL CTaskFile::SetTaskTextColor(HTASKITEM hTask, COLORREF color)
{
	return SetTaskULong(hTask, TDL_TASKTEXTCOLOR, color) &&
			SetTaskCChar(hTask, TDL_TASKTEXTWEBCOLOR, GetWebColor(color));
}

BOOL CTaskFile::SetTaskPriorityColor(HTASKITEM hTask, COLORREF color)
{
	return SetTaskULong(hTask, TDL_TASKPRIORITYCOLOR, color) &&
			SetTaskCChar(hTask, TDL_TASKPRIORITYWEBCOLOR, GetWebColor(color));
}

BOOL CTaskFile::SetTaskCalcTimeEstimate(HTASKITEM hTask, double dTime)
{
	return SetTaskDouble(hTask, TDL_TASKCALCTIMEESTIMATE, dTime);
}

BOOL CTaskFile::SetTaskCalcTimeSpent(HTASKITEM hTask, double dTime)
{
	return SetTaskDouble(hTask, TDL_TASKCALCTIMESPENT, dTime);
}

BOOL CTaskFile::SetTaskEarliestDueDate(HTASKITEM hTask, const COleDateTime& date)
{
	return SetTaskDate(hTask, TDL_TASKEARLIESTDUEDATE, date, FALSE);
}

BOOL CTaskFile::SetTaskCalcCompletion(HTASKITEM hTask, int nPercent)
{
	return SetTaskUChar(hTask, TDL_TASKCALCCOMPLETION, (unsigned char)nPercent);
}

BOOL CTaskFile::SetTaskHighestPriority(HTASKITEM hTask, int nPriority)
{
	if (nPriority != FT_NOPRIORITY)
		nPriority = (char)max(0, min(10, nPriority));

	return SetTaskInt(hTask, TDL_TASKHIGHESTPRIORITY, nPriority);
}

BOOL CTaskFile::SetTaskHighestRisk(HTASKITEM hTask, int nRisk)
{
	if (nRisk != FT_NORISK)
		nRisk = (char)max(0, min(10, nRisk));

	return SetTaskInt(hTask, TDL_TASKHIGHESTRISK, nRisk);
}

BOOL CTaskFile::SetTaskCalcCost(HTASKITEM hTask, double dCost)
{
	return SetTaskDouble(hTask, TDL_TASKCALCCOST, dCost);
}

bool CTaskFile::SetTaskPosition(HTASKITEM hTask, unsigned long nPos)
{
	return SetTaskULong(hTask, TDL_TASKPOS, nPos);
}

bool CTaskFile::SetTaskRisk(HTASKITEM hTask, unsigned char nRisk)
{
	return SetTaskUChar(hTask, TDL_TASKRISK, (unsigned char)max(0, min(10, nRisk)));
}

bool CTaskFile::SetTaskRisk(HTASKITEM hTask, int nRisk)
{
	if (nRisk != FT_NORISK)
		nRisk = (char)max(-1, min(10, nRisk));

	return SetTaskInt(hTask, TDL_TASKRISK, nRisk);
}

bool CTaskFile::SetTaskExternalID(HTASKITEM hTask, const char* szID)
{
	return SetTaskCChar(hTask, TDL_TASKEXTERNALID, szID);
}

////////////////////////////////////////////////
// utility functions

time_t CTaskFile::GetTaskDate(HTASKITEM hTask, LPCTSTR szDateItem, BOOL bIncTime) const
{
	COleDateTime date = GetTaskDateOle(hTask, szDateItem, bIncTime);

	if (date.m_dt)
	{
		tm time = { date.GetSecond(), 
					date.GetMinute(),
					date.GetHour(), 
					date.GetDay(),
					date.GetMonth() - 1, 
					date.GetYear() - 1900, 
					date.GetDayOfWeek() - 1, 
					date.GetDayOfYear(), 
					-1};

		time_t timet = mktime(&time);

		return (timet == -1) ? 0 : timet;
	}

	return 0;
}

COleDateTime CTaskFile::GetTaskDateOle(HTASKITEM hTask, LPCTSTR szDateItem, BOOL bIncTime) const
{
	double dDate = GetTaskDouble(hTask, szDateItem);

	if (!bIncTime)
		dDate = floor(dDate);

	return dDate;
}

unsigned char CTaskFile::GetTaskUChar(HTASKITEM hTask, LPCTSTR szUCharItem) const
{
	unsigned long lVal = GetTaskULong(hTask, szUCharItem);

	return (unsigned char)min(max(0, lVal), 255);
}

unsigned long CTaskFile::GetTaskULong(HTASKITEM hTask, LPCTSTR szULongItem) const
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, 0);

	return (unsigned long)pXITask->GetItemValueI(szULongItem);
}

int CTaskFile::GetTaskInt(HTASKITEM hTask, LPCTSTR szIntItem) const
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, 0);

	return pXITask->GetItemValueI(szIntItem);
}

const char* CTaskFile::GetTaskCChar(HTASKITEM hTask, LPCTSTR szCCharItem) const
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, NULL);

	return pXITask->GetItemValue(szCCharItem);
}

double CTaskFile::GetTaskDouble(HTASKITEM hTask, LPCTSTR szDoubleItem) const
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, 0.0);

	return pXITask->GetItemValueF(szDoubleItem);
}

double CTaskFile::GetTaskTime(HTASKITEM hTask, LPCTSTR szTimeItem) const
{
	return GetTaskDouble(hTask, szTimeItem);
}

char CTaskFile::GetTaskTimeUnits(HTASKITEM hTask, LPCTSTR szUnitsItem) const
{
	return (char)GetTaskUChar(hTask, szUnitsItem);
}

////////////////////////////////////////////////////////////////////

bool CTaskFile::SetTaskDate(HTASKITEM hTask, LPCTSTR szDateItem, const COleDateTime& tVal, 
							BOOL bIncTime)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, false);

	double dDate = bIncTime ? tVal.m_dt : floor(tVal.m_dt);

   return (pXITask->SetItemValue(szDateItem, dDate) != NULL);
}

bool CTaskFile::SetTaskDate(HTASKITEM hTask, LPCTSTR szDateItem, time_t tVal, BOOL bIncTime)
{
	//fabio_2005
#if _MSC_VER >= 1400
    errno_t err;
	tm* pTime =NULL;
        // Get time as 64-bit integer.
        // Convert to local time
	err= localtime_s(pTime ,&tVal  );
#else
	tm* pTime = localtime(&tVal);
#endif



	if (!pTime)
		return false;

	// else
	COleDateTime date(pTime->tm_year + 1900,
					  pTime->tm_mon + 1,
					  pTime->tm_mday,
					  pTime->tm_hour,
					  pTime->tm_min,
					  pTime->tm_sec);
	
	return SetTaskDate(hTask, szDateItem, date, bIncTime);
}

bool CTaskFile::SetTaskUChar(HTASKITEM hTask, LPCTSTR szUCharItem, unsigned char cVal)
{
	return SetTaskULong(hTask, szUCharItem, cVal);
}

bool CTaskFile::SetTaskULong(HTASKITEM hTask, LPCTSTR szULongItem, unsigned long lVal)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, false);

   return (pXITask->SetItemValue(szULongItem, (int)lVal) != NULL);
}

bool CTaskFile::SetTaskInt(HTASKITEM hTask, LPCTSTR szIntItem, int iVal)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, false);

   return (pXITask->SetItemValue(szIntItem, iVal) != NULL);
}

bool CTaskFile::SetTaskCChar(HTASKITEM hTask, LPCTSTR szCCharItem, const char* szVal, BOOL bCData)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, false);

   return (pXITask->SetItemValue(szCCharItem, szVal, bCData) != NULL);
}

bool CTaskFile::SetTaskDouble(HTASKITEM hTask, LPCTSTR szDoubleItem, double dVal)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, false);

   return (pXITask->SetItemValue(szDoubleItem, dVal) != NULL);
}

bool CTaskFile::SetTaskTime(HTASKITEM hTask, LPCTSTR szTimeItem, double dTime,
							LPCTSTR szUnitsItem, char cUnits)
{
  char* szUnits;

	switch (cUnits)
	{
	case 'i': 
	case 'I': szUnits = "I"; // minutes
    break;

	case 'h': 
	case 'H': szUnits = "H";
    break;

	case 'd': 
	case 'D': szUnits = "D";
    break;

	case 'w':
	case 'W': szUnits = "W";
    break;

	case 'm': 
	case 'M': szUnits = "M";
    break;

	case 'y': 
	case 'Y': szUnits = "Y";
    break;

	default: // all else
		return false;
	}

	return SetTaskDouble(hTask, szTimeItem, dTime) &&
		  	SetTaskCChar(hTask, szUnitsItem, szUnits);
}

CString CTaskFile::GetWebColor(COLORREF color)
{
	unsigned char cRed = GetRValue(color);
	unsigned char cGreen = GetGValue(color);
	unsigned char cBlue = GetBValue(color);
	
	static CString sColor;
	sColor.Format("#%02X%02X%02X", cRed, cGreen, cBlue);
	
	return sColor;
}

const char* CTaskFile::GetTaskArrayItem(HTASKITEM hTask, const char* szNumItemTag, 
										const char* szItemTag, int nIndex) const
{
	if (nIndex == 0)
		return GetTaskCChar(hTask, szItemTag); // first item
	
	// else
	int nCount = GetTaskUChar(hTask, szNumItemTag);
	
	if (!nCount || nIndex < 1 || nIndex > nCount - 1)
		return NULL;
	
	CString sItem;
	sItem.Format("%s%d", szItemTag, nIndex);
	
	return GetTaskCChar(hTask, sItem);
}

bool CTaskFile::AddTaskArrayItem(HTASKITEM hTask, const char* szNumItemTag, 
								 const char* szItemTag, const char* szItem)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, false);
	
	int nCount = pXITask->GetItemValueI(szNumItemTag);
	
	// see if it already exists
	if (nCount || pXITask->GetItem(szItemTag))
	{
		CString sValue = pXITask->GetItemValue(szItemTag);
		
		if (sValue.CompareNoCase(szItem) == 0)
			return false; // already exists
		
		// the rest have numbers after their names
		for (int nItem = 1; nItem < nCount; nItem++)
		{
			CString sItem;
			sItem.Format("%s%d", szItemTag, nItem);
			
			CString sValue = pXITask->GetItemValue(sItem);
			
			if (sValue.CompareNoCase(szItem) == 0)
				return false; // already exists
		}
	}
	
	// does the task have an existing item?
	if (!pXITask->GetItem(szItemTag))
	{
		pXITask->AddItem(szNumItemTag, 1); // num
		pXITask->AddItem(szItemTag, szItem); // first item
	}
	else // append
	{
		// increment item count
		pXITask->SetItemValue(szNumItemTag, nCount + 1);
		
		CString sItem;
		sItem.Format("%s%d", szItemTag, nCount);
		
		pXITask->AddItem(sItem, szItem);
	}
	
	return true;
}

int CTaskFile::GetTaskArray(HTASKITEM hTask, const char* szNumItemTag, 
				  	 const char* szItemTag, CStringArray& aItems) const
{
	aItems.RemoveAll();

	// first item
	CString sItem = GetTaskCChar(hTask, szItemTag);

	if (!sItem.IsEmpty())
	{
		aItems.Add(sItem);

		// rest
		int nCount = GetTaskUChar(hTask, szNumItemTag);

		for (int nItem = 1; nItem < nCount; nItem++)
			aItems.Add(GetTaskArrayItem(hTask, szNumItemTag, szItemTag, nItem));
	}

	return aItems.GetSize();

}

BOOL CTaskFile::SetTaskArray(HTASKITEM hTask, const char* szNumItemTag, 
				  	 const char* szItemTag, const CStringArray& aItems)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, FALSE);

	// delete any existing categories
	pXITask->DeleteItem(szItemTag);
	pXITask->DeleteItem(szNumItemTag);

	// then add these
	int nCount = aItems.GetSize();
	
	for (int nItem = 0; nItem < nCount; nItem++)
		AddTaskArrayItem(hTask, szNumItemTag, szItemTag, aItems[nItem]);

	return TRUE;
}
taskfile.cpp - 源码说明

本页面展示了「管理项目进度工具的原代码」中的 taskfile.cpp 源码文件，采用 C++ 编程语言编写，共 1,983 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。
虫虫开发者社区收录了大量与项目进度管理相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。
⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?