Window.cpp

// Including some important header files.
#include "Window.h"

#pragma comment(lib, "Build\\Font.lib")

namespace Function
{
    static BOOL GetWindowMaximizedStatus(HWND hWnd)
    {
        // Help to check wether the window is maximized or not.
        WINDOWPLACEMENT placement = {0};
        placement.length = sizeof(WINDOWPLACEMENT);
        if (GetWindowPlacement(hWnd, &placement))
        {
            return placement.showCmd == SW_SHOWMAXIMIZED;
        }

        return FALSE;
    }

    RECT GetButtonRect(RECT windowRect, int buttonWidth, int buttonHeight, int otherButtonDifference)
    {
        RECT buttonRect;
        buttonRect.left = windowRect.right - windowRect.left - buttonWidth - otherButtonDifference;
        buttonRect.right = windowRect.right - windowRect.left - 1 - otherButtonDifference;
        buttonRect.top = 1;
        buttonRect.bottom = buttonHeight + 1;

        return buttonRect;
    }

    HICON __LoadImageFromFile(std::string path)
    {
        // Important for the loading of the icon from a local file.
        HICON image = NULL;
        std::wstring pathWString = std::wstring(path.begin(), path.end());
        const WCHAR *pathWChar = pathWString.c_str();
        Gdiplus::Bitmap bitmap(pathWChar, false);
        bitmap.GetHICON(&image);

        return image;
    }

    void SetCursorF(HCURSOR hCursor)
    {
        SetCursor(hCursor);
    }

    void SetDefaultConfiguration()
    {
        // Setting the default configuration.
        std::ofstream file;
        file.open("TkinterWindow.Config", std::ios::out);

        file << "Width=800" << std::endl;
        file << "Height=600" << std::endl;
        file << "XPosition=";
        file << std::to_string((GetSystemMetrics(SM_CXSCREEN) - 800) / 2) << std::endl;
        file << "YPosition=";
        file << std::to_string((GetSystemMetrics(SM_CYSCREEN) - 600) / 2) << std::endl;
        file << "Theme=RandomTheme" << std::endl;
        file << "WindowStatus=Normal" << std::endl;
    }

    std::string GetConfigurationValue(std::string value)
    {
        // Getting the value from the configuration file.

        std::ifstream existFileCheck("TkinterWindow.Config");

        if (!existFileCheck.is_open())
        {
            SetDefaultConfiguration();
        }
        else
        {
            existFileCheck.close();
        }

        std::ifstream filein("TkinterWindow.Config");

        for (std::string line; std::getline(filein, line);)
        {
            if (line.find(value) != std::string::npos)
            {
                std::string value = line.substr(line.find("=") + 1);
                filein.close();

                return value;
            }
        }

        return "0";
    }

    std::string GetThemeConfigValue(std::string value)
    {
        // Getting the value of the theme.

        std::ifstream themeFile("Themes\\" + GetConfigurationValue("Theme") + "\\" + GetConfigurationValue("Theme") + ".Config", std::ios::in);

        if (!themeFile.is_open())
        {
            MessageBoxA(NULL, "The theme file is not found.", "TkinterWindow", MB_OK | MB_ICONERROR);
            exit(-1);
            return "";
        }

        for (std::string line; std::getline(themeFile, line);)
        {
            if (line.find(value) != std::string::npos)
            {
                std::string value = line.substr(line.find("=") + 1);
                themeFile.close();

                return value;
            }
        }

        if ("Themes\\" + GetConfigurationValue("Theme") + "\\" + GetConfigurationValue("Theme") + ".Config" == "Themes\\RandomTheme.Config")
        {
            return "";
        }
        else
        {
            std::ifstream themeFileD("Themes\\" + GetConfigurationValue("Theme") + "\\" + GetConfigurationValue("Theme") + ".Config", std::ios::in);

            if (!themeFileD.is_open())
            {
                MessageBoxA(NULL, "The theme file is not found.", "TkinterWindow", MB_OK | MB_ICONERROR);
                return "";
            }

            for (std::string line; std::getline(themeFileD, line);)
            {
                if (line.find(value) != std::string::npos)
                {
                    std::string value = line.substr(line.find("=") + 1);
                    themeFileD.close();

                    return value;
                }
            }

            return "";
        }
    }

    COLORREF GetColorFromText(std::string text)
    {
        // Getting the color from the text.

        if (text.find(",") != std::string::npos)
        {
            std::string color = text.substr(text.find("=") + 1);
            std::string red = color.substr(0, color.find(","));
            color.replace(0, color.find(",") + 1, "");
            std::string green = color.substr(0, color.find(","));
            color.replace(0, color.find(",") + 1, "");
            std::string blue = color.substr(0, color.length());
            int redInt = std::stoi(red);
            int greenInt = std::stoi(green);
            int blueInt = std::stoi(blue);

            return RGB(redInt, greenInt, blueInt);
        }

        return RGB(0, 0, 0);
    }

    void LoadThemeData(Function::THEME *theme, HINSTANCE hInstance)
    {
        // Loading the theme data.
        theme->windowBorderFocusColor = GetColorFromText(GetThemeConfigValue("WindowBorderFocusColor"));
        theme->transparentColor = GetColorFromText(GetThemeConfigValue("TransparentColor"));
        theme->windowBackgroundColor = GetColorFromText(GetThemeConfigValue("WindowBackgroundColor"));
        theme->windowBorderUnfocusColor = GetColorFromText(GetThemeConfigValue("WindowBorderUnfocusColor"));
        theme->windowBorderRadius = std::stoi(GetThemeConfigValue("WindowBorderRadius"));
        theme->windowTitleBarBackgroundColor = GetColorFromText(GetThemeConfigValue("WindowTitleBarBackgroundColor"));
        theme->windowFocusIconPath = GetThemeConfigValue("WindowFocusIconPath");
        theme->windowUnfocusIconPath = GetThemeConfigValue("WindowUnfocusIconPath");
        theme->windowTitleBarTextFocusColor = GetColorFromText(GetThemeConfigValue("WindowTitleBarTextFocusColor"));
        theme->windowTitleBarTextUnfocusColor = GetColorFromText(GetThemeConfigValue("WindowTitleBarTextUnfocusColor"));
        theme->windowCloseButtonTextFocusColor = GetColorFromText(GetThemeConfigValue("WindowCloseButtonTextFocusColor"));
        theme->windowCloseButtonTextUnfocusColor = GetColorFromText(GetThemeConfigValue("WindowCloseButtonTextUnfocusColor"));
        theme->windowCloseButtonTextHoverColor = GetColorFromText(GetThemeConfigValue("WindowCloseButtonTextHoverColor"));
        theme->windowCloseButtonBackgroundHoverColor = GetColorFromText(GetThemeConfigValue("WindowCloseButtonBackgroundHoverColor"));
        theme->windowMaximizeButtonTextFocusColor = GetColorFromText(GetThemeConfigValue("WindowMaximizeButtonTextFocusColor"));
        theme->windowMaximizeButtonTextUnfocusColor = GetColorFromText(GetThemeConfigValue("WindowMaximizeButtonTextUnfocusColor"));
        theme->windowMaximizeButtonTextHoverColor = GetColorFromText(GetThemeConfigValue("WindowMaximizeButtonTextHoverColor"));
        theme->windowMaximizeButtonBackgroundHoverColor = GetColorFromText(GetThemeConfigValue("WindowMaximizeButtonBackgroundHoverColor"));
        theme->windowMinimizeButtonTextFocusColor = GetColorFromText(GetThemeConfigValue("WindowMinimizeButtonTextFocusColor"));
        theme->windowMinimizeButtonTextUnfocusColor = GetColorFromText(GetThemeConfigValue("WindowMinimizeButtonTextUnfocusColor"));
        theme->windowMinimizeButtonTextHoverColor = GetColorFromText(GetThemeConfigValue("WindowMinimizeButtonTextHoverColor"));
        theme->windowMinimizeButtonBackgroundHoverColor = GetColorFromText(GetThemeConfigValue("WindowMinimizeButtonBackgroundHoverColor"));
        theme->windowSettingButtonTextFocusColor = GetColorFromText(GetThemeConfigValue("WindowSettingButtonTextFocusColor"));
        theme->windowSettingButtonTextUnfocusColor = GetColorFromText(GetThemeConfigValue("WindowSettingButtonTextUnfocusColor"));
        theme->windowSettingButtonTextHoverColor = GetColorFromText(GetThemeConfigValue("WindowSettingButtonTextHoverColor"));
        theme->windowSettingButtonBackgroundHoverColor = GetColorFromText(GetThemeConfigValue("WindowSettingButtonBackgroundHoverColor"));
        theme->windowCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowTopLeftResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowTopLeftResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowLeftResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowLeftResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowBottomLeftResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowBottomLeftResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowTopResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowTopResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowBottomResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowBottomResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowTopRightResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowTopRightResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowRightResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowRightResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowBottomRightResizeCursor = (HCURSOR)LoadImageA(hInstance, (LPCSTR)Function::GetThemeConfigValue("WindowBottomRightResizeCursor").c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);
        theme->windowStatusBarBackgroundColor = GetColorFromText(GetThemeConfigValue("WindowStatusBarBackgroundColor"));
        theme->windowStatusBarTextFocusColor = GetColorFromText(GetThemeConfigValue("WindowStatusBarTextFocusColor"));
        theme->windowStatusBarTextUnfocusColor = GetColorFromText(GetThemeConfigValue("WindowStatusBarTextUnfocusColor"));
    }

