Создание Windows приложения с использованием Win API и библиотек классов MFC

 

SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

 

// Center icon in client rectangle

int cxIcon = GetSystemMetrics(SM_CXICON);

int cyIcon = GetSystemMetrics(SM_CYICON);

CRect rect;

GetClientRect(&rect);

int x = (rect.Width() - cxIcon + 1) / 2;

int y = (rect.Height() - cyIcon + 1) / 2;

 

// Draw the icon

dc.DrawIcon(x, y, m_hIcon);

}

else

{

CDialogEx::OnPaint();

}

}

 

// The system calls this function to obtain the cursor to display while the user drags

//  the minimized window.

HCURSOR CKursovoyDlg::OnQueryDragIcon()

{

return static_cast<HCURSOR>(m_hIcon);

}

 

 

//============================ Функции  для построения графиков ============================

//Построение осей координат

void CKursovoyDlg::DrawAxis(CDC *pdc, RECT rectClient)

{

//Создание карандаша  (сплошной, толщина = 2 пикселя , цвет  темно-синий)

CPen pen(PS_SOLID,2,RGB(0,0,100));

//Привязка карандаша к нашей области

CGdiObject *oOld = pdc->SelectObject(&pen);

 

 

Рисунок 5 - Продолжение

      pdc->MoveTo(0, rectClient.bottom/2);

pdc->LineTo(rectClient.right, rectClient.bottom/2);

pdc->LineTo(rectClient.right - 5, rectClient.bottom/2 + 2);

pdc->MoveTo(rectClient.right, rectClient.bottom/2);

pdc->LineTo(rectClient.right - 5, rectClient.bottom/2 - 2);

pdc->MoveTo(rectClient.right/2, rectClient.bottom);

pdc->LineTo(rectClient.right/2, rectClient.top);

pdc->LineTo(rectClient.right/2 - 2, rectClient.top + 5);

pdc->MoveTo(rectClient.right/2, rectClient.top);

pdc->LineTo(rectClient.right/2 + 2, rectClient.top + 5);

   

//Результат выставить  в область

pdc->SelectObject(oOld);

}

 

//Закрашивание области

void CKursovoyDlg::FillRect(CDC *pdc, RECT rectClient)

{ 

//Создание карандаша  (сплошной, толщина = 1000 пикселей (чтобы  хватило на нашу область), цвет  белый)

CPen pen(PS_SOLID,1000,RGB(255,255,255));

//Привязка карандаша к нашей области

CGdiObject *oOld = pdc->SelectObject(&pen);

 

pdc->MoveTo(0, rectClient.bottom/2);

pdc->LineTo(rectClient.right, rectClient.bottom/2);

   

//Результат выставить  в область

pdc->SelectObject(oOld);

}

 

//Перерисовка черной рамки  по контуру области

//При закраске области  исчезает рамка - перерисовываем  её

void CKursovoyDlg::DrawBorder(CDC *pdc, RECT rectClient)

{ 

//Создание карандаша  (сплошной, толщина = 1 пиксель, цвет  черный)

CPen pen(PS_SOLID,1,RGB(0,0,0));

//Привязка карандаша к нашей области

CGdiObject *oOld = pdc->SelectObject(&pen);

 

pdc->MoveTo(0, 0);

pdc->LineTo(rectClient.right-1, 0);

pdc->LineTo(rectClient.right-1, rectClient.bottom-1);

pdc->LineTo(rectClient.left, rectClient.bottom-1);

pdc->LineTo(rectClient.left, rectClient.top);

   

//Результат выставить  в область

pdc->SelectObject(oOld);

}

 

//Рисование пределов интегрирования

void CKursovoyDlg::DrawLim(CDC *pdc, RECT rectClient)

{ 

//Создание карандаша  (пунктирный, толщина = 1 пиксель,  цвет черный)

CPen pen(PS_DASH,1,RGB(0,0,0));

//Привязка карандаша к нашей области

CGdiObject *oOld = pdc->SelectObject(&pen);

 

//шаг = ширине  пикчер контрола (для корректного  рисования единичного отрезка)

double STEP = x_end - x_start;

pdc->MoveTo(rectClient.right/2 + ((rectClient.right/STEP)*a), 0);

pdc->LineTo(rectClient.right/2 + ((rectClient.right/STEP)*a), rectClient.bottom);

pdc->MoveTo(rectClient.right/2 + ((rectClient.right/STEP)*b), 0);

 

Рисунок 5 - Продолжение

      pdc->LineTo(rectClient.right/2 + ((rectClient.right/STEP)*b), rectClient.bottom);

   

//Результат выставить  в область

pdc->SelectObject(oOld);

}

 

