taskfile.cpp

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

CPP
1,983 行
字号
1234
BOOL CTaskFile::SetArchive(BOOL bArchive)
{
	CXmlItem* pXItem = GetItem(TDL_ARCHIVE);

	if (pXItem)
	{
		if (bArchive)
			pXItem->SetValue((int)1);
		else
			DeleteItem(pXItem);

		return true;
	}
	else if (bArchive)
		return (NULL != AddItem(TDL_ARCHIVE, (int)1));

	// else
	return TRUE;
}

bool CTaskFile::SetFileVersion(unsigned long nVersion)
{
	return (NULL != SetItemValue(TDL_FILEVERSION, (int)nVersion));
}

BOOL CTaskFile::SetCheckedOutTo(const CString& sCheckedOutTo)
{
	return (NULL != SetItemValue(TDL_CHECKEDOUTTO, sCheckedOutTo));
}

BOOL CTaskFile::SetCharSet(LPCTSTR szCharSet)
{
	CXmlItem* pXItem = GetItem(TDL_CHARSET);

	if (pXItem)
	{
		if (szCharSet && *szCharSet)
			pXItem->SetValue(szCharSet);
		else
			DeleteItem(pXItem);
	
		return TRUE;
	}
	else if (szCharSet && *szCharSet)
		return (NULL != AddItem(TDL_CHARSET, szCharSet));

	// else
	return TRUE;
}

BOOL CTaskFile::SetFileName(LPCTSTR szFilename)
{
	CXmlItem* pXItem = GetItem(TDL_FILENAME);
	CString sFName = FileMisc::GetFileNameFromPath(szFilename);

	if (pXItem)
	{
		if (sFName.IsEmpty())
			DeleteItem(pXItem);
		else
			pXItem->SetValue(szFilename);
	
		return TRUE;
	}
	else if (!sFName.IsEmpty())
		return (NULL != AddItem(TDL_FILENAME, szFilename));

	// else
	return TRUE;
}

BOOL CTaskFile::SetFileFormat(unsigned long lFormat)
{
	return (NULL != SetItemValue(TDL_FILEFORMAT, (int)lFormat));
}

BOOL CTaskFile::SetNextUniqueID(DWORD dwNextID)
{
	ASSERT (dwNextID >= m_dwNextUniqueID);

	BOOL bResult = FALSE;
	CXmlItem* pXItem = GetItem(TDL_NEXTUNIQUEID);

	if (pXItem)
	{
		pXItem->SetValue((int)dwNextID);
		bResult = TRUE;
	}
	else
		bResult = (NULL != AddItem(TDL_NEXTUNIQUEID, (int)dwNextID));

	if (bResult)
		m_dwNextUniqueID = dwNextID;

	return bResult;
}

BOOL CTaskFile::SetLastModified(const CString& sLastMod)
{
	return (NULL != SetItemValue(TDL_LASTMODIFIED, sLastMod));
}

BOOL CTaskFile::CheckOut()
{
	CString sTemp;
	return CheckOut(sTemp);
}

BOOL CTaskFile::CheckOut(CString& sCheckedOutTo)
{
	// make sure its got a filepath attached
	if (GetFilePath().IsEmpty())
		return FALSE;
	
	sCheckedOutTo = GetCheckOutTo();
	
	if (sCheckedOutTo.GetLength())
	{
		if (sCheckedOutTo == Misc::GetComputerName()) // its us
			return TRUE;
		
		else if (!sCheckedOutTo.IsEmpty()) // someone else
			return FALSE;
		
		// else check it out
		SetCheckedOutTo(Misc::GetComputerName());
	}
	else // check it out
		SetCheckedOutTo(Misc::GetComputerName());
	
	// and rewrite the file but keeping the same timestamp
	FILETIME ftMod;
	::GetFileTime((HANDLE)GetFileHandle(), NULL, NULL, &ftMod);
	
	SortTasksByID();
	BOOL bCheckedOut = SaveEx();
	
	::SetFileTime((HANDLE)GetFileHandle(), NULL, NULL, &ftMod);
	
	if (bCheckedOut)
		sCheckedOutTo = Misc::GetComputerName();
	
	return bCheckedOut;
}

