config.cpp.svn-base

wince c++ 下 开发的 rss 阅读器源代码

	reg.Write(szHtmlOptimizerURL, HtmlOptimizerURL);
}

void CConfig::Load() {
	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_CONFIGURATION);

	NavigationType = reg.Read(szNavigationType, CONFIG_DEFAULT_NAVIGATION_TYPE);

	// cache
	CacheLocation = reg.Read(szCacheLocation, _T("\\My Documents\\pRSSreader"));
	CacheLimit = reg.Read(szCacheLimit, CONFIG_DEFAULT_CACHE_LIMIT);

	// general
	NotifyNew = reg.Read(szNotifyNew, CONFIG_DEFAULT_NOTIFYNEW);
	WrapTitles = reg.Read(szWrapTitles, CONFIG_DEFAULT_WRAPTITLES);
	ShowRelativeDates = reg.Read(szShowRelativeDates, CONFIG_DEFAULT_SHOWRELATIVEDATES);
	MoveToUnread = reg.Read(szMoveToUnread, CONFIG_DEFAULT_MOVETOUNREAD);
	EmailAccount = reg.Read(szEmailAccount, CONFIG_DEFAULT_EMAIL_ACCOUNT);
	GroupByFeed = reg.Read(szGroupByFeed, CONFIG_DEFAULT_GROUP_BY_FEED);

	// retrieve
	UpdateInterval = reg.Read(szUpdateInterval, CONFIG_DEFAULT_UPDATEINTERVAL);

	//
	TimeUpdate = reg.Read(szTimeUpdate, CONFIG_DEFAULT_TIME_UPDATE);
	SYSTEMTIME tm;
	if (reg.Read(szUpdateAtTime, &tm, sizeof(tm)))
		UpdateAtTime = tm;
	else {
		UpdateAtTime.wHour = 8;
		UpdateAtTime.wMinute = 0;
		UpdateAtTime.wSecond = 0;
	}

	AutoConnect = reg.Read(szAutoConnect, CONFIG_DEFAULT_AUTOCONNECT);
	UseConnManager = reg.Read(szUseConnMan, CONFIG_DEFAULT_USE_CONN_MANAGER);
	CheckOnCradling = reg.Read(szCheckOnCradling, CONFIG_DEFAULT_CHECKONCRADLING);
	ClearErrorLog = reg.Read(szClearErrorLog, CONFIG_DEFAULT_CLEARERRORLOG);
	CString ua = reg.Read(szUserAgent, UserAgent);
	UserAgent = ua;

	// global caching options
	CacheImages = reg.Read(szCacheImages, CONFIG_DEFAULT_CACHE_IMAGES);
	CacheHtml = reg.Read(szCacheHtml, CONFIG_DEFAULT_CACHE_HTML);

	// sync
	SyncSite = (ESyncSite) reg.Read(szSyncSite, CONFIG_DEFAULT_SYNCSITE);
	SyncUserName = reg.Read(szSyncUserName, _T(""));
	SyncPassword = reg.Read(szSyncPassword, _T(""));

	// enclosures
	GeneratePlaylists = reg.Read(szGeneratePlaylists, CONFIG_DEFAULT_GENERATEPLAYLISTS);
	EnclosurePlaylistFormat = reg.Read(szEnclosurePlaylistFormat, CONFIG_DEFAULT_ENCLOSUREPLAYLISTFORMAT);

	// html optimizer
	UseHtmlOptimizer = reg.Read(szUseHtmlOptimizer, CONFIG_DEFAULT_USE_HTML_OPTIMIZER);
	HtmlOptimizerURL = reg.Read(szHtmlOptimizerURL, _T(""));
	AdvancedHtmlOptimizer = reg.Read(szAdvancedHtmlOptimizer, FALSE);

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

	// TWEAKS ////

	AdditionalHttpHeaders.RemoveAll();
	CString strRawHeaders = reg.Read(szAdditionalHttpHeaders, _T(""));
	int start = 0;
	int nullPos = strRawHeaders.Find((TCHAR) '\0', start);
	while (nullPos != -1 && start < nullPos && start < strRawHeaders.GetLength()) {
		CString strHeader = strRawHeaders.Mid(start, nullPos - start);
		AdditionalHttpHeaders.Add(strHeader);
		start = nullPos + 1;
		nullPos = strRawHeaders.Find((TCHAR) '\0', start);
	}

