.#task.c.1.29

个人日程管理系统

	while (TaskGetLevel(dbP, index) > gRefLevel + 1)
	{
		index = TaskGetFatherIndex(dbP, index);
		if (!TaskIsOpened(dbP, index))
			TaskSetOpened(dbP, index, true);
	}
} // void TaskMakeVisible(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskToggleIsOpened
 * Desc : toggle isOpened flag
 * Parm : 
 * 			-> db to search
 * 			-> index of the record
 * Out  : 
 * Auth : lb, 01.08.2000
 * Mod  : lb, 22.08.2000
 * 			new preferences scheme
 ***************************************************************************/
pgErr TaskToggleIsOpened(DmOpenRef dbP, UInt16 index)
{
	TaskAttrType attr;

	DBGMSG((DBB, "TaskToggleIsOpened"));

	attr = TaskGetAttr(dbP, index);
	attr.opened = !attr.opened;
	TaskSetAttr(dbP, index, attr);
	return pgOK;
} // pgErr TaskToggleIsOpened(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskSetOpened
 * Desc : set isOpened flag
 * Parm : 
 * 			-> db to search
 * 			-> index of the record
 * Out  : 
 * Auth : lb, 04.08.2000
 * Mod  : lb, 22.08.2000
 * 			new preferences scheme
 * Rem  : bad err handling
 * TODO : better error handling
 ***************************************************************************/
pgErr TaskSetOpened(DmOpenRef dbP, UInt16 index, Boolean value)
{
	TaskAttrType attr;

	DBGMSG((DBB, "TaskSetOpened"));

	attr = TaskGetAttr(dbP, index);
	attr.opened = value;
	TaskSetAttr(dbP, index, attr);

	return pgOK;
} // pgErr TaskSetOpened(DmOpenRef dbP, UInt16 index, Boolean value)



/****************************************************************************
 * Name : TaskGetFatherIndex
 * Desc : get the father of a task
 * Parm : 
 * 			-> db to search
 * 			-> index of the record
 * Out  : father, dmMaxRecordIndex if not found
 * Auth : lb, 28.07.2000
 * Rem  : bad err handling
 * TODO : better error handling
 ***************************************************************************/
UInt16 TaskGetFatherIndex(DmOpenRef dbP, UInt16 index)
{
	UInt16 prev = 0;
	UInt16 sindex;
	UInt8 level;

	DBGMSG((DBB, "TaskGetFatherIndex"));

	level = TaskGetLevel(dbP, index);

	// top level tasks have no father
	if (level == FIRST_LEVEL)
		return prev;

	sindex = index - 1;

	while (sindex < index)
	{
		if (TaskGetLevel(dbP, sindex) == level - 1)
		{
			prev = sindex;
			break;
		}
		sindex--;
	}
	return prev;
} // UInt16 TaskGetFatherIndex(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskGetPrevIndex
 * Desc : get the previous of a task
 * Parm : 
 * 			-> db to search
 * 			-> index of the record
 * Out  : previous, dmMaxRecordIndex if not found
 * Auth : lb, 27.07.2000
 * Rem  : bad err handling
 * TODO : better error handling
 ***************************************************************************/
UInt16 TaskGetPrevIndex(DmOpenRef dbP, UInt16 index)
{
	UInt16 prev = dmMaxRecordIndex;
	UInt16 sindex;
	UInt8  level;
	UInt8  actLevel;

	DBGMSG((DBB, "TaskGetPrevIndex"));

	if (!TaskGetHasPrev(dbP, index))
		return prev;

	level = TaskGetLevel(dbP, index);
	sindex = index - 1;

	while (sindex < index)
	{
		// get level of item sindex
		actLevel = TaskGetLevel(dbP, sindex);

		// if it's the same, we found
		if (actLevel == level)
		{
			prev = sindex;
			break;
		}

		// if it's less, there's no previous
		if (actLevel < level)
		{
			break;
		}
		sindex--;
	}
	return prev;
} // UInt16 TaskGetPrevIndex(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskGetPrevIndexByLevel
 * Desc : get the previous of same level from index
 * Parm : 
 * 			-> db to search
 * 			-> index of the record
 * 			-> level to search for
 * Out  : previous, dmMaxRecordIndex if not found
 * Auth : lb, 31.07.2000
 * Rem  : bad err handling
 * TODO : better error handling
 ***************************************************************************/
