meerk40t 0.9.2000__py2.py3-none-any.whl → 0.9.3001__py2.py3-none-any.whl

meerk40t/gui/ribbon.py

@@ -7,13 +7,13 @@ The primary method of defining a panel is by calling the `set_buttons()` on the
 control_panel.set_buttons(
     {
         "label": _("Red Dot On"),
-        "icon": icons8_quick_mode_on_50,
+        "icon": icons8_flash_on,
         "tip": _("Turn Redlight On"),
         "action": lambda v: service("red on\n"),
         "toggle": {
             "label": _("Red Dot Off"),
             "action": lambda v: service("red off\n"),
-            "icon": icons8_flash_off_50,
+            "icon": icons8_flash_off,
             "signal": "grbl_red_dot",
         },
         "rule_enabled": lambda v: has_red_dot_enabled(),
@@ -53,8 +53,9 @@ from meerk40t.svgelements import Color
 
 _ = wx.GetTranslation
 
-SMALL_RESIZE_FACTOR = 2 / 3
-TINY_RESIZE_FACTOR = 0.5
+COLOR_MODE_DEFAULT = 0
+COLOR_MODE_COLOR = 1
+COLOR_MODE_DARK = 2
 
 
 class DropDown:
@@ -101,20 +102,22 @@ class Button:
         self._aspects = {}
         self.key = "original"
         self.object = None
-        self.bitmapsize = "large"
 
         self.position = None
         self.toggle = False
 
         self.label = None
+        self.icon = None
+
         self.bitmap = None
         self.bitmap_disabled = None
-        self.bitmap_tiny_disabled = None
-        self.bitmap_small_disabled = None
-        self.bitmap_large_disabled = None
-        self.bitmap_tiny = None
-        self.bitmap_small = None
-        self.bitmap_large = None
+
+        self.min_size = 15
+        self.max_size = 150
+
+        self.available_bitmaps = {}
+        self.available_bitmaps_disabled = {}
+
         self.tip = None
         self.client_data = None
         self.state = 0
@@ -132,35 +135,11 @@ class Button:
         self.rule_visible = None
         self.min_width = 0
         self.min_height = 0
-        self.default_width = 50
+        self.default_width = int(self.max_size / 2)
+        self.icon_size = self.default_width
+
         self.set_aspect(**description)
         self.apply_enable_rules()
-        # self.sizes = {
-        #     "large_label": (0, 0),
-        #     "small_label": (0, 0),
-        #     "tiny_label": (0, 0),
-        #     "large": (0, 0),
-        #     "small": (0, 0),
-        #     "tiny": (0, 0),
-        # }
-
-    # def calc_sizes(self, dc):
-    #     def calc(bmap, uselabel):
-    #         w = 0
-    #         h = 0
-    #         return w, h
-    #     bw, bh = calc(self.bitmap_large, True)
-    #     self.sizes["large_label"] = (bw, bh)
-    #     bw, bh = calc(self.bitmap_large, False)
-    #     self.sizes["large"] = (bw, bh)
-    #     bw, bh = calc(self.bitmap_small, True)
-    #     self.sizes["small_label"] = (bw, bh)
-    #     bw, bh = calc(self.bitmap_small, False)
-    #     self.sizes["small"] = (bw, bh)
-    #     bw, bh = calc(self.bitmap_tiny, True)
-    #     self.sizes["tiny_label"] = (bw, bh)
-    #     bw, bh = calc(self.bitmap_tiny, False)
-    #     self.sizes["tiny"] = (bw, bh)
 
     def set_aspect(
         self,
@@ -195,63 +174,25 @@ class Button:
         @return:
         """
         self.label = label
-        self.icon = icon
         resize_param = kwargs.get("size")
         if resize_param is None:
-            resize_param = 50
-        if resize_param is None:
-            # We can get the real icon width, that means though
-            # all buttons will have slightly different dimensions
-            # so we set the minimum size
-            siz = icon.GetBitmap().GetSize()
-            wd = max(self.default_width, siz[0])
-            small_resize = int(SMALL_RESIZE_FACTOR * wd)
-            tiny_resize = int(TINY_RESIZE_FACTOR * wd)
-            # print (f"No size parameter given for: {label}")
-
+            self.default_width = int(self.max_size / 2)
         else:
             self.default_width = resize_param
-            small_resize = int(SMALL_RESIZE_FACTOR * resize_param)
-            tiny_resize = int(TINY_RESIZE_FACTOR * resize_param)
 
-        top = self.parent.parent.parent
-        if top.art.dark_mode:
-            targetcolor = Color("white")
-            darkm = True
-        else:
-            targetcolor = None
-            darkm = False
         # We need to cast the icon explicitly to PyEmbeddedImage
         # as otherwise a strange type error is thrown:
         # TypeError: GetBitmap() got an unexpected keyword argument 'force_darkmode'
         # Well...
+        from meerk40t.gui.icons import PyEmbeddedImage, VectorIcon
 
-        icon = PyEmbeddedImage(icon.data)
-        self.bitmap_large = icon.GetBitmap(
-            resize=resize_param,
-            noadjustment=True,
-            force_darkmode=darkm,
-        )
-        self.bitmap_large_disabled = icon.GetBitmap(
-            resize=resize_param,
-            color=Color("grey"),
-            noadjustment=True,
-            force_darkmode=darkm,
-        )
-        self.bitmap_small = icon.GetBitmap(
-            resize=small_resize, noadjustment=True, force_darkmode=darkm
-        )
-        self.bitmap_small_disabled = icon.GetBitmap(
-            resize=small_resize, color=Color("grey"), noadjustment=True
-        )
-        self.bitmap_tiny = icon.GetBitmap(
-            resize=tiny_resize, noadjustment=True, force_darkmode=darkm
-        )
-        self.bitmap_tiny_disabled = icon.GetBitmap(
-            resize=tiny_resize, color=Color("grey"), noadjustment=True
-        )
-        self.bitmap = self.bitmap_large
-        self.bitmap_disabled = self.bitmap_large_disabled
+        if not isinstance(icon, VectorIcon):
+            icon = PyEmbeddedImage(icon.data)
+        self.icon = icon
+
+        self.available_bitmaps.clear()
+        self.available_bitmaps_disabled.clear()
+        self.get_bitmaps(self.default_width)
 
         self.tip = tip
         self.group = group
@@ -269,6 +210,32 @@ class Button:
             self.dropdown = DropDown()
         self.modified()
 
+    def get_bitmaps(self, point_size):
+        top = self.parent.parent.parent
+        darkm = bool(top.art.color_mode == COLOR_MODE_DARK)
+        if point_size < self.min_size:
+            point_size = self.min_size
+        if point_size > self.max_size:
+            point_size = self.max_size
+        self.icon_size = int(point_size)
+        edge = int(point_size / 25.0) + 1
+        key = str(self.icon_size)
+        if key not in self.available_bitmaps:
+            self.available_bitmaps[key] = self.icon.GetBitmap(
+                resize=self.icon_size,
+                noadjustment=True,
+                force_darkmode=darkm,
+                buffer=edge,
+            )
+            self.available_bitmaps_disabled[key] = self.icon.GetBitmap(
+                resize=self.icon_size,
+                color=Color("grey"),
+                noadjustment=True,
+                buffer=edge,
+            )
+        self.bitmap = self.available_bitmaps[key]
+        self.bitmap_disabled = self.available_bitmaps_disabled[key]
+
     def _restore_button_aspect(self, key):
         """
         Restores a saved button aspect for the given key. Given a key to the alternative aspect we restore the given
@@ -432,7 +399,7 @@ class Button:
             if icon:
                 # There seems to be a bug to display icons in a submenu consistently
                 # print (f"Had a bitmap for {v.get('label')}")
-                item.SetBitmap(icon.GetBitmap(resize=STD_ICON_SIZE / 2))
+                item.SetBitmap(icon.GetBitmap(resize=STD_ICON_SIZE / 2, buffer=2))
             top.Bind(wx.EVT_MENU, self.drop_menu_click(v), id=item.GetId())
         top.PopupMenu(menu)
 
@@ -589,6 +556,7 @@ class RibbonPanel:
 
         self.buttons = []
         self.position = None
+        self.available_position = None
         self._overflow = list()
         self._overflow_position = None
 
@@ -730,7 +698,7 @@ class RibbonPanel:
             item.Enable(v.enabled)
             item.SetHelp(v.tip)
             if v.icon:
-                item.SetBitmap(v.icon.GetBitmap(resize=STD_ICON_SIZE / 2))
+                item.SetBitmap(v.icon.GetBitmap(resize=STD_ICON_SIZE / 2, buffer=2))
             top.Bind(wx.EVT_MENU, v.click, id=item.Id)
         top.PopupMenu(menu)
 
@@ -1059,12 +1027,59 @@ class RibbonBarPanel(wx.Control):
         """
         pos = event.Position
         button = self._button_at_position(pos)
-        if button is None:
-            return
         if button is not None:
             action = button.action_right
             if action:
                 action(event)
+        else:
+            # Click on background, off menu to edit and set colors
+            def set_color(newmode):
+                self.context.root.ribbon_color = newmode
+                # Force refresh
+                self.context.signal("ribbon_recreate", None)
+
+            top = self  # .parent
+            c_mode = self.context.root.setting(int, "ribbon_color", COLOR_MODE_DEFAULT)
+            menu = wx.Menu()
+            item = menu.Append(wx.ID_ANY, _("Colorscheme"))
+            item.Enable(False)
+            item = menu.Append(wx.ID_ANY, _("System Default"), "", wx.ITEM_CHECK)
+            item.Check(bool(c_mode == COLOR_MODE_DEFAULT))
+            top.Bind(
+                wx.EVT_MENU, lambda v: set_color(COLOR_MODE_DEFAULT), id=item.GetId()
+            )
+            item = menu.Append(wx.ID_ANY, _("Colored"), "", wx.ITEM_CHECK)
+            item.Check(bool(c_mode == COLOR_MODE_COLOR))
+            top.Bind(
+                wx.EVT_MENU, lambda v: set_color(COLOR_MODE_COLOR), id=item.GetId()
+            )
+            item = menu.Append(wx.ID_ANY, _("Black"), "", wx.ITEM_CHECK)
+            item.Check(bool(c_mode == COLOR_MODE_DARK))
+            top.Bind(wx.EVT_MENU, lambda v: set_color(COLOR_MODE_DARK), id=item.GetId())
+            item = menu.AppendSeparator()
+            haslabel = self.art.show_labels
+            item = menu.Append(wx.ID_ANY, _("Show Labels"), "", wx.ITEM_CHECK)
+            if not getattr(self, "allow_labels", True):
+                item.Enable(False)
+            item.Check(haslabel)
+            top.Bind(
+                wx.EVT_MENU,
+                lambda v: self.toggle_show_labels(not haslabel),
+                id=item.GetId(),
+            )
+            item = menu.AppendSeparator()
+            item = menu.Append(wx.ID_ANY, _("Customize Toolbars"))
+
+            def show_pref():
+                self.context("window open Preferences\n")
+                self.context.signal("preferences", "ribbon")
+
+            top.Bind(
+                wx.EVT_MENU,
+                lambda v: show_pref(),
+                id=item.GetId(),
+            )
+            top.PopupMenu(menu)
 
     def on_click(self, event: wx.MouseEvent):
         """
@@ -1213,14 +1228,14 @@ class Art:
         self.text_dropdown_buffer = 7
         self.show_labels = True
 
-        self._establish_colors()
+        self.establish_colors()
 
         self.current_page = None
         self.hover_tab = None
         self.hover_button = None
         self.hover_dropdown = None
 
-    def _establish_colors(self):
+    def establish_colors(self):
         self.text_color = copy.copy(
             wx.SystemSettings().GetColour(wx.SYS_COLOUR_BTNTEXT)
         )
@@ -1230,12 +1245,12 @@ class Art:
             wx.SystemSettings().GetColour(wx.SYS_COLOUR_BTNTEXT)
         )
 
-        # self.button_face_hover = copy.copy(
-        #     wx.SystemSettings().GetColour(wx.SYS_COLOUR_HIGHLIGHT)
-        # ).ChangeLightness(50)
         self.button_face_hover = copy.copy(
-            wx.SystemSettings().GetColour(wx.SYS_COLOUR_BTNHILIGHT)
-        )  # .ChangeLightness(25)
+            wx.SystemSettings().GetColour(wx.SYS_COLOUR_HIGHLIGHT)
+        ).ChangeLightness(150)
+        # self.button_face_hover = copy.copy(
+        #     wx.SystemSettings().GetColour(wx.SYS_COLOUR_GRADIENTACTIVECAPTION)
+        # )
         self.inactive_background = copy.copy(
             wx.SystemSettings().GetColour(wx.SYS_COLOUR_INACTIVECAPTION)
         )
@@ -1249,21 +1264,34 @@ class Art:
             wx.SystemSettings().GetColour(wx.SYS_COLOUR_INFOBK)
         )
         self.button_face = copy.copy(
-            wx.SystemSettings().GetColour(wx.SYS_COLOUR_BTNFACE)
+            wx.SystemSettings().GetColour(wx.SYS_COLOUR_BTNHILIGHT)
+        )
+        self.ribbon_background = copy.copy(
+            wx.SystemSettings().GetColour(wx.SYS_COLOUR_BTNHILIGHT)
         )
         self.highlight = copy.copy(
             wx.SystemSettings().GetColour(wx.SYS_COLOUR_HOTLIGHT)
         )
 