//	DateFormat = reg.Read(szDateFormat, CONFIG_DEFAULT_DATE_FORMAT);						// custom date format
	DateFormat = reg.Read(szDateFormat, _T(""));						// custom date format
	SearchLimit = reg.Read(szSearchLimit, CONFIG_DEFAULT_SEARCHLIMIT);					// search
	MsgScrollThrought = reg.Read(szMsgScrollThrought, CONFIG_DEFAULT_MSG_SCROLL_THROUGHT);
	MinimalSyncInterval = reg.Read(szMinimalSyncInterval, CONFIG_DEFAULT_MINIMALSYNCINTERVAL);
	SetPropertiesAfterSiteAdded = reg.Read(szSetPropertiesAfterSiteAdded, CONFIG_DEFAULT_SETPROPERTIESAFTERSITEADDED);
	ShowMainToolbar = reg.Read(szShowMainToolbar, CONFIG_DEFAULT_SHOWMAINTOOLBAR);
	CheckCertificates = reg.Read(szCheckCertificates, CONFIG_DEFAULT_CHECKCERTIFICATES);
	Timeout = reg.Read(szTimeout, CONFIG_DEFAULT_TIMEOUT);
	ReportErrorsAfterUpdate = reg.Read(szReportErrorsAfterUpdate, CONFIG_DEFAULT_REPORTERRORSAFTERUPDATE);
	OpenMsgWithHtmlOptimizer = reg.Read(szOpenMsgWithHtmlOptimizer, CONFIG_DEFAULT_OPENMSGWITHHTMLOPTIMIZER);
	HtmlOptAfterUrlRewriting = reg.Read(szHtmlOptAfterUrlRewriting, CONFIG_DEFAULT_HTMLOPTAFTERURLREWRITING);
	BackgroundUpdate = reg.Read(szBackgroundUpdate, CONFIG_DEFAULT_BACKGROUNDUPDATE);
	WrapAround = reg.Read(szWrapAround, CONFIG_DEFAULT_WRAPAROUND);
}

// UI ////

void CConfig::SaveUI() {
	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_UI);

	// main widow
	reg.Write(szActSiteIdx, ActSiteIdx);
	reg.Write(szActFeedItem, ActFeedItem);
	reg.Write(szMainView, MainView);
	reg.Write(szWorkOffline, WorkOffline);
	reg.Write(szHideGroups, HideGroups);
	reg.Write(szHideReadItems, HideReadItems);
	reg.Write(szUpdateOnly, UpdateOnly);
}

void CConfig::LoadUI() {
	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_UI);

	ActSiteIdx = reg.Read(szActSiteIdx, CONFIG_DEFAULT_ACTSITEIDX);
	ActFeedItem = reg.Read(szActFeedItem, -1);
	MainView = reg.Read(szMainView, CONFIG_DEFAULT_MAIN_VIEW);
	WorkOffline = reg.Read(szWorkOffline, CONFIG_DEFAULT_WORK_OFFLINE);
	HideGroups = reg.Read(szHideGroups, CONFIG_DEFAULT_HIDE_GROUPS);
	HideReadItems = reg.Read(szHideReadItems, CONFIG_DEFAULT_HIDE_READ_ITEMS);
	UpdateOnly = reg.Read(szUpdateOnly, CONFIG_DEFAULT_UPDATE_ONLY);
}

// Proxy Profiles ////

void CConfig::SaveProxyProfiles() {
	CRegistry::DeleteKey(HKEY_CURRENT_USER, REG_KEY_PROXY_PROFILES);

	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_PROXY_PROFILES);
	for (int i = 0; i < ProxyProfiles.GetSize(); i++) {
		CString sNum;
		sNum.Format(_T("%d"), i);

		CProxyProfile *profile = ProxyProfiles[i];
		CRegistry regProfile(reg, sNum);
		regProfile.Write(szName, profile->Name);
		regProfile.Write(szType, (DWORD) profile->ProxyConfig.Type);
		regProfile.Write(szHostName, profile->ProxyConfig.HostName);
		regProfile.Write(szPort, profile->ProxyConfig.Port);
		regProfile.Write(szNeedAuth, profile->ProxyConfig.NeedAuth);
		regProfile.Write(szUserName, profile->ProxyConfig.UserName);
		regProfile.Write(szPassword, profile->ProxyConfig.Password);
	}

	reg.Write(szActive, ProxyProfileIdx);
}

void CConfig::LoadProxyProfiles() {
	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_PROXY_PROFILES);

	DWORD cSubKeys = 0;
	reg.QuerySubKeyNumber(&cSubKeys);
	ProxyProfiles.SetSize(cSubKeys);

	for (DWORD i = 0; i < cSubKeys; i++) {
		CString sNum;
		sNum.Format(_T("%d"), i);

		CRegistry regProfile(reg, sNum);
		CProxyProfile *profile = new CProxyProfile();

		profile->Name = regProfile.Read(szName, _T(""));
		profile->ProxyConfig.Type = (EProxyType) regProfile.Read(szType, 0);
		profile->ProxyConfig.HostName = regProfile.Read(szHostName, _T(""));
		profile->ProxyConfig.Port = regProfile.Read(szPort, 0);
		profile->ProxyConfig.NeedAuth = regProfile.Read(szNeedAuth, FALSE);
		profile->ProxyConfig.UserName = regProfile.Read(szUserName, _T(""));
		profile->ProxyConfig.Password = regProfile.Read(szPassword, _T(""));

		ProxyProfiles[i] = profile;
	}

	ProxyProfileIdx = reg.Read(szActive, -1);
	if (ProxyProfileIdx < 0 || ProxyProfileIdx > ProxyProfiles.GetUpperBound())
		ProxyProfileIdx = -1;
}

