Стратегия создания многоуровневого окна с дочерними окнами (элементами управления)

Думаю, я выберу такое решение:

Окно верхнего уровня

Окно верхнего уровня поддерживает два растровых изображения. Одно - это отображаемое окно, а второе - без отображаемых дочерних элементов управления. Последнему потребуется перерисовка только при изменении размера окна. В окне будет обработчик сообщений, который отображает дочерний элемент управления на отображаемом растровом изображении. Обработчик сообщений будет ожидать указатель либо на DIB, содержащий дочерний элемент управления, либо на фактические биты (не уверен, что лучше на данный момент), как WPARAM, и указатель на структуру, содержащую прямоугольник, которым должен быть дочерний элемент. втянут как LPARAM. Вызов BitBlt () будет сделан, чтобы очистить нижележащую поверхность (это то место, где появляется другое растровое изображение) до вызова AlphaBlend () для рендеринга растрового изображения дочернего элемента управления на отображаемую поверхность растрового изображения.

Родительское окно будет вызывать EnumChildWindows всякий раз, когда его размер изменяется или по какой-то причине необходимо перерисовать его дочерние элементы. Конечно, здесь может быть какой-то режим недействительности, чтобы уменьшить ненужную визуализацию дочерних элементов управления. Не уверен, что увеличение скорости того стоит.

Дочерние окна

После создания экземпляра дочернего элемента управления создается внутреннее растровое изображение, совместимое с растровым изображением окна верхнего уровня. Дочерний элемент отображает себя в этом внутреннем растровом изображении, и всякий раз, когда ему необходимо перерисовать, он уведомляет свое родительское окно с помощью функции SendMessage (), передавая указатель на свое растровое изображение как WPARAM и RECT как LPARAM, определяя его положение и размеры. Если родительский объект нуждается в перерисовке, он отправляет сообщение всем своим дочерним окнам с запросом их растрового изображения. Затем дочерние элементы ответят тем же сообщением, которое они обычно отправляют, когда решают, что им нужно перерисовать себя.

Эйрик

Я пытался сделать то же самое. Из чтения этой и другой поисковой сети. Он объединяет рекомендуемый механизм для рисования CWnd (или HWND), а его дочерние элементы на ваш собственный CDC (или HDC) должны использовать API печати.

CWnd имеет методы Print и PrintClient, которые правильно отправляют WM_PRINT. Также существуют методы Win32: PrintWindow.

Сначала у меня были проблемы с тем, чтобы это работало, но в конце концов я получил правильный метод и параметры. Код, который у меня сработал, был:

void Vg2pImageHeaderRibbon::Update() {
    // Get dimensions
    CRect window_rect;
    GetWindowRect(&window_rect);

    // Make mem DC + mem  bitmap
    CDC* screen_dc = GetDC(); // Get DC for the hwnd
    CDC dc;
    dc.CreateCompatibleDC(screen_dc);
    CBitmap dc_buffer;
    dc_buffer.CreateCompatibleBitmap(screen_dc, window_rect.Width(), window_rect.Height());
    auto hBmpOld = dc.SelectObject(dc_buffer);

    // Create a buffer for manipulating the raw bitmap pixels (per-pixel alpha).
    // Used by ClearBackgroundAndPrepForPerPixelTransparency and CorrectPerPixelAlpha.
    BITMAP raw_bitmap;
    dc_buffer.GetBitmap(&raw_bitmap);
    int bytes =  raw_bitmap.bmWidthBytes * raw_bitmap.bmHeight;
    std::unique_ptr<char> bits(new char[bytes]);

    // Clears the background black (I want semi-transparent black background).
    ClearBackgroundAndPrepForPerPixelTransparency(dc, raw_bitmap, bytes, bits.get(), dc_buffer);

    // To get the window and it's children to draw using print command
    Print(&dc, PRF_CLIENT | PRF_CHILDREN | PRF_OWNED);

    CorrectPerPixelAlpha(dc, raw_bitmap, bytes, bits.get(), dc_buffer);

    // Call UpdateLayeredWindow
    BLENDFUNCTION blend = {0};
    blend.BlendOp = AC_SRC_OVER;
    blend.SourceConstantAlpha = 255;
    blend.AlphaFormat = AC_SRC_ALPHA;
    CPoint ptSrc;
    UpdateLayeredWindow(
        screen_dc, 
        &window_rect.TopLeft(), 
        &window_rect.Size(), 
        &dc, 
        &ptSrc, 
        0, 
        &blend, 
        ULW_ALPHA
    );

    SelectObject(dc, hBmpOld);
    DeleteObject(dc_buffer);
    ReleaseDC(screen_dc);
}

Это сработало для меня, как есть. Но если ваше окно или дети не поддерживают WM_PRINT. Я посмотрел, как это было реализовано для класса CView. Я обнаружил, что этот класс предоставляет виртуальный метод под названием OnDraw (CDC * dc), который снабжен DC для рисования. WM_PAINT реализован примерно так:

CPaintDC dc(this);
OnDraw(&dc);

И WM_PAINT реализован:

CDC* dc = CDC::FromHandle((HDC)wParam);
OnDraw(dc);

Таким образом, WM_PAINT и WM_PRINT приводят к OnDraw (), и код рисования реализован один раз.

Вы можете добавить эту же логику в свой собственный производный класс CWnd. Это может быть невозможно с помощью мастеров классов Visual Studio. Мне пришлось добавить в блок карты сообщений следующее:

