更改win32应用程序的标题栏(标题)的颜色

Question

我想在我的应用程序中更改标题栏的颜色,就像我在Skype预览程序中看到的那样.我发现在互联网上只提供了一个解决方案(WM_NCPAINT),这似乎要求我绘制一个完全自定义的标题栏,当我想要做的只是改变背景颜色时当然不是理想的.有人知道更好的解决方案吗？有人建议挂钩GetSysColor,但从不使用索引2(COLOR_ACTIVECAPTION)调用它,因此从其他地方检索颜色.

当前标题栏:

最终目标:

Answer 1

您可以使用 Win32 中的 DWMAPI 的DwmSetWindowAttribute函数更改窗口标题栏颜色/行为。

注意：可能需要 Windows SDK 10.0.22000.0（又名第一个 Windows 11 SDK），Windows SDK 10.0.19041.0（最新的 Windows 10 SDK）中DWMWA_USE_IMMERSIVE_DARK_MODE|DWMWA_BORDER_COLOR|DWMWA_CAPTION_COLOR未记录。人们在该变量的公共文档发布之前就已经开始DWMWA_USE_IMMERSIVE_DARK_MODE工作了，只需使用dwAttributeas 20（如果 Windows 是 Windows 10 20H1 之前的版本，则为 19）。下面是 Qt 在 Windows 平台集成中使用它的示例，允许应用程序-platform windows:darkmode=1在启动应用程序时通过传递标志来使用它。

启用沉浸式深色模式（在 Windows 10 / 11 中可用，但在 Windows 10 SDK 中未记录（可以通过将值设置为dwAttribute20 来使用），在 Windows 10 20H1 更新之前值为 19）

• 启用沉浸式深色模式
• 启用沉浸式黑暗模式失焦

#include <dwmapi.h>

BOOL USE_DARK_MODE = true;
BOOL SET_IMMERSIVE_DARK_MODE_SUCCESS = SUCCEEDED(DwmSetWindowAttribute(
    WINhWnd, DWMWINDOWATTRIBUTE::DWMWA_USE_IMMERSIVE_DARK_MODE,
    &USE_DARK_MODE, sizeof(USE_DARK_MODE)));

更改边框颜色（仅在 Windows 11 SDK 中）

• 边框颜色设置为0x00FFFFFF
• 边框颜色设置为0x00505050

#include <dwmapi.h>

COLORREF DARK_COLOR = 0x00505050;
BOOL SET_CAPTION_COLOR = SUCCEEDED(DwmSetWindowAttribute(
    WINhWnd, DWMWINDOWATTRIBUTE::DWMWA_BORDER_COLOR,
    &DARK_COLOR, sizeof(DARK_COLOR)));

更改标题颜色（仅在 Windows 11 SDK 中）

• 标题颜色设置为0x00FFFFFF
• 标题颜色设置为0x00505050

#include <dwmapi.h>

COLORREF DARK_COLOR = 0x00505050;
BOOL SET_CAPTION_COLOR = SUCCEEDED(DwmSetWindowAttribute(
    WINhWnd, DWMWINDOWATTRIBUTE::DWMWA_CAPTION_COLOR,
    &DARK_COLOR, sizeof(DARK_COLOR)));

Answer 2

我要说的第一件事是：您已经被警告过！ 这是一项艰巨的任务。这与轻松实现还有很长的路要走，而且花了很多时间阅读Wine的资源（本机win32功能的linux实现）

看到这个问题，我回想起了我为实现相同结果而付出的努力的“喜爱”（读作：令人气愤！）的回忆。该过程有些复杂，并且给您带来了比单纯绘制标题栏还要多得多的责任。（我已经包含了大约500行代码）

除其他外，您需要处理窗口激活/禁用，大小调整，NC区域按钮，应用程序图标和标题文本。

在我未包含的其他文件中使用一些（绘图）实用程序功能，可以实现以下目的：

两者都是对该对话框的修改：