// Social Bookmarking Sites ////

void CConfig::SaveSocialBookmarkingSites() {
	CRegistry::DeleteKey(HKEY_CURRENT_USER, REG_KEY_SOCIAL_BOOKMARKING_SITES);

	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_SOCIAL_BOOKMARKING_SITES);
	for (int i = 0; i < SocialBookmarkSites.GetSize(); i++) {
		CString sNum;
		sNum.Format(_T("%d"), i);

		CRegistry regProfile(reg, sNum);

		CSocialBookmarkSite *sbs = SocialBookmarkSites[i];
		regProfile.Write(szName, sbs->Name);
		regProfile.Write(szUrl, sbs->Url);
	}
}

void CConfig::LoadSocialBookmarkingSites() {
	{	CRegistry reg(HKEY_CURRENT_USER, REG_KEY_SOCIAL_BOOKMARKING_SITES);

		DWORD cSubKeys = 0;
		reg.QuerySubKeyNumber(&cSubKeys);
		SocialBookmarkSites.SetSize(cSubKeys);

		int j = 0;
		for (DWORD i = 0; i < cSubKeys; i++) {
			CString sNum;
			sNum.Format(_T("%d"), i);

			CRegistry regProfile(reg, sNum);

			CSocialBookmarkSite *sbs = new CSocialBookmarkSite();
			sbs->Name = regProfile.Read(szName, _T(""));
			sbs->Url = regProfile.Read(szUrl, _T(""));

			if (!sbs->Name.IsEmpty())
				SocialBookmarkSites[j++] = sbs;
		}

		// destructor of reg is called here
	}

	if (SocialBookmarkSites.GetSize() <= 0) {
		// no sites - someone want to fuck up with us -> create del.icio.us
		CSocialBookmarkSite *sbs = new CSocialBookmarkSite();
		sbs->Name = _T("del.icio.us");
		sbs->Url = _T("http://del.icio.us/post?url=[%URL%]&title=[%TITLE%]");

		SocialBookmarkSites.SetAtGrow(0, sbs);

		// social bookmarking
		SaveSocialBookmarkingSites();
	}
}

void CConfig::SaveKeywords() {
	LOG0(3, "CConfig::SaveKeywords()");

	// Keywords
	CRegistry::DeleteKey(HKEY_CURRENT_USER, REG_KEY_KEYWORDS);
	CRegistry regKeywords(HKEY_CURRENT_USER, REG_KEY_KEYWORDS);

	for (int i = 0; i < Keywords.GetSize(); i++) {
		CString sNum;
		sNum.Format(_T("%d"), i + 1);

		CString kw = Keywords.GetAt(i);
		regKeywords.Write(sNum, kw);
	}
}

void CConfig::LoadKeywords() {
	LOG0(3, "CConfig::LoadKeywords()");

	// read keywords
	DWORD cKeywords;
	CRegistry regKeywords(HKEY_CURRENT_USER, REG_KEY_KEYWORDS);
	regKeywords.QueryValueNumber(&cKeywords);

	for (DWORD k = 1; k <= cKeywords; k++) {
		CString sNum;
		sNum.Format(_T("%d"), k);

		CString kword = regKeywords.Read(sNum, _T(""));
		if (!kword.IsEmpty())
			Keywords.Add(kword);
	}
}

void CConfig::SaveRewriteRules() {
	LOG0(3, "CConfig::SaveRewriteRules()");

	CRegistry regRewriteRules(HKEY_CURRENT_USER, REG_KEY_REWRITE_RULES);
	for (int i = 0; i < RewriteRules.GetSize(); i++) {
		CRewriteRule *rr = RewriteRules[i];

		CString sNum;
		sNum.Format(_T("%02d"), i);
		CRegistry regRule(regRewriteRules, sNum);
		regRule.Write(szMatch, rr->Match);
		regRule.Write(szReplace, rr->Replace);
	}
}

void CConfig::LoadRewriteRules() {
	LOG0(3, "CConfig::LoadRewriteRules()");

	CRegistry regRewriteRules(HKEY_CURRENT_USER, REG_KEY_REWRITE_RULES);
	DWORD cSubKeys = 0;
	regRewriteRules.QuerySubKeyNumber(&cSubKeys);
	RewriteRules.SetSize(cSubKeys);

	for (DWORD i = 0; i < cSubKeys; i++) {
		CString sNum;
		sNum.Format(_T("%02d"), i);

		CRegistry regRule(regRewriteRules, sNum);
		CRewriteRule *rule = new CRewriteRule();

		rule->Match = regRule.Read(szMatch, _T(""));
		rule->Replace = regRule.Read(szReplace, _T(""));

		RewriteRules.SetAtGrow(i, rule);
	}
}