# -*- coding: utf-8 -*-
"""Drawing routines and customizations for the AGW widgets
:class:`~wx.lib.agw.labelbook.LabelBook` and :class:`~wx.lib.agw.flatmenu.FlatMenu`.
"""

import random
from io import BytesIO
from typing import Callable, Dict, List, Optional, Tuple, Type, Union


from DisplayCAL.lib.agw.fmresources import (
    BU_EXT_LEFT_ALIGN_STYLE,
    BU_EXT_RIGHT_ALIGN_STYLE,
    BU_EXT_RIGHT_TO_LEFT_STYLE,
    BottomShadow,
    BottomShadowFull,
    CS_DROPSHADOW,
    ControlDisabled,
    ControlFocus,
    ControlPressed,
    RightShadow,
    Style2007,
    StyleXP,
    arrow_down,
    arrow_up,
    shadow_bottom_alpha,
    shadow_bottom_left_alpha,
    shadow_bottom_left_xpm,
    shadow_bottom_xpm,
    shadow_center_alpha,
    shadow_center_xpm,
    shadow_right_alpha,
    shadow_right_top_alpha,
    shadow_right_top_xpm,
    shadow_right_xpm,
)

import wx

# ------------------------------------------------------------------------------------ #
# Class DCSaver
# ------------------------------------------------------------------------------------ #

_: Callable[[str], str] = wx.GetTranslation

_libimported = None

if wx.Platform == "__WXMSW__":
    osVersion = wx.GetOsVersion()
    # Shadows behind menus are supported only in XP
    if osVersion[1] == 5 and osVersion[2] == 1:
        try:
            import win32api
            import win32con
            import winxpgui

            _libimported = "MH"
        except ImportError:
            try:
                import ctypes

                _libimported = "ctypes"
            except ImportError:
                pass
    else:
        _libimported = None


class DCSaver:
    """Construct a DC saver.

    The dc is copied as-is.

    Args:
        pdc (wx.DC): An instance of :class:`wx.DC`.
    """

    def __init__(self, pdc: wx.DC):
        self._pdc = pdc
        self._pen = pdc.GetPen()
        self._brush = pdc.GetBrush()

    def __del__(self) -> None:
        """While destructing, restore the dc pen and brush."""
        if self._pdc:
            self._pdc.SetPen(self._pen)
            self._pdc.SetBrush(self._brush)


# ------------------------------------------------------------------------------------ #
# Class RendererBase
# ------------------------------------------------------------------------------------ #


class RendererBase:
    """Base class for all theme renderers."""

    def DrawButtonBorders(
        self, dc: wx.DC, rect: wx.Rect, penColour: wx.Colour, brushColour: wx.Colour
    ) -> None:
        """Draw borders for buttons.

        Args:
            dc (wx.DC): an instance of :class:`wx.DC`.
            rect (wx.Rect): the button's client rectangle.
            penColour (wx.Colour): a valid :class:`wx.Colour` for the pen border.
            brushColour (wx.Colour): a valid :class:`wx.Colour` for the brush.
        """
        # Keep old pen and brush
        _ = DCSaver(dc)

        # Set new pen and brush
        dc.SetPen(wx.Pen(penColour))
        dc.SetBrush(wx.Brush(brushColour))

        # Draw the rectangle
        dc.DrawRectangle(rect)

    def DrawBitmapArea(
        self,
        dc: wx.DC,
        xpm_name: str,
        rect: wx.Rect,
        baseColour: wx.Colour,
        flipSide: bool,
    ) -> None:
        """Draw the area below a bitmap and the bitmap itself using a gradient shading.

        Args:
            dc (wx.DC): :class:`wx.DC` instance.
            xpm_name (str): The name of the XPM bitmap.
            rect (wx.Rect): The bitmap client rectangle.
            baseColour (wx.Colour): A valid :class:`wx.Colour` for the bitmap
                background.
            flipSide (bool): `True` to flip the gradient direction, `False` otherwise.
        """
        # draw the gradient area
        if not flipSide:
            ArtManager.Get().PaintDiagonalGradientBox(
                dc,
                rect,
                wx.WHITE,
                ArtManager.Get().LightColour(baseColour, 20),
                True,
                False,
            )
        else:
            ArtManager.Get().PaintDiagonalGradientBox(
                dc,
                rect,
                ArtManager.Get().LightColour(baseColour, 20),
                wx.WHITE,
                True,
                False,
            )

        # draw arrow
        arrowDown = wx.Bitmap(xpm_name)
        arrowDown.SetMask(wx.Mask(arrowDown, wx.WHITE))
        dc.DrawBitmap(arrowDown, rect.x + 1, rect.y + 1, True)

    def DrawBitmapBorders(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        penColour: wx.Colour,
        bitmapBorderUpperLeftPen: wx.Colour,
    ) -> None:
        """Draw borders for a bitmap.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The button's client rectangle.
            penColour (wx.Colour): A valid :class:`wx.Colour` for the pen border.
            bitmapBorderUpperLeftPen (wx.Colour): A valid :class:`wx.Colour` for the pen
                upper left border.
        """
        # Keep old pen and brush
        _ = DCSaver(dc)

        # lower right side
        dc.SetPen(wx.Pen(penColour))
        dc.DrawLine(
            rect.x,
            rect.y + rect.height - 1,
            rect.x + rect.width,
            rect.y + rect.height - 1,
        )
        dc.DrawLine(
            rect.x + rect.width - 1,
            rect.y,
            rect.x + rect.width - 1,
            rect.y + rect.height,
        )

        # upper left side
        dc.SetPen(wx.Pen(bitmapBorderUpperLeftPen))
        dc.DrawLine(rect.x, rect.y, rect.x + rect.width, rect.y)
        dc.DrawLine(rect.x, rect.y, rect.x, rect.y + rect.height)

    def GetMenuFaceColour(self) -> wx.Colour:
        """Return the foreground colour for the menu.

        Returns:
            wx.Colour: A :class:`wx.Colour` instance.
        """
        return ArtManager.Get().LightColour(
            wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE), 80
        )

    def GetTextColourEnable(self) -> wx.Colour:
        """Return the colour used for text colour when enabled.

        Returns:
            wx.Colour: A :class:`wx.Colour` instance.
        """
        return wx.BLACK

    def GetTextColourDisable(self) -> wx.Colour:
        """Return the colour used for text colour when disabled.

        Returns:
            wx.Colour: A :class:`wx.Colour` instance.
        """
        return ArtManager.Get().LightColour(
            wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT), 30
        )

    def GetFont(self) -> wx.Font:
        """Return the font used for text.

        Returns:
            wx.Font: A :class:`wx.Font` instance.
        """
        return wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)

    def DrawButton(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        state: int,
        input_: Optional[Union[bool, wx.Colour]] = None,
    ) -> None:
        """Draw a button using the appropriate theme.

        Args:
            dc (wx.DC): an instance of :class:`wx.DC`.
            rect (wx.Rect): the button's client rectangle.
            state (int): the button state.
            input_ (Optional[Union[bool, wx.Colour]]): a flag used to call the
                right method.

        Raises:
            NotImplementedError: This method must be implemented in derived
                classes.
        """
        raise NotImplementedError(
            "DrawButton method must be implemented in derived classes"
        )

    def DrawToolBarBg(self, dc: wx.DC, rect: wx.Rect) -> None:
        """Draw the toolbar background according to the active theme.

        Args:
            dc (wx.DC): an instance of :class:`wx.DC`.
            rect (wx.Rect): the toolbar's client rectangle.

        Raises:
            NotImplementedError: This method must be implemented in derived classes.
        """
        raise NotImplementedError(
            "DrawToolBarBg method must be implemented in derived classes"
        )

    def DrawMenuBarBg(self, dc: wx.DC, rect: wx.Rect) -> None:
        """Draw the menu bar background according to the active theme.

        Args:
            dc (wx.DC): an instance of :class:`wx.DC`.
            rect (wx.Rect): the menu bar's client rectangle.

        Raises:
            NotImplementedError: This method must be implemented in derived classes.
        """
        raise NotImplementedError(
            "DrawMenuBarBg method must be implemented in derived classes"
        )


# ------------------------------------------------------------------------------------ #
# Class RendererXP
# ------------------------------------------------------------------------------------ #