-        self.dark_mode = wx.SystemSettings().GetColour(wx.SYS_COLOUR_WINDOW)[0] < 127
-        manualmode = self.parent.context.root.setting(bool, "force_darkmode", False)
-        if manualmode:
-            self.dark_mode = True
+        # Do we have a setting for the color?
+        c_mode = self.parent.context.root.setting(int, "ribbon_color", 0)
+        # 0 system default
+        # 1 colored background
+        # 2 forced dark_mode
+        if c_mode < COLOR_MODE_DEFAULT or c_mode > COLOR_MODE_DARK:
+            c_mode = COLOR_MODE_DEFAULT
+        if (
+            c_mode == COLOR_MODE_DEFAULT
+            and wx.SystemSettings().GetColour(wx.SYS_COLOUR_WINDOW)[0] < 127
+        ):
+            c_mode = COLOR_MODE_DARK  # dark mode
+        self.color_mode = c_mode
 
-        if self.dark_mode:
+        if self.color_mode == COLOR_MODE_DARK:
             # This is rather crude, as a dark mode could also
             # be based eg on a dark blue scheme
             self.button_face = wx.BLACK
+            self.ribbon_background = wx.BLACK
             self.text_color = wx.WHITE
             self.text_color_inactive = copy.copy(self.text_color)
             self.text_color_disabled = wx.Colour("Light Grey")
