mcpower-proxy 0.0.58__py3-none-any.whl

modules/ui/xdialog/windows_dialogs.py

@@ -0,0 +1,250 @@
+import ctypes
+import atexit
+from ctypes import wintypes
+
+from .constants import *
+from .windows_structs import *
+
+# dlls
+user32 = ctypes.windll.user32
+comdlg32 = ctypes.windll.comdlg32
+shell32 = ctypes.windll.shell32
+ole32 = ctypes.oledll.ole32
+
+BUFFER_SIZE = 8192
+
+
+def split_null_list(strp):
+    p = ctypes.cast(strp, ctypes.c_wchar_p)
+    v = p.value
+    while v:
+        yield v
+        loc = ctypes.cast(p, ctypes.c_void_p).value + (len(v)*2+2)
+        p = ctypes.cast(loc, ctypes.c_wchar_p)
+        v = p.value
+
+
+def open_file(title, filetypes, multiple=False):
+    file = ctypes.create_unicode_buffer(BUFFER_SIZE)
+    pfile = ctypes.cast(file, ctypes.c_wchar_p)
+
+    # Default options
+    opts = tagOFNW(
+        lStructSize=ctypes.sizeof(tagOFNW),
+
+        lpstrFile=pfile,
+        nMaxFile=BUFFER_SIZE,
+
+        lpstrTitle=title,
+        Flags=0x00081808 + (0x200 if multiple else 0)
+    )
+
+    # Filetypes
+    if filetypes:
+        out = []
+        for s, t in filetypes:
+            out.append(f'{s} ({t})\0{";".join(t.split())}\0')
+        
+        buf = ctypes.create_unicode_buffer(''.join(out)+'\0')
+
+        opts.lpstrFilter = LPCWSTR(ctypes.addressof(buf))
+        opts.lpstrDefExt = LPCWSTR(ctypes.addressof(buf))
+    
+    # Call file dialog
+    ok = comdlg32.GetOpenFileNameW(ctypes.byref(opts))
+
+    # Return data
+    if multiple:
+        if ok:
+            # Windows splits the parent folder, followed by files, by null characters.
+            gen = split_null_list(pfile)
+            parent = next(gen)
+            return [parent + "\\" + f for f in gen] or [parent]
+        else:
+            return []
+    else:
+        if ok:
+            return file.value
+        else:
+            return ''
+
+def save_file(title, filetypes):
+    file = ctypes.create_unicode_buffer(BUFFER_SIZE)
+    pfile = ctypes.cast(file, ctypes.c_wchar_p)
+
+    # Default options
+    opts = tagOFNW(
+        lStructSize=ctypes.sizeof(tagOFNW),
+
+        lpstrFile=pfile,
+        nMaxFile=BUFFER_SIZE,
+
+        lpstrTitle=title,
+        Flags=0x0008000A
+    )
+
+    # Filetypes
+    if filetypes:
+        out = []
+        for s, t in filetypes:
+            out.append(f'{s} ({t})\0{";".join(t.split())}\0')
+        
+        buf = ctypes.create_unicode_buffer(''.join(out)+'\0')
+        
+        opts.lpstrFilter = LPCWSTR(ctypes.addressof(buf))
+        opts.lpstrDefExt = LPCWSTR(ctypes.addressof(buf))
+    
+    # Call file dialog
+    ok = comdlg32.GetSaveFileNameW(ctypes.byref(opts))
+
+    # Return data
+    if ok:
+        return file.value
+    else:
+        return ''
+
+# Code simplified and turned into python bindings from the tk8.6.12/win/tkWinDialog.c file.
+# tk is licensed here: https://www.tcl.tk/software/tcltk/license.html
+def directory(title):
+    # Create dialog
+    ifd = ctypes.POINTER(IFileOpenDialog)()
+    
+    ole32.OleInitialize(None)
+    try:
+        hr = ole32.CoCreateInstance(
+            ctypes.byref(ClsidFileOpenDialog),
+            None,
+            1,
+            ctypes.byref(IIDIFileOpenDialog),
+            ctypes.byref(ifd)
+        )
+        if hr < 0: raise OSError("Failed to create dialog")
+
+        # Set options
+        flags = UINT(0)
+        hr = ifd.contents.lpVtbl.contents.GetOptions(ifd, ctypes.byref(flags))
+        if hr < 0: raise OSError("Failed to get options")
+
+        flags = UINT(flags.value | 0x1020)
+        hr = ifd.contents.lpVtbl.contents.SetOptions(ifd, flags)
+
+        # Set title
+        if title is not None: ifd.contents.lpVtbl.contents.SetTitle(ifd, title)
+
+        try:
+            hr = ifd.contents.lpVtbl.contents.Show(ifd, None)
+        except OSError:
+            return ''
+    
+        # Acquire selection result
+        resultIf = LPIShellItem()
+        try:
+            hr = ifd.contents.lpVtbl.contents.GetResult(ifd, ctypes.byref(resultIf))
+            if hr < 0: raise OSError("Failed to get result of directory selection")
+            wstr = LPWSTR()
+            hr = resultIf.contents.lpVtbl.contents.GetDisplayName(resultIf, 0x80058000, ctypes.byref(wstr))
+            if hr < 0: raise OSError("Failed to get display name from shell item")
+            val = wstr.value
+            ole32.CoTaskMemFree(wstr)
+            return val
+        finally:
+            resultIf.contents.lpVtbl.contents.Release(resultIf)
+    finally:
+        ole32.OleUninitialize()
+
+
+# For where the magic numbers come from, see https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-messageboxw
+
+def info(title, message):
+    user32.MessageBoxW(None, message or "", title or "Message", 0x00000040)
+
+def warning(title, message):
+    user32.MessageBoxW(None, message or "", title or "Warning", 0x00000030)
+
+def error(title, message):
+    user32.MessageBoxW(None, message or "", title or "Error", 0x00000010)
+
+def yesno(title, message):
+    if user32.MessageBoxW(None, message or "", title or "", 0x00000030) == 6:
+        return YES
+    else:
+        return NO
+
+def yesnocancel(title, message):
+    r = user32.MessageBoxW(None, message or "", title or "", 0x00000023)
+
+    if r == 2:
+        return CANCEL
+    elif r == 6:
+        return YES
+    else:
+        return NO
+
+def yesno_always(title, message, yes_always=False, no_always=False):
+    """
+    Enhanced yes/no dialog with optional always buttons
+    Button order: No, No Always (if enabled), Yes, Yes Always (if enabled)
+    
+    Uses custom Windows dialog implementation with proper 4-button support.
+    Falls back to standard yesno dialog if custom dialog fails.
+    """
+    try:
+        from .windows_custom_dialog import show_confirmation_dialog, is_available
+        
+        # Use custom dialog if available
+        if is_available():
+            return show_confirmation_dialog(title, message, yes_always, no_always)
+    except Exception:
+        pass
+    
+    # Fallback to standard yesno dialog
+    return yesno(title, message)
+
+def retrycancel(title, message):
+    if user32.MessageBoxW(None, message or "", title or "", 0x00000025) == 4:
+        return RETRY
+    else:
+        return CANCEL
+
+def okcancel(title, message):
+    if user32.MessageBoxW(None, message or "", title or "", 0x00000021) == 1:
+        return OK
+    else:
+        return CANCEL
+
+def generic_dialog(title, message, buttons, default_button, icon):
+    """
+    Generic dialog with custom buttons and icon
+    
+    Args:
+        title (str): Dialog title
+        message (str): Dialog message
+        buttons (list): List of button text strings
+        default_button (int): Index of default button (0-based)
+        icon (str): Icon type (ICON_QUESTION, ICON_WARNING, ICON_ERROR, ICON_INFO)
+    
+    Returns:
+        int: Index of clicked button (0-based)
+    """
+    from .constants import ICON_QUESTION, ICON_WARNING, ICON_ERROR, ICON_INFO
+    
+    if icon not in [ICON_QUESTION, ICON_WARNING, ICON_ERROR, ICON_INFO]:
+        raise ValueError(f"Unsupported icon: {icon}")
+    
+    if not isinstance(buttons, list) or len(buttons) == 0:
+        raise ValueError("buttons must be a non-empty list")
+    
+    if not isinstance(default_button, int) or default_button < 0 or default_button >= len(buttons):
+        raise ValueError(f"default_button must be a valid index (0-{len(buttons)-1})")
+    
+    try:
+        from .windows_custom_dialog import show_generic_dialog, is_available
+        
+        # Use custom dialog implementation
+        if is_available():
+            return show_generic_dialog(title, message, buttons, default_button, icon)
+    except Exception:
+        pass
+    
+    # This should not happen since we require custom dialog support
+    raise RuntimeError("Windows custom dialog implementation not available")