在这些（彩色键）图像的帮助下： 和一些拉伸/绘图（图像分为9个部分）

我注意到在重新查看此代码后，边界被客户区域覆盖了。我想像是因为我没有正确调整大小以响应WM_NCCALCSIZE消息。我还使用了另一个确实具有8像素宽边框的图像，而不是这两个图像显示的14像素。（您可以看到注释掉的代码以回应我提到的消息）

这个想法是，首先，我们将标准对话框的WindowProc子类化。在此子类化的处理程序中，我们告诉桌面窗口管理器禁用窗口的合成，我们设置一个分层的窗口（这是黑色窗口显示为半透明的方式），然后最后，非客户端绘制自己以响应一个WM_NCPAINT消息。

我还要指出，出于使我逃脱很久的原因，我对代码的功能并不特别满意。

话虽这么说，这里有一些代码可以帮助您：

#define _WIN32_WINNT 0x0501
#define UNICODE 1
#include <windows.h>
#include <commctrl.h>
#include <stdio.h>
#include "resource.h"
#include "../graphics/graphics.h"
#include <dwmapi.h>
using namespace Gdiplus;

HINSTANCE hInst;
LRESULT CALLBACK DlgSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData);
LRESULT onNcPaint(HWND hwnd, WPARAM wParam, LPARAM lParam);

HBITMAP frameImg, frameRedImg, frameOrigImg;
int frameIndex = 0;


//HRESULT DwmEnableComposition(UINT uCompositionAction);

typedef HRESULT (WINAPI *pFnDwmEnableComposition)(UINT uCompAction);
typedef HRESULT (WINAPI *pFnDwmSetWindowAttribute)(HWND hwnd, DWORD dwAttribute, LPCVOID pvAttribute, DWORD cbAttribute);

#define WM_DMWNCRENDERINGCHANGED 0x31F
// wParam = 1 (fRenderingEnabled = true)
// wParam = 0 (fRenderingEnabled = false)


HRESULT EnableNcDwm(HWND hwnd, bool enable)
{
    HMODULE dwmMod = LoadLibrary(L"dwmapi.dll");
    if (dwmMod)
    {
        pFnDwmSetWindowAttribute DwmSetWindowAttribute;
        DwmSetWindowAttribute = (pFnDwmSetWindowAttribute)GetProcAddress(dwmMod, "DwmSetWindowAttribute");

       HRESULT hr = S_OK;
       DWMNCRENDERINGPOLICY ncrp;
       if (enable)
            ncrp = DWMNCRP_ENABLED;
       else
            ncrp = DWMNCRP_DISABLED;

       // Disable non-client area rendering on the window.
       hr = DwmSetWindowAttribute(hwnd, DWMWA_NCRENDERING_POLICY, &ncrp, sizeof(ncrp));
       FreeLibrary(dwmMod);
       if (SUCCEEDED(hr))
       {
          return hr;
       }
   }
   return S_FALSE;
}

/*
#define DWM_EC_DISABLECOMPOSITION 0
#define DWM_EC_ENABLECOMPOSITION 1
HRESULT EnableDWM(HWND hwnd, bool enable)
{
    HMODULE dwmMod = LoadLibrary(L"dwmapi.dll");
    pFnDwmEnableComposition DwmEnableComposition;
    DwmEnableComposition = (pFnDwmEnableComposition)GetProcAddress(dwmMod, "DwmEnableComposition");
    HRESULT hr = S_OK;
    // Disable DWM Composition
    if (enable)
        hr = DwmEnableComposition(DWM_EC_ENABLECOMPOSITION);
    else
        hr = DwmEnableComposition(DWM_EC_DISABLECOMPOSITION);
    FreeLibrary(dwmMod);
   return hr;
}
*/