@@ -1272,15 +1300,30 @@ class Art:
             OS_NAME = platform.system()
             if OS_NAME == "Windows":
                 self.button_face_hover = wx.BLUE
-
+        if self.color_mode == COLOR_MODE_COLOR:
+            self.ribbon_background = copy.copy(
+                wx.SystemSettings().GetColour(wx.SYS_COLOUR_GRADIENTINACTIVECAPTION)
+            )
+            self.button_face = copy.copy(
+                wx.SystemSettings().GetColour(wx.SYS_COLOUR_GRADIENTACTIVECAPTION)
+            )
+            self.button_face_hover = wx.Colour("gold").ChangeLightness(150)
+            self.highlight = wx.Colour("gold")
+
+        # Let's adjust the fontsize for the page headers
+        screen_wd, screen_ht = wx.GetDisplaySize()
+        ptdefault = 10
+        if screen_wd <= 800 or screen_ht <= 600:
+            ptdefault = 8
+            self.tab_height = 16
+        try:
+            wxsize = wx.Size(ptdefault, ptdefault)
+            dipsize = self.parent.FromDIP(wxsize)
+            ptsize = int(dipsize[0])
+        except AttributeError:
+            ptsize = ptdefault
         self.default_font = wx.Font(
-            10, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL
-        )
-        self.small_font = wx.Font(
-            8, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL
-        )
-        self.tiny_font = wx.Font(
-            6, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL
+            ptsize, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL
         )
 
     def paint_main(self, dc, ribbon):
