luajitos

Application.lua (32214B)

---

 -- Application.lua - Application instance management with function exports
 -- Manages application lifecycle, process information, and exported functions
 
 local Application = {}
 Application.__index = Application
 Application.__metatable = false  -- Prevent metatable access/modification
 
 -- Track used PIDs to avoid collisions
 if not _G._used_pids then
     _G._used_pids = {}
 end
 
 -- Helper: Generate a random PID that hasn't been used
 local function generatePid()
     local max_attempts = 1000
     for i = 1, max_attempts do
         -- Generate random PID between 1000 and 65535
         local pid = math.random(1000, 65535)
 
         -- Check if this PID is already in use
         if not _G._used_pids[pid] then
             _G._used_pids[pid] = true
             return pid
         end
     end
 
     -- Fallback: if we somehow can't find a free PID after 1000 attempts,
     -- just use a sequential counter
     if not _G._fallback_pid then
         _G._fallback_pid = 1000
     end
 
     while _G._used_pids[_G._fallback_pid] do
         _G._fallback_pid = _G._fallback_pid + 1
     end
 
     local pid = _G._fallback_pid
     _G._used_pids[pid] = true
     _G._fallback_pid = _G._fallback_pid + 1
     return pid
 end
 
 -- Helper: Free a PID when application terminates
 local function freePid(pid)
     if pid and _G._used_pids[pid] then
         _G._used_pids[pid] = nil
     end
 end
 
 -- Helper: Get current timestamp (simplified for bare metal)
 local function getTimestamp()
     -- In a real implementation, this would query a hardware timer
     -- For now, we'll use a simple counter
     if not _G._app_timestamp then
         _G._app_timestamp = 0
     end
     _G._app_timestamp = _G._app_timestamp + 1
     return _G._app_timestamp
 end
 
 -- Helper: Parse parameter string like "arg1=number,arg2=string,..." or "string,number,..."
 local function parseParameters(paramStr)
     if not paramStr or paramStr == "" then
         return {}
     end
 
     local params = {}
     local argIndex = 1
 
     for param in paramStr:gmatch("[^,]+") do
         -- Trim whitespace
         param = param:match("^%s*(.-)%s*$")
 
         -- Parse name=type format
         local name, paramType = param:match("^([%w_]+)=([%w_]+)$")
         if name and paramType then
             table.insert(params, {
                 name = name,
                 type = paramType
             })
         else
             -- No equals sign - treat whole string as type, generate arg name
             table.insert(params, {
                 name = "arg" .. argIndex,
                 type = param
             })
             argIndex = argIndex + 1
         end
     end
 
     return params
 end
 
 -- Helper: Validate export definition
 local function validateExport(exportDef)
     -- Required fields
     if type(exportDef) ~= "table" then
         return false, "Export definition must be a table"
     end
 
     if type(exportDef.name) ~= "string" or exportDef.name == "" then
         return false, "Export must have a non-empty 'name' field"
     end
 
     if type(exportDef.func) ~= "function" then
         return false, "Export must have a 'func' field that is a function"
     end
 
     -- Optional fields validation
     if exportDef.args and type(exportDef.args) ~= "string" then
         return false, "Export 'args' field must be a string"
     end
 
     if exportDef.rets and type(exportDef.rets) ~= "string" then
         return false, "Export 'rets' field must be a string"
     end
 
     if exportDef.description and type(exportDef.description) ~= "string" then
         return false, "Export 'description' field must be a string"
     end
 
     return true
 end
 
 --- Create a new Application instance
 -- @param appPath: Path to the application (e.g., "/apps/com.example.myapp")
 -- @param options: Optional table with configuration
 --   - pid: Override auto-generated process ID
 --   - name: Application name (defaults to last component of appPath)
 -- @return Application instance
 function Application.new(appPath, options)
     options = options or {}
 
     if type(appPath) ~= "string" or appPath == "" then
         error("Application.new requires a valid appPath string")
     end
 
     -- Extract app name from path if not provided
     local appName = options.name
     if not appName then
         appName = appPath:match("([^/]+)$") or "unknown"
     end
 
     local self = setmetatable({}, Application)
 
     -- Process information
     self.pid = options.pid or generatePid()
 
     self.appPath = appPath
     self.appName = appName
     self.startTime = getTimestamp()
 
     -- Export registry
     self.exports = {}
 
     -- Application state
     self.status = "initialized"  -- initialized, running, paused, stopped
 
     -- Output capture
     self.stdout = ""  -- Captured standard output
     self.stderr = ""  -- Captured standard error (for future use)
 
     -- Window management
     self.windows = {}  -- Array of windows created by this app
 
     if osprint then
         osprint("Application created: " .. appName .. " (PID: " .. self.pid .. ", Path: " .. appPath .. ")\n")
     end
 
     return self
 end
 
 --- Export a function from this application
 -- @param exportDef: Table containing export definition
 --   - name: Function name (required)
 --   - func: The function to export (required)
 --   - args: Input parameter specification (optional, e.g., "arg1=number,arg2=string")
 --   - rets: Output type specification (optional, e.g., "number" or "result=table")
 --   - description: Human-readable description (optional)
 -- @return true on success, or (nil, error_message) on failure
 function Application:export(exportDef)
     -- Validate the export definition
     local valid, err = validateExport(exportDef)
     if not valid then
         if osprint then
             osprint("ERROR: Invalid export definition: " .. err .. "\n")
         end
         return nil, err
     end
 
     -- Check for duplicate exports
     if self.exports[exportDef.name] then
         local err = "Function '" .. exportDef.name .. "' is already exported"
         if osprint then
             osprint("WARNING: " .. err .. "\n")
         end
         return nil, err
     end
 
     -- Parse input and output specifications
     local inputParams = parseParameters(exportDef.args or "")
     local outputParams = parseParameters(exportDef.rets or "")
 
     -- Store the export with metadata
     self.exports[exportDef.name] = {
         name = exportDef.name,
         func = exportDef.func,
         input = inputParams,
         output = outputParams,
         description = exportDef.description or "",
         exportedAt = getTimestamp()
     }
 
     if osprint then
         osprint("Exported function: " .. exportDef.name .. " from " .. self.appName .. "\n")
     end
 
     return true
 end
 
 --- Call an exported function
 -- @param functionName: Name of the exported function
 -- @param ...: Arguments to pass to the function
 -- @return Function result, or (nil, error_message) on failure
 function Application:call(functionName, ...)
     local exportDef = self.exports[functionName]
     if not exportDef then
         return nil, "Function '" .. functionName .. "' is not exported"
     end
 
     -- Call the function with provided arguments
     local success, result = pcall(exportDef.func, ...)
     if not success then
         return nil, "Function call failed: " .. tostring(result)
     end
 
     return result
 end
 
 --- Get information about an exported function
 -- @param functionName: Name of the exported function
 -- @return Export metadata table, or nil if not found
 function Application:getExport(functionName)
     return self.exports[functionName]
 end
 
 --- List all exported functions
 -- @return Array of export names
 function Application:listExports()
     local names = {}
     for name, _ in pairs(self.exports) do
         table.insert(names, name)
     end
     table.sort(names)
     return names
 end
 
 --- Get application status information
 -- @return Table with application metadata
 function Application:getInfo()
     return {
         pid = self.pid,
         name = self.appName,
         path = self.appPath,
         status = self.status,
         startTime = self.startTime,
         uptime = getTimestamp() - self.startTime,
         exportCount = self:getExportCount()
     }
 end
 
 --- Get count of exported functions
 -- @return Number of exported functions
 function Application:getExportCount()
     local count = 0
     for _ in pairs(self.exports) do
         count = count + 1
     end
     return count
 end
 
 --- Update application status
 -- @param newStatus: New status string (running, paused, stopped, etc.)
 function Application:setStatus(newStatus, reason)
     self.status = newStatus
     self.stopReason = reason
     if osprint then
         local msg = "Application " .. self.appName .. " status changed to: " .. newStatus
         if reason then
             msg = msg .. " (reason: " .. reason .. ")"
         end
         osprint(msg .. "\n")
     end
 end
 
 --- Generate a help message for an exported function
 -- @param functionName: Name of the exported function
 -- @return Help string, or nil if not found
 function Application:getHelp(functionName)
     local exportDef = self.exports[functionName]
     if not exportDef then
         return nil
     end
 
     local help = {}
     table.insert(help, "Function: " .. exportDef.name)
 
     if exportDef.description and exportDef.description ~= "" then
         table.insert(help, "Description: " .. exportDef.description)
     end
 
     if #exportDef.input > 0 then
         local inputs = {}
         for _, param in ipairs(exportDef.input) do
             table.insert(inputs, param.name .. ": " .. param.type)
         end
         table.insert(help, "Input: " .. table.concat(inputs, ", "))
     else
         table.insert(help, "Input: (none)")
     end
 
     if #exportDef.output > 0 then
         local outputs = {}
         for _, param in ipairs(exportDef.output) do
             table.insert(outputs, param.type)
         end
         table.insert(help, "Output: " .. table.concat(outputs, ", "))
     else
         table.insert(help, "Output: (unspecified)")
     end
 
     return table.concat(help, "\n")
 end
 
 --- Print all exported functions with their signatures
 function Application:printExports()
     local exportNames = self:listExports()
 
     if #exportNames == 0 then
         if osprint then
             osprint("No exported functions\n")
         end
         return
     end
 
     if osprint then
         osprint("Exported functions from " .. self.appName .. ":\n")
         osprint(string.rep("=", 50) .. "\n")
 
         for _, name in ipairs(exportNames) do
             local help = self:getHelp(name)
             if help then
                 osprint(help .. "\n")
                 osprint(string.rep("-", 50) .. "\n")
             end
         end
     end
 end
 
 --- Write to stdout (append text to stdout buffer)
 -- @param text: Text to append to stdout
 function Application:writeStdout(text)
     if type(text) ~= "string" then
         text = tostring(text)
     end
     self.stdout = self.stdout .. text
 end
 
 --- Get stdout content
 -- @return Current stdout buffer content
 function Application:getStdout()
     return self.stdout
 end
 
 --- Clear stdout buffer
 function Application:clearStdout()
     self.stdout = ""
 end
 
 --- Terminate the application and free its PID
 function Application:terminate()
     self.status = "terminated"
     freePid(self.pid)
 
     if osprint then
         osprint("Application terminated: " .. self.appName .. " (PID: " .. self.pid .. ")\n")
     end
 end
 
 --- Get process information
 -- @return Table with pid, appName, appPath, startTime, status
 function Application:getProcessInfo()
     return {
         pid = self.pid,
         appName = self.appName,
         appPath = self.appPath,
         startTime = self.startTime,
         status = self.status
     }
 end
 
 --- Create a new window for this application
 -- Supported overloads:
 -- @param x, y, width, height, resizable: Position and size
 -- @param title, x, y, width, height, resizable: Title with position and size
 -- @param title, width, height, resizable: Title with centered position
 -- @param width, height, resizable: Centered position
 -- @return Window instance
 function Application:newWindow(arg1, arg2, arg3, arg4, arg5, arg6)
     local title = nil
     local x, y, width, height, resizable
 
     -- Handle overload: newWindow(title, x, y, width, height, resizable) - title with position
     if type(arg1) == "string" and type(arg2) == "number" and type(arg3) == "number" and type(arg4) == "number" and type(arg5) == "number" then
         title = arg1
         x = arg2
         y = arg3
         width = arg4
         height = arg5
         resizable = arg6
     -- Handle overload: newWindow(title, width, height, resizable) - center on screen with title
     elseif type(arg1) == "string" and type(arg2) == "number" and type(arg3) == "number" then
         title = arg1
         width = arg2
         height = arg3
         resizable = arg4
         -- Center on screen (assume 1024x768 for now, should get from gfx API)
         x = math.floor((1024 - width) / 2)
         y = math.floor((768 - height) / 2)
     -- Handle overload: newWindow(x, y, width, height, resizable) - position and size
     elseif type(arg1) == "number" and type(arg2) == "number" and type(arg3) == "number" and type(arg4) == "number" then
         x = arg1
         y = arg2
         width = arg3
         height = arg4
         resizable = arg5
     -- Handle overload: newWindow(width, height, resizable) - center on screen
     elseif type(arg1) == "number" and type(arg2) == "number" then
         width = arg1
         height = arg2
         resizable = arg3
         -- Center on screen (assume 1024x768 for now, should get from gfx API)
         x = math.floor((1024 - width) / 2)
         y = math.floor((768 - height) / 2)
     end
 
     -- Validate parameters
     if type(x) ~= "number" or type(y) ~= "number" or type(width) ~= "number" or type(height) ~= "number" then
         error("newWindow requires (x, y, width, height), (width, height), or (title, width, height)")
     end
 
     if width <= 0 or height <= 0 then
         error("Window width and height must be positive")
     end
 
     -- Default resizable to false if not provided
     if resizable == nil then
         resizable = false
     end
 
     -- Create window instance
     local window = {
         x = x,
         y = y,
         width = width,
         height = height,
         title = title,  -- Window title (optional)
         resizable = resizable,  -- Whether window can be resized
         visible = true,
         app = self,
         appInstance = self,  -- Reference for icon drawing in title bar
         drawCallback = nil,  -- User-defined draw function
         inputCallback = nil,  -- User-defined input handler
         buffer = nil,  -- Per-window pixel buffer (allocated on first draw)
         dirty = true,  -- Needs redraw
         createdAt = getTimestamp(),  -- Track creation order for Z-ordering
         -- Minimize/maximize state
         minimized = false,
         maximized = false,
         -- Store pre-maximize position/size for restore
         restoreX = nil,
         restoreY = nil,
         restoreWidth = nil,
         restoreHeight = nil,
         -- Text selection support
         selectable = true,  -- Whether text selection is enabled for this window
         selectableText = {},  -- Array of {text, x, y, w, h, color, scale}
         selection = nil  -- {start={index,pos}, finish={index,pos}, content, type}
     }
 
     -- Window cursor API (window.cursor.add, window.cursor.remove, etc.)
     window.cursor = {
         -- Add a cursor drawing function for this window (overrides global when window is active)
         -- @param draw_func function(state, gfx) - Called with cursor state and SafeGfx
         -- @return number Index for removal
         add = function(draw_func)
             if _G._cursor_api and _G._cursor_api.windowAdd then
                 return _G._cursor_api.windowAdd(window, draw_func)
             end
             error("Cursor API not available")
         end,
 
         -- Remove a cursor drawing function from this window's stack
         -- @param index number The index returned by add()
         -- @return boolean True if removed
         remove = function(index)
             if _G._cursor_api and _G._cursor_api.windowRemove then
                 return _G._cursor_api.windowRemove(window, index)
             end
             return false
         end,
 
         -- Pop the top cursor from this window's stack
         -- @return boolean True if popped
         pop = function()
             if _G._cursor_api and _G._cursor_api.windowPop then
                 return _G._cursor_api.windowPop(window)
             end
             return false
         end,
 
         -- Clear all cursors from this window's stack
         clear = function()
             if _G._cursor_api and _G._cursor_api.windowClear then
                 _G._cursor_api.windowClear(window)
             end
         end
     }
 
     -- Window draw method (will be called by LPM drawScreen)
     function window:draw(safeGfx)
         -- Clear selectable text array before each draw
         self.selectableText = {}
         if self.onDraw and self.visible then
             self.onDraw(safeGfx)
         end
     end
 
     -- Window visibility control
     function window:show()
         self.visible = true
         self.dirty = true  -- Mark for redraw when shown
     end
 
     function window:hide()
         self.visible = false
     end
 
     -- Center window on screen
     function window:centerScreen()
         self.x = math.floor((1024 - self.width) / 2)
         self.y = math.floor((768 - self.height) / 2)
         self.dirty = true
     end
 
     -- Close window (with optional cancel via onClose callback)
     function window:close()
         -- Call onClose callback if it exists
         if self.onClose then
             local success, shouldCancel = pcall(self.onClose)
             if success and shouldCancel == true then
                 -- onClose returned true, cancel the close
                 return false
             end
         end
 
         -- Free window buffer to release memory
         if self.buffer and VESAFreeWindowBuffer then
             VESAFreeWindowBuffer(self.buffer)
             self.buffer = nil
         end
 
         -- Hide the window
         self:hide()
 
         -- Fire WindowClosed hook
         if _G.sys and _G.sys.hook and _G.sys.hook.run then
             _G.sys.hook:run("WindowClosed", self)
         end
 
         return true
     end
 
     -- Minimize window
     function window:minimize()
         if self.minimized then return end
         self.minimized = true
         self.visible = false
         self.dirty = true
 
         -- Fire WindowMinimized hook
         if _G.sys and _G.sys.hook and _G.sys.hook.run then
             _G.sys.hook:run("WindowMinimized", self)
         end
     end
 
     -- Restore from minimized state
     function window:restore()
         if not self.minimized then return end
         self.minimized = false
         self.visible = true
         self.dirty = true
 
         -- Bring to front by updating timestamp
         self.createdAt = (_G.getTimestamp and _G.getTimestamp()) or (os.time() * 1000)
 
         -- Fire WindowRestored hook
         if _G.sys and _G.sys.hook and _G.sys.hook.run then
             _G.sys.hook:run("WindowRestored", self)
         end
     end
 
     -- Maximize/restore window
     function window:maximize()
         local TITLE_BAR_HEIGHT = self.TITLE_BAR_HEIGHT or 20
         local BORDER_WIDTH = self.BORDER_WIDTH or 2
         local TASKBAR_HEIGHT = 32  -- Account for taskbar at bottom
 
         -- Get screen dimensions from sys.screens
         local screenW = 1024
         local screenH = 768
         if _G.sys and _G.sys.screens and _G.sys.screens[1] then
             screenW = _G.sys.screens[1].width or screenW
             screenH = _G.sys.screens[1].height or screenH
         end
 
         if self.maximized then
             -- Restore to previous size/position
             if self.restoreX then
                 self.x = self.restoreX
                 self.y = self.restoreY
                 self.width = self.restoreWidth
                 self.height = self.restoreHeight
             end
             self.maximized = false
         else
             -- Save current position/size
             self.restoreX = self.x
             self.restoreY = self.y
             self.restoreWidth = self.width
             self.restoreHeight = self.height
 
             -- Maximize to fill screen (accounting for title bar and taskbar)
             self.x = BORDER_WIDTH
             self.y = BORDER_WIDTH + TITLE_BAR_HEIGHT
             self.width = screenW - (BORDER_WIDTH * 2)
             self.height = screenH - TASKBAR_HEIGHT - TITLE_BAR_HEIGHT - (BORDER_WIDTH * 2)
             self.maximized = true
         end
 
         -- Free old buffer and clear to force recreation with new size
         if self.buffer and VESAFreeWindowBuffer then
             VESAFreeWindowBuffer(self.buffer)
         end
         self.buffer = nil
         self.dirty = true
 
         if _G.osprint then
             _G.osprint(string.format("[MAXIMIZE] Window now %dx%d, buffer cleared, maximized=%s\n",
                 self.width, self.height, tostring(self.maximized)))
         end
 
         -- Call onResize callback if it exists
         if self.onResize then
             local oldWidth = self.restoreWidth or self.width
             local oldHeight = self.restoreHeight or self.height
             if self.maximized then
                 -- We just maximized, old size is restore size
                 pcall(self.onResize, self.width, self.height, self.restoreWidth, self.restoreHeight)
             else
                 -- We just restored, old size was the maximized size (screen size)
                 local screenW = 1024
                 local screenH = 768
                 if _G.sys and _G.sys.screens and _G.sys.screens[1] then
                     screenW = _G.sys.screens[1].width or screenW
                     screenH = _G.sys.screens[1].height or screenH
                 end
                 local maxW = screenW - (BORDER_WIDTH * 2)
                 local maxH = screenH - TASKBAR_HEIGHT - TITLE_BAR_HEIGHT - (BORDER_WIDTH * 2)
                 pcall(self.onResize, self.width, self.height, maxW, maxH)
             end
         end
     end
 
     -- Resize window
     function window:resize(newWidth, newHeight)
         if type(newWidth) ~= "number" or type(newHeight) ~= "number" then
             error("resize requires numeric width and height")
         end
 
         if newWidth <= 0 or newHeight <= 0 then
             error("Window dimensions must be positive")
         end
 
         local oldWidth = self.width
         local oldHeight = self.height
 
         self.width = newWidth
         self.height = newHeight
 
         -- Free old buffer and clear to force recreation with new size
         if self.buffer and VESAFreeWindowBuffer then
             VESAFreeWindowBuffer(self.buffer)
         end
         self.buffer = nil
         self.dirty = true
 
         -- Call onResize callback if it exists
         if self.onResize then
             pcall(self.onResize, newWidth, newHeight, oldWidth, oldHeight)
         end
     end
 
     -- Set window size (alias for resize)
     function window:setSize(newWidth, newHeight)
         self:resize(newWidth, newHeight)
     end
 
     -- Set window position
     function window:setPos(newX, newY)
         if type(newX) ~= "number" or type(newY) ~= "number" then
             error("setPos requires numeric x and y coordinates")
         end
 
         self.x = newX
         self.y = newY
         self.dirty = true
     end
 
     -- Mark window for redraw
     function window:markDirty()
         self.dirty = true
     end
 
     -- Render - draw window frame and flush buffer to screen
     -- Call this after drawing to gfx to update the display
     function window:render()
         self.dirty = true
     end
 
     -- Internal draw operations buffer for imperative drawing
     window._draw_ops = {}
 
     -- Create gfx object for imperative drawing (draw anytime, call render() to display)
     window.gfx = {
         _window = window,
 
         -- Clear the drawing buffer (call before redrawing)
         clear = function(gfxSelf)
             gfxSelf._window._draw_ops = {}
         end,
 
         fillRect = function(gfxSelf, x, y, w, h, color)
             if type(gfxSelf) == "number" then
                 color = h
                 h = w
                 w = y
                 y = x
                 x = gfxSelf
                 gfxSelf = window.gfx
             end
             local r = bit.band(bit.rshift(color, 16), 0xFF)
             local g = bit.band(bit.rshift(color, 8), 0xFF)
             local b = bit.band(color, 0xFF)
             table.insert(gfxSelf._window._draw_ops, {2, x, y, w, h, r, g, b})
         end,
 
         drawRect = function(gfxSelf, x, y, w, h, color)
             if type(gfxSelf) == "number" then
                 color = h
                 h = w
                 w = y
                 y = x
                 x = gfxSelf
                 gfxSelf = window.gfx
             end
             local r = bit.band(bit.rshift(color, 16), 0xFF)
             local g = bit.band(bit.rshift(color, 8), 0xFF)
             local b = bit.band(color, 0xFF)
             table.insert(gfxSelf._window._draw_ops, {2, x, y, w, 1, r, g, b})
             table.insert(gfxSelf._window._draw_ops, {2, x, y + h - 1, w, 1, r, g, b})
             table.insert(gfxSelf._window._draw_ops, {2, x, y, 1, h, r, g, b})
             table.insert(gfxSelf._window._draw_ops, {2, x + w - 1, y, 1, h, r, g, b})
         end,
 
         drawText = function(gfxSelf, x, y, text, color, scale)
             if type(gfxSelf) == "string" then
                 scale = color
                 color = text
                 text = y
                 y = x
                 x = gfxSelf
                 gfxSelf = window.gfx
             end
             local r = bit.band(bit.rshift(color, 16), 0xFF)
             local g = bit.band(bit.rshift(color, 8), 0xFF)
             local b = bit.band(color, 0xFF)
             scale = scale or 1
             table.insert(gfxSelf._window._draw_ops, {10, x, y, text, r, g, b, scale})
 
             -- Record text for selection support (6 pixels per char at scale 1, 12 pixels height)
             local charWidth = 8 * scale
             local charHeight = 12 * scale
             local textWidth = #text * charWidth
             table.insert(gfxSelf._window.selectableText, {
                 text = text,
                 x = x,
                 y = y,
                 w = textWidth,
                 h = charHeight,
                 color = color,
                 scale = scale
             })
         end,
 
         drawUText = function(gfxSelf, x, y, text, color, scale)
             -- Draw unselectable text (not recorded for selection)
             if type(gfxSelf) == "number" then
                 scale = color
                 color = text
                 text = y
                 y = x
                 x = gfxSelf
                 gfxSelf = window.gfx
             end
             local r = bit.band(bit.rshift(color, 16), 0xFF)
             local g = bit.band(bit.rshift(color, 8), 0xFF)
             local b = bit.band(color, 0xFF)
             scale = scale or 1
             table.insert(gfxSelf._window._draw_ops, {10, x, y, text, r, g, b, scale})
             -- Note: not recording in selectableText
         end,
 
         drawImage = function(gfxSelf, image, x, y, w, h)
             if type(gfxSelf) == "userdata" then
                 h = w
                 w = y
                 y = x
                 x = image
                 image = gfxSelf
                 gfxSelf = window.gfx
             end
             table.insert(gfxSelf._window._draw_ops, {11, image, x, y, w, h, 1})
         end,
 
         drawPixel = function(gfxSelf, x, y, color)
             if type(gfxSelf) == "number" then
                 color = y
                 y = x
                 x = gfxSelf
                 gfxSelf = window.gfx
             end
             local r = bit.band(bit.rshift(color, 16), 0xFF)
             local g = bit.band(bit.rshift(color, 8), 0xFF)
             local b = bit.band(color, 0xFF)
             table.insert(gfxSelf._window._draw_ops, {0, x, y, r, g, b})
         end,
 
         -- Draw a raw BGRA buffer (from Image object) directly
         -- luaImage: Image object with .buffer and :getSize()
         -- x, y: destination position
         -- srcX, srcY, srcW, srcH: optional source region (defaults to full image)
         drawBuffer = function(gfxSelf, luaImage, x, y, srcX, srcY, srcW, srcH)
             if type(gfxSelf) ~= "table" or not gfxSelf._window then
                 -- Called without self, shift args
                 srcH = srcW
                 srcW = srcY
                 srcY = srcX
                 srcX = y
                 y = x
                 x = luaImage
                 luaImage = gfxSelf
                 gfxSelf = window.gfx
             end
             if not luaImage or not luaImage.buffer then return end
             local bufW, bufH = luaImage:getSize()
             -- {12, buffer, x, y, bufWidth, bufHeight, srcX, srcY, srcW, srcH}
             table.insert(gfxSelf._window._draw_ops, {12, luaImage.buffer, x, y, bufW, bufH, srcX or 0, srcY or 0, srcW or 0, srcH or 0})
         end,
 
         getWidth = function(gfxSelf)
             if type(gfxSelf) == "table" and gfxSelf._window then
                 return gfxSelf._window.width
             end
             return window.width
         end,
 
         getHeight = function(gfxSelf)
             if type(gfxSelf) == "table" and gfxSelf._window then
                 return gfxSelf._window.height
             end
             return window.height
         end
     }
 
     -- Getters for window dimensions
     function window:getWidth()
         return self.width
     end
 
     function window:getHeight()
         return self.height
     end
 
     function window:getX()
         return self.x
     end
 
     function window:getY()
         return self.y
     end
 
     -- Add to app's window list
     table.insert(self.windows, window)
 
     -- Set as active window in LPM
     -- LPM removed - no longer needed
 
     if osprint then
         osprint("Window created for " .. self.appName .. " at (" .. x .. "," .. y .. ") size " .. width .. "x" .. height .. "\n")
     end
 
     -- Call onOpen callback after window is fully initialized
     if window.onOpen then
         pcall(window.onOpen)
     end
 
     -- Fire WindowCreated hook
     if _G.sys and _G.sys.hook and _G.sys.hook.run then
         _G.sys.hook:run("WindowCreated", window)
     end
 
     return window
 end
 
 --- Enter exclusive fullscreen mode
 -- Creates a fullscreen window (1024x768)
 function Application:enterFullscreen()
     -- LPM is no longer required for fullscreen mode
 
     -- Create fullscreen window if it doesn't exist
     if not self.fullscreenWindow then
         self.fullscreenWindow = {
             x = 0,
             y = 0,
             width = 1024,
             height = 768,
             visible = true,
             app = self,
             appInstance = self,
             drawCallback = nil,
             inputCallback = nil,
             isFullscreen = true,
             isBorderless = true
         }
 
         -- Window draw method
         function self.fullscreenWindow:draw(safeGfx)
             if self.drawCallback and self.visible then
                 self.drawCallback(safeGfx)
             end
         end
 
         -- Set draw callback
         function self.fullscreenWindow:onDraw(callback)
             if type(callback) ~= "function" then
                 error("onDraw requires a function")
             end
             self.drawCallback = callback
         end
 
         -- Set input callback
         function self.fullscreenWindow:onInput(callback)
             if type(callback) ~= "function" then
                 error("onInput requires a function")
             end
             self.inputCallback = callback
         end
 
         -- Add to app's window list
         table.insert(self.windows, self.fullscreenWindow)
 
         if osprint then
             osprint("Fullscreen window created for " .. self.appName .. "\n")
         end
     end
 
     return self.fullscreenWindow
 end
 
 --- Exit exclusive fullscreen mode
 function Application:exitFullscreen()
     -- LPM removed - exclusive fullscreen disabled
 end
 
 return Application