modules/ui/xdialog/windows_structs.py

@@ -0,0 +1,183 @@
+# Code simplified and turned into python bindings from the tk8.6.12/win/tkWinDialog.c file.
+# tk is licensed here: https://www.tcl.tk/software/tcltk/license.html
+
+import ctypes 
+from ctypes.wintypes import *
+from typing import Tuple
+
+LPLPWSTR = ctypes.POINTER(LPWSTR)
+LPVOIDP = ctypes.POINTER(ctypes.c_void_p)
+
+LPOFNHOOKPROC = ctypes.WINFUNCTYPE(ctypes.POINTER(UINT), HWND, UINT, WPARAM, LPARAM)
+
+
+class tagOFNW(ctypes.Structure):
+    _fields_ = [
+        ("lStructSize",         DWORD),
+        ("hwndOwner",           HWND),
+        ("hInstance",           HINSTANCE),
+        ("lpstrFilter",         LPCWSTR),
+        ("lpstrCustomFilter",   LPWSTR),
+        ("nMaxCustFilter",      DWORD),
+        ("nFilterIndex",        DWORD),
+        ("lpstrFile",           LPWSTR),
+        ("nMaxFile",            DWORD),
+        ("lpstrFileTitle",      LPWSTR),
+        ("nMaxFileTitle",       DWORD),
+        ("lpstrInitialDir",     LPCWSTR),
+        ("lpstrTitle",          LPCWSTR),
+        ("Flags",               DWORD),
+        ("nFileOffset",         WORD),
+        ("nFileExtension",      WORD),
+        ("lpstrDefExt",         LPCWSTR),
+        ("lCustData",           LPARAM),
+        ("lpfnHook",            LPOFNHOOKPROC),
+        ("lpTemplateName",      LPCWSTR),
+        ("pvReserved",          ctypes.c_void_p),
+        ("dwReserved",          DWORD),
+        ("FlagsEx",             DWORD)
+    ]
+
+    def __init__(self, *args, **kwargs):
+        ctypes.memset(ctypes.pointer(self), 0, ctypes.sizeof(tagOFNW))
+        super().__init__(*args, **kwargs)
+
+
+class GUID(ctypes.Structure):
+    _fields_ = [
+        ("Data1", ctypes.c_ulong),
+        ("Data2", ctypes.c_ushort),
+        ("Data3", ctypes.c_ushort),
+        ("Data4", ctypes.c_ubyte * 8)
+    ]
+
+    def __init__(self, data1: int, data2: int, data3: int, data4: Tuple[int], *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.Data1 = data1
+        self.Data2 = data2
+        self.Data3 = data3
+
+        arr = self.Data4
+        for i in range(8):
+            arr[i] = data4[i]
+
+CLSID = GUID
+IID = GUID
+REFGUID = ctypes.POINTER(GUID)
+REFIID = ctypes.POINTER(GUID)
+
+ClsidFileOpenDialog = CLSID(
+    0xDC1C5A9C, 0xE88A, 0X4DDE, (0xA5, 0xA1, 0x60, 0xF8, 0x2A, 0x20, 0xAE, 0xF7)
+)
+IIDIFileOpenDialog = IID(
+    0xD57C7288, 0xD4AD, 0x4768, (0xBE, 0x02, 0x9D, 0x96, 0x95, 0x32, 0xD9, 0x60)
+)
+
+
+
+SFGAOF = ULONG
+SICHINTF = DWORD
+LPSFGAOF = ctypes.POINTER(SFGAOF)
+LPLPOLESTR = ctypes.POINTER(LPOLESTR)
+FILEOPENDIALOGOPTIONS = DWORD
+LPFILEOPENDIALOGOPTIONS = ctypes.POINTER(FILEOPENDIALOGOPTIONS)
+
+# System dependent enums, could be wrong (I believe this is c_uint)
+FDAP = ctypes.c_uint
+SIGDN = ctypes.c_uint
+SIATTRIBFLAGS = ctypes.c_uint
+
+# Not useful for now
+IBindCtx = ctypes.c_void_p
+LPIBindCtx = LPVOIDP
+
+
+
+# Single shell item class
+class IShellItem(ctypes.Structure): pass
+
+LPIShellItem = ctypes.POINTER(IShellItem)
+LPLPIShellItem = ctypes.POINTER(ctypes.POINTER(IShellItem))
+
+class IShellItemVtbl(ctypes.Structure):
+    _fields_ = [
+        ('QueryInterface',  ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItem, REFIID, LPVOIDP)),
+        ('AddRef',          ctypes.WINFUNCTYPE(ULONG, LPIShellItem)),
+        ('Release',         ctypes.WINFUNCTYPE(ULONG, LPIShellItem)),
+        ('BindToHandler',   ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItem, LPIBindCtx, REFGUID, REFIID, LPVOIDP)),
+        ('GetParent',       ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItem, LPLPIShellItem)),
+        ('GetDisplayName',  ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItem, SIGDN, LPLPOLESTR)),
+        ('GetAttributes',   ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItem, SFGAOF, LPSFGAOF)),
+        ('Compare',         ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItem, LPIShellItem, SICHINTF, ctypes.POINTER(ctypes.c_int))),
+    ]
+
+IShellItem.\
+    _fields_ = [("lpVtbl", ctypes.POINTER(IShellItemVtbl))]
+
+
+# Multiple shell item class
+class IShellItemArray(ctypes.Structure): pass
+
+LPIShellItemArray = ctypes.POINTER(IShellItem)
+LPLPIShellItemArray = ctypes.POINTER(ctypes.POINTER(IShellItem))
+
+class IShellItemArrayVtbl(ctypes.Structure):
+    _fields_ = [
+        ('QueryInterface',              ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, REFIID, LPVOIDP)),
+        ('AddRef',                      ctypes.WINFUNCTYPE(ULONG, LPIShellItemArray)),
+        ('Release',                     ctypes.WINFUNCTYPE(ULONG, LPIShellItemArray)),
+        ('BindToHandler',               ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, LPIBindCtx, REFGUID, REFIID, LPVOIDP)),
+        ('GetPropertyStore',            ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, ctypes.c_int,  REFIID, LPVOIDP)),
+        ('GetPropertyDescriptionList',  ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, ctypes.c_void_p, REFIID, LPVOIDP)),
+        ('GetAttributes',               ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, SIATTRIBFLAGS, SFGAOF, LPSFGAOF)),
+        ('GetCount',                    ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, LPDWORD)),
+        ('GetItemAt',                   ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, DWORD, LPLPIShellItem)),
+        ('EnumItems',                   ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIShellItemArray, LPVOIDP)),
+    ]
+
+IShellItemArray.\
+    _fields_ = [("lpVtbl", ctypes.POINTER(IShellItemArrayVtbl))]
+
+
+# file open dialog
+class IFileOpenDialog(ctypes.Structure): pass
+
+LPIFileOpenDialog = ctypes.POINTER(IFileOpenDialog)
+LPTCLCOMDLG_FILTERSPEC = ctypes.c_void_p
+
+class IFileOpenDialogVtbl(ctypes.Structure):
+    _fields_ = [
+        ('QueryInterface',          ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, REFIID, LPVOIDP)),
+        ('AddRef',                  ctypes.WINFUNCTYPE(ULONG, LPIFileOpenDialog)),
+        ('Release',                 ctypes.WINFUNCTYPE(ULONG, LPIFileOpenDialog)),
+        ('Show',                    ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, HWND)),
+        ('SetFileTypes',            ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, UINT, LPTCLCOMDLG_FILTERSPEC)),
+        ('SetFileTypeIndex',        ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, UINT)),
+        ('GetFileTypeIndex',        ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPUINT)),
+        ('Advise',                  ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, ctypes.c_void_p, LPDWORD)),
+        ('Unadvise',                ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, DWORD)),
+        ('SetOptions',              ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, FILEOPENDIALOGOPTIONS)),
+        ('GetOptions',              ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPFILEOPENDIALOGOPTIONS)),
+        ('SetDefaultFolder',        ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPIShellItem)),
+        ('SetFolder',               ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPIShellItem)),
+        ('GetFolder',               ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPLPIShellItem)),
+        ('GetCurrentSelection',     ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPLPIShellItem)),
+        ('SetFileName',             ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPCWSTR)),
+        ('GetFileName',             ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPLPWSTR)),
+        ('SetTitle',                ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPCWSTR)),
+        ('SetOkButtonLabel',        ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPCWSTR)),
+        ('SetFileNameLabel',        ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPCWSTR)),
+        ('GetResult',               ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPLPIShellItem)),
+        ('AddPlace',                ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPIShellItem, FDAP)),
+        ('SetDefaultExtension',     ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPCWSTR)),
+        ('Close',                   ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, ctypes.HRESULT)),
+        ('SetClientGuid',           ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, REFGUID)),
+        ('ClearClientData',         ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog)),
+        ('SetFilter',               ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, ctypes.c_void_p)),
+        ('GetResults',              ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPLPIShellItemArray)),
+        ('GetSelectedItems',        ctypes.WINFUNCTYPE(ctypes.HRESULT, LPIFileOpenDialog, LPLPIShellItemArray)),
+    ]
+
+IFileOpenDialog.\
+    _fields_ = [("lpVtbl", ctypes.POINTER(IFileOpenDialogVtbl))]