//Построение 1 графика

//CDC *pdc - указатель на контекст  устройства 

//RECT - область нашего пикчер  контрола (rectClient)

void CKursovoyDlg::DrawGraph(CDC *pdc, RECT rectClient)

{

//Создание карандаша  (сплошной, толщина = 2 пикселя, цвет  красный)

CPen pen(PS_SOLID,2,RGB(255,0,0));

//Привязка карандаша к нашей области

CGdiObject *oOld = pdc->SelectObject(&pen);

 

double x_current = x_start;  //Начальное значение текущего Х

double step = (x_end - x_start)/rectClient.right; //шаг перемещения по оси ОХ

double y_start = func1(x_start); //Начальное значение У

pdc->MoveTo(0, double(-y_start/step) + rectClient.bottom/2); //Перемещаем курсор в начальную точку

 

while(x_current < x_end)

{  

//Проходим все  значения по оси ОХ

x_current += step;

double y_current = func1(x_current);

 

//Если точка графика  функции попала в нашую область,  значит будем её рисовать

if(y_current<((x_end-x_start)/2))

{ 

//Объявление значений  Х и У предыдущей точки

double x_previous = x_current - step;

double y_previous = func1(x_previous);

//Объявление значений  Х и У следующей точки

double x_next = x_current + step;

double y_next = func1(x_next);

 

//Курсор перемещается  в место предыдущей точки

pdc->MoveTo(double(x_previous/step) + rectClient.right/2, double(-y_previous/step) + rectClient.bottom/2);

//Рисуется линия до текущей точки

pdc->LineTo(double(x_current/step) + rectClient.right/2, double(-y_current/step) + rectClient.bottom/2);

//Рисуется линия до следующей точки

pdc->LineTo(double(x_next/step) + rectClient.right/2, double(-y_next/step) + rectClient.bottom/2);

}

}

   

//Результат выставить  в область

pdc->SelectObject(oOld);

}

 

//Построение 2 графика

void CKursovoyDlg::DrawGraph2(CDC *pdc, RECT rectClient)

{

CPen pen(PS_SOLID,2,RGB(0,0,255));

CGdiObject *oOld = pdc->SelectObject(&pen);

 

 

double x_current = x_start;

 

Рисунок 5 - Продолжение

      double step = (x_end - x_start)/rectClient.right;

double y_start = func2(x_start);

pdc->MoveTo(0, double(-y_start/step) + rectClient.bottom/2);

 

while(x_current < x_end)

{  

x_current += step;

double y_current = func2(x_current);

 

if(y_current<((x_end-x_start)/2))

{ 

double x_previous = x_current - step;

double y_previous = func2(x_previous);

double x_next = x_current + step;

double y_next = func2(x_next);

 

pdc->MoveTo(double(x_previous/step) + rectClient.right/2, double(-y_previous/step) + rectClient.bottom/2);

pdc->LineTo(double(x_current/step) + rectClient.right/2, double(-y_current/step) + rectClient.bottom/2);

pdc->LineTo(double(x_next/step) + rectClient.right/2, double(-y_next/step) + rectClient.bottom/2);

}

}

   

//Результат выставить  в область

pdc->SelectObject(oOld);

}

//=========================================================================================

 

 

 

//============================= Функции  перевода чисел в с.с ==============================

//Функция перевода передаваемой  строки с числом любой системы  счисления 

//и перевод её в число  десятеричной системы 

double CKursovoyDlg::lea_to_dec(CString lea)

