大学的第一个自己的程序

　　之前高中的时候，用字符界面开发（能叫开发吗。。）了一些小游戏，算是从底层写起吧。但是因为性能上的先天不足（显示字符最小也是3*5像素，然后还不是方形的，最重要的是刷新太慢），历经层层优化也只能达到全屏120*60字符或者离散200字符 10fps的刷新率，可以写一些贪吃蛇，国际象棋之类的简单游戏和程序，但是更高的想法就不能满足了。在进入大学之后，有了更多的时间，想再自己从底层写一些东西出来，于是有了下面这种过程。。

　　首先是选择API，一开始我有三种想法：WINAPI，Direct_x，openGL。但在查阅相关资料后，放弃了这三种选项，WINAPI太过繁琐，而且Microsoft那堆程序员的程序标准我也真是不习惯，全大写函数名我就不说了，元音字母省略让人根本看不懂，最后函数名还是那么冗长。。而Direct_x和openGL整合太好了，不符合我从较基础（至少功能上）写起的初衷。

　　然后我想起了曾经使用pascal时的恐惧，哦不是，是舒服。pascal当时有个Graphic库，函数简单实用，性能也不错，著名的pascal自带游戏就是用的那个东西。听说很多语言都可以用。然后试着百度了一下，发现一个国内团体还在提供可使用的graphic库，名字叫easyX。就下下来作为API的选择。附链接：easyX

　　第一个软件写什么？这要说到我自己遇到的一个问题。我在上大学之前入手了一台surface3，平常上课的时候可以带去看课件，记笔记，在寝室里用“重型”笔记本的时候，它就会被我架在旁边，充着电。因为用笔记本打代码的原因，并不想碰鼠标，加上任务栏上时间太小且一般隐藏任务栏，所以一个在surface上看时间的应用成为了我的需求。这类应用应该不少，但是直接的桌面应用界面都非常麻烦，不够简洁，metro界面则没有找到这样一款应用，可能是大家觉得太简单了吧。于是我准备自己来写这样一个东西。

　　初步目标是，写一个应用，全屏显示当前时间。

　　 

　　然后我想增加一些功能，我在使用时可能需要计时和倒计时功能来规范工作时间。然后我想更改字的颜色以符合我的癖好。

　　更改颜色很简单，只需要加一个变量和一个函数就够了。但是其他的功能会比较麻烦。

　　因为理论上来说都是显示时间，于是我新建了一个叫TimeShower的类，准备现在时间显示，计时，倒计时分别用这样一个类来表示，除了计时方面共用同样的显示函数。

　　计时和倒计时也不难。计时可以从0开始每秒加一，然后暂停功能自然而然的实现。倒计时也简单，将用户给出的秒数每秒减一显示就可以了。因为要让用户选择倒计时的开始时间，对于倒计时界面增加了一个箭头的显示。按动上下键选择时，箭头颜色会发生变化使容易看见。

　　　　

　　似乎该实现的功能都实现了，但是单一的字符大小有一点不是很适合所有情况，所以我添加了一个函数以改变所有显示的大小。但是一个字符的显示有许多参数（都是自己设置的），包括笔画宽度，字宽度，字高度，数字间距，数字与间隔号间距，两旁间距，上下间距等。如果有如此多的函数设置起来也会非常麻烦，然后会出现许多可能的bug比如 笔画宽度 * 2 < 字符宽度 就会出现一些奇怪的事。同样的，如果字宽度和字高度比例达到很奇怪的数值比如1：1也会很难看。所以我设计了一个函数，传入参数只有一个简单的百分比（一个0~1之间的小数），表示的意思是字高占据屏幕高度的比例，一般（如上面的图）是0.5 。当然也可以自己改动。使用这个函数后整个界面默认居中显示。

　　突然，我发现了一个我没有考虑到的点。现在我有三个TImeShower类，但是我有可能在倒计时运行的过程中查看现在的时间。这样就有一个问题，如何实现在显示某个TImeShower时，其他的TimeShower一样在运行。一开始我想到了多线程，但是想想又觉得太麻烦，于是我就想伪造这样一个情况。新建了一个TImeControler类，在里面添加三个TimeShower类分别是现在时间，倒计时，计时。接着更改了计时和倒计时的机制。计时改为记录一个当前时间（这个时间在每次更新显示时即不暂停又在显示时会自动更新），记录一个显示时间（即显示的那个时钟），记录一个上次挂起的时间（退出时会挂起），当然还有一个是否暂停中的bool变量。每次进入时先判断是否是暂停状态，如果是，那么显示时间就赋值为挂起时间，如果不是，那么显示时间就是挂起时间加上现在时间（ctime的time（）函数）减去挂起时的当前时间。倒计时改为无挂起时间时进入选择时间，有挂起时间时，显示时间赋值为挂起时间减去现在时间加上挂起时的当前时间。