modules/ui/xdialog/yad_dialogs.py

@@ -0,0 +1,236 @@
+import subprocess
+from os.path import isfile
+from typing import Tuple
+
+from .constants import *
+
+def clean(txt: str):
+    return txt\
+        .replace("\\", "\\\\")\
+        .replace("$", "\\$")\
+        .replace("!", "\\!")\
+        .replace("*", "\\*")\
+        .replace("?", "\\?")\
+        .replace("&", "&")\
+        .replace("|", "|")\
+        .replace("<", "&lt;")\
+        .replace(">", "&gt;")\
+        .replace("(", "\\(")\
+        .replace(")", "\\)")\
+        .replace("[", "\\[")\
+        .replace("]", "\\]")\
+        .replace("{", "\\{")\
+        .replace("}", "\\}")\
+
+def yad(typ, filetypes=None, **kwargs) -> Tuple[int, str]:
+    # Build args based on keywords
+    args = ['yad', '--'+typ]
+    for k, v in kwargs.items():
+        vv = v
+        if not isinstance(v, list):
+            vv = [v]
+
+        for vvv in vv:
+            if vvv is True:
+                args.append(f'--{k.replace("_", "-").strip("-")}')
+            elif isinstance(vvv, str):
+                cv = clean(vvv) if k != "title" else vvv
+                args.append(f'--{k.replace("_", "-").strip("-")}={cv}')
+
+    # Build filetypes specially if specified
+    if filetypes:
+        for name, globs in filetypes:
+            if name:
+                globlist = globs.split()
+                args.append(f'--file-filter={name.replace("|", "")} ({", ".join(t for t in globlist)})|{globs}')
+
+    proc = subprocess.Popen(
+        args,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.DEVNULL,
+        shell=False
+    )
+    stdout, _ = proc.communicate()
+
+    return (proc.returncode, stdout.decode('utf-8').strip())
+
+
+def open_file(title, filetypes, multiple=False):
+    # Yad is strange and will let you select folders for some reason in some cases. So we filter those out.
+    if multiple:
+        files = yad('file', title=(title or ""), filetypes=filetypes, multiple=True, separator="\n", width="800", height="600")[1].splitlines()
+        return list(filter(isfile, files))
+    else:
+        file = yad('file', title=(title or ""), filetypes=filetypes, width="800", height="600")[1]
+        if file and isfile(file):
+            return file
+        else:
+            return ''
+
+def save_file(title, filetypes):
+    return yad('file', title=(title or ""), filetypes=filetypes, save=True, width="800", height="600")[1]
+
+def directory(title):
+    return yad("file", title=(title or ""), directory=True, width="800", height="600")[1]
+
+def info(title, message):
+    yad(
+        "info",
+        title=(title or ""),
+        text=message,
+        image="dialog-information",
+        window_icon="dialog-information",
+        width="350",
+        button=f"OK:{OK}"
+    )
+
+def warning(title, message):
+    yad(
+        "warning",
+        title=(title or ""),
+        text=message,
+        image="dialog-warning",
+        window_icon="dialog-warning",
+        width="350",
+        button=f"OK:{OK}"
+    )
+
+def error(title, message):
+    yad(
+        "error",
+        title=(title or ""),
+        text=message,
+        image="dialog-error",
+        window_icon="dialog-error",
+        width="350",
+        button=f"OK:{OK}"
+    )
+
+def yesno(title, message):
+    r = yad(
+        "question",
+        title=(title or ""),
+        text=message,
+        image="dialog-question",
+        window_icon="dialog-question",
+        width="350",
+        button=[f"No:{NO}", f"Yes:{YES}"]
+    )[0]
+    return NO if r > 128 or r < 0 else r
+
+def yesno_always(title, message, yes_always=False, no_always=False):
+    """
+    Enhanced yes/no dialog with optional always buttons
+    Button order: No, No Always (if enabled), Yes, Yes Always (if enabled)
+    """
+    buttons = []
+    
+    # Build button list in order: No, No Always, Yes, Yes Always
+    buttons.append(f"No:{NO}")
+    if no_always:
+        buttons.append(f"No (Always):{NO_ALWAYS}")
+    buttons.append(f"Yes:{YES}")
+    if yes_always:
+        buttons.append(f"Yes (Always):{YES_ALWAYS}")
+    
+    r = yad(
+        "question",
+        title=(title or ""),
+        text=message,
+        image="dialog-question",
+        window_icon="dialog-question",
+        width="350",
+        button=buttons
+    )[0]
+    return NO if r > 128 or r < 0 else r
+
+def yesnocancel(title, message):
+    r = yad(
+        "question",
+        title=(title or ""),
+        text=message,
+        image="dialog-question",
+        window_icon="dialog-question",
+        width="350",
+        button=[f"Cancel:{CANCEL}", f"No:{NO}", f"Yes:{YES}"]
+    )[0]
+    return CANCEL if r > 128 or r < 0 else r
+
+def retrycancel(title, message):
+    r = yad(
+        "question",
+        title=(title or ""),
+        text=message,
+        image="dialog-question",
+        window_icon="dialog-question",
+        width="350",
+        button=[f"Cancel:{CANCEL}", f"Retry:{RETRY}"]
+    )[0]
+    return CANCEL if r > 128 or r < 0 else r
+
+def okcancel(title, message):
+    r = yad(
+        "question",
+        title=(title or ""),
+        text=message,
+        image="dialog-question",
+        window_icon="dialog-question",
+        width="350",
+        button=[f"Cancel:{CANCEL}", f"OK:{OK}"]
+    )[0]
+    return CANCEL if r > 128 or r < 0 else r
+
+def generic_dialog(title, message, buttons, default_button, icon):
+    """
+    Generic dialog with custom buttons and icon
+    
+    Args:
+        title (str): Dialog title
+        message (str): Dialog message
+        buttons (list): List of button text strings
+        default_button (int): Index of default button (0-based)
+        icon (str): Icon type (ICON_QUESTION, ICON_WARNING, ICON_ERROR, ICON_INFO)
+    
+    Returns:
+        int: Index of clicked button (0-based)
+    """
+    from .constants import ICON_QUESTION, ICON_WARNING, ICON_ERROR, ICON_INFO
+    
+    # Map icon constants to YAD icons
+    icon_map = {
+        ICON_QUESTION: "dialog-question",
+        ICON_WARNING: "dialog-warning", 
+        ICON_ERROR: "dialog-error",
+        ICON_INFO: "dialog-information"
+    }
+    
+    if icon not in icon_map:
+        raise ValueError(f"Unsupported icon: {icon}")
+    
+    if not isinstance(buttons, list) or len(buttons) == 0:
+        raise ValueError("buttons must be a non-empty list")
+    
+    if not isinstance(default_button, int) or default_button < 0 or default_button >= len(buttons):
+        raise ValueError(f"default_button must be a valid index (0-{len(buttons)-1})")
+    
+    # Build button list with custom text and return codes (button index)
+    button_args = []
+    for i, button_text in enumerate(buttons):
+        button_args.append(f"{button_text}:{i}")
+    
+    r = yad(
+        "question",
+        title=(title or ""),
+        text=message,
+        image=icon_map[icon],
+        window_icon=icon_map[icon],
+        width="350",
+        button=button_args
+    )[0]
+    
+    # Handle cancellation/dismissal - return default button index
+    if r > 128 or r < 0:
+        return default_button
+    
+    # YAD returns the button index we specified
+    return r