if (View == FeedView) {
		CollectSelectedFeedItems(items);
		m_wndFeedView.DeselectAllItems();
	}

	ClearEnclosures(items);
}

LRESULT CMainFrame::OnUpdateFavicon(WPARAM wParam, LPARAM lParam) {
	LOG0(3, "CMainFrame::OnShowUpdateBar()");

	CSiteItem *si = (CSiteItem *) lParam;
	LoadFaviconForSite(SiteList.GetIndexOf(si), si);

	return 0;
}

void CMainFrame::LoadFaviconForSite(int idx, CSiteItem *si) {
	if (si != NULL) {
		if (si->Info != NULL) {
			CString fileName = GetCacheFile(FILE_TYPE_FAVICON, Config.CacheLocation, si->Info->FileName);

			HICON hIcon = LoadIconFromFile(fileName, SCALEX(16), SCALEY(16));
			if (hIcon != NULL) {
				si->ImageIdx = m_ilIcons.Replace(TOPBAR_IMAGE_COUNT + idx, hIcon);
				si->CheckFavIcon = FALSE;			// for sure
			}
			else
				si->ImageIdx = TOPBAR_IMAGE_OK;
		}
		else
			si->ImageIdx = TOPBAR_IMAGE_OK;
	}
}

LRESULT CMainFrame::OnUpdateAll(WPARAM wParam, LPARAM lParam) {
	WorkOffline = Config.WorkOffline;
	if (CheckCachePresence()) {
		CList<CSiteItem *, CSiteItem *> sites;
		for (int i = 0; i < SiteList.GetCount(); i++)
			sites.AddTail(SiteList.GetAt(i));
		m_wndUpdateBar.EnqueueSites(sites, FALSE);
		m_wndUpdateBar.Redraw();
		m_wndUpdateBar.Start();
	}
	else {
		m_wndUpdateBar.ShowError(IDS_CACHE_NOT_AVAILABLE);
	}

	return 0;
}

// Sort ////

void CMainFrame::OnSortChange() {
	LOG0(3, "CMainFrame::OnSortChange()");

	ReleaseCapture();
	SendMessage(WM_CANCELMODE);

	CRect rcItem;
	m_wndTopBar.GetWindowRect(&rcItem);

	CMenu popup;
	popup.CreatePopupMenu();
	AppendMenuFromResource(&popup, IDR_SORT);
	// NOTE: has to make it via TPM_RETURNCMD, because std. WM_CMD machinery did not work for me (strange)
	UINT cmd = (UINT) popup.TrackPopupMenu(TPM_RIGHTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, rcItem.right, rcItem.bottom - 1, this);
//	TrackPopupMenuEx(popup.GetSafeHmenu(), TPM_RIGHTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, rcItem.right, rcItem.bottom - 1, GetSafeHwnd(), NULL);
//	TrackPopupMenuEx(popup.GetSafeHmenu(), TPM_RIGHTALIGN | TPM_TOPALIGN, rcItem.right, rcItem.bottom - 1, GetSafeHwnd(), NULL);

	switch (cmd) {
		case ID_VIEW_SORTBY_DATE: OnViewSortbyDate(); break;
		case ID_VIEW_SORTBY_READ: OnViewSortbyRead(); break;
	}
}

void CMainFrame::UpdateSort() {
	LOG0(3, "CMainFrame::UpdateSort()");

	if (m_wndFeedView.SiteItem == NULL)
		return;

	switch (m_wndFeedView.SiteItem->Sort.Type) {
		case CSortInfo::Ascending:  m_wndTopBar.SetSortButton(TOPBAR_IMAGE_ASC); break;
		case CSortInfo::Descending: m_wndTopBar.SetSortButton(TOPBAR_IMAGE_DESC); break;
	}

	m_wndTopBar.Invalidate();
}

void CMainFrame::OnViewSortbyDate() {
	LOG0(1, "CMainFrame::OnViewSortbyDate()");

	if (m_wndFeedView.SiteItem == NULL)
		return;

	if (m_wndFeedView.SiteItem->Sort.Item != CSortInfo::Date) {
		m_wndFeedView.SiteItem->Sort.Item = CSortInfo::Date;
		m_wndFeedView.DeselectAllItems();
		m_wndFeedView.SortItems();
	}
	else {
		switch (m_wndFeedView.SiteItem->Sort.Type) {
			case CSortInfo::Descending:	m_wndFeedView.OnSortAscending(); break;
			case CSortInfo::Ascending:	m_wndFeedView.OnSortDescending(); break;
		}
		UpdateSort();
	}

	SaveSiteItem(SiteList.GetAt(Config.ActSiteIdx), Config.ActSiteIdx);
}

