Código Fonte

Desenha um retângulo na área do cliente

2024-07-05T14:37:00.000-07:00

main.html

#include <windows.h>

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    PAINTSTRUCT ps;
    HBRUSH hBrush;
    HDC hdc;
    RECT rect;
    
    switch(msg) {
        case WM_PAINT:
            BeginPaint(hwnd, &ps);
            hdc = GetDC(hwnd);
            GetClientRect(hwnd, &rect);
            hBrush = CreateSolidBrush(RGB(0, 77, 77));
            hBrush = (HBRUSH) SelectObject(hdc, hBrush);
            Rectangle(hdc, 80,80,rect.right,rect.bottom);
            DeleteObject(SelectObject(hdc, hBrush));
            EndPaint(hwnd, &ps);
            break;
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, LPSTR szCL, int iCS) {
    WNDCLASSEX wc; /* A properties struct of our window */
    HWND hwnd;
    MSG msg; /* A temporary location for all messages */

    /* zero out the struct and set the stuff we want to modify */
    memset(&wc,0,sizeof(wc));
    wc.cbSize      = sizeof(WNDCLASSEX);
    wc.lpfnWndProc = WndProc;
    wc.hInstance   = hI;
    wc.hCursor     = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszClassName = "WindowClass";
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "WindowClass",
        "Desenha um retângulo",
        WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        200, /* x */
        40, /* y */
        360, /* width */
        360, /* height */
        NULL,
        NULL,
        hI,
        NULL
    );

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

    while(GetMessage(&msg, NULL, 0, 0) > 0) { /* If no error is received... */
        TranslateMessage(&msg); /* Translate key codes to chars if present */
        DispatchMessage(&msg); /* Send it to WndProc */
    }
    return msg.wParam;
}

Desenho em formato de Pizza com a função Pie

2024-07-04T00:50:00.000-07:00

main.html

#include <windows.h>

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    PAINTSTRUCT ps;
    HBRUSH hBrush;
    HDC hdc;
    RECT rect;
    
    switch(msg) {
        case WM_PAINT:
            BeginPaint(hwnd, &ps);
            hdc = GetDC(hwnd);
            GetClientRect(hwnd, &rect);
            hBrush = CreateSolidBrush(RGB(0, 100, 89));
            hBrush = (HBRUSH) SelectObject(hdc, hBrush);
            Pie(
                hdc,
                40, 20, 226, 144,
                155, 32, 202, 115
            );
            DeleteObject(SelectObject(hdc, hBrush));
            EndPaint(hwnd, &ps);
            break;
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, LPSTR szCL, int iCS) {
    WNDCLASSEX wc; /* A properties struct of our window */
    HWND hwnd;
    MSG msg; /* A temporary location for all messages */

    /* zero out the struct and set the stuff we want to modify */
    memset(&wc,0,sizeof(wc));
    wc.cbSize      = sizeof(WNDCLASSEX);
    wc.lpfnWndProc = WndProc;
    wc.hInstance   = hI;
    wc.hCursor     = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszClassName = "WindowClass";
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "WindowClass",
        "Desenho em forma de Pizza",
        WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        200, /* x */
        40, /* y */
        360, /* width */
        360, /* height */
        NULL,
        NULL,
        hI,
        NULL
    );

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

    while(GetMessage(&msg, NULL, 0, 0) > 0) { /* If no error is received... */
        TranslateMessage(&msg); /* Translate key codes to chars if present */
        DispatchMessage(&msg); /* Send it to WndProc */
    }
    return msg.wParam;
}

Desenha uma elipse de acordo com o tamanho da janela

2024-07-03T21:34:00.000-07:00

main.html

#include <windows.h>

/* This is where all the input to the window goes to */
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    PAINTSTRUCT ps;
    HBRUSH hBrush;
    HDC hdc;
    RECT rect;
    
    switch(msg) {
        case WM_PAINT:
            BeginPaint(hwnd, &ps);
            hdc = GetDC(hwnd);
            GetClientRect(hwnd, &rect);
            hBrush = CreateSolidBrush(RGB(7, 45, 121));
            hBrush = (HBRUSH) SelectObject(hdc, hBrush);
            Ellipse(hdc, rect.left, rect.top, rect.right, rect.bottom);
            DeleteObject(SelectObject(hdc, hBrush));
            EndPaint(hwnd, &ps);
            break;
        /* Upon destruction, tell the main thread to stop */
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
        /* All other messages (a lot of them) are processed using default procedures */
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

/* The 'main' function of Win32 GUI programs: this is where execution starts */
int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, LPSTR szCL, int iCS) {
    WNDCLASSEX wc; /* A properties struct of our window */
    HWND hwnd; /* A 'HANDLE', hence the H, or a pointer to our window */
    MSG msg; /* A temporary location for all messages */

    /* zero out the struct and set the stuff we want to modify */
    memset(&wc,0,sizeof(wc));
    wc.cbSize      = sizeof(WNDCLASSEX);
    wc.lpfnWndProc = WndProc; /* This is where we will send messages to */
    wc.hInstance   = hI;
    wc.hCursor     = LoadCursor(NULL, IDC_ARROW);
	
    /* White, COLOR_WINDOW is just a #define for a system color, try Ctrl+Clicking it */
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wc.lpszClassName = "WindowClass";
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION); /* Load a standard icon */
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION); /* use the name "A" to use the project icon */

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

    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "WindowClass",
        "Ellipse",
        WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        200, /* x */
        40, /* y */
        500, /* width */
        400, /* height */
        NULL,
        NULL,
        hI,
        NULL
    );

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

    /*
        This is the heart of our program where all input is processed and 
        sent to WndProc. Note that GetMessage blocks code flow until it receives something, so
        this loop will not produce unreasonably high CPU usage
    */
    while(GetMessage(&msg, NULL, 0, 0) > 0) { /* If no error is received... */
        TranslateMessage(&msg); /* Translate key codes to chars if present */
        DispatchMessage(&msg); /* Send it to WndProc */
    }
    return msg.wParam;
}

Funções GetSystemTime e GetLocalTime | Linguagem C

2024-06-30T20:08:00.000-07:00

main.html

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

void main(void) {
    system("title SYSTEMTIME");
    SYSTEMTIME st, lt;
    HANDLE pcmd;
    pcmd = GetStdHandle(STD_OUTPUT_HANDLE);
    GetSystemTime(&st);
    GetLocalTime(&lt);
    SetConsoleTextAttribute(pcmd, 46);
    printf(
        "\n\nHora do sistema: %02d:%02d\n",
        st.wHour,
        st.wMinute
    );
    printf(
        "Hora local: %02d:%02d\n",
        lt.wHour,
        lt.wMinute
    );
}