@@ -1306,13 +1349,14 @@ class Art:
             if page is not self.current_page or not page.visible:
                 continue
 
-            dc.SetBrush(wx.Brush(self.button_face))
+            dc.SetBrush(wx.Brush(self.ribbon_background))
             x, y, x1, y1 = page.position
             dc.DrawRoundedRectangle(
                 int(x), int(y), int(x1 - x), int(y1 - y), self.rounded_radius
             )
             for panel in page.panels:
-                if panel is None:
+                # We suppress empty panels
+                if panel is None or panel.visible_button_count == 0:
                     continue
                 self._paint_panel(dc, panel)
                 for button in panel.visible_buttons():
@@ -1368,7 +1412,7 @@ class Art:
         @return:
         """
         w, h = dc.Size
-        dc.SetBrush(wx.Brush(self.button_face))
+        dc.SetBrush(wx.Brush(self.ribbon_background))
         dc.SetPen(wx.TRANSPARENT_PEN)
         dc.DrawRectangle(0, 0, w, h)
 
@@ -1384,7 +1428,7 @@ class Art:
             return
         x, y, x1, y1 = panel.position
         # print(f"Painting panel {panel.label}: {panel.position}")
-        dc.SetBrush(wx.Brush(self.button_face))
+        dc.SetBrush(wx.Brush(self.ribbon_background))
         dc.SetPen(wx.Pen(self.black_color))
         dc.DrawRoundedRectangle(
             int(x), int(y), int(x1 - x), int(y1 - y), self.rounded_radius
@@ -1407,13 +1451,18 @@ class Art:
         cx = (x + x1) / 2
         cy = -r / 2 + (y + y1) / 2
         # print (f"area: {x},{y}-{x1},{y1} - center={cx},{cy} r={r}")
-        points = [
-            (
-                int(cx + r * math.cos(math.radians(angle))),
-                int(cy + r * math.sin(math.radians(angle))),
-            )
-            for angle in (0, 90, 180)
-        ]
+        # points = [
+        #     (
+        #         int(cx + r * math.cos(math.radians(angle))),
+        #         int(cy + r * math.sin(math.radians(angle))),
+        #     )
+        #     for angle in (0, 90, 180)
+        # ]
+        lp_x = int(cx - r)
+        lp_y = int(cy)
+        dp_x = int(cx)
+        dp_y = int(cy + r)
+        points = [(lp_x, lp_y), (dp_x, dp_y), (2 * dp_x - lp_x, lp_y)]
         dc.SetPen(wx.Pen(self.black_color))
         dc.SetBrush(wx.Brush(self.inactive_background))
         dc.DrawPolygon(points)
@@ -1436,17 +1485,22 @@ class Art:
         dc.DrawRoundedRectangle(
             int(x), int(y), int(x1 - x), int(y1 - y), self.rounded_radius
         )
-        r = min((x1 - x) / 2, (y1 - y) / 2)
+        r = min((y1 - y) / 2, (x1 - x) / 2) - 2
         cx = (x + x1) / 2
         cy = -r / 2 + (y + y1) / 2
-
-        points = [
-            (
-                int(cx + r * math.cos(math.radians(x))),
-                int(cy + r * math.sin(math.radians(x))),
-            )
-            for x in (0, 90, 180)
-        ]
+        # print (f"area: {x},{y}-{x1},{y1} - center={cx},{cy} r={r}")
+        # points = [
+        #     (
+        #         int(cx + r * math.cos(math.radians(angle))),
+        #         int(cy + r * math.sin(math.radians(angle))),
+        #     )
+        #     for angle in (0, 90, 180)
+        # ]
+        lp_x = int(cx - r)
+        lp_y = int(cy)
+        dp_x = int(cx)
+        dp_y = int(cy + r)
+        points = [(lp_x, lp_y), (dp_x, dp_y), (2 * dp_x - lp_x, lp_y)]
         dc.SetPen(wx.Pen(self.black_color))
         dc.SetBrush(wx.Brush(self.inactive_background))
         dc.DrawPolygon(points)
@@ -1461,15 +1515,6 @@ class Art:
         """
         if button.overflow or not button.visible or button.position is None:
             return
