📄 site.cpp.svn-base

📁 wince c++ 下开发的 rss 阅读器源代码
💻 SVN-BASE
📖 第 1 页 / 共 2 页
字号:
上一页 12
		while (pos != NULL) {
			CSiteItem *si = SubItems.GetNext(pos);
			sites.AddTail(si);
		}
	}
}


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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSiteList::CSiteList() {
	Root = NULL;
}

CSiteList::~CSiteList() {
}

void CSiteList::Detach() {
	Root = NULL;
	Data.RemoveAll();
}

void CSiteList::Destroy() {
	LOG0(5, "CSiteList::Destroy()");

	if (Root != NULL) {
		Root->Destroy();
		delete Root; Root = NULL;
	}

	Data.RemoveAll();
}

/*void CSiteList::SetKeywords(CStringArray &kws) {
	Keywords.RemoveAll();

	for (int i = 0; i < kws.GetSize(); i++)
		Keywords.Add(kws.GetAt(i));
}
*/

void CSiteList::CreateFrom(CSiteItem *root) {
	if (root == NULL)
		return;

	if (root->Type == CSiteItem::Site) {
		Data.Add(root);
	}
	else if (root->Type == CSiteItem::Group) {
		POSITION pos = root->SubItems.GetHeadPosition();
		while (pos != NULL) {
			CSiteItem *si = root->SubItems.GetNext(pos);
			CreateFrom(si);
		}
	}
}

int CSiteList::GetIndexOf(CSiteItem *item) {
	for (int i = 0; i < Data.GetSize(); i++)
		if (Data[i] == item)
			return i;
	return SITE_INVALID;
}

int CSiteList::GetCount() {
	return Data.GetSize();
}

CSiteItem *CSiteList::GetAt(int i) {
	if (i >= 0 && i < Data.GetSize())
		return Data.GetAt(i);
	else
		return NULL;
}

void CSiteList::SetRoot(CSiteItem *root) {
	Root = root;
}

// Save ///////

#if defined PRSSR_APP

BOOL SaveSiteItem(CSiteItem *item, int idx) {
	LOG2(5, "SaveSiteItem(%p, %d)", item, idx);

	if (item == NULL) return TRUE;

	CString sRegPath;
	sRegPath.Format(_T("%s\\%d"), REG_KEY_SUBSCRIPTIONS, idx + 1);

	CRegistry::DeleteKey(HKEY_CURRENT_USER, sRegPath);
	CRegistry reg(HKEY_CURRENT_USER, sRegPath);

	reg.Write(szName, item->Name);
	if (item->Type == CSiteItem::Site && item->Info != NULL) {
		reg.Write(szFileName, item->Info->FileName);
		reg.Write(szXmlUrl, item->Info->XmlUrl);
		reg.Write(szTodayShow, item->Info->TodayShow);
		reg.Write(szUseGlobalCacheOptions, item->Info->UseGlobalCacheOptions);
		reg.Write(szCacheItemImages, item->Info->CacheItemImages);
		reg.Write(szCacheHtml, item->Info->CacheHtml);
		reg.Write(szCacheLimit, item->Info->CacheLimit);
		reg.Write(szUpdateInterval, item->Info->UpdateInterval);
		reg.Write(szCacheEnclosures, item->Info->CacheEnclosures);
		reg.Write(szEnclosureLimit, item->Info->EnclosureLimit);
		reg.Write(szETag, item->Info->ETag);
		reg.Write(szLastModified, item->Info->LastModified);
		reg.Write(szUserName, item->Info->UserName);
		reg.Write(szPassword, item->Info->Password);
	}

	reg.Write(szCheckFavIcon, item->CheckFavIcon);

	switch (item->Sort.Item) {
		case CSortInfo::Date: reg.Write(szSort, _T("date")); break;
		case CSortInfo::Read: reg.Write(szSort, _T("read")); break;
	}

	if (item->Sort.Type == CSortInfo::Ascending)
		reg.Write(szSortReversed, FALSE);
	else
		reg.Write(szSortReversed, TRUE);

	return TRUE;
}