BOOL CTaskFile::SetReportAttributes(LPCTSTR szTitle, LPCTSTR szDate)
{
	BOOL bRes = TRUE;

	CXmlItem* pXItem = GetItem(TDL_REPORTTITLE);

	if (pXItem)
		pXItem->SetValue(szTitle);
	else
		bRes &= (NULL != AddItem(TDL_REPORTTITLE, szTitle));

	if (szDate && *szDate)
	{
		pXItem = GetItem(TDL_REPORTDATE);

		if (pXItem)
			pXItem->SetValue(szDate);
		else
			bRes &= (NULL != AddItem(TDL_REPORTDATE, szDate));
	}

	return bRes;
}

BOOL CTaskFile::DeleteTaskAttributes(HTASKITEM hTask)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, FALSE);

	POSITION pos = pXITask->GetFirstItemPos();

	while (pos)
	{
		CXmlItem* pXIChild = pXITask->GetNextItem(pos);

		if (!pXIChild->NameMatches(TDL_TASK))
			pXITask->DeleteItem(pXIChild);
	}

	return TRUE;
}

HTASKITEM CTaskFile::FindTask(DWORD dwTaskID) const
{
	const CXmlItem* pXI = FindItem(TDL_TASKID, (int)dwTaskID);

	return pXI ? (HTASKITEM)(pXI->GetParent()) : NULL;
}

BOOL CTaskFile::DeleteTask(HTASKITEM hTask)
{
	CXmlItem* pXITask = NULL;
	GET_TASK(pXITask, hTask, FALSE);

	CXmlItem* pXIParent = pXITask->GetParent();
	ASSERT (pXIParent);

	// remove task from map first
	RemoveTaskFromMap(pXITask);

	return pXIParent->DeleteItem(pXITask);
}

BOOL CTaskFile::SetTaskCustomComments(HTASKITEM hTask, const CString& sContent, const CString& sType)
{
	if (!TaskFromHandle(hTask))
		return FALSE;

	BOOL bRes = TRUE;

	if (sContent.GetLength())
	{
		Base64Coder b64;
		b64.Encode((const PBYTE)(LPCTSTR)sContent, sContent.GetLength());

		bRes = SetTaskCChar(hTask, TDL_TASKCUSTOMCOMMENTS, b64.EncodedMessage());
	}

	if (bRes)
		bRes = SetTaskCChar(hTask, TDL_TASKCOMMENTSTYPE, sType);

	return bRes;
}

BOOL CTaskFile::SetTaskHtmlComments(HTASKITEM hTask, const CString& sContent, BOOL bForTransform)
{
	if (!TaskFromHandle(hTask))
		return FALSE;

	return SetTaskCChar(hTask, TDL_TASKHTMLCOMMENTS, sContent, !bForTransform);
}

BOOL CTaskFile::GetTaskCustomComments(HTASKITEM hTask, CString& sContent, CString& sType) const
{
	// comments type
	sType = GetTaskCChar(hTask, TDL_TASKCOMMENTSTYPE);

	// custom comments
	CString sTemp = GetTaskCChar(hTask, TDL_TASKCUSTOMCOMMENTS);

	if (sTemp.IsEmpty())
		return FALSE;

	Base64Coder b64;
	b64.Decode(sTemp);

	unsigned long nLenContent;
	PBYTE pContent = b64.DecodedMessage(nLenContent);

	PBYTE szContent = (PBYTE)sContent.GetBuffer(nLenContent);
	CopyMemory(szContent, pContent, nLenContent);
	sContent.ReleaseBuffer(nLenContent);
	
	return nLenContent;
}

