start.cpp

一个LED楼宇亮化同步控制源码

	{
		dc1.MoveTo(X, Y);
		dc1.LineTo(X, nWndY);

		dc1.MoveTo(X + nWidth/4, Y);
		dc1.LineTo(X + nWidth/4, nWndY);

		dc1.MoveTo(X + nWidth/2, Y);
		dc1.LineTo(X + nWidth/2, nWndY);

		dc1.MoveTo(X + nWidth*3/4, Y);
		dc1.LineTo(X + nWidth*3/4, nWndY);
		X = X + 1;
		Sleep(20);
	}
	Sleep(20);
	
	//百叶变幻3 从左到右 分四块区域 用黑笔
	X      = m_staPointx[index] ;
	nWndX  = m_staPointx[index] + m_iWidth[index];	
	for (n = 0; n <= nWidth/4; n++)
	{
		dc2.MoveTo(X, Y);
		dc2.LineTo(X, nWndY);

		dc2.MoveTo(X + nWidth/4, Y);
		dc2.LineTo(X + nWidth/4, nWndY);

		dc2.MoveTo(X + nWidth/2, Y);
		dc2.LineTo(X + nWidth/2, nWndY);

		dc2.MoveTo(X + nWidth*3/4, Y);
		dc2.LineTo(X + nWidth*3/4, nWndY);
		X = X + 1;
		Sleep(20);
	}
	
	//下面还没想好什么变幻
	
	DeleteObject(pen);
	DeleteObject(penBlack);
	ReleaseDC(&dc1);
	ReleaseDC(&dc2);
}

