taskfile.cpp

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

CPP
1,983 行
字号
1234
	return color;
}

int CTaskFile::GetTaskPriority(HTASKITEM hTask, BOOL bHighest) const
{
	if (bHighest && TaskHasAttribute(hTask, TDL_TASKHIGHESTPRIORITY))
		return GetTaskInt(hTask, TDL_TASKHIGHESTPRIORITY);

	return GetTaskInt(hTask, TDL_TASKPRIORITY);
}

unsigned char CTaskFile::GetTaskPercentDone(HTASKITEM hTask, BOOL bCalc) const
{
	if (bCalc && TaskHasAttribute(hTask, TDL_TASKCALCCOMPLETION))
		return GetTaskUChar(hTask, TDL_TASKCALCCOMPLETION);

	return GetTaskUChar(hTask, TDL_TASKPERCENTDONE);
}

double CTaskFile::GetTaskCost(HTASKITEM hTask, BOOL bCalc) const
{
	if (bCalc && TaskHasAttribute(hTask, TDL_TASKCALCCOST))
		return GetTaskDouble(hTask, TDL_TASKCALCCOST);

	// else
	return GetTaskDouble(hTask, TDL_TASKCOST);
}

BOOL CTaskFile::GetTaskRecurrence(HTASKITEM hTask, TDIRECURRENCE& tr) const
{
	return GetTaskRecurrence(hTask, (int&)tr.nRegularity, tr.dwSpecific1, 
							tr.dwSpecific2, tr.bRecalcFromDue);
}

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

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

		if (pXIRecur)
		{
			nRegularity = pXIRecur->GetItemValueI(TDL_TASKRECURRENCEREG);
			dwSpecific1 = pXIRecur->GetItemValueI(TDL_TASKRECURRENCESPEC1);
			dwSpecific2 = pXIRecur->GetItemValueI(TDL_TASKRECURRENCESPEC2);
			bRecalcFromDue = pXIRecur->GetItemValueI(TDL_TASKRECURRENCEFROMDUE);

			return true;
		}
	}

	return false;
}

const char* CTaskFile::GetTaskVersion(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKVERSION);
}

double CTaskFile::GetTaskTimeEstimate(HTASKITEM hTask, char& cUnits, BOOL bCalc) const
{
	cUnits = 0;
	
	if (bCalc && TaskHasAttribute(hTask, TDL_TASKCALCTIMEESTIMATE))
	{
		cUnits = 'H';
		return GetTaskDouble(hTask, TDL_TASKCALCTIMEESTIMATE);
	}
	else if (TaskHasAttribute(hTask, TDL_TASKTIMEESTUNITS))
	{
		const char* szUnits = GetTaskCChar(hTask, TDL_TASKTIMEESTUNITS);
		
		if (szUnits && *szUnits)
		{
			// bug fix
			cUnits = (char)atoi(szUnits);
			
			if (!cUnits)
				cUnits = szUnits[0];
		}
	}
	
	if (!cUnits)
		cUnits = 'H';
	
	return GetTaskDouble(hTask, TDL_TASKTIMEESTIMATE);
}

double CTaskFile::GetTaskTimeSpent(HTASKITEM hTask, char& cUnits, BOOL bCalc) const
{
	cUnits = 0;
	
	if (bCalc && TaskHasAttribute(hTask, TDL_TASKCALCTIMESPENT))
	{
		cUnits = 'H';
		return GetTaskDouble(hTask, TDL_TASKCALCTIMESPENT);
	}
	else if (TaskHasAttribute(hTask, TDL_TASKTIMESPENTUNITS))
	{
		const char* szUnits = GetTaskCChar(hTask, TDL_TASKTIMESPENTUNITS);
		
		if (szUnits && *szUnits)
		{
			// bug fix
			cUnits = (char)atoi(szUnits);
			
			if (!cUnits)
				cUnits = szUnits[0];
		}
	}
	// backwards compatibility
	else if (TaskHasAttribute(hTask, TDL_TASKTIMESPENTUNITS_OLD))
	{
		const char* szUnits = GetTaskCChar(hTask, TDL_TASKTIMESPENTUNITS_OLD);
		
		if (szUnits && *szUnits)
		{
			// bug fix
			cUnits = (char)atoi(szUnits);
			
			if (!cUnits)
				cUnits = szUnits[0];
		}
	}
	
	if (!cUnits)
		cUnits = 'H';

	if (TaskHasAttribute(hTask, TDL_TASKTIMESPENT))
		return GetTaskDouble(hTask, TDL_TASKTIMESPENT);

	// else for backwards compatibility
		return GetTaskDouble(hTask, TDL_TASKTIMESPENT_OLD);
}

