From 86f00c5236b6ba13b859b90bae2bb9c3a7565294 Mon Sep 17 00:00:00 2001
From: Jim Huang <jserv@ccns.ncku.edu.tw>
Date: Fri, 3 Oct 2025 04:56:27 +0800
Subject: [PATCH 1/2] Implement lxdialog-style button dialogs

This adds button dialog support matching Linux menuconfig (lxdialog)
visual style and behavior.
---
 menuconfig.py | 355 +++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 324 insertions(+), 31 deletions(-)

diff --git a/menuconfig.py b/menuconfig.py
index 77c57cd..dc5dfc2 100755
--- a/menuconfig.py
+++ b/menuconfig.py
@@ -298,6 +298,15 @@
     edit=fg:black,bg:white
     jump-edit=fg:black,bg:white
     text=fg:black,bg:white
+    shadow=fg:black,bg:black,bold
+    button-active=fg:black,bg:white
+    button-inactive=fg:white,bg:blue,bold
+    button-key-active=fg:red,bg:white
+    button-key-inactive=fg:white,bg:blue,bold
+    button-label-active=fg:black,bg:white,bold
+    button-label-inactive=fg:yellow,bg:blue,bold
+    dialog=fg:black,bg:white
+    dialog-frame=fg:white,bg:blue,bold
     """,
 
     # This style is forced on terminals that do not support colors
@@ -934,25 +943,26 @@ def _quit_dialog():
     if not _conf_changed:
         return "No changes to save (for '{}')".format(_conf_filename)
 
-    while True:
-        c = _key_dialog(
-            "Quit",
-            " Save configuration?\n"
-            "\n"
-            "(Y)es  (N)o  (C)ancel",
-            "ync")
+    # Use button dialog with Yes/No/Cancel buttons (matching lxdialog style)
+    result = _button_dialog(
+        None,  # No title in yesno dialog
+        "Save configuration?",
+        [" Yes ", "  No  ", " Cancel "],
+        default_button=0)
 
-        if c is None or c == "c":
-            return None
+    if result is None or result == 2:  # ESC or Cancel
+        return None
 
-        if c == "y":
-            # Returns a message to print
-            msg = _try_save(_kconf.write_config, _conf_filename, "configuration")
-            if msg:
-                return msg
+    if result == 0:  # Yes
+        # Returns a message to print
+        msg = _try_save(_kconf.write_config, _conf_filename, "configuration")
+        if msg:
+            return msg
+        # If save failed, try again
+        return None
 
-        elif c == "n":
-            return "Configuration ({}) was not saved".format(_conf_filename)
+    elif result == 1:  # No
+        return "Configuration ({}) was not saved".format(_conf_filename)
 
 
 def _init():
@@ -1367,10 +1377,16 @@ def _draw_main():
 
     _menu_win.erase()
 
+    # Draw box around the menu window (like lxdialog's menubox)
+    menu_win_height, menu_win_width = _menu_win.getmaxyx()
+    _draw_box(_menu_win, 0, 0, menu_win_height, menu_win_width,
+              _style["list"], _style["list"])
+
     # Draw the _shown nodes starting from index _menu_scroll up to either as
     # many as fit in the window, or to the end of _shown
+    # Note: Now we need to account for the border (1 character on each side)
     for i in range(_menu_scroll,
-                   min(_menu_scroll + _height(_menu_win), len(_shown))):
+                   min(_menu_scroll + _height(_menu_win) - 2, len(_shown))):
 
         node = _shown[i]
 
@@ -1383,7 +1399,8 @@ def _draw_main():
         else:
             style = _style["inv-selection" if i == _sel_node_i else "inv-list"]
 
-        _safe_addstr(_menu_win, i - _menu_scroll, 0, _node_str(node), style)
+        # Draw inside the box (offset by 1 row and 1 column)
+        _safe_addstr(_menu_win, 1 + i - _menu_scroll, 1, _node_str(node), style)
 
     _menu_win.noutrefresh()
 
@@ -1789,6 +1806,13 @@ def _resize_input_dialog(win, title, info_lines):
 def _draw_input_dialog(win, title, info_lines, s, i, hscroll):
     edit_width = _width(win) - 4
 
+    # Get window position and size for shadow
+    win_y, win_x = win.getbegyx()
+    win_height, win_width = win.getmaxyx()
+
+    # Draw shadow on stdscr first
+    _draw_shadow(_stdscr, win_y, win_x, win_height, win_width)
+
     win.erase()
 
     # Note: Perhaps having a separate window for the input field would be nicer
@@ -1983,35 +2007,304 @@ def _resize_key_dialog(win, text):
 
 
 def _draw_key_dialog(win, title, text):
+    # Get window position and size for shadow
+    win_y, win_x = win.getbegyx()
+    win_height, win_width = win.getmaxyx()
+
+    # Draw shadow on stdscr first
+    _draw_shadow(_stdscr, win_y, win_x, win_height, win_width)
+
     win.erase()
 
+    # Draw the frame first
+    _draw_frame(win, title)
+
+    # Then draw text content inside the frame
+    win.attron(_style["body"])
     for i, line in enumerate(text.split("\n")):
         _safe_addstr(win, 2 + i, 2, line)
-
-    # Draw the frame last so that it overwrites the body text for small windows
-    _draw_frame(win, title)
+    win.attroff(_style["body"])
 
     win.noutrefresh()
 
 
+def _button_dialog(title, text, buttons, default_button=0):
+    # Dialog with button selection support, matching lxdialog's yesno/msgbox
+    #
+    # title: Dialog title (shown at top of border if provided)
+    # text: Dialog text content
+    # buttons: List of button labels (e.g., [" Yes ", "  No  ", " Cancel "])
+    # default_button: Index of initially selected button
+    #
+    # Returns: Index of selected button, or None if ESC pressed
+
+    win = _styled_win("dialog")
+    win.keypad(True)
+
+    selected_button = default_button
+
+    # Calculate window size based on content
+    lines = text.split("\n")
+    # Height: border(1) + text lines + blank + separator(1) + buttons + border(1)
+    # = 1 + len(lines) + 1 + 1 + 1 + 1 = len(lines) + 5
+    win_height = min(len(lines) + 5, _height(_stdscr) - 4)
+    # Calculate width from longest line and button row
+    # Button row width includes buttons + spacing between them
+    # 2 buttons: spacing 13, 3+ buttons: spacing 4
+    spacing = 13 if len(buttons) == 2 else 4
+    button_row_width = sum(len(b) + 2 for b in buttons) + spacing * (len(buttons) - 1)
+    win_width = min(max(max(len(line) for line in lines) + 4, button_row_width + 4),
+                    _width(_stdscr) - 4)
+
+    win.resize(win_height, win_width)
+    win.mvwin((_height(_stdscr) - win_height)//2,
+              (_width(_stdscr) - win_width)//2)
+
+    while True:
+        # Draw main display behind dialog
+        _draw_main()
+
+        # Get window position and size
+        win_y, win_x = win.getbegyx()
+        win_height, win_width = win.getmaxyx()
+
+        # Don't draw shadow for now - TODO: Add shadow support later
+
+        win.erase()
+
+        # Draw box border with proper colors
+        # Use dialog-frame (blue background) for both box and border to get uniform blue frame
+        _draw_box(win, 0, 0, win_height, win_width,
+                  _style.get("dialog-frame", _style["dialog"]),
+                  _style.get("dialog-frame", _style["dialog"]))
+
+        # Draw title bar with blue background if title provided
+        if title:
+            # Fill entire top line with blue background
+            win.attron(_style.get("dialog-frame", _style["dialog"]))
+            for i in range(1, win_width - 1):
+                _safe_addch(win, 0, i, ord(' '))
+            # Draw title text centered
+            title_x = (win_width - len(title)) // 2
+            _safe_addstr(win, 0, title_x, title)
+            win.attroff(_style.get("dialog-frame", _style["dialog"]))
+
+        # Draw horizontal separator line before buttons (height - 3)
+        # This line should have blue background
+        win.attron(_style.get("dialog-frame", _style["dialog"]))
+        _safe_addch(win, win_height - 3, 0, curses.ACS_LTEE)
+        for i in range(1, win_width - 1):
+            _safe_addch(win, win_height - 3, i, curses.ACS_HLINE)
+        _safe_addch(win, win_height - 3, win_width - 1, curses.ACS_RTEE)
+        win.attroff(_style.get("dialog-frame", _style["dialog"]))
+
+        # Draw text content with blue background (dialog-frame style)
+        # Fill text area with blue background
+        win.attron(_style.get("dialog-frame", _style["dialog"]))
+        for i in range(1, win_height - 3):
+            for j in range(1, win_width - 1):
+                _safe_addch(win, i, j, ord(' '))
+        # Draw text lines
+        for i, line in enumerate(lines):
+            if i < len(lines):
+                # Text starts at row 1, column 2 (inside border)
+                _safe_addstr(win, 1 + i, 2, line)
+        win.attroff(_style.get("dialog-frame", _style["dialog"]))
+
+        # Buttons at row (height - 2)
+        button_y = win_height - 2
+
+        # Fill button row with blue background (dialog-frame style)
+        win.attrset(_style.get("dialog-frame", _style["dialog"]))
+        for i in range(1, win_width - 1):
+            _safe_addch(win, button_y, i, ord(' '))
+
+        # Calculate button positions with spacing
+        # For Yes/No: 13 chars spacing (from lxdialog/yesno.c)
+        # For 3+ buttons: smaller spacing for better fit
+        if len(buttons) == 2:
+            # Two buttons: use fixed spacing of 13
+            spacing = 13
+            total_width = (len(buttons[0]) + 2) + spacing + (len(buttons[1]) + 2)
+            button_x = (win_width - total_width) // 2
+            button_positions = [
+                button_x,
+                button_x + len(buttons[0]) + 2 + spacing
+            ]
+        else:
+            # Three or more buttons: use smaller spacing
+            spacing = 4
+            total_width = sum(len(b) + 2 for b in buttons) + spacing * (len(buttons) - 1)
+            button_x = (win_width - total_width) // 2
+            button_positions = []
+            current_x = button_x
+            for i, b in enumerate(buttons):
+                button_positions.append(current_x)
+                current_x += len(b) + 2 + spacing  # button width + spacing
+
+        # Draw buttons at calculated positions
+        for i, button_label in enumerate(buttons):
+            _print_button(win, button_label, button_y, button_positions[i], i == selected_button)
+
+        win.noutrefresh()
+        curses.doupdate()
+
+        # Handle input
+        c = _getch_compat(win)
+
+        if c == curses.KEY_RESIZE:
+            _resize_main()
+            # Recalculate window size
+            win.resize(win_height, win_width)
+            win.mvwin((_height(_stdscr) - win_height)//2,
+                      (_width(_stdscr) - win_width)//2)
+
+        elif c == "\x1B":  # ESC
+            return None
+
+        elif c == "\t" or c == curses.KEY_RIGHT:  # TAB or RIGHT arrow
+            selected_button = (selected_button + 1) % len(buttons)
+
+        elif c == curses.KEY_LEFT:  # LEFT arrow
+            selected_button = (selected_button - 1) % len(buttons)
+
+        elif c == " " or c == "\n":  # SPACE or ENTER
+            return selected_button
+
+        elif isinstance(c, str):
+            # Check for hotkey match
+            c_lower = c.lower()
+            for i, button_label in enumerate(buttons):
+                if button_label.strip().lower().startswith(c_lower):
+                    return i
+
+
+def _print_button(win, label, y, x, selected):
+    # Print a button matching lxdialog's print_button()
+    #
+    # Format: <Label> with first letter highlighted
+    # selected: If True, button is active (white background - reversed)
+    # inactive: blue background (same as dialog background)
+
+    # Count leading spaces
+    leading_spaces = len(label) - len(label.lstrip(' '))
+    label_stripped = label.lstrip(' ')
+
+    # Move to position
+    _safe_move(win, y, x)
+
+    # Draw bracket "<" with button style
+    win.attrset(_style["button-active" if selected else "button-inactive"])
+    _safe_addstr(win, y, x, "<")
+
+    # Draw leading spaces with label style
+    win.attrset(_style["button-label-active" if selected else "button-label-inactive"])
+    for _ in range(leading_spaces):
+        _safe_addch(win, y, x + 1 + _, ord(' '))
+
+    # Draw first character (hotkey) with key style
+    if label_stripped:
+        win.attrset(_style["button-key-active" if selected else "button-key-inactive"])
+        _safe_addch(win, y, x + 1 + leading_spaces, ord(label_stripped[0]))
+
+        # Draw rest of label with label style
+        win.attrset(_style["button-label-active" if selected else "button-label-inactive"])
+        _safe_addstr(win, y, x + 1 + leading_spaces + 1, label_stripped[1:])
+
+    # Draw bracket ">" with button style
+    win.attrset(_style["button-active" if selected else "button-inactive"])
+    _safe_addstr(win, y, x + 1 + len(label), ">")
+
+    # Move cursor to the hotkey position for selected button
+    _safe_move(win, y, x + 1 + leading_spaces)
+
+
+def _draw_box(win, y, x, height, width, box_attr, border_attr):
+    # Draw a rectangular box with line drawing characters, matching lxdialog's draw_box()
+    #
+    # box_attr: attribute for box body and right/bottom borders
+    # border_attr: attribute for left/top borders
+
+    for i in range(height):
+        for j in range(width):
+            win_y, win_x = y + i, x + j
+
+            # Corners
+            if i == 0 and j == 0:
+                win.attrset(border_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_ULCORNER)
+            elif i == height - 1 and j == 0:
+                win.attrset(border_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_LLCORNER)
+            elif i == 0 and j == width - 1:
+                win.attrset(box_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_URCORNER)
+            elif i == height - 1 and j == width - 1:
+                win.attrset(box_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_LRCORNER)
+            # Edges
+            elif i == 0:
+                win.attrset(border_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_HLINE)
+            elif i == height - 1:
+                win.attrset(box_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_HLINE)
+            elif j == 0:
+                win.attrset(border_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_VLINE)
+            elif j == width - 1:
+                win.attrset(box_attr)
+                _safe_addch(win, win_y, win_x, curses.ACS_VLINE)
+            # Interior - don't fill, let caller handle background
+            else:
+                pass  # Interior is handled by caller
+
+
+def _draw_shadow(win, y, x, height, width):
+    # Draw shadows along the right and bottom edge to give a more 3D look,
+    # matching lxdialog's draw_shadow()
+
+    if curses.has_colors():
+        # Note: We need to define shadow color if not already defined
+        # For now, use a simple approach: draw with shadow style
+        try:
+            win.attrset(_style.get("shadow", 0))
+        except:
+            # Fallback: use dimmed/dark color
+            win.attrset(curses.A_DIM)
+
+        # Bottom shadow (offset by 2 on x-axis)
+        for i in range(width):
+            try:
+                ch = win.inch(y + height, x + 2 + i)
+                _safe_addch(win, y + height, x + 2 + i, ch & curses.A_CHARTEXT)
+            except:
+                pass
+
+        # Right shadow (2 characters wide)
+        for i in range(1, height + 1):
+            try:
+                ch1 = win.inch(y + i, x + width)
+                _safe_addch(win, y + i, x + width, ch1 & curses.A_CHARTEXT)
+                ch2 = win.inch(y + i, x + width + 1)
+                _safe_addch(win, y + i, x + width + 1, ch2 & curses.A_CHARTEXT)
+            except:
+                pass
+
+
 def _draw_frame(win, title):
     # Draw a frame around the inner edges of 'win', with 'title' at the top
+    # Now uses _draw_box() for proper box drawing characters
 
     win_height, win_width = win.getmaxyx()
 
-    win.attron(_style["frame"])
-
-    # Draw top/bottom edge
-    _safe_hline(win,              0, 0, " ", win_width)
-    _safe_hline(win, win_height - 1, 0, " ", win_width)
-
-    # Draw left/right edge
-    _safe_vline(win, 0,             0, " ", win_height)
-    _safe_vline(win, 0, win_width - 1, " ", win_height)
+    # Draw box with frame style for both border and box
+    _draw_box(win, 0, 0, win_height, win_width,
+              _style["frame"], _style["frame"])
 
     # Draw title
+    win.attron(_style["frame"])
     _safe_addstr(win, 0, max((win_width - len(title))//2, 0), title)
-
     win.attroff(_style["frame"])
 
 

From a94153716df3a3cf8f7faf27c5434dead2efbd44 Mon Sep 17 00:00:00 2001
From: Jim Huang <jserv@ccns.ncku.edu.tw>
Date: Fri, 3 Oct 2025 22:42:12 +0800
Subject: [PATCH 2/2] Enhance menuconfig UI to match lxdialog appearance

This refines color scheme, layout, and dialog rendering to closely match
Linux kernel's lxdialog implementation. Key improvements include blue
background for separators and help text, proper shadow windows for
dialogs, corrected window sizing and centering, and immediate background
fill using bkgd().
---
 menuconfig.py | 164 ++++++++++++++++++++++++++++++++++----------------
 1 file changed, 113 insertions(+), 51 deletions(-)

diff --git a/menuconfig.py b/menuconfig.py
index dc5dfc2..23cb44f 100755
--- a/menuconfig.py
+++ b/menuconfig.py
@@ -286,12 +286,12 @@
     # Precisely matches lxdialog's set_bluetitle_theme() and set_classic_theme()
     "linux": """
     path=fg:white,bg:blue,bold