Resto da divisão em C/C++

2024-06-30T19:51:00.000-07:00

main.html

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

int resto(int x, int y) {
    return x % y;
}

void main(void) {
    system("title Resto da Divisão");
    setlocale(LC_ALL, "ptb");
    SYSTEMTIME st, lt;
    int x, y;
    HANDLE pcmd;
    pcmd = GetStdHandle(STD_OUTPUT_HANDLE);
    GetSystemTime(&st);
    GetLocalTime(&lt);
    SetConsoleTextAttribute(pcmd, 46);
    printf("\n\nValor de x: ");
    scanf("%d", &x);
    printf("\n\nValor de y: ");
    scanf("%d", &y);
    printf("\n\nO resto de %d / %d é %d", x, y, resto(x,y));
}

Exemplo de uso da função SetConsoleTextAttribute(função válida somente em sistemas Windows) em C/C++

2024-06-25T11:10:00.000-07:00

main.html

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

void main(void) {
    system("title Tabuleiro 16 por 16");
    int i, j;
    HANDLE pcmd;
    pcmd = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(pcmd, 46);
    for(i=1; i<=16; i++) {
        for(j=1; j<=16; j++) {
            if((i+j)%2==0)
                printf("\xdb\xdb");
            else
                printf("  ");
        }
        printf("\n");
    }
}

Linguagem C - Acesso em Arquivos

2024-06-22T15:39:00.000-07:00

main.html

#include <stdio.h>
#include <io.h>
#include <stdlib.h>
/**
    0 -> Verifica se o arquivo existe
    2 -> Verifica se o arquivo pode ser gravado
    4 -> Verifica se o arquivo pode ser lido
    6 -> Verifica se o programa tem permissão
             de leitura e gravação no arquivo
*/
void main(int argc, char *argv[]) {
    system("title Acesso de Arquivos");//stdlib.h
    int modo_acesso = access("mlist", 0); //io.h
    if(modo_acesso)
        printf("\n\nO arquivo %s não existe\n");
    else {
        modo_acesso = access("mlist", 2); //io.h
        if(modo_acesso)
            printf("O arquivo não pode ser gravado\n");
        else
            printf("O arquivo pode ser gravado\n");
        modo_acesso = access("mlist", 4); //io.h
        if(modo_acesso)
            printf("O arquivo não pode ser lido\n");
        else
            printf("O arquivo pode ser lido\n");
        modo_acesso = access("mlist", 6); //io.h
        if(modo_acesso)
            printf("O arquivo não pode ser lido/gravado\n");
        else
            printf("O arquivo pode ser lido/gravado\n");
    }
}

Linguagem C - Acesso em Arquivos

2024-06-22T15:13:00.000-07:00

main.html

#include <stdio.h>
#include <io.h>
#include <stdlib.h>
/**
    0 -> Verifica se o arquivo existe
    2 -> Verifica se o arquivo pode ser gravado
    4 -> Verifica se o arquivo pode ser lido
    6 -> Verifica se o programa tem permissão
             de leitura e gravação no arquivo
*/
void main(int argc, char *argv[]) {
    system("title Acesso de Arquivos");
    int modo_acesso = access(argv[1], 0); //io.h
    if(modo_acesso)
        printf("\n\nO arquivo %s não existe\n");
    else {
        modo_acesso = access(argv[1], 2); //io.h
        if(modo_acesso)
            printf("O arquivo não pode ser gravado\n");
        else
            printf("O arquivo pode ser gravado\n");
        modo_acesso = access(argv[1], 4); //io.h
        if(modo_acesso)
            printf("O arquivo não pode ser lido\n");
        else
            printf("O arquivo pode ser lido\n");
        modo_acesso = access(argv[1], 6); //io.h
        if(modo_acesso)
            printf("O arquivo não pode ser lido/gravado\n");
        else
            printf("O arquivo pode ser lido/gravado\n");
    }
}

Para sair pressione a letra Q

2024-06-11T15:14:00.000-07:00

main.html

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define MAX 100

char *p[MAX];
char *qretrieve(void);

int spos = 0;
int rpos = 0;

void enter(void);
void qstore(char *q);
void review(void);
void delete(void);

void main(void) {
    char s[80];
    register int t;
    for(t=0; t<MAX; ++t) {
        p[t] = NULL;
    }
    for(;;) {
        printf("Inserir, Listar, Remover, Sair: ");
        gets(s);
        *s = toupper(*s);
        switch(*s) {
            case 'E':
                enter();
                break;
            case 'L':
            	review();
            	break;
            case 'R':
            	delete();
            	break;
            case 'Q':
            	exit(0);
        }
    }
}

void enter(void) {
    char s[256], *p;
    do {
        printf("Insira o evento %d: ", spos+1);
        gets(s);
        if(*s==p) {
            break; //Sem entrada
        }
        p = malloc(strlen(s)+1);
        if(!p) {
            printf("Sem memória!\n");
            return;
        }
        strcpy(p, s);
        if(*s) {
            qstore(p);
        }
    } while(*s);
}

void review(void) {
    register int t;
    for(t=rpos; t<spos; ++t) {
        printf("%d. %s\n", t+1, p[t]);
    }
}

void delete(void) {
    char *p;
    if((p=qretrieve())==NULL) {
        return;
    }
    printf("%s\n", p);
}
//Armazena um evento
void qstore(char *q) {
    if(spos==MAX) {
        printf("Lista cheia\n");
        return;
    }
    p[spos] = q;
    spos++;
}
//Recupera um evento
char *qretrieve(void) {
    if(rpos==spos) {
        printf("Sem eventos.\n");
        return NULL;
    }
    rpos++;
    return p[rpos-1];
}

A função trocar é responsável por inverter os valores de "a" e "b"

2024-06-11T03:10:00.000-07:00

main.html

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include "resource.h"

void trocar(int *, int *);

char txt[] = {"Trocar"};

TCHAR szAppName[] = TEXT("RECURSOS");

HFONT hFonte;

