C++ Como fazer um programa que inverte as cores em c++

22 de janeiro de 2022

Olá, Eu preciso que vocês me digam como eu vou fazer um programa que inverte as cores da tela do computador em c++ igual como o virus MEMZ

faz.

Eu pesquisei como que eu fazia no google, mas eu não achei o que eu queria, até encontrei um tópico aqui no Clube do Hardware,

mas ele era de inverter as cores de uma imagem, que não era o que eu queria.

O Payload da inversão das cores do MEMZ:

//O Que eu coloco a mais aqui?
#include <stdio.h>
  
int main(){
	//Agora o que eu coloco aqui para inverter as cores?
}

Lucca Rodrigues · 23 de janeiro de 2022

@Arthur160

Eu posso te dar uma ideia de como fazer usando a API do Windows.

Pelo o que vi a ordem é:

GetDC() recupera um identificador para um device context (DC). Se o argumento for NULL, a função recupera o DC para a tela inteira;
CreateCompatibleDC() cria um DC compatível com o DC da tela;
CreateCompatibleBitmap() cria um bitmap compatível com o DC da tela;
SelectObject() seleciona o bitmap compatível no DC compatível;
BitBlt() transfere um retângulo de pixels do DC da tela para o DC compatível. Se o último argumento for NOTSRCCOPY, a função copia o retângulo com as cores invertidas;
SelectObject() tira de seleção o bitmap compatível do DC compatível;
DeleteDC() deleta o DC compatível, considerando que foi usada a função CreateCompatibleDC() para criá-lo;
ReleaseDC() libera o DC da tela, considerando que foi usada a função GetDC() para recuperá-lo;
DeleteObject() deleta o bitmap caso não nos sirva mais.

Um exemplo:

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

void CapturaCorInvertida(void)
{
    int x1 = GetSystemMetrics(SM_XVIRTUALSCREEN);
    int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
    int x2 = GetSystemMetrics(SM_CXVIRTUALSCREEN);
    int y2 = GetSystemMetrics(SM_CYVIRTUALSCREEN);
    int w = x2 - x1;
    int h = y2 - y1;

    HDC telaDC = GetDC(NULL);
    HDC compDC = CreateCompatibleDC(telaDC);
    HBITMAP btm = CreateCompatibleBitmap(telaDC, w, h);
    HGDIOBJ obj = SelectObject(compDC, btm);
    BOOL ret = BitBlt(compDC, 0, 0, w, h, telaDC, x1, y1, NOTSRCCOPY);

    // Salvando para a area de transferencia
    OpenClipboard(NULL);
    EmptyClipboard();
    SetClipboardData(CF_BITMAP, btm);
    CloseClipboard();

    // Deletando e liberando
    SelectObject(compDC, obj);
    DeleteDC(compDC);
    ReleaseDC(NULL, telaDC);
    DeleteObject(btm);
}

int main()
{
    Sleep(500);
    CapturaCorInvertida();
    return 0;
}

Tente rodar isso e dar ctrl + v no Paint por exemplo (talvez tenha que incluir -lgdi32 no linker options dependendo do IDE)

Em aplicativo gráfico do Windows, você pode chamar CreateWindow() e usar o estilo SS_BITMAP para que o bitmap seja exibido no controle estático.

Daí vai da sua imaginação... Dá uma olhada aqui pra começar.

edit:
Só agora vi que é C++. Aliás...

4 horas atrás, Arthur160 disse:

//O Que eu coloco a mais aqui?
#include <stdio.h>
  
int main(){
	//Agora o que eu coloco aqui para inverter as cores?
}

Isso não é C++

Talvez tudo o que eu escrevi nessa postagem seja novo pra você, dê uma pesquisada, eu anexei links para as documentações, é só clicar no nome das funções...

arfneto · 23 de janeiro de 2022

19 horas atrás, Arthur160 disse:

Olá, Eu preciso que vocês me digam como eu vou fazer um programa que inverte as cores da tela do computador em c++ igual como o virus MEMZ

faz.

Na imagem que mostrou fica claro que as cores sequer são invertidas. Talvez pudesse explicar melhor o que quer fazer.

