好玩的Windows编程之"本地时间"(3) BigBen

最新推荐文章于 2024-07-19 11:24:15 发布
最新推荐文章于 2024-07-19 11:24:15 发布
阅读量187 收藏
点赞数
文章标签： c/c++
原文链接：https://my.oschina.net/u/160145/blog/264393
版权

______________________________________

最近又有新的想法了,编一个有指针的钟,名字就叫BigBen.(下载页面)

原理很简单:首先要取得本地时间,然后把时间转化成钟的指针画上去,最后再把边沿剪切掉,就是一个桌面指针时钟了.

开工了!!!

_______________________________________

原理


时针走时角度是圆的十二等分,走一刻度的角度 alpha=360/12(角度)=PI/180*360/12(弧度)
秒和分针走时角度是圆的六十等分,走一刻度角度alpha=360/60(角度)=PI/180*360/60(弧度)

 
圆心的坐标pt0(m,n)和半径r是已知的,我们可以算出秒针的轨迹坐标pt(x,y)=(r*cos(sec*alpha)+m,r*sin(sec*alpha)+n)

把秒数代入公式得到pt(x,y)=(r*cos(sec*PI/180*360/60)+m,r*sin(sec*PI/180*360/60)+n),然后从圆心pt(m,n)画线到pt(x,y)就是秒针,或者分针了,慢着!什么地方错了.

由于时钟是以90度计为0秒,不是0度,所以要减去90度(即PI/2弧度),所以上面的公式修正为pt(x,y)=(r*cos(sec*PI/180*360/60-PI/2)+m,r*sin(sec*PI/180*360/60-PI/2)+n)=(r*cos(sec*PI/30-PI/2)+m,r*sin(sec*PI/30-PI/2)+n),这样还是有点错误,在C语言下,整数代入计算可能会因为求整,舍去小数而产生误差.于是再把公式改成这样子pt(x,y)=(r*cos(sec*PI/30.0-PI/2.0)+m,r*sin(sec*PI/30.0-PI/2.0)+n)

 

SYSTEMTIME  current_time;
POINT pt0;
POINT pt;
GetLocalTime(&ct);
pt.x=r*cos(ct.wSecond*PI/30.0-PI/2.0)+pt0.x;pt.y=r*sin(ct.wSecond*PI/30.0-PI/2.0)+pt0.yMoveToEx(hdc,pt0.x,pt0.y,NULL);
LineTo(hdc,pt.x,pt.y);


 




 


同样的方法,我们可以得出分针,时针的公式,同样也容易算出刻度的坐标

 

m_alpha_min=m_time.wMinute*PI/30.0-PI/2;
                m_alpha_hour=m_time.wHour*PI/6.0-PI/2.0;
                m_ptmin.x=m_rmin*cos(m_alpha_min)+m_pt0.x;
                m_ptmin.y=m_rmin*sin(m_alpha_min)+m_pt0.y;
                m_pthour.x=m_rhour*cos(m_alpha_hour)+m_pt0.x;
                m_pthour.y=m_rhour*sin(m_alpha_hour)+m_pt0.y);


下图是出现BUG时的截图












这就是雏形,不过还有几点问题,数字电子表上,小时数是在分钟从59变00时,才加1,跳变的,如果直接画在表上,会产生什么呢,分针到了59秒时,时针突然从上一个刻度上跳变!!!有白天见鬼的感觉,而且容易让人产生错觉,所以时针计算公式还要改进.也就是分针行进过程,时针要缓缓前行,然后自然而然地随着分针到了59,00时,小时也到了下一个刻度.想想...想想--走60分钟,时针行进一刻度,也就是PI/180*(360/12)弧度,那走一分钟就是  +PI/180*(360/12)*((m_time.wMinute/60));这是就在原来时针走的角度上加上这个微小的角度.

 

m_alpha_hour=m_time.wHour*PI/6.0-PI/2.0+PI/360.0*m_time.wMinute;


有了这个想法,我想我们也可以改动秒针让它也,缓缓移动.一般情况下秒针一秒跳一次,或许你也见过平滑流动行走的秒针吧,那就要请出微秒

 

m_alpha_sec=(m_time.wSecond+( m_bsmooth ? m_time.wMilliseconds/1000.0 :0.0 ) )*PI/30.0-PI/2;//平滑秒针跳走second+m_time.wMilliseconds/1000.0


  

 半成品


然后有了罗马数字,并剪除了多余的正方形边框






最后用上汉字,完工



 

 

//BigBen.h
//程序名:BigBen  
//作者wisepragma  
//主页:http://blog.csdn.net/wisepragma  

#pragma once
#include <cmath>//#define EDGE_LENGTH 600
//#define FONT_WIDTH 14
//#define FONT_HIGHT 14//#define EDGE_LENGTH 400
//#define FONT_WIDTH 14
//#define FONT_HIGHT 14#define EDGE_LENGTH 250
#define FONT_WIDTH 5
#define FONT_HIGHT 5//时钟的外观设定
#define COLOR_HOUR  (RGB(224,63,196))
#define COLOR_MINUTE (RGB(255,0,0))
#define COLOR_SECOND (RGB(0,255,255)) 
#define COLOR_BACK (RGB(0,0,0))TCHAR *clktxt[]={TEXT("天"),TEXT("道"),TEXT("酬"),TEXT("勤"),TEXT("静"),TEXT("以"),TEXT("修"),TEXT("身"),TEXT("检"),TEXT("以"),TEXT("养"),TEXT("德")};
//TCHAR *clktxt[12]={TEXT("XII"),TEXT("I"),TEXT("II"),TEXT("III"),TEXT("IV"),TEXT("V"),TEXT("VI"),TEXT("VII"),TEXT("VIII"),TEXT("IX"),TEXT("X"),TEXT("XI")};
TCHAR *clktxt[]={TEXT("待"),TEXT("我"),TEXT("君"),TEXT("临"),TEXT("天"),TEXT("下"),TEXT("许"),TEXT("你"),TEXT("四"),TEXT("海"),TEXT("为"),TEXT("家")};