static HWND btn, edit1, edit2, edit3, edit4;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    switch(msg) {
        case WM_CREATE:
            hFonte=CreateFont(28,0,0,0,0,FALSE,0,0,0,0,0,0,0,"Arial");
            edit1 = CreateWindow(
                TEXT("edit"),TEXT(""),WS_VISIBLE|WS_CHILD|DT_CENTER,
                10, 80, 80, 30,
                hwnd, NULL, NULL, NULL
            );
            edit2 = CreateWindow(
                TEXT("edit"),TEXT(""),WS_VISIBLE|WS_CHILD|DT_CENTER,
                120, 80, 80, 30,
                hwnd, NULL, NULL, NULL
            );
            btn = CreateWindow(
                TEXT("button"), TEXT("Trocar"), WS_VISIBLE | WS_CHILD,
                230, 80, 120, 30,
                hwnd, (HMENU) IBTN, NULL, NULL
            );
            edit3 = CreateWindow(
                TEXT("edit"),TEXT(""),WS_VISIBLE|WS_CHILD|DT_CENTER,
                380, 80, 80, 30,
                hwnd, NULL, NULL, NULL
            );
            edit4 = CreateWindow(
                TEXT("edit"),TEXT(""),WS_VISIBLE|WS_CHILD|DT_CENTER,
                490, 80, 80, 30,
                hwnd, NULL, NULL, NULL
            );
            SendMessage(btn, WM_SETFONT, (WPARAM) hFonte, TRUE);
            SendMessage(edit1, WM_SETFONT, (WPARAM) hFonte, TRUE);
            SendMessage(edit2, WM_SETFONT, (WPARAM) hFonte, TRUE);
            SendMessage(edit3, WM_SETFONT, (WPARAM) hFonte, TRUE);
            SendMessage(edit4, WM_SETFONT, (WPARAM) hFonte, TRUE);
            return 0;
        case WM_COMMAND:
            if(LOWORD(wP)==IDM_A1) {
                int cxScreen, cyScreen;
                cxScreen = GetSystemMetrics(0);
                cyScreen = GetSystemMetrics(1);
                char tela[20];
                wsprintf(
                    tela,
                    "Vertical: %d Horiontal: %d",
                    cxScreen,
                    cyScreen
                );
            	MessageBox(
                    NULL,
                    tela,
                    "Medidas do Monitor!",
                    MB_OK
                );
            }
            if(LOWORD(wP)==IDM_A2) {
            	MessageBox(
                    NULL,
                    "O aplicativo será fechado!",
                    "Aviso!",
                    MB_OK
                );
                exit(0);
            }
            if(LOWORD(wP)==IDM_A3) {
            	MessageBox(
                    NULL,
                    __TIME__,
                    "Hora:",
                    MB_OK
                );
            }
            if(LOWORD(wP)==IBTN) {
            	int x = GetWindowTextLength(edit1)+1;
            	int y = GetWindowTextLength(edit2)+1;
            	static char a[50], b[50];
                GetWindowText(edit1, a, x);
                GetWindowText(edit2, b, y);
                int n1 = atoi(a), n2 = atoi(b);
                trocar(&a, &b);
                SetWindowText(edit3, a);
                SetWindowText(edit4, b);
            }
            return 0;
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
		
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, LPSTR szCL, int iCS) {
    WNDCLASS wc;
    HWND     hwnd;
    MSG      msg;

    wc.style       = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra  = 0;
    wc.cbWndExtra  = 0;
    wc.hInstance   = hI;
    wc.hIcon       = LoadIcon(hI, ICONE);
    wc.hCursor     = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetSysColorBrush(COLOR_MENUHILIGHT);
    wc.lpszMenuName  = szAppName;
    wc.lpszClassName = szAppName;

    if(!RegisterClass(&wc)) {
        MessageBox(
            NULL,
            "Window Registration Failed!",
            "Error!",
            MB_ICONEXCLAMATION | MB_OK
        );
        return 0;
    }

    hwnd = CreateWindow(
        szAppName, txt, WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 600, 250,
        NULL, NULL, hI, NULL
    );

    ShowWindow(hwnd, iCS);
    UpdateWindow(hwnd);

    while(GetMessage(&msg, NULL, 0, 0) > 0) {
        TranslateMessage(&msg);
        DispatchMessage(&msg); /* Send it to WndProc */
    }
    return msg.wParam;
}

void trocar(int *p, int *q) {
    int x;
    x = *p;
    *p = *q;
    *q = x;
}

Menu e submenu

2024-06-07T05:08:00.000-07:00

main.html

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include "resource.h"

char txt[] = {"Arquivos de Recursos"};

TCHAR szAppName[] = TEXT("RECURSOS");

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    switch(msg) {
        case WM_COMMAND:
            if(LOWORD(wP)==IDM_A1) {
                int cxScreen, cyScreen;
                cxScreen = GetSystemMetrics(0);
                cyScreen = GetSystemMetrics(1);
                char tela[20];
                wsprintf(
                    tela,
                    "Vertical: %d Horiontal: %d",
                    cxScreen,
                    cyScreen
                );
            	MessageBox(
                    NULL,
                    tela,
                    "Medidas do Monitor!",
                    MB_OK
                );
            }
            if(LOWORD(wP)==IDM_A2) {
            	MessageBox(
                    NULL,
                    "O aplicativo será fechado!",
                    "Aviso!",
                    MB_OK
                );
                exit(0);
            }
            if(LOWORD(wP)==IDM_A3) {
            	MessageBox(
                    NULL,
                    __TIME__,
                    "Hora:",
                    MB_OK
                );
            }
            return 0;
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
		
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, LPSTR szCL, int iCS) {
    WNDCLASS wc;
    HWND     hwnd;
    MSG      msg;

    wc.style       = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra  = 0;
    wc.cbWndExtra  = 0;
    wc.hInstance   = hI;
    wc.hIcon       = LoadIcon(hI, ICONE);
    wc.hCursor     = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetSysColorBrush(COLOR_GRAYTEXT);
    wc.lpszMenuName  = szAppName;
    wc.lpszClassName = szAppName;

    if(!RegisterClass(&wc)) {
        MessageBox(
            NULL,
            "Window Registration Failed!",
            "Error!",
            MB_ICONEXCLAMATION | MB_OK
        );
        return 0;
    }

    hwnd = CreateWindow(
        szAppName, txt, WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 500, 300,
        NULL, NULL, hI, NULL
    );

    ShowWindow(hwnd, iCS);
    UpdateWindow(hwnd);

    while(GetMessage(&msg, NULL, 0, 0) > 0) {
        TranslateMessage(&msg);
        DispatchMessage(&msg); /* Send it to WndProc */
    }
    return msg.wParam;
}

resource.html



/* -- Arquivo: resource.h -- */


#define ICONE  17

#define IDM_A1 18
#define IDM_A2 19
#define IDM_A3 20
#define IDM_A4 21
#define IDM_A5 22
#define IDM_A6 23
#define IDM_A7 24

resourcerc.html



/* -- Arquivo: resource.rc -- */