-        bitmap = button.bitmap_large
-        bitmap_small = button.bitmap_small
-        bitmap_tiny = button.bitmap_tiny
-
-        button.bitmapsize = "large"
-        if not button.enabled:
-            bitmap = button.bitmap_large_disabled
-            bitmap_small = button.bitmap_small_disabled
-            bitmap_tiny = button.bitmap_tiny_disabled
 
         dc.SetBrush(wx.Brush(self.button_face))
         dc.SetPen(wx.TRANSPARENT_PEN)
@@ -1488,104 +1533,98 @@ class Art:
         x, y, x1, y1 = button.position
         w = int(round(x1 - x, 2))
         h = int(round(y1 - y, 2))
+        img_h = h
+        # do we have text? if yes let's reduce the available space in y
+        if self.show_labels:  # Regardless whether we have a label or not...
+            img_h -= self.bitmap_text_buffer
+            ptsize = min(18, int(round(min(w, img_h) / 5.0, 2)) * 2)
+            img_h -= int(ptsize * 1.35)
+
+        button.get_bitmaps(min(w, img_h))
+        if button.enabled:
+            bitmap = button.bitmap
+        else:
+            bitmap = button.bitmap_disabled
 
-        # Lets clip the output
+        # Let's clip the output
         dc.SetClippingRegion(int(x), int(y), int(w), int(h))
 
         dc.DrawRoundedRectangle(int(x), int(y), int(w), int(h), self.rounded_radius)
         bitmap_width, bitmap_height = bitmap.Size
-        font = self.default_font
         # if button.label in  ("Circle", "Ellipse", "Wordlist", "Property Window"):
         #     print (f"N - {button.label}: {bitmap_width}x{bitmap_height} in {w}x{h}")
-        if bitmap_height > h or bitmap_width > w:
-            button.bitmapsize = "small"
-            bitmap = bitmap_small
-            font = self.small_font
-            bitmap_width, bitmap_height = bitmap.Size
-            # if button.label in  ("Circle", "Ellipse", "Wordlist", "Property Window"):
-            #     print (f"S - {button.label}: {bitmap_width}x{bitmap_height} in {w}x{h}")
-            if bitmap_height > h or bitmap_width > w:
-                button.bitmapsize = "tiny"
-                bitmap = bitmap_tiny
-                font = self.tiny_font
-                bitmap_width, bitmap_height = bitmap.Size
-                # if button.label in  ("Circle", "Ellipse", "Wordlist", "Property Window"):
-                #     print (f"T - {button.label}: {bitmap_width}x{bitmap_height} in {w}x{h}")
+        bs = min(bitmap_width, bitmap_height)
+        ptsize = self.get_font_size(bs)
+        font = wx.Font(
+            ptsize, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL
+        )
 