BOOL CTaskFile::SetTaskCategories(HTASKITEM hTask, const CStringArray& aCategories)
{
	return SetTaskArray(hTask, TDL_TASKNUMCATEGORY, TDL_TASKCATEGORY, aCategories);
}

BOOL CTaskFile::SetTaskDependencies(HTASKITEM hTask, const CStringArray& aDepends)
{
	return SetTaskArray(hTask, TDL_TASKNUMDEPENDENCY, TDL_TASKDEPENDENCY, aDepends);
}

BOOL CTaskFile::SetTaskAllocatedTo(HTASKITEM hTask, const CStringArray& aAllocTo)
{
	return SetTaskArray(hTask, TDL_TASKNUMALLOCTO, TDL_TASKALLOCTO, aAllocTo);
}

bool CTaskFile::AddTaskDependency(HTASKITEM hTask, const char* szDepends)
{
	return AddTaskArrayItem(hTask, TDL_TASKNUMDEPENDENCY, TDL_TASKDEPENDENCY, szDepends);
}

bool CTaskFile::AddTaskAllocatedTo(HTASKITEM hTask, const char* szAllocTo)
{
	return AddTaskArrayItem(hTask, TDL_TASKNUMALLOCTO, TDL_TASKALLOCTO, szAllocTo);
}

bool CTaskFile::AddTaskCategory(HTASKITEM hTask, const char* szCategory)
{
	return AddTaskArrayItem(hTask, TDL_TASKNUMCATEGORY, TDL_TASKCATEGORY, szCategory);
}

int CTaskFile::GetTaskCategories(HTASKITEM hTask, CStringArray& aCategories) const
{
	return GetTaskArray(hTask, TDL_TASKNUMCATEGORY, TDL_TASKCATEGORY, aCategories);
}

int CTaskFile::GetTaskDependencies(HTASKITEM hTask, CStringArray& aDepends) const
{
	return GetTaskArray(hTask, TDL_TASKNUMDEPENDENCY, TDL_TASKDEPENDENCY, aDepends);
}

int CTaskFile::GetTaskAllocatedTo(HTASKITEM hTask, CStringArray& aAllocTo) const
{
	return GetTaskArray(hTask, TDL_TASKNUMALLOCTO, TDL_TASKALLOCTO, aAllocTo);
}

CXmlItem* CTaskFile::NewItem(LPCTSTR szName)
{
	return new CXmlItem(NULL, szName);
}

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

HTASKITEM CTaskFile::NewTask(const char* szTitle, HTASKITEM hParent, DWORD dwID)
{
	CXmlItem* pXIParent = hParent ? TaskFromHandle(hParent) : Root();

	if (!pXIParent)
	{
		// handle the fact that hParent might already point to Root()
		if (hParent == (HTASKITEM)Root())
			pXIParent = Root();
		else
			return NULL;
	}

	CXmlItem* pXINew = NewItem(TDL_TASK);

	if (pXINew)
	{
		pXIParent->AddItem(pXINew);
		AddTaskToMap(pXINew, FALSE);

		// set ID and name
		SetTaskTitle((HTASKITEM)pXINew, szTitle);

		if (dwID <= 0)
			dwID = m_dwNextUniqueID++;
		else
			m_dwNextUniqueID = max(m_dwNextUniqueID, dwID + 1);

		SetTaskID((HTASKITEM)pXINew, dwID);
	}

	return (HTASKITEM)pXINew;
}

HTASKITEM CTaskFile::NewTask(const char* szTitle, HTASKITEM hParent)
{
	return NewTask(szTitle, hParent, 0); // 0 means 'allocate new ID'
}

HTASKITEM CTaskFile::GetFirstTask(HTASKITEM hParent) const
{
	const CXmlItem* pXIParent = hParent ? TaskFromHandle(hParent) : Root();

	if (!pXIParent)
	{
		// handle the fact that hParent might already point to Root()
		if (hParent == (HTASKITEM)Root())
			pXIParent = Root();
		else
			return NULL;
	}

	return (HTASKITEM)pXIParent->GetItem(TDL_TASK);
}

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

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

