Logo GenDocs.ru

Поиск по сайту:  

Загрузка...

4 лабораторные работы (3 семестр) - файл 1.doc


4 лабораторные работы (3 семестр)
скачать (1909 kb.)

Доступные файлы (1):

1.doc1909kb.17.11.2011 14:23скачать

содержание

1.doc

Лабораторная работа 1.

Создание двух окон с разными оконными функциями.


Вариант 22

1. Создать два окна, расположенных относительно клиентской области

экрана в соответствии с рис.;

2. Окна оформить в соответствии с кодами цветов и стилей, приведенных ниже;

3. В оконные функции Окна-1 и Окна-2 включить обработку сообщений , приведенных ниже;

4. При обработке сообщений выводить на экран окно с надписью, содержащей код

сообщения и его расшифровку на русском языке, а так же произвольную фразу, характеризующую студента-исполнителя(фамилия, группа и т.д.);

5. В обработку сообщения, помеченного <*> включить выход из приложения;

6. В строках заголовка окон выводить коды сообщений, которые обрабатывает оконная

функция этого окна.


ОКНО-1

Цвет окна: GRAY_BRUSH,

Стиль окна: WS_MAXIMIZEBOX, WS_VSCROLL,

Обработать сообщения: WM_RBUTTONDOWN, WM_RBUTTONDBLCLK.

ОКНО-2

Цвет окна: COLOR_BACKGROUND,

Стиль окна: WS_BORDER, WS_MINIMIZEBOX,

Обработать сообщения: * WM_LBUTTONDBLCLK, WM_KEYDOWN.


Листинг программы:


#include <windows.h>

#include <tchar.h>


HINSTANCE g_hApp;

HWND hwnd1,hwnd2;


LPCTSTR g_szClassName_left = _T("WC_left"),

g_szClassName_right = _T("WC_right");


BOOL RegisterWndClasses (void);

void UnregisterWndClasses (void);

BOOL CreateWindows (void);

LRESULT CALLBACK WindowProc_left (HWND, UINT, WPARAM, LPARAM);

LRESULT CALLBACK WindowProc_right (HWND, UINT, WPARAM, LPARAM);

BOOL MainOnDestroy (HWND);

BOOL InitApp (void);

void UninitApp (void);

int APIENTRY WinMain (HINSTANCE, HINSTANCE, LPSTR, int);


BOOL RegisterWndClasses ()

{

WNDCLASSEX wc;

memset (&wc, 0, sizeof(wc));


wc.cbSize = sizeof(wc);

wc.hInstance = g_hApp;

wc.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS;

wc.lpfnWndProc = (WNDPROC)WindowProc_left;

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);

wc.lpszClassName = g_szClassName_left;


if (! RegisterClassEx(&wc))

return FALSE;


wc.cbSize = sizeof(wc);

wc.hInstance = g_hApp;

wc.style = CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS;

wc.lpfnWndProc = (WNDPROC)WindowProc_right;

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);

wc.lpszClassName = g_szClassName_right;


return RegisterClassEx (&wc);

}


BOOL CreateWindows ()

{

int scrw = GetSystemMetrics(SM_CXSCREEN) ,

scrh = GetSystemMetrics(SM_CYSCREEN);


hwnd1 = CreateWindow( g_szClassName_left, _T("Окно 1"),

^ WS_OVERLAPPED | WS_SYSMENU | WS_VSCROLL |

WS_MAXIMIZEBOX | WS_THICKFRAME | WS_VISIBLE,

scrw/6, 0 , scrw/3, scrh , NULL, NULL, g_hApp, 0

);

if (! hwnd1)

return FALSE;


hwnd2 = CreateWindow( g_szClassName_right, _T("Окно 2"),

^ WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX |

WS_BORDER | WS_THICKFRAME | WS_VISIBLE,

scrw/2, 0 , scrw/2, scrh , NULL, NULL, g_hApp, 0

);

if (! hwnd2)

return FALSE;


return TRUE;

}


