huffmanview.cpp

对文本文件进行huffman编码

// huffmanView.cpp : ChuffmanView 类的实现
//

#include "stdafx.h"
#include "huffman.h"
#include "ChooseDialog.h"
#include "InputDialog.h"
#include "huffmanDoc.h"
#include "OptionSheet.h"
#include "huffmanView.h"
#include ".\huffmanview.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// ChuffmanView

IMPLEMENT_DYNCREATE(ChuffmanView, CScrollView)

BEGIN_MESSAGE_MAP(ChuffmanView, CScrollView)
	// 标准打印命令
	ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
	ON_COMMAND(ID_OPTION_SETING, OnOptionSeting)
	ON_COMMAND(ID__NEW_FILE, OnNewFile)
	ON_COMMAND(ID_NEW_INPUT, OnNewInput)
END_MESSAGE_MAP()

// ChuffmanView 构造/析构

ChuffmanView::ChuffmanView()
: m_flag(0)
{
}

ChuffmanView::~ChuffmanView()
{
}

BOOL ChuffmanView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: 在此处通过修改 CREATESTRUCT cs 来修改窗口类或
	// 样式

	return CScrollView::PreCreateWindow(cs);
}

// ChuffmanView 绘制

void ChuffmanView::OnDraw(CDC* pDC)
{
	ChuffmanDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	if (!pDoc)
		return;

	CRect rect;
	this->GetClientRect(&rect);
	CBrush gb(pDoc->m_clrBack);
	CBrush * pOldBrush=pDC->SelectObject(&gb);
	pDC->Rectangle(&rect);
	pDC->SelectObject(pOldBrush);

	if((theApp.m_HuffTree.m_pHT)!=NULL)
	{
		int layer=theApp.m_HuffTree.getLayerNum();
		int maxnum=power2(layer)-1;
		int *treeArray=(int *)malloc(maxnum*sizeof(int));
		int length=theApp.m_HuffTree.toArray(treeArray);
		int i=0;
		int j=0;
		int sx=5;
		int sy=30;
		int x=0;
		int y=0;
		int w=pDoc->m_widthDoc;
		int h=pDoc->m_heigthDoc;
		COLORREF clrEdge=pDoc->m_clrEdge;
		COLORREF clrBack=pDoc->m_clrBack;
		CSize logicSize;
		logicSize.cx=sx+power2(layer-1)*w+10;
		logicSize.cy=sy+(layer-1)*h+10;
		if(logicSize.cx>100||logicSize.cy>100)
		{
			SetScrollSizes(MM_TEXT, logicSize);
		}
		CRect rect;
		this->GetClientRect(&rect);
		CRect rect2(0,0,Max(logicSize.cx,rect.right),Max(logicSize.cy,rect.bottom));
		CBrush brush(clrBack);
		CBrush * pOldBrush=pDC->SelectObject(&brush);
		pDC->Rectangle(&rect2);
		pDC->SelectObject(pOldBrush);
	
		bool forb=true;
		CString str;
		CString notLeaf=pDoc->m_notLeaf;
		CString spaceLeaf=pDoc->m_spaceLeaf;
		COLORREF clrNotLeaf=pDoc->m_clrNotLeaf;
		COLORREF clrSpaceLeaf=pDoc->m_clrSpaceLeaf;
		COLORREF clrLeaf=pDoc->m_clrLeaf;
		LOGFONT leafFont=pDoc->m_leafFont;
		LOGFONT notLeafFont=pDoc->m_notLeafFont;
		LOGFONT spaceLeafFont=pDoc->m_spaceLeafFont;
		int cc=1;
		while(cc<=layer)
		{
			y=sy+(cc-1)*h;
			x=sx+(power2(layer-cc)-1)*(w/2);
			j=0;
			i=power2(cc-1)-1;
			while(i<(power2(cc)-1))
			{
				x=x+(j*w*power2(layer-cc));
				if(treeArray[i]!=0)
				{
					if(treeArray[i]>theApp.m_HuffTree.m_nCNum)
					{
						CFont font;
						font.CreateFontIndirect(&notLeafFont);
						CFont * pOldFont=pDC->SelectObject(&font);
						pDC->SetTextColor(clrNotLeaf);
						pDC->SetBkMode(TRANSPARENT);
						pDC->TextOut(x,y,notLeaf);
						pDC->SelectObject(pOldFont);
					}
					else
					{
						char sp=theApp.m_HuffTree.m_pHT[treeArray[i]].data;
						if((sp>=0&&sp<=32)||sp==255)
						{
							CFont font;
							font.CreateFontIndirect(&spaceLeafFont);
							CFont * pOldFont=pDC->SelectObject(&font);
							pDC->SetTextColor(clrSpaceLeaf);
							pDC->SetBkMode(TRANSPARENT);
							pDC->TextOut(x,y,spaceLeaf);
							pDC->SelectObject(pOldFont);
						}
						else
						{
							CFont font;
							font.CreateFontIndirect(&leafFont);
							CFont * pOldFont=pDC->SelectObject(&font);
							pDC->SetTextColor(clrLeaf);
							pDC->SetBkMode(TRANSPARENT);
							str.Format("%c",theApp.m_HuffTree.m_pHT[treeArray[i]].data);
							pDC->TextOut(x,y,str);
							pDC->SelectObject(pOldFont);
						}
					}
					if(cc>=2)
					{
						if(forb)
						{
							int ly=y-h;
							int lx=x+w*power2(layer-cc)/2;
							CPen pen(PS_SOLID,1,clrEdge);
							CPen * pOldPen=pDC->SelectObject(&pen);
							pDC->MoveTo(lx,ly);
							pDC->LineTo(x,y);
							pDC->SelectObject(pOldPen);
							forb=false;
						}
						else
						{
							int ly=y-h;
							int lx=x-w*power2(layer-cc)/2;
							CPen pen(PS_SOLID,1,clrEdge);
							CPen * pOldPen=pDC->SelectObject(&pen);
							pDC->MoveTo(lx,ly);
							pDC->LineTo(x,y);
							pDC->SelectObject(pOldPen);
							forb=true;
						}
					}
				}
				j=1;
				i++;
			}
			cc++;
		}
	}
}

