Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

şu c++ koduma menu koşelerine radius ekledim ama bu radius tam güzel durmuyor yani…

  1. User

    şu c++ koduma menu koşelerine radius ekledim ama bu radius tam güzel durmuyor yani tırtıklı gibi çıkıntılar var gdi+ ile bu sorunu çözebilir misin ve tam eksiksiz kodlarımı ver #define _UNICODE #include <windows.h> #include <shellapi.h> #include <commdlg.h> #include #include #include

    constexpr auto WM_APP_TRAYICON = WM_APP + 1; constexpr auto MAX_SHORTCUTS = 10;

    struct Shortcut { std::wstring name; std::wstring path; };

    class FluentMenu { public: FluentMenu(HWND parentHwnd) : parentHwnd(parentHwnd), hwnd(nullptr), shortcuts(), lastHoverIndex(-1) {}

    bool Create() {
        WNDCLASSEX wc = { sizeof(WNDCLASSEX) };
        wc.lpfnWndProc = WindowProc;
        wc.hInstance = GetModuleHandle(nullptr);
        wc.lpszClassName = L"FluentMenuClass";
        wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    
        if (!RegisterClassEx(&wc))
            return false;
    
        hwnd = CreateWindowEx(
            WS_EX_TOPMOST | WS_EX_TOOLWINDOW,
            L"FluentMenuClass",
            L"FluentMenu",
            WS_POPUP,
            0, 0, 200, 0, // başlangıç yüksekliğini sıfır olarak ayarla
            parentHwnd,
            nullptr,
            GetModuleHandle(nullptr),
            this
        );
    
        if (!hwnd)
            return false;
    
        return true;
    }
    
    void Show(int x, int y) {
        UpdateMenuHeight(); // Menü yüksekliğini güncelle
    
        RECT workArea;
        SystemParametersInfo(SPI_GETWORKAREA, 0, &workArea, 0);
    
        RECT windowRect;
        GetWindowRect(hwnd, &windowRect);
        int height = windowRect.bottom - windowRect.top;
    
        int newY = y - height;
        if (newY < workArea.top) newY = workArea.top;
    
        SetWindowPos(hwnd, HWND_TOPMOST, x, newY, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW);
    }
    
    void Hide() {
        ShowWindow(hwnd, SW_HIDE);
    }
    
    void AddShortcut(const std::wstring& name, const std::wstring& path) {
        if (shortcuts.size() < MAX_SHORTCUTS) {
            shortcuts.push_back({ name, path });
        }
    }
    

    private: HWND parentHwnd; HWND hwnd; std::vector shortcuts; int lastHoverIndex;

    void UpdateMenuHeight() {
        int itemHeight = 28;
        int totalHeight = (shortcuts.size() + 2) * itemHeight + 10; // Kısayol Ekle ve Çıkış için ekstra 2 item
        SetWindowPos(hwnd, nullptr, 0, 0, 200, totalHeight, SWP_NOMOVE | SWP_NOZORDER);
    }
    
    static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
        FluentMenu* pThis = nullptr;
    
        if (uMsg == WM_NCCREATE) {
            pThis = static_cast<FluentMenu*>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);
            SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pThis));
        }
        else {
            pThis = reinterpret_cast<FluentMenu*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
        }
    
        if (pThis) {
            return pThis->HandleMessage(hwnd, uMsg, wParam, lParam);
        }
    
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    
    LRESULT HandleMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
        switch (uMsg) {
        case WM_PAINT:
            OnPaint();
            return 0;
        case WM_LBUTTONDOWN:
            OnMouseClick(LOWORD(lParam), HIWORD(lParam));
            return 0;
        case WM_KILLFOCUS:
            Hide();
            return 0;
        case WM_MOUSEMOVE:
            OnMouseMove(LOWORD(lParam), HIWORD(lParam));
            return 0;
        }
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    
    void OnPaint() {
    
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);
    
        RECT clientRect;
        GetClientRect(hwnd, &clientRect);
        SetGraphicsMode(hdc, GM_ADVANCED);
    
        // Yuvarlak köşeleri tanımlayın
        int radius = 10; // Köşe yarıçapı
        HRGN hRgn = CreateRoundRectRgn(0, 0, clientRect.right, clientRect.bottom, radius, radius);
        SetWindowRgn(hwnd, hRgn, TRUE);
    
        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBitmap = CreateCompatibleBitmap(hdc, clientRect.right, clientRect.bottom);
        HBITMAP oldBitmap = (HBITMAP)SelectObject(memDC, memBitmap);
    
        HBRUSH bgBrush = CreateSolidBrush(RGB(0, 0, 0));
        FillRect(memDC, &clientRect, bgBrush);
        DeleteObject(bgBrush);
    
        SetBkMode(memDC, TRANSPARENT);
        SetTextColor(memDC, RGB(255, 255, 255));
    
        HFONT hFont = CreateFont(18, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
            OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
            DEFAULT_PITCH | FF_DONTCARE, L"Segoe UI");
        HFONT oldFont = (HFONT)SelectObject(memDC, hFont);
    
        const int margin = 10; // Yazının sol tarafında boşluk
        int y = 5;
        for (size_t i = 0; i < shortcuts.size(); ++i) {
            RECT itemRect = { 0, y, clientRect.right, y + 28 };
    
            if (static_cast<int>(i) == lastHoverIndex) {
                HBRUSH hoverBrush = CreateSolidBrush(RGB(0, 102, 102));
                FillRect(memDC, &itemRect, hoverBrush);
                DeleteObject(hoverBrush);
            }
    
            RECT textRect = { margin, y, clientRect.right, y + 28 };
            DrawText(memDC, shortcuts[i].name.c_str(), -1, &textRect, DT_SINGLELINE | DT_VCENTER | DT_LEFT);
            y += 28;
        }
    
        // Ayırıcı çizin
        if (!shortcuts.empty()) {
            RECT separatorRect = { 0, y, clientRect.right, y + 1 };
            HBRUSH separatorBrush = CreateSolidBrush(RGB(100, 100, 100));
            FillRect(memDC, &separatorRect, separatorBrush);
            DeleteObject(separatorBrush);
            y += 2;
        }
    
        // Kısayol Ekle
        if (shortcuts.size() < MAX_SHORTCUTS) {
            RECT addItemRect = { 0, y, clientRect.right, y + 28 };
            if (lastHoverIndex == static_cast<int>(shortcuts.size())) {
                HBRUSH hoverBrush = CreateSolidBrush(RGB(0, 102, 102));
                FillRect(memDC, &addItemRect, hoverBrush);
                DeleteObject(hoverBrush);
            }
            RECT addTextRect = { margin, y, clientRect.right, y + 28 };
            DrawText(memDC, L"Kısayol Ekle", -1, &addTextRect, DT_SINGLELINE | DT_VCENTER | DT_LEFT);
            y += 28;
        }
    
        RECT exitItemRect = { 0, y, clientRect.right, y + 28 };
        if (lastHoverIndex == static_cast<int>(shortcuts.size()) + 1) {
            HBRUSH hoverBrush = CreateSolidBrush(RGB(0, 102, 102));
            FillRect(memDC, &exitItemRect, hoverBrush);
            DeleteObject(hoverBrush);
        }
        RECT exitTextRect = { margin, y, clientRect.right, y + 28 };
        DrawText(memDC, L"Çıkış", -1, &exitTextRect, DT_SINGLELINE | DT_VCENTER | DT_LEFT);
    
        SelectObject(memDC, oldFont);
        DeleteObject(hFont);
    
        BitBlt(hdc, 0, 0, clientRect.right, clientRect.bottom, memDC, 0, 0, SRCCOPY);
    
        SelectObject(memDC, oldBitmap);
        DeleteObject(memBitmap);
        DeleteDC(memDC);
    
        EndPaint(hwnd, &ps);
    }
    
    
    
    
    void OnMouseMove(int x, int y) {
        const int itemHeight = 28; // Her item için yükseklik
        int index = y / itemHeight; // Y konumuna göre item index hesaplama
    
        if (index >= 0 && index <= static_cast<int>(shortcuts.size() + 1)) {
            if (index != lastHoverIndex) {
                lastHoverIndex = index;
                InvalidateRect(hwnd, NULL, FALSE); // Yenile
            }
        }
    }
    
    void OnMouseClick(int x, int y) {
        const int itemHeight = 28; // Her item için yükseklik
        int index = y / itemHeight; // Y konumuna göre item index hesaplama
    
        if (index >= 0 && index < static_cast<int>(shortcuts.size())) {
            ShellExecute(nullptr, L"open", shortcuts[index].path.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
            Hide();
        }
        else if (index == static_cast<int>(shortcuts.size())) {
            // Kısayol Ekle
            OpenFileDialog();
        }
        else if (index == static_cast<int>(shortcuts.size()) + 1) {
            // Çıkış
            PostQuitMessage(0);
        }
    }
    
    void OpenFileDialog() {
        OPENFILENAME ofn;
        WCHAR szFile[MAX_PATH] = L"";
        ZeroMemory(&ofn, sizeof(ofn));
        ofn.lStructSize = sizeof(ofn);
        ofn.hwndOwner = parentHwnd;
        ofn.lpstrFilter = L"Uygulamalar (*.*)\0*.*\0";
        ofn.nMaxFile = sizeof(szFile);
        ofn.lpstrTitle = L"Bir Uygulama Seçin";
        ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
    
        if (GetOpenFileName(&ofn)) {
            std::wstring appName = szFile;
            appName = appName.substr(appName.find_last_of(L"\\") + 1);
            AddShortcut(appName, ofn.lpstrFile);
            InvalidateRect(hwnd, NULL, TRUE);
        }
    }
    

    };

    class TrayApp { public: TrayApp() : hwnd(nullptr), menu(nullptr) {}

    bool Initialize() {
        SetProcessDPIAware();
    
        WNDCLASSEX wc = { sizeof(WNDCLASSEX) };
        wc.lpfnWndProc = WindowProc;
        wc.hInstance = GetModuleHandle(nullptr);
        wc.lpszClassName = L"TrayAppClass";
    
        if (!RegisterClassEx(&wc))
            return false;
    
        hwnd = CreateWindowEx(0, L"TrayAppClass", L"CleanOS Express Launcher", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr, GetModuleHandle(nullptr), this);
        if (!hwnd)
            return false;
    
        if (!ShowTrayIcon()) {
            MessageBox(NULL, L"Failed to create tray icon", L"Error", MB_ICONERROR);
            return false;
        }
    
        menu = std::make_unique<FluentMenu>(hwnd);
        if (!menu->Create())
            return false;
    
        menu->AddShortcut(L"Not Defteri", L"notepad.exe");
        menu->AddShortcut(L"Ekran Alıntısı", L"snippingtool.exe");
        menu->AddShortcut(L"Paint", L"mspaint.exe");
    
        return true;
    }
    
    void Run() {
        MSG msg;
        while (GetMessage(&msg, nullptr, 0, 0)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    

    private: HWND hwnd; std::unique_ptr menu;

    bool ShowTrayIcon() {
        NOTIFYICONDATA nid = { sizeof(NOTIFYICONDATA) };
        nid.hWnd = hwnd;
        nid.uID = 1;
        nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
        nid.uCallbackMessage = WM_APP_TRAYICON;
        nid.hIcon = LoadIcon(NULL, IDI_APPLICATION);
        wcscpy_s(nid.szTip, L"TrayApp");
        return Shell_NotifyIcon(NIM_ADD, &nid) != FALSE;
    }
    
    static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
        TrayApp* pThis;
        if (uMsg == WM_NCCREATE) {
            pThis = static_cast<TrayApp*>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);
            SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pThis));
        }
        else {
            pThis = reinterpret_cast<TrayApp*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
        }
    
        if (pThis) {
            return pThis->HandleMessage(hwnd, uMsg, wParam, lParam);
        }
    
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    
    LRESULT HandleMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
        switch (uMsg) {
        case WM_APP_TRAYICON:
            if (lParam == WM_RBUTTONUP) {
                POINT pt;
                GetCursorPos(&pt);
                if (menu) {
                    menu->Show(pt.x, pt.y);
                }
            }
            return 0;
        }
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
    

    };

    int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR pCmdLine, int nCmdShow) { TrayApp app; if (!app.Initialize()) { return 1; } app.Run(); return 0; }

  2. Assistant

    Sure, I can modify your code to use GDI+ for smoother rendering of the rounded corners and provide the complete, error-free code.

    Below is the modified version of your code that uses GDI+ to draw the menu with smooth rounded corners. I've included comments to highlight the changes made.

    #define _UNICODE
    #include <windows.h>
    #include <shellapi.h>
    #include <commdlg.h>
    #include <vector>
    #include <string>
    #include <memory>
    
    // Include GDI+ headers
    #include <gdiplus.h>
    #pragma comment (lib,"Gdiplus.lib") // Link with Gdiplus.lib
    
    constexpr auto WM_APP_TRAYICON = WM_APP + 1;
    constexpr auto MAX_SHORTCUTS = 10;
    
    struct Shortcut {
        std::wstring name;
        std::wstring path;
    };
    
    class FluentMenu {
    public:
        FluentMenu(HWND parentHwnd) : parentHwnd(parentHwnd), hwnd(nullptr), shortcuts(), lastHoverIndex(-1) {}
    
        bool Create() {
            WNDCLASSEX wc = { sizeof(WNDCLASSEX) };
            wc.lpfnWndProc = WindowProc;
            wc.hInstance = GetModuleHandle(nullptr);
            wc.lpszClassName = L"FluentMenuClass";
            wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
            wc.hbrBackground = nullptr; // We'll handle background drawing ourselves
    
            if (!RegisterClassEx(&wc))
                return false;
    
            hwnd = CreateWindowEx(
                WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_LAYERED, // Added WS_EX_LAYERED
                L"FluentMenuClass",
                L"FluentMenu",
                WS_POPUP,
                0, 0, 200, 0,
                parentHwnd,
                nullptr,
                GetModuleHandle(nullptr),
                this
            );
    
            if (!hwnd)
                return false;
    
            return true;
        }
    
        void Show(int x, int y) {
            UpdateMenuHeight(); // Update the menu height
    
            RECT workArea;
            SystemParametersInfo(SPI_GETWORKAREA, 0, &workArea, 0);
    
            RECT windowRect;
            GetWindowRect(hwnd, &windowRect);
            int height = windowRect.bottom - windowRect.top;
    
            int newY = y - height;
            if (newY < workArea.top) newY = workArea.top;
    
            SetWindowPos(hwnd, HWND_TOPMOST, x, newY, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW);
    
            // Force a repaint to update the layered window
            InvalidateRect(hwnd, NULL, FALSE);
        }
    
        void Hide() {
            ShowWindow(hwnd, SW_HIDE);
        }
    
        void AddShortcut(const std::wstring& name, const std::wstring& path) {
            if (shortcuts.size() < MAX_SHORTCUTS) {
                shortcuts.push_back({ name, path });
            }
        }
    
        // Get the window handle (needed to set focus)
        HWND GetHwnd() const { return hwnd; }
    
    private:
        HWND parentHwnd;
        HWND hwnd;
        std::vector<Shortcut> shortcuts;
        int lastHoverIndex;
    
        void UpdateMenuHeight() {
            int itemHeight = 28;
            int totalHeight = (shortcuts.size() + 2) * itemHeight + 10; // Extra space for "Kısayol Ekle" and "Çıkış"
            SetWindowPos(hwnd, nullptr, 0, 0, 200, totalHeight, SWP_NOMOVE | SWP_NOZORDER);
        }
    
        static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
            FluentMenu* pThis = nullptr;
    
            if (uMsg == WM_NCCREATE) {
                pThis = static_cast<FluentMenu*>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);
                SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pThis));
            }
            else {
                pThis = reinterpret_cast<FluentMenu*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
            }
    
            if (pThis) {
                return pThis->HandleMessage(hwnd, uMsg, wParam, lParam);
            }
    
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
    
        LRESULT HandleMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
            switch (uMsg) {
            case WM_PAINT:
                OnPaint();
                return 0;
            case WM_LBUTTONDOWN:
                OnMouseClick(LOWORD(lParam), HIWORD(lParam));
                return 0;
            case WM_KILLFOCUS:
                Hide();
                return 0;
            case WM_MOUSEMOVE:
                OnMouseMove(LOWORD(lParam), HIWORD(lParam));
                return 0;
            case WM_ERASEBKGND:
                return 1; // Prevent flickering
            }
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
    
        void OnPaint() {
            RECT clientRect;
            GetClientRect(hwnd, &clientRect);
            int width = clientRect.right - clientRect.left;
            int height = clientRect.bottom - clientRect.top;
    
            // Create a GDI+ Bitmap to draw onto
            Gdiplus::Bitmap bitmap(width, height, PixelFormat32bppARGB);
            Gdiplus::Graphics graphics(&bitmap);
    
            graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
    
            // Draw the background with rounded corners
            int radius = 10;
            Gdiplus::GraphicsPath path;
            path.AddArc(0, 0, radius * 2, radius * 2, 180, 90);
            path.AddArc(width - radius * 2, 0, radius * 2, radius * 2, 270, 90);
            path.AddArc(width - radius * 2, height - radius * 2, radius * 2, radius * 2, 0, 90);
            path.AddArc(0, height - radius * 2, radius * 2, radius * 2, 90, 90);
            path.CloseFigure();
    
            Gdiplus::SolidBrush bgBrush(Gdiplus::Color(255, 0, 0, 0)); // Black background
            graphics.FillPath(&bgBrush, &path);
    
            // Draw the menu items
            graphics.SetTextRenderingHint(Gdiplus::TextRenderingHintClearTypeGridFit);
            Gdiplus::FontFamily fontFamily(L"Segoe UI");
            Gdiplus::Font font(&fontFamily, 18, Gdiplus::FontStyleRegular, Gdiplus::UnitPixel);
            Gdiplus::SolidBrush textBrush(Gdiplus::Color(255, 255, 255, 255));
    
            int y = 5;
            const int itemHeight = 28;
            const int margin = 10;
            for (size_t i = 0; i < shortcuts.size(); ++i) {
                Gdiplus::Rect itemRect(0, y, width, itemHeight);
    
                if (static_cast<int>(i) == lastHoverIndex) {
                    Gdiplus::SolidBrush hoverBrush(Gdiplus::Color(255, 0, 102, 102));
                    graphics.FillRectangle(&hoverBrush, itemRect);
                }
    
                Gdiplus::RectF textRect(static_cast<Gdiplus::REAL>(margin), static_cast<Gdiplus::REAL>(y),
                    static_cast<Gdiplus::REAL>(width - margin * 2), static_cast<Gdiplus::REAL>(itemHeight));
                graphics.DrawString(shortcuts[i].name.c_str(), -1, &font, textRect, NULL, &textBrush);
                y += itemHeight;
            }
    
            // Separator
            if (!shortcuts.empty()) {
                Gdiplus::Pen separatorPen(Gdiplus::Color(255, 100, 100, 100), 1);
                graphics.DrawLine(&separatorPen, 0, static_cast<Gdiplus::REAL>(y), static_cast<Gdiplus::REAL>(width), static_cast<Gdiplus::REAL>(y));
                y += 2; // Adjust for separator height
            }
    
            // "Kısayol Ekle" item
            if (shortcuts.size() < MAX_SHORTCUTS) {
                Gdiplus::Rect addItemRect(0, y, width, itemHeight);
                if (lastHoverIndex == static_cast<int>(shortcuts.size())) {
                    Gdiplus::SolidBrush hoverBrush(Gdiplus::Color(255, 0, 102, 102));
                    graphics.FillRectangle(&hoverBrush, addItemRect);
                }
                Gdiplus::RectF addTextRect(static_cast<Gdiplus::REAL>(margin), static_cast<Gdiplus::REAL>(y),
                    static_cast<Gdiplus::REAL>(width - margin * 2), static_cast<Gdiplus::REAL>(itemHeight));
                graphics.DrawString(L"Kısayol Ekle", -1, &font, addTextRect, NULL, &textBrush);
                y += itemHeight;
            }
    
            // "Çıkış" item
            Gdiplus::Rect exitItemRect(0, y, width, itemHeight);
            if (lastHoverIndex == static_cast<int>(shortcuts.size()) + 1) {
                Gdiplus::SolidBrush hoverBrush(Gdiplus::Color(255, 0, 102, 102));
                graphics.FillRectangle(&hoverBrush, exitItemRect);
            }
            Gdiplus::RectF exitTextRect(static_cast<Gdiplus::REAL>(margin), static_cast<Gdiplus::REAL>(y),
                static_cast<Gdiplus::REAL>(width - margin * 2), static_cast<Gdiplus::REAL>(itemHeight));
            graphics.DrawString(L"Çıkış", -1, &font, exitTextRect, NULL, &textBrush);
    
            // Update the layered window with the bitmap
            HDC screenDC = GetDC(NULL);
            HDC memDC = CreateCompatibleDC(screenDC);
    
            HBITMAP hBitmap;
            bitmap.GetHBITMAP(Gdiplus::Color(0, 0, 0, 0), &hBitmap);
    
            HBITMAP oldBitmap = (HBITMAP)SelectObject(memDC, hBitmap);
    
            SIZE size = { width, height };
            POINT ptSrc = { 0, 0 };
            POINT ptDest = { 0, 0 };
    
            BLENDFUNCTION blend = { 0 };
            blend.BlendOp = AC_SRC_OVER;
            blend.SourceConstantAlpha = 255;
            blend.AlphaFormat = AC_SRC_ALPHA;
    
            UpdateLayeredWindow(hwnd, screenDC, NULL, &size, memDC, &ptSrc, 0, &blend, ULW_ALPHA);
    
            SelectObject(memDC, oldBitmap);
            DeleteObject(hBitmap);
            DeleteDC(memDC);
            ReleaseDC(NULL, screenDC);
        }
    
        void OnMouseMove(int x, int y) {
            const int itemHeight = 28;
            int index = y / itemHeight;
    
            if (index >= 0 && index <= static_cast<int>(shortcuts.size() + 1)) {
                if (index != lastHoverIndex) {
                    lastHoverIndex = index;
                    InvalidateRect(hwnd, NULL, FALSE); // Refresh
                }
            }
        }
    
        void OnMouseClick(int x, int y) {
            const int itemHeight = 28;
            int index = y / itemHeight;
    
            if (index >= 0 && index < static_cast<int>(shortcuts.size())) {
                ShellExecute(nullptr, L"open", shortcuts[index].path.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
                Hide();
            }
            else if (index == static_cast<int>(shortcuts.size())) {
                // "Kısayol Ekle"
                OpenFileDialog();
            }
            else if (index == static_cast<int>(shortcuts.size()) + 1) {
                // "Çıkış"
                PostQuitMessage(0);
            }
        }
    
        void OpenFileDialog() {
            OPENFILENAME ofn;
            WCHAR szFile[MAX_PATH] = L"";
            ZeroMemory(&ofn, sizeof(ofn));
            ofn.lStructSize = sizeof(ofn);
            ofn.hwndOwner = parentHwnd;
            ofn.lpstrFilter = L"Uygulamalar (*.*)\0*.*\0";
            ofn.lpstrFile = szFile;
            ofn.nMaxFile = sizeof(szFile);
            ofn.lpstrTitle = L"Bir Uygulama Seçin";
            ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
    
            if (GetOpenFileName(&ofn)) {
                std::wstring appName = szFile;
                appName = appName.substr(appName.find_last_of(L"\\") + 1);
                AddShortcut(appName, ofn.lpstrFile);
                UpdateMenuHeight();
                InvalidateRect(hwnd, NULL, TRUE);
            }
        }
    };
    
    class TrayApp {
    public:
        TrayApp() : hwnd(nullptr), menu(nullptr) {}
    
        bool Initialize() {
            SetProcessDPIAware();
    
            WNDCLASSEX wc = { sizeof(WNDCLASSEX) };
            wc.lpfnWndProc = WindowProc;
            wc.hInstance = GetModuleHandle(nullptr);
            wc.lpszClassName = L"TrayAppClass";
    
            if (!RegisterClassEx(&wc))
                return false;
    
            hwnd = CreateWindowEx(0, L"TrayAppClass", L"CleanOS Express Launcher", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr, GetModuleHandle(nullptr), this);
            if (!hwnd)
                return false;
    
            if (!ShowTrayIcon()) {
                MessageBox(NULL, L"Failed to create tray icon", L"Error", MB_ICONERROR);
                return false;
            }
    
            menu = std::make_unique<FluentMenu>(hwnd);
            if (!menu->Create())
                return false;
    
            menu->AddShortcut(L"Not Defteri", L"notepad.exe");
            menu->AddShortcut(L"Ekran Alıntısı", L"snippingtool.exe");
            menu->AddShortcut(L"Paint", L"mspaint.exe");
    
            return true;
        }
    
        void Run() {
            MSG msg;
            while (GetMessage(&msg, nullptr, 0, 0)) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
    
    private:
        HWND hwnd;
        std::unique_ptr<FluentMenu> menu;
    
        bool ShowTrayIcon() {
            NOTIFYICONDATA nid = { sizeof(NOTIFYICONDATA) };
            nid.hWnd = hwnd;
            nid.uID = 1;
            nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
            nid.uCallbackMessage = WM_APP_TRAYICON;
            nid.hIcon = LoadIcon(NULL, IDI_APPLICATION);
            wcscpy_s(nid.szTip, L"TrayApp");
            return Shell_NotifyIcon(NIM_ADD, &nid) != FALSE;
        }
    
        static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
            TrayApp* pThis;
            if (uMsg == WM_NCCREATE) {
                pThis = static_cast<TrayApp*>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);
                SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pThis));
            }
            else {
                pThis = reinterpret_cast<TrayApp*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
            }
    
            if (pThis) {
                return pThis->HandleMessage(hwnd, uMsg, wParam, lParam);
            }
    
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
    
        LRESULT HandleMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
            switch (uMsg) {
            case WM_APP_TRAYICON:
                if (lParam == WM_RBUTTONUP) {
                    POINT pt;
                    GetCursorPos(&pt);
                    if (menu) {
                        menu->Show(pt.x, pt.y);
                        SetForegroundWindow(menu->GetHwnd());
                    }
                }
                return 0;
            case WM_DESTROY:
                PostQuitMessage(0);
                return 0;
            }
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
    };
    
    int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR pCmdLine, int nCmdShow) {
        // Initialize GDI+
        Gdiplus::GdiplusStartupInput gdiplusStartupInput;
        ULONG_PTR gdiplusToken;
        if (Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL) != Gdiplus::Ok) {
            MessageBox(NULL, L"GDI+ başlatılamadı", L"Hata", MB_ICONERROR);
            return 1;
        }
    
        TrayApp app;
        if (!app.Initialize()) {
            Gdiplus::GdiplusShutdown(gdiplusToken);
            return 1;
        }
        app.Run();
    
        // Shutdown GDI+
        Gdiplus::GdiplusShutdown(gdiplusToken);
        return 0;
    }
    

    Explanation of Changes:

    • GDI+ Initialization: Added GDI+ initialization in wWinMain using GdiplusStartup and shutdown with GdiplusShutdown.

    • Layered Window: Modified the CreateWindowEx call in FluentMenu::Create to include WS_EX_LAYERED to support per-pixel alpha blending.

    • OnPaint Method: Rewrote OnPaint to use GDI+ for drawing. We create a Gdiplus::Bitmap and a Gdiplus::Graphics object to draw the menu with antialiased rounded corners and text.

    • UpdateLayeredWindow: After drawing the menu onto the bitmap, we use UpdateLayeredWindow to apply the bitmap to the window, ensuring smooth edges and proper transparency.

    • Prevent Flickering: Handled WM_ERASEBKGND message by returning 1 to prevent background erasure, reducing flickering.

    • Foreground Window: Added SetForegroundWindow in TrayApp::HandleMessage when showing the menu to ensure it receives input correctly.

    • GetHwnd Method: Added GetHwnd method in FluentMenu to access the window handle from TrayApp.

    Notes:

    • Make sure to link against Gdiplus.lib when compiling the code.

    • This code should provide smoother rounded corners without jagged edges, as it uses GDI+ for antialiased rendering.

    • I've kept your original logic intact while integrating GDI+ for rendering.

    Compilation Instructions:

    • Use a compiler that supports C++ and Windows API, such as Microsoft Visual Studio.

    • Ensure that GDI+ is properly linked by adding #pragma comment (lib,"Gdiplus.lib") or linking it in your project settings.

    • Compile the code as a Windows application.

    Testing:

    • Run the compiled application. It should display an icon in the system tray.

    • Right-click the tray icon to display the menu. The menu should have smooth rounded corners.

    • Hover over menu items to see the highlight effect.

    • Click on "Kısayol Ekle" to add new shortcuts.

    • Click on "Çıkış" to exit the application.