void Cstart::RectangleRightToLeft(int index, int order)
{
	CClientDC dc1(this);
	CClientDC dc2(this);

	CPen pen, penBlack;
	pen.CreatePen(PS_SOLID, 1, m_rgbColor[index][order].Color());//创建颜色笔
	penBlack.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));//创建黑笔

	dc1.SelectObject(pen);
	dc2.SelectObject(penBlack);

	int X = 0, Y = 0, nWidth = 0, nWndX = 0, nWndY = 0;

	X      = m_staPointx[index];
	Y      = m_staPointy[index];

	nWidth = m_iWidth[index];

	nWndX  = m_staPointx[index] + m_iWidth[index];
	nWndY  = m_staPointy[index] + m_iHigh[index];

	//从右到左，画矩形 用颜色笔, 用变量  nWndX
	for (nWndX; X<=nWndX; nWndX--)
	{
		dc1.MoveTo(nWndX, Y);
		dc1.LineTo(nWndX, nWndY);
		Sleep(5);
	}
	nWndX  = m_staPointx[index] + m_iWidth[index];//变量 nWndX 复位
	Sleep(50);

	//从两边同时画线， 用黑笔 用到变两
	for (int n=0; n<=nWidth/2; n++)
	{
		dc2.MoveTo(X, Y);
		dc2.LineTo(X, nWndY);
		dc2.MoveTo(nWndX, Y);
		dc2.LineTo(nWndX, nWndY);
		
		X	  = X + 1;
		nWndX = nWndX - 1;
		Sleep(10);
	}
	X      = m_staPointx[index];//变量 X 复位
	nWndX  = m_staPointx[index] + m_iWidth[index];// 变量 nWndX 复位
	Sleep(50);

	//从中间向两边画线， 用颜色笔， 用到变量 X，nWndX
	X      = m_staPointx[index] + nWidth / 2;
	nWndX  = m_staPointx[index] + m_iWidth[index] / 2;
	for (n = 0; n <= nWidth/2; n++)
	{
		dc1.MoveTo(X, Y);
		dc1.LineTo(X, nWndY);
		dc1.MoveTo(nWndX, Y);
		dc1.LineTo(nWndX, nWndY);
		X	  = X - 1;
		nWndX = nWndX + 1;
		Sleep(10);
	}
	X      = m_staPointx[index];//变量 X 复位
	nWndX  = m_staPointx[index] + m_iWidth[index];// 变量 nWndX 复位
	Sleep(50);

	//百叶变幻1 从右到左， 分四块， 用黑笔填充
	for (n = 0; n<=nWidth/4; n++)
	{
		dc2.MoveTo(nWndX, Y);//第一条线
		dc2.LineTo(nWndX, nWndY);

		dc2.MoveTo(nWndX - nWidth/4, Y);//第二条线
		dc2.LineTo(nWndX - nWidth/4, nWndY);

		dc2.MoveTo(nWndX - nWidth/2, Y);//第三条线
		dc2.LineTo(nWndX - nWidth/2, nWndY);

		dc2.MoveTo(nWndX - nWidth*3/4, Y);//第四条线
		dc2.LineTo(nWndX - nWidth*3/4, nWndY);
		nWndX = nWndX - 1;
		Sleep(20);
	}
	nWndX  = m_staPointx[index] + m_iWidth[index];// 变量 nWndX 复位
	Sleep(50);

	//百叶变幻2 从右向左， 分四块 用颜色笔填充
	for (n = 0; n<=nWidth/4; n++)
	{
		dc1.MoveTo(nWndX, Y);//第一条线
		dc1.LineTo(nWndX, nWndY);

		dc1.MoveTo(nWndX - nWidth/4, Y);//第二条线
		dc1.LineTo(nWndX - nWidth/4, nWndY);

		dc1.MoveTo(nWndX - nWidth/2, Y);//第三条线
		dc1.LineTo(nWndX - nWidth/2, nWndY);

		dc1.MoveTo(nWndX - nWidth*3/4, Y);//第四条线
		dc1.LineTo(nWndX - nWidth*3/4, nWndY);
		nWndX = nWndX - 1;
		Sleep(20);
	}
	nWndX  = m_staPointx[index] + m_iWidth[index];// 变量 nWndX 复位
	Sleep(50);

	//百叶变幻3 从右到左， 分四块， 用黑笔填充
	for (n = 0; n<=nWidth/4; n++)
	{
		dc2.MoveTo(nWndX, Y);//第一条线
		dc2.LineTo(nWndX, nWndY);

		dc2.MoveTo(nWndX - nWidth/4, Y);//第二条线
		dc2.LineTo(nWndX - nWidth/4, nWndY);

		dc2.MoveTo(nWndX - nWidth/2, Y);//第三条线
		dc2.LineTo(nWndX - nWidth/2, nWndY);

		dc2.MoveTo(nWndX - nWidth*3/4, Y);//第四条线
		dc2.LineTo(nWndX - nWidth*3/4, nWndY);
		nWndX = nWndX - 1;
		Sleep(20);
	}
	nWndX  = m_staPointx[index] + m_iWidth[index];// 变量 nWndX 复位
	Sleep(50);

	//百叶变幻4 从右向左， 分四块 用颜色笔填充
	for (n = 0; n<=nWidth/4; n++)
	{
		dc1.MoveTo(nWndX, Y);//第一条线
		dc1.LineTo(nWndX, nWndY);

		dc1.MoveTo(nWndX - nWidth/4, Y);//第二条线
		dc1.LineTo(nWndX - nWidth/4, nWndY);

		dc1.MoveTo(nWndX - nWidth/2, Y);//第三条线
		dc1.LineTo(nWndX - nWidth/2, nWndY);

		dc1.MoveTo(nWndX - nWidth*3/4, Y);//第四条线
		dc1.LineTo(nWndX - nWidth*3/4, nWndY);
		nWndX = nWndX - 1;
		Sleep(20);
	}
	nWndX  = m_staPointx[index] + m_iWidth[index];// 变量 nWndX 复位
	Sleep(50);

	//其他变幻还没有想好,............

	DeleteObject(pen);//删除颜色笔
	DeleteObject(penBlack);//删除黑笔
	ReleaseDC(&dc1);//
	ReleaseDC(&dc2);//
}