//TCHAR *clktxt[]={TEXT("历"),TEXT("史"),TEXT("尘"),TEXT("封"),TEXT("了"),TEXT("锁"), TEXT("在"),TEXT("岁"),TEXT("月"),TEXT("的"),TEXT("橱"),TEXT("窗")}; 
//       //  TCHAR *clktxt[]={TEXT("12"),TEXT("1"),TEXT("2"),TEXT("3"),TEXT("4"),TEXT("5"),TEXT("6"),TEXT("7"),TEXT("8"),TEXT("9"),TEXT("10"),TEXT("11")};
 





class XPEN
{
private:
        HPEN m_hpen,m_hpenold;
        HDC m_hdc;
public: 
        XPEN(HDC hdc,COLORREF clr,int width=1)
        {                
                m_hdc=hdc;
                m_hpen=CreatePen(PS_SOLID,width,clr);
                m_hpenold=static_cast<HPEN>(SelectObject(m_hdc,m_hpen));     
        }
        void select(COLORREF clr,int width=1)
        {
                SelectObject(m_hdc,m_hpenold);
                DeleteObject(m_hpen);  
                m_hpen=CreatePen(PS_SOLID,width,clr);
                m_hpenold=(HPEN)SelectObject(m_hdc,m_hpen);      
        }
        ~XPEN()
        {
                SelectObject(m_hdc,m_hpenold);
                DeleteObject(m_hpen);      
        }
};
class XBRUSH
{
private:
        HBRUSH m_hbrush,m_hbrold;
        HDC m_hdc;

public:
        XBRUSH(HDC hdc,int br)
        {                 
                m_hdc=hdc;
                m_hbrush=static_cast<HBRUSH>(GetStockObject(br));//会自动填充白色画刷而覆盖其他色彩 
                m_hbrold=static_cast<HBRUSH>(SelectObject(m_hdc,m_hbrush));
        }
        XBRUSH(HDC hdc,COLORREF clr)
        {
                m_hdc=hdc;
                m_hbrush=static_cast<HBRUSH>(CreateSolidBrush(clr));//会自动填充白色画刷而覆盖其他色彩 
                m_hbrold=static_cast<HBRUSH>(SelectObject(m_hdc,m_hbrush));
        }
        void select(COLORREF clr)
        {
                SelectObject(m_hdc,m_hbrold);
                DeleteObject(m_hbrush);  
                m_hbrush=CreateSolidBrush(clr);
                m_hbrold=static_cast<HBRUSH>(SelectObject(m_hdc,m_hbrold));      
        }
        HBRUSH get()
        {
                return m_hbrush;
        }
        ~XBRUSH()
        {
                SelectObject(m_hdc,m_hbrold);
                DeleteObject(m_hbrush);      
        }

};

class XBigBen
{

private:
        COLORREF m_clrHour,m_clrMinute,m_clrSecond,m_clrBack;   
        SYSTEMTIME  m_time;
        unsigned int  m_r,m_rsec_tail,m_rhour,m_rmin,m_rsec;
        POINT m_pt0,m_ptedge,m_ptsec,m_ptmin,m_pthour,m_ptsec_tail;
        RECT    m_rc;
        double m_alpha_sec,m_alpha_min,m_alpha_hour;
        const double PI;
        bool m_bsmooth;     
        TCHAR m_clktxt[12][15];


public:     
        bool m_bAdjustWindow;

        XBigBen(int x,int y,int r,
                COLORREF clrh=RGB(224,63,196),
                COLORREF clrm=RGB(255,0,0),
                COLORREF clrs=RGB(0,255,255),
                COLORREF clrbk=RGB(0,0,0))
                :PI(3.1415)
        {
                m_clrHour=clrh; 
                m_clrMinute=clrm;
                m_clrSecond=clrs;
                m_clrBack=clrbk;
                m_r=r;
                m_pt0.x=x;
                m_pt0.y=y;                   
                m_rc.left=m_pt0.x-m_r;
                m_rc.top=m_pt0.y-m_r;
                m_rc.right=m_pt0.x+m_r;
                m_rc.bottom=m_pt0.y+m_r;
                m_rsec_tail=m_r/4;
                m_rsec=m_r*85/100;
                m_rmin=m_r*80/100;
                m_rhour=m_r*60/100;
                m_bsmooth=true;
                m_bAdjustWindow=true;

                //TCHAR *str[12]={TEXT("XII"),TEXT("I"),TEXT("II"),TEXT("III"),TEXT("IV"),TEXT("V"),TEXT("VI"),TEXT("VII"),TEXT("VIII"),TEXT("IX"),TEXT("X"),TEXT("XI")};
                //setclktext(str);
        }
        void setclktext(TCHAR *ptxt[12])
        {
                for(int i=0;i<12;i++)
                {
                        lstrcpy(m_clktxt[i],ptxt[i]);
                }
        }
        void gettime()
        {
                GetLocalTime(&m_time);

                //秒针,分针都是圆的六十等分(360/60),走一秒为n*6度,由于C函数用的参数变弧度,所以n*6再乘以转化率PSECOND/180=n*6*PI/180=n*PI/30=n*3.1415/30===n*360.0/60.0*3.1415/180,由于时钟是以90度计为0秒,不是0度,所以要减去90度(即PI/2)
                //时针是圆的十二等分(360/12)===360.0/12*3.1415/180,分针行进过程中,时针缓缓地步进到下一个刻度

                m_alpha_sec=(m_time.wSecond+( m_bsmooth ? m_time.wMilliseconds/1000.0 :0.0 ) )*PI/30.0-PI/2;//平滑秒针跳走second+m_time.wMilliseconds/1000.0
                m_alpha_min=m_time.wMinute*PI/30.0-PI/2;
                m_alpha_hour=m_time.wHour*PI/6.0-PI/2.0+PI/360.0*m_time.wMinute;//分针行进过程中,时针缓缓地步进到下一个刻度,而不像数字表那样瞬间跳变,一定要用浮点数代入计算,否则将被求整而产生错误m_alpha_hour=m_time.wHour*PI/6-PI/2+PI/180*(360/12)*((m_time.wMinute/60));
                m_ptsec.x=static_cast<long>(m_rsec*cos(m_alpha_sec)+m_pt0.x);
                m_ptsec.y=static_cast<long>(m_rsec*sin(m_alpha_sec)+m_pt0.y);

                m_ptsec_tail.x=static_cast<long>(m_rsec_tail*cos(m_alpha_sec+PI)+m_pt0.x);
                m_ptsec_tail.y=static_cast<long>(m_rsec_tail*sin(m_alpha_sec+PI)+m_pt0.y);//当拷贝粘贴时错误也一并拷贝

                m_ptedge.x=static_cast<long>(m_r*cos(m_alpha_sec)+m_pt0.x);
                m_ptedge.y=static_cast<long>(m_r*sin(m_alpha_sec)+m_pt0.y);

                m_ptmin.x=static_cast<long>(m_rmin*cos(m_alpha_min)+m_pt0.x);
                m_ptmin.y=static_cast<long>(m_rmin*sin(m_alpha_min)+m_pt0.y);

                m_pthour.x=static_cast<long>(m_rhour*cos(m_alpha_hour)+m_pt0.x);
                m_pthour.y=static_cast<long>(m_rhour*sin(m_alpha_hour)+m_pt0.y);   
        }
        void drawcircle(HDC hdc,POINT pt,int r,COLORREF clr,int width=1)//pt为圆心,半径为r,以clr色彩画圆
        {
                XPEN hpen(hdc,clr,width);
                XBRUSH hbr(hdc,HOLLOW_BRUSH);  //若不设定为(HOLLOW_BRUSH);会自动填充白色画刷而覆盖其他色彩
                RECT rc0;
                rc0.left=pt.x-r;
                rc0.top=pt.y-r;
                rc0.right=pt.x+r;
                rc0.bottom=pt.y+r;
                Ellipse(hdc,rc0.left,rc0.top,rc0.right,rc0.bottom );//指针的中心圆点
        }

