Como fazer um botão na barra de tarefas exibir uma barra de progresso em C?

Embora as interfaces COM possam se parecer muito com C++, com chamadas como pTaskbar->lpVtbl->Release(pTaskbar), elas não são. São estruturas com ponteiros de função C, e você passa constantemente como argumento o "objeto" principal — diferentemente do que seria feito em C++.

O código a seguir deve mostrar como fazer isso:

#define UNICODE

#include <windows.h>
#include <shobjidl.h>
#include <objbase.h>

#pragma comment(lib, "ole32.lib")
#pragma comment(lib, "shell32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")

#define ID_BUTTON 1001
#define ID_TIMER  1002

// This is the main COM interface for ITaskbarList3.
static ITaskbarList3* pTaskbar = NULL;
static HWND hwndMain = NULL;
static int progress = 0;

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg) {
        case WM_CREATE: {
            CreateWindowW(L"BUTTON", L"Show progress bar", WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON, 10, 10, 265, 40, hwnd, (HMENU)ID_BUTTON, NULL, NULL);
            break;
        }
        case WM_COMMAND:
            if (LOWORD(wParam) == ID_BUTTON) {
                progress = 0;
                // Start the progress bar.
                pTaskbar->lpVtbl->SetProgressState(pTaskbar, hwnd, TBPF_NORMAL);
                SetTimer(hwnd, ID_TIMER, 50, NULL);
            }
            break;
        case WM_TIMER:
            if (wParam == ID_TIMER) {
                progress += 2;
                if (progress <= 100)
                    // Advance the progress bar.
                    pTaskbar->lpVtbl->SetProgressValue(pTaskbar, hwnd, progress, 100);
                else {
                    KillTimer(hwnd, ID_TIMER);
                    // Hide the progress bar.
                    pTaskbar->lpVtbl->SetProgressState(pTaskbar, hwnd, TBPF_NOPROGRESS);
                }
            }
            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)
{
    // Never ever forget this!
    CoInitialize(NULL);
    // Create the COM interface.
    CoCreateInstance(&CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskbarList3, (void**)&pTaskbar);
    WNDCLASSW wc = { 0 };
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = L"TaskbarDemo";
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    RegisterClassW(&wc);
    hwndMain = CreateWindowW(L"TaskbarDemo", L"Taskbar Progress Demo",
        WS_OVERLAPPEDWINDOW ^ WS_THICKFRAME ^ WS_MAXIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, 300, 100,
        NULL, NULL, hInstance, NULL);
    ShowWindow(hwndMain, nCmdShow);
    UpdateWindow(hwndMain);
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    // Destroy the COM interface.
    if (pTaskbar)
        pTaskbar->lpVtbl->Release(pTaskbar);
    // Never ever forget this!
    CoUninitialize();
    return 0;
}

Testado no Windows 10, MSVC 2019, 64 bits, C17. Não deve ser muito diferente com outros compiladores ou padrões C, exceto, é claro, pelas diretivas #pragma comment(lib, ...), que só serão reconhecidas pelo MSVC — vincule essas 4 bibliotecas manualmente, se necessário.

Você pode compilá-lo com a seguinte linha de comando, a partir de um prompt do ambiente VS:

cl /std:c17 main.c /link

Não verifiquei com o MinGW ou outras versões do VS - como eu disse, este é um código C e Windows padrão, e seria compilado até mesmo em Windows muito antigos, se ITaskbarList3estivesse disponível. COM é algo muito antigo na API do Windows.

Você compila, executa e clica no botão para exibir uma barra de progresso simulada. Os pontos-chave são destacados no código com comentários; todo o resto está sem comentários, pois está lá apenas para fornecer um aplicativo Windows mínimo – não há necessidade de entrar em detalhes sobre o gerador de mensagens ou o temporizador. Eu sei, é um pouco confuso, mas o objetivo não era mostrar as "melhores práticas" para construir um aplicativo Windows em C. Ele compila sem avisos, então é o suficiente para um exemplo rápido.

Para obter detalhes sobre cada função, consulte a documentação da Microsoft, especialmente se você não estiver familiarizado com interfaces COM (tenha cuidado para inicializar/desinicializar corretamente a API COM no início/fim do seu programa).

O COM foi projetado para ser independente de linguagem. A introdução ao Modelo de Objeto Componente explica isso:

Para entender COM [...], é crucial entender que não é uma linguagem orientada a objetos, mas um padrão. [...]. [Objetos COM] podem ser escritos em diferentes linguagens e podem ser estruturalmente bem diferentes, e é por isso que COM é chamado de padrão binário ; um padrão que se aplica depois que um programa foi traduzido para código de máquina binário.

O único requisito de linguagem para COM é que o código seja gerado em uma linguagem que possa criar estruturas de ponteiros e, explícita ou implicitamente, chamar funções por meio de ponteiros. Linguagens orientadas a objetos, como C++ e Smalltalk, fornecem mecanismos de programação que simplificam a implementação de objetos COM, mas linguagens como C, Java e VBScript podem ser usadas para criar e utilizar objetos COM.

C é capaz de criar estruturas (ou arrays) de ponteiros de função e chamar funções por meio deles. Isso significa que C pode ser usado para implementar e utilizar interfaces COM. A única razão pela qual você não encontrará muita abordagem para o uso de COM em C é que ele é muito trabalhoso.

No nível binário, um ponteiro de interface COM é um ponteiro para uma estrutura com uma (ou mais) tabelas de ponteiros de função. O compilador MIDL padrão gera arquivos de cabeçalho que chamam o ponteiro da tabela de funções lpVtbl. Em C++, isso é tratado de forma transparente pelo compilador, com os métodos sendo exibidos como se fossem funções-membro da classe. Em C, por outro lado, você precisa digitar manualmente as indireções de ponteiro e passar o thisponteiro (implícito em C++).