/////////////矩形从下到上//////////////////////////////////////
void Cstart::RectangleBottomToLeft(int index, int order)
{
	CClientDC dc1(this);
	CClientDC dc2(this);
	
	CPen pen, penBlack;
	pen.CreatePen(PS_SOLID, 1, m_rgbColor[index][order].Color());
	penBlack.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));

	dc1.SelectObject(pen);
	dc2.SelectObject(penBlack);

	int X = 0, Y = 0, nHigh = 0, nWndX = 0, nWndY = 0;

	X	  = m_staPointx[index];
	Y     = m_staPointy[index];

	nHigh = m_iHigh[index];

	nWndX = m_staPointx[index] + m_iWidth[index];
	nWndY = m_staPointy[index] + m_iHigh[index];

	//矩形 从下到上 画线 用颜色笔
	for (int n = 0; n <=nHigh; n++)
	{
		dc1.MoveTo(X, nWndY);
		dc1.LineTo(nWndX, nWndY);
		nWndY = nWndY - 1;
		Sleep(5);
	}
	nWndY = m_staPointy[index] + m_iHigh[index];//变量复位 nWndY
	Sleep(20);

	//从上和下 同时画线 用黑笔
	for (n = 0; n <= nHigh/2; n++)
	{
		dc2.MoveTo(X, Y);//第一条线
		dc2.LineTo(nWndX, Y);

		dc2.MoveTo(X, nWndY);//第二条线
		dc2.LineTo(nWndX, nWndY);
			
		Y	  = Y + 1;
		nWndY = nWndY - 1;
		Sleep(10);
	}
	Y     = m_staPointy[index];
	nWndY = m_staPointy[index] + m_iHigh[index];
	Sleep(20);

	//从中间向两边 同时画线 用颜色笔
	Y	  = m_staPointy[index] + m_iHigh[index]/2;
	nWndY = m_staPointy[index] + m_iHigh[index]/2;
	for (n = 0; n <= nHigh /2; n++)
	{
		dc1.MoveTo(X, Y);//第一条线
		dc1.LineTo(nWndX, Y);

		dc1.MoveTo(X, nWndY);//第二天线
		dc1.LineTo(nWndX, nWndY);
	
		Y	  = Y -1;
		nWndY = nWndY + 1;
		Sleep(10);
	}
	Y     = m_staPointy[index];//变量复位 Y
	nWndY = m_staPointy[index] + m_iHigh[index];//变量复位Y
	Sleep(20);

	//百叶变幻1 从下到上， 分四分 用黑笔 每次画四条线
	for (n =0; n<=nHigh/4; n++)
	{
		dc2.MoveTo(X,     nWndY);//第一条线
		dc2.LineTo(nWndX, nWndY);

		dc2.MoveTo(X, nWndY - nHigh/4);//第二条线
		dc2.LineTo(nWndX, nWndY - nHigh/4);

		dc2.MoveTo(X, nWndY - nHigh/2);//第三条线
		dc2.LineTo(nWndX, nWndY- nHigh/2);

		dc2.MoveTo(X, nWndY - nHigh*3/4);//第四条线
		dc2.LineTo(nWndX, nWndY - nHigh*3/4);

		nWndY = nWndY - 1;
		Sleep(20);
	}
	nWndY = m_staPointy[index] + m_iHigh[index];//变量复位Y
	Sleep(20);

	//百叶变幻2 从下到上， 分四封， 用颜色笔	
	for (n =0; n<=nHigh/4; n++)
	{
		dc1.MoveTo(X,     nWndY);//第一条线
		dc1.LineTo(nWndX, nWndY);

		dc1.MoveTo(X, nWndY - nHigh/4);//第二条线
		dc1.LineTo(nWndX, nWndY - nHigh/4);

		dc1.MoveTo(X, nWndY - nHigh/2);//第三条线
		dc1.LineTo(nWndX, nWndY- nHigh/2);

		dc1.MoveTo(X, nWndY - nHigh*3/4);//第四条线
		dc1.LineTo(nWndX, nWndY - nHigh*3/4);

		nWndY = nWndY - 1;
		Sleep(20);
	}
	nWndY = m_staPointy[index] + m_iHigh[index];//变量复位Y
	Sleep(20);

	//其它输入法有空在写

	DeleteObject(pen);//删除pen, penBlack
	DeleteObject(penBlack);

	ReleaseDC(&dc1);//删除dc1, dc2
	ReleaseDC(&dc2);
}
//////////////////////矩形从到上/////////////////////////////////////


//彩虹变幻， 从上到下
void Cstart::RainbowTopToBottom(int index, int order)
{
    int tempy;
	int tempx;

	CClientDC dc(this);
	tempy=m_staPointy[index]+m_iHigh[index];
	tempx=m_staPointx[index]+m_iWidth[index];
	for(int y=m_staPointy[index];y<=tempy;y++)
	{    
		m_sevTemp=(++m_sevTemp)%7;

		if(y%5==0)
		{
             dc.SelectObject(&pen[m_sevTemp]);//实现颜色的变化
		}
        dc.MoveTo(m_staPointx[index],y);
		dc.LineTo(tempx,y);
		Sleep(20);
	}
	
	ReleaseDC(&dc);
}