-    separator=fg:black,bg:white
+    separator=fg:white,bg:blue
     list=fg:black,bg:white
     selection=fg:white,bg:blue,bold
     inv-list=fg:red,bg:white
     inv-selection=fg:red,bg:blue,bold
-    help=fg:black,bg:white
+    help=fg:white,bg:blue
     show-help=fg:black,bg:white
     frame=fg:white,bg:blue,bold
     body=fg:black,bg:white
@@ -999,6 +999,10 @@ def _init():
 
     _init_styles()
 
+    # Set stdscr background to match main list style
+    # This ensures areas not covered by subwindows have correct background
+    _stdscr.bkgd(' ', _style.get("list", 0))
+
     # Hide the cursor
     _safe_curs_set(0)
 
@@ -1044,17 +1048,24 @@ def _resize_main():
 
     screen_height, screen_width = _stdscr.getmaxyx()
 
-    _path_win.resize(1, screen_width)
-    _top_sep_win.resize(1, screen_width)
-    _bot_sep_win.resize(1, screen_width)
-
     help_win_height = _SHOW_HELP_HEIGHT if _show_help else \
         len(_MAIN_HELP_LINES)
 
+    # Screen layout:
+    # Row 0: _path_win, Row 1: _top_sep_win, Row 2+: _menu_win
+    # Row (2+menu_win_height): _bot_sep_win
+    # Row (2+menu_win_height+1): _help_win
+    # Total: 1 + 1 + menu_win_height + 1 + help_win_height = screen_height
     menu_win_height = screen_height - help_win_height - 3