Se pretende mudar o desktop todo e não a tela do seu programa tem muitas coisas mais para resolver, como privilégios de acesso.

Lucca Rodrigues · 23 de janeiro de 2022

34 minutos atrás, arfneto disse:

Na imagem que mostrou fica claro que as cores sequer são invertidas. Talvez pudesse explicar melhor o que quer fazer.

Na realidade MEMZ inverte a cor da tela em certo ponto, e isso fica em loop. Dá uma olhada nesse vídeo (minuto 2:40):

Bem, sobre o que eu havia postado:

16 horas atrás, Lucca Rodrigues disse:

Em aplicativo gráfico do Windows, você pode chamar CreateWindow() e usar o estilo SS_BITMAP para que o bitmap seja exibido no controle estático.

Eu fiz aqui pra testar.

@Arthur160 Basta fazer com que CapturaCorInvertida() retorne HBITMAP, e daí pode chamar CreateWindowW() e SendMessage(). Também chamei ShowWindow() pra maximizar a tela:

arfneto · 23 de janeiro de 2022

3 horas atrás, Lucca Rodrigues disse:

Na realidade MEMZ inverte a cor da tela em certo ponto, e isso fica em loop

Entendo, @Lucca Rodrigues, e agradeço a atenção em ilustrar melhor a parada. O que eu quiz dizer é que a realidade não tem a ver com o título nem com o efeito na (única) figura. E acho que o autor pode muitas vezes fazer algo mais para ilustrar a questão. Claro que eu poderia ter ido atrás disso, mas optei por não fazer, em uma questão que nada tem de código e tem um título distante do sentido.

25 de janeiro de 2022

No meu compilador (MinGW) esse código não funciona o que faço?

arfneto · 25 de janeiro de 2022

2 minutos atrás, Arthur160 disse:

No meu compilador (MinGW) esse código não funciona o que faço?

Que código? Qual versão de compilador? Quais as opções de compilação?

25 de janeiro de 2022

1 minuto atrás, arfneto disse:

Que código? Qual versão de compilador? Quais as opções de compilação?

o código que ele mandou de exemplo, 8.1.0, não sei

Lucca Rodrigues · 25 de janeiro de 2022

@Arthur160

Em 22/01/2022 às 23:09, Lucca Rodrigues disse:

talvez tenha que incluir -lgdi32 no linker options

25 de janeiro de 2022

mds eu consegui fazer isso mas lucca, também você pode colocar o código que você usou para eu usar no meu windows 7?

Lucca Rodrigues · 25 de janeiro de 2022

@Arthur160 O que eu postei era só um exemplo de como capturar a tela com as cores invertidas.

Como eu havia dito:

Em 22/01/2022 às 23:09, Lucca Rodrigues disse:

Em aplicativo gráfico do Windows, você pode chamar CreateWindow() e usar o estilo SS_BITMAP para que o bitmap seja exibido no controle estático.

Daí vai da sua imaginação... Dá uma olhada aqui pra começar.

Quem vem ao fórum tem que estar disposto a se esforçar um pouco também, não é nada muito complicado, dá uma lida na documentação

25 de janeiro de 2022

@Lucca Rodrigues

Eu não consigo ultilizar a função CreateWIndowW porque dá esse erro:

In file included from C:/MinGW/x86_64-w64-mingw32/include/windows.h:72,
from vtmuv.cpp:1:
vtmuv.cpp: In function 'int WinMain(HINSTANCE, HINSTANCE, LPSTR, int)':
vtmuv.cpp:85:10: error: expression list treated as compound expression in initia
lizer [-fpermissive]
HWND CreateWindowW(
^~~~~~~~~~~~~
vtmuv.cpp:85:10: error: invalid conversion from 'int' to 'HWND' {aka 'HWND__*'}
[-fpermissive]

Lucca Rodrigues · 25 de janeiro de 2022

@Arthur160 E o código?

25 de janeiro de 2022

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

const char g_szClassName[] = "ClassedaJanela";

void CapturaCorInvertida(void)
{
    int x1 = GetSystemMetrics(SM_XVIRTUALSCREEN);
    int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
    int x2 = GetSystemMetrics(SM_CXVIRTUALSCREEN);
    int y2 = GetSystemMetrics(SM_CYVIRTUALSCREEN);
    int w = x2 - x1;
    int h = y2 - y1;

    HDC telaDC = GetDC(NULL);
    HDC compDC = CreateCompatibleDC(telaDC);
    HBITMAP btm = CreateCompatibleBitmap(telaDC, w, h);
    HGDIOBJ obj = SelectObject(compDC, btm);
    BOOL ret = BitBlt(compDC, 0, 0, w, h, telaDC, x1, y1, NOTSRCCOPY);

    // Salvando para a area de transferencia
    OpenClipboard(NULL);
    EmptyClipboard();
    SetClipboardData(CF_BITMAP, btm);
    CloseClipboard();

    // Deletando e liberando
    SelectObject(compDC, obj);
    DeleteDC(compDC);
    ReleaseDC(NULL, telaDC);
    DeleteObject(btm);
}

int main()
{
    Sleep(500);
    CapturaCorInvertida();
    return 0;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
        case WM_CLOSE:
            DestroyWindow(hwnd);
        break;
        case WM_DESTROY:
            PostQuitMessage(0);
        break;
        default:
            return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wc;
    HWND hwnd;
    MSG Msg;

    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = 0;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = "BasicWindow";
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    HWND CreateWindowW(
  		"BasicWindow",
  		L"MEMZ",
  		WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_BORDER,
  		0,
  		0,
  		1366,
  		768,
  		0,
		0,
  		hInstance,
  		0);

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

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

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return Msg.wParam;
}

Lucca Rodrigues · 25 de janeiro de 2022

@Arthur160 CreateWindowW() retorna um identificador para a janela criada (HWND).

28 minutos atrás, Arthur160 disse:

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

Acredito que esse `hwnd` receberia o retorno da função:

hwnd = CreateWindowW(...);

Assim é verificado se deu problema na criação da janela depois que a função foi chamada.

Aliás, WinMain() é a função principal de qualquer aplicativo do Windows, esqueça main().

E como eu havia dito:

Em 23/01/2022 às 15:28, Lucca Rodrigues disse:

Basta fazer com que CapturaCorInvertida() retorne HBITMAP

Você não quer mais salvar o bitmap para a área de transferência, e nem deletar o bitmap como é feito com DeleteObject().

Você precisa que a função retorne HBITMAP pra que você possa chamar CreateWindowW() e SendMessage() na WndProc(). Você pode fazer isso através da mensagem WM_CREATE.

28 minutos atrás, Arthur160 disse:

    HWND CreateWindowW(
  		"BasicWindow",
  		L"MEMZ",

Coloque um L antes de "BasicWindow" para que seja uma string de wchar_t.

arfneto · 25 de janeiro de 2022

Isso está errado.

WinMain é a entrada para uma aplicação Windows.

main é a entrada para uma aplicação de console.

Não pode ter os dois.

26 de janeiro de 2022

________________________________________________________________________

Agora deu mais um erro:

In file included from C:/MinGW/x86_64-w64-mingw32/include/windows.h:72,
from vtmuv.cpp:1:
vtmuv.cpp: In function 'int WinMain(HINSTANCE, HINSTANCE, LPSTR, int)':
vtmuv.cpp:69:10: error: expression list treated as compound expression in initia
lizer [-fpermissive]
HWND CreateWindowW(
^~~~~~~~~~~~~
vtmuv.cpp:69:10: error: invalid conversion from 'int' to 'HWND' {aka 'HWND__*'}
[-fpermissive]
vtmuv.cpp:82:5: error: 'bk' was not declared in this scope
bk = CreateWindowW(
^~
In file included from C:/MinGW/x86_64-w64-mingw32/include/windows.h:72,
from vtmuv.cpp:1:
vtmuv.cpp:82:10: error: 'CreateWindowExW' cannot be used as a function
bk = CreateWindowW(
^~~~~~~~~~~~~

arfneto · 26 de janeiro de 2022

@Arthur160 entendeu que estava errado como escreveu? Talvez deva pesquisar um pouco sobre a diferença entre uma aplicação desktop e uma aplicação para console

3 horas atrás, Arthur160 disse:

Agora deu mais um erro:

Poste o código.

Deve imaginar que não deve ter nada errado em windows.h já que é usado toda hora há décadas, certo?

26 de janeiro de 2022

#include <windows.h>
#include <winuser.h>
#include <stdio.h>
#define WM_CREATE                       0x0001

const char g_szClassName[] = "ClassedaJanela";

void CapturaCorInvertida(void)
{
    int x1 = GetSystemMetrics(SM_XVIRTUALSCREEN);
    int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
    int x2 = GetSystemMetrics(SM_CXVIRTUALSCREEN);
    int y2 = GetSystemMetrics(SM_CYVIRTUALSCREEN);
    int w = x2 - x1;
    int h = y2 - y1;

    HDC telaDC = GetDC(NULL);
    HDC compDC = CreateCompatibleDC(telaDC);
    HBITMAP btm = CreateCompatibleBitmap(telaDC, w, h);
    HGDIOBJ obj = SelectObject(compDC, btm);
    BOOL ret = BitBlt(compDC, 0, 0, w, h, telaDC, x1, y1, NOTSRCCOPY);
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
        case WM_CLOSE:
            DestroyWindow(hwnd);
        break;
        case WM_DESTROY:
            PostQuitMessage(0);
        break;
        default:
            return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
	Sleep(500);
    CapturaCorInvertida();
    WNDCLASSEX wc;
    HWND hwnd;
    MSG Msg;

    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = 0;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = "BasicWindow";
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    HWND CreateWindowW(
  		L"BasicWindow",
  		L"MEMZ",
  		WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_BORDER,
  		0,
  		0,
  		1366,
  		768,
  		0,
		0,
  		hInstance,
  		0);

    bk = CreateWindowW(
  		L"BasicWindow",
  		L"MEMZ",
  		WS_CHILD | WS_VISIBLE | SS_BITMAP,
  		0,
  		0,
  		1366,
  		768,
  		0,
		0,
  		hwnd,
  		0);

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

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    BOOL ShowWindow(
		  HWND hWnd,
		  int  nCmdShow
	);

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return Msg.wParam;
}

Lucca Rodrigues · 26 de janeiro de 2022

@Arthur160 Bom colega, nada te impede de pesquisar um exemplo de como criar uma janela com uma imagem, e de preferência em inglês pra ter mais resultados .

O exemplo nesse link expressa bem o que quis dizer na postagem anterior.

O autor criou uma tal LoadMyImage() só pra chamar LoadImageW(), pra mim não fez muito sentido isso, e de qualquer forma você não precisa dessa função, CapturaCorInvertida() deve te retornar o bitmap.

Aliás...

56 minutos atrás, Arthur160 disse:
void CapturaCorInvertida(void)

Nada de void, retorne o bitmap criado pela função...

2 de fevereiro de 2022

Lucca, E Agora o que eu coloco no caminho da imagem?

#include <windows.h>
#include <winuser.h>
#include <stdio.h>
#define WM_CREATE                       0x0001

const char g_szClassName[] = "ClassedaJanela";

int CapturaCorInvertida()
{
    int x1 = GetSystemMetrics(SM_XVIRTUALSCREEN);
    int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
    int x2 = GetSystemMetrics(SM_CXVIRTUALSCREEN);
    int y2 = GetSystemMetrics(SM_CYVIRTUALSCREEN);
    int w = x2 - x1;
    int h = y2 - y1;

    HDC telaDC = GetDC(NULL);
    HDC compDC = CreateCompatibleDC(telaDC);
    HBITMAP btm = CreateCompatibleBitmap(telaDC, w, h);
    HGDIOBJ obj = SelectObject(compDC, btm);
    BOOL ret = BitBlt(compDC, 0, 0, w, h, telaDC, x1, y1, NOTSRCCOPY);
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    
    HWND hsti;

    switch(msg) {

        case WM_CREATE:
    
            LoadMyImage();
            hsti = CreateWindowW(L"Static", L"", 
                WS_CHILD | WS_VISIBLE | SS_BITMAP,
                0, 0, WindowX(), WindowY(), hwnd, (HMENU) 1, NULL, NULL);

            SendMessage(hsti, STM_SETIMAGE,
                (WPARAM) IMAGE_BITMAP, (LPARAM) hBitmap); 
            break;

        case WM_DESTROY:

            DeleteObject(hBitmap);
            PostQuitMessage(0);
            break;
    }

    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

void LoadMyImage(void) {

    hBitmap = LoadImageW(NULL, L"", IMAGE_BITMAP,
        0, 0, LR_LOADFROMFILE);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
	Sleep(500);
    CapturaCorInvertida();
    WNDCLASSEX wc;
    HWND hwnd;
    MSG Msg;

    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = 0;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = "BasicWindow";
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    HWND CreateWindowW(
  		L"BasicWindow",
  		L"MEMZ",
  		WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_BORDER,
  		0,
  		0,
  		1366,
  		768,
  		0,
		0,
  		hInstance,
  		0);

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

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    BOOL ShowWindow(
		  HWND hWnd,
		  int  nCmdShow
	);

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return Msg.wParam;
}

Lucca Rodrigues · 2 de fevereiro de 2022

@Arthur160

Em 26/01/2022 às 20:19, Lucca Rodrigues disse:
CapturaCorInvertida() deve te retornar o bitmap.

Aliás...
Em 26/01/2022 às 19:20, Arthur160 disse:
void CapturaCorInvertida(void)
Nada de void, retorne o bitmap criado pela função...

Nada de void, nada de int

O bitmap é criado com CreateCompatibleBitmap(), o retorno é atribuído `btm` que é HBITMAP. Você precisa retornar o bitmap.

Pode criar um HBITMAP global e chamar CapturaCorInvertida() no início da WinMain() mesmo, atribuindo o retorno da função à variável global.

Esqueça LoadMyImage()...

Em 26/01/2022 às 20:19, Lucca Rodrigues disse:

O autor criou uma tal LoadMyImage() só pra chamar LoadImageW(), pra mim não fez muito sentido isso, e de qualquer forma você não precisa dessa função

Aliás, depois de CreateWindowW() e SendMessage() que chamou pra criar a janela com o bitmap na WndProc(), pode chamar SetWindowLong() com os argumentos GWL_STYLE (pra definir um novo estilo de janela) e WS_POPUP.

Chame também ShowWindow() se pretende maximizar a janela.

26 de fevereiro de 2022

Deu mais um erro:

warning: built-in function 'y1' declared as non-function [-Wbuiltin-declaration-mismatch]
int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
^~
In file included from C:/MinGW/x86_64-w64-mingw32/include/windows.h:72,
from InvertColors.cpp:1:
InvertColors.cpp: In function 'LRESULT WndProc(HWND, UINT, WPARAM, LPARAM)':
InvertColors.cpp:26:45: error: cannot convert 'HBITMAP' {aka 'HBITMAP__*'} to 'LPCWSTR' {aka 'const wchar_t*'}
hsti = CreateWindowW(L"Static", btm,
^~~
C:/MinGW/x86_64-w64-mingw32/include/winuser.h:2138:86: note: initializing argument 3 of 'HWND__* CreateWindowExW(DWORD, LPCWSTR, LPCWSTR, DWORD, int, int, int, int, HWND, HMENU, HINSTANCE, LPVOID)'
WINUSERAPI HWND WINAPI CreateWindowExW(DWORD dwExStyle,LPCWSTR lpClassName,LPCWSTR lpWindowName,DWORD dwStyle,int X,int Y,int nWidth,int nHeight,HWND hWndParent,HMENU hMenu,HINSTANCE hInstance,LPVOID lpParam);
~~~~~~~~^~~~~~~~~~~~
InvertColors.cpp:31:49: error: 'hBitmap' was not declared in this scope
(WPARAM) IMAGE_BITMAP, (LPARAM) hBitmap);
^~~~~~~
In file included from C:/MinGW/x86_64-w64-mingw32/include/windows.h:72,
from InvertColors.cpp:1:
InvertColors.cpp: In function 'int WinMain(HINSTANCE, HINSTANCE, LPSTR, int)':
InvertColors.cpp:72:10: error: expression list treated as compound expression in initializer [-fpermissive]
HWND CreateWindowW(
^~~~~~~~~~~~~
InvertColors.cpp:72:10: error: invalid conversion from 'int' to 'HWND' {aka 'HWND__*'} [-fpermissive]

E o Código:

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

const char g_szClassName[] = "ClassedaJanela";

int x1 = GetSystemMetrics(SM_XVIRTUALSCREEN);
int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
int x2 = GetSystemMetrics(SM_CXVIRTUALSCREEN);
int y2 = GetSystemMetrics(SM_CYVIRTUALSCREEN);
int w = x2 - x1;
int h = y2 - y1;
HDC telaDC = GetDC(NULL);
HDC compDC = CreateCompatibleDC(telaDC);
HBITMAP btm = CreateCompatibleBitmap(telaDC, w, h);
HGDIOBJ obj = SelectObject(compDC, btm);
BOOL ret = BitBlt(compDC, 0, 0, w, h, telaDC, x1, y1, NOTSRCCOPY);

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    HWND hsti;

    switch(msg) {

        case WM_CREATE:
    
            hsti = CreateWindowW(L"Static", btm, 
                WS_CHILD | WS_VISIBLE | SS_BITMAP,
                0, 0, 1366, 768, hwnd, (HMENU) 1, NULL, NULL);

            SendMessage(hsti, STM_SETIMAGE,
                (WPARAM) IMAGE_BITMAP, (LPARAM) hBitmap); 
            break;

        case WM_DESTROY:

            DeleteObject(hBitmap);
            PostQuitMessage(0);
            break;
    }

    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
	Sleep(500);
    WNDCLASSEX wc;
    HWND hwnd;
    MSG Msg;

    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = 0;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = "BasicWindow";
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    HWND CreateWindowW(
  		L"BasicWindow",
  		L"MEMZ",
  		WS_POPUP | WS_VISIBLE | WS_BORDER,
  		0,
  		0,
  		1366,
  		768,
  		0,
		0,
  		hInstance,
  		0);

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

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    BOOL ShowWindow(
		  HWND hWnd,
		  int  nCmdShow
	);

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return Msg.wParam;
}

Lucca Rodrigues · 26 de fevereiro de 2022

@Arthur160

31 minutos atrás, Arthur160 disse:

            hsti = CreateWindowW(L"Static", btm, 
                WS_CHILD | WS_VISIBLE | SS_BITMAP,
                0, 0, 1366, 768, hwnd, (HMENU) 1, NULL, NULL);

O segundo parâmetro de CreateWindowW() é o nome da janela, você não vai passar `btm` pra essa função.

29 minutos atrás, Arthur160 disse:

            SendMessage(hsti, STM_SETIMAGE,
                (WPARAM) IMAGE_BITMAP, (LPARAM) hBitmap);

Em nenhum lugar você declarou hBitmap, isso é algo que você esqueceu de alterar.

E parece que apagou a CapturaCorInvertida() e deixou tudo global sem necessidade.

Em 02/02/2022 às 18:55, Lucca Rodrigues disse:

O bitmap é criado com CreateCompatibleBitmap(), o retorno é atribuído `btm` que é HBITMAP. Você precisa retornar o bitmap.

Entendeu o que "retornar o bitmap" significa?

#include <stdio.h>

int main()
{
    printf("Hello World");

    return 0;
}

Nesse código, que valor main() retorna? 0. De que tipo? int.

main() retorna um inteiro: int main().

Agora faça CapturaCorInvertida() retornar HBITMAP, mais especificamente `btm`.

Pode chamar a função como último argumento de SendMessage() no lugar de hBitmap.

2 de março de 2022

Deu mais um erro:

InvertColors.cpp:8:5: warning: built-in function 'y1' declared as non-function [-Wbuiltin-declaration-mismatch]
int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
^~
InvertColors.cpp: In function 'int CapturaTelaInvertida()':
InvertColors.cpp:20:12: error: invalid conversion from 'HBITMAP' {aka 'HBITMAP__*'} to 'int' [-fpermissive]
return btm;
^~~
InvertColors.cpp: In function 'LRESULT WndProc(HWND, UINT, WPARAM, LPARAM)':
InvertColors.cpp:40:46: error: invalid conversion from 'int' to 'HGDIOBJ' {aka 'void*'} [-fpermissive]
DeleteObject(CapturaTelaInvertida());
~~~~~~~~~~~~~~~~~~~~^~
In file included from C:/MinGW/x86_64-w64-mingw32/include/windows.h:71,
from InvertColors.cpp:1:
C:/MinGW/x86_64-w64-mingw32/include/wingdi.h:2722:49: note: initializing argument 1 of 'WINBOOL DeleteObject(HGDIOBJ)'

WINGDIAPI WINBOOL WINAPI DeleteObject(HGDIOBJ ho);
~~~~~~~~^~
In file included from C:/MinGW/x86_64-w64-mingw32/include/windows.h:72,
from InvertColors.cpp:1:
InvertColors.cpp: In function 'int WinMain(HINSTANCE, HINSTANCE, LPSTR, int)':
InvertColors.cpp:76:10: error: expression list treated as compound expression in initializer [-fpermissive]
HWND CreateWindowW(
^~~~~~~~~~~~~
InvertColors.cpp:76:10: error: invalid conversion from 'int' to 'HWND' {aka 'HWND__*'} [-fpermissive]

E o código:

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

const char g_szClassName[] = "ClassedaJanela";

int x1 = GetSystemMetrics(SM_XVIRTUALSCREEN);
int y1 = GetSystemMetrics(SM_YVIRTUALSCREEN);
int x2 = GetSystemMetrics(SM_CXVIRTUALSCREEN);
int y2 = GetSystemMetrics(SM_CYVIRTUALSCREEN);
int w = x2 - x1;
int h = y2 - y1;

int CapturaTelaInvertida(){
    HDC telaDC = GetDC(NULL);
    HDC compDC = CreateCompatibleDC(telaDC);
    HBITMAP btm = CreateCompatibleBitmap(telaDC, w, h);
    HGDIOBJ obj = SelectObject(compDC, btm);
    BOOL ret = BitBlt(compDC, 0, 0, w, h, telaDC, x1, y1, NOTSRCCOPY);
    return btm;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    HWND hsti;

    switch(msg) {

        case WM_CREATE:
    
            hsti = CreateWindowW(L"Static", L"", 
                WS_CHILD | WS_VISIBLE | SS_BITMAP,
                0, 0, 1366, 768, hwnd, (HMENU) 1, NULL, NULL);

            SendMessage(hsti, STM_SETIMAGE,
                (WPARAM) IMAGE_BITMAP, (LPARAM) CapturaTelaInvertida()); 
            break;

        case WM_DESTROY:

            DeleteObject(CapturaTelaInvertida());
            PostQuitMessage(0);
            break;
    }

    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    LPSTR lpCmdLine, int nCmdShow)
{
	Sleep(500);
    WNDCLASSEX wc;
    HWND hwnd;
    MSG Msg;

    wc.cbSize        = sizeof(WNDCLASSEX);
    wc.style         = 0;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground = CreateSolidBrush(RGB(0,0,0));
    wc.lpszMenuName  = NULL;
    wc.lpszClassName = "BasicWindow";
    wc.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);

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

    HWND CreateWindowW(
  		L"BasicWindow",
  		L"MEMZ",
  		WS_POPUP | WS_VISIBLE | WS_BORDER,
  		0,
  		0,
  		1366,
  		768,
  		0,
		0,
  		hInstance,
  		0);

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

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);
    BOOL ShowWindow(
		  HWND hWnd,
		  int  nCmdShow
	);

    // Step 3: The Message Loop
    while(GetMessage(&Msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&Msg);
        DispatchMessage(&Msg);
    }
    return Msg.wParam;
}