void ChuffmanView::OnInitialUpdate()
{
	CScrollView::OnInitialUpdate();
	CSize sizeTotal;
	// TODO: 计算此视图的合计大小
	sizeTotal.cx = 100;
	sizeTotal.cy=100;
	SetScrollSizes(MM_TEXT, sizeTotal);
}


// ChuffmanView 打印

BOOL ChuffmanView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// 默认准备
	return DoPreparePrinting(pInfo);
}

void ChuffmanView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: 打印前添加额外的初始化
}

void ChuffmanView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: 打印后添加清除过程
}


// ChuffmanView 诊断

#ifdef _DEBUG
void ChuffmanView::AssertValid() const
{
	CScrollView::AssertValid();
}

void ChuffmanView::Dump(CDumpContext& dc) const
{
	CScrollView::Dump(dc);
}

ChuffmanDoc* ChuffmanView::GetDocument() const // 非调试版本是内联的
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(ChuffmanDoc)));
	return (ChuffmanDoc*)m_pDocument;
}
#endif //_DEBUG


// ChuffmanView 消息处理程序



int ChuffmanView::power2(int n)
{
	int result=1;
	if(n==0) return result;
	for(int i=1;i<=n;i++)
	{
		result=result*2;
	}
	return result;
}

void ChuffmanView::OnOptionSeting()
{
	COptionSheet opsht("设置");
	ChuffmanDoc * pDoc=this->GetDocument();
	opsht.m_spacePage.m_width=pDoc->m_widthDoc;
	opsht.m_spacePage.m_height=pDoc->m_heigthDoc;
	opsht.m_spacePage.m_clrEdge=pDoc->m_clrEdge;
	opsht.m_spacePage.m_clrBack=pDoc->m_clrBack;
	opsht.m_nodePage.m_notLeaf=pDoc->m_notLeaf;
	opsht.m_nodePage.m_spaceLeaf=pDoc->m_spaceLeaf;
	opsht.m_nodePage.m_notLeafFont=pDoc->m_notLeafFont;
	opsht.m_nodePage.m_spaceLeafFont=pDoc->m_spaceLeafFont;
	opsht.m_nodePage.m_leafFont=pDoc->m_leafFont;
	opsht.m_nodePage.m_clrLeaf=pDoc->m_clrLeaf;
	opsht.m_nodePage.m_clrNotLeaf=pDoc->m_clrNotLeaf;
	opsht.m_nodePage.m_clrSpaceLeaf=pDoc->m_clrSpaceLeaf;
	if(opsht.DoModal()==IDOK)
	{
		pDoc->m_widthDoc=opsht.m_spacePage.m_width;
		pDoc->m_heigthDoc=opsht.m_spacePage.m_height;
		pDoc->m_clrEdge=opsht.m_spacePage.m_clrEdge;
		pDoc->m_clrBack=opsht.m_spacePage.m_clrBack;
		pDoc->m_notLeaf=opsht.m_nodePage.m_notLeaf;
		pDoc->m_spaceLeaf=opsht.m_nodePage.m_spaceLeaf;
		pDoc->m_notLeafFont=opsht.m_nodePage.m_notLeafFont;
		pDoc->m_spaceLeafFont=opsht.m_nodePage.m_spaceLeafFont;
		pDoc->m_leafFont=opsht.m_nodePage.m_leafFont;
		pDoc->m_clrLeaf=opsht.m_nodePage.m_clrLeaf;
		pDoc->m_clrNotLeaf=opsht.m_nodePage.m_clrNotLeaf;
		pDoc->m_clrSpaceLeaf=opsht.m_nodePage.m_clrSpaceLeaf;
		Invalidate();
		pDoc->SetModifiedFlag();
	}
}


int ChuffmanView::Max(int x, int y)
{
	if(x>y) return x;
	else return y;
}

void ChuffmanView::OnNewFile()
{
	ChuffmanDoc * pDoc=this->GetDocument();
	pDoc->OnNewDocument();
	CChooseDialog cdlg(true);
	if(cdlg.DoModal()==IDOK)
	{
		pDoc->m_strYFile=cdlg.GetPathName();
		int i;
		theApp.m_HuffTree.m_nCNum=0;
		for(i=0;i<128;i++)
		{
			theApp.m_HuffTree.m_CN[i].ch='\0';
			theApp.m_HuffTree.m_CN[i].weht=0;
		}
		theApp.m_HuffTree.pidu(pDoc->m_strYFile);
		theApp.m_HuffTree.HufmanTree();
		
		//m_flag=1;
		this->Invalidate();
		pDoc->SetModifiedFlag();
	}
}

void ChuffmanView::OnNewInput()
{
	ChuffmanDoc * pDoc=this->GetDocument();
	pDoc->OnNewDocument();
	CInputDialog id;
	if(id.DoModal()==IDOK)
	{
		theApp.m_HuffTree.m_nCNum=0;
		for(int i=0;i<128;i++)
		{
			theApp.m_HuffTree.m_CN[i].ch='\0';
			theApp.m_HuffTree.m_CN[i].weht=0;
		}
		theApp.m_HuffTree.piduInput(id.m_source);
		theApp.m_HuffTree.HufmanTree();

		this->Invalidate();
		pDoc->SetModifiedFlag();
	}
}