+    menu_win_width = screen_width
+
+    _path_win.resize(1, screen_width)
+    _top_sep_win.resize(1, menu_win_width)
 
     if menu_win_height >= 1:
-        _menu_win.resize(menu_win_height, screen_width)
+        _menu_win.resize(menu_win_height, menu_win_width)
+        _bot_sep_win.resize(1, menu_win_width)
+        # _help_win uses full screen width for blue background to extend to right edge
         _help_win.resize(help_win_height, screen_width)
 
         _top_sep_win.mvwin(1, 0)
@@ -1363,8 +1374,10 @@ def _draw_main():
         _safe_hline(_top_sep_win, 0, 4, curses.ACS_UARROW, _N_SCROLL_ARROWS)
 
     # Add the 'mainmenu' text as the title, centered at the top
+    # Use _top_sep_win width instead of term_width for correct centering
+    top_sep_width = _width(_top_sep_win)
     _safe_addstr(_top_sep_win,
-                 0, max((term_width - len(_kconf.mainmenu_text))//2, 0),
+                 0, max((top_sep_width - len(_kconf.mainmenu_text))//2, 0),
                  _kconf.mainmenu_text)
 
     _top_sep_win.noutrefresh()
@@ -1752,12 +1765,22 @@ def edit_width():
     # Horizontal scroll offset
     hscroll = max(i - edit_width() + 1, 0)
 
+    # Create shadow windows once
+    win_y, win_x = win.getbegyx()
+    win_height, win_width = win.getmaxyx()
+    bottom_shadow, right_shadow = _create_shadow_windows(win_y, win_x, win_height, win_width)
+
     while True:
         # Draw the "main" display with the menu, etc., so that resizing still
         # works properly. This is like a stack of windows, only hardcoded for
         # now.
         _draw_main()
+
         _draw_input_dialog(win, title, info_lines, s, i, hscroll)
+
+        # Refresh shadow windows after dialog window to ensure they're on top
+        _refresh_shadow_windows(bottom_shadow, right_shadow)
+
         curses.doupdate()
 
 
@@ -1767,6 +1790,10 @@ def edit_width():
             # Resize the main display too. The dialog floats above it.
             _resize_main()
             _resize_input_dialog(win, title, info_lines)
+            # Recreate shadow windows with new dialog size
+            win_y, win_x = win.getbegyx()
+            win_height, win_width = win.getmaxyx()
+            bottom_shadow, right_shadow = _create_shadow_windows(win_y, win_x, win_height, win_width)
 
         elif c == "\n":
             _safe_curs_set(0)
@@ -1806,13 +1833,6 @@ def _resize_input_dialog(win, title, info_lines):
 def _draw_input_dialog(win, title, info_lines, s, i, hscroll):
     edit_width = _width(win) - 4
 
-    # Get window position and size for shadow
-    win_y, win_x = win.getbegyx()
-    win_height, win_width = win.getmaxyx()
-
-    # Draw shadow on stdscr first
-    _draw_shadow(_stdscr, win_y, win_x, win_height, win_width)
-
     win.erase()
 
     # Note: Perhaps having a separate window for the input field would be nicer
@@ -1968,10 +1988,20 @@ def _key_dialog(title, text, keys):
 
     _resize_key_dialog(win, text)
 
+    # Create shadow windows once
+    win_y, win_x = win.getbegyx()
+    win_height, win_width = win.getmaxyx()
+    bottom_shadow, right_shadow = _create_shadow_windows(win_y, win_x, win_height, win_width)
+
     while True:
         # See _input_dialog()
         _draw_main()
+
         _draw_key_dialog(win, title, text)
+
+        # Refresh shadow windows after dialog window to ensure they're on top
+        _refresh_shadow_windows(bottom_shadow, right_shadow)
+
         curses.doupdate()
 
 
@@ -1981,6 +2011,10 @@ def _key_dialog(title, text, keys):
             # Resize the main display too. The dialog floats above it.
             _resize_main()
             _resize_key_dialog(win, text)
+            # Recreate shadow windows with new dialog size
+            win_y, win_x = win.getbegyx()
+            win_height, win_width = win.getmaxyx()
+            bottom_shadow, right_shadow = _create_shadow_windows(win_y, win_x, win_height, win_width)
 
         elif c == "\x1B":  # \x1B = ESC
             return None
@@ -2007,13 +2041,6 @@ def _resize_key_dialog(win, text):
 
 
 def _draw_key_dialog(win, title, text):
-    # Get window position and size for shadow
-    win_y, win_x = win.getbegyx()
-    win_height, win_width = win.getmaxyx()
-
-    # Draw shadow on stdscr first
-    _draw_shadow(_stdscr, win_y, win_x, win_height, win_width)
-
     win.erase()
 
     # Draw the frame first
@@ -2060,16 +2087,15 @@ def _button_dialog(title, text, buttons, default_button=0):
     win.mvwin((_height(_stdscr) - win_height)//2,
               (_width(_stdscr) - win_width)//2)
 
+    # Create shadow windows once
+    win_y, win_x = win.getbegyx()
+    win_height, win_width = win.getmaxyx()
+    bottom_shadow, right_shadow = _create_shadow_windows(win_y, win_x, win_height, win_width)
+
     while True:
-        # Draw main display behind dialog
+        # Draw main display behind dialog (calls noutrefresh on all subwindows)
         _draw_main()
 
-        # Get window position and size
-        win_y, win_x = win.getbegyx()
-        win_height, win_width = win.getmaxyx()
-
-        # Don't draw shadow for now - TODO: Add shadow support later
-
         win.erase()
 
         # Draw box border with proper colors
@@ -2147,6 +2173,10 @@ def _button_dialog(title, text, buttons, default_button=0):
             _print_button(win, button_label, button_y, button_positions[i], i == selected_button)
 
         win.noutrefresh()
+
+        # Refresh shadow windows after dialog window to ensure they're on top
+        _refresh_shadow_windows(bottom_shadow, right_shadow)
+
         curses.doupdate()
 
         # Handle input
@@ -2158,6 +2188,10 @@ def _button_dialog(title, text, buttons, default_button=0):
             win.resize(win_height, win_width)
             win.mvwin((_height(_stdscr) - win_height)//2,
                       (_width(_stdscr) - win_width)//2)
+            # Recreate shadow windows with new dialog size
+            win_y, win_x = win.getbegyx()
+            win_height, win_width = win.getmaxyx()
+            bottom_shadow, right_shadow = _create_shadow_windows(win_y, win_x, win_height, win_width)
 
         elif c == "\x1B":  # ESC
             return None
@@ -2260,37 +2294,64 @@ def _draw_box(win, y, x, height, width, box_attr, border_attr):
                 pass  # Interior is handled by caller
 
 
-def _draw_shadow(win, y, x, height, width):
-    # Draw shadows along the right and bottom edge to give a more 3D look,
-    # matching lxdialog's draw_shadow()
+def _create_shadow_windows(y, x, height, width, right_y_offset=1):
+    # Create shadow windows for bottom and right edges
+    # Returns tuple of (bottom_shadow_win, right_shadow_win)
+    #
+    # Based on lxdialog's draw_shadow():
+    # - Bottom: at y + height, from x + 2, width chars
+    # - Right: from y + right_y_offset to y + height (inclusive), at x + width, 2 chars wide
 
-    if curses.has_colors():
-        # Note: We need to define shadow color if not already defined
-        # For now, use a simple approach: draw with shadow style
-        try:
-            win.attrset(_style.get("shadow", 0))
-        except:
-            # Fallback: use dimmed/dark color
-            win.attrset(curses.A_DIM)
+    if not curses.has_colors():
+        return None, None
+
+    try:
+        shadow_attr = _style.get("shadow", 0)
 
-        # Bottom shadow (offset by 2 on x-axis)
-        for i in range(width):
+        # Bottom shadow window (1 line high, width wide, offset by 2 on x)
+        bottom_shadow = None
+        if y + height < _height(_stdscr) and x + 2 + width <= _width(_stdscr):
             try:
-                ch = win.inch(y + height, x + 2 + i)
-                _safe_addch(win, y + height, x + 2 + i, ch & curses.A_CHARTEXT)
+                bottom_shadow = curses.newwin(1, width, y + height, x + 2)
+                bottom_shadow.bkgd(' ', shadow_attr)
             except:
                 pass
 
-        # Right shadow (2 characters wide)
-        for i in range(1, height + 1):
+        # Right shadow window
+        # lxdialog: for (i = y + 1; i < y + height + 1; i++)
+        # Draw from y+right_y_offset to y+height (inclusive)
+        right_shadow = None
+        if x + width + 2 <= _width(_stdscr) and y + height <= _height(_stdscr):
             try:
-                ch1 = win.inch(y + i, x + width)
-                _safe_addch(win, y + i, x + width, ch1 & curses.A_CHARTEXT)
-                ch2 = win.inch(y + i, x + width + 1)
-                _safe_addch(win, y + i, x + width + 1, ch2 & curses.A_CHARTEXT)
+                # From (y + right_y_offset) to (y + height) inclusive
+                # Total rows = (y + height) - (y + right_y_offset) + 1 = height - right_y_offset + 1
+                shadow_height = height - right_y_offset + 1
+                if shadow_height > 0:
+                    right_shadow = curses.newwin(shadow_height, 2, y + right_y_offset, x + width)
+                    right_shadow.bkgd(' ', shadow_attr)
             except:
                 pass
 
+        return bottom_shadow, right_shadow
+    except:
+        return None, None
+
+
+def _refresh_shadow_windows(bottom_shadow, right_shadow):
+    # Refresh shadow windows, refilling them each time to ensure visibility
+    if bottom_shadow:
+        try:
+            bottom_shadow.erase()  # Clear and refill with background
+            bottom_shadow.noutrefresh()
+        except:
+            pass
+    if right_shadow:
+        try:
+            right_shadow.erase()  # Clear and refill with background
+            right_shadow.noutrefresh()
+        except:
+            pass
+
 
 def _draw_frame(win, title):
     # Draw a frame around the inner edges of 'win', with 'title' at the top
@@ -3147,8 +3208,9 @@ def _styled_win(style):
 
 def _set_style(win, style):
     # Changes the style of an existing window
+    # Use bkgd() to immediately fill window with background
 
-    win.bkgdset(" ", _style[style])
+    win.bkgd(" ", _style[style])
 
 
 def _max_scroll(lst, win):