-        bitmap_width, bitmap_height = bitmap.Size
         dc.DrawBitmap(bitmap, int(x + (w - bitmap_width) / 2), int(y))
         y += bitmap_height
 
+        text_edge = self.bitmap_text_buffer
+
         if button.label and self.show_labels:
             show_text = True
             label_text = list(button.label.split(" "))
             # We try to establish whether this would fit properly.
             # We allow a small oversize of 25% to the button,
             # before we try to reduce the fontsize
-            font_candidates = [
-                self.default_font,
-                self.small_font,
-                self.tiny_font,
-            ]
-            if button.bitmapsize == "tiny":
-                font_candidates = font_candidates[2:]
-            elif button.bitmapsize == "small":
-                font_candidates = font_candidates[1:]
             wouldfit = False
-            for testfont in font_candidates:
-                test_y = y + self.bitmap_text_buffer
+            while not wouldfit:
+                testfont = wx.Font(
+                    ptsize,
+                    wx.FONTFAMILY_SWISS,
+                    wx.FONTSTYLE_NORMAL,
+                    wx.FONTWEIGHT_NORMAL,
+                )
+                test_y = y + text_edge
                 dc.SetFont(testfont)
                 wouldfit = True
-                for word in label_text:
+                i = 0
+                while i < len(label_text):
+                    # We know by definition that all single words
+                    # are okay for drawing, now we check whether
+                    # we can draw multiple in one line
+                    word = label_text[i]
+                    cont = True
+                    while cont:
+                        cont = False
+                        if i < len(label_text) - 1:
+                            nextword = label_text[i + 1]
+                            test = word + " " + nextword
+                            tw, th = dc.GetTextExtent(test)
+                            if tw < w:
+                                word = test
+                                i += 1
+                                cont = True
+
                     text_width, text_height = dc.GetTextExtent(word)
                     if text_width > w:
                         wouldfit = False
                         break
+                    test_y += text_height
+                    if test_y > y1:
+                        wouldfit = False
+                        text_edge = 0
+                        break
+                    i += 1
+
                 if wouldfit:
                     font = testfont
                     break
+
+                ptsize -= 2
+                if ptsize < 6:  # too small
+                    break
             if not wouldfit:
                 show_text = False
                 label_text = list()
-
-            # Previous algorithm with abbreviated text
-            # test_y = y + self.bitmap_text_buffer
-            # dc.SetFont(font)
-            # for idx, word in enumerate(label_text):
-            #     test_word = word
-            #     while True:
-            #         text_width, text_height = dc.GetTextExtent(test_word)
-            #         if text_width <= w:
-            #             break
-            #         if test_word.endswith("..."):
-            #             test_word = test_word[:-4]
-            #         else:
-            #             test_word = word[:-2]
-            #         if len(test_word) > 0:
-            #             test_word += "..."
-            #         else:
-            #             show_text = False
-            #             break
-            #     if len(test_word) > 0:
-            #         if test_word.endswith("..."):
-            #             label_text[idx] = test_word
-            #             label_text = label_text[: idx + 1]
-            #             break
-            #     else:
-            #         if idx == 0:
-            #             show_text = False
-            #         else:
-            #             label_text = label_text[:idx]
-
-            #         break
-
-            #     test_y += text_height
-
         else:
             show_text = False
             label_text = list()
         if show_text:
-            y += self.bitmap_text_buffer
+            y += text_edge
             dc.SetFont(font)
             i = 0
             while i < len(label_text):
@@ -1631,6 +1670,7 @@ class Art:
         xpos = 0
         ypos = 0
         has_page_header = ribbon.visible_pages() > 1
+        dc.SetFont(self.default_font)
         for pn, page in enumerate(ribbon.pages):
             if not page.visible:
                 continue
@@ -1639,6 +1679,16 @@ class Art:
             # if bigger than default then extend width
             if has_page_header:
                 line_width, line_height = dc.GetTextExtent(page.label)
+                if line_height + 4 > self.tab_height:
+                    self.tab_height = line_height + 4
+                    for former in range(0, pn):
+                        former_page = ribbon.pages[former]
+                        t_x, t_y, t_x1, t_y1 = former_page.tab_position
+                        if horizontal:
+                            t_y1 = t_y + self.tab_height * 2
+                        else:
+                            t_x1 = t_x + self.tab_height * 2
+                        former_page.tab_position = (t_x, t_y, t_x1, t_y1)
 
                 tabwidth = max(line_width + 2 * self.tab_tab_buffer, self.tab_width)
                 if horizontal:
@@ -1709,22 +1759,6 @@ class Art:
             #     print(f"page: {page.position}")
             self.page_layout(dc, page)
 