BOOL CALLBACK DlgMain(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    static bool isSubclassed = false;
    switch(uMsg)
    {
        case WM_DMWNCRENDERINGCHANGED:
        {
            long dwEx = GetWindowLong(hwndDlg, GWL_EXSTYLE);
            dwEx &= ~(WS_EX_LAYERED);
            SetWindowLong(hwndDlg, GWL_EXSTYLE, dwEx);
            InvalidateRect(hwndDlg, NULL, true);
            UpdateWindow(hwndDlg);
            MoveAnchorsImmediatelly(hwndDlg);
        }
        return 0;

   //     case WM_ERASEBKGND:
   //         {
   //             RECT rc;
   //             GetClientRect(hwndDlg, &rc);
   //             FillRect((HDC)wParam, &rc, (HBRUSH) COLOR_BACKGROUND);
   //             return 1;
   //         }

        case WM_INITDIALOG:
        {
            mSetAnchorMode(GetDlgItem(hwndDlg, IDC_BUTTON1), ANCHOR_CENTER);
        }
        return TRUE;

        case WM_SIZE:
        {
            //MoveAnchorsImmediatelly(hwndDlg);
            DeferAnchorsMove(hwndDlg);
        }
        return TRUE;

        case WM_CLOSE:
        {
            EndDialog(hwndDlg, 0);
        }
        return TRUE;

        case WM_COMMAND:
        {
            switch(LOWORD(wParam))
            {
            case IDC_BUTTON1:
                if (isSubclassed == false)
                {
                    SetWindowSubclass( hwndDlg, DlgSubclassProc, 1, NULL);
                    EnableNcDwm(hwndDlg, false);
                    frameIndex++;
                    frameIndex &= 1;        // make sure it can only be in range [0..1]
                }
                else
                {
                    RemoveWindowSubclass( hwndDlg, DlgSubclassProc, 1);
                    EnableNcDwm(hwndDlg, true);
                }
                isSubclassed = !isSubclassed;


             //   InvalidateRect(hwndDlg, NULL, true);
             //   UpdateWindow(hwndDlg);
             //   MoveAnchorsImmediatelly(hwndDlg);
                break;
            }
        }
        return TRUE;
    }

    return FALSE;
}