BOOL SaveSiteItemUnreadCount(CSiteItem *item, int idx) {
	LOG2(5, "SaveSiteItemUnreadCount(%p, %d)", item, idx);

	if (item == NULL)
		return TRUE;

	if (item->Type == CSiteItem::Site) {
		CString sRegPath;
		sRegPath.Format(_T("%s\\%d"), REG_KEY_SUBSCRIPTIONS, idx + 1);

		CRegistry reg(HKEY_CURRENT_USER, sRegPath);
		reg.Write(szUnreadCount, item->GetUnreadCount());
	}

	return TRUE;
}

BOOL SaveSiteItemFlaggedCount(CSiteItem *item, int idx) {
	LOG2(5, "SaveSiteItemFlaggedCount(%p, %d)", item, idx);

	if (item == NULL)
		return TRUE;

	if (item->Type == CSiteItem::Site) {
		CString sRegPath;
		sRegPath.Format(_T("%s\\%d"), REG_KEY_SUBSCRIPTIONS, idx + 1);

		CRegistry reg(HKEY_CURRENT_USER, sRegPath);
		reg.Write(szFlaggedCount, item->GetFlaggedCount());
	}

	return TRUE;
}

BOOL SaveSiteGroup(CSiteItem *item, CRegistry &reg) {
	LOG1(5, "SaveSiteGroup(%p)", item);

	// save sub items
	int k = 1;

	POSITION pos = item->SubItems.GetHeadPosition();
	while (pos != NULL) {
		CSiteItem *si = item->SubItems.GetNext(pos);

		CString sNum;
		sNum.Format(_T("%d"), k);
		CRegistry regItem(reg, sNum);
		SaveSiteGroup(si, regItem);

		k++;
	}

	// save item itself
	if (item->Type == CSiteItem::Site) {
		reg.Write(szIdx, SiteList.GetIndexOf(item));
	}
	else if (item->Type == CSiteItem::Group) {
		reg.Write(szName, item->Name);
	}

	return TRUE;
}

BOOL SaveSiteList() {
	LOG0(3, "SaveSiteList()");

	// sites
	CRegistry::DeleteKey(HKEY_CURRENT_USER, REG_KEY_SUBSCRIPTIONS);
	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_SUBSCRIPTIONS);
	for (int i = 0; i < SiteList.GetCount(); i++) {
		CSiteItem *item = SiteList.GetAt(i);
		SaveSiteItem(item, i);
		SaveSiteItemUnreadCount(item, i);
		SaveSiteItemFlaggedCount(item, i);
	}

	// save hierarchy
	CRegistry::DeleteKey(HKEY_CURRENT_USER, REG_KEY_GROUPS);
	CRegistry regGroups(HKEY_CURRENT_USER, REG_KEY_GROUPS);
	SaveSiteGroup(SiteList.GetRoot(), regGroups);

	return TRUE;
}


#endif

// Load //////////

BOOL LoadSiteGroup(CSiteItem *item, CRegistry &reg, CArray<CSiteItem*, CSiteItem*> &sites) {
	LOG1(5, "LoadSiteGroup(%p, ,)", item);

	// load sub items
	DWORD cSubKeys;
	reg.QuerySubKeyNumber(&cSubKeys);
	for (DWORD k = 1; k <= cSubKeys; k++) {
		CString sNum;
		sNum.Format(_T("%d"), k);
		CRegistry regItem(reg, sNum);

		CString name = regItem.Read(szName, _T(""));
		int idx = regItem.Read(szIdx, -1);

		CSiteItem *si = NULL;
		if (idx == -1) {
			si = new CSiteItem(item, CSiteItem::Group);
			si->Name = name;
			item->AddItem(si);

			LoadSiteGroup(si, regItem, sites);
		}
		else {
			sites[idx]->Parent = item;
			item->AddItem(sites[idx]);
		}
	}

	return TRUE;
}