　　这样，我们就实现了三种时间的同时（看起来同时）的进行。

　　接下来，我又觉得黑色的背景太过难看，于是添加了一段显示背景的代码。首先利用easyX提供的库读入图片，得到颜色表（即每个像素对应的颜色）。再将颜色表显示在屏幕上。因为数字需要重绘，重绘时不能像原来直接用黑色覆盖而需要将一个数组中的某些值复制到另一个数组中，效率有明显的降低。我终于能够理解为什么在苹果的早起移动设备中（比如ipod touch 2）不能设置桌面背景图片了。

　　背后有了图片，我就想让文字透明显示。透明也很简单。比如两层的颜色，前景的透明度为50%的意思就是每个像素的RGB三个值，就是前景的RGB三个值乘上50%再加上背景的RGB三色值乘上50%。就像调颜料一样按不同比例添加最后比例和为1就行了。这个又会多一次计算，不过因为字的颜色统一，透明度统一，可以预先计算。

　　最后呢，我尝试使用字符的图片来代替数字显示。这一块代码量比较大，然后写的时候兼容调比例函数时发现一个问题。原来我是在上一个设置的基础上调比例，比如说先调至很小的60 * 24像素，再调大至300 * 120像素，虽然读入时是300 * 120像素的较高清图片，但是经过这个过程之后就会全是马赛克。。。改过之后就好了。

　　

　　于是现在我的开发就算完成了，因为懒没有写用户界面什么的，在运行中改设置和操控会很奇葩，但是总体质量比高中的好了不少。有什么不足吗？有，代码上还是太多蛮干而不是利用面向对象的特性，visual studio运用的也不太熟练，时间函数上也用的精确度很低的系统函数。这些方面在我以后的程序中也会不断的改进。

　　下面就贴一下代码吧：

#include "targetver.h"
#include <stdio.h>
#include <tchar.h>
#include <ctime>
#include <fstream>
#include <graphics.h>
#include <conio.h>
#include <algorithm>

#define SCREENX GetSystemMetrics(SM_CXSCREEN)
#define SCREENY GetSystemMetrics(SM_CYSCREEN)

void FullScreen()
{
    HWND hwnd = GetHWnd();
    SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) - WS_CAPTION);
    SetWindowPos(hwnd, HWND_TOP, 0, 0, SCREENX, SCREENY, SWP_SHOWWINDOW);
}


struct NumberBox
{
    bool exist[600][200];

    NumberBox ChangeXY(int newx, int newy, int x, int y,NumberBox* Origin = NULL)
    {
        if (Origin == NULL) Origin = this;
        NumberBox ret;
        double xratio = (double)x / newx;
        double yratio = (double)y / newy;
        for (int i = 0; i < newx; ++i)
        {
            for (int j = 0; j < newy; ++j)
            {
                ret.exist[j][i] = Origin->exist[ (int)(j * yratio) ][ (int)(i * xratio) ];
            }
        }
        return ret;
    }
};

class NumberShower
{
private:
    IMAGE Number;
    DWORD Graph[300][1200];
    DWORD* Buffer;
public:
    NumberShower()
    {
        loadimage(&Number, L"Number.bmp", 1200, 300);
        Buffer = GetImageBuffer(&Number);
        DWORD* end = Buffer + 1200 * 300;
        DWORD* j = &Graph[0][0];    
        for (DWORD* i = Buffer; i < end; ++i, ++j)
            *j = *i;
        return;
    }

    NumberBox GetNumber(int t)
    {
        if (t == 0) t = 10;
        int sx = t * 120 - 120;
        int sy = 0;
        int ex = t * 120 - 1;
        int ey = 300;
        NumberBox ret;
        for (int j = sy; j < ey; ++j)
        {
            for (int i = sx; i <= ex; ++i)
            {
                ret.exist[j - sy][i - sx] = Graph[j][i]? 0 : 1;
            }
        }
        return ret;
    }
};