UInt16 TaskGetPrevIndexByLevel(DmOpenRef dbP, UInt16 index, UInt8 level)
{
	UInt16 prev = dmMaxRecordIndex;
	UInt16 sindex = index - 1;
	UInt8  actLevel;

	DBGMSG((DBB, "TaskGetPrevIndexByLevel"));

	// cannot search before first item
	if (index == FIRST_INDEX)
		return prev;

	// search all preceding items
	while (sindex < index)
	{
		// get level of item sindex
		actLevel = TaskGetLevel(dbP, sindex);

		// if it's the same, we found
		if (actLevel == level)
		{
			prev = sindex;
			break;
		}

		// if it's less, there's no previous
		if (actLevel < level)
		{
			break;
		}
		sindex--;
	}

	return prev;
} // UInt16 TaskGetPrevIndexByLevel(DmOpenRef dbP, UInt16 index, UInt8 level)



/****************************************************************************
 * Name : TaskGetNextIndex
 * Desc : get the next of a task
 * Parm : 
 * 			-> index of the record
 * Out  : next, 0 if not found
 * Auth : lb, 27.07.2000
 * Mod  : 01.08.2000
 * 			corrected bug that found a next in other branchs
 * Rem  : bad err handling
 * TODO : better error handling
 ***************************************************************************/
UInt16 TaskGetNextIndex(DmOpenRef dbP, UInt16 index)
{
	UInt16 next = 0, lastRecord = PgNumRecords(dbP);
	UInt8 level;
	UInt8 actLevel;

	DBGMSG((DBB, "TaskGetNextIndex"));

	level = TaskGetLevel(dbP, index);
	index++;

	while (index < lastRecord)
	{
		actLevel = TaskGetLevel(dbP, index);
		if (actLevel == level)
		{
			next = index;
			break;
		}

		if (actLevel < level)
		{
			break;
		}
		index++;
	}
	return next;
} // UInt16 TaskGetNextIndex(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskGetNextRelativeIndex
 * Desc : get the next of a task, may be the next of a father (TODO be clearer...)
 * Parm : 
 * 			-> index of the record
 * Out  : next, 0 if not found
 * Auth : lb, 01.08.2000
 * Mod  : lb, 09.08.2000
 * 			- adding support for subtree viewing
 * 		  lb, 28.09.2000
 * 		  	- return index if index = dmMaxRecordIndex
 * Rem  : bad err handling
 * TODO : better error handling
 ***************************************************************************/
UInt16 TaskGetNextRelativeIndex(DmOpenRef dbP, UInt16 index)
{
	UInt16 next = 0, lastRecord = PgNumRecords(dbP);
	UInt8 level;
	UInt8 actLevel;

	DBGMSG((DBB, "TaskGetNextRelativeIndex"));

	if (lastRecord == 0)
		return next;
	
	if (index == dmMaxRecordIndex)
		return index;

	level = TaskGetLevel(dbP, index);
	index++;

	while (index < lastRecord)
	{
		actLevel = TaskGetLevel(dbP, index);
		//if (actLevel <= level && actLevel >= gRefLevel)
		if (actLevel <= level)
		{
			next = index;
			break;
		}

		index++;
	}
	return next;
} // UInt16 TaskGetNextRelativeIndex(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskGetType
 * Desc : get the type of a task
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * Out  : ItemType type
 * Auth : lb, 2001-09-06
 ***************************************************************************/
ItemType TaskGetType(DmOpenRef dbP, UInt16 index)
{
	DBGMSG((DBB, "TaskGetType"));

	return TaskGetFormat(dbP, index).itemType;
} // ItemType TaskGetType(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskSetType
 * Desc : set the type of a task
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * 			-> type
 * Out  : 
 * Auth : lb, 2001-09-06
 * Rem  : Replaces TaskSetActionState, which was good at the time there were
 * 		  only progress and action types...
 * Mod	: lb, 2001-11-25
 * 		  	adapt to 0.23 db format
 ***************************************************************************/
pgErr TaskSetType(DmOpenRef dbP, UInt16 index, ItemType type)
{
	UInt8 completed;
	TaskFormatType format;
	MemHandle h;
	TaskExtendedRecordType *p;

	DBGMSG((DBB, "TaskSetType"));

	h = DmGetRecord(dbP, index);
	p = MemHandleLock(h);
	completed = StdFields(p)->completed;
	format = p->format.bits;

	// convert the completed value when needed
	switch (type)
	{
		case actionType:
			if (completed != 10)
				completed = 0;
			break;
		case informativeType:
			completed = 0;
			break;
		default:
			break;
	}

	format.itemType = type;

	DmWrite(p, StdFieldsOffset(p) + OffsetOf(TaskStandardFields, completed), 
		&completed, sizeof(UInt8));
	DmWrite(p, OffsetOf(TaskRecordType, format), &format, 
		sizeof(TaskFormatType));
	MemHandleUnlock(h);
	DmReleaseRecord(dbP, index, true);
	return pgOK;
} // pgErr TaskSetType(DmOpenRef dbP, UInt16 index, ItemType type)