BOOL LoadSiteItem(CSiteItem *item, int idx) {
	LOG2(5, "LoadSiteItem(%p, %d)", item, idx);

	CString sRegPath;
	sRegPath.Format(_T("%s\\%d"), REG_KEY_SUBSCRIPTIONS, idx);

	CRegistry reg(HKEY_CURRENT_USER, sRegPath);

	item->Name = reg.Read(szName, _T(""));
	if (item->Type == CSiteItem::Site) {
		CFeedInfo *info = new CFeedInfo();

		info->FileName = reg.Read(szFileName, _T(""));
		info->XmlUrl = reg.Read(szXmlUrl, _T(""));
		info->TodayShow = reg.Read(szTodayShow, TRUE);
#ifdef PRSSR_APP
		info->UseGlobalCacheOptions = reg.Read(szUseGlobalCacheOptions, TRUE);
		info->CacheItemImages = reg.Read(szCacheItemImages, FALSE);
		info->CacheHtml = reg.Read(szCacheHtml, FALSE);
		info->CacheLimit = reg.Read(szCacheLimit, CACHE_LIMIT_DEFAULT);
		info->UpdateInterval = reg.Read(szUpdateInterval, UPDATE_INTERVAL_GLOBAL);
		info->CacheEnclosures = reg.Read(szCacheEnclosures, FALSE);
		info->EnclosureLimit = reg.Read(szEnclosureLimit, 0);
		info->ETag = reg.Read(szETag, _T(""));
		info->LastModified = reg.Read(szLastModified, _T(""));
		info->UserName = reg.Read(szUserName, _T(""));
		info->Password = reg.Read(szPassword, _T(""));

		CString sortItem = reg.Read(szSort, _T(""));
		if (sortItem.CompareNoCase(_T("read")) == 0)
			item->Sort.Item = CSortInfo::Read;
		else
			item->Sort.Item = CSortInfo::Date;

		BOOL sortReversed = reg.Read(szSortReversed, FALSE);
		if (sortReversed)
			item->Sort.Type = CSortInfo::Descending;
		else
			item->Sort.Type = CSortInfo::Ascending;

		//
		item->CheckFavIcon = reg.Read(szCheckFavIcon, TRUE);
#endif
		item->Info = info;
		item->Feed = NULL;
		item->Status = CSiteItem::Empty;
	}

	return TRUE;
}

BOOL LoadSiteItemUnreadCount(CSiteItem *item, int idx) {
	LOG2(5, "LoadSiteItemUnreadCount(%p, %d)", item, idx);

	if (item->Type == CSiteItem::Site) {
		CString sRegPath;
		sRegPath.Format(_T("%s\\%d"), REG_KEY_SUBSCRIPTIONS, idx);

		CRegistry reg(HKEY_CURRENT_USER, sRegPath);
		item->UnreadItems = reg.Read(szUnreadCount, 0);
	}

	return TRUE;
}

BOOL LoadSiteItemFlaggedCount(CSiteItem *item, int idx) {
	LOG2(5, "LoadSiteItemFlaggedCount(%p, %d)", item, idx);

	if (item->Type == CSiteItem::Site) {
		CString sRegPath;
		sRegPath.Format(_T("%s\\%d"), REG_KEY_SUBSCRIPTIONS, idx);

		CRegistry reg(HKEY_CURRENT_USER, sRegPath);
		item->FlaggedItems = reg.Read(szFlaggedCount, 0);
	}

	return TRUE;
}

int LoadSiteList(CSiteList &siteList) {
	LOG0(3, "LoadSiteList()");

	CSiteItem *rootItem = new CSiteItem(NULL, CSiteItem::Group);

	// read sites
	DWORD cSites;

	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_SUBSCRIPTIONS);
	reg.QuerySubKeyNumber(&cSites);

	CArray<CSiteItem*, CSiteItem*> sites;
	if (cSites > 0) {
		sites.SetSize(cSites);
		for (DWORD i = 1; i <= cSites; i++) {
			CSiteItem *item = new CSiteItem(NULL, CSiteItem::Site);
			LoadSiteItem(item, i);
			LoadSiteItemUnreadCount(item, i);
			LoadSiteItemFlaggedCount(item, i);
			sites.SetAt(i - 1, item);
		}

		// read hierarchy
		CRegistry regGroup(HKEY_CURRENT_USER, REG_KEY_GROUPS);
		LoadSiteGroup(rootItem, regGroup, sites);
	}

	//
	siteList.CreateFrom(rootItem);
	siteList.SetRoot(rootItem);
//	siteList.SetKeywords(keywords);

	return 0;
}
上一页 12
⌨️ 快捷键说明

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