#include "resource.h"
#include "afxres.h"

ICONE ICON "project1.ico"

RECURSOS MENU DISCARDABLE
BEGIN
    POPUP "&Detalhe"
    BEGIN
        MENUITEM "&Monitor",  IDM_A1
        MENUITEM "&Fechar",   IDM_A2
    END
    MENUITEM "&Horário",      IDM_A3
    MENUITEM "&Conexão",      IDM_A4
    MENUITEM "&Sistema",      IDM_A5
    MENUITEM "&Localização",  IDM_A6
    MENUITEM "&Memória",      IDM_A7
END

Usando variáveis do tipo register

2024-06-06T05:37:00.000-07:00

index1.html

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>

int mult(register int x, register int y) {
    return (x*y);
}
int main() {
    system("title Usando variáveis do tipo register");
    setlocale(LC_ALL, "ptb");
    int a = 3, b = 7, resultado;
    resultado = mult(a, b);
    printf("\nResultado: %d\n", resultado);
}

Imprime o maior valor ao comparar "a", "b" e "c"

2024-06-02T14:33:00.000-07:00

main.html

#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <locale.h>

int maior(int x, int y, int z) {
    int max = x;
    if(y > max) {
        max = y;
    }
    if(z > max) {
        max = z;
    }
    return max;
}

void main(void) {
    system("title Imprime o maior valor ao comparar \"a\", \"b\" e \"c\"");
    setlocale(LC_ALL, "ptb");
    HANDLE ptc;
    ptc = GetStdHandle(STD_OUTPUT_HANDLE);
    int a = 7, b = 2, c = 15, x;
    x = maior(a,b,c);
    SetConsoleTextAttribute(ptc, 11);
    printf("\n\nO maior valor é %d\n", x);
}

Laço for na condição i!=j

2024-05-17T11:56:00.000-07:00

Sem Título1.html

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    system("title Laço for na condição i!=j");
    
    int i, j;
    for(i=1, j=9; i!=j; i++, j--) {
    	printf("i = %d   j = %d\n", i ,j);
    } 

    getchar();
    return 0;
}

COMPRE JÁ SUA POINT SMART COM 69% DE DESCONTO
------------------ Mercado Pago ------------------

Ponteiro para estrutura em argumento de função | Linguagem C

2024-02-01T04:19:00.000-08:00

main.html

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct pessoa {
    int idade;
    char nome[20];
    char desc[50];
};

static void my_print(struct pessoa *ptr) {
    fprintf(
        stdout,
        "\n\nNome: %s\nIdade: %d\nDescrição: %s\n",
        ptr->nome,
        ptr->idade,
        ptr->desc
    );
}

int main() {
    struct pessoa idn;
    memset(&idn, 0, sizeof(idn));
    idn.idade = 29;
    snprintf(idn.nome, sizeof(idn.nome), "Erick");
    snprintf(
        idn.desc,
        sizeof(idn.desc),
        "Engenheiro Mecânico"
    );
    my_print(&idn);//Imprime na tela
    return 0;
}

Informações do hardware - Linguagem C/C++

2023-10-03T02:02:00.001-07:00

main.html

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

#define BTN_BUSCA 1

void Controles(HWND);

static HWND c1, c2, c3, c4, c5, c6, c7;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    SYSTEM_INFO siSysInfo;
    GetSystemInfo(&siSysInfo); 
    switch(msg) {
        case WM_CREATE:
            Controles(hwnd);
            return 0;
        case WM_COMMAND:
            if(LOWORD(wP)==BTN_BUSCA) {
            	static char v1[50],v2[50],v3[50],v4[50],v5[50],v6[50],v7[50];
                sprintf(v1, "OEM ID: %u", siSysInfo.dwOemId);
                sprintf(
                    v2, "Number of processors: %u",
                    siSysInfo.dwNumberOfProcessors
                );
                sprintf(v3, "Page size: %u", siSysInfo.dwPageSize);
                sprintf(v4, "Processor type: %u", siSysInfo.dwProcessorType);
                sprintf(
                    v5, "Minimum application address: %lx",
                    siSysInfo.lpMinimumApplicationAddress
                );
                sprintf(
                    v6, "Maximum application address: %lx",
                    siSysInfo.lpMaximumApplicationAddress
                );
                sprintf(
                    v7, "Active processor mask: %u",
                    siSysInfo.dwActiveProcessorMask
                );
                SetWindowText(c1, v1);
                SetWindowText(c2, v2);
                SetWindowText(c3, v3);
                SetWindowText(c4, v4);
                SetWindowText(c5, v5);
                SetWindowText(c6, v6);
                SetWindowText(c7, v7);
            }
            return 0;
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
		
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

void Controles(HWND hwnd) {
    CreateWindow(
        TEXT("button"),TEXT("Getting Hardware Information"),
        WS_VISIBLE | WS_CHILD | WS_BORDER,
        20, 20, 250, 20,
        hwnd, (HMENU) BTN_BUSCA, NULL, NULL
    );
    c1 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        20, 60, 250, 20,
        hwnd, NULL, NULL, NULL
    );
    c2 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        20, 100, 250, 20,
        hwnd, NULL, NULL, NULL
    );
    c3 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        20, 140, 250, 20,
        hwnd, NULL, NULL, NULL
    );
    c4 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        20, 180, 250, 20,
        hwnd, NULL, NULL, NULL
    );
    c5 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        20, 220, 250, 20,
        hwnd, NULL, NULL, NULL
    );
    c6 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        20, 260, 250, 20,
        hwnd, NULL, NULL, NULL
    );
    c7 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        20, 300, 250, 20,
        hwnd, NULL, NULL, NULL
    );
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, LPSTR lpCmdLine, int iCS) {
    WNDCLASSEX wc; /* A properties struct of our window */
    HWND hwnd; /* A 'HANDLE', hence the H, or a pointer to our window */
    MSG msg; /* A temporary location for all messages */

    memset(&wc,0,sizeof(wc));
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.lpfnWndProc   = WndProc;
    wc.hInstance     = hI;
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetSysColorBrush(COLOR_MENUHILIGHT);
    wc.lpszClassName = "WindowClass";
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE, "WindowClass", "Programação para Windows",
        WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, /* x */
        CW_USEDEFAULT, /* y */
        310, /* width */
        385, /* height */
        NULL, NULL, hI, NULL
    );

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

    while(GetMessage(&msg, NULL, 0, 0) > 0) {
        TranslateMessage(&msg);
        DispatchMessage(&msg); /* Send it to WndProc */
    }
    return msg.wParam;
}