time_t CTaskFile::GetTaskLastModified(HTASKITEM hTask) const
{
	return GetTaskDate(hTask, TDL_TASKLASTMOD, TRUE);
}

time_t CTaskFile::GetTaskCreationDate(HTASKITEM hTask) const
{
	return GetTaskDate(hTask, TDL_TASKCREATIONDATE, FALSE);
}

time_t CTaskFile::GetTaskDoneDate(HTASKITEM hTask) const
{
	return GetTaskDate(hTask, TDL_TASKDONEDATE, FALSE);
}

time_t CTaskFile::GetTaskDueDate(HTASKITEM hTask) const
{
	return GetTaskDueDate(hTask, FALSE);
}

time_t CTaskFile::GetTaskDueDate(HTASKITEM hTask, BOOL bEarliest) const
{
	if (bEarliest && TaskHasAttribute(hTask, TDL_TASKEARLIESTDUEDATE))
		return GetTaskDate(hTask, TDL_TASKEARLIESTDUEDATE, FALSE);

	return GetTaskDate(hTask, TDL_TASKDUEDATE, FALSE);
}

const char* CTaskFile::GetTaskDueDateString(HTASKITEM hTask, BOOL bEarliest) const
{
	if (bEarliest && TaskHasAttribute(hTask, TDL_TASKEARLIESTDUEDATESTRING))
		return GetTaskCChar(hTask, TDL_TASKEARLIESTDUEDATESTRING);

	return GetTaskCChar(hTask, TDL_TASKDUEDATESTRING);
}

time_t CTaskFile::GetTaskStartDate(HTASKITEM hTask) const
{
	return GetTaskDate(hTask, TDL_TASKSTARTDATE, FALSE);
}

COleDateTime CTaskFile::GetTaskLastModifiedOle(HTASKITEM hTask) const
{
	return GetTaskDateOle(hTask, TDL_TASKLASTMOD, TRUE);
}

COleDateTime CTaskFile::GetTaskDoneDateOle(HTASKITEM hTask) const
{
	return GetTaskDateOle(hTask, TDL_TASKDONEDATE, FALSE);
}

COleDateTime CTaskFile::GetTaskDueDateOle(HTASKITEM hTask) const
{
	return GetTaskDateOle(hTask, TDL_TASKDUEDATE, FALSE);
}

COleDateTime CTaskFile::GetTaskStartDateOle(HTASKITEM hTask) const
{
	return GetTaskDateOle(hTask, TDL_TASKSTARTDATE, FALSE);
}

COleDateTime CTaskFile::GetTaskCreationDateOle(HTASKITEM hTask) const
{
	return GetTaskDateOle(hTask, TDL_TASKCREATIONDATE, FALSE);
}

const char* CTaskFile::GetTaskDoneDateString(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKDONEDATESTRING);
}

const char* CTaskFile::GetTaskCreationDateString(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKCREATIONDATESTRING);
}

const char* CTaskFile::GetTaskDueDateString(HTASKITEM hTask) const
{
	return GetTaskDueDateString(hTask, FALSE);
}

const char* CTaskFile::GetTaskStartDateString(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKSTARTDATESTRING);
}

unsigned long CTaskFile::GetTaskPosition(HTASKITEM hTask) const
{
	return GetTaskULong(hTask, TDL_TASKPOS);
}

bool CTaskFile::IsTaskDone(HTASKITEM hTask) const
{
	return (GetTaskDoneDateOle(hTask).m_dt > 0.0 ||
			GetTaskPercentDone(hTask, FALSE) == 100);
}

bool CTaskFile::IsTaskDue(HTASKITEM hTask) const
{
	double dDue = GetTaskDueDateOle(hTask);

	if (dDue > 0.0)
	{
		double dToday = floor(COleDateTime::GetCurrentTime());
		return dDue <= dToday;
	}

	return false;
}