Supondo que pTaskbarList3seja um ponteiro para uma ITaskbarList3interface, os seguintes trechos mostram como chamar o ITaskbarList::HrInitmétodo.

C:

hr = pTaskbarList3->lpVtbl->HrInit(pTaskbarList3);
// or, if COBJMACROS is defined
hr = ITaskbarList3_HrInit(pTaskbarList3);

C++:

hr = pTaskbarList3->HrInit();

O código gerado é idêntico em ambos os casos. O compilador C++ apenas nos permite ser muito menos prolixos.

Os arquivos de cabeçalho fornecidos com o SDK do Windows geralmente fornecem uma interface C++ e uma interface C, que estão disponíveis condicionalmente com base na __cplusplusdefinição de "se" ou não. Ao usar um compilador C, você pode, opcionalmente, habilitar macros de conveniência por meio do COBJMACROSsímbolo do pré-processador. Essas macros nos permitem nomear o ponteiro da interface apenas uma vez:

hr = pInterface->lpVtbl->Method(pInterface, ...);
// vs.
hr = IInterface_Method(pInterface, ...);

Com os conceitos básicos abordados, veja como você criaria e usaria a ITaskbarList3interface em C.

static ITaskbarList3* pTaskbarList3 = NULL;

// ...

// Create a TaskbarList object and request its ITaskbarList3 interface
HRESULT hr = CoCreateInstance(&CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER,
                              &IID_ITaskbarList3, &pTaskbarList3);

// Initialize the TaskbarList object
if (SUCCEEDED(hr))
{
    hr = ITaskbarList3_HrInit(pTaskbarList3);
}

// Set the progress state to indeterminate
if (SUCCEEDED(hr))
{
    hr = ITaskbarList3_SetProgressState(pTaskbarList3, hwnd, TBPF_INDETERMINATE);
}

Abaixo está um programa de exemplo completo que demonstra como usar a ITaskbarList3interface de C:

#define UNICODE
#define COBJMACROS

#include <Shobjidl.h>
#include <objbase.h>
#include <winerror.h>

#include <Windows.h>


static UINT REGM_TASKBAR_BUTTON_CREATED = 0;
static ITaskbarList3* pTaskbarList3 = NULL;

static LRESULT WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);


int main()
{
    // Initialize COM library for the current thread
    HRESULT hr = CoInitialize(NULL);
    if (FAILED(hr))
        return hr;

    // Register the taskbar button created message; this needs to be done before the
    // application window is created
    REGM_TASKBAR_BUTTON_CREATED = RegisterWindowMessageW(L"TaskbarButtonCreated");
    if (REGM_TASKBAR_BUTTON_CREATED == 0)
        return HRESULT_FROM_WIN32(GetLastError());

    // Register window class
    WNDCLASSW wc = { .style = CS_HREDRAW | CS_VREDRAW,
                     .lpfnWndProc = WndProc,
                     .hInstance = GetModuleHandleW(NULL),
                     .hCursor = LoadCursorW(NULL, IDC_ARROW),
                     .hbrBackground = (HBRUSH)(COLOR_WINDOW + 1),
                     .lpszClassName = L"MainWndCls" };
    ATOM cls_atom = RegisterClassW(&wc);
    if (cls_atom == 0)
        return HRESULT_FROM_WIN32(GetLastError());

    // Create window
    HWND hwnd
        = CreateWindowW(wc.lpszClassName, L"Taskbar Button Progressbar Example", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, wc.hInstance, NULL);
    if (hwnd == NULL)
        return HRESULT_FROM_WIN32(GetLastError());

    // Run a message loop
    MSG msg = { 0 };
    while (GetMessageW(&msg, NULL, 0, 0))
    {
        DispatchMessageW(&msg);
    }
}

static LRESULT WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    if (msg == REGM_TASKBAR_BUTTON_CREATED)
    {
        if (pTaskbarList3 == NULL)
        {
            // Create a TaskbarList object and request its ITaskbarList3 interface
            HRESULT hr
                = CoCreateInstance(&CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, &IID_ITaskbarList3, &pTaskbarList3);

            // Initialize the TaskbarList object
            if (SUCCEEDED(hr))
            {
                hr = ITaskbarList3_HrInit(pTaskbarList3);
            }

            // Set the progress state to indeterminate
            if (SUCCEEDED(hr))
            {
                hr = ITaskbarList3_SetProgressState(pTaskbarList3, hwnd, TBPF_INDETERMINATE);
            }
        }
    }

    switch (msg)
    {
    case WM_DESTROY:
        // Clean up
        if (pTaskbarList3)
        {
            ITaskbarList3_Release(pTaskbarList3);
            pTaskbarList3 = NULL;
        }
        // Request breaking out of the message loop
        PostQuitMessage(0);
        return 0;

    default:
        break;
    }

    return DefWindowProcW(hwnd, msg, wparam, lparam);
}

Você pode compilá-lo a partir de um prompt de comando do Visual Studio usando a seguinte linha de comando:

cl main.c /std:c17 /W4 /O2 /link Ole32.lib User32.lib /SUBSYSTEM:CONSOLE

Alguns pontos que vale a pena destacar:

• O programa registra a L"TaskbarButtonCreated"mensagem para ser notificado quando o botão da barra de tarefas estiver pronto para ser usado.
• O programa evita , decididamente, a desinicialização explícita da biblioteca COM (via CoUninitialize). Temos décadas de evidências de que permitir que a biblioteca COM seja limpa como parte do encerramento de threads é a opção mais segura. Ignore a documentação neste caso.