Calcula o maior dos valores nos campos num1, num2 e num3, o resultado estará armazenado na variável valorfinal através da função sprintf

2023-09-29T13:26:00.003-07:00

main.html

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

#define BTN_BUSCA 1

void Controles(HWND);
int mm(int, int, int);

static HWND num1, num2, num3, r;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    switch(msg) {
        case WM_CREATE:
            Controles(hwnd);
            return 0;
        case WM_COMMAND:
            if(LOWORD(wP)==BTN_BUSCA) {
                int n1 = GetWindowTextLength(num1)+1;
                int n2 = GetWindowTextLength(num2)+1;
                int n3 = GetWindowTextLength(num3)+1;
                static char nr1[50], nr2[50], nr3[50], valorfinal[50];
                GetWindowText(num1, nr1, n1);
                GetWindowText(num2, nr2, n2);
                GetWindowText(num3, nr3, n3);
                sprintf(
                    valorfinal,
                    "%d é o maior valor digitado",
                    mm(atoi(nr1), atoi(nr2), atoi(nr3))
                );
                SetWindowText(r, valorfinal);
            }
            return 0;
        /* Upon destruction, tell the main thread to stop */
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

void Controles(HWND hwnd) {
    num1 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_BORDER,
        10, 70, 70, 20,
        hwnd, NULL, NULL, NULL
    );
    num2 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_BORDER,
        100, 70, 70, 20,
        hwnd, NULL, NULL, NULL
    );
    num3 = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_BORDER,
        190, 70, 70, 20,
        hwnd, NULL, NULL, NULL
    );
    CreateWindow(
        TEXT("button"),TEXT("Calcular"),WS_VISIBLE|WS_CHILD|WS_BORDER,
        280, 70, 70, 20,
        hwnd, (HMENU) BTN_BUSCA, NULL, NULL
    );
    r = CreateWindow(
        TEXT("edit"), TEXT(""),WS_VISIBLE|WS_CHILD|WS_DISABLED,
        370, 70, 180, 20,
        hwnd, NULL, NULL, NULL
    );
}

int mm(int x, int y, int z) {
    int max = x;
    if(y > max) {
        max = y;
    }
    if(z > max) {
        max = z;
    }
    return max;
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, LPSTR szCL, int iCS) {
    WNDCLASSEX wc;
    HWND hwnd;
    MSG   msg;
    /* zero out the struct and set the stuff we want to modify */
    memset(&wc,0,sizeof(wc));
    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.lpfnWndProc   = WndProc;
    wc.hInstance     = hI;
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = GetSysColorBrush(COLOR_WINDOWFRAME);
    wc.lpszClassName = "WindowClass";
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE, "WindowClass",
        "Programação para Windows",
        WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, /* x */
        CW_USEDEFAULT, /* y */
        600, /* width */
        210, /* height */
        NULL, NULL, hI, NULL
    );

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

    while(GetMessage(&msg, NULL, 0, 0) > 0) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

Imprimir texto na tela, através de um arquivo externo

2023-09-06T10:29:00.002-07:00

main.html

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

static char font[50] = "Arial Black";
static char aviso[50] = "Crie um arquivo.txt na pasta do projeto";
static char CON[200];

static HFONT tamanho;

/* This is where all the input to the window goes to */
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
    PAINTSTRUCT ps;
    HDC         ctx;
    FILE *fp;
	
    switch(msg) {
        case WM_CREATE:
            CreateWindow(
                "edit", " ", WS_VISIBLE|WS_BORDER|WS_CHILD,
                10, 10, 280, 20,
                hwnd, NULL, NULL, NULL
            );
            CreateWindow(
                "edit", " ",WS_VISIBLE|WS_BORDER|WS_CHILD,
                10, 40, 280, 20,
                hwnd,NULL,NULL,NULL
            );
            CreateWindow(
                "edit", " ", WS_VISIBLE | WS_BORDER | WS_CHILD,
                10, 70, 280, 20,
                hwnd,NULL,NULL,NULL
            );
            CreateWindow(
                "button","Click Me", WS_VISIBLE | WS_BORDER | WS_CHILD,
                10, 100, 280, 20,
                hwnd, (HMENU) 1,NULL,NULL
            );
            return 0;
        case WM_COMMAND:
            tamanho = CreateFont(
                42, 0, 0, 0, 1,
                0, 0, 0, 0, 0,
                0, 0, 0, font
            );
            if(LOWORD(wP)==1) {
                MessageBoxA(NULL, aviso, "Importante!", MB_OK);
            }
            return 0;
        case WM_PAINT:
            ctx = BeginPaint(hwnd, &ps);
            
            SelectObject(ctx, tamanho);
            
            SetTextColor(ctx, RGB(120, 0, 136));
            fp = fopen("arquivo.txt", "r");
            fgets(CON, 126, fp);//char *fgets(char *str, int n, FILE *stream)
            
            TextOut(ctx, 10, 150, CON, strlen(CON));
            fclose(fp);
            EndPaint(hwnd, &ps);
            return 0;

        /* Upon destruction, tell the main thread to stop */
        case WM_DESTROY: {
            PostQuitMessage(0);
            break;
        }
		
        /* All other messages (a lot of them) are processed using default procedures */
        default:
            return DefWindowProc(hwnd, msg, wP, lP);
    }
    return 0;
}

/* The 'main' function of Win32 GUI programs: this is where execution starts */
int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPrevI, LPSTR lpCmdLine, int nCmdShow) {
    WNDCLASSEX wc; /* A properties struct of our window */
    HWND hwnd; /* A 'HANDLE', hence the H, or a pointer to our window */
    MSG msg; /* A temporary location for all messages */

    /* zero out the struct and set the stuff we want to modify */
    memset(&wc,0,sizeof(wc));
    wc.cbSize		 = sizeof(WNDCLASSEX);
    wc.lpfnWndProc	 = WndProc; /* This is where we will send messages to */
    wc.hInstance	 = hI;
    wc.hCursor		 = LoadCursor(NULL, IDC_ARROW);
	
    wc.hbrBackground = (HBRUSH)(COLOR_GRADIENTACTIVECAPTION+1);
    wc.lpszClassName = "WindowClass";
    wc.hIcon   = LoadIcon(NULL, IDI_APPLICATION); /* Load a standard icon */
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION); /* use the name "A" to use the project icon */

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

    hwnd = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        "WindowClass",
        "Janela Principal",
        WS_VISIBLE | WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, /* x */
        CW_USEDEFAULT, /* y */
        640, /* width */
        360, /* height */
        NULL, NULL, hI, NULL
    );

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

    /*
        This is the heart of our program where all input is processed and 
        sent to WndProc. Note that GetMessage blocks code flow until it receives something, so
        this loop will not produce unreasonably high CPU usage
    */
    while(GetMessage(&msg, NULL, 0, 0) > 0) { /* If no error is received... */
        TranslateMessage(&msg); /* Translate key codes to chars if present */
        DispatchMessage(&msg); /* Send it to WndProc */
    }
    return msg.wParam;
}