    void WriteDataToConfigurationFile(std::string value, std::string data)
    {
        // Writing data to the configuration file.

        std::ifstream filein("TkinterWindow.Config");
        std::string fileContent;
        std::string line;

        while (std::getline(filein, line))
        {
            if (line.find(value) != std::string::npos)
            {
                line = value + "=" + data;
            }

            fileContent += line + "\n";
        }

        filein.close();

        std::ofstream fileout("TkinterWindow.Config");
        fileout << fileContent;
        fileout.close();
    }
}

namespace TkinterWindow
{
    // [ Starting ] Private Functions.

    LRESULT Window::__WindowProcedure(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        // Assigning the procedure to the class procedure.

        if (message == WM_NCCREATE)
        {
            // Setting the class as user data.

            CREATESTRUCT *lParamStruct = (CREATESTRUCT *)lParam;
            TkinterWindow::Window *lpLabelClass = (TkinterWindow::Window *)lParamStruct->lpCreateParams;
            SetWindowLongPtrA(hWnd, GWLP_USERDATA, (LONG_PTR)lpLabelClass);

            return DefWindowProcA(hWnd, message, wParam, lParam);
        }
        else
        {
            // Getting the class as user data that stored in NC_CREATE.

            TkinterWindow::Window *windowObject = reinterpret_cast<TkinterWindow::Window *>(static_cast<LONG_PTR>(GetWindowLongPtrA(hWnd, GWLP_USERDATA)));

            if (windowObject)
            {
                // Returning and calling to the class procedure.

                return windowObject->__TkinterWindow_WindowProc(hWnd, message, wParam, lParam);
            }
            else
            {
                // Returning and calling to the default window procedure.

                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }

        return 0;
    }

    LRESULT Window::__TkinterWindow_WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        // The procedure of the window.
        switch (message)
        {
        case WM_SETCURSOR:
        {
            // Setting the cursor.
            POINT mousePosition;

            GetCursorPos(&mousePosition);
            ScreenToClient(hWnd, &mousePosition);

            if (Function::GetWindowMaximizedStatus(hWnd))
            {
                Function::SetCursorF(__theme.windowCursor);
            }
            else
            {

                if ((mousePosition.x < 8) && (mousePosition.y < 8))
                {
                    Function::SetCursorF(__theme.windowTopLeftResizeCursor);
                }
                else if ((mousePosition.x > __width - 6) && (mousePosition.y < 6))
                {
                    Function::SetCursorF(__theme.windowTopRightResizeCursor);
                }
                else if ((mousePosition.x > __width - 8) && (mousePosition.y < 8))
                {
                    Function::SetCursorF(__theme.windowTopResizeCursor);
                }
                else if ((mousePosition.y > __height - 8) && (mousePosition.x < 8))
                {
                    Function::SetCursorF(__theme.windowBottomLeftResizeCursor);
                }
                else if ((mousePosition.y > __height - 8) && (mousePosition.x > __width - 8))
                {
                    Function::SetCursorF(__theme.windowBottomRightResizeCursor);
                }
                else if (mousePosition.x < 3)
                {
                    Function::SetCursorF(__theme.windowLeftResizeCursor);
                }
                else if (mousePosition.x > __width - 4)
                {
                    Function::SetCursorF(__theme.windowRightResizeCursor);
                }
                else if (mousePosition.y < 3)
                {
                    Function::SetCursorF(__theme.windowTopResizeCursor);
                }
                else if (mousePosition.y > __height - 4)
                {
                    Function::SetCursorF(__theme.windowBottomResizeCursor);
                }
                else
                {
                    Function::SetCursorF(__theme.windowCursor);
                }
            }

            return TRUE;
        }

        case WM_PAINT:
        {
            // Painting the window.
            PAINTSTRUCT ps;
            HDC hDC = BeginPaint(hWnd, &ps);

            // Getting about the focus.
            bool isFocused = !!GetFocus();

            // Getting the window size.
            RECT windowRect;
            GetWindowRect(hWnd, &windowRect);

            int width = windowRect.right - windowRect.left;
            int height = windowRect.bottom - windowRect.top;

            // Painting the background with transparent color.
            HBRUSH transparentBrush = CreateSolidBrush(__theme.transparentColor);
            FillRect(hDC, &ps.rcPaint, transparentBrush);
            DeleteObject(transparentBrush);

            // The difference between maximized window and normal window
            if (Function::GetWindowMaximizedStatus(hWnd))
            {
                __differenceX = 8;
                __differenceY = 8;
                __widthDifference = 8;
                __heightDifference = 8;
            }
            else
            {
                __differenceX = 0;
                __differenceY = 0;
                __widthDifference = 0;
                __heightDifference = 0;
            }

            // Painting the border and the background with the accurate color.
            HBRUSH backgroundBrush = CreateSolidBrush(__theme.windowBackgroundColor);
            HPEN borderPen;

            if (isFocused)
            {
                borderPen = CreatePen(PS_SOLID, 1, __theme.windowBorderFocusColor);
            }
            else
            {
                borderPen = CreatePen(PS_SOLID, 1, __theme.windowBorderUnfocusColor);
            }

            SelectObject(hDC, backgroundBrush);
            SelectObject(hDC, borderPen);
            RoundRect(hDC, ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom, __theme.windowBorderRadius, __theme.windowBorderRadius);
            DeleteObject(backgroundBrush);
            DeleteObject(borderPen);

            // Painting the title bar.
            HBRUSH titleBarBrush = CreateSolidBrush(__theme.windowTitleBarBackgroundColor);
            HPEN titleBarPen = CreatePen(PS_SOLID, 1, __theme.windowTitleBarBackgroundColor);
            SelectObject(hDC, titleBarBrush);
            RoundRect(hDC, 0, 0, width, __titleBarHeight, __theme.windowBorderRadius, __theme.windowBorderRadius);

            SelectObject(hDC, titleBarPen);
            Rectangle(hDC, 1 - __differenceX, 10 - __differenceY, width - 1 + __widthDifference, __titleBarHeight + __heightDifference);
            DeleteObject(titleBarPen);
            DeleteObject(titleBarBrush);

            // Drawing the icon.
            if (isFocused)
            {
                HICON icon = Function::__LoadImageFromFile(__theme.windowFocusIconPath);
                DrawIconEx(hDC, 10 + __differenceX, 5 + __differenceY, icon, 20, 20, 0, NULL, DI_NORMAL);
            }
            else
            {
                HICON icon = Function::__LoadImageFromFile(__theme.windowUnfocusIconPath);
                DrawIconEx(hDC, 10 + __differenceX, 5 + __differenceY, icon, 20, 20, 0, NULL, DI_NORMAL);
            }

            // Drawing the title.
            SetBkMode(hDC, TRANSPARENT);
            if (isFocused)
            {
                SetTextColor(hDC, __theme.windowTitleBarTextFocusColor);
            }
            else
            {
                SetTextColor(hDC, __theme.windowTitleBarTextUnfocusColor);
            }

            __titleTextFont.SetFontSize(16);
            __titleTextFont.GetFontObject(hDC);

            RECT titleTextRect;
            titleTextRect.left = 35 + __differenceX;
            titleTextRect.top = 1 + __differenceY;
            titleTextRect.right = width - 1 + __widthDifference;
            titleTextRect.bottom = __titleBarHeight + __heightDifference;

            DrawTextA(hDC, __windowTitle.c_str(), __windowTitle.length(), &titleTextRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
            __titleTextFont.DeleteFontObject();

            // Drawing the buttons of the window.
            __buttonState.isAllButtonPaint = false;
            SendMessageA(hWnd, WM_NCMOUSEMOVE, NULL, NULL);

            // Drawing the status bar.
            SetBkMode(hDC, TRANSPARENT);
            if (isFocused)
            {
                SetTextColor(hDC, __theme.windowStatusBarTextFocusColor);
            }
            else
            {
                SetTextColor(hDC, __theme.windowStatusBarTextUnfocusColor);
            }

            HBRUSH statusBarBrush = CreateSolidBrush(__theme.windowStatusBarBackgroundColor);
            HPEN statusBarPenB = CreatePen(PS_SOLID, 1, __theme.windowStatusBarBackgroundColor);
            HPEN statusBarPen;

            if (isFocused)
            {
                statusBarPen = CreatePen(PS_SOLID, 1, __theme.windowBorderFocusColor);
            }
            else
            {
                statusBarPen = CreatePen(PS_SOLID, 1, __theme.windowBorderUnfocusColor);
            }
            __statusBarTextFont.GetFontObject(hDC);
            SelectObject(hDC, statusBarPen);
            SelectObject(hDC, statusBarBrush);
            __heightDifference -= 1;
            RoundRect(hDC, 0, height - __statusBarHeight - __heightDifference, width - 1, height - 1, __theme.windowBorderRadius, __theme.windowBorderRadius);
            DeleteObject(statusBarPen);
            SelectObject(hDC, statusBarPenB);
            Rectangle(hDC, 1, height - __statusBarHeight - __heightDifference, width - 2, height - 10);
            DeleteObject(statusBarPenB);
            DeleteObject(statusBarBrush);

            __heightDifference += 1;

            RECT statusBarRect;
            statusBarRect.left = 10 + __differenceX;
            statusBarRect.right = width - 10 - __widthDifference;
            statusBarRect.top = height - __statusBarHeight - __heightDifference;
            statusBarRect.bottom = height - 1 - __heightDifference;
            DrawTextA(hDC, __statusBarText.c_str(), __statusBarText.length(), &statusBarRect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
            __statusBarTextFont.DeleteFontObject();

            EndPaint(hWnd, &ps);
            break;
        }

        case WM_NCMOUSEMOVE:
        {
            // controlling the hovering functionalities of the buttons.
            POINT cursorPoint;
            GetCursorPos(&cursorPoint);
            ScreenToClient(hWnd, &cursorPoint);

            RECT windowRect;
            GetWindowRect(hWnd, &windowRect);

            // The difference between maximized window and normal window
            if (Function::GetWindowMaximizedStatus(hWnd))
            {
                __differenceX = 8;
                __differenceY = 8;
                __widthDifference = 8;
                __heightDifference = 8;
            }
            else
            {
                __differenceX = 0;
                __differenceY = 0;
                __widthDifference = 0;
                __heightDifference = 0;
            }

            bool coloringTop = false;
            bool coloringTopRight = false;

            if (!Function::GetWindowMaximizedStatus(hWnd))
            {
                if ((cursorPoint.x > __width - 6) && (cursorPoint.y < 6))
                {
                    coloringTopRight = true;
                }
                else if (cursorPoint.x > __width - 4)
                {
                    coloringTopRight = true;
                }
                else if (cursorPoint.y < 3)
                {
                    coloringTopRight = true;
                    coloringTop = true;
                }
            }

            // Difference in the paint and move getting.
            windowRect.right += 1;
            windowRect.top += 1;

            HDC hDC = GetDC(hWnd);

            // Checking for the close button hovering.
            if ((PtInRect(&Function::GetButtonRect(windowRect, 45, __titleBarHeight + __differenceY, 0 + __widthDifference), cursorPoint)) && (coloringTopRight == false))
            {
                if (!__buttonState.isCloseButtonHover)
                {
                    __buttonState.isCloseButtonHover = true;
                    __DrawCloseButton(hDC, windowRect, 45, __titleBarHeight);
                }
            }
            else
            {
                if ((__buttonState.isCloseButtonHover) || (!__buttonState.isAllButtonPaint))
                {
                    __buttonState.isCloseButtonHover = false;
                    __DrawCloseButton(hDC, windowRect, 45, __titleBarHeight);
                }
            }

            // checking for the maximize button hovering.
            if ((PtInRect(&Function::GetButtonRect(windowRect, 42, __titleBarHeight + __differenceY, 45 + __widthDifference), cursorPoint)) && (coloringTop == false))
            {
                if (!__buttonState.isMaximizeButtonHover)
                {
                    __buttonState.isMaximizeButtonHover = true;
                    __DrawMaximizeButton(hDC, windowRect, 42, __titleBarHeight);
                }
            }
            else
            {
                if ((__buttonState.isMaximizeButtonHover) || (!__buttonState.isAllButtonPaint))
                {
                    __buttonState.isMaximizeButtonHover = false;
                    __DrawMaximizeButton(hDC, windowRect, 42, __titleBarHeight);
                }
            }

            // checking for the minimize button hovering.
            if ((PtInRect(&Function::GetButtonRect(windowRect, 42, __titleBarHeight + __differenceY, 87 + __widthDifference), cursorPoint)) && (coloringTop == false))
            {
                if (!__buttonState.isMinimizeButtonHover)
                {
                    __buttonState.isMinimizeButtonHover = true;
                    __DrawMinimizeButton(hDC, windowRect, 42, __titleBarHeight);
                }
            }
            else
            {
                if ((__buttonState.isMinimizeButtonHover) || (!__buttonState.isAllButtonPaint))
                {
                    __buttonState.isMinimizeButtonHover = false;
                    __DrawMinimizeButton(hDC, windowRect, 42, __titleBarHeight);
                }
            }

            // checking for the menu button hovering.
            if ((PtInRect(&Function::GetButtonRect(windowRect, 42, __titleBarHeight + __differenceY, 129 + __widthDifference), cursorPoint)) && (coloringTop == false))
            {
                if (!__buttonState.isSettingButtonHover)
                {
                    __buttonState.isSettingButtonHover = true;
                    __DrawSettingButton(hDC, windowRect, 42, __titleBarHeight);
                }
            }
            else
            {
                if ((__buttonState.isSettingButtonHover) || (!__buttonState.isAllButtonPaint))
                {
                    __buttonState.isSettingButtonHover = false;
                    __DrawSettingButton(hDC, windowRect, 42, __titleBarHeight);
                }
            }

            __buttonState.isAllButtonPaint = true;
            coloringTop = false;
            coloringTopRight = false;

            ReleaseDC(hWnd, hDC);

            break;
        }

        case WM_NCHITTEST:
        {
            // Making the window draggable and resizable.
            LRESULT hit = DefWindowProcA(hWnd, message, wParam, lParam);

            if (hit == HTNOWHERE)
            {
                return hit;
            }

            POINT mousePosition;

            GetCursorPos(&mousePosition);
            ScreenToClient(hWnd, &mousePosition);

            if ((mousePosition.x > 8) && (mousePosition.x < 30) && (mousePosition.y > 5) && (mousePosition.y < 30 + __differenceY))
            {
                return HTMENU;
            }
            else if ((mousePosition.x < 8) && (mousePosition.y < 8))
            {
                return HTTOPLEFT;
            }
            else if ((mousePosition.x > __width - 6) && (mousePosition.y < 6))
            {
                return HTTOPRIGHT;
            }
            else if ((mousePosition.y > __height - 8) && (mousePosition.x < 8))
            {
                return HTBOTTOMLEFT;
            }
            else if ((mousePosition.y > __height - 8) && (mousePosition.x > __width - 8))
            {
                return HTBOTTOMRIGHT;
            }
            else if ((mousePosition.y > 3) && (mousePosition.y < 31 + __differenceY) && (mousePosition.x > 3) && (mousePosition.x < __width - 3))
            {
                return HTCAPTION;
            }
            else if (mousePosition.x < 3)
            {
                return HTLEFT;
            }
            else if (mousePosition.x > __width - 4)
            {
                return HTRIGHT;
            }
            else if (mousePosition.y < 3)
            {
                return HTTOP;
            }
            else if (mousePosition.y > __height - 4)
            {
                return HTBOTTOM;
            }
            else if (__buttonState.isMaximizeButtonHover)
            {
                return HTMAXBUTTON;
            }
            else if (__buttonState.isCloseButtonHover)
            {
                return HTCLOSE;
            }
            else if (__buttonState.isMinimizeButtonHover)
            {
                return HTMINBUTTON;
            }
            else
            {
                return HTCLIENT;
            }

            break;
        }

        case WM_NCLBUTTONUP:
        {
            if (__buttonState.isCloseButtonHover)
            {
                SendMessageA(hWnd, WM_CLOSE, NULL, NULL);
            }
            else if (__buttonState.isMaximizeButtonHover)
            {
                if (Function::GetWindowMaximizedStatus(hWnd))
                {
                    ShowWindow(hWnd, SW_NORMAL);
                }
                else
                {
                    ShowWindow(hWnd, SW_MAXIMIZE);
                }
            }
            else if (__buttonState.isMinimizeButtonHover)
            {
                ShowWindow(hWnd, SW_MINIMIZE);
            }
            else if (__buttonState.isSettingButtonHover)
            {
            }

            break;
        }

        case WM_KILLFOCUS:
        {
            // Repainting the whole window.
            __RePaintWindow();

            break;
        }

        case WM_SETFOCUS:
        {
            // Repainting the whole window.
            __RePaintWindow();

            break;
        }

        case WM_EXITSIZEMOVE:
        {
            // Resizing the window.
            RECT windowRect;
            GetWindowRect(hWnd, &windowRect);

            __width = windowRect.right - windowRect.left;
            __height = windowRect.bottom - windowRect.top;
            __xPosition = windowRect.left;
            __yPosition = windowRect.top;

            Function::WriteDataToConfigurationFile("Width", std::to_string(__width));
            Function::WriteDataToConfigurationFile("Height", std::to_string(__height));
            Function::WriteDataToConfigurationFile("XPosition", std::to_string(__xPosition));
            Function::WriteDataToConfigurationFile("YPosition", std::to_string(__yPosition));

            // Setting the pixels to transparent.
            SetLayeredWindowAttributes(hWnd, __theme.transparentColor, 255, LWA_COLORKEY);
            break;
        }

        case WM_ENTERSIZEMOVE:
        {
            // Setting pixels to visible in order to get rid of fluckkerings.
            SetLayeredWindowAttributes(hWnd, 0, 255, LWA_ALPHA);
            break;
        }

        case WM_NCLBUTTONDOWN:
        {
            // Checking for the button hover state.
            if ((__buttonState.isCloseButtonHover) || (__buttonState.isMaximizeButtonHover) || (__buttonState.isMinimizeButtonHover) || (__buttonState.isSettingButtonHover))
            {
                return 0;
            }

            break;
        }

        case WM_MOUSEMOVE:
        {
            // Checking for Enter and Leave events.
            TRACKMOUSEEVENT tme;
            tme.cbSize = sizeof(TRACKMOUSEEVENT);
            tme.dwFlags = TME_HOVER | TME_LEAVE;
            tme.dwHoverTime = 1;
            tme.hwndTrack = hWnd;
            TrackMouseEvent(&tme);

            if (__buttonState.isSettingButtonHover)
            {
                POINT cursorPoint;
                GetCursorPos(&cursorPoint);
                ScreenToClient(hWnd, &cursorPoint);

                RECT windowRect;
                GetWindowRect(hWnd, &windowRect);

                // Difference in the paint and move getting.
                windowRect.right += 1;
                windowRect.top += 1;

                HDC hDC = GetDC(hWnd);

                __buttonState.isSettingButtonHover = false;
                __DrawSettingButton(hDC, windowRect, 42, __titleBarHeight);

                ReleaseDC(hWnd, hDC);
            }

            break;
        }

        case WM_DESTROY:
        {
            // Destroying the window.
            PostQuitMessage(0);
            return 0;
            break;
        }

        case WM_CLOSE:
        {
            // Closing the window.
            DestroyWindow(hWnd);

            // Checking if the window is in full screen mode.
            if (__isFullScreen)
            {
                HWND taskBar = FindWindowA("Shell_TrayWnd", NULL);
                HWND startButton = FindWindowA("Button", NULL);

                ShowWindow(taskBar, SW_SHOW);
                ShowWindow(startButton, SW_SHOW);
            }

            break;
        }

        case WM_NCMOUSELEAVE:
        {
            // Checking for the unhovering of the button.
            if ((__buttonState.isCloseButtonHover) || (__buttonState.isMaximizeButtonHover) || (__buttonState.isMinimizeButtonHover) || (__buttonState.isSettingButtonHover))
            {
                __RePaintWindow();
            }

            break;
        }

        case WM_KEYDOWN:
        {
            // Key down event.
            if (wParam == VK_F11)
            {
                HWND taskBar = FindWindowA("Shell_TrayWnd", NULL);
                HWND startButton = FindWindowA("Button", NULL);

                if (__isFullScreen)
                {
                    // Setting the window to normal.
                    ShowWindow(taskBar, SW_SHOW);
                    ShowWindow(startButton, SW_SHOW);
                    SetWindowPos(hWnd, NULL, __previousXPosition, __previousYPosition, __previousWidth, __previousHeight, SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
                    SetFocus(hWnd);
                    SetWindowBorderRadius(__previouseBorderRadius);
                    __isFullScreen = false;
                }
                else
                {
                    // Setting the window to full screen.
                    ShowWindow(taskBar, SW_HIDE);
                    ShowWindow(startButton, SW_HIDE);

                    __previousWidth = __width;
                    __previousHeight = __height;
                    __previousXPosition = __xPosition;
                    __previousYPosition = __yPosition;
                    __previouseBorderRadius = __theme.windowBorderRadius;

                    // Getting the screen size.
                    MONITORINFO monitorInformation;
                    monitorInformation.cbSize = sizeof(monitorInformation);
                    GetMonitorInfo(MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST),
                                   &monitorInformation);
                    RECT monitorSizeRect = monitorInformation.rcMonitor;
                    SetWindowPos(hWnd, NULL, monitorSizeRect.left - 1, monitorSizeRect.top - 1, monitorSizeRect.right - monitorSizeRect.left + 2, monitorSizeRect.bottom - monitorSizeRect.top + 2, SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
                    SetWindowBorderRadius(0);
                    __isFullScreen = true;
                }
            }

            break;
        }

        case WM_CREATE:
        {
            // Extending the client area.
            RECT sizeRect;

            GetWindowRect(hWnd, &sizeRect);
            SetWindowPos(hWnd, NULL, 0, 0, sizeRect.right - sizeRect.left, sizeRect.bottom - sizeRect.top, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE);

            break;
        }

        case WM_ERASEBKGND:
        {
            // Removing the background.
            return 1;
        }

        case WM_NCCALCSIZE:
        {
            // Removing the border.
            return 0;

            break;
        }

        case WM_SIZE:
        {
            // Saving the state of the window.
            if (wParam == SIZE_MAXIMIZED)
            {
                Function::WriteDataToConfigurationFile("WindowStatus", "Maximized");
            }
            else if (wParam == SIZE_MINIMIZED)
            {
                Function::WriteDataToConfigurationFile("WindowStatus", "Minimized");
            }
            else if (wParam == SIZE_RESTORED)
            {
                Function::WriteDataToConfigurationFile("WindowStatus", "Normal");
            }

            break;
        }

        default:
        {
            break;
        }
        }

        return DefWindowProcA(hWnd, message, wParam, lParam);
    }

    void Window::__RePaintWindow()
    {
        // Repainting the window.
        if (__windowHandle != NULL)
        {
            SendMessageA(__windowHandle, WM_SIZE, NULL, NULL);
            InvalidateRect(__windowHandle, NULL, TRUE);
            UpdateWindow(__windowHandle);
        }
    }

    void Window::__DrawCloseButton(HDC hDC, RECT windowRect, int buttonWidth, int buttonHeight)
    {
        // Drawing the close button.

        bool isFocused = !!GetFocus();

        // Checking if the button is hovered or not.
        HBRUSH backgroundBrush;
        HPEN backgroundPen;

        if (__buttonState.isCloseButtonHover)
        {
            // Filling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowCloseButtonBackgroundHoverColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowCloseButtonBackgroundHoverColor);
        }
        else
        {
            // Unfilling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowTitleBarBackgroundColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowTitleBarBackgroundColor);
        }

        HPEN borderPen;

        if (isFocused)
        {
            borderPen = CreatePen(PS_SOLID, 1, __theme.windowBorderFocusColor);
        }
        else
        {
            borderPen = CreatePen(PS_SOLID, 1, __theme.windowBorderUnfocusColor);
        }

        SelectObject(hDC, borderPen);
        SelectObject(hDC, backgroundBrush);
        RoundRect(hDC, windowRect.right - windowRect.left - buttonWidth - 1 - __widthDifference, 0 - __heightDifference, windowRect.right - windowRect.left - 1 + __widthDifference, buttonHeight - 1 + __heightDifference, __theme.windowBorderRadius, __theme.windowBorderRadius);
        DeleteObject(borderPen);
        SelectObject(hDC, backgroundPen);
        Rectangle(hDC, windowRect.right - windowRect.left - buttonWidth - 1 - __widthDifference, 10 - __heightDifference, windowRect.right - windowRect.left - 2 + __widthDifference, buttonHeight - 1 + __heightDifference);
        Rectangle(hDC, windowRect.right - windowRect.left - buttonWidth - 1 - __widthDifference, 1 - __heightDifference, windowRect.right - windowRect.left - 10 + __widthDifference, buttonHeight - 1 + __heightDifference);
        DeleteObject(backgroundBrush);
        DeleteObject(backgroundPen);

        int red, green, blue;

        if (__buttonState.isCloseButtonHover)
        {
            red = GetRValue(__theme.windowCloseButtonTextHoverColor);
            green = GetGValue(__theme.windowCloseButtonTextHoverColor);
            blue = GetBValue(__theme.windowCloseButtonTextHoverColor);
        }
        else
        {
            if (isFocused)
            {
                red = GetRValue(__theme.windowCloseButtonTextFocusColor);
                green = GetGValue(__theme.windowCloseButtonTextFocusColor);
                blue = GetBValue(__theme.windowCloseButtonTextFocusColor);
            }
            else
            {
                red = GetRValue(__theme.windowCloseButtonTextUnfocusColor);
                green = GetGValue(__theme.windowCloseButtonTextUnfocusColor);
                blue = GetBValue(__theme.windowCloseButtonTextUnfocusColor);
            }
        }

        Gdiplus::Graphics graphics(hDC);

        Gdiplus::Pen transparentPen(Gdiplus::Color(150, red, green, blue), 1);
        Gdiplus::Pen pen(Gdiplus::Color(255, red, green, blue), 1);

        if (Function::GetWindowMaximizedStatus(__windowHandle))
        {
            __heightDifference -= 1;
        }

        int x = windowRect.right - windowRect.left - buttonWidth + 17 - __widthDifference;
        int y = buttonHeight - 19 + __heightDifference;

        if (Function::GetWindowMaximizedStatus(__windowHandle))
        {
            __heightDifference += 1;
        }

        // Drawing lines
        graphics.DrawLine(&transparentPen, x + 1, y, x + 9, y + 8);
        graphics.DrawLine(&transparentPen, x, y + 1, x + 8, y + 9);
        graphics.DrawLine(&transparentPen, x + 9, y + 1, x + 1, y + 9);
        graphics.DrawLine(&transparentPen, x + 8, y, x, y + 8);

        // Drawing lines
        graphics.DrawLine(&pen, x, y, x + 9, y + 9);
        graphics.DrawLine(&pen, x + 9, y, x, y + 9);
    }

    void Window::__DrawMaximizeButton(HDC hDC, RECT windowRect, int buttonWidth, int buttonHeight)
    {
        // Helps to draw the maximize button.

        bool isFocused = !!GetFocus();
        int red, green, blue;

        HBRUSH backgroundBrush;
        HPEN backgroundPen;

        if (__buttonState.isMaximizeButtonHover)
        {
            // Filling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowMaximizeButtonBackgroundHoverColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowMaximizeButtonBackgroundHoverColor);
        }
        else
        {
            // Unfilling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowTitleBarBackgroundColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowTitleBarBackgroundColor);
        }

        SelectObject(hDC, backgroundBrush);
        SelectObject(hDC, backgroundPen);
        Rectangle(hDC, windowRect.right - windowRect.left - buttonWidth - 1 - __widthDifference - 45, 1 - __heightDifference, windowRect.right - windowRect.left - 2 - __widthDifference - 45, buttonHeight - 1 + __heightDifference);
        DeleteObject(backgroundBrush);
        DeleteObject(backgroundPen);

        int x = windowRect.right - windowRect.left - buttonWidth + 17 - __widthDifference - 47;
        int y = buttonHeight - 19 + __heightDifference;

        if (__buttonState.isMaximizeButtonHover)
        {
            red = GetRValue(__theme.windowMaximizeButtonTextHoverColor);
            green = GetGValue(__theme.windowMaximizeButtonTextHoverColor);
            blue = GetBValue(__theme.windowMaximizeButtonTextHoverColor);
        }
        else
        {
            if (isFocused)
            {
                red = GetRValue(__theme.windowMaximizeButtonTextFocusColor);
                green = GetGValue(__theme.windowMaximizeButtonTextFocusColor);
                blue = GetBValue(__theme.windowMaximizeButtonTextFocusColor);
            }
            else
            {
                red = GetRValue(__theme.windowMaximizeButtonTextUnfocusColor);
                green = GetGValue(__theme.windowMaximizeButtonTextUnfocusColor);
                blue = GetBValue(__theme.windowMaximizeButtonTextUnfocusColor);
            }
        }

        Gdiplus::Graphics graphics(hDC);

        Gdiplus::Pen transparentPen(Gdiplus::Color(70, red, green, blue), 1);
        Gdiplus::Pen pen(Gdiplus::Color(255, red, green, blue), 1);

        if (Function::GetWindowMaximizedStatus(__windowHandle))
        {
            graphics.DrawLine(&transparentPen, x, y, x + 7, y);
            graphics.DrawLine(&transparentPen, x, y, x, y + 7);
            graphics.DrawLine(&transparentPen, x + 7, y, x + 7, y + 7);
            graphics.DrawLine(&transparentPen, x, y + 7, x + 7, y + 7);
            graphics.DrawLine(&transparentPen, x + 2, y - 2, x + 8, y - 2);
            graphics.DrawLine(&transparentPen, x + 8, y - 1, x + 9, y - 1);
            graphics.DrawLine(&transparentPen, x + 9, y, x + 9, y + 5);

            graphics.DrawLine(&pen, x + 1, y, x + 6, y);
            graphics.DrawLine(&pen, x, y + 1, x, y + 6);
            graphics.DrawLine(&pen, x + 7, y + 1, x + 7, y + 6);
            graphics.DrawLine(&pen, x + 1, y + 7, x + 6, y + 7);
            graphics.DrawLine(&pen, x + 3, y - 2, x + 7, y - 2);
            SetPixel(hDC, x + 8, y - 1, RGB(red, green, blue));
            graphics.DrawLine(&pen, x + 9, y, x + 9, y + 4);
        }
        else
        {
            graphics.DrawLine(&transparentPen, x, y, x + 9, y);
            graphics.DrawLine(&transparentPen, x, y, x, y + 9);
            graphics.DrawLine(&transparentPen, x + 9, y, x + 9, y + 9);
            graphics.DrawLine(&transparentPen, x, y + 9, x + 9, y + 9);

            // Drawing lines
            graphics.DrawLine(&pen, x + 1, y, x + 8, y);
            graphics.DrawLine(&pen, x, y + 1, x, y + 8);
            graphics.DrawLine(&pen, x + 9, y + 1, x + 9, y + 8);
            graphics.DrawLine(&pen, x + 1, y + 9, x + 8, y + 9);
        }
    }

    void Window::__DrawMinimizeButton(HDC hDC, RECT windowRect, int buttonWidth, int buttonHeight)
    {
        // Helps to draw the minimize button.

        bool isFocused = !!GetFocus();
        int red, green, blue;

        HBRUSH backgroundBrush;
        HPEN backgroundPen;

        if (__buttonState.isMinimizeButtonHover)
        {
            // Filling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowMinimizeButtonBackgroundHoverColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowMinimizeButtonBackgroundHoverColor);
        }
        else
        {
            // Unfilling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowTitleBarBackgroundColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowTitleBarBackgroundColor);
        }

        SelectObject(hDC, backgroundBrush);
        SelectObject(hDC, backgroundPen);
        Rectangle(hDC, windowRect.right - windowRect.left - buttonWidth - 1 - __widthDifference - 87, 1 - __heightDifference, windowRect.right - windowRect.left - 2 - __widthDifference - 87, buttonHeight - 1 + __heightDifference);
        DeleteObject(backgroundBrush);
        DeleteObject(backgroundPen);

        int x = windowRect.right - windowRect.left - buttonWidth + 17 - __widthDifference - 90;
        int y = buttonHeight - 19 + __heightDifference + 4;

        if (__buttonState.isMinimizeButtonHover)
        {
            red = GetRValue(__theme.windowMinimizeButtonTextHoverColor);
            green = GetGValue(__theme.windowMinimizeButtonTextHoverColor);
            blue = GetBValue(__theme.windowMinimizeButtonTextHoverColor);
        }
        else
        {
            if (isFocused)
            {
                red = GetRValue(__theme.windowMinimizeButtonTextFocusColor);
                green = GetGValue(__theme.windowMinimizeButtonTextFocusColor);
                blue = GetBValue(__theme.windowMinimizeButtonTextFocusColor);
            }
            else
            {
                red = GetRValue(__theme.windowMinimizeButtonTextUnfocusColor);
                green = GetGValue(__theme.windowMinimizeButtonTextUnfocusColor);
                blue = GetBValue(__theme.windowMinimizeButtonTextUnfocusColor);
            }
        }

        Gdiplus::Graphics graphics(hDC);

        Gdiplus::Pen pen(Gdiplus::Color(255, red, green, blue), 1);

        graphics.DrawLine(&pen, x + 1, y, x + 10, y);
    }

    void Window::__DrawSettingButton(HDC hDC, RECT windowRect, int buttonWidth, int buttonHeight)
    {
        // Helps to draw the setting button.

        bool isFocused = !!GetFocus();
        int red, green, blue;

        HBRUSH backgroundBrush;
        HPEN backgroundPen;

        if (__buttonState.isSettingButtonHover)
        {
            // Filling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowSettingButtonBackgroundHoverColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowSettingButtonBackgroundHoverColor);
        }
        else
        {
            // Unfilling the button rectangle.
            backgroundBrush = CreateSolidBrush(__theme.windowTitleBarBackgroundColor);
            backgroundPen = CreatePen(PS_SOLID, 1, __theme.windowTitleBarBackgroundColor);
        }

        SelectObject(hDC, backgroundBrush);
        SelectObject(hDC, backgroundPen);
        Rectangle(hDC, windowRect.right - windowRect.left - buttonWidth - 1 - __widthDifference - 129, 1 - __heightDifference, windowRect.right - windowRect.left - 2 - __widthDifference - 129, buttonHeight - 1 + __heightDifference);
        DeleteObject(backgroundBrush);
        DeleteObject(backgroundPen);

        int x = windowRect.right - windowRect.left - buttonWidth + 17 - __widthDifference - 132;
        int y = buttonHeight - 20 + __heightDifference;

        if (__buttonState.isSettingButtonHover)
        {
            red = GetRValue(__theme.windowSettingButtonTextHoverColor);
            green = GetGValue(__theme.windowSettingButtonTextHoverColor);
            blue = GetBValue(__theme.windowSettingButtonTextHoverColor);
        }
        else
        {
            if (isFocused)
            {
                red = GetRValue(__theme.windowSettingButtonTextFocusColor);
                green = GetGValue(__theme.windowSettingButtonTextFocusColor);
                blue = GetBValue(__theme.windowSettingButtonTextFocusColor);
            }
            else
            {
                red = GetRValue(__theme.windowSettingButtonTextUnfocusColor);
                green = GetGValue(__theme.windowSettingButtonTextUnfocusColor);
                blue = GetBValue(__theme.windowSettingButtonTextUnfocusColor);
            }
        }

        Gdiplus::Graphics graphics(hDC);

        Gdiplus::Pen pen(Gdiplus::Color(255, red, green, blue), 1);

        graphics.DrawLine(&pen, x, y, x + 11, y);
        graphics.DrawLine(&pen, x, y + 5, x + 11, y + 5);
        graphics.DrawLine(&pen, x, y + 10, x + 11, y + 10);
    }

    // [ Ending ] Private Functions.

    // *********************************************************************************************************************
    // *********************************************************************************************************************

    // [ Starting ] Public Functions.

    // [ Starting ] Main Functions.
    bool Window::InitializeWindow(HINSTANCE hInstance, std::string sWindowClassName)
    {
        // Helps to initialize the window and set some important stuff.

        // Setting some variables
        __hInstance = hInstance;
        __windowClassName = sWindowClassName;

        // Loading Default Values.
        if (__xPosition == NULL)
        {
            __xPosition = std::stoi(Function::GetConfigurationValue("XPosition"));
        }

        if (__yPosition == NULL)
        {
            __yPosition = std::stoi(Function::GetConfigurationValue("YPosition"));
        }

        if (__width == NULL)
        {
            __width = std::stoi(Function::GetConfigurationValue("Width"));
        }

        if (__height == NULL)
        {
            __height = std::stoi(Function::GetConfigurationValue("Height"));
        }

        if (__windowIcon == "")
        {
            __windowIcon = Function::GetThemeConfigValue("WindowTaskBarIcon");
        }

        // Loading the theme data.
        Function::LoadThemeData(&__theme, __hInstance);

        // Initializing GDI+
        Gdiplus::GdiplusStartup(&__gdiplusToken, &__gdiplusStartupInput, NULL);

        // Setting some font styles.
        __titleTextFont.SetFontStyle("Segoe UI");
        __titleTextFont.SetFontSize(16);
        __titleTextFont.SetFontWeight(400);

        __statusBarTextFont.SetFontStyle("Segoe UI");
        __statusBarTextFont.SetFontSize(14);
        __statusBarTextFont.SetFontWeight(400);

        // Setting up the window class
        __windowClass.cbSize = sizeof(__windowClass);
        __windowClass.style = CS_HREDRAW | CS_VREDRAW;
        __windowClass.lpfnWndProc = __WindowProcedure;
        __windowClass.cbClsExtra = 0;
        __windowClass.cbWndExtra = 0;
        __windowClass.hInstance = __hInstance;

        // Checking if the window icon is set or not.
        if (__windowIcon != "")
        {
            __windowClass.hIcon = Function::__LoadImageFromFile(__windowIcon);
            __windowClass.hIconSm = Function::__LoadImageFromFile(__windowIcon);
        }
        else
        {
            __windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
            __windowClass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
        }

        __windowClass.hCursor = __theme.windowCursor;
        __windowClass.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
        __windowClass.lpszMenuName = NULL;
        __windowClass.lpszClassName = __windowClassName.c_str();

        // Registering the window class
        if (!RegisterClassExA(&__windowClass))
        {
            return false;
        }

        // Creating the window
        __windowHandle = CreateWindowExA(WS_EX_APPWINDOW | WS_EX_LAYERED, __windowClassName.c_str(), __windowTitle.c_str(), WS_OVERLAPPEDWINDOW, __xPosition, __yPosition, __width, __height, NULL, NULL, __hInstance, this);

        // Checking for the error
        if (!__windowHandle)
        {
            return false;
        }

        self = __windowHandle;
        Self = __windowHandle;

        SetLayeredWindowAttributes(__windowHandle, __theme.transparentColor, 255, LWA_COLORKEY);

        // Showing the window
        std::string status = Function::GetConfigurationValue("WindowStatus");
        if (status == "Normal")
        {
            ShowWindow(__windowHandle, SW_NORMAL);
        }
        else if (status == "Maximized")
        {
            ShowWindow(__windowHandle, SW_SHOWMAXIMIZED);
        }
        else if (status == "Minimized")
        {
            ShowWindow(__windowHandle, SW_SHOWMINIMIZED);
        }
        else
        {
            ShowWindow(__windowHandle, SW_SHOW);
        }

        return true;
    }

    bool Window::StartMainLoop(int nMax, int nMin)
    {
        // Helps to start the main loop of the window.

        while (GetMessageA(&__msg, NULL, nMin, nMax))
        {
            TranslateMessage(&__msg);
            DispatchMessageA(&__msg);
        }

        // Shutting down the GDI+
        Gdiplus::GdiplusShutdown(__gdiplusToken);

        return true;
    }
    // [ Ending ] Main Functions.

    // [ Starting ] Icon Setting Functions.
    bool Window::SetWindowTaskBarIcon(std::string sIconPath)
    {
        // Helps to set the icon of the window in the taskbar.

        if (__windowHandle == NULL)
        {
            __windowIcon = sIconPath;
            return true;
        }
        else
        {
            if ((SendMessageA(__windowHandle, WM_SETICON, ICON_SMALL, (LPARAM)Function::__LoadImageFromFile(sIconPath))) && (SendMessageA(__windowHandle, WM_SETICON, ICON_BIG, (LPARAM)Function::__LoadImageFromFile(sIconPath))))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    bool Window::SetTaskBarIcon(std::string sIconPath)
    {
        // Same as SetWindowTaskBarIcon() but it is a alias.
        return SetWindowTaskBarIcon(sIconPath);
    }

    bool Window::SetWindowFocusIcon(std::string sIconPath)
    {
        // Helps to set the icon of the window when it is focused.
        __theme.windowFocusIconPath = sIconPath;

        if (__windowHandle != NULL)
        {
            __RePaintWindow();
        }

        return true;
    }

    bool Window::SetFocusIcon(std::string sIconPath)
    {
        // Same as SetWindowFocusIcon() but it is a alias.
        return SetWindowFocusIcon(sIconPath);
    }

    bool Window::SetWindowUnfocusIcon(std::string sIconPath)
    {
        // Helps to set the icon of the window when it is unfocused.
        __theme.windowUnfocusIconPath = sIconPath;

        if (__windowHandle != NULL)
        {
            __RePaintWindow();
        }

        return true;
    }

    bool Window::SetUnfocusIcon(std::string sIconPath)
    {
        // Same as SetWindowUnfocusIcon() but it is a alias.
        return SetWindowUnfocusIcon(sIconPath);
    }
    // [ Ending ] Icon Setting Functions.

    // [ Starting ] Cursor Setting Functions.
    bool Window::SetWindowCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window.

        __theme.windowCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetCursor(std::string sCursorPath)
    {
        // Same as SetWindowCursor() but it is a alias.
        return SetWindowCursor(sCursorPath);
    }

    bool Window::SetWindowLeftResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from left side.
        __theme.windowLeftResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowLeftResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetLeftResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowLeftResizeCursor() but it is a alias.
        return SetWindowLeftResizeCursor(sCursorPath);
    }

    bool Window::SetWindowRightResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from right side.
        __theme.windowRightResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowRightResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetRightResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowRightResizeCursor() but it is a alias.
        return SetWindowRightResizeCursor(sCursorPath);
    }

    bool Window::SetWindowTopResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from top side.
        __theme.windowTopResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowTopResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetTopResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowTopResizeCursor() but it is a alias.
        return SetWindowTopResizeCursor(sCursorPath);
    }

    bool Window::SetWindowBottomResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from bottom side.
        __theme.windowBottomResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowBottomResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetBottomResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowBottomResizeCursor() but it is a alias.
        return SetWindowBottomResizeCursor(sCursorPath);
    }

    bool Window::SetWindowTopLeftResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from top left side.
        __theme.windowTopLeftResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowTopLeftResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetTopLeftResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowTopLeftResizeCursor() but it is a alias.
        return SetWindowTopLeftResizeCursor(sCursorPath);
    }