void CMainFrame::OnViewSortbyRead() {
	LOG0(1, "CMainFrame::OnViewSortbyRead()");

	if (m_wndFeedView.SiteItem == NULL)
		return;

	if (m_wndFeedView.SiteItem->Sort.Item != CSortInfo::Read) {
		m_wndFeedView.SiteItem->Sort.Item = CSortInfo::Read;
		m_wndFeedView.DeselectAllItems();
		m_wndFeedView.SortItems();
	}
	else {
		switch (m_wndFeedView.SiteItem->Sort.Type) {
			case CSortInfo::Descending:	m_wndFeedView.OnSortAscending(); break;
			case CSortInfo::Ascending:	m_wndFeedView.OnSortDescending(); break;
		}
		UpdateSort();
	}

	SaveSiteItem(SiteList.GetAt(Config.ActSiteIdx), Config.ActSiteIdx);
}

void CMainFrame::OnUpdateSortby(CCmdUI *pCmdUI) {
	LOG0(3, "CMainFrame::OnUpdateSortby()");

	if (Config.ActSiteIdx == SITE_UNREAD) pCmdUI->m_pMenu->CheckMenuRadioItem(ID_VIEW_SORTBY_DATE, ID_VIEW_SORTBY_READ, ID_VIEW_SORTBY_DATE + UnreadItems.Sort.Item - 1, MF_BYCOMMAND);
	else if (Config.ActSiteIdx == SITE_FLAGGED) pCmdUI->m_pMenu->CheckMenuRadioItem(ID_VIEW_SORTBY_DATE, ID_VIEW_SORTBY_READ, ID_VIEW_SORTBY_DATE + FlaggedItems.Sort.Item - 1, MF_BYCOMMAND);
	else {
		CSiteItem *si = SiteList.GetAt(Config.ActSiteIdx);
		if (si != NULL)
			pCmdUI->m_pMenu->CheckMenuRadioItem(ID_VIEW_SORTBY_DATE, ID_VIEW_SORTBY_READ, ID_VIEW_SORTBY_DATE + si->Sort.Item - 1, MF_BYCOMMAND);
	}
}

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

void CMainFrame::OnInitMenuPopup(CMenu* pMenu, UINT nIndex, BOOL bSysMenu) {
	LOG0(1, "CMainFrame::OnInitMenuPopup()");

	if (bSysMenu)
		return; // don't support system menu

	ASSERT(pMenu != NULL); // check the enabled state of various menu items
	CCmdUI state;
	state.m_pMenu = pMenu;
	ASSERT(state.m_pOther == NULL);
	ASSERT(state.m_pParentMenu == NULL);

	// determine if menu is popup in top-level menu and set m_pOther to
	// it if so (m_pParentMenu == NULL indicates that it is secondary popup)
	HMENU hParentMenu;
	if (AfxGetThreadState()->m_hTrackingMenu == pMenu->m_hMenu)
		state.m_pParentMenu = pMenu; // parent == child for tracking popup
	else if ((hParentMenu = ::WCE_FCTN(GetMenu)(m_hWnd)) != NULL) {
		CWnd *pParent = GetTopLevelParent(); // child windows don't have menus -- need to go to the top!

		if (pParent != NULL &&
			(hParentMenu = ::WCE_FCTN(GetMenu)(pParent->m_hWnd)) != NULL)
		{
			int nIndexMax = ::WCE_FCTN(GetMenuItemCount)(hParentMenu);
			for (int nIndex = 0; nIndex < nIndexMax; nIndex++) {
				if (::GetSubMenu(hParentMenu, nIndex) == pMenu->m_hMenu) {
					// when popup is found, m_pParentMenu is containing menu
					state.m_pParentMenu = CMenu::FromHandle(hParentMenu);
					break;
				}
			}
		}
	}

	state.m_nIndexMax = pMenu->GetMenuItemCount();
	for (state.m_nIndex = 0; state.m_nIndex < state.m_nIndexMax; state.m_nIndex++) {
		state.m_nID = pMenu->GetMenuItemID(state.m_nIndex);
		if (state.m_nID == 0)
			continue; // menu separator or invalid cmd - ignore it

		ASSERT(state.m_pOther == NULL);
		ASSERT(state.m_pMenu != NULL);
		if (pMenu->GetSubMenu(state.m_nIndex) != NULL) {
			// possibly a popup menu, route to first item of that popup
			state.m_pSubMenu = pMenu->GetSubMenu(state.m_nIndex);
			if (state.m_pSubMenu == NULL ||
				(state.m_nID = state.m_pSubMenu->GetMenuItemID(0)) == 0 ||
				state.m_nID == (UINT)-1)
			{
				continue; // first item of popup can't be routed to
			}
			state.DoUpdate(this, FALSE); // popups are never auto disabled
		}
		else {
			// normal menu item
			// Auto enable/disable if frame window has 'm_bAutoMenuEnable'
			// set and command is _not_ a system command.
			state.m_pSubMenu = NULL;
			state.DoUpdate(this, TRUE);
		}

		// adjust for menu deletions and additions
		UINT nCount = pMenu->GetMenuItemCount();
		if (nCount < state.m_nIndexMax) {
			state.m_nIndex -= (state.m_nIndexMax - nCount);
			while (state.m_nIndex < nCount &&
				pMenu->GetMenuItemID(state.m_nIndex) == state.m_nID)
			{
				state.m_nIndex++;
			}
		}
		state.m_nIndexMax = nCount;
	}
}