Listas Combobox

2023-08-26T00:51:00.002-07:00

A função SendMessage -> SendMessage(HWND, UINT, WPARAM, LPARAM);

Linguagem C - Função BeginPaint, SetMapMode, SetWindowExtEx, SetViewportExtEx, SelectObject, ExtCreatePen, BeginPath, MoveToEx, LineTo, ..

2022-08-24T23:58:00.006-07:00

main.html

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

HMENU hMenu;

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

void addMenus(HWND);

static int r = 0, g = 77, b = 77;

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, PSTR szCL, int iCS) {
   static TCHAR szAppName[] = TEXT("EndJoin") ;
   HWND hwnd;
   MSG msg;
   WNDCLASS wndclass;
   wndclass.style = CS_HREDRAW | CS_VREDRAW ;
   wndclass.lpfnWndProc = WndProc;
   wndclass.cbClsExtra = 0;
   wndclass.cbWndExtra = 0;
   wndclass.hInstance = hI;
   wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
   wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
   wndclass.hbrBackground=(HBRUSH) GetStockObject(GRAY_BRUSH);
   wndclass.lpszMenuName = NULL;
   wndclass.lpszClassName = szAppName;
   
   if(!RegisterClass(&wndclass)) {
      MessageBox(
         NULL,
         TEXT("This program requires Windows NT!"),
         szAppName,
         MB_ICONERROR
      );
      return 0;
   }
   hwnd = CreateWindow(
      szAppName, TEXT("Linguagem C"), WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
      NULL, NULL, hI, NULL
   );
   ShowWindow(hwnd, iCS);
   UpdateWindow(hwnd);
   while(GetMessage(&msg, NULL, 0, 0)) {
      TranslateMessage(&msg);
      DispatchMessage (&msg);
   }
   return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wP, LPARAM lP) {
   /* Configuração específica para canetas geométricas(PS_GEOMETRIC) */
   static int iEnd[] = {
      PS_ENDCAP_ROUND,
      PS_ENDCAP_SQUARE,
      PS_ENDCAP_FLAT
   };
   static int iJoin[] = {
      PS_JOIN_ROUND,
      PS_JOIN_BEVEL,
      PS_JOIN_MITER
   };
   /* Configuração específica para canetas geométricas(PS_GEOMETRIC) */
   
   static int cxClient, cyClient;
   HDC hdc;
   int i;
   LOGBRUSH lb; //lb contém os attributos do pincel
   PAINTSTRUCT ps;
   switch(msg) {
      case WM_SIZE:
         cxClient = LOWORD(lP);//Guarda o valor da largura em cxClient
         cyClient = HIWORD(lP);//Guarda o valor da altura em cyClient
         return 0;

      case WM_CREATE:
         addMenus(hwnd);
         return 0;
         
      case WM_COMMAND:
         if(LOWORD(wP)==5) {
            struct tm *ptr;
            time_t lt;
            lt = time(NULL);
            ptr = localtime(&lt);
            MessageBox(NULL, asctime(ptr), "Data e Hora:", MB_OK);
         }
         if(LOWORD(wP)==8) {
            int cxScreen, cyScreen;
            cxScreen = GetSystemMetrics(0);
            cyScreen = GetSystemMetrics(1);
            char charX[500], charY[500];
            itoa(cxScreen, charX, 10);
            itoa(cyScreen, charY, 10);

            char ttl[60];//total

            sprintf(ttl,"Horizontal: %spx - Vertical: %spx",charX,charY);

            MessageBox(NULL, ttl, "Tamanha da Tela: ", MB_OK);
         }
         if(LOWORD(wP)==11) {
            exit(0);
         }
         return 0;
         
      case WM_PAINT:
         hdc = BeginPaint(hwnd, &ps);
         SetMapMode(hdc, MM_ANISOTROPIC);
         SetWindowExtEx(hdc, 100, 100, NULL);
         SetViewportExtEx(hdc, cxClient, cyClient, NULL);
         lb.lbStyle = BS_SOLID; //Estilo do pincel
         lb.lbColor = RGB(r, g, b); //Cor do desenho
         lb.lbHatch = 0;
         for(i = 0; i < 3; i++) {
            SelectObject(
               hdc,
               ExtCreatePen( //Cria a caneta em modo geométrico
                  PS_SOLID | PS_GEOMETRIC | iEnd[i] | iJoin[i],
                  10,
                  &lb,
                  0,
                  NULL
               )
            );//Função SelectObject
            BeginPath(hdc);
            MoveToEx(//Posição inicial da linha de contorno
               hdc,
               10+30*i,
               25,
               NULL
            );       //Posição inicial da linha de contorno
            LineTo(hdc,20 + 30 * i,75);//Configura a linha de contorno
            LineTo(hdc,30 + 30 * i, 0);//Configura a linha de contorno
            EndPath(hdc);
            StrokePath(hdc);
            DeleteObject(
               SelectObject(hdc, GetStockObject(BLACK_PEN))
            );
            MoveToEx(hdc,10 + 30 * i,25,NULL);//Posição inicial da linha
            LineTo(hdc,20 + 30 * i,75);//Configura a linha(normal)
            LineTo(hdc,30 + 30 * i, 0);//Configura a linha(normal)
         } //Fecha o laço for
         EndPaint(hwnd, &ps);
         return 0; //WM_PAINT
      
      case WM_DESTROY:
         PostQuitMessage(0);
         return 0; //WM_DESTROY
   } //switch(msg)
   return DefWindowProc(hwnd, msg, wP, lP);
}

void addMenus(HWND hwnd) {
    hMenu = CreateMenu();//Menu Principal

    HMENU hFileMenu = CreateMenu();//SubMenu

    AppendMenu(hMenu,MF_POPUP,(UINT_PTR) hFileMenu,"Opções");
    AppendMenu(hFileMenu, MF_STRING, 5, "Data e Hora");
    AppendMenu(hFileMenu, MF_STRING, 8, "Medidas da tela..");
    AppendMenu(hFileMenu, MF_STRING, 11, "Sair");

    SetMenu(hwnd, hMenu);
}