bool CTaskFile::TaskHasAttribute(HTASKITEM hTask, const char* szAttrib) const
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, false);
	
	CXmlItem* pXIAttrib = pXITask->GetItem(szAttrib);
	
	if (!pXIAttrib || !pXIAttrib->GetValueLen()) // not found
	{
		// some fallbacks
		if (lstrcmp(szAttrib, TDL_TASKCOLOR) == 0)
			return TaskHasAttribute(hTask, TDL_TASKTEXTCOLOR);
		
		else if (lstrcmp(szAttrib, TDL_TASKWEBCOLOR) == 0)
			return TaskHasAttribute(hTask, TDL_TASKTEXTWEBCOLOR);

		// else
		return FALSE;
	}
	
	// finally check for hidden attribute
	return (pXIAttrib->GetItemValueI("HIDE") == 0);
}

const char* CTaskFile::GetTaskAttribute(HTASKITEM hTask, const char* szAttrib) const
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, "");

	return (pXITask->GetItemValue(szAttrib));
}

HTASKITEM CTaskFile::GetTaskParent(HTASKITEM hTask) const
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, NULL);

	return (HTASKITEM)pXITask->GetParent();
}

unsigned long CTaskFile::GetTaskTextColor(HTASKITEM hTask) const
{
	if (TaskHasAttribute(hTask, TDL_TASKTEXTCOLOR))
		return GetTaskULong(hTask, TDL_TASKTEXTCOLOR);

	else if (TaskHasAttribute(hTask, TDL_TASKCOLOR))
		return GetTaskULong(hTask, TDL_TASKCOLOR);

	// else
	return 0;
}

int CTaskFile::GetTaskRisk(HTASKITEM hTask, BOOL bHighest) const
{
	if (bHighest && TaskHasAttribute(hTask, TDL_TASKHIGHESTRISK))
		return GetTaskInt(hTask, TDL_TASKHIGHESTRISK);

	return GetTaskInt(hTask, TDL_TASKRISK);
}

const char* CTaskFile::GetTaskExternalID(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKEXTERNALID);
}

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

bool CTaskFile::SetTaskTitle(HTASKITEM hTask, const char* szTitle)
{
	return SetTaskCChar(hTask, TDL_TASKTITLE, szTitle);
}

bool CTaskFile::SetTaskComments(HTASKITEM hTask, const char* szComments)
{
	// if the first two chars are '\r\n' then we need to translate them 
	// because otherwise MSXML will remove them
	


	CString sComments(szComments);
//	sComments.Replace("\r\n", "&#13;&#10;");

	return SetTaskCChar(hTask, TDL_TASKCOMMENTS, sComments);
}

bool CTaskFile::SetTaskAllocatedTo(HTASKITEM hTask, const char* szAllocTo)
{
	return SetTaskCChar(hTask, TDL_TASKALLOCTO, szAllocTo);
}

bool CTaskFile::SetTaskDependency(HTASKITEM hTask, const char* szDepends)
{
	return SetTaskCChar(hTask, TDL_TASKDEPENDENCY, szDepends);
}

bool CTaskFile::SetTaskAllocatedBy(HTASKITEM hTask, const char* szAllocBy)
{
	return SetTaskCChar(hTask, TDL_TASKALLOCBY, szAllocBy);
}

bool CTaskFile::SetTaskCategory(HTASKITEM hTask, const char* szCategory)
{
	return SetTaskCChar(hTask, TDL_TASKCATEGORY, szCategory);
}

bool CTaskFile::SetTaskStatus(HTASKITEM hTask, const char* szStatus)
{
	return SetTaskCChar(hTask, TDL_TASKSTATUS, szStatus);
}

bool CTaskFile::SetTaskFlag(HTASKITEM hTask, bool bFlag)
{
	return SetTaskUChar(hTask, TDL_TASKFLAG, (unsigned char)(bFlag ? 1 : 0));
}

bool CTaskFile::SetTaskFileReferencePath(HTASKITEM hTask, const char* szFileRefpath)
{
	return SetTaskCChar(hTask, TDL_TASKFILEREFPATH, szFileRefpath);
}

bool CTaskFile::SetTaskCreatedBy(HTASKITEM hTask, const char* szCreatedBy)
{
	return SetTaskCChar(hTask, TDL_TASKCREATEDBY, szCreatedBy);
}

BOOL CTaskFile::SetTaskID(HTASKITEM hTask, unsigned long nID, BOOL bVisible)
{
	if (SetTaskULong(hTask, TDL_TASKID, nID))
	{
		// update m_dwNextUniqueID
		m_dwNextUniqueID = max(m_dwNextUniqueID, nID + 1);

		HideAttribute(hTask, TDL_TASKID, !bVisible);

		return true;
	}
	
	return false;
}