LRESULT CALLBACK WindowProc_left (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{

switch (msg)

{

case WM_DESTROY: return MainOnDestroy (hwnd);

case WM_RBUTTONDOWN :

MessageBox (hwnd, _T("Нажата правая кнопка мыши"), _T("Левое окно"), MB_OK);

break;

case WM_RBUTTONDBLCLK :

MessageBox (hwnd, _T("Двойное нажатие правой кнопки мыши"), _T("Левое окно"), MB_OK);

break;


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

}

return 0L;

}


LRESULT CALLBACK WindowProc_right (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{

switch (msg)

{

case WM_DESTROY: return MainOnDestroy (hwnd);


case WM_KEYDOWN:

MessageBox (hwnd, _T("Нажата клавиша на клавиатуре"), _T("Правое окно"), MB_OK);

break;


case WM_LBUTTONDBLCLK:

MessageBox (hwnd, _T("Двойное нажатие левой кнопкой мыши. Выход из программы."), _T("Правое окно"), MB_OK);

PostQuitMessage (0);

break;


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

}

return 0L;

}


BOOL MainOnDestroy (HWND hwnd)

{ PostQuitMessage (0); return TRUE;

}


BOOL InitApp ()

{

if (! RegisterWndClasses())

return FALSE;

CreateWindows ();

return TRUE;

}


void UninitApp ()

{ UnregisterClass (g_szClassName_left , g_hApp);

UnregisterClass (g_szClassName_right, g_hApp);

}


int APIENTRY WinMain (HINSTANCE hi_crr, HINSTANCE hi_prv, LPSTR pc_cmdLine, int cmdShow)

{ MSG msg;

g_hApp = hi_crr;

InitApp ();

while (GetMessage (&msg, NULL, 0, 0)) DispatchMessage (&msg);

UninitApp ();

return msg.wParam;

}


Результат:




Лабораторная работа 2.

Вывод графической информации в окно.


С помощью графических средств Windows GDI создать в окне приложения следующий рисунок:




Листинг программы:


#include <windows.h>

#include <tchar.h>


HINSTANCE g_hApp;

HWND g_hWndMain;

LPCTSTR g_szWndClassName = _T("SomeWindowsClass"),

g_szTitle = _T("Вариант 11");


BOOL RegisterWndClasses (void);

void UnregisterWndClasses (void);

BOOL CreateWindows (void);

LRESULT CALLBACK MainWindowProc (HWND, UINT, WPARAM, LPARAM);

BOOL MainOnDestroy (HWND);

BOOL MainOnPaint (HWND);

BOOL InitApp (void);

void UninitApp (void);

int APIENTRY WinMain (HINSTANCE, HINSTANCE, LPSTR, int);


BOOL RegisterWndClasses ()

{ WNDCLASSEX wc;

memset (&wc, 0, sizeof(wc));

wc.cbSize = sizeof(wc);

wc.hInstance = g_hApp;

wc.style = CS_VREDRAW | CS_HREDRAW;

wc.lpfnWndProc = (WNDPROC)MainWindowProc;

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

wc.lpszClassName = g_szWndClassName;

return RegisterClassEx (&wc);

}


BOOL CreateWindows ()

{ int scrw2 = GetSystemMetrics(SM_CXSCREEN) / 2,

scrh2 = GetSystemMetrics(SM_CYSCREEN) / 2;

g_hWndMain = CreateWindow(g_szWndClassName, g_szTitle,

^ WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX |

WS_MAXIMIZEBOX | WS_THICKFRAME | WS_CLIPCHILDREN

| WS_MINIMIZE | WS_VISIBLE,

scrw2-400, scrh2-300, 800, 600, NULL, NULL, g_hApp, 0);

if (! g_hWndMain)

return FALSE;

return TRUE;

}


LRESULT CALLBACK MainWindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{ switch (msg) {

case WM_PAINT: return MainOnPaint (hwnd);

case WM_DESTROY: return MainOnDestroy (hwnd);

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

}

return 0L;

}


BOOL MainOnPaint (HWND hwnd)

{

PAINTSTRUCT ps;


HPEN hpen_1 = CreatePen(PS_SOLID, 10, RGB(0, 0, 255)),//синий

hpen_2 = CreatePen(PS_SOLID, 10 , RGB(0, 128, 0)),//зелёный

hpen_3 = CreatePen(PS_DASH, 1, RGB(0, 0, 0)),//чёрный пунктир

hpen_prv;


HBRUSH hbrush_1 = CreateHatchBrush(HS_FDIAGONAL,RGB(0, 0, 0)), //чёрный

hbrush_2 = CreateSolidBrush(RGB (0, 0, 255)),//синий

hbrush_3 = CreateSolidBrush(RGB (255, 255, 0)),//красный

hbrush_prv;


HDC hdc = BeginPaint(hwnd, &ps);

SetBkMode (hdc, TRANSPARENT);

hpen_prv = (HPEN)SelectObject(hdc, hpen_3);

MoveToEx (hdc, 100,100, NULL);

LineTo (hdc, 700, 100);

LineTo (hdc, 700, 500);

LineTo (hdc, 100, 500);

LineTo (hdc, 100, 100);


hpen_prv = (HPEN)SelectObject(hdc, hpen_1);

LineTo (hdc, 700, 500);


hpen_prv = (HPEN)SelectObject(hdc, hpen_2);

MoveToEx (hdc, 100,500, NULL);

LineTo (hdc, 700, 100);


SetTextColor (hdc, RGB(128, 128, 128));

TextOut (hdc, 350,50, _T("Триод AS-12"), lstrlen(_T("Триод AS-12")));


SetBkMode (hdc, OPAQUE);

SelectObject(hdc, hbrush_2);//синий

hpen_prv = (HPEN) SelectObject(hdc,hpen_2);//зелёный


Ellipse (hdc, 350, 150, 450, 250);


SetBkColor (hdc,RGB(255, 0, 0));//красный

SelectObject(hdc, hbrush_1);//чёрный

hpen_prv = (HPEN) SelectObject(hdc,hpen_2);//зелёный


Rectangle (hdc, 300, 385, 500, 480);


EndPaint (hwnd, &ps);

DeleteObject (hpen_1);

DeleteObject (hpen_2);

DeleteObject (hbrush_1);

DeleteObject (hbrush_4);


return TRUE;

}


BOOL MainOnDestroy (HWND hwnd)

{

PostQuitMessage (0);

return TRUE;

}


BOOL InitApp ()

{

if (! RegisterWndClasses())

return FALSE;

CreateWindows ();

// ShowWindow (g_hWndMain, SW_MINIMIZE);

// UpdateWindow (g_hWndMain);

return TRUE;

}


void UninitApp ()

{

UnregisterClass (g_szWndClassName, g_hApp);

}


int APIENTRY WinMain (HINSTANCE hi_crr, HINSTANCE hi_prv, LPSTR pc_cmdLine, int cmdShow)

{

MSG msg;

g_hApp = hi_crr;

InitApp ();

while (GetMessage (&msg, NULL, 0, 0)) DispatchMessage (&msg);

UninitApp ();

return msg.wParam;

}

Результат:


Лабораторная работа 3.

Работа с окнами.




Листинг программы:

lab3_multi_win.cpp

// Основы программирования для ОС Windows.

// Лабораторная работа №1.

// Работа с окнами.


#include <windows.h>

#include <tchar.h>


HINSTANCE hi_app;

HWND hwnd_main,hwnd_draw = NULL;


LPCTSTR szClass1 =_T("WindowClassName_blue"),

szClass2 =_T("WindowClassName_gray"),

szClass3 =_T("WindowClassName_black"),

szTitle =_T("Лабораторная работа 4. Вариант 9.");


int wndCount,flag_draw=0;


#define MATR_DIM 6

HWND aa_hwnd[MATR_DIM][MATR_DIM];

static int matr[MATR_DIM][MATR_DIM];


void add_matr( void);


BOOL RegisterWndClasses (void);

void UnregisterWndClasses (void);

BOOL CreateWindows (void);

BOOL MainOnPaint (HWND);


LRESULT CALLBACK WProc_blue (HWND, UINT, WPARAM, LPARAM);

LRESULT CALLBACK WProc_gray (HWND, UINT, WPARAM, LPARAM);

LRESULT CALLBACK WProc_black (HWND, UINT, WPARAM, LPARAM);


BOOL MainOnDestroy (HWND);

BOOL InitializeApp (void);

void UninitializeApp (void);

int APIENTRY WinMain (HINSTANCE, HINSTANCE, LPSTR, int);


/*****************************************************************/

/* RegisterWndClasses */

/* ================== */

/* Регистрация классов окон */

/*****************************************************************/

BOOL RegisterWndClasses ()

{ WNDCLASSEX wce_main;

memset (&wce_main, 0, sizeof(WNDCLASSEX));

wce_main.cbSize = sizeof(WNDCLASSEX);

wce_main.hInstance = hi_app;

wce_main.style = CS_VREDRAW | CS_HREDRAW | CS_NOCLOSE;

wce_main.lpfnWndProc = (WNDPROC)WProc_blue;

wce_main.hCursor = LoadCursor(NULL, IDC_ARROW);

wce_main.hbrBackground = (HBRUSH)(COLOR_ACTIVECAPTION+1);

wce_main.lpszClassName = szClass1;


if (! RegisterClassEx(&wce_main))

return FALSE;


wce_main.style = CS_VREDRAW | CS_HREDRAW;

wce_main.lpfnWndProc = (WNDPROC)WProc_gray;

wce_main.hbrBackground = (HBRUSH) GetStockObject(LTGRAY_BRUSH);

wce_main.lpszClassName = szClass2;


if (! RegisterClassEx(&wce_main))

return FALSE;


wce_main.style = CS_VREDRAW | CS_HREDRAW;

wce_main.lpfnWndProc = (WNDPROC)WProc_black;

wce_main.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);

wce_main.lpszClassName = szClass3;


if (! RegisterClassEx(&wce_main))

return FALSE;


}


/*****************************************************************/

/* CreateWindows */

/* ============= */

/* Создание окон */

/*****************************************************************/

BOOL CreateWindows ()

{

LPCTSTR cl_cur;


TCHAR mc_buff[255];


int scrw = GetSystemMetrics(SM_CXSCREEN) ,

scrh = GetSystemMetrics(SM_CYSCREEN) ,wndW, wndH ,gap=5,i,j,x,y;


hwnd_main = CreateWindow(szClass3, szTitle,

^ WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX |

WS_MAXIMIZEBOX | WS_VISIBLE | WS_THICKFRAME,

0, 0, scrw, scrh, NULL, NULL, hi_app, 0);


wndW = scrw/MATR_DIM - gap;

wndH = scrh/MATR_DIM - gap;


add_matr();


for (i=0; i<MATR_DIM; i++)

for (j=0; j<MATR_DIM; j++)

{

x = j * (wndW + gap);

y = i * (wndH + gap);


_stprintf (mc_buff, _T("matr[%i][%i]=%i"), i, j,matr[i][j]);


switch(matr[i][j])

{


case 1: cl_cur=szClass2; break;

case 2: cl_cur=szClass1; break;

case 3: cl_cur=szClass3; break;


}


aa_hwnd[i][j] = CreateWindow( cl_cur , mc_buff ,

^ WS_OVERLAPPED | WS_SYSMENU | WS_VISIBLE | WS_THICKFRAME,

x, y, wndW, wndH, NULL, NULL, hi_app, 0

);


if (aa_hwnd[i][j]==NULL)

{

MessageBox (NULL, _T("Ошибка при открытии окна."), szTitle, MB_OK);

return FALSE;

}


}


return TRUE;

}


/*****************************************************************/

/* */

/* Оконные функции */

/* */

/*****************************************************************/


LRESULT CALLBACK WProc_black (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{

int i,j;

switch (msg)

{

case WM_LBUTTONDOWN:

{

HWND hwnd_old = hwnd_draw;


hwnd_draw = hwnd;

if (hwnd_old!=NULL)

InvalidateRect(hwnd_old,NULL,TRUE);


InvalidateRect(hwnd,NULL,TRUE);

}

return MainOnPaint (hwnd);


break;


case WM_DESTROY: return MainOnDestroy (hwnd);

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

}

return 0L;

}


LRESULT CALLBACK WProc_gray (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{ switch (msg)

{

case WM_DESTROY: return MainOnDestroy (hwnd);

case WM_LBUTTONDBLCLK: MessageBox (NULL, _T("Двойное нажатие на левую клавишу мыши"),_T(""), MB_OK);

break;


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

}

return 0L;

}


LRESULT CALLBACK WProc_blue(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{ switch (msg)

{

case WM_DESTROY: return MainOnDestroy (hwnd);

case WM_KEYDOWN: MessageBox (NULL, _T("Клавиатура нажата"),_T(""), MB_OK);

break;

case WM_KEYUP: MessageBox (NULL, _T("Клавиатура отпущена"),_T(""), MB_OK);

break;

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

}

return 0L;

}


/*****************************************************************/

/* MainOnDestroy */

/* ============= */

/* Действия при закрытии окон */

/*****************************************************************/

BOOL MainOnDestroy (HWND hwnd)

{

int i, j;

for (i=0; i<MATR_DIM; i++)

for (j=0; j<MATR_DIM; j++)

if (hwnd == aa_hwnd[i][j])

switch(matr[i][j])

{

case 1: PostQuitMessage (0);

return TRUE;

case 2:

case 3:

case 4: MessageBox (0, _T("Закрываю окно"),_T("Выход"), MB_OK);

return TRUE;

}


PostQuitMessage (0);

return TRUE;

}


BOOL InitializeApp ()

{ if (! RegisterWndClasses()) {

MessageBox (NULL, _T("Ошибка регистрации классов окон."), szTitle, MB_OK);

return FALSE;

}

CreateWindows ();

return TRUE;

}


void UninitializeApp ()

{

UnregisterClass (szClass1, hi_app);

UnregisterClass (szClass2, hi_app);

UnregisterClass (szClass3, hi_app);

}

/*****************************************************************/

/* _tWinMain */

/* ========= */

/* Главная функция (точка входа в прграмму) */

/*****************************************************************/

int APIENTRY _tWinMain (HINSTANCE hi_crr, HINSTANCE hi_prv, LPTSTR pc_cmdLine, int cmdShow)

{ MSG msg;

hi_app = hi_crr;

InitializeApp ();

while (GetMessage (&msg, NULL, 0, 0))

DispatchMessage (&msg);


UninitializeApp ();

return msg.wParam;

}


/**************************************************/

/* add_matr */

/* ======== */

/* Заполнение числовой матрицы */

/**************************************************/

void add_matr( )

{

int i,j,n;


TCHAR buff[300]=_T("");

n=MATR_DIM-1;


for (i=0; i< MATR_DIM ; i++)

{

for(i=0;i<6;i++)

for(j=0;j<6;j++)

matr[i][j]=3;


for(i=0;i<3;i++)

for(j=i;j<5-i;j++)

matr[i][j]=2;


for(i=3;i<6;i++)

for(j=5-i;j<i;j++)

matr[i][j]=1;


}


/*------------------------------------------*/

/* Отладочная печать числовой матрицы */

/*------------------------------------------*/


for (i=0; i< MATR_DIM ; i++)

{

for (j=0; j< MATR_DIM ; j++)

_stprintf (buff, _T("%s %3d"),buff, matr[i][j]);


_stprintf (buff, _T("%s\n"),buff);

}

MessageBox (NULL, buff, _T("Отладка"), MB_OK);

}


gr_win.cpp

// Вывод произвольного набора примитивов в окно

#include <windows.h>

#include <tchar.h>


#define K_SCALE 6


BOOL MainOnPaint (HWND hwnd)

{

PAINTSTRUCT ps;

HPEN hpen_1 = CreatePen(PS_SOLID, 10, RGB(0, 0, 255)),//синий

hpen_2 = CreatePen(PS_SOLID, 10 , RGB(0, 128, 0)),//зелёный

hpen_3 = CreatePen(PS_DASH, 1, RGB(0, 0, 0)),//чёрный пунктир

hpen_prv;


HBRUSH hbrush_1 = CreateHatchBrush(HS_FDIAGONAL,RGB(0, 0, 0)), //чёрный

hbrush_2 = CreateSolidBrush(RGB (0, 0, 255)),//синий

hbrush_3 = CreateSolidBrush(RGB (255, 255, 0)),//красный

hbrush_prv;


HDC hdc = BeginPaint(hwnd, &ps);

SetBkMode (hdc, TRANSPARENT);

hpen_prv = (HPEN)SelectObject(hdc, hpen_3);

MoveToEx (hdc, 100/K_SCALE,100/K_SCALE, NULL);

LineTo (hdc, 700/K_SCALE, 100/K_SCALE);

LineTo (hdc, 700/K_SCALE, 500/K_SCALE);

LineTo (hdc, 100/K_SCALE, 500/K_SCALE);

LineTo (hdc, 100/K_SCALE, 100/K_SCALE);


hpen_prv = (HPEN)SelectObject(hdc, hpen_1);

LineTo (hdc, 700/K_SCALE, 500/K_SCALE);


hpen_prv = (HPEN)SelectObject(hdc, hpen_2);

MoveToEx (hdc, 100/K_SCALE,500/K_SCALE, NULL);

LineTo (hdc, 700/K_SCALE, 100/K_SCALE);


SetTextColor (hdc, RGB(128, 128, 128));

TextOut (hdc, 150/K_SCALE,50/K_SCALE, _T("Триод AS-12"), lstrlen(_T("Триод AS-12")));


SetBkMode (hdc, OPAQUE);

SelectObject(hdc, hbrush_2);//синий

hpen_prv = (HPEN) SelectObject(hdc,hpen_2);//зелёный


Ellipse (hdc, 350/K_SCALE, 150/K_SCALE, 450/K_SCALE, 250/K_SCALE);


SetBkColor (hdc,RGB(255, 0, 0));//красный

SelectObject(hdc, hbrush_1);//чёрный

hpen_prv = (HPEN) SelectObject(hdc,hpen_2);//зелёный


Rectangle (hdc, 300/K_SCALE, 385/K_SCALE, 500/K_SCALE, 480/K_SCALE);


EndPaint (hwnd, &ps);

DeleteObject (hpen_1);

DeleteObject (hpen_2);

DeleteObject (hbrush_1);


return TRUE;

}


Результат:





^ Лабораторная работа 4

Вывод графической информации в окно (разложение ф-ции в ряд).





^ Листинг программы:


/************************************************************************/

/* Основы программирования для Windows. */

/* Лабораторная работа №2. */

/* Вывод графической информации в окно (разложение ф-ции в ряд). */

/************************************************************************/


#define STRICT

#define _CRT_SECURE_NO_WARNINGS

#define _CRT_NON_CONFORMING_SWPRINTFS


#include <windows.h>

#include <tchar.h>

#include <stdio.h>

#include <math.h>


HINSTANCE g_hApp;

HWND g_hWndMain;


LPCTSTR g_szClass1 = _T("WindowClassName1"),

g_szTitle = _T("Пример Windows-приложения");


BOOL RegisterWndClasses (void);

void UnregisterWndClasses (void);

BOOL CreateWindows (void);

LRESULT CALLBACK MainWindowProc (HWND, UINT, WPARAM, LPARAM);

BOOL MainOnPaint (HWND);

BOOL MainOnDestroy (HWND);

BOOL InitApp (void);

void UninitApp (void);

int APIENTRY WinMain (HINSTANCE, HINSTANCE, LPSTR, int);


BOOL RegisterWndClasses ()

{ WNDCLASSEX wc;

memset (&wc, 0, sizeof(wc));

wc.cbSize = sizeof(wc);

wc.hInstance = g_hApp;

wc.style = CS_VREDRAW | CS_HREDRAW;

wc.lpfnWndProc = (WNDPROC)MainWindowProc;

wc.hCursor = LoadCursor(NULL, IDC_ARROW);

wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);

wc.lpszClassName = g_szClass1;

return RegisterClassEx(&wc);

}


BOOL CreateWindows ()

{

int scrw2 = GetSystemMetrics(SM_CXSCREEN) / 2,

scrh2 = GetSystemMetrics(SM_CYSCREEN) / 2;


g_hWndMain = CreateWindow(g_szClass1, g_szTitle,

^ WS_OVERLAPPEDWINDOW | WS_VISIBLE,

scrw2-400, scrh2-300, 800, 600, NULL, NULL, g_hApp, 0);

return TRUE;

}


LRESULT CALLBACK MainWindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{ switch (msg) {

case WM_PAINT: return MainOnPaint (hwnd);

case WM_DESTROY: return MainOnDestroy (hwnd);

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

}

return 0L;

}


BOOL MainOnDestroy (HWND hwnd)

{

PostQuitMessage (0);

return TRUE;

}


/*****************************************************************/

/* MainOnPaint */

/* =========== */

/* Рисование сложного набора графиков аналитических функций */

/*****************************************************************/


#define ALL_PT 10 // число точек на графике

#define ALL_FUN 3 // число функций

#define K_GAB 0.05 // отступ от края

#define XN 0.1 // интервал

#define XK 1.0 //


#define MIN_MSERIES 3 // минимальное число членов ряда

#define MAX_MSERIES 15 // максимальное число членов ряда


/*-----------------------------------------*/

/* Прототипы вспомогательных функций */

/*-----------------------------------------*/

double fun_user( double );

double fun_expansion(double , int );


POINT coor_w (RECT , double , double , double [2][2] ) ;


void draw_point(HDC , int , int , int);

/*----------------------------------------*/


BOOL MainOnPaint (HWND hwnd)

{

PAINTSTRUCT ps;

// запросить данные о повреждённой области окна, требующей перерисовки,

// получить дескриптор контекста поверхности вывода

HDC hdc = BeginPaint(hwnd, &ps);


// разрешить рисование подложки окна

SetBkMode (hdc, TRANSPARENT);


// --- создать перья ---

HPEN mpen[]= { CreatePen(PS_SOLID, 3, RGB(0, 0, 0)),

CreatePen(PS_SOLID, 3, RGB(0 , 255, 0)),

CreatePen(PS_SOLID, 1, RGB(0 , 0, 0)),

CreatePen(PS_SOLID, 1, RGB(0 , 0, 0 )),

CreatePen(PS_SOLID, 1, RGB(0 , 0, 0))

},


// выделить созданное перо 1 в контексте,

// сохранить дескриптор предыдущего активного в данном контексте пера

hpen_prv = (HPEN)SelectObject(hdc, mpen[0]);


POINT coor_int[ALL_FUN][ALL_PT], // оконные координаты узлов графика

pt1,pt2;


int Y_axis_x, X_axis_y,

i,j,pr_first=0, n_max;


double mas_y[ALL_FUN][ALL_PT], // массив координат Y набора графиков

mas_gab[2][2], // массив габаритных точек набора графиков

y_max, y_min, x_max, Y_max,

dx,x_cur ,y_cur;


// буфер для формирования текста

TCHAR acBuff[255];


/*---------------------------------------*/

/* Формирование массивов координат */

/*---------------------------------------*/


dx=fabs(XK-XN)/ALL_PT;

for (i=0 ; i < ALL_PT; i++)

{

x_cur=XN+dx*i;


mas_y[0][i]=fun_user (x_cur);

mas_y[1][i]=fun_expansion(x_cur,MIN_MSERIES)+0.3;

mas_y[2][i]=fun_expansion(x_cur,MAX_MSERIES)+0.5;

}


// определение габаритов графика

y_max=y_min=mas_y[0][1];

for(i=0; i< ALL_FUN ; i++)

for (j=0 ; j < ALL_PT; j++)

{

y_cur=mas_y[i][j];


if (y_cur>=y_max) y_max=y_cur;

if (y_cur<=y_min) y_min=y_cur;

}


mas_gab[0][0]=0.1; mas_gab[0][1]=-0.1;

mas_gab[1][0]=XK; mas_gab[1][1]=y_max;


// определить размеры клиентской области окна

RECT rc;

GetClientRect (hwnd, &rc);

/*----------------------------------------------*/

/* вычислить оконные координаты узлов графика */

/*----------------------------------------------*/


for(i=0; i< ALL_FUN ; i++)

for (j=0 ; j < ALL_PT; j++)

{

x_cur=XN+dx*j;

y_cur=mas_y[i][j];


coor_int[i][j]= coor_w ( rc , x_cur , y_cur, mas_gab);

}

//поиск экстремума в оконных коодинатах

Y_max=mas_y[0][0];

n_max=0;

//for(i=0; i< ALL_FUN ; i++)

for (j=1; j < ALL_PT; j++)

{


if (mas_y[0][j]>=Y_max)

{Y_max=mas_y[0][j];

n_max=j;

}

}


/*----------------------------------*/

/* Нарисовать график */

/*----------------------------------*/

for(i=0; i< ALL_FUN ; i++)

{

SelectObject(hdc, mpen[i]);

pr_first = 0;

for (j=0; j < ALL_PT; j++)

{

pt1=coor_int[i][j];


// если узел не первый - нарисовать линию

if (pr_first!=0)

LineTo (hdc, pt1.x, pt1.y);

else

{

MoveToEx (hdc, pt1.x, pt1.y, NULL);

// отметить, что первый узел пройден

pr_first = 1;

}

}

}


/*-----------------------------------------------------------------------*/

/* нарисовать оси */

/*-----------------------------------------------------------------------*/


// ось X


SelectObject(hdc,mpen[3]);


pt1=coor_w ( rc , 0 , 0 , mas_gab);

pt2=coor_w ( rc , XK , 0 , mas_gab);

Y_axis_x=pt1.y;


MoveToEx (hdc, pt1.x , pt1.y, NULL);

LineTo (hdc, pt2.x , pt2.y);


SelectObject(hdc,mpen[3]);

pt1=coor_int[0][n_max];

pt2.y=coor_int[0][n_max].y;

pt2.x=coor_int[0][56].y;


MoveToEx (hdc, pt1.x, pt1.y, NULL);

LineTo (hdc, pt2.x, pt2.y);


// ось Y


pt1=coor_w ( rc , 0 , 0 , mas_gab);

pt2=coor_w ( rc , 0 , y_max , mas_gab);


MoveToEx (hdc, pt1.x , pt1.y, NULL);

LineTo (hdc, pt2.x , pt2.y);


SelectObject(hdc,mpen[3]);

pt1=coor_int[0][0];

pt2.x=coor_int[0][0].x;

pt2.y=Y_axis_x;


MoveToEx (hdc, pt1.x, pt1.y, NULL);

LineTo (hdc, pt2.x, pt2.y);


SelectObject(hdc,mpen[3]);

pt1=coor_int[0][n_max];

pt2.x=coor_int[0][n_max].x;

pt2.y=Y_axis_x;


MoveToEx (hdc, pt1.x, pt1.y, NULL);

LineTo (hdc, pt2.x, pt2.y);


/*-----------------------------------------------------------------------*/

/* закрасить трапеции через одну */

/*-----------------------------------------------------------------------*/

// создать перо


HBRUSH

hbrush_1 = CreateHatchBrush(HS_DIAGCROSS, RGB(0, 0, 255)), // blue xxx

hbrush_2 = CreateSolidBrush(RGB(0, 255, 0)), // ----------------

hbrush_3 = CreateHatchBrush(HS_HORIZONTAL, RGB(0, 255, 0)), // GREEN

hbrush_4 = CreateHatchBrush(HS_BDIAGONAL, RGB(255, 0, 0)), //RED

hbrush_prv = (HBRUSH)SelectObject(hdc, hbrush_4);


SelectObject (hdc, (HPEN)GetStockObject(NULL_PEN));


POINT cp[15];

SelectObject (hdc, hbrush_4);

for (i=1; i < ALL_PT-1; i+=3)

{

cp[0]=coor_int[0][i];

cp[1]=coor_int[0][i+1];

cp[2]=coor_int[2][i+1];

cp[3]=coor_int[2][i];

cp[2].y=Y_axis_x;

cp[3].y=Y_axis_x;


Polygon (hdc, cp, 4 );

}


SelectObject (hdc, hbrush_3);

for (i=2; i < ALL_PT-1; i+=3)

{

cp[0]=coor_int[0][i];

cp[1]=coor_int[0][i+1];

cp[2]=coor_int[2][i+1];

cp[3]=coor_int[2][i];

cp[2].y=Y_axis_x;

cp[3].y=Y_axis_x;


Polygon (hdc, cp, 4 );

}


SelectObject (hdc, hbrush_1);

for (i=0; i < ALL_PT-1; i+=3)

{

cp[0]=coor_int[0][i];

cp[1]=coor_int[0][i+1];

cp[2]=coor_int[2][i+1];

cp[3]=coor_int[2][i];

cp[2].y=Y_axis_x;

cp[3].y=Y_axis_x;


Polygon (hdc, cp, 4 );

}


/*-----------------------------------------------------------------------*/

/* Нарисовать вертикальные линии */

/*-----------------------------------------------------------------------*/


SelectObject(hdc, mpen[4]);

for (i=0; i < ALL_PT; i++)

{

pt1=coor_int[0][i];

pt2=coor_int[0][i];


MoveToEx (hdc, pt1.x , pt1.y , NULL);

LineTo (hdc, pt2.x , pt2.y);

}


for (i=0; i < ALL_PT; i++)

{

pt1=coor_int[0][i];

pt2=coor_int[0][i];

pt2.y=Y_axis_x;


MoveToEx (hdc, pt1.x , pt1.y , NULL);

LineTo (hdc, pt2.x , pt2.y);

}


/*-----------------------------------------------------------------------*/

/* создать шрифт */

/*-----------------------------------------------------------------------*/

LOGFONT lf; // структура с логическим описанием шрифта (параметры шрифта)

// получить параметры шрифта, используемого для рисования

// текста диалоговых элементов по умолчанию, в структуру lf

GetObject ((HFONT)GetStockObject(DEFAULT_GUI_FONT), sizeof(lf), &lf);

lf.lfItalic = TRUE; // курсив

lf.lfWeight = FW_BOLD; // жирный

lf.lfOrientation = 900; // поворот на 90 градусов против ЧС

lf.lfEscapement = 900;

lf.lfHeight = 14; // высота поля 25 pix

// создать физический шрифт,

// наиболее близко соответствующий описанному в lf

HFONT hfont_1 = CreateFontIndirect(&lf);


GetObject ((HFONT)GetStockObject(DEFAULT_GUI_FONT), sizeof(lf), &lf);

lf.lfItalic = TRUE; // курсив

lf.lfWeight = FW_BOLD; // жирный

lf.lfOrientation = 0; // поворот на 90 градусов против ЧС

lf.lfEscapement = 0;

lf.lfHeight = 14;

HFONT hfont_2 = CreateFontIndirect(&lf);

// получить дескриптор текущего активного шрифта

HFONT hfont_prv = (HFONT)SelectObject(hdc, hfont_1);

/*-----------------------------------------------------------------------*/

/* нарисовать номера узлов */

/*-----------------------------------------------------------------------*/

SelectObject(hdc, hfont_2);

SetTextColor (hdc, RGB(0, 0, 0));


pt1=coor_int[0][0];

_stprintf (acBuff, _T("%.2f"), XN);

TextOut (hdc, pt1.x, Y_axis_x, acBuff, lstrlen(acBuff));


pt1=coor_int[0][ALL_PT-1];

_stprintf (acBuff, _T("%.2f"), Y_max);

TextOut (hdc, pt1.x+10, pt1.y, acBuff, lstrlen(acBuff));

pt1=coor_int[0][ALL_PT-1];

_stprintf (acBuff, _T("%.2f"), XK);

TextOut (hdc, pt1.x, Y_axis_x, acBuff, lstrlen(acBuff));

/*-----------------------------------------------------------------------*/

// --- восстановить контекст и удалить GDI-объекты ---

// выделить в контексте перо, активное изначально

SelectObject (hdc, hpen_prv);

SelectObject (hdc, hbrush_prv);

// удалить наши перья

for(i=0 ; i < sizeof(mpen)/sizeof(mpen[0]) ; i++)

DeleteObject (mpen[i]);


// удалить кисти

DeleteObject ( hbrush_1);

DeleteObject ( hbrush_2);

DeleteObject ( hbrush_3);


// (аналогично для шрифтов)

SelectObject (hdc, hfont_prv);

DeleteObject (hfont_1);

// объявить, что сообщение WM_PAINT обработано,

// освободить полученный ранее контекст окна

EndPaint (hwnd, &ps);

// успешное завершение


return TRUE;

}


/******************************************************************/

/* fun_user */

/* ======== */

/* пользовательская функция exp(x) */

/******************************************************************/

double fun_user(double x )

{ return (exp(x)); }


/**********************************************************************/

/* fun_user */

/* ======== */

/* разложение в ряд пользовательской функции */

/* пользовательской функции exp(x) на участке 0.1 <= x < 1.0 */

/**********************************************************************/

double fun_expansion(double x , int n)

{

int i,j;

double sum=0.0,xp=1.0,fact;


for(i=0; i<=n ; i++)

{ for (fact=1.0, j=1;j<=i;j++)

fact*=j;

xp=pow(x,i);

sum+=xp/fact;

}

return (sum);

}


/******************************************************************/

/* coor_w */

/* ====== */

/* Возвращает указатель экранные координаты точки */

/* a- ширина области вывода */

/* b- высота области вывода */

/******************************************************************/


POINT coor_w ( RECT cp ,

double x , double y ,

double mas_gab[2][2]

)

{

int a,b,gab_a,gab_b, xc_w , yc_w ;


double k_scale, xc,yc,x_max,y_max,x_min,y_min,dx,dy,k1,k2;


POINT ptw;


/*--------------------------------*/

/* Параметры окна вывода */

/*--------------------------------*/


a=abs(cp.right-cp.left);

b=abs(cp.top-cp.bottom);


gab_a=(int)((double)a*K_GAB); // отступ по ширине

gab_b=(int)((double)b*K_GAB); // отступ по высоте


a-=gab_a;

b-=gab_b;


xc_w=(cp.right+cp.left )/2;

yc_w=(cp.top +cp.bottom)/2;


/*-----------------------------------------*/

/* Определение масштабного коэффициента */

/*-----------------------------------------*/

x_min=mas_gab[0][0]; y_min=mas_gab[0][1];

x_max=mas_gab[1][0]; y_max=mas_gab[1][1];


dx=fabs(x_max-x_min);

dy=fabs(y_max-y_min);


xc=(x_max+x_min)/2;

yc=(y_max+y_min)/2;


k1=a/dx;

k2=b/dy;


k_scale= ( k1 < k2 ) ? k1 : k2;


/*-----------------------------------------*/

/* Масштабирование координат */

/*-----------------------------------------*/


ptw.x= (int)( (x-xc)*3*k_scale + xc_w) ;

ptw.y= (int)(-(y-yc)*k_scale + yc_w) ;


return (ptw);

}


BOOL InitApp ()

{

if (! RegisterWndClasses())

return FALSE;

CreateWindows ();

return TRUE;

}


void UninitApp ()

{

UnregisterClass (g_szClass1, g_hApp);

}


int APIENTRY WinMain (HINSTANCE hi_crr, HINSTANCE hi_prv, LPSTR pc_cmdLine, int cmdShow)

{ MSG msg;

g_hApp = hi_crr;

InitApp ();

while (GetMessage (&msg, NULL, 0, 0)) DispatchMessage (&msg);

UninitApp ();

return msg.wParam;

}


Результат:




Скачать файл (1909 kb.)

Поиск по сайту:  

© gendocs.ru
При копировании укажите ссылку.
обратиться к администрации