{

char *st = new char[50]; //задание длины строки st

    size_t convertedCharsw = 0; //задание необходимого параметра convertedCharsw

    wcstombs_s(&convertedCharsw, st, 50, lea, _TRUNCATE ); //конвертирование (взято с msdn)

 

double s, k;

int N, N_cl, L;

s = 0;  //Конечное значение числа в 10й системе = 0

N_cl = 0; //Число символов целой части обнуляем

N = strlen(st) - 1; //общее кол-во символов = длине строки минус заключительный 0

 

if(st[0]=='-')

N = strlen(st) - 2;

 

for (int i=0; st[i]!='.'; i++) //выяснение кол-ва символов целой части

N_cl++;

 

L = N_cl - 1;

 

if(st[0]=='-')

{L = N_cl - 2;}

//Объявление L как  числа символов целой части.  Причина:

// исходное число = 1258.12

// N_cl = 4

 

Рисунок 5 - Продолжение

      // L = 3

// B = основание системы счисления искомого числа

// целая часть получаемого числа = 1*B^L (L=3) (программный декремент L) +

// + 2*B^L (L=2) (программный декремент L) + 5*B^L (L=1) (программный декремент L) +

//  + 8*B^L (L=0). Далее  нахождение символа '.' (точка), обнуление  и декремент L

// дробная часть получаемого числа = 1*B^L (L=-1) (программный декремент L) +

// + 2*B^L (L=-2)

int o;

o=0;

//при наличии  символа  '-' - резервируем место  для него и начинаем сичтать  не с 0го, а с 1го

if(st[0]==L'-')

o=1;

 

  for (int i=o; st[i]!='\0'; i++)

{

//toupper - превращает  строчные символы в заглавные

switch (toupper(st[i]))

{

            case '0': k=0; break;

case '1': k=1; break;

            case '2': k=2; break;

            case '3': k=3; break;

            case '4': k=4; break;

            case '5': k=5; break;

case '6': k=6; break;

            case '7': k=7; break;

            case '8': k=8; break;

            case '9': k=9; break;

case '.': L=0; goto p;

 

}

//Вызов окна с  ошибкой

if(k>=6)

{

MessageBox(_T("Введенные значения не соответствует указанной системе счисления."),_T("Предупреждение"),MB_ICONEXCLAMATION | MB_OK);

break;

} 

 

s=s+k*pow(6.0, L);

p:

L--;

}

if(st[0]=='-')

s=s*(-1);

 

return s;

}

 

//Функция перевода числа  десятеричной системы в число  любой системы счисления 

//и конвертирование его  в передаваемую строку

CString CKursovoyDlg::dec_to_leac(double A)

{ 

double cur = abs(A);

double cur_cl1;

double cur_dr;

unsigned long long int cur_cl;

int j;

cur_dr = modf(cur, &cur_cl1); //дробное значение cur уйдет в cur_dr, а целое

 

 

Рисунок 5 - Продолжение

в cur_cl1

cur_cl = cur_cl1; ///преобразование double cur_cl1 в long long int cur_cl

 

char st[50]; //инициируем массив из символов типа char

//присваивание каждому  элементу st знака "пробел"

int p=49;

while (p>=0)

{

st[p]=NULL;

p--;

}

 

//j - переменная для  постановки числа в ячейку  массива

//изначально j=-1, т.к.  даже при 1 цифре в числе  j увеличится, превращаясь

//в j=0 и выполняя  перевод целой части

j = -1;

//Нахождение количества  символов в числе

while (cur_cl>0)

{

cur_cl=cur_cl/16;

j++;

}

cur_cl=cur;  //До этой строки cur_cl==0, поэтому снова его задаем

 

//если число отрицательное  - добавляем j, резервируя место  впереди числа для '-'

if (A<0)

j++;

 

int flagj=j;

//Перевод целой  части

while(j>=0)

{

int rem = cur_cl % 16;

//Если остаток  > системы счисления, то вызов  окна об ошибке

if(rem>=16)

{

MessageBox(_T("Введенные значения не соответствует указанной системе счисления."),_T("Предупреждение"), MB_ICONEXCLAMATION | MB_OK);

break;

} 

//в зависимости  от остатка - присваивание числа  элементу массива

switch (rem)

{

case 0: st[j]='0'; break;

case 1: st[j]='1'; break;

            case 2: st[j]='2'; break;

            case 3: st[j]='3'; break;

            case 4: st[j]='4'; break;

            case 5: st[j]='5'; break;

            case 6: st[j]='6'; break;

            case 7: st[j]='7'; break;

            case 8: st[j]='8'; break;

            case 9: st[j]='9'; break;

            case 10: st[j]='A'; break;

            case 11: st[j]='B'; break;

            case 12: st[j]='C'; break;

            case 13: st[j]='D'; break;

            case 14: st[j]='E'; break;

            case 15: st[j]='F'; break;

}

cur_cl = cur_cl - rem;

cur_cl = cur_cl / 16;

j--;

}

 

Рисунок 5 - Продолжение

//устанавливаем  символ '.' сразу после найденного  числа

st[flagj+1]='.';

 

if(cur_dr==0.0)

{

st[flagj+2]='0';

goto p1;  //если дробной части нет - то переход в конец, без расчета дробной части

}

 

//перевод дробной части

double cur_temp = cur_dr;

double cur_temp2;

long int cur_temp3;

 

j = flagj+1;

for (int i=0; i<15; i++)

{

j++;

cur_temp = cur_temp * 16;

cur_temp = modf(cur_temp, &cur_temp2);

cur_temp3 = cur_temp2;

 

switch (cur_temp3)

{

case 0: st[j]='0'; break;

case 1: st[j]='1'; break;

            case 2: st[j]='2'; break;

            case 3: st[j]='3'; break;

            case 4: st[j]='4'; break;

            case 5: st[j]='5'; break;

            case 6: st[j]='6'; break;

            case 7: st[j]='7'; break;

            case 8: st[j]='8'; break;

            case 9: st[j]='9'; break;

            case 10: st[j]='A'; break;

            case 11: st[j]='B'; break;

            case 12: st[j]='C'; break;

            case 13: st[j]='D'; break;

            case 14: st[j]='E'; break;

            case 15: st[j]='F'; break;

}

}

p1:

//если число отрицательное  - постановка знака '-' перед числом 

if (A<0)

st[0]='-';

 

CString leac;

leac.Empty(); //делаем строку leac пустой

leac = st;

return leac;

}