COMPRE JÁ SUA POINT SMART COM 69% DE DESCONTO
------------------ Mercado Pago ------------------

Relógio Analógico em C - Pequeno trecho do código: iAngle[2] = pst->wSecond * 6;

2022-07-29T19:32:00.002-07:00

main.html


#include <windows.h>
#include <math.h>
#define ID_TIMER 1
#define dPI (2 * 3.14159)

static HFONT font;

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

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, PSTR szCL, int iCS) {
   static TCHAR szAppName[] = TEXT("Clock");
   HWND hwnd;
   MSG msg;
   WNDCLASS wndclass;
   wndclass.style = CS_HREDRAW | CS_VREDRAW;
   wndclass.lpfnWndProc = WndProc;
   wndclass.cbClsExtra = 0;
   wndclass.cbWndExtra = 0;
   wndclass.hInstance = hI;
   wndclass.hIcon = NULL;
   wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
   wndclass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
   wndclass.lpszMenuName = NULL;
   wndclass.lpszClassName = szAppName;
   if(!RegisterClass(&wndclass)) {
      MessageBox(NULL, TEXT("Error!"), szAppName, MB_ICONERROR);
      return 0;
   }
	
   hwnd = CreateWindow( /* ---- Janela Principal ---- */
      szAppName, TEXT("Analog Clock"), WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
      NULL, NULL, hI, NULL
   );                   /* ---- Janela Principal ---- */
	
   ShowWindow(hwnd, iCS);
   UpdateWindow(hwnd);
	
   while(GetMessage(&msg, NULL, 0, 0)) {
      TranslateMessage(&msg);
      DispatchMessage (&msg);
   }
   return msg.wParam ;
}

void SetIsotropic(HDC hdc, int cxClient, int cyClient) {
   SetMapMode(hdc, MM_ISOTROPIC);
   SetWindowExtEx(hdc, 1000, 1000, NULL);
   SetViewportExtEx(hdc, cxClient / 2, -cyClient / 2, NULL);
   SetViewportOrgEx(hdc, cxClient / 2, cyClient / 2, NULL);
}

void RotatePoint(POINT pt[], int iNum, int iAg) {
   int i;
   POINT ptTemp;
   for(i=0; i<iNum; i++) {
      ptTemp.x=(int)(pt[i].x*cos(dPI*iAg/360)+pt[i].y*sin(dPI*iAg/360));
      ptTemp.y=(int)(pt[i].y*cos(dPI*iAg/360)-pt[i].x*sin(dPI*iAg/360));
      pt[i] = ptTemp;
   }
}