class RendererXP(RendererBase):
    """Xp-Style renderer."""

    def __init__(self) -> None:
        RendererBase.__init__(self)

    def DrawButton(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        state: int,
        input_: Optional[Union[bool, wx.Colour]] = None,
    ) -> None:
        """Draw a button using the XP theme.

        Args:
            dc (wx.DC): An instance of :class:`wx.DC`.
            rect (wx.Rect): The button's client rectangle.
            state (int): The button state.
            input_ (Optional[Union[bool, wx.Colour]]): a flag used to call the
                right method.
        """
        if input_ is None or isinstance(input_, bool):
            self.DrawButtonTheme(dc, rect, state, input_)
        else:
            self.DrawButtonColour(dc, rect, state, input_)

    def DrawButtonTheme(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        state: int,
        useLightColours: Optional[bool] = None,
    ) -> None:
        """Draw a button using the XP theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The button's client rectangle.
            state (int): The button state.
            useLightColours (bool): `True` to use light colours, `False` otherwise.
        """
        # switch according to the status
        if state == ControlFocus:
            penColour = ArtManager.Get().FrameColour()
            brushColour = ArtManager.Get().BackgroundColour()
        elif state == ControlPressed:
            penColour = ArtManager.Get().FrameColour()
            brushColour = ArtManager.Get().HighlightBackgroundColour()
        else:
            penColour = ArtManager.Get().FrameColour()
            brushColour = ArtManager.Get().BackgroundColour()

        # Draw the button borders
        self.DrawButtonBorders(dc, rect, penColour, brushColour)

    def DrawButtonColour(
        self, dc: wx.DC, rect: wx.Rect, state: int, colour: wx.Colour
    ) -> None:
        """Draw a button using the XP theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The button's client rectangle.
            state (int): The button state.
            colour (wx.Colour): a valid :class:`wx.Colour` instance.
        """
        # switch according to the status
        if state == ControlFocus:
            penColour = colour
            brushColour = ArtManager.Get().LightColour(colour, 75)
        elif state == ControlPressed:
            penColour = colour
            brushColour = ArtManager.Get().LightColour(colour, 60)
        else:
            penColour = colour
            brushColour = ArtManager.Get().LightColour(colour, 75)

        # Draw the button borders
        self.DrawButtonBorders(dc, rect, penColour, brushColour)

    def DrawMenuBarBg(self, dc: wx.DC, rect: wx.Rect) -> None:
        """Draw the menu bar background according to the active theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The menu bar's client rectangle.
        """
        # For office style, we simple draw a rectangle with a gradient colouring
        artMgr = ArtManager.Get()
        vertical = artMgr.GetMBVerticalGradient()

        _ = DCSaver(dc)

        # fill with gradient
        startColour = artMgr.GetMenuBarFaceColour()
        if artMgr.IsDark(startColour):
            startColour = artMgr.LightColour(startColour, 50)

        endColour = artMgr.LightColour(startColour, 90)
        artMgr.PaintStraightGradientBox(dc, rect, startColour, endColour, vertical)

        # Draw the border
        if artMgr.GetMenuBarBorder():
            dc.SetPen(wx.Pen(startColour))
            dc.SetBrush(wx.TRANSPARENT_BRUSH)
            dc.DrawRectangle(rect)

    def DrawToolBarBg(self, dc: wx.DC, rect: wx.Rect) -> None:
        """Draw the toolbar background according to the active theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The toolbar's client rectangle.
        """
        artMgr = ArtManager.Get()

        if not artMgr.GetRaiseToolbar():
            return

        # For office style, we simple draw a rectangle with a gradient colouring
        vertical = artMgr.GetMBVerticalGradient()

        _ = DCSaver(dc)

        # fill with gradient
        startColour = artMgr.GetMenuBarFaceColour()
        if artMgr.IsDark(startColour):
            startColour = artMgr.LightColour(startColour, 50)

        startColour = artMgr.LightColour(startColour, 20)

        endColour = artMgr.LightColour(startColour, 90)
        artMgr.PaintStraightGradientBox(dc, rect, startColour, endColour, vertical)
        artMgr.DrawBitmapShadow(dc, rect)

    def GetTextColourEnable(self) -> wx.Colour:
        """Return the colour used for text colour when enabled.

        Returns:
            wx.Colour: A :class:`wx.Colour` instance.
        """
        return wx.BLACK


# ------------------------------------------------------------------------------------ #
# Class RendererMSOffice2007
# ------------------------------------------------------------------------------------ #


class RendererMSOffice2007(RendererBase):
    """Windows MS Office 2007 style."""

    def __init__(self) -> None:
        RendererBase.__init__(self)

    def GetColoursAccordingToState(self, state: int) -> Tuple[int, int, int, int]:
        """Return a tuple according to the menu item state.

        Args:
            state (int): One of the following bits:

         ==================== ======= ==========================
         Item State            Value  Description
         ==================== ======= ==========================
         ``ControlPressed``         0 The item is pressed
         ``ControlFocus``           1 The item is focused
         ``ControlDisabled``        2 The item is disabled
         ``ControlNormal``          3 Normal state
         ==================== ======= ==========================

        Returns:
            Tuple[int, int, int, int, bool, bool]: A tuple containing the
                gradient percentages.
        """
        # switch according to the status
        if state == ControlFocus:
            upperBoxTopPercent = 95
            upperBoxBottomPercent = 50
            lowerBoxTopPercent = 40
            lowerBoxBottomPercent = 90
            concaveUpperBox = True
            concaveLowerBox = True

        elif state == ControlPressed:
            upperBoxTopPercent = 75
            upperBoxBottomPercent = 90
            lowerBoxTopPercent = 90
            lowerBoxBottomPercent = 40
            concaveUpperBox = True
            concaveLowerBox = True

        elif state == ControlDisabled:
            upperBoxTopPercent = 100
            upperBoxBottomPercent = 100
            lowerBoxTopPercent = 70
            lowerBoxBottomPercent = 70
            concaveUpperBox = True
            concaveLowerBox = True

        else:
            upperBoxTopPercent = 90
            upperBoxBottomPercent = 50
            lowerBoxTopPercent = 30
            lowerBoxBottomPercent = 75
            concaveUpperBox = True
            concaveLowerBox = True

        return (
            upperBoxTopPercent,
            upperBoxBottomPercent,
            lowerBoxTopPercent,
            lowerBoxBottomPercent,
            concaveUpperBox,
            concaveLowerBox,
        )

    def DrawButton(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        state: int,
        input_: Optional[Union[bool, wx.Colour]] = None,
    ) -> None:
        """Draw a button using the MS Office 2007 theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The button's client rectangle.
            state (int): The button state.
            input_ (Optional[Union[bool, wx.Colour]]): A flag used to call the
                right method.
        """
        if input_ is None or isinstance(input_, bool):
            self.DrawButtonTheme(dc, rect, state, input_)
        else:
            self.DrawButtonColour(dc, rect, state, input_)

    def DrawButtonTheme(
        self, dc: wx.DC, rect: wx.Rect, state: int, useLightColours: Union[None, bool]
    ) -> None:
        """Draw a button using the MS Office 2007 theme.

        Args:
            dc (wx.DC): an instance of :class:`wx.DC`.
            rect (wx.Rect): the button's client rectangle.
            state (int): the button state.
            useLightColours (Union[None, bool]): `True` to use light colours,
                ``False`` otherwise.
        """
        self.DrawButtonColour(
            dc, rect, state, ArtManager.Get().GetThemeBaseColour(useLightColours)
        )

    def DrawButtonColour(self, dc, rect, state, colour):
        """Draw a button using the MS Office 2007 theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The button's client rectangle.
            state (int): The button state.
            colour (wx.Colour): a valid :class:`wx.Colour` instance.
        """
        artMgr = ArtManager.Get()

        # Keep old pen and brush
        _ = DCSaver(dc)

        # Define the rounded rectangle base on the given rect
        # we need an array of 9 points for it
        baseColour = colour

        # Define the middle points
        leftPt = wx.Point(rect.x, rect.y + (rect.height / 2))
        rightPt = wx.Point(rect.x + rect.width - 1, rect.y + (rect.height / 2))

        # Define the top region
        top = wx.Rect((rect.GetLeft(), rect.GetTop()), rightPt)
        bottom = wx.Rect(leftPt, (rect.GetRight(), rect.GetBottom()))

        (
            upperBoxTopPercent,
            upperBoxBottomPercent,
            lowerBoxTopPercent,
            lowerBoxBottomPercent,
            concaveUpperBox,
            concaveLowerBox,
        ) = self.GetColoursAccordingToState(state)

        topStartColour = artMgr.LightColour(baseColour, upperBoxTopPercent)
        topEndColour = artMgr.LightColour(baseColour, upperBoxBottomPercent)
        bottomStartColour = artMgr.LightColour(baseColour, lowerBoxTopPercent)
        bottomEndColour = artMgr.LightColour(baseColour, lowerBoxBottomPercent)

        artMgr.PaintStraightGradientBox(dc, top, topStartColour, topEndColour)
        artMgr.PaintStraightGradientBox(dc, bottom, bottomStartColour, bottomEndColour)

        rr = wx.Rect(rect.x, rect.y, rect.width, rect.height)
        dc.SetBrush(wx.TRANSPARENT_BRUSH)

        frameColour = artMgr.LightColour(baseColour, 60)
        dc.SetPen(wx.Pen(frameColour))
        dc.DrawRectangle(rr)

        wc = artMgr.LightColour(baseColour, 80)
        dc.SetPen(wx.Pen(wc))
        rr.Deflate(1, 1)
        dc.DrawRectangle(rr)

    def DrawMenuBarBg(self, dc: wx.DC, rect: wx.Rect) -> None:
        """Draw the menu bar background according to the active theme.

        Args:
            dc (wx.DC): an instance of :class:`wx.DC`.
            rect (wx.Rect): the menu bar's client rectangle.
        """
        # Keep old pen and brush
        _ = DCSaver(dc)
        artMgr = ArtManager.Get()
        baseColour = artMgr.GetMenuBarFaceColour()

        dc.SetBrush(wx.Brush(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE)))
        dc.SetPen(wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE)))
        dc.DrawRectangle(rect)

        # Define the rounded rectangle base on the given rect
        # we need an array of 9 points for it
        regPts = [wx.Point() for _ in range(9)]
        radius = 2

        regPts[0] = wx.Point(rect.x, rect.y + radius)
        regPts[1] = wx.Point(rect.x + radius, rect.y)
        regPts[2] = wx.Point(rect.x + rect.width - radius - 1, rect.y)
        regPts[3] = wx.Point(rect.x + rect.width - 1, rect.y + radius)
        regPts[4] = wx.Point(rect.x + rect.width - 1, rect.y + rect.height - radius - 1)
        regPts[5] = wx.Point(rect.x + rect.width - radius - 1, rect.y + rect.height - 1)
        regPts[6] = wx.Point(rect.x + radius, rect.y + rect.height - 1)
        regPts[7] = wx.Point(rect.x, rect.y + rect.height - radius - 1)
        regPts[8] = regPts[0]

        # Define the middle points
        factor = artMgr.GetMenuBgFactor()

        leftPt1 = wx.Point(rect.x, rect.y + (rect.height / factor))
        leftPt2 = wx.Point(rect.x, rect.y + (rect.height / factor) * (factor - 1))

        rightPt1 = wx.Point(rect.x + rect.width, rect.y + (rect.height / factor))
        rightPt2 = wx.Point(
            rect.x + rect.width, rect.y + (rect.height / factor) * (factor - 1)
        )

        # Define the top region
        topReg = [wx.Point() for _ in range(7)]
        topReg[0] = regPts[0]
        topReg[1] = regPts[1]
        topReg[2] = wx.Point(regPts[2].x + 1, regPts[2].y)
        topReg[3] = wx.Point(regPts[3].x + 1, regPts[3].y)
        topReg[4] = wx.Point(rightPt1.x, rightPt1.y + 1)
        topReg[5] = wx.Point(leftPt1.x, leftPt1.y + 1)
        topReg[6] = topReg[0]

        # Define the middle region
        middle = wx.Rect(leftPt1, wx.Point(rightPt2.x - 2, rightPt2.y))

        # Define the bottom region
        bottom = wx.Rect(leftPt2, wx.Point(rect.GetRight() - 1, rect.GetBottom()))

        topStartColour = artMgr.LightColour(baseColour, 90)
        topEndColour = artMgr.LightColour(baseColour, 60)
        bottomStartColour = artMgr.LightColour(baseColour, 40)
        bottomEndColour = artMgr.LightColour(baseColour, 20)

        topRegion = wx.Region(topReg)

        artMgr.PaintGradientRegion(dc, topRegion, topStartColour, topEndColour)
        artMgr.PaintStraightGradientBox(dc, bottom, bottomStartColour, bottomEndColour)
        artMgr.PaintStraightGradientBox(dc, middle, topEndColour, bottomStartColour)

    def DrawToolBarBg(self, dc: wx.DC, rect: wx.Rect):
        """Draw the toolbar background according to the active theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The toolbar's client rectangle.
        """
        artMgr = ArtManager.Get()

        if not artMgr.GetRaiseToolbar():
            return

        # Keep old pen and brush
        _ = DCSaver(dc)

        baseColour = artMgr.GetMenuBarFaceColour()
        baseColour = artMgr.LightColour(baseColour, 20)

        dc.SetBrush(wx.Brush(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE)))
        dc.SetPen(wx.Pen(wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE)))
        dc.DrawRectangle(rect)

        radius = 2

        # Define the rounded rectangle base on the given rect
        # we need an array of 9 points for it
        regPts = [None] * 9

        regPts[0] = wx.Point(rect.x, rect.y + radius)
        regPts[1] = wx.Point(rect.x + radius, rect.y)
        regPts[2] = wx.Point(rect.x + rect.width - radius - 1, rect.y)
        regPts[3] = wx.Point(rect.x + rect.width - 1, rect.y + radius)
        regPts[4] = wx.Point(rect.x + rect.width - 1, rect.y + rect.height - radius - 1)
        regPts[5] = wx.Point(rect.x + rect.width - radius - 1, rect.y + rect.height - 1)
        regPts[6] = wx.Point(rect.x + radius, rect.y + rect.height - 1)
        regPts[7] = wx.Point(rect.x, rect.y + rect.height - radius - 1)
        regPts[8] = regPts[0]

        # Define the middle points
        factor = artMgr.GetMenuBgFactor()

        leftPt1 = wx.Point(rect.x, rect.y + (rect.height / factor))
        rightPt1 = wx.Point(rect.x + rect.width, rect.y + (rect.height / factor))

        leftPt2 = wx.Point(rect.x, rect.y + (rect.height / factor) * (factor - 1))
        rightPt2 = wx.Point(
            rect.x + rect.width, rect.y + (rect.height / factor) * (factor - 1)
        )

        # Define the top region
        topReg = [None] * 7
        topReg[0] = regPts[0]
        topReg[1] = regPts[1]
        topReg[2] = wx.Point(regPts[2].x + 1, regPts[2].y)
        topReg[3] = wx.Point(regPts[3].x + 1, regPts[3].y)
        topReg[4] = wx.Point(rightPt1.x, rightPt1.y + 1)
        topReg[5] = wx.Point(leftPt1.x, leftPt1.y + 1)
        topReg[6] = topReg[0]

        # Define the middle region
        middle = wx.Rect(leftPt1, wx.Point(rightPt2.x - 2, rightPt2.y))

        # Define the bottom region
        bottom = wx.Rect(leftPt2, wx.Point(rect.GetRight() - 1, rect.GetBottom()))

        topStartColour = artMgr.LightColour(baseColour, 90)
        topEndColour = artMgr.LightColour(baseColour, 60)
        bottomStartColour = artMgr.LightColour(baseColour, 40)
        bottomEndColour = artMgr.LightColour(baseColour, 20)

        topRegion = wx.Region(topReg)

        artMgr.PaintGradientRegion(dc, topRegion, topStartColour, topEndColour)
        artMgr.PaintStraightGradientBox(dc, bottom, bottomStartColour, bottomEndColour)
        artMgr.PaintStraightGradientBox(dc, middle, topEndColour, bottomStartColour)

        artMgr.DrawBitmapShadow(dc, rect)

    def GetTextColourEnable(self) -> wx.Colour:
        """Return the colour used for text colour when enabled.

        Returns:
            An instance of :class:`wx.Colour`.
        """
        return wx.Colour("MIDNIGHT BLUE")


