Draw Graphic

#include <windows.h>
#include <math.h>
#include <stdio.h>

#define TIMER_INT 10
#define WINDOW_W 640
#define WINDOW_H 480
#define WINDOW_X_COR 20
#define WINDOW_Y_COR 60
#define MAX_COUNT 1001
#define AMPLITUDE 2.0
#define FREQUENCY 5.0
#define PI 3.1415926535
#define GR_COLOR RGB(255, 0, 0)
#define REC_COLOR RGB(0, 0, 0)
#define LINE_WIDTH 2
#define OFFSET 25
#define RESOLURION 6

int TimerID = 1;
int x[MAX_COUNT], y[MAX_COUNT];
int count_of_points = 0;
int xView, yView;
float y_max = 0;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
void DrawArray(HWND& hwnd, HDC& hdc, PAINTSTRUCT& ps, int* x, int* y, const int count_of_points);
void CalcGraph(int* x, int* y, const int count_of_points);
void TestTimer(HWND& hwnd);
int FindMax(const int* arr, const int n);
int FindMin(const int* arr, const int n);

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    const char g_szClassName[] = "Lab3WindowClass";
    const char WinName[] = "Лабаратораная работа 3 - Лисин, Никифоров";

    WNDCLASSEX wc;

    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = 0;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = NULL;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)WHITE_PEN;
    wc.lpszMenuName = NULL;
    wc.lpszClassName = g_szClassName;
    wc.hIconSm = NULL;

    if (!RegisterClassEx(&wc)){
        MessageBox(NULL, "Win Reg Failed!", "Error", MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    HWND hwnd;

    hwnd = CreateWindowEx(
        NULL,
        g_szClassName,
        WinName,
        WS_OVERLAPPEDWINDOW,//WS_POPUPWINDOW,
        WINDOW_X_COR, WINDOW_Y_COR, WINDOW_W, WINDOW_H,
        NULL, NULL,
        hInstance, NULL);

    if (hwnd == NULL){
        MessageBox(NULL, "Failed to create window!", "Error", MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG Msg;
    BOOL bRet;

    while ((bRet = GetMessage(&Msg, NULL, 0, 0)) != 0){
        if (bRet == -1){
            MessageBox(NULL, "Error in GetMessage()", "Error", MB_ICONEXCLAMATION | MB_OK);
        }
        else{
            TranslateMessage(&Msg);
            DispatchMessage(&Msg);
        }
    }
    return Msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam){
    switch (msg)
    {
    case WM_CLOSE:
        DestroyWindow(hwnd);
        break;

    case WM_DESTROY:
        KillTimer(hwnd, TimerID);
        PostQuitMessage(0);
        break;

    case WM_CREATE:
        SetTimer(hwnd, TimerID, TIMER_INT, NULL);
        CalcGraph(x, y, MAX_COUNT);
        break;

    case WM_PAINT:
    {
        HDC hdc;
        PAINTSTRUCT ps;

        hdc = BeginPaint(hwnd, &ps);

        SetMapMode(hdc, MM_ISOTROPIC); //логические единицы отображаем, как физические
        SetWindowExtEx(hdc, xView, xView, NULL); //длина осей
        SetViewportExtEx(hdc, xView, xView, NULL); //определяем облась вывода
        SetViewportOrgEx(hdc, OFFSET, yView / 2, NULL); //начало координат

        HPEN hpen = CreatePen(PS_SOLID, LINE_WIDTH, REC_COLOR);
        HBRUSH hbrush = (HBRUSH)GetStockObject(NULL_BRUSH);

        //отрисовка ограничительного прямоугольника
        SelectObject(hdc, hbrush);
        SelectObject(hdc, hpen);
        Rectangle(hdc, 0, -yView / 2 + OFFSET, xView - 2 * OFFSET, yView / 2 - OFFSET);
        DeleteObject(hpen);
        DeleteObject(hbrush);

        //вывод графика
        DrawArray(hwnd, hdc, ps, x, y, count_of_points);

        EndPaint(hwnd, &ps);
        break;
    }

    case WM_TIMER:
    {
        if (count_of_points > MAX_COUNT){
            KillTimer(hwnd, TimerID);
            //убиваем таймер без возможности перезапуска
            TimerID = 0;
        }
        else{
            count_of_points++;
        }
        InvalidateRect(hwnd, NULL, NULL);
        break;
    }

    case WM_SIZE:
        //получаем размеры клиентской области
        xView = LOWORD(lParam);
        yView = HIWORD(lParam);

        switch (wParam){
        case SIZE_RESTORED:
        {
            TestTimer(hwnd);
            InvalidateRect(hwnd, NULL, TRUE);
            break;
        }
        case SIZE_MINIMIZED:
        {
            KillTimer(hwnd, TimerID);
            TimerID = -1;
            break;
        }
        case SIZE_MAXIMIZED:
        {
            TestTimer(hwnd);
            InvalidateRect(hwnd, NULL, TRUE);
            break;
        }
        default:
            InvalidateRect(hwnd, NULL, TRUE);
            break;
        }

    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
        break;
    }
    return 0;
}

void CalcGraph(int* x, int* y, const int n)
{
    for (int i = 0; i < n; ++i){
        //получаем координаты графика
        x[i] = i;
        y[i] = round(AMPLITUDE * tan(round(FREQUENCY) * i * (PI / (180 * RESOLURION))));
        //находим точки бесконечных значений
        if ((int)FREQUENCY * i % (90 * RESOLURION) == 0){
            y[i] = y[i-1];
        }
    }
    //находим максимальное значение функции
    y_max = (abs(FindMin(y, n)) + FindMax(y, n)) / 2;
}

void DrawArray(HWND& hwnd, HDC& hdc, PAINTSTRUCT& ps, int* x, int* y, const int n)
{
    //получем размер ограничительного прямоугольника
    float rec_h = yView - 2 * OFFSET;
    float rec_w = xView - 2 * OFFSET;
    //коэфициент маштабирования по Y
    float k_Y = rec_h / (y_max * 2);
    //коэфициент маштабирования по X
    float k_X = (float)rec_w / MAX_COUNT;

    HPEN hpen = CreatePen(PS_SOLID, LINE_WIDTH, GR_COLOR);
    SelectObject(hdc, hpen);
    MoveToEx(hdc, 0, 0, NULL);
    for (int i = 2; i < n; i++){
        MoveToEx(hdc, roundf(k_X * x[i - 2]), roundf(k_Y * y[i - 2]), (LPPOINT)NULL);
        LineTo(hdc, roundf(k_X * x[i - 1]), roundf(k_Y * y[i - 1]));
    }
    DeleteObject(hpen);
}

void TestTimer(HWND& hwnd)
{
    //проверяем работает ли таймер
    if (TimerID == -1)
        SetTimer(hwnd, TimerID = 1, TIMER_INT, NULL);
}

int FindMax(const int* arr, const int n){
    int max = arr[0];
    for (int i = 1; i < n; ++i)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }
    return max;
}

int FindMin(const int* arr, const int n){
    int min = arr[0];
    for (int i = 1; i < n; ++i)
    {
        if (arr[i] < min)
        {
            min = arr[i];
        }
    }
    return min;
}