        void show(HWND hwnd,HDC hdc)
        {

                RECT rcwnd;  //client rect
                GetClientRect(hwnd,&rcwnd); 
                HDC hmem=CreateCompatibleDC(hdc);//使用缓冲BitBlt方式避免闪烁 
                HBITMAP hbmp=CreateCompatibleBitmap(hdc,rcwnd.right-rcwnd.left,rcwnd.bottom-rcwnd.top);//RIGHT-LEFT NO LEFT-RIGHT,一出错全是白的
                SelectObject(hmem,hbmp);
                XBRUSH brBack(hmem,m_clrBack);
                FillRect(hmem,&rcwnd,brBack.get());//背景着色
                gettime();//取得时间,并计算各时钟指针的坐标

                drawface(hmem);      //表盘刻度 和文字         
                drawhour(hmem);  //画时针
                drawminute(hmem);//画分针
                drawsecond(hmem);  //画秒针
                drawcircle(hmem,m_pt0,4,RGB(0,0,255),2);
                BitBlt(hdc,0,0,rcwnd.right-rcwnd.left,rcwnd.bottom-rcwnd.top,hmem,0,0,SRCCOPY  );// SRCCOPY刷新//SRCAND重叠 

                DeleteObject(hbmp);
                DeleteDC(hmem);
                int t=6;
                HRGN hrgn=  CreateEllipticRgn (m_rc.left-t+3,m_rc.top-t+2,m_rc.right+t,m_rc.bottom+t); 
                SetWindowRgn(hwnd,hrgn,TRUE);//把窗口切成圆的
        }


        void line(HDC hdc,POINT pt1,POINT pt2)
        {
                MoveToEx(hdc,pt1.x,pt1.y,NULL);
                LineTo(hdc,pt2.x,pt2.y);
        }       
        void drawhour(HDC hdc)
        {
                XPEN hpen(hdc,m_clrHour,4);
                line(hdc,m_pt0,m_pthour);
        }
        void drawminute(HDC hdc)
        {
                XPEN hpen(hdc,m_clrMinute,3);
                line(hdc,m_pt0,m_ptmin);
        }
        void drawsecond(HDC hdc)
        {              
                XPEN hpen(hdc,m_clrSecond,2);
                SetPixel(hdc,m_ptedge.x,m_ptedge.y,RGB(255,0,0));
                line(hdc,m_pt0,m_ptsec);
                //hpen.select(RGB(146,250,43),2);//秒针的尾巴色彩
                line(hdc,m_pt0,m_ptsec_tail);
        }
        void drawface(HDC hdc)
        {       

                for(int i=0;i<60;i++)//绘制分钟,秒钟的刻度
                {
                        double beta=i*PI/30.0-PI/2.0; 
                        POINT ptedge;//圆框的点的位置
                        ptedge.x=static_cast<long>(m_r*cos(beta)+m_pt0.x);
                        ptedge.y=static_cast<long>(m_r*sin(beta)+m_pt0.y);
                        POINT ptit;//时刻度的点的位置
                        ptit.x=static_cast<long>((m_rsec*1.1)*cos(beta)+m_pt0.x);
                        ptit.y=static_cast<long>((m_rsec*1.1)*sin(beta)+m_pt0.y);
                        XPEN hpen(hdc,RGB(159,34,241),2);
                        line(hdc,ptit,ptedge);
                        if(i%5==0)
                        {
                                XPEN hpen(hdc,RGB(51,140,183),3);//绘制时钟刻度的位置
                                ptit.x=static_cast<long>((m_rsec+1.0)*cos(beta)+m_pt0.x);
                                ptit.y=static_cast<long>((m_rsec+1.0)*sin(beta)+m_pt0.y);

                                POINT ptit_num;//时间的数值的位置
                                ptit_num.x=static_cast<long>((m_rsec-15.0)*cos(beta)+m_pt0.x);//数值为微调位置
                                ptit_num.y=static_cast<long>((m_rsec-9.0)*sin(beta)+m_pt0.y);
                                line(hdc,ptit,ptedge);

                                TEXTMETRIC tm;
                                LOGFONT lf={0};

                                GetTextMetrics(hdc,&tm); 
                                lstrcpy(lf.lfFaceName,TEXT("Lucida"));
                                lf.lfHeight= tm.tmHeight+FONT_HIGHT;
                                lf.lfWidth=tm.tmAveCharWidth+FONT_WIDTH ;
                                HFONT hfont=CreateFontIndirect(&lf);
                                HGDIOBJ hdcOld=SelectObject(hdc,hfont);

                                SIZE sz;
                                GetTextExtentPoint32(hdc,m_clktxt[i/5],lstrlen(m_clktxt[i/5]),&sz);
                                SetBkMode(hdc,TRANSPARENT);//使文字背景透明
                                SetTextColor(hdc,RGB(190,177,27));
                                TextOut(hdc,ptit_num.x-sz.cx/2,ptit_num.y-sz.cy/2,m_clktxt[i/5],lstrlen(m_clktxt[i/5]));
                                SelectObject(hdc,hdcOld);//还原否则字体会不断变大
                                DeleteObject(hfont);
                        }
                }              

                XBRUSH hbr(hdc,HOLLOW_BRUSH); 
                drawcircle(hdc,m_pt0,m_r,RGB(191,138,28),3);


        }
};


