helper.cpp

离线的RSS阅读器

#include "StdAfx.h"
#include "helper.h"
#include "db.h"
#include "xml.h"
#include "MainFrm.h"
#include "ToolBarView.h"

typedef BOOL (*CMP)(ItemList *left,ItemList *right,int type);

//根据一棵myTreeNode树创建一棵TreeCtrl树
void _makeTree(MyTreeNode *root,CTreeCtrl *tree,HTREEITEM treeRoot /* = TVI_ROOT */){
	if(root==NULL)
		return;
	HTREEITEM h = tree->InsertItem(root->name,treeRoot,TVI_LAST);
	tree->SetItemText(h,root->name);
	tree->SetItemData(h,(DWORD)root);
	tree->SetItemImage(h,root->type,root->type);
	if (root->type==1||root->type==2)
	{
		return;
	}
	DirNode *node = (DirNode*)root;
	MyTreeNode *firstChild = node->firstChild;
	while (firstChild)
	{
		_makeTree(firstChild,tree,h);
		firstChild = firstChild->nextSubling;
	}
}

void makeTree(MyTreeNode *root,CTreeCtrl *tree,HTREEITEM treeRoot /* = TVI_ROOT */){
	while (root)
	{	
		_makeTree(root,tree,TVI_ROOT);
		root = root->nextSubling;
	}
}

//从一棵树获取一个myTreeNode的树
MyTreeNode* storeTree(CTreeCtrl *tree, HTREEITEM root /* = TVI_ROOT */){
	return (MyTreeNode*)tree->GetItemData(root);
}

//把一个itemlist显示出来
void makeList(ItemList *item, CItemList *list){
	if (list->items==item)
	{
		
	}
	else{
		ItemList *oldItems = list->items;
//  	while (oldItems)
//  	{
//  		oldItems->~ItemList();
//  		oldItems = oldItems->nextItem;
//  	}
		while (oldItems!=NULL)
		{
			ItemList *next = oldItems->nextItem;
			delete oldItems;
			oldItems = next;
		}
		
		list->items = item;
	}
	list->DeleteAllItems();
	for (int i=0;item;i++,item=item->nextItem)
	{
		list->InsertItem(i,TEXT(""),item->isRead);
		list->SetItemText(i,2,item->author);
		list->SetItemText(i,3,item->time);
		list->SetItemText(i,1,item->title);
		list->SetItemData(i,(DWORD)item);
	}
}

//查找
ItemList *search(MyTreeNode *root,char *key,char *startTime,char *endTime,int type){
	if (root->type==1)
	{
		ChannelNode *p = (ChannelNode*)root;
		return searchChannel(root->id,key,startTime,endTime,type);
	}
	else{
		ItemList *result = NULL;
		DirNode * p = (DirNode*)root;
		MyTreeNode *child = p->firstChild;
		while (child!=NULL)
		{
			result = result + *search(child,key,startTime,endTime,type);
			child = child->nextSubling;
		}
		return result;
	}
	return NULL;
}

//在频道里面查找
ItemList *searchChannel(int id,char *key,char *startTime,char *endTime,int type){
	ItemList *temp = DBGetItemById(id,db);
	ItemList *result = NULL;
	while (temp!=NULL)
	{
		char *keyfiled = NULL;
		if(type==0){
			keyfiled = temp->title;
		}
		else if (type==1)
		{
			keyfiled = temp->author;
		}
		char *c = strstr(keyfiled,key);
		bool substr = false;
		if (!strlen(key)||strstr(keyfiled,key))
		{
			substr = true;
		}
		strcpy(startTime+11,"00:00:00");
		strcpy(endTime+11,"23:59:59");
		if (substr&&(strcmp(startTime,temp->time)<=0)&&(strcmp(endTime,temp->time)>=0))
		{
			ItemList *tempresult = new ItemList(temp->url,temp->title,temp->author,temp->description,temp->time);
			tempresult->nextItem = result;
			result = tempresult;
		}
		temp = temp->nextItem;
	}
	while (temp!=NULL)
	{
		ItemList *next = temp->nextItem;
		delete temp;
		temp = next;
	}
	return result;
}

//全部更新
void updateAllChannel(MyTreeNode *root){
	CStatusBar *bar = (CStatusBar*)AfxGetMainWnd()->GetDescendantWindow(AFX_IDW_STATUS_BAR);
	bar->SetWindowText("正在更新");

	if(root->type==1){
		//ChannelNode * temp = (ChannelNode*)us->node;
		updateThreadFun((PVOID)root);
	}
	else{
		DirNode *temp = (DirNode*)root;
		MyTreeNode *child = temp->firstChild;
		while (child)
		{
			updateAllChannel(child);
			child = child->nextSubling;
		}
	}
	bar->SetWindowText("完成");
}

//多线程更新

void updateChannel(ChannelNode *channel){
	AfxBeginThread((AFX_THREADPROC)updateThreadFun,channel,THREAD_PRIORITY_BELOW_NORMAL);
}

UINT updateThreadFun(PVOID param){
	ChannelNode *channel = (ChannelNode*)param;
	char *url = channel->url;
	Channel *result = XMLGetChannelByURL(url);
	if (result)
	{
		DBUpdateChannel(channel->id,result->items,db);
	}
	ItemList *items = result->items;
	while (items)
	{
		ItemList *temp = items->nextItem;
		delete items;
		items = temp;
	}
	delete result;
	return 0;
}