class TimeShower
{
private:
    int AllColor;
    int left;
    int top;
    int xsize;
    int ysize;
    int lwidth;
    int gapsize;
    int DNsize;
    bool pause;
    double alpha;

    DWORD* Buffer;
    int CoTab[864][1536];
    int rstart;// = xsize - lwidth;
    int midstart;// = (ysize - lwidth) / 2;
    int mid;// = ysize / 2;
    int botstart;// = ysize - lwidth;
    time_t ntime;
    time_t sustime;
    time_t lastime;
    tm nowtime;
    NumberShower TypeOr;
    NumberBox Type[10];
public:

    //Source Draw

    int GetAlphaColor(int color,double alph = -1)
    {
        if (alph == -1) alph = alpha;
        if (alph > 1 || alph < 0) return 0;
        int R = color >> 16;
        int G = (color >> 8) & 255;
        int B = color & 255;
        R *= alph;
        G *= alph;
        B *= alph;
        return R << 16 | G << 8 | B;
    }

    void ChangeAlpha(double alph)
    {
        if (alph < 0 || alph > 1) return;
        alpha = alph;
    }

    void VEline(int sx, int sy, bool half = false, int color = -1, double alph = -1)//^v
    {
        if (color = -1) color = this->AllColor;
        if (alph == 0)
        {
            int ex = sx + lwidth;
            int ey = sy + ysize;
            for (int i = sx; i < ex; ++i)
            {
                for (int j = sy; j < ey; ++j)
                {
                    putpixel(i , j , CoTab[j][i]);
                }
            }
            return;
        }
        if (alph == -1) alph = alpha;
        int ys = ysize;
        if (half)
            ys = ysize / 2;
        color = GetAlphaColor(color, alph);
        for (int i = 0; i < lwidth; ++i)
        {
            for (int j = 0; j < ys; ++j)
            {
                putpixel(i + sx, j + sy, color + GetAlphaColor(CoTab[j + sy][i + sx],1-alph) );
            }
        }
        return;
    }

    void HOline(int sx, int sy, int color = -1, double alph = -1)//<-->
    {
        if (color = -1) color = this->AllColor;
        if (alph == 0)
        {
            int ex = sx + xsize;
            int ey = sy + lwidth;
            for (int i = sx; i < ex; ++i)
            {
                for (int j = sy; j < ey; ++j)
                {
                    putpixel(i , j, CoTab[j][i]);
                }
            }
            return;
        }
        if (alph == -1) alph = alpha;
        int xs = xsize;
        color = GetAlphaColor(color, alph);
        for (int i = 0; i < xs; ++i)
        {
            for (int j = 0; j < lwidth; ++j)
            {
                putpixel(i + sx, j + sy, color + GetAlphaColor(CoTab[j + sy][i + sx], 1 - alph));
            }
        }
        return;
    }

    void Dot(int sx, int sy, int color = -1,double alph = -1)
    {
        if (color = -1) color = this->AllColor;
        if (alph == -1) alph = alpha;
        color = GetAlphaColor(color, alph);
        for (int i = 0; i < lwidth; ++i)
        {
            for (int j = 0; j < lwidth; ++j)
            {
                putpixel(i + sx, j + sy, color + GetAlphaColor(CoTab[j + sy][i + sx], 1 - alph));
            }
        }
        return;
    }

    void UperTri(int sx, int sy, int color = -1,double alph = -1)
    {
        if (color == -1) color = AllColor;
        if (alph == -1) alph = alpha;
        color = GetAlphaColor(color, alph);
        for (int j = 0; j <= xsize/4; ++j)
        {
            for (int i = j - xsize/4; i <= xsize/4 - j; ++i)
            {
                int x = sx + (xsize / 2) + i;
                int y = sy - lwidth - j;
                putpixel(x, y, color + GetAlphaColor(CoTab[y][x], 1 - alph));
            }
        }
        return;
    }

    void LowerTri(int sx, int sy, int color = -1, double alph = -1)
    {
        if (color == -1) color = AllColor;
        if (alph == -1) alph = alpha;
        color = GetAlphaColor(color, alph);
        for (int j = 0; j <= xsize/4; ++j)
        {
            for (int i = - xsize/4 +j; i <= -j + xsize/4 ; ++i)
            {
                int x = sx + (xsize / 2) + i;
                int y = sy + lwidth + ysize + j;
                putpixel(x,y, color + GetAlphaColor(CoTab[y][x], 1 - alph));
            }
        }
        return;
    }