-    # def preferred_button_size_for_panel(self, dc, panel):
-    #     # Provides
-    #     x, y, max_x, max_y = panel.position
-    #     panel_width = max_x - x
-    #     panel_height = max_y - y
-    #     button_sizes = []
-    #     for button in panel.buttons:
-    #         this_button_sizes = []
-    #         # We calculate the space requirement for regular,
-    #         # small and tiny buttons, both with and without
-    #         # labels
-    #         button_sizes.append(this_button_sizes)
-    #     button_width = 0
-    #     button_height = 0
-    #     return button_width, button_height
-
     def preferred_button_size_for_page(self, dc, page):
         x, y, max_x, max_y = page.position
         page_width = max_x - x
@@ -1814,9 +1848,37 @@ class Art:
         button_width, button_height = self.preferred_button_size_for_page(dc, page)
         x += self.page_panel_buffer
         y += self.page_panel_buffer
+        """
+        THIS ALGORITHM NEEDS STILL TO BE IMPLEMENTED
+        --------------------------------------------
+        We discuss now the horizontal case, the same
+        logic would apply for the vertical case.
+        We iterate through the sizes and establish the space
+        needed for every panel:
+        1) We calculate the required button dimensions for all
+        combinations of tiny/small/regular icons plus with/without labels
+        2) We get the minimum amount of columns required to display
+        the buttons (taking the vertical extent ie the amount
+        of available rows into account).
+        This will provide us with a solution that would need
+        the least horizontal space.
+        3) That may lead to a situation where you would still
+        have horizontal space available for the panels.
+        Hence we do a second pass where we assign additional space
+        to all panels that need more than one row of icons.
+        As we will do this for all possible size combinations,
+        we will chose eventually that solution that has the
+        fewest amount of buttons in overflow.
+        """
+        # 1 Calculate button sizes - this is not required
+        # here, already done during button creation
+
+        # 2 Loop over all sizes
+
+        # Now that we have gathered all information we can assign
+        # the space...
+        available_space = 0
         for p, panel in enumerate(page.panels):
-            if panel.visible_button_count == 0:
-                continue
             if p != 0:
                 # Non-first move between panel gap.
                 if is_horizontal:
@@ -1841,11 +1903,35 @@ class Art:
                 + (single_panel_vertical - 1) * self.between_button_buffer
                 + 2 * self.panel_button_buffer
             )
-
+            if is_horizontal:
+                sx = available_space
+                sy = 0
+            else:
+                sx = 0
+                sy = available_space
+            panel_width += sx
+            panel_height += sy
             panel.position = x, y, x + panel_width, y + panel_height
-            # if self.parent.visible_pages() == 1:
-            #     print(f"panel: {panel.position}")
-            self.panel_layout(dc, panel)
+            panel_max_x, panel_max_y = self.panel_layout(dc, panel)
+            # Do we have more space than needed?
+            available_space = 0
+            if panel._overflow_position is None:
+                # print (f"({x}, {y}) - ({x + panel_width},  {y+panel_height}), sx={sx}, sy={sy}")
+                if is_horizontal:
+                    available_space = max(
+                        0, x + panel_width - panel_max_x - self.panel_button_buffer
+                    )
+                    # print (f"x={x + panel_width}, {panel_max_x} will become: {panel_max_x + self.panel_button_buffer}, available={available_space}")
+                    if available_space != 0:
+                        panel_width = panel_max_x + self.panel_button_buffer - x
+                else:
+                    available_space = max(
+                        0, y + panel_height - panel_max_y - self.panel_button_buffer
+                    )
+                    # print (f"y={y + panel_height}, {panel_max_y} will become: {panel_max_y + self.panel_button_buffer}, available={available_space}")
+                    if available_space != 0:
+                        panel_height = panel_max_y + self.panel_button_buffer - y
+                panel.position = x, y, x + panel_width, y + panel_height
 
             if is_horizontal:
                 x += panel_width
@@ -1887,7 +1973,7 @@ class Art:
         button_width = all_button_width / button_horizontal
         button_height = all_button_height / button_vertical
         # 'tiny'-size of a default 50x50 icon
-        minim_size = int(TINY_RESIZE_FACTOR * 50)
+        minim_size = 15
         button_width = max(minim_size, button_width)
         button_height = max(minim_size, button_height)
 
@@ -1897,13 +1983,13 @@ class Art:
         panel._overflow_position = None
         lastbutton = None
         for b, button in enumerate(list(panel.visible_buttons())):
-            button.bitmapsize = "large"
-            bitmap_width, bitmap_height = button.bitmap_large.Size
-            if bitmap_height > button_height or bitmap_width > button_width:
-                button.bitmapsize = "small"
-                bitmap_width, bitmap_height = button.bitmap_small.Size
-                if bitmap_height > button_height or bitmap_width > button_width:
-                    button.bitmapsize = "tiny"
+            found = False
+            bitmapsize = button.max_size
+            while bitmapsize > button.min_size:
+                if bitmapsize <= button_height and bitmapsize <= button_width:
+                    break
+                bitmapsize -= 5
+            button.get_bitmaps(bitmapsize)
             self.button_calc(dc, button)
             if b == 0:
                 max_width = button.min_width
