agendaview.cpp

手机文件浏览器 Here are the sources to SMan v1.2c 1.2 is a major jump from v1.1. You will see this from the

	// There must be an easier way than making 3 function calls. :( Anyway, this is to ensure the hotkey
	// does not activate while the calendar is visible
	Window().SetFaded(ETrue, RWindowTreeNode::EFadeIncludeChildren);
	CEikonEnv::Static()->AppUiFactory()->MenuBar()->DrawableWindow()->SetFaded(ETrue, RWindowTreeNode::EFadeIncludeChildren);
	CEikonEnv::Static()->AppUiFactory()->ToolBar()->DrawableWindow()->SetFaded(ETrue, RWindowTreeNode::EFadeIncludeChildren);
	
	calendar->ExecuteLD();
	Window().SetFaded(EFalse, RWindowTreeNode::EFadeIncludeChildren);
	CEikonEnv::Static()->AppUiFactory()->MenuBar()->DrawableWindow()->SetFaded(EFalse, RWindowTreeNode::EFadeIncludeChildren);
	CEikonEnv::Static()->AppUiFactory()->ToolBar()->DrawableWindow()->SetFaded(EFalse, RWindowTreeNode::EFadeIncludeChildren);
	ReadAgenda(ETrue);
}

void CSMan2AgendaView::SetZoomLevel(TInt zoomLevel)
{
	generateZoomFont(zoomLevel);
	((CTextListItemDrawer*)cHierListBox->View()->ItemDrawer())->SetFont(font);
	cHierListBox->SetItemHeightL(font->HeightInPixels() + cHierListBox->VerticalInterItemGap());
	configData->zoomAgenda = zoomLevel;
	releaseFont();	
}

/*************************************************************
*
* Item drawer
*
**************************************************************/

CHierItemDrawer::CHierItemDrawer(CHierModel* aModel, const CFont* aFont, CArrayPtrFlat<CGulIcon>* aBitmaps) 
: CHierarchicalListItemDrawer(aModel, aFont, aBitmaps)
{
}

CGulIcon* CHierItemDrawer::ItemIcon(TInt aItemIndex) const
{
	if ((!iIconArray) || (aItemIndex <= -1) || (aItemIndex >= iModel->NumberOfItems()))
		return NULL;

	TInt bitmapIndex;

	if (iModel->Item(aItemIndex)->Level() == 2)
	{
		if (aItemIndex >= fullHierModel->NumberOfItems())
			bitmapIndex = 2;
		else
		{
			if (((CHListItem*)(fullHierModel->Item(aItemIndex)))->iComplete)
				bitmapIndex = 3;
			else
				bitmapIndex = 2;
		}
	}
	else
	{
		if (iModel->Item(aItemIndex)->IsExpanded())
			bitmapIndex = 1;
		else
			bitmapIndex = 0;
	}
	return (*iIconArray)[bitmapIndex];
}

/*************************************************************
*
* Listbox model
*
**************************************************************/

void CHierModel::ExpandItemL(TInt aItemIndex)
{
	CHListItem* itemToBeExpanded = (CHListItem*)Item(aItemIndex);
	if (itemToBeExpanded->Level() < 2)
	{
		if (itemToBeExpanded->IsExpanded())
			return;
		else
		{
			itemToBeExpanded->SetExpanded();

			// Build all child items for this item
			CArrayFix<TInt>* childItems;
			childItems = new (ELeave) CArrayFixSeg<TInt>(2);
			fullHierModel->GetChildrenIndexesL(itemToBeExpanded->iFullHierListModelIndex, childItems);
			CHListItem *listItem;
			for (int i = childItems->Count() - 1; i >= 0; i--)
			{
				listItem = new (ELeave) CHListItem(0);
				listItem->SetTextL(fullHierModel->ItemText(childItems->At(i)));
				listItem->iFullHierListModelIndex = childItems->At(i);
				AddItemL(listItem, aItemIndex, KEikHierListInsertAsFirstSibling);
			}
			delete childItems;
		}
	}
}

/*************************************************************
*
* Agenda file reader
*
**************************************************************/