    //NumberDraw

    void DrawType(NumberBox in, int sx, int sy, int color = -1, double alph = -1) 
    {
        if (alph == 0)
        {
            for (int j = 0; j < ysize; ++j)
            {
                for (int i = 0; i < xsize; ++i)
                {
                    if (in.exist[j][i])
                    {
                        putpixel(i + sx, j + sy,CoTab[j + sy][i + sx]); 
                    }
                }
            }
            return;
        }
        if (color == -1) color = AllColor;
        if (alph == -1) alph = alpha;
        color = GetAlphaColor(color, alph);
        for (int j = 0; j < ysize; ++j)
        {
            for (int i = 0; i < xsize; ++i)
            {
                if (in.exist[j][i])
                {
                    putpixel(i + sx, j + sy, color + GetAlphaColor(CoTab[j + sy][i + sx], 1 - alph)); 
                }
            }
        }
        return;
    }

    void p1(int sx, int sy, double alph = -1)
    {
        VEline(sx + rstart, sy,false,-1,alph);
    }

    void p2(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy,-1,alph);
        HOline(sx, sy + midstart,-1,alph);
        HOline(sx, sy + botstart,-1,alph);
        VEline(sx, sy + mid, true,-1,alph);
        VEline(sx + rstart, sy, true,-1,alph);
    }

    void p3(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy,-1,alph);
        HOline(sx, sy + midstart ,- 1, alph);
        HOline(sx, sy + botstart, -1, alph);
        VEline(sx + rstart, sy,0 , -1, alph);
    }

    void p4(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy + midstart, -1, alph);
        VEline(sx, sy, true, -1, alph);
        VEline(sx + rstart, sy,0, -1, alph);
    }

    void p5(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy, -1, alph);
        HOline(sx, sy + midstart, -1, alph);
        HOline(sx, sy + botstart, -1, alph);
        VEline(sx + rstart, sy + mid, true, -1, alph);
        VEline(sx, sy, true, -1, alph);
    }

    void p6(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy, -1, alph);
        HOline(sx, sy + midstart, -1, alph);
        HOline(sx, sy + botstart, -1, alph);
        VEline(sx + rstart, sy + mid, true, -1, alph);
        VEline(sx, sy,0,  -1, alph);
    }

    void p7(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy, -1, alph);
        VEline(sx + rstart, sy,0, -1, alph);
    }

    void p8(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy, -1, alph);
        HOline(sx, sy + midstart, -1, alph);
        HOline(sx, sy + botstart, -1, alph);
        VEline(sx, sy,0, -1, alph);
        VEline(sx + rstart, sy,0, -1, alph);
    }

    void p9(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy, -1, alph);
        HOline(sx, sy + midstart, -1, alph);
        HOline(sx, sy + botstart, -1, alph);
        VEline(sx + rstart, sy,0, -1, alph);
        VEline(sx, sy, true, -1, alph);
    }

    void p0(int sx, int sy, double alph = -1)
    {
        HOline(sx, sy, -1, alph);
        HOline(sx, sy + botstart, -1, alph);
        VEline(sx, sy,0, -1, alph);
        VEline(sx + rstart, sy,0, -1, alph);
    }

    void Clean(int sx, int sy, int ex, int ey)
    {
        for (int j = sy; j <= ey; ++j)
        {
            for (int i = sx; i <= ex; ++i)
            {
                putpixel(i, j, CoTab[j][i]);
            }
        }
    }

    void CleanHuge(int sx, int sy)
    {
//        p8(sx, sy, 0);
        Clean(sx, sy, sx + xsize, sy + ysize);
        UperTri(sx, sy, -1, 0);
        LowerTri(sx, sy, -1, 0);
    }

    void DrawNumber(int sx, int sy, int t, double alph = -1)
    {
        CleanHuge(sx, sy);
/*        if (t == 1) p1(sx, sy,alph);
        if (t == 2) p2(sx, sy, alph);
        if (t == 3) p3(sx, sy, alph);
        if (t == 4) p4(sx, sy, alph);
        if (t == 5) p5(sx, sy, alph);
        if (t == 6) p6(sx, sy, alph);
        if (t == 7) p7(sx, sy, alph);
        if (t == 8) p8(sx, sy, alph);
        if (t == 9) p9(sx, sy, alph);
        if (t == 0) p0(sx, sy, alph);
*/
        DrawType(Type[t],sx,sy,-1,alph );
    }

    void DrawTwo(int sx, int sy, int number,double alph  = -1)
    {
        DrawNumber(sx, sy, number / 10, alph);
        DrawNumber(sx + xsize + gapsize, sy, number % 10, alph);
    }

    void DrawPoint(int sx, int sy,double alph = -1)
    {
        Dot(sx, sy + ysize / 3 - lwidth / 2, alph);
        Dot(sx, sy + 2 * ysize / 3 - lwidth / 2, alph);
    }

    void GetCoTab()
    {
        Buffer = GetImageBuffer();
        DWORD* end = Buffer + SCREENX * SCREENY;
        int* j = &CoTab[0][0];
        for (DWORD* i = Buffer; i < end; ++i, ++j)
        {
            *j = (*i >> 16) | (*i & 65280) | ((*i & 255) << 16);
        }
    }

    TimeShower(int AC = RGB(255, 255, 255), int l = 0, int t = 0, int x = 120, int y = 300, int w = 20, int g = 20, int DN = 60,double alph = 0.5)
    {
//        BeginBatchDraw();
        for (int i = 0; i <= 9; ++i)
            Type[i] = TypeOr.GetNumber(i);
        alpha = alph;
        pause = false;
        sustime = 0;
        lastime = 0;
        AllColor = AC;
        left = l;
        top = t;
        xsize = x;
        ysize = y;
        lwidth = w;
        gapsize = g;
        DNsize = DN;
        ntime = time(0);
        localtime_s(&nowtime, &ntime);
        rstart = xsize - lwidth;
        midstart = (ysize - lwidth) / 2;
        mid = ysize / 2;
        botstart = ysize - lwidth;
        return;
    }

    void ChangeInfo(int AC = RGB(255, 255, 255), int l = 0, int t = 0, int x = 120, int y = 300, int w = 20, int g = 20, int DN = 60)
    {
        AllColor = AC;
        left = l;
        top = t;
        xsize = x;
        ysize = y;
        for (int i = 0; i <= 9; ++i)
        {
            Type[i] = TypeOr.GetNumber(i);
            Type[i] = Type[i].ChangeXY(xsize, ysize,120,300);
        }
        lwidth = w;
        gapsize = g;
        DNsize = DN;
        rstart = xsize - lwidth;
        midstart = (ysize - lwidth) / 2;
        mid = ysize / 2;
        botstart = ysize - lwidth;
        return;
    }

    void GetNowTime()
    {
        ntime = time(0);
    }

    void CleanTime()
    {
        ntime = 0;
    }

    void IncTime()
    {
        ntime++;
    }

    void SetTime(long long tim)
    {
        ntime = tim;
    }

    void DecTime()
    {
        ntime--;
        if (ntime < 0) ntime = 0;
    }

    void AutoSize(double ratio = 0.4,int x = SCREENX,int y = SCREENY)
    {
        if (ratio < 0 || ratio >= 0.7) return;
        ysize = y * ratio;
        top = (y - ysize) / 2;
        xsize = ysize * 0.618 / 2;
        for (int i = 0; i <= 9; ++i)
        {
            Type[i] = TypeOr.GetNumber(i);
            Type[i] = Type[i].ChangeXY(xsize, ysize, 120, 300);
        }
        lwidth = xsize / 6;
        gapsize = lwidth * 2;
        DNsize = gapsize * 1.5;
        left = (x - (DNsize * 4 + gapsize * 3 + xsize * 6)) / 2;
        rstart = xsize - lwidth;
        midstart = (ysize - lwidth) / 2;
        mid = ysize / 2;
        botstart = ysize - lwidth;
        return;
    }

    void AutoSize(int sx, int sy, int nx, int ny, double ratio = 0.4)
    {
        int x = nx - sx;
        int y = ny - sy;
        if (x <= 0 || y <= 0) return;
        if (ratio < 0 || ratio >= 0.7) return;
        ysize = y * ratio;
        top = (y - ysize) / 2 + sy;
        xsize = ysize * 0.618 / 2;
        lwidth = xsize / 6;
        gapsize = lwidth * 2;
        DNsize = gapsize * 1.5;
        left = (x - (DNsize * 4 + gapsize * 3 + xsize * 6)) / 2 + sx;
        rstart = xsize - lwidth;
        midstart = (ysize - lwidth) / 2;
        mid = ysize / 2;
        botstart = ysize - lwidth;
        return;
    }

    void DrawTIMER(bool local = true,double alph = -1)
    {
        if (local) localtime_s(&nowtime, &ntime);
        else
            gmtime_s(&nowtime, &ntime);
        int hour = nowtime.tm_hour;
        int min = nowtime.tm_min;
        int sec = nowtime.tm_sec;
        int nowx = left;
        DrawTwo(nowx, top, hour,alph);
        nowx += xsize * 2 + gapsize + DNsize;
        DrawPoint(nowx, top, alph);
        nowx += DNsize + lwidth;
        DrawTwo(nowx, top, min, alph);
        nowx += xsize * 2 + gapsize + DNsize;
        DrawPoint(nowx, top, alph);
        nowx += DNsize + lwidth;
        DrawTwo(nowx, top, sec, alph);
        FlushBatchDraw();
    }//need

    void DrawChoosenNumber(int sx,int sy,int t,double alph = -1)
    {
        CleanHuge(sx, sy); 
/*        if (t == 1) p1(sx, sy, alph);
        if (t == 2) p2(sx, sy, alph);
        if (t == 3) p3(sx, sy, alph);
        if (t == 4) p4(sx, sy, alph);
        if (t == 5) p5(sx, sy, alph);
        if (t == 6) p6(sx, sy, alph);
        if (t == 7) p7(sx, sy, alph);
        if (t == 8) p8(sx, sy, alph);
        if (t == 9) p9(sx, sy, alph);
        if (t == 0) p0(sx, sy, alph);
*/
        DrawType(Type[t], sx, sy, -1, alph);
        UperTri(sx, sy, alph);
        LowerTri(sx, sy, alph);
    }

    void DrawChangingNumber(int sx, int sy, int t,bool ul,double alph = -1)
    {
        CleanHuge(sx, sy);
/*        if (t == 1) p1(sx, sy, alph);
        if (t == 2) p2(sx, sy, alph);
        if (t == 3) p3(sx, sy, alph);
        if (t == 4) p4(sx, sy, alph);
        if (t == 5) p5(sx, sy, alph);
        if (t == 6) p6(sx, sy, alph);
        if (t == 7) p7(sx, sy, alph);
        if (t == 8) p8(sx, sy, alph);
        if (t == 9) p9(sx, sy, alph);
        if (t == 0) p0(sx, sy, alph);
*/
        DrawType(Type[t], sx, sy, -1, alph);
        int orcolor = AllColor;
        AllColor -= RGB(0, 200, 50);
        if (ul)
        {
            UperTri(sx, sy, alph);
            AllColor = orcolor;
            LowerTri(sx, sy, alph);
        }
        else
        {
            LowerTri(sx, sy, alph);
            AllColor = orcolor;
            UperTri(sx, sy, alph);
        }
    }

    void DrawChoosenTwo(int sx, int sy, int number,double alph = -1)
    {
        DrawChoosenNumber(sx, sy, number / 10, alph);
        DrawChoosenNumber(sx + xsize + gapsize, sy, number % 10, alph);
    }

    void DrawChangingTwo(int sx, int sy, int number,bool ul)
    {
        DrawChangingNumber(sx, sy, number / 10,ul);
        DrawChangingNumber(sx + xsize + gapsize, sy, number % 10,ul);
    }

    void DrawChoosenTIMER(int chspart,double alph = -1)
    {
        gmtime_s(&nowtime, &ntime);
        int hour = nowtime.tm_hour;
        int min = nowtime.tm_min;
        int sec = nowtime.tm_sec;
        int nowx = left;
        if (chspart == 2)
            DrawChoosenTwo(nowx, top, hour, alph);
        else
            DrawTwo(nowx, top,hour);
        nowx += xsize * 2 + gapsize + DNsize;
        DrawPoint(nowx, top, alph);
        nowx += DNsize + lwidth;
        if (chspart == 1)
            DrawChoosenTwo(nowx, top, min, alph);
        else
            DrawTwo(nowx, top, min);
        nowx += xsize * 2 + gapsize + DNsize;
        DrawPoint(nowx, top, alph);
        nowx += DNsize + lwidth;
        if (chspart == 0)
            DrawChoosenTwo(nowx, top, sec, alph);
        else
            DrawTwo(nowx, top, sec, alph);
        FlushBatchDraw();
    }

    void DrawChangingTIMER(int chspart,bool ul,double alph = -1)
    {
        gmtime_s(&nowtime, &ntime);
        int hour = nowtime.tm_hour;
        int min = nowtime.tm_min;
        int sec = nowtime.tm_sec;
        int nowx = left;
        if (chspart == 2)
            DrawChangingTwo(nowx, top, hour,ul);
        else
            DrawTwo(nowx, top, hour, alph);
        nowx += xsize * 2 + gapsize + DNsize;
        DrawPoint(nowx, top, alph);
        nowx += DNsize + lwidth;
        if (chspart == 1)
            DrawChangingTwo(nowx, top, min,ul);
        else
            DrawTwo(nowx, top, min, alph);
        nowx += xsize * 2 + gapsize + DNsize;
        DrawPoint(nowx, top, alph);
        nowx += DNsize + lwidth;
        if (chspart == 0)
            DrawChangingTwo(nowx, top, sec,ul);
        else
            DrawTwo(nowx, top, sec, alph);
        FlushBatchDraw();
    }

    void SwitchTimeControl()
    {
        CleanTime();
        int nowpos = 0;
        int add[3] = { 1,60,3600 };
        int allt = 86400;
        DrawChoosenTIMER(nowpos);
        while (1)
        {
            if (!_kbhit()) continue;
            char ch = _getch();
            if (ch == 13) 
            {
                DrawTIMER(0);
                return;
            }
            if (ch != 0 && ch != -32) continue;
            DrawChoosenTIMER(nowpos);
            ch = _getch();
            if (ch == 72)
            {
                ntime += add[nowpos];
                if (ntime >= allt)
                    ntime = 0;
                DrawChangingTIMER(nowpos,true);
                Sleep(100);
                DrawChoosenTIMER(nowpos);
            }
            if (ch == 80)
            {

                ntime -= add[nowpos];
                if (ntime < 0) ntime += allt;
                DrawChangingTIMER(nowpos,false);
                Sleep(100);
                DrawChoosenTIMER(nowpos);
            }
            if (ch == 75)
            {
                nowpos = (nowpos + 1) % 3;
            }
            if (ch == 77)
            {
                nowpos = nowpos - 1;
                if (nowpos < 0) nowpos = 2;
            }
            DrawChoosenTIMER(nowpos);
        }
    }

    void Suspend()
    {
        sustime = ntime;
        lastime = time(0);
    }

    int CurrentTimeShow()
    {
        int lasttime = time(0);
        while (1)
        {
            if (_kbhit())
            {
                char ch = _getch();
                if (ch == 'c' || ch == 'C')
                    return 2;
                if (ch == 't' || ch == 'T')
                    return 3;
                if (ch == 'q' || ch == 'Q')
                    return 4;
                if (ch == 'x' || ch == 'X')
                    return 0;
                if (ch == 's' || ch == 'S')
                    return 5;
                if (ch == 'r' || ch == 'R')
                    return 6;
            }
            if (time(0) != lasttime)
            {
                GetNowTime();
                DrawTIMER();
                lasttime = time(0);
            }
            Sleep(50);
        }
        return 0;
    }

    int DecTimeShow()
    {
        int lasttime = time(0);
        if (!sustime)
            SwitchTimeControl();
        else
        {
            ntime = sustime - (time(0) - lastime);
            if (ntime < 0) ntime = 0;
            DrawTIMER(0);
        }
        while (1)
        {
            if (_kbhit())
            {
                char ch = _getch();
                if (ch == 'n' || ch == 'N')
                {
                    Suspend();
                    return 1;
                }
                if (ch == 't' || ch == 'T')
                {
                    Suspend();
                    return 3;
                }
                if (ch == 'x' || ch == 'X')
                {
                    Suspend();
                    return 0;
                }
                if (ch == 'q' || ch == 'Q')
                {
                    Suspend();
                    return 4;
                }
                if (ch == 's' || ch == 'S')
                {
                    Suspend();
                    return 5;
                }
                if (ch == 'r' || ch == 'R')
                {
                    Suspend();
                    return 6;
                }
                if (ch == 'a' || ch == 'A')
                {
                    sustime = 0;
                    return 2;
                }
            }
            if (time(0) != lasttime)
            {
                DecTime();
                DrawTIMER(0);
                lasttime = time(0);
            }
            Sleep(50);
        }
        return 0;
    }

    int IncTimeShow()
    {
        int lasttime = time(0);
        if (sustime == 0)
        {
            ntime = 0;
            DrawTIMER(0);
            char ch2;
            while (ch2 = _getch())
            {
                if (ch2 == 13) break;
            }
        }
        else
        {
            if (!pause)
                ntime = sustime + time(0) - lastime;
            else
                ntime = sustime;
            DrawTIMER(0);
        }
        while (1)
        {
            if (_kbhit())
            {
                char ch = _getch();
                if (ch == 'n' || ch == 'N')
                {
                    Suspend();
                    return 1;
                }
                if (ch == 'c' || ch == 'C')
                {
                    Suspend();
                    return 2;
                }
                if (ch == 'x' || ch == 'X')
                {
                    Suspend();
                    return 0;
                }
                if (ch == 'q' || ch == 'Q')
                {
                    Suspend();
                    return 4;
                }
                if (ch == 's' || ch == 'S')
                {
                    Suspend();
                    return 5;
                }
                if (ch == 'a' || ch == 'A')
                {
                    sustime = 0;
                    return 3;
                }
                if (ch == 'r' || ch == 'R')
                {
                    Suspend();
                    return 6;
                }
                if (ch == 13)
                    pause = !pause;
            }
            if (time(0) != lasttime )
            {
                if (!pause)
                {
                    IncTime();
                    DrawTIMER(0);
                }
                lasttime = time(0);
            }
            Sleep(50);
        }
        return 0;
    }

};