@@ -1914,8 +2000,7 @@ class Art:
 
         target_height = button_height
         target_width = button_width
-        # if self.parent.visible_pages() == 1:
-        #     print(f"Target: {target_width}x{target_height}")
+        # print(f"Target: {panel.label} - {target_width}x{target_height}")
         for b, button in enumerate(list(panel.visible_buttons())):
             button.overflow = False
             this_width = target_width
@@ -1923,9 +2008,9 @@ class Art:
             local_width = 1.25 * button.min_width
             local_height = 1.25 * button.min_height
             if not distribute_evenly:
-                if button_horizontal > 1:
+                if button_horizontal > 1 or is_horizontal:
                     this_width = min(this_width, local_width)
-                if button_vertical > 1:
+                if button_vertical > 1 or not is_horizontal:
                     this_height = min(this_height, local_height)
             if b != 0:
                 # Move across button gap if not first button.
@@ -2022,33 +2107,46 @@ class Art:
             else:
                 y += this_height
             lastbutton = button
+        return min(x, panel.position[2]), min(y, panel.position[3])
 
     def button_calc(self, dc: wx.DC, button):
-        default_w = button.default_width
-        if button.bitmapsize == "small":
-            default_w = int(SMALL_RESIZE_FACTOR * button.default_width)
-            bitmap = button.bitmap_small
-            dc.SetFont(self.small_font)
-        elif button.bitmapsize == "tiny":
-            default_w = int(TINY_RESIZE_FACTOR * button.default_width)
-            bitmap = button.bitmap_tiny
-            dc.SetFont(self.tiny_font)
-        else:
-            default_w = button.default_width
-            bitmap = button.bitmap_large
-            dc.SetFont(self.default_font)
+        bitmap = button.bitmap
+        ptsize = self.get_font_size(button.icon_size)
+        font = wx.Font(
+            ptsize, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL
+        )
+
+        dc.SetFont(font)
         bitmap_width, bitmap_height = bitmap.Size
-        bitmap_height = max(bitmap_height, default_w)
-        bitmap_width = max(bitmap_width, default_w)
+        bitmap_height = max(bitmap_height, button.icon_size)
+        bitmap_width = max(bitmap_width, button.icon_size)
 
         # Calculate text height/width
         text_width = 0
         text_height = 0
         if button.label and self.show_labels:
-            for word in button.label.split(" "):
+            label_text = list(button.label.split(" "))
+            i = 0
+            while i < len(label_text):
+                # We know by definition that all single words
+                # are okay for drawing, now we check whether
+                # we can draw multiple in one line
+                word = label_text[i]
+                cont = True
+                while cont:
+                    cont = False
+                    if i < len(label_text) - 1:
+                        nextword = label_text[i + 1]
+                        test = word + " " + nextword
+                        tw, th = dc.GetTextExtent(test)
+                        if tw < bitmap_width:
+                            word = test
+                            i += 1
+                            cont = True
                 line_width, line_height = dc.GetTextExtent(word)
                 text_width = max(text_width, line_width)
                 text_height += line_height
+                i += 1
 
         # Calculate button_width/button_height
         button_width = max(bitmap_width, text_width)
@@ -2065,12 +2163,7 @@ class Art:
 
     def button_layout(self, dc: wx.DC, button):
         x, y, max_x, max_y = button.position
-        if button.bitmapsize == "small":
-            bitmap = button.bitmap_small
-        elif button.bitmapsize == "tiny":
-            bitmap = button.bitmap_tiny
-        else:
-            bitmap = button.bitmap_large
+        bitmap = button.bitmap
         bitmap_width, bitmap_height = bitmap.Size
         if button.kind == "hybrid" and button.key != "toggle":
             # Calculate text height/width
@@ -2100,3 +2193,18 @@ class Art:
             #     f"Required for {button.label}: button: {x},{y} to {max_x},{max_y}," +
             #     f"dropd: {extx-sizx},{exty-sizy} to {extx},{exty}"
             # )
+
+    def get_font_size(self, imgsize):
+        if imgsize <= 20:
+            ptsize = 6
+        elif imgsize <= 30:
+            ptsize = 8
+        elif imgsize <= 40:
+            ptsize = 10
+        elif imgsize <= 60:
+            ptsize = 12
+        elif imgsize <= 80:
+            ptsize = 14
+        else:
+            ptsize = 16
+        return ptsize