LRESULT CALLBACK DlgSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
    static byte alpha = 255;
    switch (uMsg)
    {
        case WM_ENTERSIZEMOVE:
            printf("WM_ENTERSIZEMOVE\n");
            return 0;
            break;
        case WM_EXITSIZEMOVE:
            printf("WM_EXITSIZEMOVE\n");
            return 0;
            break;

        case WM_MOUSEWHEEL:
            if (((SHORT)(HIWORD(wParam))) > 0)
            {
                if (alpha > 30)
                    alpha -= 5;
            }
            else if (alpha < 255)
                alpha += 5;
            SetLayeredWindowAttributes(hwnd, RGB(255,0,255), alpha, LWA_COLORKEY|LWA_ALPHA);
            UpdateWindow(hwnd);
            return 0;

        case WM_DMWNCRENDERINGCHANGED:
            {
               // printf("WM_DMWNCRENDERINGCHANGED\n");
                long dwEx = GetWindowLong(hwnd, GWL_EXSTYLE);
                dwEx |= WS_EX_LAYERED;
                SetWindowLong(hwnd, GWL_EXSTYLE, dwEx);
                SetLayeredWindowAttributes(hwnd, RGB(255,0,255), alpha, LWA_COLORKEY|LWA_ALPHA);
                //MoveAnchorsImmediatelly(hwnd);
                DeferAnchorsMove(hwnd);
                InvalidateRect(hwnd, NULL, true);
                UpdateWindow(hwnd);
//                showWndRect(hwnd);
                return 0;
            }
            break;

        case WM_NCACTIVATE:
        case WM_NCPAINT:
          //  printf("WM_NCPAINT -");
          //  printf("wParam: 0x%08d lParam 0x%08x\n", wParam, lParam);
            onNcPaint(hwnd, wParam, lParam);
            return 0;

        case WM_NCCALCSIZE:
            {
                RECT *rc = (RECT*)lParam;
                rc->left += 8;             // frame image margin widths
                rc->top += 30;
                rc->right -= 8;
                rc->bottom -= 8;

//                rc->left += 14;             // frame image margin widths
//               rc->top += 39;
//                rc->right -= 14;
//                rc->bottom -= 14;
            }
            return (WVR_HREDRAW | WVR_VREDRAW);

        case WM_NCHITTEST:
            {
                POINT mousePos, rawMousePos;
                RECT clientRect, windowRect;

                mousePos.x = LOWORD(lParam);
                mousePos.y = HIWORD(lParam);
                rawMousePos = mousePos;

                GetClientRect(hwnd, &clientRect);
                GetWindowRect(hwnd, &windowRect);
                ScreenToClient(hwnd, &mousePos);

                if ((mousePos.x < clientRect.left) && (rawMousePos.y < windowRect.top+8))
                    return HTTOPLEFT;

                if ((mousePos.x > clientRect.right) && (rawMousePos.y < windowRect.top+8))
                    return HTTOPRIGHT;

                if ( (mousePos.x < clientRect.left) && (mousePos.y > clientRect.bottom))
                    return HTBOTTOMLEFT;

                if ( (mousePos.x > clientRect.right) && (mousePos.y > clientRect.bottom))
                    return HTBOTTOMRIGHT;

                if (rawMousePos.x < windowRect.left+11)
                    return HTLEFT;

                if (rawMousePos.x > windowRect.right-11)
                    return HTRIGHT;

                if (mousePos.y  > clientRect.bottom)
                    return HTBOTTOM;

                RECT closeRect;
                SetRect(&closeRect, windowRect.left + 15, windowRect.top+7, windowRect.left+15+16, windowRect.top+25);
                if (PtInRect(&closeRect, rawMousePos))
                {
//                    printf("over sys menu (appIcon) - %d,%d\n", mousePos.x, mousePos.y);
                    return HTSYSMENU;
                }

                if (rawMousePos.y < windowRect.top+8)
                    return HTTOP;

                if (mousePos.y < 0)
                    return HTCAPTION;
                else
                    return HTCLIENT;
            }

    }
    return DefSubclassProc(hwnd, uMsg, wParam, lParam);
//    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