class TimerControler
{
private:
    TimeShower NowTime, DecTime, IncTime;
    IMAGE BackGround;

public:
    void TimerControl(double ratio = 0.5, int colo = RGB(255, 255, 255),double alpha = 0.6)
    {
        loadimage(&BackGround, _T("test.jpg"),SCREENX,SCREENY);
        putimage(0,0,&BackGround);
        NowTime.ChangeInfo(colo);
        DecTime.ChangeInfo(colo);
        IncTime.ChangeInfo(colo);
        NowTime.AutoSize(ratio);
        IncTime.AutoSize(ratio);
        DecTime.AutoSize(ratio);
        NowTime.ChangeAlpha(alpha);
        DecTime.ChangeAlpha(alpha);
        IncTime.ChangeAlpha(alpha);
        NowTime.GetCoTab();
        IncTime.GetCoTab();
        DecTime.GetCoTab();
        int t = NowTime.CurrentTimeShow();
        while (1)
        {
            if (t == 1)
                t = NowTime.CurrentTimeShow();
            if (t == 2)
                t = DecTime.DecTimeShow();
            if (t == 3)
                t = IncTime.IncTimeShow();
            if (t == 4)
            {
                int r, g, b;
                scanf_s("%d%d%d", &r,&g,&b);
                colo = RGB(r, g, b);
                NowTime.ChangeInfo(colo);
                DecTime.ChangeInfo(colo);
                IncTime.ChangeInfo(colo);
                NowTime.AutoSize(ratio);
                IncTime.AutoSize(ratio);
                DecTime.AutoSize(ratio);
                t = 1;
            }
            if (t == 5)
            {
                scanf_s("%lf", &ratio); 
                initgraph(SCREENX, SCREENY);
                FullScreen();
                putimage(0, 0, &BackGround);
                NowTime.AutoSize(ratio);
                IncTime.AutoSize(ratio);
                DecTime.AutoSize(ratio);
                t = 1;
            }
            if (t == 6)
            {
                scanf_s("%lf", &alpha);
                NowTime.ChangeAlpha(alpha);
                DecTime.ChangeAlpha(alpha);
                IncTime.ChangeAlpha(alpha);
                t = 1;
            }
            if (t == 0)
                return;
        }
    }

};

#include "stdafx.h"
#include "TIMER.h"
using namespace std;

TimerControler TimeCo;
int main()
{
    initgraph(SCREENX, SCREENY);
    FullScreen();
    BeginBatchDraw();
    TimeCo.TimerControl();
    closegraph();
    return 0;
}