// BigBen.cpp 
//程序名:BigBen  
//作者wisepragma  
//主页:http://blog.csdn.net/wisepragma  

#include "stdafx.h"
#include "BigBen.h"
#include <cmath>

#pragma comment(lib,"user32.lib")
#pragma comment(lib,"gdi32.lib")

XBigBen BigBen(EDGE_LENGTH/2,EDGE_LENGTH/2,(EDGE_LENGTH-10)/2,COLOR_HOUR,COLOR_MINUTE,COLOR_SECOND, COLOR_BACK );



//________________________________________________________________

TCHAR szTitle[ ]=TEXT("BigBen");        // 标题栏文本
TCHAR szWindowClass[ ]=TEXT("BigCls");	 	// 主窗口类名

ATOM    MyRegisterClass(HINSTANCE hInstance);
BOOL    InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);
 	MSG msg;
 
 
	MyRegisterClass(hInstance);

	// 执行应用程序初始化:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}
	// 主消息循环:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
                DispatchMessage(&msg);
	}

	return (int) msg.wParam;
}
 
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style              = CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_QUESTION));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= static_cast<HBRUSH>(0);//(WHITE_BRUSH);(COLOR_WINDOW+1);//有色的背景某此情下会造成闪烁
	wcex.lpszMenuName	=NULL;// MAKEINTRESOURCE(IDC_BigBen);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_QUESTION));

	return RegisterClassEx(&wcex);
}
 
 
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
        HWND hWnd =CreateWindowEx(WS_EX_TOPMOST|WS_EX_TOOLWINDOW,
                        szWindowClass,szTitle,WS_POPUPWINDOW,
                        CW_USEDEFAULT,CW_USEDEFAULT,EDGE_LENGTH,EDGE_LENGTH,
                        NULL,NULL,hInstance,NULL);
        if (!hWnd)  return FALSE;
        ShowWindow(hWnd, nCmdShow);
        UpdateWindow(hWnd);

        return TRUE;
}



LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
 
	PAINTSTRUCT ps;
	HDC hdc;
 
	switch (message)
	{
        case WM_LBUTTONDOWN:
                RECT rcWnd;       
                GetWindowRect(hWnd,&rcWnd);
                SendMessage(hWnd,WM_NCLBUTTONDOWN,HTCAPTION,lParam);
                GetWindowRect(hWnd,&rcWnd);  
                if(rcWnd.top<0) MoveWindow(hWnd,rcWnd.left,0,EDGE_LENGTH,EDGE_LENGTH,TRUE);//WIN7下窗口超出顶端会变形,所以要调整
                break;
 
        case WM_KEYDOWN:
               if(wParam==VK_ESCAPE)PostQuitMessage(0);
                break;
 
	case WM_PAINT:
                {  
                        hdc = BeginPaint(hWnd, &ps);
                        BigBen.show(hWnd,hdc);
  		        EndPaint(hWnd, &ps);
                }
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
        case WM_CREATE:
                BigBen.setclktext(clktxt);
                SetTimer(hWnd,0,100,NULL);
                if(BigBen.m_bAdjustWindow)
                {
                        RECT rectDesktop;
                        SystemParametersInfo(SPI_GETWORKAREA,0,&rectDesktop,0);
                        MoveWindow( hWnd, GetSystemMetrics(SM_CXFULLSCREEN)-EDGE_LENGTH,//微调
                                rectDesktop.bottom-EDGE_LENGTH,//rectDesktop.bottom是系统状态栏最高处的纵坐标
                                EDGE_LENGTH,
                                EDGE_LENGTH,
                                TRUE);

                        BigBen.m_bAdjustWindow=false;
                }	
                break;
        case WM_TIMER:
                InvalidateRect(hWnd,NULL,TRUE);
                break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

 

最新版本加入这张背景图片IMAGE.BMP

 

//resource.h的内容
#define IDI_IMAGE   180

//BigBen.rc的内容
//编译方式:RC /v BigBen.rc
//显示:Writing BITMAP:180,     lang:0x804,     size 313240.
#include "resource.h"
IDI_IMAGE               BITMAP                  "image.bmp"

//BigBen.h
//更新版本:1.1
//程序名:BigBen  
//作者wisepragma 
//主页:http://blog.csdn.net/wisepragma
#pragma once

#include "resource.h"
#include <cmath>

//#define EDGE_LENGTH 600
//#define FONT_WIDTH 14
//#define FONT_HIGHT 14
//
//#define EDGE_LENGTH 400
//#define FONT_WIDTH 11
//#define FONT_HIGHT 11

#define EDGE_LENGTH 250
#define FONT_WIDTH 5
#define FONT_HIGHT 5



//#define EDGE_LENGTH 150
//#define FONT_WIDTH 1
//#define FONT_HIGHT 1




//时钟的外观设定
#define COLOR_HOUR  (RGB(155,30,255))//2014.3.24 add (RGB(224,63,196))
#define COLOR_MINUTE (RGB(0,49,255))//(RGB(255,0,0))
#define COLOR_SECOND (RGB(0,255,255)) 
#define COLOR_BACK (RGB(0,0,0))
#define COLOR_TEXT (RGB(255,0,0))//(0)//RGB(162,120,9)RGB(0,200,128));//字体色彩RGB(190,177,27)RGB(142,36,162)RGB(94,36,126)

TCHAR *clktxt[]={TEXT("天"),TEXT("道"),TEXT("酬"),TEXT("勤"),TEXT("静"),TEXT("以"),TEXT("修"),TEXT("身"),TEXT("检"),TEXT("以"),TEXT("养"),TEXT("德")};
//TCHAR *clktxt[12]={TEXT("XII"),TEXT("I"),TEXT("II"),TEXT("III"),TEXT("IV"),TEXT("V"),TEXT("VI"),TEXT("VII"),TEXT("VIII"),TEXT("IX"),TEXT("X"),TEXT("XI")};
TCHAR *clktxt[]={TEXT("待"),TEXT("我"),TEXT("君"),TEXT("临"),TEXT("天"),TEXT("下"),TEXT("许"),TEXT("你"),TEXT("四"),TEXT("海"),TEXT("为"),TEXT("家")};



//TCHAR *clktxt[]={TEXT("历"),TEXT("史"),TEXT("尘"),TEXT("封"),TEXT("了"),TEXT("锁"), TEXT("在"),TEXT("岁"),TEXT("月"),TEXT("的"),TEXT("橱"),TEXT("窗")}; 
//       

//  TCHAR *clktxt[]={TEXT("12"),TEXT("1"),TEXT("2"),TEXT("3"),TEXT("4"),TEXT("5"),TEXT("6"),TEXT("7"),TEXT("8"),TEXT("9"),TEXT("10"),TEXT("11")};





class XPEN
{
private:
        HPEN m_hpen,m_hpenold;
        HDC m_hdc;
public: 
        XPEN(HDC hdc,COLORREF clr,int width=1)
        {                
                m_hdc=hdc;
                m_hpen=CreatePen(PS_SOLID,width,clr);
                m_hpenold=static_cast<HPEN>(SelectObject(m_hdc,m_hpen));     
        }
        void select(COLORREF clr,int width=1)
        {
                SelectObject(m_hdc,m_hpenold);
                DeleteObject(m_hpen);  
                m_hpen=CreatePen(PS_SOLID,width,clr);
                m_hpenold=(HPEN)SelectObject(m_hdc,m_hpen);      
        }
        ~XPEN()
        {
                SelectObject(m_hdc,m_hpenold);
                DeleteObject(m_hpen);      
        }
};
class XBRUSH
{
private:
        HBRUSH m_hbrush,m_hbrold;
        HDC m_hdc;

public:
        XBRUSH(HDC hdc,int br)
        {                 
                m_hdc=hdc;
                m_hbrush=static_cast<HBRUSH>(GetStockObject(br));//会自动填充白色画刷而覆盖其他色彩 
                m_hbrold=static_cast<HBRUSH>(SelectObject(m_hdc,m_hbrush));
        }
        XBRUSH(HDC hdc,COLORREF clr)
        {
                m_hdc=hdc;
                m_hbrush=static_cast<HBRUSH>(CreateSolidBrush(clr));//会自动填充白色画刷而覆盖其他色彩 
                m_hbrold=static_cast<HBRUSH>(SelectObject(m_hdc,m_hbrush));
        }
        void select(COLORREF clr)
        {
                SelectObject(m_hdc,m_hbrold);
                DeleteObject(m_hbrush);  
                m_hbrush=CreateSolidBrush(clr);
                m_hbrold=static_cast<HBRUSH>(SelectObject(m_hdc,m_hbrold));      
        }
        HBRUSH get()
        {
                return m_hbrush;
        }
        ~XBRUSH()
        {
                SelectObject(m_hdc,m_hbrold);
                DeleteObject(m_hbrush);      
        }

};

class XBigBen
{

private:
        COLORREF m_clrHour,m_clrMinute,m_clrSecond,m_clrBack;   
        SYSTEMTIME  m_time;
        unsigned int  m_r,m_rsec_tail,m_rhour,m_rmin,m_rsec;
        POINT m_pt0,m_ptedge,m_ptsec,m_ptmin,m_pthour,m_ptsec_tail;
        RECT    m_rc;
        double m_alpha_sec,m_alpha_min,m_alpha_hour;
        const double PI;
        bool m_bsmooth;     
        TCHAR m_clktxt[12][15];


public:     
        bool m_bAdjustWindow;

        XBigBen(int x,int y,int r,
                COLORREF clrh=RGB(224,63,196),
                COLORREF clrm=RGB(255,0,0),
                COLORREF clrs=RGB(0,255,255),
                COLORREF clrbk=RGB(0,0,0))
                :PI(3.1415)
        {
                m_clrHour=clrh; 
                m_clrMinute=clrm;
                m_clrSecond=clrs;
                m_clrBack=clrbk;
                m_r=r;
                m_pt0.x=x;
                m_pt0.y=y;                   
                m_rc.left=m_pt0.x-m_r;
                m_rc.top=m_pt0.y-m_r;
                m_rc.right=m_pt0.x+m_r;
                m_rc.bottom=m_pt0.y+m_r;
                m_rsec_tail=m_r/4;
                m_rsec=m_r*85/100;
                m_rmin=m_r*80/100;
                m_rhour=m_r*60/100;
                m_bsmooth=true;
                m_bAdjustWindow=true;

                //TCHAR *str[12]={TEXT("XII"),TEXT("I"),TEXT("II"),TEXT("III"),TEXT("IV"),TEXT("V"),TEXT("VI"),TEXT("VII"),TEXT("VIII"),TEXT("IX"),TEXT("X"),TEXT("XI")};
                //setclktext(str);
        }
        void setclktext(TCHAR *ptxt[12])
        {
                for(int i=0;i<12;i++)
                {
                        lstrcpy(m_clktxt[i],ptxt[i]);
                }
        }
        void gettime()
        {
                GetLocalTime(&m_time);

                //秒针,分针都是圆的六十等分(360/60),走一秒为n*6度,由于C函数用的参数变弧度,所以n*6再乘以转化率PSECOND/180=n*6*PI/180=n*PI/30=n*3.1415/30===n*360.0/60.0*3.1415/180,由于时钟是以90度计为0秒,不是0度,所以要减去90度(即PI/2)
                //时针是圆的十二等分(360/12)===360.0/12*3.1415/180,分针行进过程中,时针缓缓地步进到下一个刻度

                m_alpha_sec=(m_time.wSecond+( m_bsmooth ? m_time.wMilliseconds/1000.0 :0.0 ) )*PI/30.0-PI/2;//平滑秒针跳走second+m_time.wMilliseconds/1000.0
                m_alpha_min=m_time.wMinute*PI/30.0-PI/2;
                m_alpha_hour=m_time.wHour*PI/6.0-PI/2.0+PI/360.0*m_time.wMinute;//分针行进过程中,时针缓缓地步进到下一个刻度,而不像数字表那样瞬间跳变,一定要用浮点数代入计算,否则将被求整而产生错误m_alpha_hour=m_time.wHour*PI/6-PI/2+PI/180*(360/12)*((m_time.wMinute/60));
                m_ptsec.x=static_cast<long>(m_rsec*cos(m_alpha_sec)+m_pt0.x);
                m_ptsec.y=static_cast<long>(m_rsec*sin(m_alpha_sec)+m_pt0.y);

                m_ptsec_tail.x=static_cast<long>(m_rsec_tail*cos(m_alpha_sec+PI)+m_pt0.x);
                m_ptsec_tail.y=static_cast<long>(m_rsec_tail*sin(m_alpha_sec+PI)+m_pt0.y);//当拷贝粘贴时错误也一并拷贝

                m_ptedge.x=static_cast<long>(m_r*cos(m_alpha_sec)+m_pt0.x);
                m_ptedge.y=static_cast<long>(m_r*sin(m_alpha_sec)+m_pt0.y);

                m_ptmin.x=static_cast<long>(m_rmin*cos(m_alpha_min)+m_pt0.x);
                m_ptmin.y=static_cast<long>(m_rmin*sin(m_alpha_min)+m_pt0.y);

                m_pthour.x=static_cast<long>(m_rhour*cos(m_alpha_hour)+m_pt0.x);
                m_pthour.y=static_cast<long>(m_rhour*sin(m_alpha_hour)+m_pt0.y);   
        }
        void drawcircle(HDC hdc,POINT pt,int r,COLORREF clr,int width=1)//pt为圆心,半径为r,以clr色彩画圆
        {
                XPEN hpen(hdc,clr,width);
                XBRUSH hbr(hdc,HOLLOW_BRUSH);  //若不设定为(HOLLOW_BRUSH);会自动填充白色画刷而覆盖其他色彩
                RECT rc0;
                rc0.left=pt.x-r;
                rc0.top=pt.y-r;
                rc0.right=pt.x+r;
                rc0.bottom=pt.y+r;
                Ellipse(hdc,rc0.left,rc0.top,rc0.right,rc0.bottom );//指针的中心圆点
        }

        void show(HWND hwnd,HDC hdc)
        {

                RECT rcwnd;  //client rect
                GetClientRect(hwnd,&rcwnd); 
                HDC hmem=CreateCompatibleDC(hdc);//使用缓冲BitBlt方式避免闪烁 
                HBITMAP hbmp=CreateCompatibleBitmap(hdc,rcwnd.right-rcwnd.left,rcwnd.bottom-rcwnd.top);//RIGHT-LEFT NO LEFT-RIGHT,一出错全是白的
                SelectObject(hmem,hbmp);
                XBRUSH brBack(hmem,m_clrBack);
                FillRect(hmem,&rcwnd,brBack.get());//背景着色

                HANDLE hbitmp=LoadImage(   GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_IMAGE),
                                        IMAGE_BITMAP ,  EDGE_LENGTH , EDGE_LENGTH ,
                                       LR_LOADTRANSPARENT 
  );
                SelectObject(hmem,hbitmp);

                gettime();//取得时间,并计算各时钟指针的坐标

                drawface(hmem);      //表盘刻度 和文字         
                drawhour(hmem);  //画时针
                drawminute(hmem);//画分针
                drawsecond(hmem);  //画秒针
                drawcircle(hmem,m_pt0,4,RGB(0,0,255),2);
 
                BitBlt(hdc,0,0,rcwnd.right-rcwnd.left,rcwnd.bottom-rcwnd.top,hmem,0,0,SRCCOPY  );// SRCCOPY刷新//SRCAND重叠 
                
                DeleteObject(hbitmp);
                DeleteObject(hbmp);
                DeleteDC(hmem);
                int t=6;
                HRGN hrgn=  CreateEllipticRgn (m_rc.left-t+4,m_rc.top-t+4,m_rc.right+t-2,m_rc.bottom+t-2);//change2014.3.24 
                SetWindowRgn(hwnd,hrgn,TRUE);//把窗口切成圆的
        }


        void line(HDC hdc,POINT pt1,POINT pt2)
        {
                MoveToEx(hdc,pt1.x,pt1.y,NULL);
                LineTo(hdc,pt2.x,pt2.y);
        }       
        void drawhour(HDC hdc)
        {
                XPEN hpen(hdc,m_clrHour,4);
                line(hdc,m_pt0,m_pthour);
        }
        void drawminute(HDC hdc)
        {
                XPEN hpen(hdc,m_clrMinute,3);
                line(hdc,m_pt0,m_ptmin);
        }
        void drawsecond(HDC hdc)
        {              
                XPEN hpen(hdc,m_clrSecond,2);
                SetPixel(hdc,m_ptedge.x,m_ptedge.y,RGB(255,0,0));
                line(hdc,m_pt0,m_ptsec);
                //hpen.select(RGB(146,250,43),2);//秒针的尾巴色彩
                line(hdc,m_pt0,m_ptsec_tail);
        }
        void drawface(HDC hdc)
        {       

                for(int i=0;i<60;i++)//绘制分钟,秒钟的刻度
                {
                        double beta=i*PI/30.0-PI/2.0; 
                        POINT ptedge;//圆框的点的位置
                        ptedge.x=static_cast<long>(m_r*cos(beta)+m_pt0.x);
                        ptedge.y=static_cast<long>(m_r*sin(beta)+m_pt0.y);
                        POINT ptit;//时刻度的点的位置
                        ptit.x=static_cast<long>((m_rsec*1.1)*cos(beta)+m_pt0.x);
                        ptit.y=static_cast<long>((m_rsec*1.1)*sin(beta)+m_pt0.y);
                        XPEN hpen(hdc,RGB(159,34,241),2);
                        line(hdc,ptit,ptedge);
                        if(i%5==0)
                        {
                                XPEN hpen(hdc,RGB(51,140,183),3);//绘制时钟刻度的位置
                                ptit.x=static_cast<long>((m_rsec+1.0)*cos(beta)+m_pt0.x);
                                ptit.y=static_cast<long>((m_rsec+1.0)*sin(beta)+m_pt0.y);

                                POINT ptit_num;//时间的数值的位置
                                ptit_num.x=static_cast<long>((m_rsec-10.0)*cos(beta)+m_pt0.x);//数值为微调位置change2014.3.24
                                ptit_num.y=static_cast<long>((m_rsec-9.0)*sin(beta)+m_pt0.y);
                                line(hdc,ptit,ptedge);

                                TEXTMETRIC tm;
                                LOGFONT lf={0};

                                GetTextMetrics(hdc,&tm); 
                                lstrcpy(lf.lfFaceName,TEXT("Lucida"));
                                lf.lfHeight= tm.tmHeight+FONT_HIGHT;
                                lf.lfWidth=tm.tmAveCharWidth+FONT_WIDTH ;
                                HFONT hfont=CreateFontIndirect(&lf);
                                HGDIOBJ hdcOld=SelectObject(hdc,hfont);

                                SIZE sz;
                                GetTextExtentPoint32(hdc,m_clktxt[i/5],lstrlen(m_clktxt[i/5]),&sz);
                                SetBkMode(hdc,TRANSPARENT);//使文字背景透明
                                SetTextColor(hdc,COLOR_TEXT);//字体色彩RGB(190,177,27)RGB(142,36,162)RGB(94,36,126)
                                TextOut(hdc,ptit_num.x-sz.cx/2,ptit_num.y-sz.cy/2,m_clktxt[i/5],lstrlen(m_clktxt[i/5]));
                                SelectObject(hdc,hdcOld);//还原否则字体会不断变大
                                DeleteObject(hfont);
                        }
                }              

                XBRUSH hbr(hdc,HOLLOW_BRUSH); 
                drawcircle(hdc,m_pt0,m_r,RGB(191,138,28),3);


        }
};

 