//=========================================================================================

 

 

 

//========================= Обработка  функции построения графика ==========================

void CKursovoyDlg::Graph()

{

UpdateData(true);

 

A = lea_to_dec(STA);

 

Рисунок 5 - Продолжение

 

      B = lea_to_dec(STB);

C = lea_to_dec(STC);

a = lea_to_dec(STa);

b = lea_to_dec(STb);

 

//Основные функции  инициализации области (IDC_PIC1)

CWnd *pPic = GetDlgItem(IDC_PIC1);

CWindowDC dc(pPic);

RECT rect;

 

pPic->GetClientRect(&rect);

 

FillRect(&dc,rect);

DrawAxis(&dc,rect);

DrawBorder(&dc, rect);

DrawGraph(&dc,rect);

DrawGraph2(&dc,rect);

DrawLim(&dc,rect);

}

//=========================================================================================

 

 

 

//========================= Обработка  функции, проверяющей на ошибки ======================

void CKursovoyDlg::Check_error()

{

UpdateData(true);

 

a = lea_to_dec(STa);

b = lea_to_dec(STb);

n = lea_to_dec(STn);

 

if(a>b)

    {

        MessageBox(_T("Предел интегрирования слева должен быть меньше предела интегрирования справа"),_T("Ошибка"), MB_ICONERROR | MB_OK);

        return;

    }

if(n<0)

    {

        MessageBox(_T("Количество точек разбиения не может быть отрицательным числом"),_T("Ошибка"), MB_ICONERROR | MB_OK);

        return;

    }

}

//=========================================================================================

 

 

 

//==================================== Обработка  кнопок ===================================

//Обработка кнопки "Расчет"

void CKursovoyDlg::OnBnClickedButton3()

{

Check_error(); //Вызов функции проверки ошибок

Calculation();  //Вызов функции расчета

}

 

//Обработка кнопки "График"

void CKursovoyDlg::OnBnClickedButton2()

{

 

Рисунок 5 - Продолжение

      Check_error();

Graph();

}

 

//Обработка кнопки "Справка"

void CKursovoyDlg::OnBnClickedButton1()

{

CAboutDlg HelpWindow;  //Создание объекта класса CAboutDlg (окно справки)

HelpWindow.DoModal();  //Вызов окна справки

}

//=========================================================================================

 

 

 

//==================================== Задание  функций ====================================

//Возвращает значение  функции 1

double CKursovoyDlg::func1(double x)    

{ 

x = A*x + B;

return x;

}

//Возвращает значение функции 2

double CKursovoyDlg::func2(double x)    

{

x = A*x*x*cos(B*x + C);

return x;

}

//=========================================================================================

 

 

 

//=============================== Обработка  функции расчета ===============================

void CKursovoyDlg::Calculation()

{

UpdateData(true);

 

A=lea_to_dec(STA);

B=lea_to_dec(STB);

C=lea_to_dec(STC);

a=lea_to_dec(STa);

b=lea_to_dec(STb);

n=lea_to_dec(STn);

 

int i;

double x,x1,x2,  //Координаты и пределы интегрирования

f_0,f_N,  //Значение функций в крайних точках

L,    //Длина отрезка интегрирования

h,    //Диаметр разбиения

Sum1,Sum2,S; //Сумма значений

 

L=b-a; //Нахождение длины отрезка интегрирования  

h=L/n; //Расчет диаметра разбиени

x=a; //Присваивание значение начала интегрирования

 

Sum1=0; //Обнуление счетчика суммы значений функций

for(i=0;i<n-1;i++) //Расчет суммы значений функций

{

x=x+h; //Нахождение координаты каждого промежутка