LRESULT onNcPaint(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
    // draw Frame
//     HBRUSH mBrush = CreateSolidBrush( RGB(0,113,201) );
    HDC hdc = GetWindowDC(hwnd);
//     HDC hdc = GetDCEx(hwnd, (HRGN)wParam, DCX_WINDOW);//|DCX_INTERSECTRGN);

    RECT mRect, wndRect;
    GetWindowRect(hwnd, &mRect);
    wndRect = mRect;
    mRect.right -= mRect.left;
    mRect.bottom -= mRect.top;
    mRect.left = 0;
    mRect.top = 0;

    HDC memDC = CreateCompatibleDC(hdc);
    HBITMAP old, memBmp;
    old = (HBITMAP)GetCurrentObject(memDC, OBJ_BITMAP);

    memBmp = CreateCompatibleBitmap(hdc, mRect.right, mRect.bottom);
    //memBmp = zCreateDibSection(hdc, mRect.right, mRect.bottom, 24);

    SelectObject(memDC, memBmp);


    //StretchNineDraw(HDC destDC, RECT destRect, HBITMAP srcImage, RECT srcRect,
    //    int marginLeft, int marginTop, int marginRight, int marginBottom, int alpha);

    if (frameIndex == 0)
//        StretchNineDraw(memDC, mRect, frameImg, (RECT){0,0,33,58}, 16,41,16,16, 255);
        StretchNineDrawNoAlpha(memDC, mRect, frameImg, (RECT){0,0,33,58}, 16,41,16,16);
    else
        StretchNineDraw(memDC, mRect, frameRedImg, (RECT){0,0,33,58}, 16,41,16,16, 255);
//        StretchNineDrawNoAlpha(memDC, mRect, frameRedImg, (RECT){0,0,33,58}, 16,41,16,16);
    //    StretchNineDrawNoAlpha(memDC, mRect, frameOrigImg, (RECT){0,0,17,39}, 8,30,8,8);
    //1111drawImgNineSquareStretching(memDC, mRect, frameImg, (RECT){0,0,33,58}, 16,41,16,16);

//void StretchNineDrawNoAlpha(HDC destDC, RECT destRect, HBITMAP srcImage, RECT srcRect,
//                   int marginLeft, int marginTop, int marginRight, int marginBottom)



    // draw icon
    HICON smallIcon = LoadIcon (NULL, IDI_APPLICATION);
    DrawIconEx(memDC, 15, 9, smallIcon, 16, 16, 0,0, DI_NORMAL  );

    // draw window text
    wchar_t wndText[100];
    RECT textRect;
    textRect.left = 9 + 16 + 9;
    textRect.top = 0;
    textRect.right = 1000;
    textRect.bottom = 32;
    GetWindowText(hwnd, wndText, 99);
    //int oldMode = SetBkMode(hdc, TRANSPARENT);
    //int oldMode = SetBkMode(memDC, TRANSPARENT);
    SetBkMode(memDC, TRANSPARENT);

    HFONT oldFont, hfont0 = CreateFont(-13, 0, 0, 0, 0, FALSE, FALSE, FALSE, 1, 0, 0, 0, 0, (L"Ms Shell Dlg"));
    oldFont = (HFONT)SelectObject(memDC, hfont0);
    DrawText(memDC, wndText, -1, &textRect, DT_VCENTER|DT_SINGLELINE|DT_LEFT);
    SelectObject(memDC, oldFont);
    DeleteObject(hfont0);


    // top slice
    BitBlt(hdc, 0,0, mRect.right,41, memDC, 0,0, SRCCOPY);

    // left edge
    BitBlt(hdc, 0, mRect.top + 41, 16, mRect.bottom - (41+16),
           memDC, 0, mRect.top + 41, SRCCOPY);

    // right edge
    BitBlt(hdc, mRect.right-16, mRect.top + 41, 16, mRect.bottom - (41+16),
           memDC, mRect.right-16, mRect.top + 41, SRCCOPY);

    // bottom slice
    BitBlt(hdc, 0,mRect.bottom-16, mRect.right,16, memDC, 0,mRect.bottom-16, SRCCOPY);


 //   BitBlt(hdc, 0,0, mRect.right,mRect.bottom, memDC, 0,0, SRCCOPY);

    ReleaseDC(hwnd, hdc);
    SelectObject(memDC, old);
    DeleteDC(memDC);
    DeleteObject(memBmp);
 //   ValidateRgn(hwnd, (HRGN)wParam);
    return 0;
}


int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR           gdiplusToken;
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

    frameImg = mLoadImageFile(L"frame.png");
    frameRedImg = mLoadImageFile(L"frameRed.png");
    frameOrigImg = mLoadImageFile(L"frameOrig.png");

    hInst=hInstance;
    InitCommonControls();
    int result = DialogBox(hInst, MAKEINTRESOURCE(DLG_MAIN), NULL, (DLGPROC)DlgMain);

    GdiplusShutdown(gdiplusToken);
    return result;
}

在下面找到的功能：-加载png文件（使用GDI +）-将该图像拉伸到边框上

/* BMP, GIF, JPEG, PNG, TIFF, Exif, WMF, and EMF */
HBITMAP mLoadImageFile(wchar_t *filename)
{
    HBITMAP result = NULL;
    Bitmap bitmap(filename, false);
    bitmap.GetHBITMAP(0, &result);
    return result;
}


void GetRectSize(LPRECT tgt, int *width, int *height)
{
    *width = (tgt->right - tgt->left) + 1;
    *height = (tgt->bottom - tgt->top) + 1;
}

BOOL SetRectSizePos(LPRECT tgt, int xPos, int yPos, int width, int height)
{
    return SetRect(tgt, xPos, yPos, xPos+(width-1), yPos+(height-1));
}