const char* CTaskFile::GetTaskTitle(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKTITLE);
}

const char* CTaskFile::GetTaskComments(HTASKITEM hTask) const
{
/*
	CString sComments = GetTaskCChar(hTask, TDL_TASKCOMMENTS);
	sComments.Replace("&#13;&#10;", "\r\n");

	return sComments;
*/
	return GetTaskCChar(hTask, TDL_TASKCOMMENTS);
}

const char* CTaskFile::GetTaskAllocatedTo(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKALLOCTO);
}

const char* CTaskFile::GetTaskAllocatedBy(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKALLOCBY);
}

const char* CTaskFile::GetTaskCategory(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKCATEGORY);
}

unsigned char CTaskFile::GetTaskCategoryCount(HTASKITEM hTask) const
{
	return GetTaskUChar(hTask, TDL_TASKNUMCATEGORY);
}

const char* CTaskFile::GetTaskCategory(HTASKITEM hTask, int nIndex) const
{
	return GetTaskArrayItem(hTask, TDL_TASKNUMCATEGORY, TDL_TASKCATEGORY, nIndex);
}

unsigned char CTaskFile::GetTaskDependencyCount(HTASKITEM hTask) const
{
	return GetTaskUChar(hTask, TDL_TASKNUMDEPENDENCY);
}

const char* CTaskFile::GetTaskDependency(HTASKITEM hTask, int nIndex) const
{
	return GetTaskArrayItem(hTask, TDL_TASKNUMDEPENDENCY, TDL_TASKDEPENDENCY, nIndex);
}

unsigned char CTaskFile::GetTaskAllocatedToCount(HTASKITEM hTask) const
{
	return GetTaskUChar(hTask, TDL_TASKNUMALLOCTO);
}

const char* CTaskFile::GetTaskAllocatedTo(HTASKITEM hTask, int nIndex) const
{
	return GetTaskArrayItem(hTask, TDL_TASKNUMALLOCTO, TDL_TASKALLOCTO, nIndex);
}

const char* CTaskFile::GetTaskDependency(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKDEPENDENCY);
}

const char* CTaskFile::GetTaskStatus(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKSTATUS);
}

const char* CTaskFile::GetTaskFileReferencePath(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKFILEREFPATH);
}

const char* CTaskFile::GetTaskCreatedBy(HTASKITEM hTask) const
{
	return GetTaskCChar(hTask, TDL_TASKCREATEDBY);
}

unsigned long CTaskFile::GetTaskID(HTASKITEM hTask) const
{
	return GetTaskULong(hTask, TDL_TASKID);
}

bool CTaskFile::IsTaskFlagged(HTASKITEM hTask) const
{
	return (GetTaskUChar(hTask, TDL_TASKFLAG) > 0);
}

unsigned long CTaskFile::GetTaskColor(HTASKITEM hTask) const
{
	return GetTaskULong(hTask, TDL_TASKCOLOR);
}

const char* CTaskFile::GetTaskWebColor(HTASKITEM hTask) const
{
	DWORD color = 0;

	if (TaskHasAttribute(hTask, TDL_TASKTEXTCOLOR))
		color = GetTaskULong(hTask, TDL_TASKTEXTCOLOR);
	else
		color = GetTaskULong(hTask, TDL_TASKCOLOR);
	
	return GetWebColor((COLORREF)color);
}

const char* CTaskFile::GetTaskPriorityWebColor(HTASKITEM hTask) const
{
	return GetWebColor(GetTaskPriorityColor(hTask));
}

unsigned long CTaskFile::GetTaskPriorityColor(HTASKITEM hTask) const
{
	DWORD color = RGB(255, 255, 255);

	if (TaskHasAttribute(hTask, TDL_TASKPRIORITYCOLOR))
		color = GetTaskULong(hTask, TDL_TASKPRIORITYCOLOR);
1234

taskfile.cpp - 源码说明

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

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

⌨️ 快捷键说明

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