luajitos

Dialog.lua (83979B)

---

 -- Dialog.lua - Dialog Library for LuajitOS
 -- Provides common dialogs like file open/save, confirm, and prompt
 
 local Dialog = {}
 
 -- Capture global ramdisk functions at load time (before sandbox restricts access)
 local _CRamdiskList = CRamdiskList or _G.CRamdiskList
 
 -- Helper function to list directory contents
 -- Uses global ramdisk functions to show the entire filesystem (not restricted by SafeFS)
 -- This allows users to browse anywhere and select files, then SafeFS is updated to allow access
 local function listDirectory(path)
     if osprint then
         osprint("[Dialog.listDirectory] path=" .. tostring(path) .. "\n")
     end
 
     -- Use global CRamdiskList to show entire filesystem
     if _CRamdiskList then
         local entries = {}
 
         if osprint then
             osprint("[Dialog.listDirectory] Using CRamdiskList\n")
         end
 
         local items = _CRamdiskList(path)
         if items then
             if osprint then
                 osprint("[Dialog.listDirectory] CRamdiskList returned " .. #items .. " items\n")
             end
 
             for _, item in ipairs(items) do
                 if osprint then
                     osprint("[Dialog.listDirectory] item: " .. tostring(item.name) .. " type=" .. tostring(item.type) .. "\n")
                 end
                 table.insert(entries, {
                     name = item.name,
                     type = item.type == "dir" and "directory" or item.type
                 })
             end
         else
             if osprint then
                 osprint("[Dialog.listDirectory] CRamdiskList returned nil\n")
             end
         end
 
         if osprint then
             osprint("[Dialog.listDirectory] total entries: " .. #entries .. "\n")
         end
 
         return entries
     else
         if osprint then
             osprint("[Dialog.listDirectory] CRamdiskList not available\n")
         end
     end
 
     return nil
 end
 
 -- File Open Dialog
 -- Creates a file picker window in the calling application
 -- @param startPath Optional starting directory path (default: "/")
 -- @param options Optional table with fields:
 --   - app: Application instance (required)
 --   - fs: SafeFS instance (optional, for adding paths when file is selected)
 --   - title: Dialog title (default: "Open File")
 --   - width: Dialog width (default: 400)
 --   - height: Dialog height (default: 300)
 -- @return Dialog object with methods:
 --   - openDialog(callback): Show dialog and set callback for result (callback receives path or nil)
 --   - onSuccess(callback): Set callback for when file is selected
 --   - onCancel(callback): Set callback for when dialog is cancelled
 --   - show(): Show the dialog
 --   - close(): Close the dialog
 function Dialog.fileOpen(startPath, options)
     if not options or not options.app then
         error("Dialog.fileOpen requires options.app (Application instance)")
     end
 
     local app = app or options.app
     local fs = options.fs or app.fs  -- Optional, only used for adding allowed paths
     local title = options.title or "Open File"
     local width = options.width or 400
     local height = options.height or 300
 
     startPath = startPath or "/"
 
     local dialog = {
         app = app,
         fs = fs,
         currentPath = startPath,
         window = nil,
         successCallback = nil,
         cancelCallback = nil,
         entries = {},
         scrollOffset = 0,
         _isHidden = true
     }
 
     -- Open dialog with callback (new pattern)
     function dialog:openDialog(callback)
         if type(callback) ~= "function" then
             error("openDialog requires a function")
         end
 
         -- Set callbacks to invoke the single callback with result, then close
         self.successCallback = function(path)
             callback(path)
             self:close()
         end
         self.cancelCallback = function()
             callback(nil)
             self:close()
         end
 
         -- Create and show window
         self:_createWindow()
         return self
     end
 
     -- Set success callback (old pattern)
     function dialog:onSuccess(callback)
         if type(callback) ~= "function" then
             error("onSuccess requires a function")
         end
         self.successCallback = callback
         return self
     end
 
     -- Set cancel callback (old pattern)
     function dialog:onCancel(callback)
         if type(callback) ~= "function" then
             error("onCancel requires a function")
         end
         self.cancelCallback = callback
         return self
     end
 
     -- Load directory contents
     function dialog:loadDirectory(path)
         if osprint then
             osprint("[Dialog] loadDirectory called with path: " .. path .. "\n")
         end
 
         self.currentPath = path
         self.entries = {}
         self.scrollOffset = 0
 
         -- Add parent directory entry if not at root
         if path ~= "/" then
             table.insert(self.entries, {
                 name = "..",
                 type = "parent",
                 path = path:match("(.*/)[^/]+/?$") or "/"
             })
             if osprint then
                 osprint("[Dialog] Added parent directory entry\n")
             end
         end
 
         -- Use helper to get directory contents (supports diskfs and ramdisk)
         local entries = listDirectory(path)
 
         if entries then
             -- Separate directories and files
             local dirs = {}
             local files = {}
 
             for _, entry in ipairs(entries) do
                 if osprint then
                     osprint("[Dialog] Entry: '" .. entry.name .. "' type=" .. entry.type .. "\n")
                 end
 
                 if entry.type == "directory" or entry.type == "dir" then
                     table.insert(dirs, entry.name)
                 elseif entry.type == "file" then
                     table.insert(files, entry.name)
                 end
             end
 
             -- Add directories first (sorted)
             table.sort(dirs)
             for _, dir in ipairs(dirs) do
                 if osprint then
                     osprint("[Dialog] Adding directory: " .. dir .. "\n")
                 end
                 table.insert(self.entries, {
                     name = dir,
                     type = "directory",
                     path = path .. (path:sub(-1) == "/" and "" or "/") .. dir
                 })
             end
 
             -- Add files (sorted)
             table.sort(files)
             for _, file in ipairs(files) do
                 if osprint then
                     osprint("[Dialog] Adding file: " .. file .. "\n")
                 end
                 table.insert(self.entries, {
                     name = file,
                     type = "file",
                     path = path .. (path:sub(-1) == "/" and "" or "/") .. file
                 })
             end
         end
 
         if osprint then
             osprint("[Dialog] Total entries: " .. #self.entries .. "\n")
         end
 
         if self.window then
             self.window:markDirty()
         end
     end
 
     -- Close dialog
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
             self._isHidden = true
         end
     end
 
     -- Show dialog (old pattern)
     function dialog:show()
         if not self._isHidden then
             return self -- Already showing
         end
         self:_createWindow()
         return self
     end
 
     -- Internal: Create window (used by both show() and openDialog())
     function dialog:_createWindow()
         if self.window then
             return -- Already created
         end
 
         self._isHidden = false
 
         -- Create dialog window
         local screenWidth = 1024
         local screenHeight = 768
         local x = math.floor((screenWidth - width) / 2)
         local y = math.floor((screenHeight - height) / 2)
 
         self.window = self.app:newWindow(x, y, width, height)
         self.window.title = title
 
         -- Load initial directory
         self:loadDirectory(self.currentPath)
 
         -- Draw callback
         self.window.onDraw = function(gfx)
             -- Background
             gfx:fillRect(0, 0, width, height, 0x2C2C2C)
 
             -- Title bar background (drawn by window system, but we draw path)
             local pathY = 5
             gfx:fillRect(0, pathY, width, 25, 0x3C3C3C)
 
             -- Current path
             local displayPath = self.currentPath
             if #displayPath > 50 then
                 displayPath = "..." .. displayPath:sub(-47)
             end
             gfx:drawText(10, pathY + 7, displayPath, 0xCCCCCC)
 
             -- File list area
             local listY = 35
             local listHeight = height - listY - 40
             local itemHeight = 25
             local visibleItems = math.floor(listHeight / itemHeight)
 
             -- Draw entries
             local y = listY
             local startIdx = self.scrollOffset + 1
             local endIdx = math.min(startIdx + visibleItems - 1, #self.entries)
 
             for i = startIdx, endIdx do
                 local entry = self.entries[i]
                 local isHovered = false -- TODO: Add hover detection
 
                 -- Background (alternate colors)
                 local bgColor = (i % 2 == 0) and 0x383838 or 0x2C2C2C
                 gfx:fillRect(0, y, width, itemHeight, bgColor)
 
                 -- Icon (simple text-based)
                 local icon = ""
                 local iconColor = 0xCCCCCC
                 if entry.type == "parent" then
                     icon = "^"
                     iconColor = 0xFFCC00
                 elseif entry.type == "directory" then
                     icon = "/"
                     iconColor = 0x66CCFF
                 else
                     icon = " "
                     iconColor = 0xFFFFFF
                 end
 
                 gfx:drawText(10, y + 7, icon, iconColor)
 
                 -- Name
                 local nameColor = 0xFFFFFF
                 if entry.type == "directory" or entry.type == "parent" then
                     nameColor = 0x66CCFF
                 end
 
                 local displayName = entry.name
                 if #displayName > 45 then
                     displayName = displayName:sub(1, 42) .. "..."
                 end
 
                 gfx:drawText(30, y + 7, displayName, nameColor)
 
                 y = y + itemHeight
             end
 
             -- Scrollbar if needed
             if #self.entries > visibleItems then
                 local scrollbarX = width - 15
                 local scrollbarHeight = listHeight
                 local thumbHeight = math.max(20, math.floor(scrollbarHeight * visibleItems / #self.entries))
                 local thumbY = listY + math.floor((scrollbarHeight - thumbHeight) * self.scrollOffset / (#self.entries - visibleItems))
 
                 -- Scrollbar track
                 gfx:fillRect(scrollbarX, listY, 10, scrollbarHeight, 0x1C1C1C)
 
                 -- Scrollbar thumb
                 gfx:fillRect(scrollbarX, thumbY, 10, thumbHeight, 0x4C4C4C)
             end
 
             -- Buttons area
             local buttonY = height - 35
             gfx:fillRect(0, buttonY - 5, width, 40, 0x3C3C3C)
 
             -- Cancel button
             local cancelX = width - 90
             gfx:fillRect(cancelX, buttonY, 80, 25, 0x555555)
             gfx:drawRect(cancelX, buttonY, 80, 25, 0x777777)
             gfx:drawText(cancelX + 18, buttonY + 7, "Cancel", 0xFFFFFF)
         end
 
         -- Click handler
         self.window.onClick = function(mx, my)
             if osprint then
                 osprint("[Dialog.fileOpen.onClick] mx=" .. mx .. " my=" .. my .. " window.y=" .. tostring(self.window.y) .. "\n")
             end
             local listY = 35
             local listHeight = height - listY - 40
             local itemHeight = 25
             local visibleItems = math.floor(listHeight / itemHeight)
 
             -- Check if click is in file list area
             if my >= listY and my < listY + listHeight then
                 local clickedIdx = math.floor((my - listY) / itemHeight) + self.scrollOffset + 1
 
                 if clickedIdx >= 1 and clickedIdx <= #self.entries then
                     local entry = self.entries[clickedIdx]
 
                     if entry.type == "directory" or entry.type == "parent" then
                         -- Navigate to directory
                         self:loadDirectory(entry.path)
                     elseif entry.type == "file" then
                         -- File selected
                         if self.successCallback then
                             -- Add the file's directory to the app's SafeFS allowedPaths
                             local fileDir = entry.path:match("(.*/)[^/]+$") or "/"
 
                             -- Use SafeFS internal addAllowedPath (stored in _G._safefsInternal)
                             if self.fs and _G._safefsInternal then
                                 local internal = _G._safefsInternal[self.fs]
                                 if internal and internal.addAllowedPath then
                                     local success, err = internal.addAllowedPath(fileDir .. "*")
                                     if osprint then
                                         if success then
                                             osprint("[Dialog] Added allowed path: " .. fileDir .. "*\n")
                                         else
                                             osprint("[Dialog] Failed to add allowed path: " .. tostring(err) .. "\n")
                                         end
                                     end
                                 end
                             end
 
                             self.successCallback(entry.path)
                         end
                     end
                 end
                 return
             end
 
             -- Check if click is on cancel button
             local buttonY = height - 35
             local cancelX = width - 90
             if mx >= cancelX and mx < cancelX + 80 and my >= buttonY and my < buttonY + 25 then
                 if self.cancelCallback then
                     self.cancelCallback()
                 end
                 return
             end
         end
 
         return self
     end
 
     return dialog
 end
 
 -- File Save Dialog
 -- Similar to fileOpen but with a filename input field
 -- @param startPath Optional starting directory path (default: "/")
 -- @param defaultName Optional default filename
 -- @param options Optional table with same fields as fileOpen
 -- @return Dialog object with same methods as fileOpen
 function Dialog.fileSave(startPath, defaultName, options)
     if not options or not options.app then
         error("Dialog.fileSave requires options.app (Application instance)")
     end
 
     local app = options.app
     local fs = options.fs or app.fs  -- Optional, only used for adding allowed paths
     local title = options.title or "Save File"
     local width = options.width or 400
     local height = options.height or 350  -- Taller to accommodate filename input
 
     startPath = startPath or "/"
     defaultName = defaultName or "untitled"
 
     local dialog = {
         app = app,
         fs = fs,
         currentPath = startPath,
         filename = defaultName,
         window = nil,
         successCallback = nil,
         cancelCallback = nil,
         entries = {},
         scrollOffset = 0,
         filenameInputActive = false,
         _isHidden = true
     }
 
     -- Open dialog with callback (new pattern)
     function dialog:openDialog(callback)
         if type(callback) ~= "function" then
             error("openDialog requires a function")
         end
 
         -- Set callbacks to invoke the single callback with result, then close
         self.successCallback = function(path)
             callback(path)
             self:close()
         end
         self.cancelCallback = function()
             callback(nil)
             self:close()
         end
 
         -- Create and show window
         self:_createWindow()
         return self
     end
 
     -- Set success callback (old pattern)
     function dialog:onSuccess(callback)
         if type(callback) ~= "function" then
             error("onSuccess requires a function")
         end
         self.successCallback = callback
         return self
     end
 
     -- Set cancel callback (old pattern)
     function dialog:onCancel(callback)
         if type(callback) ~= "function" then
             error("onCancel requires a function")
         end
         self.cancelCallback = callback
         return self
     end
 
     -- Load directory contents
     function dialog:loadDirectory(path)
         if osprint then
             osprint("[Dialog] loadDirectory called with path: " .. path .. "\n")
         end
 
         self.currentPath = path
         self.entries = {}
         self.scrollOffset = 0
 
         -- Add parent directory entry if not at root
         if path ~= "/" then
             table.insert(self.entries, {
                 name = "..",
                 type = "parent",
                 path = path:match("(.*/)[^/]+/?$") or "/"
             })
             if osprint then
                 osprint("[Dialog] Added parent directory entry\n")
             end
         end
 
         -- Use helper to get directory contents (supports diskfs and ramdisk)
         local entries = listDirectory(path)
 
         if entries then
             -- Separate directories and files
             local dirs = {}
             local files = {}
 
             for _, entry in ipairs(entries) do
                 if osprint then
                     osprint("[Dialog] Entry: '" .. entry.name .. "' type=" .. entry.type .. "\n")
                 end
 
                 if entry.type == "directory" or entry.type == "dir" then
                     table.insert(dirs, entry.name)
                 elseif entry.type == "file" then
                     table.insert(files, entry.name)
                 end
             end
 
             -- Add directories first (sorted)
             table.sort(dirs)
             for _, dir in ipairs(dirs) do
                 if osprint then
                     osprint("[Dialog] Adding directory: " .. dir .. "\n")
                 end
                 table.insert(self.entries, {
                     name = dir,
                     type = "directory",
                     path = path .. (path:sub(-1) == "/" and "" or "/") .. dir
                 })
             end
 
             -- Add files (sorted)
             table.sort(files)
             for _, file in ipairs(files) do
                 if osprint then
                     osprint("[Dialog] Adding file: " .. file .. "\n")
                 end
                 table.insert(self.entries, {
                     name = file,
                     type = "file",
                     path = path .. (path:sub(-1) == "/" and "" or "/") .. file
                 })
             end
         end
 
         if osprint then
             osprint("[Dialog] Total entries: " .. #self.entries .. "\n")
         end
 
         if self.window then
             self.window:markDirty()
         end
     end
 
     -- Close dialog
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
             self._isHidden = true
         end
     end
 
     -- Show dialog (old pattern)
     function dialog:show()
         if not self._isHidden then
             return self -- Already showing
         end
         self:_createWindow()
         return self
     end
 
     -- Internal: Create window
     function dialog:_createWindow()
         if self.window then
             return -- Already created
         end
 
         self._isHidden = false
 
         -- Create dialog window
         local screenWidth = 1024
         local screenHeight = 768
         local x = math.floor((screenWidth - width) / 2)
         local y = math.floor((screenHeight - height) / 2)
 
         self.window = self.app:newWindow(x, y, width, height)
         self.window.title = title
 
         -- Load initial directory
         self:loadDirectory(self.currentPath)
 
         -- Draw callback
         self.window.onDraw = function(gfx)
             -- Background
             gfx:fillRect(0, 0, width, height, 0x2C2C2C)
 
             -- Title bar background (drawn by window system, but we draw path)
             local pathY = 5
             gfx:fillRect(0, pathY, width, 25, 0x3C3C3C)
 
             -- Current path
             local displayPath = self.currentPath
             if #displayPath > 50 then
                 displayPath = "..." .. displayPath:sub(-47)
             end
             gfx:drawText(10, pathY + 7, displayPath, 0xCCCCCC)
 
             -- File list area
             local listY = 35
             local listHeight = height - listY - 90  -- Extra space for filename input
             local itemHeight = 25
             local visibleItems = math.floor(listHeight / itemHeight)
 
             -- Draw entries
             local y = listY
             local startIdx = self.scrollOffset + 1
             local endIdx = math.min(startIdx + visibleItems - 1, #self.entries)
 
             for i = startIdx, endIdx do
                 local entry = self.entries[i]
 
                 -- Background (alternate colors)
                 local bgColor = (i % 2 == 0) and 0x383838 or 0x2C2C2C
                 gfx:fillRect(0, y, width, itemHeight, bgColor)
 
                 -- Icon (simple text-based)
                 local icon = ""
                 local iconColor = 0xCCCCCC
                 if entry.type == "parent" then
                     icon = "^"
                     iconColor = 0xFFCC00
                 elseif entry.type == "directory" then
                     icon = "/"
                     iconColor = 0x66CCFF
                 else
                     icon = " "
                     iconColor = 0xFFFFFF
                 end
 
                 gfx:drawText(10, y + 7, icon, iconColor)
 
                 -- Name
                 local nameColor = 0xFFFFFF
                 if entry.type == "directory" or entry.type == "parent" then
                     nameColor = 0x66CCFF
                 end
 
                 local displayName = entry.name
                 if #displayName > 45 then
                     displayName = displayName:sub(1, 42) .. "..."
                 end
 
                 gfx:drawText(30, y + 7, displayName, nameColor)
 
                 y = y + itemHeight
             end
 
             -- Scrollbar if needed
             if #self.entries > visibleItems then
                 local scrollbarX = width - 15
                 local scrollbarHeight = listHeight
                 local thumbHeight = math.max(20, math.floor(scrollbarHeight * visibleItems / #self.entries))
                 local thumbY = listY + math.floor((scrollbarHeight - thumbHeight) * self.scrollOffset / (#self.entries - visibleItems))
 
                 -- Scrollbar track
                 gfx:fillRect(scrollbarX, listY, 10, scrollbarHeight, 0x1C1C1C)
 
                 -- Scrollbar thumb
                 gfx:fillRect(scrollbarX, thumbY, 10, thumbHeight, 0x4C4C4C)
             end
 
             -- Filename input area
             local inputY = height - 85
             gfx:fillRect(0, inputY - 5, width, 50, 0x3C3C3C)
 
             -- Label
             gfx:drawText(10, inputY + 2, "Filename:", 0xCCCCCC)
 
             -- Input box
             local inputBoxX = 90
             local inputBoxY = inputY
             local inputBoxWidth = width - 100
             local inputBoxHeight = 25
 
             local inputBgColor = self.filenameInputActive and 0x4C4C4C or 0x383838
             gfx:fillRect(inputBoxX, inputBoxY, inputBoxWidth, inputBoxHeight, inputBgColor)
             gfx:drawRect(inputBoxX, inputBoxY, inputBoxWidth, inputBoxHeight, 0x666666)
 
             -- Filename text
             local displayFilename = self.filename
             if #displayFilename > 40 then
                 displayFilename = displayFilename:sub(-40)
             end
             gfx:drawText(inputBoxX + 5, inputBoxY + 7, displayFilename, 0xFFFFFF)
 
             -- Cursor if active
             if self.filenameInputActive then
                 local cursorX = inputBoxX + 5 + (#displayFilename * 6)  -- Approximate char width
                 gfx:fillRect(cursorX, inputBoxY + 5, 3, 15, 0xFFFFFF)
             end
 
             -- Buttons area
             local buttonY = height - 35
             gfx:fillRect(0, buttonY - 5, width, 40, 0x3C3C3C)
 
             -- Save button
             local saveX = width - 180
             local saveEnabled = #self.filename > 0
             local saveBgColor = saveEnabled and 0x0066CC or 0x444444
             gfx:fillRect(saveX, buttonY, 80, 25, saveBgColor)
             gfx:drawRect(saveX, buttonY, 80, 25, 0x777777)
             local saveTextColor = saveEnabled and 0xFFFFFF or 0x888888
             gfx:drawText(saveX + 22, buttonY + 7, "Save", saveTextColor)
 
             -- Cancel button
             local cancelX = width - 90
             gfx:fillRect(cancelX, buttonY, 80, 25, 0x555555)
             gfx:drawRect(cancelX, buttonY, 80, 25, 0x777777)
             gfx:drawText(cancelX + 18, buttonY + 7, "Cancel", 0xFFFFFF)
         end
 
         -- Input handler for filename typing
         self.window.onInput = function(key, scancode)
             if not self.filenameInputActive then
                 return
             end
 
             if key == "\b" then
                 -- Backspace
                 if #self.filename > 0 then
                     self.filename = self.filename:sub(1, -2)
                     self.window:markDirty()
                 end
             elseif key == "\n" then
                 -- Enter key - save
                 if #self.filename > 0 then
                     local fullPath = self.currentPath .. (self.currentPath:sub(-1) == "/" and "" or "/") .. self.filename
                     if self.successCallback then
                         self.successCallback(fullPath)
                     end
                 end
             elseif key == "\t" then
                 -- Tab - ignore
             elseif #key == 1 then
                 -- Regular character
                 self.filename = self.filename .. key
                 self.window:markDirty()
             end
         end
 
         -- Click handler
         self.window.onClick = function(mx, my)
             local listY = 35
             local listHeight = height - listY - 90
             local itemHeight = 25
             local visibleItems = math.floor(listHeight / itemHeight)
 
             -- Check if click is in file list area
             if my >= listY and my < listY + listHeight then
                 local clickedIdx = math.floor((my - listY) / itemHeight) + self.scrollOffset + 1
 
                 if clickedIdx >= 1 and clickedIdx <= #self.entries then
                     local entry = self.entries[clickedIdx]
 
                     if entry.type == "directory" or entry.type == "parent" then
                         -- Navigate to directory
                         self:loadDirectory(entry.path)
                     elseif entry.type == "file" then
                         -- File clicked - set filename in input
                         self.filename = entry.name
                         self.filenameInputActive = true
                         self.window:markDirty()
 
                         -- Focus window for input
                         if sys and sys.setActiveWindow then
                             sys.setActiveWindow(self.window)
                         end
                     end
                 end
                 return
             end
 
             -- Check if click is in filename input
             local inputY = height - 85
             local inputBoxX = 90
             local inputBoxWidth = width - 100
             local inputBoxHeight = 25
 
             if mx >= inputBoxX and mx < inputBoxX + inputBoxWidth and
                my >= inputY and my < inputY + inputBoxHeight then
                 self.filenameInputActive = true
                 self.window:markDirty()
 
                 -- Focus window for input
                 if sys and sys.setActiveWindow then
                     sys.setActiveWindow(self.window)
                 end
                 return
             else
                 -- Click outside input - deactivate
                 if self.filenameInputActive then
                     self.filenameInputActive = false
                     self.window:markDirty()
                 end
             end
 
             -- Check if click is on save button
             local buttonY = height - 35
             local saveX = width - 180
             if mx >= saveX and mx < saveX + 80 and my >= buttonY and my < buttonY + 25 then
                 if #self.filename > 0 then
                     local fullPath = self.currentPath .. (self.currentPath:sub(-1) == "/" and "" or "/") .. self.filename
                     if self.successCallback then
                         self.successCallback(fullPath)
                     end
                 end
                 return
             end
 
             -- Check if click is on cancel button
             local cancelX = width - 90
             if mx >= cancelX and mx < cancelX + 80 and my >= buttonY and my < buttonY + 25 then
                 if self.cancelCallback then
                     self.cancelCallback()
                 end
                 return
             end
         end
 
         return self
     end
 
     return dialog
 end
 
 -- Confirmation Dialog
 -- Creates a simple confirmation dialog with two buttons
 -- @param message The message to display (default: "Confirm?")
 -- @param yesText Text for the yes/confirm button (default: "Yes")
 -- @param noText Text for the no/cancel button (default: "No")
 -- @param options Optional table with fields:
 --   - app: Application instance (required)
 --   - title: Dialog title (default: "Confirm")
 --   - width: Dialog width (default: 300)
 --   - height: Dialog height (default: 150)
 -- @return Dialog object with methods:
 --   - openDialog(callback): Show dialog and set callback for result (callback receives true or false)
 --   - onYes(callback): Set callback for yes button
 --   - onNo(callback): Set callback for no button
 --   - show(): Show the dialog
 --   - close(): Close the dialog
 function Dialog.confirm(message, yesText, noText, options)
     -- Handle if called with just options (no message)
     if type(message) == "table" and options == nil then
         options = message
         message = nil
     end
 
     if not options or not options.app then
         error("Dialog.confirm requires options.app (Application instance)")
     end
 
     local app = options.app
     message = message or "Confirm?"
     yesText = yesText or "Yes"
     noText = noText or "No"
     local title = options.title or "Confirm"
     local width = options.width or 300
     local height = options.height or 150
 
     local dialog = {
         app = app,
         message = message,
         yesText = yesText,
         noText = noText,
         window = nil,
         yesCallback = nil,
         noCallback = nil,
         _isHidden = true
     }
 
     -- Open dialog with callback (new pattern)
     function dialog:openDialog(callback)
         if type(callback) ~= "function" then
             error("openDialog requires a function")
         end
 
         -- Set callbacks to invoke the single callback with result, then close
         self.yesCallback = function()
             callback(true)
             self:close()
         end
         self.noCallback = function()
             callback(false)
             self:close()
         end
 
         -- Create and show window
         self:_createWindow()
         return self
     end
 
     -- Set yes callback (old pattern)
     function dialog:onYes(callback)
         if type(callback) ~= "function" then
             error("onYes requires a function")
         end
         self.yesCallback = callback
         return self
     end
 
     -- Set no callback (old pattern)
     function dialog:onNo(callback)
         if type(callback) ~= "function" then
             error("onNo requires a function")
         end
         self.noCallback = callback
         return self
     end
 
     -- Close dialog
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
             self._isHidden = true
         end
     end
 
     -- Show dialog (old pattern)
     function dialog:show()
         if not self._isHidden then
             return self -- Already showing
         end
         self:_createWindow()
         return self
     end
 
     -- Internal: Create window
     function dialog:_createWindow()
         if self.window then
             return -- Already created
         end
 
         self._isHidden = false
 
         -- Create dialog window centered on screen
         local screenWidth = 1024
         local screenHeight = 768
         local x = math.floor((screenWidth - width) / 2)
         local y = math.floor((screenHeight - height) / 2)
 
         self.window = self.app:newWindow(x, y, width, height)
         self.window.title = title
 
         -- Draw callback
         self.window.onDraw = function(gfx)
             -- Background
             gfx:fillRect(0, 0, width, height, 0x2C2C2C)
 
             -- Message area
             local messageY = 30
             local messageHeight = height - 80
 
             -- Word wrap the message
             local maxChars = math.floor((width - 20) / 6)  -- Approximate chars per line
             local lines = {}
             local currentLine = ""
 
             for word in self.message:gmatch("%S+") do
                 if #currentLine + #word + 1 > maxChars then
                     if #currentLine > 0 then
                         table.insert(lines, currentLine)
                         currentLine = word
                     else
                         -- Word is too long, just add it
                         table.insert(lines, word)
                     end
                 else
                     if #currentLine > 0 then
                         currentLine = currentLine .. " " .. word
                     else
                         currentLine = word
                     end
                 end
             end
 
             if #currentLine > 0 then
                 table.insert(lines, currentLine)
             end
 
             -- Draw message lines
             local lineHeight = 15
             local startY = messageY + math.floor((messageHeight - (#lines * lineHeight)) / 2)
 
             for i, line in ipairs(lines) do
                 local textX = math.floor((width - (#line * 6)) / 2)  -- Center text
                 gfx:drawText(textX, startY + (i - 1) * lineHeight, line, 0xFFFFFF)
             end
 
             -- Buttons area
             local buttonY = height - 40
             local buttonWidth = 80
             local buttonHeight = 25
             local buttonSpacing = 20
 
             -- Calculate button positions (centered)
             local totalWidth = buttonWidth * 2 + buttonSpacing
             local startX = math.floor((width - totalWidth) / 2)
 
             -- No button (left)
             local noX = startX
             gfx:fillRect(noX, buttonY, buttonWidth, buttonHeight, 0x555555)
             gfx:drawRect(noX, buttonY, buttonWidth, buttonHeight, 0x777777)
 
             local noTextWidth = #self.noText * 6
             local noTextX = noX + math.floor((buttonWidth - noTextWidth) / 2)
             gfx:drawText(noTextX, buttonY + 7, self.noText, 0xFFFFFF)
 
             -- Yes button (right)
             local yesX = startX + buttonWidth + buttonSpacing
             gfx:fillRect(yesX, buttonY, buttonWidth, buttonHeight, 0x0066CC)
             gfx:drawRect(yesX, buttonY, buttonWidth, buttonHeight, 0x0088EE)
 
             local yesTextWidth = #self.yesText * 6
             local yesTextX = yesX + math.floor((buttonWidth - yesTextWidth) / 2)
             gfx:drawText(yesTextX, buttonY + 7, self.yesText, 0xFFFFFF)
         end
 
         -- Click handler
         self.window.onClick = function(mx, my)
             local buttonY = height - 40
             local buttonWidth = 80
             local buttonHeight = 25
             local buttonSpacing = 20
 
             local totalWidth = buttonWidth * 2 + buttonSpacing
             local startX = math.floor((width - totalWidth) / 2)
 
             -- No button
             local noX = startX
             if mx >= noX and mx < noX + buttonWidth and my >= buttonY and my < buttonY + buttonHeight then
                 if self.noCallback then
                     self.noCallback()
                 end
                 return
             end
 
             -- Yes button
             local yesX = startX + buttonWidth + buttonSpacing
             if mx >= yesX and mx < yesX + buttonWidth and my >= buttonY and my < buttonY + buttonHeight then
                 if self.yesCallback then
                     self.yesCallback()
                 end
                 return
             end
         end
 
         return self
     end
 
     return dialog
 end
 
 -- Prompt Dialog
 -- Creates a text input dialog with optional autocomplete values
 -- @param message The message/question to display (default: "Enter value:")
 -- @param autocompleteValues Optional array of strings for autocomplete (default: nil)
 -- @param options Optional table with fields:
 --   - app: Application instance (required)
 --   - title: Dialog title (default: "Prompt")
 --   - width: Dialog width (default: 350)
 --   - height: Dialog height (default: 200)
 -- @return Dialog object with methods:
 --   - openDialog(callback): Show dialog and set callback for result (callback receives text or nil)
 --   - onSuccess(callback): Set callback for when text is submitted
 --   - onCancel(callback): Set callback for when dialog is cancelled
 --   - show(): Show the dialog
 --   - close(): Close the dialog
 function Dialog.prompt(message, autocompleteValues, options)
     -- Handle if called with just options (no message)
     if type(message) == "table" and autocompleteValues == nil and options == nil then
         options = message
         message = nil
         autocompleteValues = nil
     end
 
     if not options or not options.app then
         error("Dialog.prompt requires options.app (Application instance)")
     end
 
     local app = options.app
     message = message or "Enter value:"
     autocompleteValues = autocompleteValues or {}
     local title = options.title or "Prompt"
     local width = options.width or 350
     local height = options.height or 200
 
     local dialog = {
         app = app,
         message = message,
         autocompleteValues = autocompleteValues,
         inputText = "",
         window = nil,
         successCallback = nil,
         cancelCallback = nil,
         inputActive = false,
         filteredAutocomplete = {},
         selectedAutocompleteIndex = 0,
         _isHidden = true
     }
 
     -- Open dialog with callback (new pattern)
     function dialog:openDialog(callback)
         if type(callback) ~= "function" then
             error("openDialog requires a function")
         end
 
         -- Set callbacks to invoke the single callback with result
         self.successCallback = function(text)
             callback(text)
         end
         self.cancelCallback = function()
             callback(nil)
         end
 
         -- Create and show window
         self:_createWindow()
         return self
     end
 
     -- Set success callback (old pattern)
     function dialog:onSuccess(callback)
         if type(callback) ~= "function" then
             error("onSuccess requires a function")
         end
         self.successCallback = callback
         return self
     end
 
     -- Set cancel callback (old pattern)
     function dialog:onCancel(callback)
         if type(callback) ~= "function" then
             error("onCancel requires a function")
         end
         self.cancelCallback = callback
         return self
     end
 
     -- Update autocomplete suggestions based on current input
     function dialog:updateAutocomplete()
         self.filteredAutocomplete = {}
         self.selectedAutocompleteIndex = 0
 
         if #self.inputText > 0 and #self.autocompleteValues > 0 then
             local lowerInput = self.inputText:lower()
             for _, value in ipairs(self.autocompleteValues) do
                 if value:lower():find(lowerInput, 1, true) == 1 then
                     table.insert(self.filteredAutocomplete, value)
                 end
             end
         end
     end
 
     -- Close dialog
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
             self._isHidden = true
         end
     end
 
     -- Show dialog (old pattern)
     function dialog:show()
         if not self._isHidden then
             return self -- Already showing
         end
         self:_createWindow()
         return self
     end
 
     -- Internal: Create window
     function dialog:_createWindow()
         if self.window then
             return -- Already created
         end
 
         self._isHidden = false
 
         -- Create dialog window centered on screen
         local screenWidth = 1024
         local screenHeight = 768
         local x = math.floor((screenWidth - width) / 2)
         local y = math.floor((screenHeight - height) / 2)
 
         self.window = self.app:newWindow(x, y, width, height)
         self.window.title = title
         self.inputActive = true  -- Activate input by default
 
         -- Draw callback
         self.window.onDraw = function(gfx)
             -- Background
             gfx:fillRect(0, 0, width, height, 0x2C2C2C)
 
             -- Message area
             local messageY = 20
             gfx:drawText(10, messageY, self.message, 0xCCCCCC)
 
             -- Input box
             local inputY = messageY + 30
             local inputWidth = width - 20
             local inputHeight = 25
 
             local inputBgColor = self.inputActive and 0x4C4C4C or 0x383838
             gfx:fillRect(10, inputY, inputWidth, inputHeight, inputBgColor)
             gfx:drawRect(10, inputY, inputWidth, inputHeight, 0x666666)
 
             -- Input text
             local displayText = self.inputText
             if #displayText > 50 then
                 displayText = displayText:sub(-50)
             end
             gfx:drawText(15, inputY + 7, displayText, 0xFFFFFF)
 
             -- Cursor if active
             if self.inputActive then
                 local cursorX = 15 + (#displayText * 6)  -- Approximate char width
                 gfx:fillRect(cursorX, inputY + 5, 2, 15, 0xFFFFFF)
             end
 
             -- Autocomplete suggestions
             local autocompleteY = inputY + 30
             if #self.filteredAutocomplete > 0 then
                 local maxSuggestions = 5
                 for i = 1, math.min(maxSuggestions, #self.filteredAutocomplete) do
                     local value = self.filteredAutocomplete[i]
                     local suggestionHeight = 20
                     local y = autocompleteY + (i - 1) * suggestionHeight
 
                     -- Highlight selected suggestion
                     local bgColor = (i == self.selectedAutocompleteIndex) and 0x4C4C4C or 0x383838
                     gfx:fillRect(10, y, inputWidth, suggestionHeight, bgColor)
 
                     -- Truncate if too long
                     local displayValue = value
                     if #displayValue > 50 then
                         displayValue = displayValue:sub(1, 47) .. "..."
                     end
 
                     gfx:drawText(15, y + 4, displayValue, 0xCCCCCC)
                 end
             end
 
             -- Buttons area
             local buttonY = height - 40
             local buttonWidth = 80
             local buttonHeight = 25
             local buttonSpacing = 20
 
             -- Calculate button positions (centered)
             local totalWidth = buttonWidth * 2 + buttonSpacing
             local startX = math.floor((width - totalWidth) / 2)
 
             -- Cancel button (left)
             local cancelX = startX
             gfx:fillRect(cancelX, buttonY, buttonWidth, buttonHeight, 0x555555)
             gfx:drawRect(cancelX, buttonY, buttonWidth, buttonHeight, 0x777777)
             gfx:drawText(cancelX + 18, buttonY + 7, "Cancel", 0xFFFFFF)
 
             -- OK button (right)
             local okX = startX + buttonWidth + buttonSpacing
             gfx:fillRect(okX, buttonY, buttonWidth, buttonHeight, 0x0066CC)
             gfx:drawRect(okX, buttonY, buttonWidth, buttonHeight, 0x0088EE)
             gfx:drawText(okX + 30, buttonY + 7, "OK", 0xFFFFFF)
         end
 
         -- Input handler for text typing
         self.window.onInput = function(key, scancode)
             if not self.inputActive then
                 return
             end
 
             if key == "\b" then
                 -- Backspace
                 if #self.inputText > 0 then
                     self.inputText = self.inputText:sub(1, -2)
                     self:updateAutocomplete()
                     self.window:markDirty()
                 end
             elseif key == "\n" then
                 -- Enter key - submit
                 if self.successCallback then
                     self.successCallback(self.inputText)
                 end
             elseif key == "\t" then
                 -- Tab - autocomplete if available
                 if self.selectedAutocompleteIndex > 0 and self.selectedAutocompleteIndex <= #self.filteredAutocomplete then
                     self.inputText = self.filteredAutocomplete[self.selectedAutocompleteIndex]
                     self:updateAutocomplete()
                     self.window:markDirty()
                 elseif #self.filteredAutocomplete > 0 then
                     self.inputText = self.filteredAutocomplete[1]
                     self:updateAutocomplete()
                     self.window:markDirty()
                 end
             elseif #key == 1 then
                 -- Regular character
                 self.inputText = self.inputText .. key
                 self:updateAutocomplete()
                 self.window:markDirty()
             end
         end
 
         -- Click handler
         self.window.onClick = function(mx, my)
             local messageY = 20
             local inputY = messageY + 30
             local inputWidth = width - 20
             local inputHeight = 25
 
             -- Check if click is on input box
             if mx >= 10 and mx < 10 + inputWidth and my >= inputY and my < inputY + inputHeight then
                 self.inputActive = true
                 self.window:markDirty()
 
                 -- Focus window for input
                 if sys and sys.setActiveWindow then
                     sys.setActiveWindow(self.window)
                 end
                 return
             end
 
             -- Check if click is on autocomplete suggestion
             local autocompleteY = inputY + 30
             if #self.filteredAutocomplete > 0 then
                 local maxSuggestions = 5
                 for i = 1, math.min(maxSuggestions, #self.filteredAutocomplete) do
                     local suggestionHeight = 20
                     local y = autocompleteY + (i - 1) * suggestionHeight
 
                     if mx >= 10 and mx < 10 + inputWidth and my >= y and my < y + suggestionHeight then
                         -- Clicked on suggestion - fill input
                         self.inputText = self.filteredAutocomplete[i]
                         self:updateAutocomplete()
                         self.window:markDirty()
                         return
                     end
                 end
             end
 
             -- Check if click is on buttons
             local buttonY = height - 40
             local buttonWidth = 80
             local buttonHeight = 25
             local buttonSpacing = 20
 
             local totalWidth = buttonWidth * 2 + buttonSpacing
             local startX = math.floor((width - totalWidth) / 2)
 
             -- Cancel button
             local cancelX = startX
             if mx >= cancelX and mx < cancelX + buttonWidth and my >= buttonY and my < buttonY + buttonHeight then
                 if self.cancelCallback then
                     self.cancelCallback()
                 end
                 return
             end
 
             -- OK button
             local okX = startX + buttonWidth + buttonSpacing
             if mx >= okX and mx < okX + buttonWidth and my >= buttonY and my < buttonY + buttonHeight then
                 if self.successCallback then
                     self.successCallback(self.inputText)
                 end
                 return
             end
         end
 
         return self
     end
 
     return dialog
 end
 
 -- Alert Dialog
 -- Creates an instant alert dialog with just an OK button
 -- Shows immediately without needing openDialog() call
 -- @param message The message to display (default: "Alert")
 -- @param options Optional table with fields:
 --   - app: Application instance (optional, uses sandbox app if not provided)
 --   - title: Dialog title (default: "Alert")
 --   - width: Dialog width (default: 300)
 --   - height: Dialog height (default: 150)
 -- @return Dialog object with close() method
 function Dialog.alert(message, options)
     -- Handle if called with just options (no message)
     if type(message) == "table" and options == nil then
         options = message
         message = nil
     end
 
     options = options or {}
 
     -- Use sandbox app if not provided
     local app = options.app or app
     if not app then
         error("Dialog.alert requires app instance (provide options.app or use from sandboxed context)")
     end
     message = message or "Alert"
     local title = options.title or "Alert"
     local width = options.width or 300
     local height = options.height or 150
 
     local dialog = {
         app = app,
         message = message,
         window = nil
     }
 
     -- Close dialog
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
         end
     end
 
     -- Create and show window immediately
     local screenWidth = 1024
     local screenHeight = 768
     local x = math.floor((screenWidth - width) / 2)
     local y = math.floor((screenHeight - height) / 2)
 
     dialog.window = app:newWindow(x, y, width, height)
     dialog.window.title = title
 
     -- Draw callback
     dialog.window.onDraw = function(gfx)
         -- Background
         gfx:fillRect(0, 0, width, height, 0x2C2C2C)
 
         -- Message area
         local messageY = 30
         local messageHeight = height - 80
 
         -- Word wrap the message
         local maxChars = math.floor((width - 20) / 6)  -- Approximate chars per line
         local lines = {}
         local currentLine = ""
 
         for word in dialog.message:gmatch("%S+") do
             if #currentLine + #word + 1 > maxChars then
                 if #currentLine > 0 then
                     table.insert(lines, currentLine)
                     currentLine = word
                 else
                     -- Word is too long, just add it
                     table.insert(lines, word)
                 end
             else
                 if #currentLine > 0 then
                     currentLine = currentLine .. " " .. word
                 else
                     currentLine = word
                 end
             end
         end
 
         if #currentLine > 0 then
             table.insert(lines, currentLine)
         end
 
         -- Draw message lines
         local lineHeight = 15
         local startY = messageY + math.floor((messageHeight - (#lines * lineHeight)) / 2)
 
         for i, line in ipairs(lines) do
             local textX = math.floor((width - (#line * 6)) / 2)  -- Center text
             gfx:drawText(textX, startY + (i - 1) * lineHeight, line, 0xFFFFFF)
         end
 
         -- OK button area
         local buttonY = height - 40
         local buttonWidth = 80
         local buttonHeight = 25
 
         -- Center the OK button
         local okX = math.floor((width - buttonWidth) / 2)
         gfx:fillRect(okX, buttonY, buttonWidth, buttonHeight, 0x0066CC)
         gfx:drawRect(okX, buttonY, buttonWidth, buttonHeight, 0x0088EE)
         gfx:drawText(okX + 30, buttonY + 7, "OK", 0xFFFFFF)
     end
 
     -- Click handler
     dialog.window.onClick = function(mx, my)
         local buttonY = height - 40
         local buttonWidth = 80
         local buttonHeight = 25
         local okX = math.floor((width - buttonWidth) / 2)
 
         -- Check if click is on OK button
         if mx >= okX and mx < okX + buttonWidth and my >= buttonY and my < buttonY + buttonHeight then
             dialog:close()
             return
         end
     end
 
     return dialog
 end
 
 -- Password Prompt Dialog
 -- Creates a password input dialog that masks the input with asterisks
 -- @param message The message/question to display (default: "Enter password:")
 -- @param options Optional table with fields:
 --   - app: Application instance (optional, uses sandbox app if not provided)
 --   - title: Dialog title (default: "Password")
 --   - width: Dialog width (default: 350)
 --   - height: Dialog height (default: 180)
 -- @return Dialog object with methods:
 --   - openDialog(callback): Show dialog and set callback for result (callback receives password or nil)
 --   - onSuccess(callback): Set callback for when password is submitted
 --   - onCancel(callback): Set callback for when dialog is cancelled
 --   - show(): Show the dialog
 --   - close(): Close the dialog
 function Dialog.promptPassword(message, options)
     -- Handle if called with just options (no message)
     if type(message) == "table" and options == nil then
         options = message
         message = nil
     end
 
     options = options or {}
 
     -- Use sandbox app if not provided
     local app_instance = options.app or app
     if not app_instance then
         error("Dialog.promptPassword requires app instance (provide options.app or use from sandboxed context)")
     end
 
     message = message or "Enter password:"
     local title = options.title or "Password"
     local width = options.width or 350
     local height = options.height or 180
 
     local dialog = {
         app = app_instance,
         message = message,
         inputText = "",
         window = nil,
         successCallback = nil,
         cancelCallback = nil,
         inputActive = false,
         _isHidden = true
     }
 
     -- Open dialog with callback (new pattern)
     function dialog:openDialog(callback)
         if type(callback) ~= "function" then
             error("openDialog requires a function")
         end
 
         -- Set callbacks to invoke the single callback with result, then close
         self.successCallback = function(password)
             callback(password)
             self:close()
         end
         self.cancelCallback = function()
             callback(nil)
             self:close()
         end
 
         -- Create and show window
         self:_createWindow()
         return self
     end
 
     -- Set success callback (old pattern)
     function dialog:onSuccess(callback)
         if type(callback) ~= "function" then
             error("onSuccess requires a function")
         end
         self.successCallback = callback
         return self
     end
 
     -- Set cancel callback (old pattern)
     function dialog:onCancel(callback)
         if type(callback) ~= "function" then
             error("onCancel requires a function")
         end
         self.cancelCallback = callback
         return self
     end
 
     -- Close dialog
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
             self._isHidden = true
         end
     end
 
     -- Show dialog (old pattern)
     function dialog:show()
         if not self._isHidden then
             return self -- Already showing
         end
         self:_createWindow()
         return self
     end
 
     -- Internal: Create window
     function dialog:_createWindow()
         if self.window then
             return -- Already created
         end
 
         self._isHidden = false
 
         -- Create dialog window centered on screen
         local screenWidth = 1024
         local screenHeight = 768
         local x = math.floor((screenWidth - width) / 2)
         local y = math.floor((screenHeight - height) / 2)
 
         self.window = self.app:newWindow(x, y, width, height)
         self.window.title = title
         self.inputActive = true  -- Activate input by default
 
         -- Draw callback
         self.window.onDraw = function(gfx)
             -- Background
             gfx:fillRect(0, 0, width, height, 0x2C2C2C)
 
             -- Message area
             local messageY = 20
             gfx:drawText(10, messageY, self.message, 0xCCCCCC)
 
             -- Input box
             local inputY = messageY + 30
             local inputWidth = width - 20
             local inputHeight = 25
 
             local inputBgColor = self.inputActive and 0x4C4C4C or 0x383838
             gfx:fillRect(10, inputY, inputWidth, inputHeight, inputBgColor)
             gfx:drawRect(10, inputY, inputWidth, inputHeight, 0x666666)
 
             -- Display asterisks instead of actual password
             local maskedText = string.rep("*", #self.inputText)
             if #maskedText > 50 then
                 maskedText = maskedText:sub(-50)
             end
             gfx:drawText(15, inputY + 7, maskedText, 0xFFFFFF)
 
             -- Cursor if active
             if self.inputActive then
                 local cursorX = 15 + (#maskedText * 6)  -- Approximate char width
                 gfx:fillRect(cursorX, inputY + 5, 2, 15, 0xFFFFFF)
             end
 
             -- Buttons area
             local buttonY = height - 40
             local buttonWidth = 80
             local buttonHeight = 25
             local buttonSpacing = 20
 
             -- Calculate button positions (centered)
             local totalWidth = buttonWidth * 2 + buttonSpacing
             local startX = math.floor((width - totalWidth) / 2)
 
             -- Cancel button (left)
             local cancelX = startX
             gfx:fillRect(cancelX, buttonY, buttonWidth, buttonHeight, 0x555555)
             gfx:drawRect(cancelX, buttonY, buttonWidth, buttonHeight, 0x777777)
             gfx:drawText(cancelX + 18, buttonY + 7, "Cancel", 0xFFFFFF)
 
             -- OK button (right)
             local okX = startX + buttonWidth + buttonSpacing
             gfx:fillRect(okX, buttonY, buttonWidth, buttonHeight, 0x0066CC)
             gfx:drawRect(okX, buttonY, buttonWidth, buttonHeight, 0x0088EE)
             gfx:drawText(okX + 30, buttonY + 7, "OK", 0xFFFFFF)
         end
 
         -- Input handler for password typing
         self.window.onInput = function(key, scancode)
             if not self.inputActive then
                 return
             end
 
             if key == "\b" then
                 -- Backspace
                 if #self.inputText > 0 then
                     self.inputText = self.inputText:sub(1, -2)
                     self.window:markDirty()
                 end
             elseif key == "\n" then
                 -- Enter key - submit
                 if self.successCallback then
                     self.successCallback(self.inputText)
                 end
             elseif key == "\t" then
                 -- Tab - ignore
             elseif #key == 1 then
                 -- Regular character
                 self.inputText = self.inputText .. key
                 self.window:markDirty()
             end
         end
 
         -- Click handler
         self.window.onClick = function(mx, my)
             local messageY = 20
             local inputY = messageY + 30
             local inputWidth = width - 20
             local inputHeight = 25
 
             -- Check if click is on input box
             if mx >= 10 and mx < 10 + inputWidth and my >= inputY and my < inputY + inputHeight then
                 self.inputActive = true
                 self.window:markDirty()
 
                 -- Focus window for input
                 if sys and sys.setActiveWindow then
                     sys.setActiveWindow(self.window)
                 end
                 return
             end
 
             -- Check if click is on buttons
             local buttonY = height - 40
             local buttonWidth = 80
             local buttonHeight = 25
             local buttonSpacing = 20
 
             local totalWidth = buttonWidth * 2 + buttonSpacing
             local startX = math.floor((width - totalWidth) / 2)
 
             -- Cancel button
             local cancelX = startX
             if mx >= cancelX and mx < cancelX + buttonWidth and my >= buttonY and my < buttonY + buttonHeight then
                 if self.cancelCallback then
                     self.cancelCallback()
                 end
                 return
             end
 
             -- OK button
             local okX = startX + buttonWidth + buttonSpacing
             if mx >= okX and mx < okX + buttonWidth and my >= buttonY and my < buttonY + buttonHeight then
                 if self.successCallback then
                     self.successCallback(self.inputText)
                 end
                 return
             end
         end
 
         return self
     end
 
     return dialog
 end
 
 -- HTML Dialog
 -- Creates a dialog window that renders HTML content using the moon browser
 -- The HTML has access to the calling process's environment via window.env
 -- @param html The HTML string to render
 -- @param options Optional table with fields:
 --   - app: Application instance (required)
 --   - title: Dialog title (default: "HTML Dialog")
 --   - width: Dialog width (default: 400)
 --   - height: Dialog height (default: 200)
 --   - env: Environment table to expose to HTML scripts (default: calling sandbox)
 --   - onClose: Callback when dialog is closed
 -- @return Dialog object with close() method
 function Dialog.html(html, options)
     if not html or type(html) ~= "string" then
         error("Dialog.html requires an HTML string")
     end
 
     options = options or {}
 
     local app_instance = options.app or app
     if not app_instance then
         error("Dialog.html requires app instance (provide options.app or use from sandboxed context)")
     end
 
     local title = options.title or "HTML Dialog"
     local width = options.width or 400
     local height = options.height or 200
     local env = options.env or {}
     local onCloseCallback = options.onClose
 
     local dialog = {
         app = app_instance,
         html = html,
         window = nil,
         dom = nil,
         renderer = nil,
         scrollY = 0,
         env = env
     }
 
     -- Close dialog
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
             if onCloseCallback then
                 onCloseCallback()
             end
         end
     end
 
     -- Load moonbrowser modules
     local function loadModule(path)
         local code = nil
         -- Try .luac first
         if _G.CRamdiskExists and _G.CRamdiskExists(path .. "c") then
             local handle = _G.CRamdiskOpen(path .. "c", "r")
             if handle then
                 code = _G.CRamdiskRead(handle)
                 _G.CRamdiskClose(handle)
             end
         end
         -- Fall back to .lua
         if not code and _G.CRamdiskExists and _G.CRamdiskExists(path) then
             local handle = _G.CRamdiskOpen(path, "r")
             if handle then
                 code = _G.CRamdiskRead(handle)
                 _G.CRamdiskClose(handle)
             end
         end
         return code
     end
 
     -- Load DOM module
     local domCode = loadModule("/apps/com.luajitos.moonbrowser/src/dom.lua")
     if not domCode then
         error("Dialog.html: Could not load DOM module")
     end
 
     local domEnv = setmetatable({}, { __index = _G, __metatable = false })
     local domFunc, domErr = loadstring(domCode, "dom")
     if not domFunc then
         error("Dialog.html: Failed to compile DOM: " .. tostring(domErr))
     end
     setfenv(domFunc, domEnv)
     local domOk, domModule = pcall(domFunc)
     if not domOk then
         error("Dialog.html: Failed to execute DOM: " .. tostring(domModule))
     end
 
     -- Load parser module
     local parserCode = loadModule("/apps/com.luajitos.moonbrowser/src/parser.lua")
     if not parserCode then
         error("Dialog.html: Could not load parser module")
     end
 
     local parserEnv = setmetatable({
         require = function(name)
             if name == "dom" then return domModule end
             return nil
         end
     }, { __index = _G, __metatable = false })
     local parserFunc, parserErr = loadstring(parserCode, "parser")
     if not parserFunc then
         error("Dialog.html: Failed to compile parser: " .. tostring(parserErr))
     end
     setfenv(parserFunc, parserEnv)
     local parserOk, parserModule = pcall(parserFunc)
     if not parserOk then
         error("Dialog.html: Failed to execute parser: " .. tostring(parserModule))
     end
 
     -- Load renderer module
     local renderCode = loadModule("/apps/com.luajitos.moonbrowser/src/render.lua")
     if not renderCode then
         error("Dialog.html: Could not load renderer module")
     end
 
     local renderEnv = setmetatable({}, { __index = _G, __metatable = false })
     local renderFunc, renderErr = loadstring(renderCode, "render")
     if not renderFunc then
         error("Dialog.html: Failed to compile renderer: " .. tostring(renderErr))
     end
     setfenv(renderFunc, renderEnv)
     local renderOk, rendererModule = pcall(renderFunc)
     if not renderOk then
         error("Dialog.html: Failed to execute renderer: " .. tostring(rendererModule))
     end
 
     -- Parse HTML
     local parseOk, dom = pcall(function()
         return parserModule.parse(html)
     end)
     if not parseOk or not dom then
         error("Dialog.html: Failed to parse HTML: " .. tostring(dom))
     end
     dialog.dom = dom
 
     -- Create renderer instance
     local renderer = rendererModule.new(width, height)
     dialog.renderer = renderer
 
     -- Create window centered on screen
     local screenWidth = 1024
     local screenHeight = 768
     local x = math.floor((screenWidth - width) / 2)
     local y = math.floor((screenHeight - height) / 2)
 
     dialog.window = app_instance:newWindow(x, y, width, height)
     dialog.window.title = title
 
     -- Create script execution environment with access to caller's env
     local scriptEnv = setmetatable({
         -- Standard globals
         print = print,
         tostring = tostring,
         tonumber = tonumber,
         type = type,
         pairs = pairs,
         ipairs = ipairs,
         string = string,
         table = table,
         math = math,
 
         -- Window object for HTML scripts
         window = {
             env = env,  -- Expose caller's environment
             close = function() dialog:close() end,
             alert = function(msg)
                 if Dialog.alert then
                     Dialog.alert(tostring(msg), { app = app_instance })
                 end
             end,
             width = width,
             height = height
         },
 
         -- Document object
         document = {
             title = title,
             close = function() dialog:close() end
         }
     }, { __index = _G, __metatable = false })  -- Prevent metatable access
 
     -- Draw callback
     dialog.window.onDraw = function(gfx)
         -- Clear background
         gfx:fillRect(0, 0, width, height, 0xFFFFFF)
 
         -- Render HTML
         if renderer and dom then
             local renderOk2, renderErr2 = pcall(function()
                 renderer:render(dom, gfx, 0, -dialog.scrollY)
             end)
             if not renderOk2 and osprint then
                 osprint("Dialog.html render error: " .. tostring(renderErr2) .. "\n")
             end
         end
     end
 
     -- Click handler
     dialog.window.onClick = function(mx, my)
         if renderer and dom then
             -- Check for clickable elements
             local clickY = my + dialog.scrollY
             local element = renderer:getElementAt(mx, clickY)
 
             if element then
                 -- Handle onclick attribute
                 if element.attributes and element.attributes.onclick then
                     local onclick = element.attributes.onclick
                     local clickFunc, clickErr = loadstring(onclick, "onclick")
                     if clickFunc then
                         setfenv(clickFunc, scriptEnv)
                         local ok, err = pcall(clickFunc)
                         if not ok and osprint then
                             osprint("Dialog.html onclick error: " .. tostring(err) .. "\n")
                         end
                     end
                 end
 
                 -- Handle link clicks
                 if element.tag == "a" and element.attributes and element.attributes.href then
                     local href = element.attributes.href
                     if href:sub(1, 11) == "javascript:" then
                         local code = href:sub(12)
                         local jsFunc, jsErr = loadstring(code, "href")
                         if jsFunc then
                             setfenv(jsFunc, scriptEnv)
                             pcall(jsFunc)
                         end
                     end
                 end
 
                 dialog.window:markDirty()
             end
         end
     end
 
     -- Scroll handler
     dialog.window.onScroll = function(delta)
         local contentHeight = renderer and renderer:getContentHeight() or height
         local maxScroll = math.max(0, contentHeight - height)
         dialog.scrollY = math.max(0, math.min(maxScroll, dialog.scrollY - delta * 20))
         dialog.window:markDirty()
     end
 
     return dialog
 end
 
 -- Custom Dialog
 -- Creates a dialog with dynamic content based on arguments
 -- Usage: Dialog.customDialog("Label", "STRING", "\n", "Age:", "NUMBER", "\n", "Agree?", "BOOLEAN", "\n", "BUTTON=Cancel", "BUTTON=Ok", callback)
 -- @param ... Variable arguments: strings are labels, "STRING"/"NUMBER"/"BOOLEAN" are input types,
 --            "\n" is a line break, "BUTTON=Label" creates a button
 -- @param callback The last argument must be a callback function that receives all input values followed by button label
 -- @param options Optional table with app, title, width (can be passed as second-to-last arg before callback)
 function Dialog.customDialog(...)
     local args = {...}
     local callback = nil
     local options = {}
 
     -- Last arg must be callback
     if type(args[#args]) == "function" then
         callback = table.remove(args)
     else
         error("Dialog.customDialog: last argument must be a callback function")
     end
 
     -- Check if second-to-last is options table
     if type(args[#args]) == "table" and args[#args].app then
         options = table.remove(args)
     end
 
     local app_instance = options.app or app
     if not app_instance then
         error("Dialog.customDialog requires app instance (provide options.app or use from sandboxed context)")
     end
 
     local title = options.title or "Dialog"
 
     -- Parse arguments to build UI elements
     local elements = {}  -- {type, label, value, x, y, w, h}
     local inputs = {}    -- Track input elements for collecting values
     local buttons = {}   -- Track button elements
 
     local cursorX = 10
     local cursorY = 20
     local lineHeight = 30
     local inputHeight = 22
     local checkboxSize = 18
     local buttonHeight = 25
     local buttonWidth = 80
     local padding = 10
 
     local maxWidth = 300
     local maxY = cursorY
 
     for i, arg in ipairs(args) do
         if arg == "\n" then
             -- Line break
             cursorX = 10
             cursorY = cursorY + lineHeight
         elseif arg == "STRING" then
             -- String input field
             local inputWidth = 150
             local input = {
                 type = "string",
                 x = cursorX,
                 y = cursorY,
                 w = inputWidth,
                 h = inputHeight,
                 value = "",
                 active = false
             }
             table.insert(elements, input)
             table.insert(inputs, input)
             cursorX = cursorX + inputWidth + padding
             if cursorX > maxWidth then maxWidth = cursorX end
         elseif arg == "NUMBER" then
             -- Number input field
             local inputWidth = 80
             local input = {
                 type = "number",
                 x = cursorX,
                 y = cursorY,
                 w = inputWidth,
                 h = inputHeight,
                 value = "",
                 active = false
             }
             table.insert(elements, input)
             table.insert(inputs, input)
             cursorX = cursorX + inputWidth + padding
             if cursorX > maxWidth then maxWidth = cursorX end
         elseif arg == "PASSWORD" then
             -- Password input field (masked with asterisks)
             local inputWidth = 150
             local input = {
                 type = "password",
                 x = cursorX,
                 y = cursorY,
                 w = inputWidth,
                 h = inputHeight,
                 value = "",
                 active = false
             }
             table.insert(elements, input)
             table.insert(inputs, input)
             cursorX = cursorX + inputWidth + padding
             if cursorX > maxWidth then maxWidth = cursorX end
         elseif arg == "BOOLEAN" then
             -- Checkbox
             local input = {
                 type = "boolean",
                 x = cursorX,
                 y = cursorY + 2,
                 w = checkboxSize,
                 h = checkboxSize,
                 value = false
             }
             table.insert(elements, input)
             table.insert(inputs, input)
             cursorX = cursorX + checkboxSize + padding
             if cursorX > maxWidth then maxWidth = cursorX end
         elseif type(arg) == "string" and arg:sub(1, 7) == "BUTTON=" then
             -- Button
             local label = arg:sub(8)
             local btn = {
                 type = "button",
                 label = label,
                 x = 0,  -- Will be positioned later
                 y = 0,
                 w = buttonWidth,
                 h = buttonHeight
             }
             table.insert(buttons, btn)
         elseif type(arg) == "string" then
             -- Text label
             local textWidth = #arg * 7 + 5  -- Approximate width
             local label = {
                 type = "label",
                 text = arg,
                 x = cursorX,
                 y = cursorY + 3,
                 w = textWidth,
                 h = lineHeight
             }
             table.insert(elements, label)
             cursorX = cursorX + textWidth + 5
             if cursorX > maxWidth then maxWidth = cursorX end
         end
 
         if cursorY + lineHeight > maxY then
             maxY = cursorY + lineHeight
         end
     end
 
     -- Position buttons at the bottom
     cursorY = maxY + 10
     local totalButtonWidth = #buttons * buttonWidth + (#buttons - 1) * padding
     local buttonStartX = math.floor((maxWidth - totalButtonWidth) / 2)
     if buttonStartX < 10 then buttonStartX = 10 end
 
     for i, btn in ipairs(buttons) do
         btn.x = buttonStartX + (i - 1) * (buttonWidth + padding)
         btn.y = cursorY
         table.insert(elements, btn)
     end
 
     -- Calculate dialog size
     local width = options.width or math.max(maxWidth + 20, 200)
     local height = cursorY + buttonHeight + 20
 
     -- Create dialog object
     local dialog = {
         app = app_instance,
         window = nil,
         elements = elements,
         inputs = inputs,
         buttons = buttons,
         activeInput = nil,
         callback = callback
     }
 
     -- Collect input values and call callback
     -- If callback returns true, keep dialog open
     -- If callback returns a number, clear that input index and focus it
     function dialog:submit(buttonLabel)
         local values = {}
         for _, input in ipairs(self.inputs) do
             if input.type == "string" or input.type == "password" then
                 table.insert(values, input.value)
             elseif input.type == "number" then
                 table.insert(values, tonumber(input.value) or 0)
             elseif input.type == "boolean" then
                 table.insert(values, input.value)
             end
         end
         table.insert(values, buttonLabel)
 
         local result = nil
         if self.callback then
             result = self.callback(unpack(values))
         end
 
         if result == true then
             -- Keep dialog open, do nothing
             return
         elseif type(result) == "number" then
             -- Clear the input at that index and focus it
             local inputIndex = result
             if inputIndex >= 1 and inputIndex <= #self.inputs then
                 local input = self.inputs[inputIndex]
                 -- Clear value
                 if input.type == "boolean" then
                     input.value = false
                 else
                     input.value = ""
                 end
                 -- Deactivate current input
                 if self.activeInput then
                     self.activeInput.active = false
                 end
                 -- Focus the specified input
                 input.active = true
                 self.activeInput = input
                 if self.window then
                     self.window:markDirty()
                 end
             end
             return
         end
 
         -- Default: close the dialog
         if self.window then
             self.window:close()
         end
     end
 
     -- Close method
     function dialog:close()
         if self.window then
             self.window:close()
             self.window = nil
         end
     end
 
     -- Show method
     function dialog:show()
         if self.window then return self end
 
         -- Create window
         self.window = self.app:newWindow(title, width, height)
 
         -- Draw callback
         self.window.onDraw = function(gfx)
             -- Background
             gfx:fillRect(0, 0, width, height, 0xF0F0F0)
 
             -- Draw all elements
             for _, elem in ipairs(self.elements) do
                 if elem.type == "label" then
                     gfx:drawText(elem.x, elem.y, elem.text, 0x000000)
 
                 elseif elem.type == "string" or elem.type == "number" or elem.type == "password" then
                     -- Input field background
                     local bgColor = elem.active and 0xFFFFFF or 0xFAFAFA
                     local borderColor = elem.active and 0x0066CC or 0x888888
                     gfx:fillRect(elem.x, elem.y, elem.w, elem.h, bgColor)
                     gfx:drawRect(elem.x, elem.y, elem.w, elem.h, borderColor)
                     -- Text (show asterisks for password)
                     local displayText
                     if elem.type == "password" then
                         displayText = string.rep("*", #elem.value)
                     else
                         displayText = elem.value
                     end
                     if elem.active then
                         displayText = displayText .. "|"
                     end
                     gfx:drawText(elem.x + 3, elem.y + 4, displayText, 0x000000)
 
                 elseif elem.type == "boolean" then
                     -- Checkbox
                     gfx:fillRect(elem.x, elem.y, elem.w, elem.h, 0xFFFFFF)
                     gfx:drawRect(elem.x, elem.y, elem.w, elem.h, 0x666666)
                     if elem.value then
                         -- Draw checkmark
                         local cx, cy = elem.x + elem.w/2, elem.y + elem.h/2
                         gfx:fillRect(elem.x + 4, elem.y + 4, elem.w - 8, elem.h - 8, 0x0066CC)
                     end
 
                 elseif elem.type == "button" then
                     -- Button
                     gfx:fillRect(elem.x, elem.y, elem.w, elem.h, 0xDDDDDD)
                     gfx:drawRect(elem.x, elem.y, elem.w, elem.h, 0x888888)
                     local textX = elem.x + math.floor((elem.w - #elem.label * 7) / 2)
                     local textY = elem.y + 6
                     gfx:drawText(textX, textY, elem.label, 0x000000)
                 end
             end
         end
 
         -- Key handler
         self.window.onKey = function(key)
             if self.activeInput then
                 local input = self.activeInput
                 if key == "\b" then
                     -- Backspace
                     if #input.value > 0 then
                         input.value = input.value:sub(1, -2)
                         self.window:markDirty()
                     end
                 elseif key == "\n" then
                     -- Enter - deactivate input
                     input.active = false
                     self.activeInput = nil
                     self.window:markDirty()
                 elseif key == "\t" then
                     -- Tab - move to next input
                     input.active = false
                     local found = false
                     for i, inp in ipairs(self.inputs) do
                         if found and (inp.type == "string" or inp.type == "number" or inp.type == "password") then
                             inp.active = true
                             self.activeInput = inp
                             self.window:markDirty()
                             break
                         end
                         if inp == input then
                             found = true
                         end
                     end
                     if self.activeInput == input then
                         -- Wrap around
                         for i, inp in ipairs(self.inputs) do
                             if inp.type == "string" or inp.type == "number" or inp.type == "password" then
                                 inp.active = true
                                 self.activeInput = inp
                                 self.window:markDirty()
                                 break
                             end
                         end
                     end
                 elseif #key == 1 then
                     -- Regular character
                     if input.type == "number" then
                         -- Only allow digits, minus, dot
                         if key:match("[%d%.%-]") then
                             input.value = input.value .. key
                             self.window:markDirty()
                         end
                     else
                         input.value = input.value .. key
                         self.window:markDirty()
                     end
                 end
             end
         end
 
         -- Click handler
         self.window.onClick = function(mx, my)
             -- Deactivate current input
             if self.activeInput then
                 self.activeInput.active = false
                 self.activeInput = nil
             end
 
             -- Check all elements
             for _, elem in ipairs(self.elements) do
                 if mx >= elem.x and mx < elem.x + elem.w and
                    my >= elem.y and my < elem.y + elem.h then
 
                     if elem.type == "string" or elem.type == "number" or elem.type == "password" then
                         -- Activate input
                         elem.active = true
                         self.activeInput = elem
                         self.window:markDirty()
                         return
 
                     elseif elem.type == "boolean" then
                         -- Toggle checkbox
                         elem.value = not elem.value
                         self.window:markDirty()
                         return
 
                     elseif elem.type == "button" then
                         -- Button clicked - submit with button label
                         self:submit(elem.label)
                         return
                     end
                 end
             end
 
             self.window:markDirty()
         end
 
         return self
     end
 
     -- openDialog method (convenience)
     function dialog:openDialog(cb)
         if cb then
             self.callback = cb
         end
         return self:show()
     end
 
     return dialog
 end
 
 return Dialog