# ------------------------------------------------------------------------------------ #
# Class ArtManager
# ------------------------------------------------------------------------------------ #


class ArtManager(wx.EvtHandler):
    """This class provides utilities for creating shadows and adjusting colors."""

    _alignmentBuffer = 7
    _menuTheme: int = StyleXP
    _verticalGradient = False
    _renderers: Dict[int, RendererBase] = {StyleXP: None, Style2007: None}
    _bmpShadowEnabled = False
    _ms2007sunken = False
    _drowMBBorder = True
    _menuBgFactor = 5
    _menuBarColourScheme: str = _("Default")
    _raiseTB = True
    _bitmaps: Dict[str, wx.Bitmap] = {}
    _transparency = 255

    def __init__(self) -> None:
        wx.EvtHandler.__init__(self)
        self._menuBarBgColour = wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE)

        # connect an event handler to the system colour change event
        self.Bind(wx.EVT_SYS_COLOUR_CHANGED, self.OnSysColourChange)

        # Initialize the menu bar selection colour
        self._menuBarSelColour = wx.Colour(0, 0, 0)  # Default to black

    def SetTransparency(self, amount: int) -> None:
        """Set the alpha channel value for transparent windows.

        Args:
            amount (int): The actual transparency value (between 0 and 255).

        Raises:
            Exception: If the `amount` parameter is lower than ``0`` or greater than
                ``255``.
        """
        if self._transparency == amount:
            return

        if amount < 0 or amount > 255:
            raise Exception("Invalid transparency value")

        self._transparency = amount

    def GetTransparency(self) -> int:
        """Return the alpha channel value for transparent windows.

        Returns:
            int: An integer representing the alpha channel value.
        """
        return self._transparency

    @classmethod
    def ConvertToBitmap(
        cls, xpm: Union[List[str], bytes], alpha: Optional[List[int]] = None
    ) -> wx.Bitmap:
        """Convert the given image to a bitmap, optionally overlaying an alpha channel.

        Args:
            xpm (Union[List[str], bytes]): A list of strings formatted as XPM.
            alpha (Optional[List[int]]): A list of alpha values, the same size
                as the xpm bitmap.

        Raises:
            TypeError: If `xpm` is not a list of strings or a bytes object.

        Returns:
            wx.Bitmap: An instance of :class:`wx.Bitmap`.
        """
        if isinstance(xpm, bytes):
            img = wx.ImageFromStream(BytesIO(xpm))
        elif isinstance(xpm, list) and all(isinstance(data, str) for data in xpm):
            img = wx.Bitmap(xpm).ConvertToImage()
        else:
            raise TypeError("xpm must be a list of strings or a bytes object")

        if alpha is not None:
            x = img.GetWidth()
            y = img.GetHeight()
            img.InitAlpha()
            for jj in range(y):
                for ii in range(x):
                    img.SetAlpha(ii, jj, alpha[jj * x + ii])

        return wx.Bitmap(img)

    def Initialize(self) -> None:
        """Initialize the bitmaps and colours."""
        # create wxBitmaps from the xpm's
        self._rightBottomCorner = self.ConvertToBitmap(
            shadow_center_xpm, shadow_center_alpha
        )
        self._bottom = self.ConvertToBitmap(shadow_bottom_xpm, shadow_bottom_alpha)
        self._bottomLeft = self.ConvertToBitmap(
            shadow_bottom_left_xpm, shadow_bottom_left_alpha
        )
        self._rightTop = self.ConvertToBitmap(
            shadow_right_top_xpm, shadow_right_top_alpha
        )
        self._right = self.ConvertToBitmap(shadow_right_xpm, shadow_right_alpha)

        # initialise the colour map
        self.InitColours()
        self.SetMenuBarColour(self._menuBarColourScheme)

        # Create common bitmaps
        self.FillStockBitmaps()

    def FillStockBitmaps(self) -> None:
        """Initialize few standard bitmaps."""
        bmp = self.ConvertToBitmap(arrow_down, alpha=None)
        bmp.SetMask(wx.Mask(bmp, wx.Colour(0, 128, 128)))
        self._bitmaps.update({"arrow_down": bmp})

        bmp = self.ConvertToBitmap(arrow_up, alpha=None)
        bmp.SetMask(wx.Mask(bmp, wx.Colour(0, 128, 128)))
        self._bitmaps.update({"arrow_up": bmp})

    def GetStockBitmap(self, name):
        """Return a bitmap from a stock.

        Args:
            name (str): The bitmap name.

        Returns:
            wx.Bitmap: The stock bitmap, if `name` was found in the stock bitmap
                dictionary. Otherwise, :class:`NullBitmap` is returned.
        """
        return self._bitmaps.get(name, wx.NullBitmap)

    @classmethod
    def Get(cls: Type["ArtManager"]) -> "ArtManager":
        """Accessor to the unique art manager object.

        Returns:
            A unique instance of :class:`ArtManager`.
        """
        if not hasattr(cls, "_instance"):
            cls._instance = ArtManager()
            cls._instance.Initialize()

            # Initialize the renderers map
            cls._renderers[StyleXP] = RendererXP()
            cls._renderers[Style2007] = RendererMSOffice2007()

        return cls._instance

    @classmethod
    def Free(cls) -> None:
        """Destructor for the unique art manager object."""
        if hasattr(cls, "_instance"):
            del cls._instance

    def OnSysColourChange(self, event: wx.SysColourChangedEvent) -> None:
        """Handle the ``wx.EVT_SYS_COLOUR_CHANGED`` event for :class:`ArtManager`.

        Args:
            event (wx.SysColourChangedEvent): A :class:`SysColourChangedEvent` event to
                be processed.
        """
        # reinitialise the colour map
        self.InitColours()

    def LightColour(self, colour: wx.Colour, percent: int) -> wx.Colour:
        """Return light contrast of `colour`.

        The colour returned is from the scale of `colour` ==> white.

        Args:
            colour (wx.Colour): The input colour to be brightened, an instance of
                :class:`wx.Colour`.
            percent (int): Determines how light the colour will be.
                `percent` = ``100`` returns white, `percent` = ``0`` returns `colour`.

        Returns:
            wx.Colour: A light contrast of the input `colour`.
        """
        end_colour = wx.WHITE
        rd = end_colour.Red() - colour.Red()
        gd = end_colour.Green() - colour.Green()
        bd = end_colour.Blue() - colour.Blue()
        high = 100

        # We take the percent way of the colour from colour -. white
        i = percent
        r = colour.Red() + ((i * rd * 100) / high) / 100
        g = colour.Green() + ((i * gd * 100) / high) / 100
        b = colour.Blue() + ((i * bd * 100) / high) / 100
        a = colour.Alpha()

        return wx.Colour(int(r), int(g), int(b), int(a))

    def DarkColour(self, colour: wx.Colour, percent: int) -> wx.Colour:
        """Like :meth:`.LightColour`, but create a darker colour by `percent`.

        Args:
            colour (wx.Colour): The input colour to be darkened.
            percent (int): Determines how dark the colour will be.
                `percent` = ``100`` returns black, `percent` = ``0`` returns `colour`.

        Returns:
            wx.Colour: A dark contrast of the input `colour`.
        """
        end_colour = wx.BLACK
        rd = end_colour.Red() - colour.Red()
        gd = end_colour.Green() - colour.Green()
        bd = end_colour.Blue() - colour.Blue()
        high = 100

        # We take the percent way of the colour from colour -. white
        i = percent
        r = colour.Red() + ((i * rd * 100) / high) / 100
        g = colour.Green() + ((i * gd * 100) / high) / 100
        b = colour.Blue() + ((i * bd * 100) / high) / 100

        return wx.Colour(int(r), int(g), int(b))

    def PaintStraightGradientBox(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        startColour: wx.Colour,
        endColour: wx.Colour,
        vertical: bool = True,
    ) -> None:
        """Paint the rectangle with gradient colouring.

        The gradient lines are either horizontal or vertical.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            startColour (wx.Colour): The first colour of the gradient shading.
            endColour (wx.EndColour): The second colour of the gradient shading.
            vertical (bool): ``True`` for gradient colouring in the vertical direction,
                ``False`` for horizontal shading.
        """
        _ = DCSaver(dc)

        if vertical:
            high = rect.GetHeight() - 1
            direction = wx.SOUTH
        else:
            high = rect.GetWidth() - 1
            direction = wx.EAST

        if high < 1:
            return

        dc.GradientFillLinear(rect, startColour, endColour, direction)

    def PaintGradientRegion(
        self,
        dc: wx.DC,
        region: wx.Region,
        startColour: wx.Colour,
        endColour: wx.Colour,
        vertical: bool = True,
    ) -> None:
        """Paint a region with gradient colouring.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            region (wx.Region): A region to be filled with gradient shading.
            startColour (wx.Colour): The first colour of the gradient shading.
            endColour (wx.Colour): The second colour of the gradient shading.
            vertical (bool): ``True`` for gradient colouring in the vertical
                direction, ``False`` for horizontal shading.
        """
        # The way to achieve non-rectangle
        memDC = wx.MemoryDC()
        rect = region.GetBox()
        bitmap = wx.Bitmap(rect.width, rect.height)
        memDC.SelectObject(bitmap)

        # Colour the whole rectangle with gradient
        rr = wx.Rect(0, 0, rect.width, rect.height)
        self.PaintStraightGradientBox(memDC, rr, startColour, endColour, vertical)

        # Convert the region to a black and white bitmap with the white pixels
        # being inside the region we draw the bitmap over the gradient coloured
        # rectangle, with mask set to white, this will cause our region to be
        # coloured with the gradient, while area outside the region will be
        # painted with black. Then we simply draw the bitmap to the dc with
        # mask set to black.
        tmpRegion = wx.Region(rect.x, rect.y, rect.width, rect.height)
        tmpRegion.Offset(-rect.x, -rect.y)
        regionBmp = tmpRegion.ConvertToBitmap()
        regionBmp.SetMask(wx.Mask(regionBmp, wx.WHITE))

        # The function ConvertToBitmap() return a rectangle bitmap which is
        # shorter by 1 pixel on the height and width (this is correct behavior,
        # since DrawLine does not include the second point as part of the line)
        # we fix this issue by drawing our own line at the bottom and left side
        # of the rectangle
        memDC.SetPen(wx.BLACK_PEN)
        memDC.DrawBitmap(regionBmp, 0, 0, True)
        memDC.DrawLine(0, rr.height - 1, rr.width, rr.height - 1)
        memDC.DrawLine(rr.width - 1, 0, rr.width - 1, rr.height)

        memDC.SelectObject(wx.NullBitmap)
        bitmap.SetMask(wx.Mask(bitmap, wx.BLACK))
        dc.DrawBitmap(bitmap, rect.x, rect.y, True)

    def PaintDiagonalGradientBox(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        startColour: wx.Colour,
        endColour: wx.Colour,
        startAtUpperLeft: bool = True,
        trimToSquare: bool = True,
    ) -> None:
        """Paint rectangle with gradient colouring.

        The gradient lines are diagonal and may start from the upper left
        corner or from the upper right corner.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            startColour (wx.Colour): The first colour of the gradient shading.
            endColour (wx.Colour): The second colour of the gradient shading.
            startAtUpperLeft (bool): ``True`` to start the gradient lines at
                the upper left corner of the rectangle, ``False`` to start at
                the upper right corner.
            trimToSquare (bool): ``True`` to trim the gradient lines in a square.
        """
        # gradient fill from colour 1 to colour 2 with top to bottom
        if rect.height < 1 or rect.width < 1:
            return

        # Save the current pen and brush
        savedPen = dc.GetPen()
        savedBrush = dc.GetBrush()

        # calculate some basic numbers
        size, sizeX, sizeY, proportion = self._calculate_sizes(rect, trimToSquare)
        rstep, gstep, bstep = self._calculate_steps(startColour, endColour, size)

        self._draw_upper_triangle(
            dc,
            rect,
            startColour,
            rstep,
            gstep,
            bstep,
            size,
            sizeX,
            sizeY,
            proportion,
            startAtUpperLeft,
        )
        self._draw_lower_triangle(
            dc,
            rect,
            startColour,
            rstep,
            gstep,
            bstep,
            size,
            sizeX,
            sizeY,
            proportion,
            startAtUpperLeft,
        )

        # Restore the pen and brush
        dc.SetPen(savedPen)
        dc.SetBrush(savedBrush)

    def _calculate_sizes(
        self, rect: wx.Rect, trimToSquare: bool
    ) -> Tuple[int, int, int, float]:
        """Calculate the sizes for the gradient drawing.

        Args:
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            trimToSquare (bool): ``True`` to trim the gradient lines in a
                square.

        Returns:
            Tuple[int, int, int, float]: A tuple containing the size, sizeX,
                sizeY and proportion.
        """
        if rect.width > rect.height:
            if trimToSquare:
                size = rect.height
                sizeX = sizeY = rect.height - 1
                proportion = 1.0  # Square proportion is 1.0
            else:
                proportion = float(rect.heigh) / float(rect.width)
                size = rect.width
                sizeX = rect.width - 1
                sizeY = rect.height - 1
        else:
            if trimToSquare:
                size = rect.width
                sizeX = sizeY = rect.width - 1
                proportion = 1.0  # Square proportion is 1.0
            else:
                sizeX = rect.width - 1
                size = rect.height
                sizeY = rect.height - 1
                proportion = float(rect.width) / float(rect.height)
        return size, sizeX, sizeY, proportion

    def _calculate_steps(
        self, startColour: wx.Colour, endColour: wx.Colour, size: int
    ) -> Tuple[float, float, float]:
        """Calculate the gradient steps for the diagonal gradient drawing.

        Args:
            startColour (wx.Colour): The first colour of the gradient shading.
            endColour (wx.Colour): The second colour of the gradient shading.
            size (int): The size of the gradient.

        Returns:
            A tuple containing the rstep, gstep, and bstep.
        """
        # calculate gradient coefficients
        col2 = endColour
        col1 = startColour
        rstep = float(col2.Red() - col1.Red()) / float(size)
        gstep = float(col2.Green() - col1.Green()) / float(size)
        bstep = float(col2.Blue() - col1.Blue()) / float(size)
        return rstep, gstep, bstep

    def _draw_upper_triangle(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        startColour: wx.Colour,
        rstep: float,
        gstep: float,
        bstep: float,
        size: int,
        sizeX: int,
        sizeY: int,
        proportion: float,
        startAtUpperLeft: bool,
    ) -> None:
        """Draw the upper triangle of the diagonal gradient.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            startColour (wx.Colour): The first colour of the gradient shading.
            rstep (float): The red step of the gradient.
            gstep (float): The green step of the gradient.
            bstep (float): The blue step of the gradient.
            size (int): The size of the gradient.
            sizeX (int): The width of the gradient.
            sizeY (int): The height of the gradient.
            proportion (float): The proportion of the gradient.
            startAtUpperLeft (bool): ``True`` to start the gradient lines at
                the upper left corner of the rectangle, ``False`` to start at
                the upper right corner.
        """
        rf, gf, bf = 0.0, 0.0, 0.0
        # draw the upper triangle
        for i in range(size):
            currCol = wx.Colour(
                startColour.Red() + rf,
                startColour.Green() + gf,
                startColour.Blue() + bf,
            )
            dc.SetBrush(wx.Brush(currCol, wx.BRUSHSTYLE_SOLID))
            dc.SetPen(wx.Pen(currCol))
            self._draw_line_and_point(
                dc, rect, i, sizeX, sizeY, proportion, startAtUpperLeft
            )
            rf += rstep / 2
            gf += gstep / 2
            bf += bstep / 2

    def _draw_lower_tiangle(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        startColour: wx.Colour,
        rstep: float,
        gstep: float,
        bstep: float,
        size: int,
        sizeX: int,
        sizeY: int,
        proportion: float,
        startAtUpperLeft: bool,
    ) -> None:
        """Draw the lower triangle of the diagonal gradient.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            startColour (wx.Colour): The first colour of the gradient shading.
            rstep (float): The red step of the gradient.
            gstep (float): The green step of the gradient.
            bstep (float): The blue step of the gradient.
            size (int): The size of the gradient.
            sizeX (int): The width of the gradient.
            sizeY (int): The height of the gradient.
            proportion (float): The proportion of the gradient.
            startAtUpperLeft (bool): ``True`` to start the gradient lines at
                the upper left corner of the rectangle, ``False`` to start at
                the upper right corner.
        """
        rf = rstep * size / 2
        gf = gstep * size / 2
        bf = bstep * size / 2
        # draw the lower triangle
        for i in range(size):
            currCol = wx.Colour(
                startColour.Red() + rf,
                startColour.Green() + gf,
                startColour.Blue() + bf,
            )
            dc.SetBrush(wx.Brush(currCol, wx.BRUSHSTYLE_SOLID))
            dc.SetPen(wx.Pen(currCol))
            self._draw_line_and_point(
                dc, rect, i, sizeX, sizeY, proportion, startAtUpperLeft, lower=True
            )
            rf += rstep / 2
            gf += gstep / 2
            bf += bstep / 2

    def _draw_line_and_point(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        i: int,
        sizeX: int,
        sizeY: int,
        proportion: float,
        startAtUpperLeft: bool,
        lower: bool = False,
    ) -> None:
        """Draw a line and a point for the diagonal gradient.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            i (int): The current step in the gradient.
            sizeX (int): The width of the gradient.
            sizeY (int): The height of the gradient.
            proportion (float): The proportion of the gradient.
            startAtUpperLeft (bool): ``True`` to start the gradient lines at
                the upper left corner of the rectangle, ``False`` to start at
                the upper right corner.
            lower (bool): ``True`` to draw the lower triangle, ``False`` to
                draw the upper triangle.
        """
        if startAtUpperLeft:
            if rect.width > rect.height:
                if lower:
                    dc.DrawLine(
                        rect.x + i,
                        rect.y + sizeY,
                        rect.x + sizeX,
                        int(rect.y + proportion * i),
                    )
                    dc.DrawPoint(rect.x + sizeX, int(rect.y + proportion * i))
                else:
                    dc.DrawLine(
                        rect.x + i, rect.y, rect.x, int(rect.y + proportion * i)
                    )
                    dc.DrawPoint(rect.x, int(rect.y + proportion * i))
            else:
                if lower:
                    dc.DrawLine(
                        int(rect.x + proportion * i),
                        rect.y + sizeY,
                        rect.x + sizeX,
                        rect.y + i,
                    )
                    dc.DrawPoint(rect.x + sizeX, rect.y + i)
                else:
                    dc.DrawLine(
                        int(rect.x + proportion * i), rect.y, rect.x, rect.y + i
                    )
                    dc.DrawPoint(rect.x, rect.y + i)
        else:
            if rect.width > rect.height:
                if lower:
                    dc.DrawLine(
                        rect.x + i, rect.y + sizeY, rect.x + sizeX - i, rect.y + sizeY
                    )
                    dc.DrawPoint(rect.x + sizeX - i, rect.y + sizeY)
                else:
                    dc.DrawLine(
                        rect.x + sizeX - i,
                        rect.y,
                        rect.x + sizeX,
                        int(rect.y + proportion * i),
                    )
                    dc.DrawPoint(rect.x + sizeX, int(rect.y + proportion * i))
            else:
                xTo = max(int(rect.x + sizeX - proportion * i), rect.x)
                if lower:
                    dc.DrawLine(rect.x, rect.y + i, xTo, rect.y + sizeY)
                    dc.DrawPoint(xTo, rect.y + sizeY)
                else:
                    dc.DrawLine(xTo, rect.y, rect.x + sizeX, rect.y + i)
                    dc.DrawPoint(rect.x + sizeX, rect.y + i)

    def PaintCrescentGradientBox(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        startColour: wx.Colour,
        endColour: wx.Colour,
        concave: bool = True,
    ) -> None:
        """Paint a region with gradient colouring.

        The gradient is in crescent shape which fits the 2007 style.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            startColour (wx.Colour): The first colour of the gradient shading.
            endColour (wx.Colour): The second colour of the gradient shading.
            concave (bool): ``True`` for a concave effect, ``False`` for a
                convex one.
        """
        diagonalRectWidth = rect.GetWidth() / 4
        spare = rect.width - 4 * diagonalRectWidth
        leftRect = wx.Rect(rect.x, rect.y, diagonalRectWidth, rect.GetHeight())
        rightRect = wx.Rect(
            rect.x + 3 * diagonalRectWidth + spare,
            rect.y,
            diagonalRectWidth,
            rect.GetHeight(),
        )

        if concave:
            self.PaintStraightGradientBox(
                dc, rect, self.MixColours(startColour, endColour, 50), endColour
            )
            self.PaintDiagonalGradientBox(
                dc, leftRect, startColour, endColour, True, False
            )
            self.PaintDiagonalGradientBox(
                dc, rightRect, startColour, endColour, False, False
            )

        else:
            self.PaintStraightGradientBox(
                dc, rect, endColour, self.MixColours(endColour, startColour, 50)
            )
            self.PaintDiagonalGradientBox(
                dc, leftRect, endColour, startColour, False, False
            )
            self.PaintDiagonalGradientBox(
                dc, rightRect, endColour, startColour, True, False
            )

    def FrameColour(self) -> wx.Colour:
        """Return the surrounding colour for a control.

        Returns:
            wx.Colour: An instance of :class:`wx.Colour`.
        """
        return wx.SystemSettings.GetColour(wx.SYS_COLOUR_ACTIVECAPTION)

    def BackgroundColour(self) -> wx.Colour:
        """Return the background colour of a control when not in focus.

        Returns:
            wx.Colour: An instance of :class:`wx.Colour`.
        """
        return self.LightColour(self.FrameColour(), 75)

    def HighlightBackgroundColour(self) -> wx.Colour:
        """Return the background colour of a control when it is in focus.

        Returns:
            wx.Colour: An instance of :class:`wx.Colour`.
        """
        return self.LightColour(self.FrameColour(), 60)

    def MixColours(
        self, firstColour: wx.Colour, secondColour: wx.Colour, percent: int
    ) -> wx.Colour:
        """Return mix of input colours.

        Args:
            firstColour (wx.Colour): The first colour to be mixed.
            secondColour (wx.Colour): The second colour to be mixed.
            percent (int): The relative percentage of `firstColour` with
                respect to `secondColour`.

        Returns:
            wx.Colour: An instance of :class:`wx.Colour`.
        """
        # calculate gradient coefficients
        redOffset = float(
            (secondColour.Red() * (100 - percent) / 100)
            - (firstColour.Red() * percent / 100)
        )
        greenOffset = float(
            (secondColour.Green() * (100 - percent) / 100)
            - (firstColour.Green() * percent / 100)
        )
        blueOffset = float(
            (secondColour.Blue() * (100 - percent) / 100)
            - (firstColour.Blue() * percent / 100)
        )

        return wx.Colour(
            firstColour.Red() + redOffset,
            firstColour.Green() + greenOffset,
            firstColour.Blue() + blueOffset,
        )

    @classmethod
    def RandomColour(cls) -> wx.Colour:
        """Create a random colour.

        Returns:
            wx.Colour: An instance of :class:`wx.Colour`.
        """
        r = random.randint(0, 255)  # Random value between 0-255
        g = random.randint(0, 255)  # Random value between 0-255
        b = random.randint(0, 255)  # Random value between 0-255
        return wx.Colour(r, g, b)

    def IsDark(self, colour: wx.Colour) -> bool:
        """Return whether a colour is dark or light.

        Args:
            colour (wx.Colour): A :class:`wx.Colour`.

        Returns:
            bool: ``True`` if the average RGB values are dark, ``False``
                otherwise.
        """
        evg = (colour.Red() + colour.Green() + colour.Blue()) / 3
        return evg < 127

    @classmethod
    def TruncateText(cls, dc: wx.DC, text: str, maxWidth: int) -> Union[str, None]:
        """Truncate a given string to fit given width size.

        If the text does not fit into the given width it is truncated to fit.
        The format of the fixed text is ``truncate text ...``.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            text (str): The text to be (eventually) truncated.
            maxWidth (int): The maximum width allowed for the text.

        Returns:
            Union[str, None]: A string containing the (possibly) truncated
                text.
        """
        textLen = len(text)
        tempText = text
        rectSize = maxWidth

        fixedText = ""

        textW, _ = dc.GetTextExtent(text)

        if rectSize >= textW:
            return text

        # The text does not fit in the designated area, so we need to truncate
        # it a bit
        suffix = ".."
        w, _ = dc.GetTextExtent(suffix)
        rectSize -= w

        for _ in range(textLen, -1, -1):
            textW, _ = dc.GetTextExtent(tempText)
            if rectSize >= textW:
                fixedText = tempText
                fixedText += ".."
                return fixedText

            tempText = tempText[:-1]

    def DrawButton(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        theme: int,
        state: int,
        input_: Optional[Union[bool, wx.Colour]] = None,
    ) -> None:
        """Colour rectangle according to the theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The rectangle to be filled with gradient shading.
            theme (int): The theme to use to draw the button.
            state (int): The button state.
            input_ (Optional[Union[bool, wx.Colour]]): A flag used to call the
                right method.
        """
        if input_ is None or isinstance(input_, bool):
            self.DrawButtonTheme(dc, rect, theme, state, bool(input_))
        else:
            self.DrawButtonColour(dc, rect, theme, state, input_)

    def DrawButtonTheme(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        theme: int,
        state: int,
        useLightColours: bool = True,
    ):
        """Draw a button using the appropriate theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The button's client rectangle.
            theme (int): The theme to use to draw the button.
            state (int): The button state.
            useLightColours (bool): ``True`` to use light colours, ``False``
                otherwise.
        """
        renderer = self._renderers[int(theme)]

        # Set background colour if non given by caller
        renderer.DrawButton(dc, rect, state, useLightColours)

    def DrawButtonColour(self, dc, rect, theme, state, colour):
        """Draw a button using the appropriate theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The button's client rectangle.
            theme (int): The theme to use to draw the button.
            state (int): The button state.
            colour (wx.Colour): A valid :class:`wx.Colour` instance.
        """
        renderer = self._renderers[theme]
        renderer.DrawButton(dc, rect, state, colour)

    def CanMakeWindowsTransparent(self) -> bool:
        """Check if the current OS supports transparency.

        Returns:
            bool: ``True`` if the system supports transparency of toplevel
                windows, otherwise returns ``False``.
        """
        if wx.Platform == "__WXMSW__":
            version = wx.GetOsDescription()
            found = (
                version.find("XP") >= 0
                or version.find("2000") >= 0
                or version.find("NT") >= 0
            )
            return found
        elif wx.Platform == "__WXMAC__":
            return True
        else:
            return False

    def MakeWindowTransparent(self, wnd, amount):
        """Make a toplevel window transparent if the system supports it.

        On supported windows systems (Win2000 and greater), this function will
        make a frame window transparent by a certain amount.

        Args:
            wnd (wx.TopLevelWindow): The toplevel window to make transparent.
            amount (int): The window transparency to apply.
        """
        if wnd.GetSize() == (0, 0):
            return

        # This API call is not in all SDKs, only the newer ones,
        # so we will runtime bind this
        if wx.Platform == "__WXMSW__":
            hwnd = wnd.GetHandle()

            if not hasattr(self, "_winlib"):
                if _libimported == "MH":
                    self._winlib = win32api.LoadLibrary("user32")
                elif _libimported == "ctypes":
                    self._winlib = ctypes.windll.user32

            if _libimported == "MH":
                pSetLayeredWindowAttributes = win32api.GetProcAddress(
                    self._winlib, "SetLayeredWindowAttributes"
                )

                if pSetLayeredWindowAttributes is None:
                    return

                exstyle = win32api.GetWindowLong(hwnd, win32con.GWL_EXSTYLE)
                if 0 == (exstyle & 0x80000):
                    win32api.SetWindowLong(
                        hwnd, win32con.GWL_EXSTYLE, exstyle | 0x80000
                    )

                winxpgui.SetLayeredWindowAttributes(hwnd, 0, amount, 2)

            elif _libimported == "ctypes":
                style = self._winlib.GetWindowLongA(hwnd, 0xFFFFFFEC)
                style |= 0x00080000
                self._winlib.SetWindowLongA(hwnd, 0xFFFFFFEC, style)
                self._winlib.SetLayeredWindowAttributes(hwnd, 0, amount, 2)
        else:
            if not wnd.CanSetTransparent():
                return
            wnd.SetTransparent(amount)

    def DrawBitmapShadow(self, dc, rect, where=BottomShadow | RightShadow):
        """Draw a shadow using background bitmap.

        Assumption: the background was already drawn on the dc

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The bitmap's client rectangle.
            where (int): Where to draw the shadow. This can be any combination
                of the following bits:

                ===================== ======= =======================
                Shadow Settings        Value  Description
                ===================== ======= =======================
                ``RightShadow``             1 Right side shadow
                ``BottomShadow``            2 Not full bottom shadow
                ``BottomShadowFull``        4 Full bottom shadow
                ===================== ======= =======================
        """
        shadowSize = 5

        # the rect must be at least 5x5 pixels
        if rect.height < 2 * shadowSize or rect.width < 2 * shadowSize:
            return

        # Start by drawing the right bottom corner
        if where & BottomShadow or where & BottomShadowFull:
            dc.DrawBitmap(
                self._rightBottomCorner, rect.x + rect.width, rect.y + rect.height, True
            )

        # Draw right side shadow
        xx = rect.x + rect.width
        yy = rect.y + rect.height - shadowSize

        if where & RightShadow:
            while yy - rect.y > 2 * shadowSize:
                dc.DrawBitmap(self._right, xx, yy, True)
                yy -= shadowSize

            dc.DrawBitmap(self._rightTop, xx, yy - shadowSize, True)

        if where & BottomShadow:
            xx = rect.x + rect.width - shadowSize
            yy = rect.height + rect.y
            while xx - rect.x > 2 * shadowSize:
                dc.DrawBitmap(self._bottom, xx, yy, True)
                xx -= shadowSize

            dc.DrawBitmap(self._bottomLeft, xx - shadowSize, yy, True)

        if where & BottomShadowFull:
            xx = rect.x + rect.width - shadowSize
            yy = rect.height + rect.y
            while xx - rect.x >= 0:
                dc.DrawBitmap(self._bottom, xx, yy, True)
                xx -= shadowSize

            dc.DrawBitmap(self._bottom, xx, yy, True)

    def DropShadow(self, wnd: wx.TopLevelWindow, drop=True) -> None:
        """Add a shadow under the window (Windows only).

        Args:
            wnd (wx.TopLevelWindow): The window for which we are dropping a
                shadow.
            drop (bool): ``True`` to drop a shadow, ``False`` to remove it.
        """
        if not self.CanMakeWindowsTransparent() or not _libimported:
            return

        if "__WXMSW__" in wx.Platform:
            hwnd = wnd.GetHandle()

            if not hasattr(self, "_winlib"):
                if _libimported == "MH":
                    self._winlib = win32api.LoadLibrary("user32")
                elif _libimported == "ctypes":
                    self._winlib = ctypes.windll.user32

            if _libimported == "MH":
                csstyle = win32api.GetWindowLong(hwnd, win32con.GCL_STYLE)
            else:
                csstyle = self._winlib.GetWindowLongA(hwnd, win32con.GCL_STYLE)

            if drop:
                if csstyle & CS_DROPSHADOW:
                    return
                else:
                    csstyle |= CS_DROPSHADOW  # Nothing to be done
            else:
                if csstyle & CS_DROPSHADOW:
                    csstyle &= ~(CS_DROPSHADOW)
                else:
                    return  # Nothing to be done

            win32api.SetWindowLong(hwnd, win32con.GCL_STYLE, csstyle)

    def GetBitmapStartLocation(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        bitmap: wx.Bitmap,
        text: str = "",
        style: int = 0,
    ) -> Tuple[float, float]:
        """Return the top left `x` and `y` coordinates of the bitmap drawing.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The bitmap's client rectangle.
            bitmap (wx.Bitmap): The bitmap associated with the button.
            text (str): The button label.
            style (int): The button style. This can be one of the following bits:

                ============================== ======= ================================
                Button style                    Value  Description
                ============================== ======= ================================
                ``BU_EXT_XP_STYLE``               1    A button with a XP style
                ``BU_EXT_2007_STYLE``             2    A button with a MS Office 2007
                                                       style
                ``BU_EXT_LEFT_ALIGN_STYLE``       4    A left-aligned button
                ``BU_EXT_CENTER_ALIGN_STYLE``     8    A center-aligned button
                ``BU_EXT_RIGHT_ALIGN_STYLE``      16   A right-aligned button
                ``BU_EXT_RIGHT_TO_LEFT_STYLE``    32   A button suitable for
                                                       right-to-left languages
                ============================== ======= ================================


        Returns:
            Tuple[float, float]: A tuple containing the top left `x` and `y`
                coordinates of the bitmap drawing.
        """
        alignmentBuffer = self.GetAlignBuffer()

        # get the startLocationY
        fixedTextWidth = fixedTextHeight = 0

        if not text:
            fixedTextHeight = bitmap.GetHeight()
        else:
            fixedTextWidth, fixedTextHeight = dc.GetTextExtent(text)

        startLocationY = rect.y + (rect.height - fixedTextHeight) / 2

        # get the startLocationX
        if style & BU_EXT_RIGHT_TO_LEFT_STYLE:
            startLocationX = rect.x + rect.width - alignmentBuffer - bitmap.GetWidth()
        else:
            if style & BU_EXT_RIGHT_ALIGN_STYLE:
                maxWidth = (
                    rect.x + rect.width - (2 * alignmentBuffer) - bitmap.GetWidth()
                )  # the alignment is for both sides

                # get the truncated text. The text may stay as is, it is not a
                # must that is will be truncated
                fixedText = self.TruncateText(dc, text, maxWidth)

                # get the fixed text dimensions
                fixedTextWidth, _ = dc.GetTextExtent(fixedText)

                # calculate the start location
                startLocationX = maxWidth - fixedTextWidth

            elif style & BU_EXT_LEFT_ALIGN_STYLE:
                # calculate the start location
                startLocationX = alignmentBuffer

            else:  # meaning BU_EXT_CENTER_ALIGN_STYLE
                maxWidth = (
                    rect.x + rect.width - (2 * alignmentBuffer) - bitmap.GetWidth()
                )  # the alignment is for both sides

                # get the truncated text. The text may stay as is, it is not a
                # must that is will be truncated
                fixedText = self.TruncateText(dc, text, maxWidth)

                # get the fixed text dimensions
                fixedTextWidth, _ = dc.GetTextExtent(fixedText)

                if maxWidth > fixedTextWidth:
                    # calculate the start location
                    startLocationX = (maxWidth - fixedTextWidth) / 2

                else:
                    # calculate the start location
                    startLocationX = maxWidth - fixedTextWidth

        # it is very important to validate that the start location is not less
        # than the alignment buffer
        if startLocationX < alignmentBuffer:
            startLocationX = alignmentBuffer

        return startLocationX, startLocationY

    def GetTextStartLocation(
        self, dc: wx.DC, rect: wx.Rect, bitmap: wx.Bitmap, text: str, style: int = 0
    ) -> Tuple[float, float, Union[str, None]]:
        """Return the top left `x` and `y` coordinates of the text drawing.

        In case the text is too long, the text is being fixed (the text is cut
        and a '...' mark is added in the end).

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The text's client rectangle.
            bitmap (wx.Bitmap): The bitmap associated with the button.
            text (str): The button label.
            style (int): The button style.

        Returns:
            Tuple[float, float, Union[str, None]]: A tuple containing the top
                left `x` and `y` coordinates of the text drawing, plus the
                truncated version of the input `text`.

        See :meth:`~ArtManager.GetBitmapStartLocation`for a list of valid button
        styles.
        """
        alignmentBuffer = self.GetAlignBuffer()

        # get the bitmap offset
        bitmapOffset = 0
        if bitmap != wx.NullBitmap:
            bitmapOffset = bitmap.GetWidth()

        # get the truncated text.
        # The text may stay as is, it is not a must that it will be truncated
        maxWidth = (
            rect.x + rect.width - (2 * alignmentBuffer) - bitmapOffset
        )  # the alignment is for both sides
        fixedText = self.TruncateText(dc, text, maxWidth)

        # get the fixed text dimensions
        fixedTextWidth, fixedTextHeight = dc.GetTextExtent(fixedText)
        startLocationY = (rect.height - fixedTextHeight) / 2 + rect.y

        # get the startLocationX
        if style & BU_EXT_RIGHT_TO_LEFT_STYLE:
            startLocationX = maxWidth - fixedTextWidth + alignmentBuffer
        else:
            if style & BU_EXT_LEFT_ALIGN_STYLE:
                # calculate the start location
                startLocationX = bitmapOffset + alignmentBuffer
            elif style & BU_EXT_RIGHT_ALIGN_STYLE:
                # calculate the start location
                startLocationX = (
                    maxWidth - fixedTextWidth + bitmapOffset + alignmentBuffer
                )
            else:  # meaning wxBU_EXT_CENTER_ALIGN_STYLE
                # calculate the start location
                startLocationX = (
                    (maxWidth - fixedTextWidth) / 2 + bitmapOffset + alignmentBuffer
                )

        # it is very important to validate that the start location is not less
        # than the alignment buffer
        if startLocationX < alignmentBuffer:
            startLocationX = alignmentBuffer

        return startLocationX, startLocationY, fixedText

    def DrawTextAndBitmap(
        self,
        dc: wx.DC,
        rect: wx.Rect,
        text: str,
        enable: bool = True,
        font: wx.Font = wx.NullFont,
        fontColour: wx.Colour = wx.BLACK,
        bitmap: wx.Bitmap = wx.NullBitmap,
        grayBitmap: wx.Bitmap = wx.NullBitmap,
        style: int = 0,
    ) -> None:
        """Draw the text & bitmap on the input dc.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The text and bitmap client rectangle.
            text (str): the button label.
            enable (bool): ``True`` if the button is enabled, ``False`` otherwise.
            font (wx.Font): The font to use to draw the text.
            fontColour (wx.Colour): The colour to use to draw the text.
            bitmap (wx.Bitmap): The bitmap associated with the button.
            grayBitmap (wx.Bitmap): A greyed-out version of the input `bitmap`
                representing a disabled bitmap.
            style (int): The button style.

        See: :meth:`~ArtManager.GetBitmapStartLocation` for a list of valid button
            styles.
        """
        # enable colours
        if enable:
            dc.SetTextForeground(fontColour)
        else:
            dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))

        # set the font
        if font.IsSameAs(wx.NullFont):
            font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)

        dc.SetFont(font)

        startLocationX = startLocationY = 0.0

        if not bitmap.IsSameAs(wx.NullBitmap):
            # calculate the bitmap start location
            startLocationX, startLocationY = self.GetBitmapStartLocation(
                dc, rect, bitmap, text, style
            )

            # draw the bitmap
            if enable:
                dc.DrawBitmap(bitmap, startLocationX, startLocationY, True)
            else:
                dc.DrawBitmap(grayBitmap, startLocationX, startLocationY, True)

        # calculate the text start location
        location, labelOnly = self.GetAccelIndex(text)
        startLocationX, startLocationY, fixedText = self.GetTextStartLocation(
            dc, rect, bitmap, labelOnly, style
        )

        if fixedText is None:
            fixedText = ""

        # after all the calculations are finished, it is time to draw the text underline
        # the first letter that is marked with a '&'
        if location == -1 or font.GetUnderlined() or location >= len(fixedText):
            # draw the text
            dc.DrawText(fixedText, startLocationX, startLocationY)
        else:
            # underline the first '&'
            before = fixedText[0:location]
            underlineLetter = fixedText[location]
            after = fixedText[location + 1 :]

            # before
            dc.DrawText(before, startLocationX, startLocationY)

            # underlineLetter
            if "__WXGTK__" not in wx.Platform:
                w1, _ = dc.GetTextExtent(before)
                font.SetUnderlined(True)
                dc.SetFont(font)
                dc.DrawText(underlineLetter, startLocationX + w1, startLocationY)
            else:
                w1, _ = dc.GetTextExtent(before)
                dc.DrawText(underlineLetter, startLocationX + w1, startLocationY)

                # Draw the underline ourselves since using the Underline in GTK,
                # causes the line to be too close to the letter
                uderlineLetterW, uderlineLetterH = dc.GetTextExtent(underlineLetter)

                curPen = dc.GetPen()
                dc.SetPen(wx.BLACK_PEN)

                dc.DrawLine(
                    startLocationX + w1,
                    startLocationY + uderlineLetterH - 2,
                    startLocationX + w1 + uderlineLetterW,
                    startLocationY + uderlineLetterH - 2,
                )
                dc.SetPen(curPen)

            # after
            w2, _ = dc.GetTextExtent(underlineLetter)
            font.SetUnderlined(False)
            dc.SetFont(font)
            dc.DrawText(after, startLocationX + w1 + w2, startLocationY)

    def CalcButtonBestSize(self, label: str, bmp: wx.Bitmap) -> wx.Size:
        """Return the best fit size for the supplied label & bitmap.

        Args:
            label (str): The button label.
            bmp (wx.Bitmap): The bitmap associated with the button.

        Returns:
            wx.Size: Representing the best fit size for the supplied label & bitmap.
        """
        if "__WXMSW__" in wx.Platform:
            HEIGHT = 22
        else:
            HEIGHT = 26

        dc = wx.MemoryDC()
        dc.SelectBitmap(wx.Bitmap(1, 1))

        dc.SetFont(wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT))
        width, height, _ = dc.GetFullMultiLineTextExtent(label)

        width += 2 * self.GetAlignBuffer()

        if bmp.IsOk():
            # allocate extra space for the bitmap
            heightBmp = bmp.GetHeight() + 2
            if height < heightBmp:
                height = heightBmp

            width += bmp.GetWidth() + 2

        if height < HEIGHT:
            height = HEIGHT

        dc.SelectBitmap(wx.NullBitmap)

        return wx.Size(width, height)

    def GetMenuFaceColour(self) -> wx.Colour:
        """Return the colour used for the menu foreground.

        Returns:
            wx.Colour: The colour used for the menu foreground.
        """
        renderer = self._renderers[self.GetMenuTheme()]
        return renderer.GetMenuFaceColour()

    def GetTextColourEnable(self) -> wx.Colour:
        """Return the colour used for enabled menu items.

        Returns:
            wx.Colour: The colour used for enabled menu items.
        """
        renderer = self._renderers[self.GetMenuTheme()]
        return renderer.GetTextColourEnable()

    def GetTextColourDisable(self) -> wx.Font:
        """Return the colour used for disabled menu items.

        Returns:
            wx.Colour: The colour used for disabled menu items.
        """
        renderer = self._renderers[self.GetMenuTheme()]
        return renderer.GetTextColourDisable()

    def GetFont(self) -> wx.Font:
        """Return the font used by this theme.

        Returns:
            wx.Font: The font used by this theme.
        """
        renderer = self._renderers[self.GetMenuTheme()]
        return renderer.GetFont()

    def GetAccelIndex(self, label: str) -> Tuple[int, str]:
        """Return the mnemonic index and the label without the ampersand mnemonic.

        (e.g. 'lab&el' ==> will result in 3 and labelOnly = label).

        Args:
            label (str): A string containing an ampersand.

        Returns:
            Tuple[int, str]: A tuple containing the mnemonic index of the label
                and the label stripped of the ampersand mnemonic.
        """
        indexAccel = 0
        while True:
            indexAccel = label.find("&", indexAccel)
            if indexAccel == -1:
                return indexAccel, label
            if label[indexAccel : indexAccel + 2] == "&&":
                label = label[0:indexAccel] + label[indexAccel + 1 :]
                indexAccel += 1
            else:
                break

        labelOnly = label[0:indexAccel] + label[indexAccel + 1 :]

        return indexAccel, labelOnly

    def GetThemeBaseColour(
        self, useLightColours: Union[None, bool] = True
    ) -> wx.Colour:
        """Return the theme base colour.

        If no theme is active, return the active caption colour lightened by 30%.

        Args:
            useLightColours (Union[None, bool]): ``True`` to use light colours,
                ``False`` otherwise.

        Returns:
            wx.Colour: The theme base colour or the 30% lightened active caption
                colour.
        """
        if not useLightColours and not self.IsDark(self.FrameColour()):
            return wx.Colour("GOLD")
        else:
            return self.LightColour(self.FrameColour(), 30)

    def GetAlignBuffer(self) -> int:
        """Return the padding buffer for a text or bitmap.

        Returns:
            int: An integer representing the padding buffer.
        """
        return self._alignmentBuffer

    def SetMenuTheme(self, theme: int) -> None:
        """Set the menu theme, possible values (Style2007, StyleXP, StyleVista).

        Args:
            theme (int): A rendering theme class, either `StyleXP`, `Style2007` or
                `StyleVista`.
        """
        self._menuTheme = theme

    def GetMenuTheme(self) -> int:
        """Return the currently used menu theme.

        Returns:
            int: An int containing the currently used theme for the menu.
        """
        return self._menuTheme

    def AddMenuTheme(self, render: RendererBase) -> int:
        """Add a new theme to the stock.

        Args:
            render (RendererBase): A rendering theme class, which must be
                derived from :class:`RendererBase`.

        Returns:
            int: An integer representing the size of the renderers dictionary.
        """
        # Add new theme
        lastRenderer = len(self._renderers)
        self._renderers[lastRenderer] = render

        return lastRenderer

    def SetMS2007ButtonSunken(self, sunken: bool) -> None:
        """Set MS 2007 button style sunken or not.

        Args:
            sunken (bool): ``True`` to have a sunken border effect, ``False``
                otherwise.
        """
        self._ms2007sunken = sunken

    def GetMS2007ButtonSunken(self) -> bool:
        """Return the sunken flag for MS 2007 buttons.

        Returns:
            bool: ``True`` if the MS 2007 buttons are sunken, ``False`` otherwise.
        """
        return self._ms2007sunken

    def GetMBVerticalGradient(self) -> bool:
        """Return ``True`` if the menu bar should be painted with vertical gradient.

        Returns:
            bool: A boolean indicating whether the menu bar should be painted with
                vertical gradient.
        """
        return self._verticalGradient

    def SetMBVerticalGradient(self, v: bool) -> None:
        """Set the menu bar gradient style.

        Args:
            v (bool): ``True`` for a vertical shaded gradient, ``False`` otherwise.
        """
        self._verticalGradient = v

    def DrawMenuBarBorder(self, border: bool) -> None:
        """Enable menu border drawing (XP style only).

        Args:
            border (bool): ``True`` to draw the menubar border, ``False`` otherwise.
        """
        self._drowMBBorder = border

    def GetMenuBarBorder(self) -> bool:
        """Return menu bar border drawing flag.

        Returns:
            bool: ``True`` if the menu bar border is to be drawn, ``False`` otherwise.
        """
        return self._drowMBBorder

    def GetMenuBgFactor(self) -> int:
        """Return the visibility depth of the menu in Metallic style.

        The higher the value, the menu bar will look more raised.

        Returns:
            int: An integer representing the visibility depth of the menu.
        """
        return self._menuBgFactor

    def DrawDragSash(self, rect: wx.Rect) -> None:
        """Draw resize sash.

        Args:
            rect (wx.Rect): The sash client rectangle.
        """
        dc = wx.ScreenDC()
        mem_dc = wx.MemoryDC()

        bmp = wx.Bitmap(rect.width, rect.height)
        mem_dc.SelectObject(bmp)
        mem_dc.SetBrush(wx.WHITE_BRUSH)
        mem_dc.SetPen(wx.Pen(wx.WHITE, 1))
        mem_dc.DrawRectangle(0, 0, rect.width, rect.height)

        dc.Blit(rect.x, rect.y, rect.width, rect.height, mem_dc, 0, 0, wx.XOR)

    def TakeScreenShot(self, rect: wx.Rect, bmp: wx.Bitmap) -> None:
        """Take a screenshot of the screen at given position & size (rect).

        Args:
            rect (wx.Rect): The screen rectangle we wish to capture.
            bmp (wx.Bitmap): Currently unused.
        """
        # Create a DC for the whole screen area
        dcScreen = wx.ScreenDC()

        # Create a Bitmap that will later on hold the screenshot image
        # Note that the Bitmap must have a size big enough to hold the screenshot
        # -1 means using the current default colour depth
        bmp = wx.Bitmap(rect.width, rect.height)

        # Create a memory DC that will be used for actually taking the screenshot
        memDC = wx.MemoryDC()

        # Tell the memory DC to use our Bitmap
        # all drawing action on the memory DC will go to the Bitmap now
        memDC.SelectObject(bmp)

        # Blit (in this case copy)
        # the actual screen on the memory DC and thus the Bitmap
        memDC.Blit(
            0,  # Copy to this X coordinate
            0,  # Copy to this Y coordinate
            rect.width,  # Copy this width
            rect.height,  # Copy this height
            dcScreen,  # From where do we copy?
            rect.x,  # What's the X offset in the original DC?
            rect.y,  # What's the Y offset in the original DC?
        )

        # Select the Bitmap out of the memory DC by selecting a new uninitialized Bitmap
        memDC.SelectObject(wx.NullBitmap)

    def DrawToolBarBg(self, dc: wx.DC, rect: wx.Rect) -> None:
        """Draw the toolbar background according to the active theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The toolbar's client rectangle.
        """
        renderer = self._renderers[self.GetMenuTheme()]

        # Set background colour if non given by caller
        renderer.DrawToolBarBg(dc, rect)

    def DrawMenuBarBg(self, dc: wx.DC, rect: wx.Rect) -> None:
        """Draw the menu bar background according to the active theme.

        Args:
            dc (wx.DC): A :class:`wx.DC` instance.
            rect (wx.Rect): The menubar's client rectangle.
        """
        renderer = self._renderers[self.GetMenuTheme()]
        # Set background colour if non given by caller
        renderer.DrawMenuBarBg(dc, rect)

    def SetMenuBarColour(self, scheme: str) -> None:
        """Set the menu bar colour scheme to use.

        Args:
            scheme (str): A string representing a colour scheme (i.e., 'Default',
                'Dark', 'Dark Olive Green', 'Generic').
        """
        self._menuBarColourScheme = scheme
        # set default colour
        if scheme in self._colourSchemeMap:
            self._menuBarBgColour = self._colourSchemeMap[scheme]

    def GetMenuBarColourScheme(self) -> str:
        """Return the current colour scheme.

        Returns:
            str: A string representing the current colour scheme.
        """
        return self._menuBarColourScheme

    def GetMenuBarFaceColour(self) -> wx.Colour:
        """Return the menu bar face colour.

        Returns:
            wx.Colour: The menu bar face colour.
        """
        return self._menuBarBgColour

    def GetMenuBarSelectionColour(self) -> wx.Colour:
        """Return the menu bar selection colour.

        Returns:
            wx.Colour: The menu bar selection colour.
        """
        return self._menuBarSelColour

    def InitColours(self) -> None:
        """Initialise the colour map."""
        self._colourSchemeMap = {
            _("Default"): wx.SystemSettings.GetColour(wx.SYS_COLOUR_3DFACE),
            _("Dark"): wx.BLACK,
            _("Dark Olive Green"): wx.Colour("DARK OLIVE GREEN"),
            _("Generic"): wx.SystemSettings.GetColour(wx.SYS_COLOUR_ACTIVECAPTION),
        }

    def GetColourSchemes(self) -> List[str]:
        """Return the available colour schemes.

        Returns:
            List[str]: A list of strings representing the available colour
                schemes.
        """
        return list(self._colourSchemeMap)

    def CreateGreyBitmap(self, bmp):
        """Create a grey bitmap image from the input bitmap.

        Args:
            bmp (wx.Bitmap): A valid :class:`wx.Bitmap` object to be greyed out.

        Returns:
            wx.Bitmap: A greyed-out representation of the input bitmap.
        """
        img = bmp.ConvertToImage()
        return wx.Bitmap(img.ConvertToGreyscale())

    def GetRaiseToolbar(self) -> bool:
        """Return ``True`` if we are dropping a shadow under a toolbar.

        Returns:
            bool: A boolean indicating whether a shadow is dropped under a
                toolbar.
        """
        return self._raiseTB

    def SetRaiseToolbar(self, rais: bool) -> None:
        """Enable/disable toobar shadow drop.

        Args:
            rais (bool): ``True`` to drop a shadow below a toolbar, ``False``
                otherwise.
        """
        self._raiseTB = rais