Acerca de la programación
#include lt;windows.hgt;
#include "resource.h"
//#include "English_Name.h"
#include lt; math.hgt;
LRESULT CALLBACK WndProc(HWND hwnd, mensaje UINT, WPARAM wParam, LPARAM lParam);
BOOL CALLBACK NOM(HWND hDlg, mensaje UINT , WPARAM wParam, LPARAM lParam);
BOOL CALLBACK AboutDlgProc (HWND, UINT, WPARAM, LPARAM);
POINT PadCaret;
//Ancho promedio de letras (cxChar), altura total de las letras (cyChar)
//El ancho promedio de las letras mayúsculas (cxCaps), la altura de la ventana creada (cyClient)
int cxChar, cxCaps, cyChar, cyClient, cxClient;
static int iCursor = 1;
static int cxBuffer, cyBuffer, xCaret, yCaret;
#define BUFFER(x, y ) *(pBuffer y * cxBuffer x)
#define MAXPOINTS 1000
#define NUM 800
#define DOSPI (2 * 3.14159)
HWND hDlgSetBkColor;
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
//Establecer parámetros básicos
HWND CreatPad;
WNDCLASS WND_Creat;
CHAR WND_CreatPad[] = "Creat_Super";
WND_Creat.cbClsExtra = 0;
p>
WND_Creat.cbWndExtra = 0;
//Embellece la interfaz
WND_Creat.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); >
WND_Creat.hCursor = LoadCursor(NULL, IDC_IBEAM); //Cargar el mouse
WND_Creat.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1)); .lpszMenuName= MAKEINTRESOURCE( IDR_MENU1);
WND_Creat.lpszMenuName = NULL;
//Llamada a función
> WND_Creat.hInstance = hInstance;
WND_Creat.lpfnWndProc = WndProc;
WND_Creat.lpszClassName = WND_CreatPad
//estilo de ventana
//Comprobación de error de registro
if(!RegisterClass(amp; WND_Creat))
{
MessageBox(NULL, TEXT("registro fallido"), "¡advertencia!", MB_ICONSTOP
return
}
// Cree una ventana según el tipo de ventana
CreatPad=CreateWindow(WND_CreatPad,
TEXT("Experiment_One"),
//WS_VSCROLL barra de desplazamiento vertical
//WS_HSCROLL barra de desplazamiento horizontal
WS_OVERLAPPEDWINDOW|WS_VSCROLL,
100, //X1
0, //Y1
800, //(X2-x1)
600, //(Y2-Y1)
NULL,
NULL,
hInstance,
NULL);
//posición de aparición del cursor
//PadCaret.x=200; /PadCaret .y=200;
//Mostrar ventana
ShowWindow(CreatPad, nShowCmd
MSG msg
/ *
while (GetMessage (amp; msg, NULL, 0, 0))
{
//TranslateMessage teclado de traducción
TranslateMessage ( amp; msg);
//DispatchMessage envía información a la ventana para su procesamiento
DispatchMessage (amp; msg
}
);*/
while (GetMessage (amp; msg, NULL, 0, 0))
{
if(NULL == hDlgSetBkColor || !IsDialogMessage( hDlgSetBkColor, amp;msg))
{
TranslateMessage (amp;msg);
DispatchMessage (amp;msg);
}
}
devolver msg.wParam;
volver
0;
}
/*
void DrawBezier (HDC hdc, PUNTO apt[])
{
PolyBezier (hdc, apt, 4);
MoveToEx (hdc, apt[0].x, apt[0].y,
LineTo (hdc, apt[1].x, apt[1].y);
MoveToEx (hdc, apt[2].x, apt[2].y,
); LineTo (hdc, apt[3].x, apt[3].y
}
*/
LRESULT CALLBACK WndProc(HWND hwnd, Mensaje UINT, WPARAM wParam, LPARAM lParam)
{
HDC hdc
int i, x, y, iVertPos, iHorzPos, iPaintBeg, iPaintEnd <; /p>
int f, g;
PUNTO estático st[MAXPOINTS];
static int iCount; ************************************************** * *************\
*La estructura PAINTSTRUCT contiene el código HDC. Una vez obtenido el mensaje WM_PAINT, esto es necesario para la ejecución.
* .
Por ejemplo: comenzar pintura = (hwnd, amp; (PAINTSTRUCT PS)) Luego HDC
* obtiene el hdc en ps
\************ ************************************************* ***** ******/
PAINTSTRUCT ps;
//SCROLLINFO Esta estructura contiene varios miembros como cbSize, fMask, nMin, nMax, nPage
//Estos cinco miembros se utilizarán uno por uno más adelante
SCROLLINFO si
//
POINT
//
RECT rc;
// Para mejorar la salida de mensajes del teclado, la ip y Cnum definidas son temporalmente inútiles y la compilación generará 1 advertencia
enum Tabla de caracteres{a, b, c, d};
ip estática de la tabla de caracteres
int Cnum
//
//
HMENU estático hMenuMain, hMenuEn, hMenuCh, hMenuShortCut, hMenu, IDR_MENU2_l
// HMENU estático hMenu, IDR_MENU2_l, w ;
//
UINT estático uCheck = MF_CHECKED;
//
PUNTO apto [NUM] ;
//
static TCHAR * pBuffer = NULL;
//TextOut_1 se utilizará para completar esta matriz en wsprintf
TCHAR szBuffer [ 10] ;
//Obtener la información básica de la fuente
TEXTMETRIC tm;
//
CHOOSECOLOR cc;
OPENFILENAME ofn;
static COLORREF crCustColors[16];
//
char szText_1[100] = {"¡Una pequeña pista! "};
char szText_2[100] = {"La trayectoria del movimiento del mouse se registrará y al presionar 'Conectar vértices' se conectarán los puntos en la trayectoria"};
>//Aparece el cursor
switch(mensaje)
{
case WM_CREATE:
{
hInstance = ((LPCREATESTRUCT ) lParam)-gt;
/****************************** ****** ********************************************** *****\
*GetDC(), LanzamientoDC
(), BeginPaint() y EndPaint().
*Utilizando el hdc devuelto por GetDC(), puedes dibujar en toda el área de visualización, pero el hdc devuelto por BeginPaint() solo se puede dibujar on
p>*Dibujar dentro del área rectangular especificada por rect
*GetDC y ReleaseDC no hacen válida ninguna posible área no válida en el área de visualización
\ ***** ********************************************** ****** ****************************/
hdc = GetDC (hwnd); /p>
GetTextMetrics ( hdc, amp; tm);
//Ancho de letra promedio (cxChar)
cxChar = tm.tmAveCharWidth; //Procesando caracteres ampliados
if ( tm.tmPitchAndFamily = 1)
{
// Los caracteres chinos y mayúsculas son 1,5 veces cxChar
cxCaps = 3 / 2 * cxChar
}
else
{
//Otro cxCaps = cxChar
cxCaps = cxChar;
}
// Espaciado del texto: tm.tmExternalLeading tiene como valor predeterminado 0. Para alargar la longitud del texto y hacerlo hermoso, establezca su valor a 10
tm.tmExternalLeading = 10;
cyChar = tm.tmHeight tm.tmExternalLeading
//Establece el rango y la posición inicial de la vertical; columna de desplazamiento
ReleaseDC (hwnd, hdc);
//Crear menú dinámico
hInstance = (HINSTANCE) GetWindowLong (hwnd, GWL_HINSTANCE
hMenuMain = LoadMenu (hInstance, MAKEINTRESOURCE (IDR_MENU1));
SetMenu (hwnd, hMenuMain);
devuelve 0; p>
caso WM_SIZE ：
{
/************************** ********** **************************************** ********\
*El grupo de palabras bajas del parámetro lParam contiene el ancho del área de visualización, y el grupo de palabras altas contiene la altura del área de visualización
*Por ejemplo: la oración cxClient = LOWORD (lParam) calcula el ancho del cliente
*El sistema devolverá automáticamente lParam al procesar WM_SIZE, pero la ventana debe ser la ventana principal, subventanas no están permitidos
\************ **************************** ************************* *******************
*****/
cyClient = HIWORD (lParam);
cxClient = LOWORD (lParam);
/*
apto[0].x = 40;
apto[0].y = 160;
apto[1].x = 80; 1].y = 80;
apto[2].x = 80;
apto[2].y = 240; .x = 120;
apt[3].y = 160;
*/
/*Comienza a usar la estructura SCROLLINFO*/
//La longitud de si.cbSize es la longitud de SCROLLINFO
si.cbSize = sizeof (si);
//SIF_RANGE: Sea si.nMin, si. nMax Conviértete en el rango de la barra de desplazamiento
//SIF_PAGE: obtiene el tamaño de la página actual y obtiene la barra de desplazamiento proporcional
si.fMask = SIF_RANGE | >
//(0 ~ 46)
si.nMin = 0;
si.nMax = 46
//Total de líneas de texto se muestra en el área de visualización Número
si.nPage = cyClient / cyChar;
/********************* ***** ********************************************** ****** ********\
*SetScrollInfo es la función de barra de desplazamiento de win32
*SB_VERT: Es una barra de desplazamiento proporcional (este estilo se usa aquí)
*SB_CTL: Es una barra de desplazamiento no proporcional
*SB_HORZ: Es una barra de desplazamiento proporcional, pero tiene dos lados horizontal y vertical
*SIF_TRACKPOS:
*(SB_### es el código de notificación del mouse)*
*Cuando el último parámetro es TRUE, cuando aparece la barra de desplazamiento cuando Cuando el programa se está ejecutando, será una barra de desplazamiento proporcional, es decir, cuando el programa obtiene información de acción como arrastrar el mouse
* barra de desplazamiento y otra información de acción, la barra de desplazamiento no se volverá a dibujar. Pero cuando el parámetro es FALSO, cuando aparece la barra de desplazamiento cuando el programa se está ejecutando
* es una barra de desplazamiento no proporcional. Sin embargo, cuando el programa obtiene información de acción como el mouse arrastrando el bloque de desplazamiento. , la barra de desplazamiento se vuelve a dibujar inmediatamente
*El redibujado se convierte en una barra de desplazamiento proporcional.
\****************************************** *****************************************/
SetScrollInfo (hwnd, /*SB_HORZ o SB_CTL*/SB_VERT, amp; si, TRUE/*FALSE*/
//
{
cxBuffer); = max (1, cxClient / cxChar);
cyBuffer = max (1, cyClient / cyChar);
if (pBuffer != NULL)
gratis (pBuffer);
pBuffer = (TCHAR *) malloc (cxBuffer * cyBuffer * sizeof (TCHAR))
for (y = 0; y lt; cyBuffer; y)<; /p>
for (x = 0; x lt; cxBuffer; x)
BUFFER(x, y) = ' '; >
yCaret = 0;
if (hwnd == GetFocus ())
SetCaretPos (xCaret * cxChar, yCaret * cyChar); (hwnd, NULL, VERDADERO);
}
devuelve 0
/**************** ************************************************** * *********************\
*El código anterior es solo el trabajo inicial realizado al obtener WM_SIZE Los detalles reales del trabajo de SCROLL. se obtienen después de obtener WM_SIZE Implementado en WM_VSCROLL*
\********************************. ********** **************************************** *********/
}
case WM_VSCROLL:
{
//La longitud de si. cbSize es la longitud de SCROLLINFO
si.cbSize = sizeof (si);
/******************** ************** *************************\
*SIF_RANGE: Deja que .nMin y si.nMax se convierten en el rango de la barra de desplazamiento
*SIF_PAGE: obtiene el tamaño de la página actual y obtiene la barra de desplazamiento proporcional
*SIF_POS: obtiene la posición actual del control deslizante
*SIL_ALL = SIF_RANGE |
_TRACKPOS
\****************************************** ******* ****************/
si.fMask = SIF_ALL;
//Básicamente similar a SetScrollInfo , pero puedes usar punteros numéricos de tipo LARGO La posición del bloque de desplazamiento, etc.
GetScrollInfo (hwnd, SB_VERT, amp; si);
//Coloca la posición del bloque de desplazamiento en iVertPos
iVertPos = si.nPos;
/*************************** ************ **********************************\
*Cuando la palabra baja de wParam es SB_THUMBTRACK, el bit alto de wParam es la posición actual del usuario al arrastrar el bloque de desplazamiento
*. La posición está entre los valores mínimo y máximo del rango de la barra de desplazamiento. Cuando el bit de orden inferior de wParam es
*SB_THUMBPOSITION, el bit de orden superior de wParam es la posición final del bloque de desplazamiento después de que el usuario suelta el mouse.
\****************************************** *****************************/
interruptor (LOWORD (wParam))
{
//El bloque de desplazamiento está en la parte superior y ya no se puede mover
case SB_TOP:
si.nPos = si.nMin;
break;
//El bloque de desplazamiento está en la parte inferior y ya no se puede mover
case SB_BOTTOM:
si.nPos = si.nMax ;
break ;
//Haga clic con el mouse en la flecha encima de la barra de desplazamiento vertical
case SB_LINEUP:
//Cada clic La posición del bloque de desplazamiento cae en una unidad
si.nPos -= 1;
break;
//Haga clic en la flecha debajo de la barra de desplazamiento vertical
p>case SB_LINEDOWN:
//La posición del bloque de desplazamiento aumenta en una unidad cada vez que se hace clic
si. nPos = 1;
break;
//Haga clic en la parte superior del bloque de desplazamiento y el bloque de desplazamiento aumentará una unidad cada vez que haga clic en él
case SB_PAGEUP:
si.nPos -= si.nPage;
break;
//Haga clic en la parte inferior del bloque de desplazamiento y el desplazamiento el bloque soltará una unidad cada vez que haga clic en él
case SB_PAGEDOWN:
si .nPos = si.nPage
break .nPos = si.nTrackPos;
break ;
//Otras operaciones
predeterminado:
break
}
//La posición actual del bloque de desplazamiento
si.fMask = SIF_POS;
//Cambie lo anterior (SB_#####) para procesar, obtenga el resultado y muestra la posición del bloque de desplazamiento en la ventana del programa de creación
SetScrollInfo (hwnd, SB_VERT, amp;si, TRUE);
GetScrollInfo (hwnd, SB_VERT , amp; si);
//Cuando se utiliza la barra de desplazamiento, el contenido de la ventana también debe actualizarse en consecuencia
if (si.nPos != iVertPos)
p>
{
/************************************ ***********************************\
Prototipo de función ScrollWindow:
ScrollWindow(
HWND hWnd,
int XAmount,
int YAmount,
CONST RECT *lpRect,
p>
CONST RECT *lpClipRect);
\************************ ************ **************************************** */
ScrollWindow ( hwnd , 0, cyChar * (iVertPos - si.nPos),
NULL, NULL
//Redibujar la ventana
UpdateWindow (hwnd) ;
}
devuelve 0 ;
}
caso WM_RBUTTONDOWN:
{
}
caso WM_LBUTTONDOWN:
{
iCount = 0
InvalidateRect; (hwnd, NULL, TRUE);
p>
SetCaretPos(LOWORD(lParam), HIWORD(lParam));
ShowCaret(hwnd); p> }
devuelve 0;
p>
caso WM_LBUTTONUP:
InvalidateRect (hwnd, NULL, FALSE); > devolver 0;
case WM_MOUSEMOVE:
if (wParam amp; MK_LBUTTON amp; amp; iCount lt; 1000)
{
st[iCount].x = LOWORD (lParam);
st[iCount].y = HIWORD (lParam);
hdc = GetDC (hwnd);
SetPixel (hdc, LOWORD (lParam), HIWORD (lParam), 0
ReleaseDC (hwnd, hdc
}
retorno); 0;
//Iniciar salida de texto
case WM_PAINT:
{
hdc = BeginPaint (hwnd, amp; ps);
si.cbSize = tamaño de (si
p>);
si.fMask = SIF_POS;
GetScrollInfo (hwnd, SB_VERT, y si);
iVertPos = si.nPos
GetScrollInfo (hwnd, SB_HORZ, amp; si) ;
iHorzPos = si.nPos;
//#define max(a, b) (((a) gt; (b))? (a) : (b))
//#define min(a, b) (((a) lt; (b))? (a): (b))
iPaintBeg = max (0, iVertPos ps.rcPaint.top / cyChar);
iPaintEnd = min (46, iVertPos ps.rcPaint.bottom / cyChar); veces
for (i = iPaintBeg; i lt; = iPaintEnd; i)
{
x = cxChar * (1 - iHorzPos);
y = cyChar * (i - iVertPos);
//Para marcar el número de líneas, use la variable de bucle i como contador y muestre
TextOut (hdc, x, y, szBuffer, wsprintf (szBuffer, TEXT ("d"), i));
//Emite el nombre en inglés de la primera columna en la matriz de nombres
//TextOut(hdc, x 15 * cxCaps 40 * cxChar, y, nombre[i].EnglishName,
// lstrlen (nombre[i].EnglishName)); p>//Emite el primer nombre en la matriz de nombres Nombres chinos correspondientes a dos columnas de nombres en inglés
// TextOut(hdc, x 15 * cxCaps, y, name[i].ChineseName,
// lstrlen (nombre[i] .ChineseName));
SetTextAlign (hdc, TA_LEFT | TA_TOP);
}
/ *Se utiliza para iniciar el programa*/
TextOut(hdc, 50, 10, szText_1, strlen(szText_1));
TextOut(hdc, 50, 30, szText_2, strlen(szText_2) ));
//Función de llamada de dibujo
switch(wParam)
{
caso 1: //Punto de prototipo
SelectObject(hdc, GetStockObject(BLACK_BRUSH ));
Elipse(hdc, 350, 100, 380, 130);
caso 2: //Línea
MoveToEx(hdc, 200, 200, NULL
LineTo(hdc, 500, 300); >
break;
caso 3: //rectángulo derecho
SelectObject(hdc, GetStockObject(BLACK_BRUSH));
Rectángulo(hdc, 200, 100, 400, 200);
break;
caso 4: //Rectángulo redondeado
SelectObject(hdc, GetStockObject(BLACK_BRUSH));
p>RoundRect(hdc, 200, 100, 400, 200, 50, 40
descanso
caso 5: //elipse
<); p > SelectObject(hdc, GetStockObject(BLACK_BRUSH));Elipse(hdc, 200, 100, 400, 200);
ruptura
caso 6; : //Forma circular
SelectObject(hdc, GetStockObject(BLACK_BRUSH));
Pie(hdc, 200, 100, 400, 200, 450, 220, 150, 220);
ruptura;
caso 7: //Arc
SelectObject(hdc, GetStockObject(BLACK_BRUSH));
Arc(hdc, 200, 100, 400, 200, 450, 220, 150, 220);
break;
caso 8: //cadena
SelectObject(hdc, GetStockObject(BLACK_BRUSH));
Acorde(hdc, 200, 100, 400, 200, 450, 220, 150, 220);
pausa;
caso 9: //SINAWAVE
{
int h;
MoveToEx (hdc, 0, 250,
LineTo); (hdc, 300, 250);
for (h = 0; h lt; NUM; h)
{
apt[h].x = h * 300 / NUM ;
apt[h].y = (int) (250 * (1 - sin (DOSPI * h / NUM)))
} p>
Polilínea (hdc, apt, NUM);
break
}
c;
ejemplo 10: //LINEDEMO
{
Rectángulo (hdc, 30, 60, 210, 420
MoveToEx (hdc, 0, 0, NULL);
LíneaA (hdc, 30, 60);
MoveToEx (hdc, 0, 60,
LíneaA (hdc, 30, 0);
Elipse (hdc, 30, 60, 210, 420
RedondoRect (hdc, 60, 120, 180, 360, 60, 120);
romper;
}
caso 11:
{
SetCursor (LoadCursor (NULL, IDC_WAIT)
p> p>// ShowCursor (TRUE);
para (f = 0; f lt; iCount - 1; f)
para (g = f 1; g lt ; iCount ; g )
{
MoveToEx (hdc, st[f].x, st[f].y, NULL) ;
LineTo ( hdc, st[g].x, st[g].y);
}
// ShowCursor (FALSE);
// SetCursor ( LoadCursor (NULL, IDC_ARROW));
// DrawBezier (hdc, apt);
break; caso 12:
{
TextOut(hdc, 100, 50, "a", 1);
caso 13:
{
TextOut(hdc, 120, 50, "b", 1); /p >
}
caso 14:
{
TextOut(hdc, 140, 50, "1", 1
romper;
}
}
EndPaint (hwnd, amp; ps); p>
}
caso WM_SETFOCUS:
{
//CreateCaret(, HBITMAP,,
)----gt; WINGDIAPI HBITMAP WINAPI CreateBitmap\
//(int, int, UINT, UINT, CONST VOID *);
/*
CreateCaret(hwnd, NULL, 10, 20);
ShowCaret(hwnd);
*/
CreateCaret (hwnd, NULL, cxChar, cyChar)
SetCaretPos (xCaret * cxChar, yCaret * cyChar)
ShowCaret (hwnd)
devuelve 0 ; ;
}
case WM_KILLFOCUS:
{
//El cursor se pierde
DestroyCaret() ;
return 0;
}
case WM_DESTROY:
{
//Destrucción del programa procesar
p>PostQuitMessage(0);
devolver 0;
}
// cambiar (LOWORD (wParam))
// {
// case ID_MENUITEM40041:
// SetClassLong(hwnd, GCL_HCURSOR, (LONG)LoadCursor
// ( NULL, MAKEINTRESOURCE(32512 (iCursor )5)));
// return 0;
// }