BOOL MoveRect(LPRECT tgt, int newX, int newY)
{
    int width, height;
    GetRectSize(tgt, &width, &height);
    return SetRectSizePos(tgt, newX,newY, width,height);
}

//  ****** marginLeft = 6
//   ....|....|....  *
//  ..tL.|.tM.|.tR.. *
//  ---------------- * marginTop = 3
//  ..mL.|.mM.|.mR..
//  ---------------- * marginBottom = 3
//  ..bL.|.bM.|.bR.. *
//   ....|....|....  *
//            ****** marginRight = 6
void CalcNineRects(LPRECT srcRect, RECT *dest, int marginLeft, int marginTop, int marginRight, int marginBottom)
{
    int srcWidth, srcHeight;
    int leftWidth, midWidth, rightWidth;
    int topHeight, midHeight, botHeight;
    int xOrig, yOrig;

    GetRectSize(srcRect, &srcWidth, &srcHeight);
    xOrig = srcRect->left;
    yOrig = srcRect->top;

    leftWidth = marginLeft;
    midWidth = srcWidth - (marginLeft + marginRight) - 1;
    rightWidth = marginRight;

    topHeight = marginTop;
    midHeight = srcHeight - (marginTop + marginBottom) - 1;
    botHeight = marginBottom;

    SetRectSizePos(&dest[0], xOrig, yOrig, leftWidth, topHeight);
    SetRectSizePos(&dest[1], xOrig+(leftWidth), yOrig, midWidth, topHeight);
    SetRectSizePos(&dest[2], xOrig+(leftWidth+midWidth), yOrig, rightWidth, topHeight);

    SetRectSizePos(&dest[3], xOrig, yOrig+(topHeight), leftWidth, midHeight);
    SetRectSizePos(&dest[4], xOrig+(leftWidth), yOrig+(topHeight), midWidth, midHeight);
    SetRectSizePos(&dest[5], xOrig+(leftWidth+midWidth), yOrig+(topHeight), rightWidth, midHeight);

    SetRectSizePos(&dest[6], xOrig,yOrig+(topHeight+midHeight), leftWidth, botHeight);
    SetRectSizePos(&dest[7], xOrig+(leftWidth), yOrig+(topHeight+midHeight), midWidth, botHeight);
    SetRectSizePos(&dest[8], xOrig+(leftWidth+midWidth), yOrig+(topHeight+midHeight), rightWidth, botHeight);
}

void StretchNineDraw(HDC destDC, RECT destRect, HBITMAP srcImage, RECT srcRect,
                    int marginLeft, int marginTop, int marginRight, int marginBottom,int alpha)
{
    RECT destRectList[9], srcRectList[9];
    int i;
    int curSrcWidth, curSrcHeight, curDestWidth, curDestHeight;
    HDC srcDC;
    HBITMAP oldSrcBmp;

    srcDC = CreateCompatibleDC(destDC);
//    GetCurrentObject(srcDC, OBJ_BITMAP);
    oldSrcBmp = (HBITMAP) SelectObject(srcDC, srcImage);

    BLENDFUNCTION bf = {AC_SRC_OVER,0,alpha,AC_SRC_ALPHA};

    int destHeight, destWidth;
    GetRectSize(&destRect, &destWidth, &destHeight);

    CalcNineRects(&srcRect, srcRectList, marginLeft, marginTop, marginRight, marginBottom);
    CalcNineRects(&destRect, destRectList, marginLeft, marginTop, marginRight, marginBottom);
    // printf("dst rect: %d,%d - %d,%d -- \n", destRect.left, destRect.top, destRect.right,destRect.bottom);
    for (i=0; i<9; i++)
    {
        GetRectSize(&srcRectList[i], &curSrcWidth, &curSrcHeight);
        GetRectSize(&destRectList[i], &curDestWidth, &curDestHeight);

        AlphaBlend( destDC,
                    destRectList[i].left, destRectList[i].top,
                    curDestWidth, curDestHeight,

                    srcDC,
                    srcRectList[i].left, srcRectList[i].top,
                    curSrcWidth, curSrcHeight,

                    bf
                   );
    }
    SelectObject(srcDC, oldSrcBmp);
    DeleteDC(srcDC);
}