BOOL CTaskFile::HideAttribute(HTASKITEM hTask, const char* szAttrib, BOOL bHide)
      {
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, FALSE);

	CXmlItem* pXIAttrib = pXITask->GetItem(szAttrib);

	if (pXIAttrib)
	{
		CXmlItem* pXIHide = pXIAttrib->GetItem("HIDE");

		// if not visible add 'HIDE' attribute
		if (bHide)
		{
			if (pXIHide)
				pXIHide->SetValue(1);
			else
				pXIAttrib->AddItem("HIDE", 1);
		}
		else if (pXIHide)
			pXIAttrib->DeleteItem(pXIHide);
		
		return TRUE;
	}
	
	return FALSE;
}

bool CTaskFile::SetTaskColor(HTASKITEM hTask, unsigned long nColor)
{
	return SetTaskULong(hTask, TDL_TASKCOLOR, nColor) &&
			SetTaskCChar(hTask, TDL_TASKWEBCOLOR, GetWebColor((COLORREF)nColor));
}

bool CTaskFile::SetTaskPriority(HTASKITEM hTask, unsigned char nPriority)
{
	return SetTaskUChar(hTask, TDL_TASKPRIORITY, (unsigned char)max(0, min(10, nPriority)));
}

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

	return SetTaskInt(hTask, TDL_TASKPRIORITY, nPriority);
}

bool CTaskFile::SetTaskPercentDone(HTASKITEM hTask, unsigned char nPercent)
{
	return SetTaskUChar(hTask, TDL_TASKPERCENTDONE, nPercent);
}

bool CTaskFile::SetTaskCost(HTASKITEM hTask, double dCost)
{
	return SetTaskDouble(hTask, TDL_TASKCOST, dCost);
}

bool CTaskFile::SetTaskTimeEstimate(HTASKITEM hTask, double dTimeEst, char cUnits)
{
	return SetTaskTime(hTask, TDL_TASKTIMEESTIMATE, dTimeEst,
						TDL_TASKTIMEESTUNITS, cUnits);
}

bool CTaskFile::SetTaskTimeSpent(HTASKITEM hTask, double dTimeSpent, char cUnits)
{
	return SetTaskTime(hTask, TDL_TASKTIMESPENT, dTimeSpent,
						TDL_TASKTIMESPENTUNITS, cUnits);
}

bool CTaskFile::SetTaskLastModified(HTASKITEM hTask, time_t tLastMod)
{
	return SetTaskDate(hTask, TDL_TASKLASTMOD, tLastMod, TRUE);
}

bool CTaskFile::SetTaskDoneDate(HTASKITEM hTask, time_t tDoneDate)
{
	return SetTaskDate(hTask, TDL_TASKDONEDATE, tDoneDate, FALSE);
}

bool CTaskFile::SetTaskDueDate(HTASKITEM hTask, time_t tDueDate)
{
	return SetTaskDate(hTask, TDL_TASKDUEDATE, tDueDate, FALSE);
}

bool CTaskFile::SetTaskStartDate(HTASKITEM hTask, time_t tStartDate)
{
	return SetTaskDate(hTask, TDL_TASKSTARTDATE, tStartDate, FALSE);
}

bool CTaskFile::SetTaskCreationDate(HTASKITEM hTask, time_t tCreationDate)
{
	return SetTaskDate(hTask, TDL_TASKCREATIONDATE, tCreationDate, FALSE);
}

BOOL CTaskFile::SetTaskLastModified(HTASKITEM hTask, const COleDateTime& tLastMod)
{
	return SetTaskDate(hTask, TDL_TASKLASTMOD, tLastMod, TRUE);
}

BOOL CTaskFile::SetTaskLastModified(HTASKITEM hTask, const COleDateTime& tLastMod, BOOL bISO)
{
	if (SetTaskLastModified(hTask, tLastMod))
	{
		CString sLastMod;
		sLastMod.Format("%s (%s)", CDateHelper::FormatDate(tLastMod, bISO), tLastMod.Format(VAR_TIMEVALUEONLY));
		
		SetTaskCChar(hTask, TDL_TASKLASTMODSTRING, sLastMod);
		return true;
1234

taskfile.cpp - 源码说明

本页面展示了「管理项目进度工具的原代码」中的 taskfile.cpp 源码文件，采用 C++ 编程语言编写，共 1,983 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫开发者社区收录了大量与项目进度管理相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

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