CAgendaFileReader::CAgendaFileReader(CConfig* cData)
{
 	configData = cData;
	iAgnServ = RAgendaServ::NewL();
	User::LeaveIfError(iAgnServ->Connect());
	agnModel = CAgnModel::NewL(this);
	agnModel->SetServer(iAgnServ);
	iDay.HomeTime();
	iDayList = CAgnDayList<TAgnInstanceId>::NewL(iDay.DateTime());
	agendaBusy = EFalse;
	activeSchedulerStarted = EFalse;	
}

CAgendaFileReader::~CAgendaFileReader()
{
	CloseAgendaFile();
	// You must delete the model before closing the server.
	delete agnModel;
	iAgnServ->Close();
	delete iAgnServ;
	delete iDayList;
}

CAgnEntry* CAgendaFileReader::GetOneEntry(TInt aIndex)
{
	TBool fileOk = ETrue;
	
	if (!iAgnServ->FileLoaded())
	{
		if (!activeSchedulerStarted)
		{
			fileOk = OpenAgendaFile();
			if (fileOk)
			{
				activeSchedulerStarted = ETrue;
				CActiveScheduler::Start();
			}
		}
		else
			fileOk = EFalse;
	}
		
	if (fileOk)
	{
		CHListItem *listItem = (CHListItem *)hierListModel->Item(aIndex);
		CAgnEntry *retVal = agnModel->FetchInstanceL((*iDayList)[listItem->iDayListIndex]);
		//Testing CloseAgendaFile();
		return retVal;
	}
	else
		return NULL;
}

TBool CAgendaFileReader::OpenAgendaFile()
{
	CEikonEnv::Static()->BusyMsgL(R_TBUF_AGENDA_BUSY, 0);	

	TRAPD(error, agnModel->OpenL(_L("C:\\DOCUMENTS\\AGENDA\\AGENDA"), TTimeIntervalMinutes(0), 
		TTimeIntervalMinutes(0), TTimeIntervalMinutes(0), this, EFalse));
	
	if (error == KErrNone)
	{
		iAgnServ->WaitUntilLoaded();
		CEikonEnv::Static()->BusyMsgCancel();
		return ETrue;
	}
	else
	{
		CEikonEnv::Static()->BusyMsgCancel();
		HBufC* dataBuffer = CEikonEnv::Static()->AllocReadResourceL(R_TBUF_AGENDA_OPENERROR);
		CEikonEnv::Static()->InfoMsg(*dataBuffer);
		delete dataBuffer;
		CloseAgendaFile();
		return EFalse;
	}
}

void CAgendaFileReader::CloseAgendaFile()
{
	if (iAgnServ->FileLoaded())
		iAgnServ->CloseAgenda();
}

void CAgendaFileReader::ReadDayListL()
{
	// fill the day list
	// filter allows particular types of instance to be excluded/included
	TAgnFilter filter;
	filter.SetIncludeEvents(EFalse);	
	filter.SetIncludeCrossedOutOnly(EFalse);
	filter.SetIncludeAlarmedOnly(EFalse);
	filter.SetIncludeAnnivs(EFalse);
	filter.SetIncludeRptsNextInstanceOnly(EFalse);
	iDayList->Reset();
	iDayList->SetDay(iDay);
	agnModel->PopulateDayInstanceListL(iDayList, filter, iDay);
	// Count() returns the number of instances in the list
	iCount = iDayList->Count();
	if (iCount > 0)
	   	ReadEntriesL();
}