void CMainFrame::PreloadThread() {
	LOG0(1, "CMainFrame::PreloadThread() - start");

	HANDLE handles[] = { HTerminate, HPreloadSiteEvent };
	BOOL terminated = FALSE;
	while (!terminated) {
		DWORD dwResult = WaitForMultipleObjects(countof(handles), handles, FALSE, INFINITE);
		if (dwResult == WAIT_OBJECT_0) {
			// terminate
			terminated = TRUE;
		}
		else if (dwResult == WAIT_OBJECT_0 + 1) {
			// preload everything in the list
			while (!PreloadList.IsEmpty()) {
				CSiteItem *si = PreloadList.GetHead();
				si->EnsureSiteLoaded();
				PreloadList.RemoveHead();

				if (WaitForSingleObject(HTerminate, 0) == WAIT_OBJECT_0) {
					terminated = TRUE;
					break;
				}
			}

			ResetEvent(HPreloadSiteEvent);
		}
	}

	CloseHandle(HPreloadThread);
	HPreloadThread = NULL;

	LOG0(1, "CMainFrame::PreloadThread() - end");
}

void CMainFrame::PreloadSite(int idx) {
	LOG1(5, "CMainFrame::PreloadSite(%d)", idx);

//	if (SiteList.GetCount() > 0 && (idx >= 0 && idx < SiteList.GetCount())) {
//		idx = idx % SiteList.GetCount();
//
//		int site = idx;
//		do {
//			site = (site + 1) % SiteList.GetCount();
//
//			CSiteItem *si = SiteList.GetAt(site);
//			if (si->Status == CSiteItem::Empty) {
//				PreloadList.AddTail(si);
//				SetEvent(HPreloadSiteEvent);
//				break;
//			}
//		} while (idx != site);
//	}
}

LRESULT CMainFrame::OnOpenSite(WPARAM wParam, LPARAM lParam) {
	OnSiteSelected(ID_MENU_SITE_BASE + wParam);
	return 0;
}

LRESULT CMainFrame::OnOpenFeedItem(WPARAM wParam, LPARAM lParam) {
	int siteIdx = wParam;
	int feedIdx = lParam;

	OnSiteSelected(ID_MENU_SITE_BASE + siteIdx);

	CFeed *feed = SiteList.GetAt(siteIdx)->Feed;
	if (feed != NULL && (feedIdx >= 0 && feedIdx < feed->GetItemCount())) {
		CFeedItem *fi = feed->GetItem(feedIdx);
		if (fi != NULL) {
			m_wndFeedView.OpenItem(fi);
			// mark it as read
			for (int i = 0; i < m_wndFeedView.m_oItems.GetSize(); i++) {
				if (m_wndFeedView.m_oItems.GetAt(i) == fi)
					m_wndFeedView.MarkItem(i, MESSAGE_READ);
			}
		}
	}

	return 0;
}

void CMainFrame::OnToolsCacheManager() {
	if (CheckCachePresence()) {
		CCacheManager man;
		if (man.DoModal()) {
		}
	}
	else {
		m_wndUpdateBar.ShowError(IDS_CACHE_NOT_AVAILABLE);
	}
}


void CMainFrame::OnOpenPRSSreader() {
	LOG0(3, "CMainFrame::OnRunPRSSreader()");

	CString sPrssrBin;
	sPrssrBin.Format(_T("%s\\%s"), Config.InstallDir, PRSSREADER_BIN);
	CreateProcess(sPrssrBin, _T(""), NULL, NULL, FALSE, 0, NULL, NULL, NULL, NULL);

	prssrNotificationRemove();
}

void CMainFrame::OnHide() {
	// do nothing
	prssrNotificationRemove();
}

void CMainFrame::UpdateMenu() {
	BOOL fEnableItem = !Loading && !m_wndUpdateBar.IsUpdating() && SiteList.GetCount() > 0;
	::SendMessage(m_hwndCmdBar, TB_ENABLEBUTTON, (WPARAM) ID_TOOLS_UPDATEALLCHANNELS, (LPARAM) MAKELONG(fEnableItem, 0));
}