//彩虹变幻 从左到右
void Cstart::RainbowLeftToRight(int index, int order)
{
	CClientDC dc(this);

	int X = 0, Y = 0, nWndX = 0, nWndY;
	X     = m_staPointx[index];
	Y     = m_staPointy[index];
	nWndX = m_staPointx[index] + m_iWidth[index];
	nWndY = m_staPointy[index] + m_iHigh[index];

	for (X; X <=nWndX; X++)
	{
		m_sevTemp = (++m_sevTemp) %7;

		if (X % 5 == 0)
		{
			dc.SelectObject(&pen[m_sevTemp]);
		}

		dc.MoveTo(X, Y);
		dc.LineTo(X, nWndY);
		Sleep(20);
	}
	
	ReleaseDC(&dc);
}

//彩虹变幻 从下到上
void Cstart::RainbowBottomToTop(int index, int order)
{
	CClientDC dc(this);

	int X = 0, Y = 0, nWndX = 0, nWndY = 0;

	X    = m_staPointx[index];
	Y    = m_staPointy[index];
	nWndX = m_staPointx[index] + m_iWidth[index];
	nWndY = m_staPointy[index] + m_iHigh[index];

	while (Y <= nWndY)
	{
		m_sevTemp = (++m_sevTemp) %7;

		if (nWndY % 5 == 0)
		{
			dc.SelectObject(&pen[m_sevTemp]);
		}

		dc.MoveTo(X, nWndY);
		dc.LineTo(nWndX, nWndY);
		Sleep(20);
		nWndY = nWndY - 1;			
	}
	
	ReleaseDC(&dc);
}

//彩虹变幻 从右到左
void Cstart::RainbowRightToLeft(int index, int order)
{
	CClientDC dc(this);

	int X = 0, Y = 0, nWndX = 0, nWndY = Y;
	X	  = m_staPointx[index];
	Y	  = m_staPointy[index];
	nWndX = m_staPointx[index] + m_iWidth[index];
	nWndY = m_staPointy[index] + m_iHigh[index];

	while (X <= nWndX)
	{
		m_sevTemp = (++m_sevTemp) %7;

		if (nWndX % 5 == 0)
		{
			dc.SelectObject(&pen[m_sevTemp]);
		}

		dc.MoveTo(nWndX, Y);
		dc.LineTo(nWndX, nWndY);
		
		nWndX = nWndX - 1;
		Sleep(20);
	}

	ReleaseDC(&dc);
}


void Cstart::AccTopToBottom(int index, int order)//积木从上到下
{	
	CClientDC dc1(this);
	CClientDC dc2(this);
	CPen pen, penBlack;

	pen.CreatePen(PS_SOLID, 1, m_rgbColor[index][order].Color());
	penBlack.CreatePen(PS_SOLID, 1, RGB(0, 0, 0));

	dc1.SelectObject(pen);
	dc2.SelectObject(penBlack);

	int n = 0, nHigh = 0, nWidth = 0, X = 0,  Y = 0, nWndX = 0, nWndY = 0;
		    
	X	  = m_staPointx[index];
	Y	  = m_staPointy[index];

	nWidth = m_iWidth[index];
	nHigh = m_iHigh[index];

	nWndX = m_staPointx[index] + m_iWidth[index];
	nWndY = m_staPointy[index] + m_iHigh[index];

	//从头和中间积木
	nWndY = m_staPointy[index] + m_iHigh[index]/2;
	for (n = nHigh/2;0< n; n--)
	{
		for (int i = 0; i< n; i++)
		{
			dc2.MoveTo(X, Y);//查线
			dc2.LineTo(nWndX, Y);
			Y = Y + 1;
			dc1.MoveTo(X, Y);//画线
			dc1.LineTo(nWndX, Y);
			
			dc2.MoveTo(X, nWndY);//查下半线
			dc2.LineTo(nWndX, nWndY);
			nWndY = nWndY + 1;
			dc1.MoveTo(X, nWndY);
			dc1.LineTo(nWndX, nWndY);//画下半线
			Sleep(1);
		}
		Y	  = m_staPointy[index];
		nWndY = m_staPointy[index] + m_iHigh[index]/2;
	}
	Sleep(10);
	
	//百叶变幻1, 填充为黑色
	for (n = 0; n<=nHigh/4; n++)