void CAgendaFileReader::ReadEntriesL()
{
	_LIT(KDfagndayFormat,"%-B%:0%J%:1%T%+B");

	TBuf<256> nodeText;

	todoRootOffset = 2;
	//TBool iDayPopulated;
	//TBool doShow;
	TTime currentTime;
	currentTime.HomeTime();
	/*
	if ((currentTime.DateTime().Year() == iDay.DateTime().Year()) &&
		(currentTime.DateTime().Month() == iDay.DateTime().Month()) &&
		(currentTime.DateTime().Day() == iDay.DateTime().Day()))
		iDayPopulated = EFalse;
	else
		iDayPopulated = ETrue;
	*/
	for (TInt ii = iCount; ii > 0; --ii)
	{
		// Get each instance from the list, one at a time in reverse order
		CAgnEntry* entry = agnModel->FetchInstanceL((*iDayList)[ii-1]);
		entry->RichTextL()->Extract(iText, 0, 50);
		switch(entry->Type())
		{
			case CAgnEntry::EAppt:
			{
				CAgnAppt* appt = entry->CastToAppt();
				TTime startTime = appt->InstanceStartDate();
				if (!(configData->agendaShowCompleteCalendar))
				{
					if (appt->InstanceEndDate() < currentTime)
						break;
				}
				/*
				if (!iDayPopulated)
				{
					if (!(configData->agendaShowCompleteCalendar))
					{
						if (appt->InstanceEndDate() < currentTime)
							doShow = EFalse;
					}
				}
				*/
				TBuf<30> timeString;
				startTime.FormatL(timeString, KDfagndayFormat);
				
				CHListItem *listItem;
				listItem = new (ELeave) CHListItem(0);
				if (appt->InstanceEndDate() < currentTime)
					listItem->iComplete = ETrue;
				else
					listItem->iComplete = EFalse;
				nodeText.Copy(timeString);
				nodeText.Append(_L(" "));
				nodeText.Append(iText);
				
				listItem->SetTextL(nodeText);
				listItem->iDayListIndex = ii - 1;
				hierListModel->AddItemL(listItem, 1, KEikHierListInsertAsFirstSibling);
				todoRootOffset++;
				break;
			}
			case CAgnEntry::ETodo: 
			{
				CAgnTodo* todo = entry->CastToTodo();

				if (!configData->agendaShowCompleteTodo)
				{
					if (todo->CrossedOutDate() != Time::NullTTime())
						break;
				}

				CHListItem *listItem;
				listItem = new (ELeave) CHListItem(0);				
				if (todo->CrossedOutDate() != Time::NullTTime())
					listItem->iComplete = ETrue;
				else
					listItem->iComplete = EFalse;
				
				nodeText.Copy(iText);				
				listItem->SetTextL(nodeText);
				listItem->iDayListIndex = ii - 1;
				hierListModel->AddItemL(listItem, todoRootOffset, KEikHierListInsertAsFirstSibling);
				break;
			}
			default: break;
		}
		delete entry;					
	}
}

void CAgendaFileReader::ExecuteL(CHierarchicalListBoxModel *hlModel)
{
	hierListModel = hlModel;

	if (!activeSchedulerStarted)
	{
		if (iAgnServ->FileLoaded())
		{
			ReadDayListL();
		}
		else
		{
			if (OpenAgendaFile())
			{
				activeSchedulerStarted = ETrue;
				CActiveScheduler::Start();
				ReadDayListL();
			}
		}
	}

/*
	if (!agendaBusy)
	{
		agendaBusy = ETrue;
		if (iAgnServ->FileLoaded())
		{
			ReadDayListL();
		}
		else if (!activeSchedulerStarted)
		{
			if (OpenAgendaFile())
			{
				activeSchedulerStarted = ETrue;
				CActiveScheduler::Start();
				ReadDayListL();
			}
		}
		agendaBusy = EFalse;
	}
*/
}

// Rightfully, these should be owned by a view.
void CAgendaFileReader::Completed(TInt aError) 
{ 
	if (aError != KErrNone)
	{
		TBuf<10> errNum;
		errNum.Format(_L("%d"), aError);
		HBufC* dataBuffer = CEikonEnv::Static()->AllocReadResourceL(R_TBUF_AGENDA_OPERR);
		dataBuffer = dataBuffer->ReAllocL(dataBuffer->Length() + 11);
		dataBuffer->Des().Append(errNum);
		CEikonEnv::Static()->InfoMsg(*dataBuffer);
	}
}; 

void CAgendaFileReader::StateCallBack(CAgnEntryModel::TState aState) 
{	
	switch (aState)
	{
		case CAgnModel::ENoFile: 
		{
			CEikonEnv::Static()->InfoMsg(R_TBUF_AGENDA_NOFILE);
			if (activeSchedulerStarted)
			{
				CActiveScheduler::Stop();
				activeSchedulerStarted = EFalse;
			}
			break;
		}
		case CAgnModel::EBlocked: 
		{
			break;
		}
		case CAgnModel::EOk: 
		{
			if (activeSchedulerStarted)
			{
				CActiveScheduler::Stop();
				activeSchedulerStarted = EFalse;
			}
			break;
		}
		default: break;
	}
}

void CAgendaFileReader::Progress(TInt /*aPercentageCompleted*/)
{
}

CHListItem::CHListItem(TInt aFlags) : CHierListItem(aFlags)
{
}