最新版的图



 

转载于:https://my.oschina.net/u/160145/blog/264393

chuoyunfei4184
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
48、Flink DataStream API 编程指南- 完整版
alanchanchn的专栏
11-30 3万+
addSource - 关联一个新的 source function。例如，你可以使用 addSource(new FlinkKafkaConsumer(…)) 来从 Apache Kafka 获取数据。其中的maven依赖参考本专栏的相关文章kafka该示例是基于flink1.13.5的版本/**/**// source // 准备kafka连接参数 Properties props = new Properties();
48、Flink DataStream API 编程指南（1）- DataStream 入门示例
alanchanchn的专栏
11-29 3万+
通常，只需要使用 getExecutionEnvironment() 即可，因为该方法会根据上下文做正确的处理：如果你在 IDE 中执行你的程序或将其作为一般的 Java 程序执行，那么它将创建一个本地环境，该环境将在你的本地机器上执行你的程序。如果你基于程序创建了一个 JAR 文件，并通过命令行运行它，Flink 集群管理器将执行程序的 main 方法，同时 getExecutionEnvironment() 方法会返回一个执行环境以在集群上执行你的程序。
原理+论文+实战：60篇由浅入深的时间序列预测/分类教程汇总
热门推荐
人生是要不断做减法
04-17 11万+
本文通过论文、实战教程等几十篇篇博文，梳理总结了一套系统化的时间序列预测和时间序列分类任务的入门指南。文中提及的博客、论文和教程全部内容的总字数大约在50万字到100万字之间。
DolphinScheduler（一）：工作流任务调度系统在Windows本地安装部署，源码启动及使用
Dreamy_zsy的博客
09-30 5383
简介&特点： Apache DolphinScheduler（目前处在孵化阶段）是一个分布式、去中心化、易扩展的可视化DAG工作流任务调度系统，其致力于解决数据处理流程中错综复杂的依赖关系，使调度系统在数据处理流程中开箱即用。 特点： DolphinScheduler提供了许多易于使用的功能，可加快数据ETL工作开发流程的效率。其主要特点如下： 通过拖拽以DAG 图的方式将 Task 按照任务的依赖关系关联起来，可实时可视化监控任务的运行状态； 支持丰富的任务类型； 支持工作流定时调度、依赖调度、
Windows Socket编程示例-TCP示例程序
guo8113的专栏
05-21 2万+
windos socket编程示例
读《Java编程思想第五版》心得体会
学Java，找哪吒
09-20 9440
???? Java学习路线：搬砖工逆袭Java架构师 ???? 简介：Java领域优质创作者????、CSDN哪吒公众号作者✌ 、Java架构师奋斗者 ???? 扫描主页左侧二维码，加入群聊，一起学习、一起进步 ???? 欢迎点赞 ???? 收藏 ⭐留言 ???? 一、On Java 8横空出世 很荣幸受到图灵图书邀请，首批阅读了Bruce Eckel 的新作 On Java 8。Bruce Eckel是《Thinking in Java》的作者，《Thinking in Java》被评为19
Hadoop3.2.2安装 windows版
白鸽
10-07 6520
1、下载安装包 https://www.apache.org/dyn/closer.cgi/hadoop/common/hadoop-3.2.2/hadoop-3.2.2.tar.gz 2、下载windows下使用hadoop需要的工具 winutils.exe 和 hadoop.dll https://github.com/cdarlint/winutils/tree/master/hadoop-3.2.2/bin 放入hadoop bin 目录下即可 3、配置环境变量 4、配置 配置文件
Spark3.2教程（二）Windows下Spark Shell编程实现词频统计
Java朱老师博客
12-17 9628
Spark提供了两种方式编程方式： spark-shell 是一个基于Scala语言的交互式解释器，类似于 Scala 提供的交互式解释器, 可以在此直接编写Scala执行。 spark-submit Spark submit是一个命令, 用于提交 Scala 编写的基于 Spark 框架, 这种方式可以支撑在开发工具中开发玩Scala代码之后，在集群中运行任务。 下面我们准备Spark Shell词频统计编程的单词文件，放在D://test/words.txt apple orange pear bana
hive之UDF编程详解
君永夜
04-20 7844
前言：本文详解介绍UDF编程过程，以及hive中创建UDF函数的两种方式 文章目录1.什么是udf1.1UDF分类2.UDF编程示列2.1pom依赖2.2UDF编程2.3打jar包3.创建UDF函数3.1创建临时的UDF函数3.2创建永久生效的UDF函数3.3编译hive支持自定义的UDF函数 1.什么是udf UDF（User-Defined Functions）即是用户自定义的hive函数。h...
3、flink重要概念（api分层、角色、执行流程、执行图和编程模型）及dataset、datastream详细示例入门和提交任务至on yarn运行
alanchanchn的专栏
07-06 4万+
客户端在提交任务的时候会对Operator进行优化操作，能进行合并的Operator会被合并为一个Operator，合并后的Operator称为Operator chain，实际上就是一个执行链，每个执行链会在TaskManager上一个独立的线程中执行，就是SubTask。将算子链接成 task 是个有用的优化：它减少线程间切换、缓冲的开销，并且减少延迟的同时增加整体吞吐量。由Flink程序直接映射成的数据流图是StreamGraph，也被称为逻辑流图，因为它们表示的是计算逻辑的高级视图。
HW3.zip_Windows编程_Visual_C++_
08-12
标题中的“HW3.zip”可能是指一个作业或项目文件，其中包含了与Windows编程相关的源代码或文档。"Windows编程"是指在微软操作系统环境下开发应用程序的技术，而"Visual C++"是微软开发的一种集成开发环境（IDE），...
Big_homework_of_power_system.zip_Big!_Windows编程_coldpjz_电力系统解析
09-24
_Windows编程_coldpjz_电力系统解析"压缩包中，重点是利用Windows编程实现对电力系统的牛顿拉夫逊迭代算法，用于求解系统的潮流问题。 牛顿拉夫逊法是解决非线性方程组的一种迭代方法，在电力系统领域，常用于求解...
SmallChar2Big.rar_Windows编程_Visual_C++_
08-12
标题中的"SmallChar2Big.rar"表明这是一个关于大小写字母转换的源代码压缩包，而"Windows编程_Visual_C++"则暗示了这个程序是用Microsoft的Visual C++编译器在Windows环境下开发的。这通常涉及到Windows API调用和...
Wpf5.rar_Windows编程_Python_
08-12
标题中的"Wpf5.rar"可能是指一个关于Windows Presentation Foundation (WPF)的项目或教程的压缩文件，而“Windows编程_Python_”则表明这个压缩包包含的内容与使用Python进行Windows平台上的编程有关。尽管“Wpf5”...
TwinCAT3中使用梯形图编程
07-18
TwinCAT3中使用梯形图编程 1、常用指令功能块说明 2、使用移位指令实现流水灯循环运行
小欧吃苹果-OPPO 2024届校招正式批笔试题-数据开发（C卷）
sigd的博客
07-16 500
小欧吃苹果，拓扑排序处理贪心问题。
C++ std::thread 管理线程生命周期：join 和 detach
m0_59680769的博客
07-16 995
方法用于同步主线程和子线程。也就是说，当主线程调用子线程的join方法时，主线程会被阻塞，直到子线程完成其执行。这意味着join方法确保主线程等待子线程结束，然后继续执行后续代码。t.join()方法则是让子线程在后台独立运行，与主线程分离。分离后的线程（也称为“游离线程”）不能再被join，它的资源会在该线程完成后自动释放。主线程会继续执行而不会等待该子线程。如果把std::this_thread::sleep_for(std::chrono::seconds(3));
socket 收发TCP/UDP
最新发布
Word_And_Me_的博客
07-19 375
个人测试记录，有问题还请指出，谢谢参考：C++开发基础之网络编程WinSock库使用详解TCP/UDP Socket开发_c++ udp使用什么库-CSDN博客代码中Logger测试见文章： c++中spdlog的使用/python中logger的使用-CSDN博客收发TCP信号 运行结果如下： 收发UDP信号 3、SocketManager.cpp
【素养大赛c++复赛题-序列排序题解】图像模糊处理、吉利号码、战胜白蚁题解
qq_56949201的博客
07-16 179
第一行1个整数n,表示序列的大小。( 0 < n ≤ 1000) 第二行n个正整数，表示序列的每个数，每个数不大于100000000。对于给定的正整数序列，按照每个数的各位数和从大到小排序，各位数和相同的按照本身大小排序，大的在前，小的在后。来存储输入的数字序列，排序完成后输出序列，并在最后释放了动态分配的内存。输出按照题目要求排序后的序列。也可以使用动态分配的数组。
Android编程权威指南（第3版）：Big Nerd Ranch深度解析
《Big Nerd Ranch Guides: Android Programming》（The Big Nerd Ranch Guide 3rd Edition）是由Bill Phillips、Chris Stewart和Kristin Marsicano合著的一本权威的Android编程指南，第三版于2017年由Big Nerd Ranch...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值