    bool Window::SetWindowTopRightResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from top right side.
        __theme.windowTopRightResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowTopRightResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetTopRightResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowTopRightResizeCursor() but it is a alias.
        return SetWindowTopRightResizeCursor(sCursorPath);
    }

    bool Window::SetWindowBottomLeftResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from bottom left side.
        __theme.windowBottomLeftResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowBottomLeftResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetBottomLeftResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowBottomLeftResizeCursor() but it is a alias.
        return SetWindowBottomLeftResizeCursor(sCursorPath);
    }

    bool Window::SetWindowBottomRightResizeCursor(std::string sCursorPath)
    {
        // Helps to set the cursor of the window when it is resized from bottom right side.
        __theme.windowBottomRightResizeCursor = (HCURSOR)LoadImageA(__hInstance, (LPCSTR)sCursorPath.c_str(), IMAGE_CURSOR, 0, 0, LR_LOADFROMFILE | LR_LOADTRANSPARENT);

        if (__theme.windowBottomRightResizeCursor)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Window::SetBottomRightResizeCursor(std::string sCursorPath)
    {
        // Same as SetWindowBottomRightResizeCursor() but it is a alias.
        return SetWindowBottomRightResizeCursor(sCursorPath);
    }
    // [ Ending ] Cursor Setting Functions.

    // [ Starting ] Window Colors Setting Functions.
    bool Window::SetWindowBackgroundColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the background color of the window.

        __theme.windowBackgroundColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetBackgroundColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowBackgroundColor() but it is a alias.
        return SetWindowBackgroundColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowBorderFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the border focus color of the window.

        __theme.windowBorderFocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetBorderFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowBorderFocusColor() but it is a alias.
        return SetWindowBorderFocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowBorderUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the border unfocus color of the window.

        __theme.windowBorderUnfocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetBorderUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowBorderUnfocusColor() but it is a alias.
        return SetWindowBorderUnfocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowTitleBarBackgroundColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the title bar background color of the window.

        __theme.windowTitleBarBackgroundColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetTitleBarBackgroundColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowTitleBarBackgroundColor() but it is a alias.
        return SetWindowTitleBarBackgroundColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowTitleBarTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the title bar text focus color of the window.

        __theme.windowTitleBarTextFocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetTitleBarTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowTitleBarTextFocusColor() but it is a alias.
        return SetWindowTitleBarTextFocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowCloseButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the close button text focus color of the window.

        __theme.windowCloseButtonTextFocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetCloseButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowCloseButtonTextFocusColor() but it is a alias.
        return SetWindowCloseButtonTextFocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowCloseButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the close button text hover color of the window.

        __theme.windowCloseButtonTextHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetCloseButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowCloseButtonTextHoverColor() but it is a alias.
        return SetWindowCloseButtonTextHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowCloseButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the close button background hover color of the window.

        __theme.windowCloseButtonBackgroundHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetCloseButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowCloseButtonBackgroundHoverColor() but it is a alias.
        return SetWindowCloseButtonBackgroundHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowCloseButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the close button text unfocus color of the window.

        __theme.windowCloseButtonTextUnfocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetCloseButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowCloseButtonTextUnfocusColor() but it is a alias.
        return SetWindowCloseButtonTextUnfocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMaximizeButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the maximize button text focus color of the window.

        __theme.windowMaximizeButtonTextFocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMaximizeButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMaximizeButtonTextFocusColor() but it is a alias.
        return SetWindowMaximizeButtonTextFocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMaximizeButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the maximize button text hover color of the window.

        __theme.windowMaximizeButtonTextHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMaximizeButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMaximizeButtonTextHoverColor() but it is a alias.
        return SetWindowMaximizeButtonTextHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMaximizeButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the maximize button background hover color of the window.

        __theme.windowMaximizeButtonBackgroundHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMaximizeButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMaximizeButtonBackgroundHoverColor() but it is a alias.
        return SetWindowMaximizeButtonBackgroundHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMaximizeButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the maximize button text unfocus color of the window.

        __theme.windowMaximizeButtonTextUnfocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMaximizeButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMaximizeButtonTextUnfocusColor() but it is a alias.
        return SetWindowMaximizeButtonTextUnfocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMinimizeButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the minimize button text focus color of the window.

        __theme.windowMinimizeButtonTextFocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMinimizeButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMinimizeButtonTextFocusColor() but it is a alias.
        return SetWindowMinimizeButtonTextFocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMinimizeButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the minimize button text hover color of the window.

        __theme.windowMinimizeButtonTextHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMinimizeButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMinimizeButtonTextHoverColor() but it is a alias.
        return SetWindowMinimizeButtonTextHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMinimizeButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the minimize button background hover color of the window.

        __theme.windowMinimizeButtonBackgroundHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMinimizeButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMinimizeButtonBackgroundHoverColor() but it is a alias.
        return SetWindowMinimizeButtonBackgroundHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowMinimizeButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the minimize button text unfocus color of the window.

        __theme.windowMinimizeButtonTextUnfocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetMinimizeButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowMinimizeButtonTextUnfocusColor() but it is a alias.
        return SetWindowMinimizeButtonTextUnfocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowSettingButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the setting button text focus color of the window.

        __theme.windowSettingButtonTextFocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetSettingButtonTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowSettingButtonTextFocusColor() but it is a alias.
        return SetWindowSettingButtonTextFocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowSettingButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the setting button text hover color of the window.

        __theme.windowSettingButtonTextHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetSettingButtonTextHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowSettingButtonTextHoverColor() but it is a alias.
        return SetWindowSettingButtonTextHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowSettingButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the setting button background hover color of the window.

        __theme.windowSettingButtonBackgroundHoverColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetSettingButtonBackgroundHoverColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowSettingButtonBackgroundHoverColor() but it is a alias.
        return SetWindowSettingButtonBackgroundHoverColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowSettingButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the setting button text unfocus color of the window.

        __theme.windowSettingButtonTextUnfocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetSettingButtonTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowSettingButtonTextUnfocusColor() but it is a alias.
        return SetWindowSettingButtonTextUnfocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowStatusBarBackgroundColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the status bar background color of the window.

        __theme.windowStatusBarBackgroundColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetStatusBarBackgroundColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowStatusBarBackgroundColor() but it is a alias.
        return SetWindowStatusBarBackgroundColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowStatusBarTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the status bar text focus color of the window.

        __theme.windowStatusBarTextFocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetStatusBarTextFocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowStatusBarTextFocusColor() but it is a alias.
        return SetWindowStatusBarTextFocusColor(nRed, nGreen, nBlue);
    }

    bool Window::SetWindowStatusBarTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Helps to set the status bar text unfocus color of the window.

        __theme.windowStatusBarTextUnfocusColor = RGB(nRed, nGreen, nBlue);

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetStatusBarTextUnfocusColor(int nRed, int nGreen, int nBlue)
    {
        // Same as SetWindowStatusBarTextUnfocusColor() but it is a alias.
        return SetWindowStatusBarTextUnfocusColor(nRed, nGreen, nBlue);
    }
    // [ Ending ] Window Colors Setting Functions.

    // [ Starting ] Window Positioning Functions.
    bool Window::SetWindowPosition(int nX, int nY)
    {
        // Helps to set the position of the window.

        __xPosition = nX;
        __yPosition = nY;

        if (__windowHandle)
        {
            bool result = SetWindowPos(__windowHandle, NULL, __xPosition, __yPosition, __width, __height, 0);
            __RePaintWindow();

            return result;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetPosition(int nX, int nY)
    {
        // Same as SetWindowPosition() but it is a alias.
        return SetWindowPosition(nX, nY);
    }

    bool Window::SetWindowHorizontalPosition(int nX)
    {
        // Helps to set the X position of the window.

        __xPosition = nX;

        if (__windowHandle)
        {
            bool result = SetWindowPos(__windowHandle, NULL, __xPosition, __yPosition, __width, __height, 0);
            __RePaintWindow();

            return result;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetHorizontalPosition(int nX)
    {
        // Same as SetWindowHorizontalPosition() but it is a alias.
        return SetWindowHorizontalPosition(nX);
    }

    bool Window::SetWindowXPosition(int nX)
    {
        // Same as SetWindowHorizontalPosition() but it is a alias.
        return SetWindowHorizontalPosition(nX);
    }

    bool Window::SetXPosition(int nX)
    {
        // Same as SetWindowHorizontalPosition() but it is a alias.
        return SetWindowHorizontalPosition(nX);
    }

    bool Window::SetWindowVerticalPosition(int nY)
    {
        // Helps to set the Y position of the window.

        __yPosition = nY;

        if (__windowHandle)
        {
            bool result = SetWindowPos(__windowHandle, NULL, __xPosition, __yPosition, __width, __height, 0);
            __RePaintWindow();

            return result;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetVerticalPosition(int nY)
    {
        // Same as SetWindowVerticalPosition() but it is a alias.
        return SetWindowVerticalPosition(nY);
    }

    bool Window::SetWindowYPosition(int nY)
    {
        // Same as SetWindowVerticalPosition() but it is a alias.
        return SetWindowVerticalPosition(nY);
    }

    bool Window::SetYPosition(int nY)
    {
        // Same as SetWindowVerticalPosition() but it is a alias.
        return SetWindowVerticalPosition(nY);
    }
    // [ Ending ] Window Positioning Functions.

    // [ Starting ] Window Sizing Functions.
    bool Window::SetWindowSize(int nWidth, int nHeight)
    {
        // Helps to set the size of the window.

        __width = nWidth;
        __height = nHeight;

        if (__windowHandle)
        {
            bool result = SetWindowPos(__windowHandle, NULL, __xPosition, __yPosition, __width, __height, 0);
            __RePaintWindow();

            return result;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetSize(int nWidth, int nHeight)
    {
        // Same as SetWindowSize() but it is a alias.
        return SetWindowSize(nWidth, nHeight);
    }

    bool Window::SetWindowWidth(int nWidth)
    {
        // Helps to set the width of the window.

        __width = nWidth;

        if (__windowHandle)
        {
            bool result = SetWindowPos(__windowHandle, NULL, __xPosition, __yPosition, __width, __height, 0);
            __RePaintWindow();

            return result;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetWidth(int nWidth)
    {
        // Same as SetWindowWidth() but it is a alias.
        return SetWindowWidth(nWidth);
    }

    bool Window::SetWindowHeight(int nHeight)
    {
        // Helps to set the height of the window.

        __height = nHeight;

        if (__windowHandle)
        {
            bool result = SetWindowPos(__windowHandle, NULL, __xPosition, __yPosition, __width, __height, 0);
            __RePaintWindow();

            return result;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetHeight(int nHeight)
    {
        // Same as SetWindowHeight() but it is a alias.
        return SetWindowHeight(nHeight);
    }

    bool Window::SetWindowBorderRadius(int nRadius)
    {
        // Helps to set the border radius of the window.

        __theme.windowBorderRadius = nRadius;

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetBorderRadius(int nRadius)
    {
        // Same as SetWindowBorderRadius() but it is a alias.
        return SetWindowBorderRadius(nRadius);
    }

    bool Window::SetWindowBorderRoundness(int nRoundness)
    {
        // Same as SetWindowBorderRadius() but it is a alias.
        return SetWindowBorderRadius(nRoundness);
    }

    bool Window::SetBorderRoundness(int nRoundness)
    {
        // Same as SetWindowBorderRadius() but it is a alias.
        return SetWindowBorderRadius(nRoundness);
    }
    // [ Ending ] Window Sizing Functions.

    // [ Starting ] Status Bar Text Controlling Functions.
    bool Window::SetWindowStatusBarText(std::string sStatusBarText)
    {
        // Helps to set the status bar text of the window.

        __statusBarText = sStatusBarText;

        if (__windowHandle)
        {
            __RePaintWindow();
            return true;
        }
        else
        {
            return true;
        }
    }

    bool Window::SetStatusBarText(std::string sStatusBarText)
    {
        // Same as SetWindowStatusBarText() but it is a alias.
        return SetWindowStatusBarText(sStatusBarText);
    }
    // [ Ending ] Status Bar Text Controlling Functions.

    // [ Ending ] Public Functions.
}