//删除一棵树的某一棵子树的数据(setitemdata和数据库的数据)
void deleteCategoryData(DirNode *parent,MyTreeNode *root){
	if (root->type==1)
	{
		ChannelNode *data = (ChannelNode*)root;
		DBDeleteItem(parent,root,db);
		DBUpdateChannel(root->id,NULL,db);
		//delete data;
	}
	else if (root->type==2)
	{
		CollectionNode *data = (CollectionNode*)root;
		DBDeleteItem(parent,root,db);
	}
	else{
		DirNode *data = (DirNode*)root;
		MyTreeNode *child = data->firstChild;
		while (child!=NULL)
		{
			MyTreeNode *temp = child->nextSubling;
			deleteCategoryData(data,child);
			child = temp;
		}
		DBDeleteItem(parent,data,db);
		//delete data;
	}
}

//比较函数
BOOL ItemListCmpLess(ItemList *left,ItemList *right,int type){
	if (type==1)
	{
		//return strcmp(left->author,right->author)<0;
		int i = strcmp(left->title,right->title);
		return i<0;
	}
	if (type==2)
	{
		return strcmp(left->time,right->time)<0;
	}
	else{
		return strcmp(left->author,right->author)<0;
	}
}

BOOL ItemListCmpMore(ItemList *left,ItemList *right,int type){
	return !ItemListCmpLess(left,right,type);
}

//排序
ItemList *sort(ItemList *items,int type,BOOL asc){
	if (items==NULL||items->nextItem==NULL)
	{
		return items;
	}
	
	ItemList *result = items;
	ItemList *start = items;
	//result->nextItem=NULL;
	CMP cmp;
	if (asc)
	{
		cmp = ItemListCmpLess;
	}
	else{
		cmp = ItemListCmpMore;
	}
	while(start!=NULL)
	{
		ItemList *maxItem = start;
		for (ItemList *cur = start;cur;cur=cur->nextItem)
		{
			if ((*cmp)(maxItem,cur,type))
			{
				maxItem = cur;
			}
		}
		ItemList *snext = start->nextItem;
		ItemList *mnext = maxItem->nextItem;
// 		ItemList temp = *start;
// 		*start = *maxItem;
// 		*maxItem = temp;
// 		start->nextItem = next;

		void *p = malloc(sizeof(ItemList));
		memmove(p,maxItem,sizeof(ItemList));
		memmove(maxItem,start,sizeof(ItemList));
		memmove(start,p,sizeof(ItemList));
		free(p);
		start->nextItem = snext;
		start = snext;
		maxItem->nextItem = mnext;
	}
	return result;
}

void deleteTreeNode(MyTreeNode *root){
	if (!root)
	{
		return;
	}
	if (root->type==1)
	{
		delete root;
	}
	else{
		DirNode *temp = (DirNode*)root;
		MyTreeNode *child = temp->firstChild;
		while (child)
		{
			MyTreeNode *temp = child->nextSubling;
			deleteTreeNode(child);
			child = temp;
		}
		delete temp;
	}
}

int CALLBACK CompareFunc(LPARAM lParam1,LPARAM lParam2,LPARAM lParamSort){
	MyData *data = (MyData*)lParamSort;
	ItemList *litem = (ItemList*)lParam1;
	ItemList *ritem = (ItemList*)lParam2;

	//按标题排序
	if (data->isub==1)
	{
		if (data->seq)
		{
			return strcmp(litem->title,ritem->title);
		}
		else{
			return strcmp(ritem->title,litem->title);
		}
	}
	else if (data->isub==3)
	{
		if (data->seq)
		{
			return strcmp(litem->time,ritem->time);
		}
		else{
			return strcmp(ritem->time,litem->time);
		}
	}
	else{
		if (data->seq)
		{
			return strcmp(litem->author,ritem->author);
		}
		else{
			return strcmp(ritem->author,litem->author);
		}
	}
	return 0;
	
}

void deleteTree(MyTreeNode *root){
	if (root->type)
	{
		delete root;
	}
	else{
		DirNode *dir = (DirNode*)root;
		MyTreeNode *child = dir->firstChild;
		while (child)
		{
			MyTreeNode *temp = child->nextSubling;
			deleteTree(child);
			child = temp;
		}
		delete dir;
	}
}

char *GBK2UTF8(char *gbkStr){
	int wLen = MultiByteToWideChar(CP_ACP, 0, gbkStr, -1, NULL, 0);
	LPWSTR wStr = (LPWSTR)CoTaskMemAlloc(wLen * sizeof(WCHAR));
	MultiByteToWideChar(CP_ACP, 0, gbkStr, -1, wStr, wLen);

	int aLen = WideCharToMultiByte(CP_UTF8, 0, wStr, -1, NULL, 0, NULL, NULL);
	char* utf8Str = (char*)CoTaskMemAlloc(aLen);
	WideCharToMultiByte(CP_UTF8, 0, wStr, -1, utf8Str, aLen, NULL, NULL);

	return utf8Str;
}