void DrawClock(HDC hdc) {
   int iAngle;
   POINT pt[3];
   for(iAngle=0; iAngle<360; iAngle+=6) {
      pt[0].x = 0;
      pt[0].y = 900;
      RotatePoint(pt, 1, iAngle);
      pt[2].x = pt[2].y = iAngle % 5 ? 33 : 100;
      pt[0].x -= pt[2].x / 2;
      pt[0].y -= pt[2].y / 2;
      pt[1].x = pt[0].x + pt[2].x;
      pt[1].y = pt[0].y + pt[2].y;
      SelectObject(hdc, GetStockObject(BLACK_BRUSH));
      Ellipse(hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
   }
}

void DrawHands(HDC hdc, SYSTEMTIME * pst, BOOL fCh) {
   static POINT pt[3][5] = {
      0, -150, 100, 0, 0, 600, -100, 0, 0, -150,
      0, -200,  50, 0, 0, 800,  -50, 0, 0, -200,
      0,    0,   0, 0, 0,   0,    0, 0, 0,  800
   };
   int i, iAngle[3];
   POINT ptTemp[3][5];
   iAngle[0] = (pst->wHour * 30) % 360 + pst->wMinute / 2;
   iAngle[1] = pst->wMinute * 6;
   iAngle[2] = pst->wSecond * 6;
   memcpy(ptTemp, pt, sizeof(pt));
   
   /* ---------------------- for ---------------------- */
   /*Se i for igual a fCh então retorne 0, se não for o caso retorne 2;*/
   /*i menor que 3; i++*/
   for(i=fCh?0:2; i<3; i++) {
      RotatePoint(ptTemp[i], 5, iAngle[i]);/*Parte trigonométrica*/
      Polyline(hdc, ptTemp[i], 5);
   }
   /* ---------------------- for ---------------------- */
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
   static int cxClient, cyClient;
   static SYSTEMTIME stPv;
   BOOL fCG;
   HDC hdc, hdc2;
   PAINTSTRUCT ps;
   SYSTEMTIME st;
   switch(msg) {
      case WM_CREATE:
         SetTimer(hwnd, ID_TIMER, 1000, NULL);
         GetLocalTime(&st);
         stPv = st;
         return 0;
      case WM_SIZE:
         cxClient = LOWORD(lp);
         cyClient = HIWORD(lp);
         return 0;
      case WM_TIMER:
         GetLocalTime(&st);
         fCG = st.wHour != stPv.wHour || st.wMinute != stPv.wMinute;
         hdc = GetDC(hwnd);
         SetIsotropic(hdc, cxClient, cyClient);
         SelectObject(hdc, GetStockObject(WHITE_PEN));
         DrawHands(hdc, &stPv, fCG);
         SelectObject(hdc, GetStockObject(BLACK_PEN));
         DrawHands(hdc, &st, TRUE);
         ReleaseDC(hwnd, hdc);
         stPv = st;
         return 0;
      case WM_PAINT:
         hdc = BeginPaint(hwnd, &ps);
         font = CreateFont(
            70, 0, 0, 0, 1,
            0, 0, 0, 0, 0,
            0, 0, 0, "Arial Black"
         );
         SelectObject(hdc, font);
         SetTextColor(hdc, RGB(255, 0, 1));
         TextOut(hdc, 10, 20, "Relógio:", strlen("Relógio:"));
         SetIsotropic(hdc, cxClient, cyClient);
         DrawClock(hdc);
         DrawHands(hdc, &stPv, TRUE);
         EndPaint(hwnd, &ps);
         return 0;
      case WM_DESTROY:
         KillTimer(hwnd, ID_TIMER);
         PostQuitMessage(0);
         return 0;
   }
   return DefWindowProc(hwnd, msg, wp, lp);
}

Neste exemplo foi utilizado a função SetConsoleCursorPosition

2022-06-20T18:43:00.003-07:00

Neste exemplo foi utilizado a função SetConsoleCursorPosition

#include <windows.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include "resource.h"

#define LEFT  1
#define RIGHT 2
#define UP    3
#define DOWN  4

static int x = 30, y = 10;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void gotoxy(int, int);

void gotoxy(int x, int y) {
    COORD c;
    c.X = x;
    c.Y = y;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
}

int WINAPI WinMain(HINSTANCE hI, HINSTANCE hPI, PSTR szCL, int iCS) {
    system("title SetConsoleTitle");
    setlocale(LC_ALL, "ptb");
    static TCHAR szAppName[] = TEXT("SetConsoleTitle");
    MSG    msg;
    HWND   hwnd;

    HBITMAP      imagem;
    HBRUSH       hBrush;

    imagem  = LoadBitmap(hI, IMAGEM);
    hBrush  = CreatePatternBrush(imagem);
    DeleteObject(imagem);

    WNDCLASS wndclass;
    wndclass.style         = CS_HREDRAW | CS_VREDRAW;
    wndclass.lpfnWndProc   = WndProc;
    wndclass.cbClsExtra    = 0;
    wndclass.cbWndExtra    = 0;
    wndclass.hInstance     = hI;
    wndclass.hIcon         = LoadIcon(hI, IDI_ICON);
    wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wndclass.hbrBackground = hBrush;
    wndclass.lpszMenuName  = szAppName;
    wndclass.lpszClassName = szAppName;

    if (!RegisterClass(&wndclass)) {
        MessageBox(NULL, TEXT ("Error!"), szAppName, MB_ICONERROR);
        return 0;
    }

    hwnd = CreateWindow(
        szAppName, TEXT("gotoxy(x, y);"), WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 290, 230,
        NULL, NULL, hI, NULL
    );

    ShowWindow(hwnd, iCS);
    UpdateWindow(hwnd);

    while(GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage (&msg);
    }
    return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lP) {
    switch(msg) {
        case WM_CREATE:
            CreateWindow(
                TEXT("BUTTON"), TEXT("LEFT"), WS_VISIBLE | WS_CHILD,
                20, 80, 80, 20,
                hwnd, (HWND) LEFT, NULL, NULL
            );
            CreateWindow(
                TEXT("BUTTON"), TEXT("RIGHT"), WS_VISIBLE | WS_CHILD,
                160, 80, 80, 20,
                hwnd, (HWND) RIGHT, NULL, NULL
            );
            CreateWindow(
                TEXT("BUTTON"), TEXT("UP"), WS_VISIBLE | WS_CHILD,
                90, 40, 80, 20,
                hwnd, (HWND) UP, NULL, NULL
            );
            CreateWindow(
                TEXT("BUTTON"), TEXT("DOWN"), WS_VISIBLE | WS_CHILD,
                90, 120, 80, 20,
                hwnd, (HWND) DOWN, NULL, NULL
            );
            return 0;
        case WM_COMMAND:
            if(LOWORD(wParam)==LEFT) {
                SetConsoleTitle("LEFT");
                system("color 3e");
                char ch;
                gotoxy(x, y);
                printf("LEFT");
                ch = 75;
                switch(ch) {
                    case 75:
                        x--;
                        Beep(567, 800);
                        if(x==-1) {
                            MessageBox(NULL, "Error!", "Important", MB_OK);
                            exit(0);
                        }
                        break;
                    case 27:
                        exit(0);
                }
                system("cls");
                gotoxy(x, y);
                printf("LEFT");
            }
            if(LOWORD(wParam)==RIGHT) {
                SetConsoleTitle("RIGHT");
                system("color 3e");
                char ch;
                gotoxy(x, y);
                printf("RIGHT");
                ch = 77;
                switch(ch) {
                    case 77:
                        x++;
                        Beep(700, 532);
                        break;
                    case 27:
                        exit(0);
                }
                system("cls");
                gotoxy(x, y);
                printf("RIGHT");
            }
            if(LOWORD(wParam)==UP) {
                SetConsoleTitle("UP");
                system("color 3e");
                char ch;
                gotoxy(x, y);
                printf("UP");
                ch = 72;
                switch(ch) {
                    case 72:
                        y--;
                        Beep(700, 700);
                        if(y==-1) {
                            MessageBox(NULL, "Error!", "Important", MB_OK);
                            exit(0);
                        }
                        break;
                    case 27:
                        exit(0);
                }
                system("cls");
                gotoxy(x, y);
                printf("UP");
            }
            if(LOWORD(wParam)==DOWN) {
                SetConsoleTitle("DOWN");
                system("color 3e");
                char ch;
                gotoxy(x, y);
                printf("DOWN");
                ch = 80;
                switch(ch) {
                    case 80:
                        y++;
                        Beep(600, 532);
                        break;
                    case 27:
                        exit(0);
                }
                system("cls");
                gotoxy(x, y);
                printf("DOWN");
            }
            return 0;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    return DefWindowProc(hwnd, msg, wParam, lP);
}

Neste exemplo foi utilizado a função SetConsoleCursorPosition




/********************Arquivo: resource.h********************/

#define IDI_ICON   1
#define IMAGEM     2

Neste exemplo foi utilizado a função SetConsoleCursorPosition




/********************Arquivo: resource.rc********************/

#include "afxres.h"
#include "resource.h"

IDI_ICON ICON "project1.ico"

IMAGEM BITMAP  DISCARDABLE "image.bmp"

Arquivo com extensão .bat

2021-08-09T22:58:00.002-07:00

@echo off
title "Digite os números 1 ou 2"
color 1f
:Opcoes
echo 1 - Calculadora
echo 2 - Bloco de Notas
choice /c 12 /m "O que deseja executar?"
IF errorlevel==2 goto Bloco
IF errorlevel==1 goto Calculadora
:Calculadora
start calc
goto Opcoes
:bloco
start notepad
goto Opcoes

Média - Linguagem C

2021-07-30T23:24:00.001-07:00


#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
void main(void) {
    setlocale(LC_ALL, "ptb");
    system("title Média");
    int contador,  grau,  total, media;
    total = 0;
    contador = 1;
    while(contador <= 10) {
        printf("Entre com o grau: ");
        scanf("%d",  &grau);
        total = total + grau;
        contador = contador + 1;
    }
    media = total / 10;
    printf("A media é %d/n", media);
    system("pause");
}

system("title atoi, atof e atol");

2021-07-18T21:45:00.002-07:00

#include <stdio.h>
#include <stdlib.h>

void main(void) {
    system("title atoi, atof e atol");
    int int_r;
    float float_r;
    long long_r;
    int_r   = atoi("7578");
    float_r = atof("75.5");
    long_r  = atol("757L");
    printf("%d\n%.2f\n%ld\n",int_r,float_r,long_r);
    system("pause");
}