BEGIN_MESSAGE_MAP(MyButton, CButton)
    ...other messages
    ON_MESSAGE(WM_PRINT, OnPrint)
END_MESSAGE_MAP()

И мой обработчик:

LRESULT MyButton::OnPrint(WPARAM wParam, LPARAM lParam) {
    CDC* dc = CDC::FromHandle((HDC)wParam);
    OnDraw(dc);
    return 0;
}

ПРИМЕЧАНИЕ. Если вы добавите собственный обработчик WM_PRINT в класс, который уже поддерживает это автоматически, вы потеряете реализацию по умолчанию. Для OnPrint нет метода CWnd, поэтому вы должны использовать метод Default () для вызова обработчика по умолчанию.

Я не пробовал следующее, но надеюсь, что это сработает:

LRESULT MyCWnd::OnPrint(WPARAM wParam, LPARAM lParam) {
    CDC* dc = CDC::FromHandle((HDC)wParam);
    // Do my own drawing using custom drawing
    OnDraw(dc);

    // And get the default handler to draw children
    return Default();
}

Выше я определил несколько странных методов: ClearBackgroundAndPrepForPerPixelTransparency и CorrectPerPixelAlpha. Это позволяет мне сделать фон моего диалога полупрозрачным, когда дочерние элементы управления будут полностью непрозрачными (это моя попиксельная прозрачность).

// This method is not very efficient but the CBitmap class doens't
// give me a choice I have to copy all the pixel data out, process it and set it back again.
// For performance I recommend using another bitmap class
//
// This method makes every pixel have an opacity of 255 (fully opaque).
void Vg2pImageHeaderRibbon::ClearBackgroundAndPrepForPerPixelTransparency( 
    CDC& dc, const BITMAP& raw_bitmap, int bytes, char* bits, CBitmap& dc_buffer 
) {
    CRect rect;
    GetClientRect(&rect);
    dc.FillSolidRect(0, 0, rect.Width(), rect.Height(), RGB(0,0,0));
    dc_buffer.GetBitmapBits(bytes, bits);
    UINT* pixels = reinterpret_cast<UINT*>(bits);
    for (int c = 0; c < raw_bitmap.bmWidth * raw_bitmap.bmHeight; c++ ){
        pixels[c] |= 0xff000000;
    }
    dc_buffer.SetBitmapBits(bytes, bits);
}

// This method is not very efficient but the CBitmap class doens't
// give me a choice I have to copy all the pixel data out, process it and set it back again.
// For performance I recommend using another bitmap class
//
// This method modifies the opacity value because we know GDI drawing always sets
// the opacity to 0 we find all pixels that have been drawn on since we called 
// For performance I recommend using another bitmap class such as the IcfMfcRasterImage
// ClearBackgroundAndPrepForPerPixelTransparency. Anything that has been drawn on will get an 
// opacity of 255 and all untouched pixels will get an opacity of 100.
void Vg2pImageHeaderRibbon::CorrectPerPixelAlpha( 
    CDC& dc, const BITMAP& raw_bitmap, int bytes, char* bits, CBitmap& dc_buffer 
) {
    const unsigned char AlphaForBackground = 100; // (0 - 255)
    const int AlphaForBackgroundWord = AlphaForBackground << 24;
    dc_buffer.GetBitmapBits(bytes, bits);
    UINT* pixels = reinterpret_cast<UINT*>(bits);
    for (int c = 0; c < raw_bitmap.bmWidth * raw_bitmap.bmHeight; c++ ){
        if ((pixels[c] & 0xff000000) == 0) {
            pixels[c] |= 0xff000000;
        } else {
            pixels[c] = (pixels[c] & 0x00ffffff) | AlphaForBackgroundWord;
        }
    }
    dc_buffer.SetBitmapBits(bytes, bits);
}

Вот скриншот моего тестового приложения. Когда пользователь наводит указатель мыши на кнопку «больше кнопок», диалоговое окно создается с полупрозрачным фоном. Кнопки от «B1» до «B16» являются дочерними элементами управления, производными от CButton и отрисовываются с помощью вызова Print (), показанного выше. Вы можете увидеть полупрозрачный фон на правом краю представления и между кнопками.

Чтобы процитировать страницу MSDN для WM_PAINT:

Сообщение WM_PAINT создается системой и не должно отправляться приложением. Чтобы окно отображалось в конкретном контексте устройства, используйте сообщение WM_PRINT или WM_PRINTCLIENT. Обратите внимание, что для этого требуется, чтобы целевое окно поддерживало сообщение WM_PRINTCLIENT. Большинство общих элементов управления поддерживают сообщение WM_PRINTCLIENT.

Похоже, вы можете перебирать все дочерние окна с помощью EnumChildWindows и отправьте им WM_PRINT с вашим DC памяти между шагами 5 и 6.

Это будет выглядеть примерно так:

static BOOL CALLBACK MyPaintCallback(HWND hChild,LPARAM lParam) {
    SendMessage(hChild,WM_PRINT,(WPARAM)lParam,(LPARAM)(PRF_CHECKVISIBLE|PRF_CHILDREN|PRF_CLIENT));
    return TRUE;
}

void MyPaintMethod(HWND hWnd) {
    //steps 1-5

    EnumChildWindows(hWnd,MyPaintCallback,MyMemoryDC);

    //step 6
}