最后，用于将控件锚定到窗口的代码（在调整窗口大小时自动重新计算其位置）

typedef struct ANCHORPROPERTY
{
    long anchorType;
    RECT rc;
} *pANCHORPROPERTY;

#define ANCHOR_NONE                  0
#define ANCHOR_WIDTH                 1
#define ANCHOR_RIGHT                 2
#define ANCHOR_CENTER_HORZ           3
#define ANCHOR_HEIGHT                4
#define ANCHOR_HEIGHT_WIDTH          5
#define ANCHOR_HEIGHT_RIGHT          6
#define ANCHOR_BOTTOM                7
#define ANCHOR_BOTTOM_WIDTH          8
#define ANCHOR_BOTTOM_RIGHT          9
#define ANCHOR_CENTER_HORZ_BOTTOM    10
#define ANCHOR_CENTER_VERT           11
#define ANCHOR_CENTER_VERT_RIGHT     12
#define ANCHOR_CENTER                13

pANCHORPROPERTY getWndAnchor(HWND hwnd);
bool removeAnchor(HWND hwnd);
bool mSetAnchorMode(HWND hwnd, long anchorMode);
BOOL CALLBACK AnchorEnum(HWND hwnd, LPARAM lParam);
void MoveAnchorsImmediatelly(HWND controlParent);
void DeferAnchorsMove(HWND controlParent);
long getChildCount(HWND controlParent);

pANCHORPROPERTY getWndAnchor(HWND hwnd)
{
    return (pANCHORPROPERTY)GetProp(hwnd, L"anchor");
}

bool removeAnchor(HWND hwnd)
{
    pANCHORPROPERTY pAnchor;
    if (GetProp(hwnd, L"anchor") != NULL)
    {
        pAnchor = (pANCHORPROPERTY)RemoveProp(hwnd, L"anchor");
        delete pAnchor;
    }
    return false;
}

bool mSetAnchorMode(HWND hwnd, long anchorMode)
{
    bool result = false;
    RECT rc, pr;
    POINT p;
    if (IsWindow(hwnd))
    {
        pANCHORPROPERTY pAnchor;
        pAnchor = getWndAnchor(hwnd);
        if (pAnchor == NULL)
        {
            pAnchor = new ANCHORPROPERTY;
            SetProp(hwnd, L"anchor", pAnchor);
        }
        GetWindowRect(hwnd, &rc);
        p.x = rc.left;
        p.y = rc.top;
        ScreenToClient( GetParent(hwnd), &p);
        GetClientRect( GetParent(hwnd), &pr);
    //    printf("pos: %d,%d\n", p.x, p.y);
        pAnchor->anchorType = mmin( mmax(anchorMode, ANCHOR_NONE), ANCHOR_CENTER);
        pAnchor->rc.left = p.x;
        pAnchor->rc.top = p.y;
        pAnchor->rc.right = pr.right - (rc.right-rc.left + p.x);
        pAnchor->rc.bottom = pr.bottom - (rc.bottom - rc.top + p.y);
        result = true;
    }
    return result;
}

BOOL CALLBACK AnchorEnum(HWND hwnd, LPARAM lParam)
{
    RECT pr, rc;
    long x,y,xW,yH;
    pANCHORPROPERTY pAnchor;
    pAnchor = (pANCHORPROPERTY)GetProp(hwnd, L"anchor");
    if

        
      
    

Answer 3

您可以尝试创建一个没有框架的窗口。我在这里找到参考： 用win32打开一个没有标题栏的窗口

然后在您的应用程序中以自己喜欢的颜色（位于窗口顶部从可见部分开始）创建自己的标题栏。