void CMainFrame::OnRewriteRules() {
	CRewritingDlg dlg;

	// rewrite rules
	for (int i = 0; i < Config.RewriteRules.GetSize(); i++) {
		CRewriteRule *rr = Config.RewriteRules[i];

		CRewriteRule *dupRR = new CRewriteRule();
		*dupRR = *rr;
		dlg.Rules.SetAtGrow(i, dupRR);
	}

	if (dlg.DoModal() == IDOK) {
		// rewrite rules
		int i;
		for (i = 0; i < Config.RewriteRules.GetSize(); i++)
			delete Config.RewriteRules[i];
		for (i = 0; i < dlg.Rules.GetSize(); i++)
			Config.RewriteRules.SetAtGrow(i, dlg.Rules[i]);

		Config.SaveRewriteRules();
	}
	else {
		// free previously allocated rewrite rules (duplicates)
		for (int i = 0; i < dlg.Rules.GetSize(); i++)
			delete dlg.Rules[i];
	}
}

void CMainFrame::SyncItemsThread() {
	LOG0(1, "CMainFrame::SyncItemsThread() - start");

	HANDLE handles[] = { HTerminate, HSyncItemEvent };
	BOOL terminated = FALSE;
	while (!terminated) {
		DWORD dwResult = WaitForMultipleObjects(countof(handles), handles, FALSE, INFINITE);
		if (dwResult == WAIT_OBJECT_0) {
			// terminate
			terminated = TRUE;
		}
		else if (dwResult == WAIT_OBJECT_0 + 1) {
			// got connection?
			if (Connection.IsAvailable() == S_OK && Config.SyncSite != SYNC_SITE_NONE) {
				// sync items in the list
				while (!ItemsToSync.IsEmpty()) {
					CFeedItem *fi = ItemsToSync.GetHead();
					Syncer->SyncItem(fi, MESSAGE_MASK_ALL);
					ItemsToSync.RemoveHead();

					if (WaitForSingleObject(HTerminate, 0) == WAIT_OBJECT_0) {
						terminated = TRUE;
						break;
					}
				}
			}
			else {
				// no connection -> empty the list
				while (!ItemsToSync.IsEmpty())
					ItemsToSync.RemoveHead();
			}

			ResetEvent(HSyncItemEvent);
		}
	}

	CloseHandle(HSyncItemsThread);
	HSyncItemsThread = NULL;

	LOG0(1, "CMainFrame::SyncItemsThread() - end");
}

void CMainFrame::SyncItem(CFeedItem *fi) {
	ItemsToSync.AddTail(fi);
	SetEvent(HSyncItemEvent);
}

void CMainFrame::OnFeedListView() {
	// moving from article view to feed list view

	SwitchView(FeedView);
	// remove read items if needed
	if ((m_wndFeedView.SiteItem->Type != CSiteItem::VFolder && Config.HideReadItems) ||
		(m_wndFeedView.SiteItem->Type == CSiteItem::VFolder && m_wndFeedView.SiteItem->FlagMask == MESSAGE_READ_STATE))
	{
		for (int i = m_wndFeedView.GetItemCount() - 1; i >= 0; i--) {
			if (m_wndFeedView.GetItem(i)->IsRead())
				m_wndFeedView.DeleteItem(i);
		}
	}
	m_wndFeedView.UpdateItemHeights();
	UpdateTopBar();
}

void CMainFrame::SetupEnclosureBar(CFeedItem *fi) {
	if (fi->HasEnclosure()) {
		CEnclosureItem *ei = fi->Enclosures.GetHead();

		CString name = GetUrlFileName(ei->URL);
		if (name.IsEmpty())
			name.LoadString(IDS_ENCLOSURE);
		m_wndEnclosureBar.SetName(name);
		BOOL cached = IsEnclosureCached(ei->URL);
		m_wndEnclosureBar.SetCached(cached);
		m_wndEnclosureBar.SetSize(ei->Length);
		// set icon according to the file type
		int nImage;
		switch (ei->Type) {
			case ENCLOSURE_TYPE_AUDIO: nImage = ICON_AUDIO; break;
			case ENCLOSURE_TYPE_VIDEO: nImage = ICON_VIDEO; break;
			case ENCLOSURE_TYPE_IMAGE: nImage = ICON_IMAGE; break;
			default: nImage = ICON_OTHER; break;
		}

		if (!cached) nImage--;
		m_wndEnclosureBar.SetIcon(nImage);

//		m_wndEnclosureBar.ShowWindow(SW_SHOW);
		ShowControlBar(&m_wndEnclosureBar, TRUE, FALSE);
		m_wndEnclosureBar.Invalidate();
		m_wndEnclosureBar.UpdateWindow();
	}
	else {
//		m_wndEnclosureBar.ShowWindow(SW_HIDE);
		ShowControlBar(&m_wndEnclosureBar, FALSE, FALSE);
	}


}

BOO