/****************************************************************************
 * Name : TaskGetCompleted
 * Desc : get completed value of a task
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * Out  : 
 * Auth : lb, 04.08.2000
 * Mod	: lb, 2001-09-09
 * 		  	adapt to 0.23 db format
 ***************************************************************************/
UInt8 TaskGetCompleted(DmOpenRef dbP, UInt16 index)
{
	MemHandle h;
	TaskExtendedRecordType *p;
	UInt8 value;

	DBGMSG((DBB, "TaskGetCompleted"));

	h = DmQueryRecord(dbP, index);
	p = MemHandleLock(h);
	value = StdFields(p)->completed;
	MemHandleUnlock(h);
	return value;
} // UInt8 TaskGetCompleted(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskSetCompleted
 * Desc : set completed value of a task
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * 			-> value
 * 			-> need to set the dirty bit ?
 * Out  : 
 * Auth : lb, 04.08.2000
 * Mod  : lb, 08.05.2001
 * 			- don't change the task's type
 * 			- adapt to ACTION type
 * 			=> same day : was a very bad idea, undo
 * Mod	: lb, 2001-09-09
 * 		  	adapt to 0.23 db format
 * 		  lb, 2002-01-21
 * 		  	added dirty param, because TaskCalcCompleted must not set dirty
 ***************************************************************************/
pgErr TaskSetCompleted(DmOpenRef dbP, UInt16 index, UInt8 value, Boolean dirty)
{
	MemHandle h;
	TaskExtendedRecordType *p;

	DBGMSG((DBB, "TaskSetCompleted"));

	h = DmGetRecord(dbP, index);
	p = MemHandleLock(h);
	DmWrite(p, StdFieldsOffset(p) + OffsetOf(TaskStandardFields, completed), 
		&value, sizeof(UInt8));
	MemHandleUnlock(h);
	DmReleaseRecord(dbP, index, dirty);
	return pgOK;
} // pgErr TaskSetCompleted(DmOpenRef dbP, UInt16 index, UInt8 value, 
  // Boolean dirty)



/****************************************************************************
 * Name : TaskGetIsDone
 * Desc : true if the task is 100% done or ACTION_OK
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * Out  : true if the task is 100% done or ACTION_OK
 * Auth : lb, 09.08.2000
 * Rem  : bad err handling
 * Mod	: lb, 2001-09-06
 * 		  	adapt to 0.23 db format
 ***************************************************************************/
Boolean TaskGetIsDone(DmOpenRef dbP, UInt16 index)
{
	DBGMSG((DBB, "TaskGetIsDone"));

	return (TaskGetCompleted(dbP, index) == 10);
} // Boolean TaskGetIsDone(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskGetActionState
 * Desc : get action state of a task
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * Out  : action status
 * Auth : lb, 03.08.2000
 * Rem  : bad err handling
 * TODO : better error handling
 * Mod  : lb, 2001-08-23
 * 			adapted for info types
 ***************************************************************************/
Boolean TaskGetActionState(DmOpenRef dbP, UInt16 index)
{
	DBGMSG((DBB, "TaskSetActionState"));

	return TaskGetFormat(dbP, index).itemType == actionType;
} // Boolean TaskGetActionState(DmOpenRef dbP, UInt16 index)



/****************************************************************************
 * Name : TaskSetDueDate
 * Desc : set the due date of a task
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * 			-> date
 * Out  : 
 * Auth : lb, 06.08.2000
 * Mod	: lb, 2001-09-09
 * 		  	adapt to 0.23 db format
 ***************************************************************************/
pgErr TaskSetDueDate(DmOpenRef dbP, UInt16 index, DateType date)
{
	MemHandle h;
	TaskExtendedRecordType *p;

	DBGMSG((DBB, "TaskSetDueDate"));

	h = DmGetRecord(dbP, index);
	if (h)
	{
		p = MemHandleLock(h);
		if (p)
			DmWrite(p, 
				StdFieldsOffset(p) + OffsetOf(TaskStandardFields, dueDate), 
				&date, sizeof(DateType));
		MemHandleUnlock(h);
	}

	DmReleaseRecord(dbP, index, true);
	return pgOK;
} // pgErr TaskSetDueDate(DmOpenRef dbP, UInt16 index, DateType date)



/****************************************************************************
 * Name : TaskGetDueDate
 * Desc : get the due date of a task
 * Parm : 
 * 			-> database pointer
 * 			-> index of the record
 * Out  : 
 * Auth : lb, 03.08.2000