# Manual This is KolibriOS lua syscalls library. Usually you shouldn't use this library Better if you read before [KolibriOS syscalls wiki](http://wiki.kolibrios.org/wiki/) include this library: ```lua local syscalls = require("syscalls") ``` ## Events ### SetEventMask(newMask) ### CheckEvent() check [event](#events-list) ### WaitEvent() Endless wait [event](#events-list) ### WaitEventTimeout(timeout) Wait timeout 1/100 sec return event or `nil` ### Events list ```lua syscalls.Event. ``` + `Redraw` + `Button` + `Key` + `Desktop` + `Mouse` + `Network` + `IPC` + `Debug` ## Window ### CreateWindow(x, y, width, height, workColor, [style](#window-style), borderColor, titleColor) Define window `borderColor` and borderColor` only for FixSizes` and CanChangeSizes` (without skin styles) style. ### StartRedraw() Start window redraw. Just call it before CreateWindow` ### EndRedraw() End window redraw. Just call it after you done redraw window. ### ChangeWindow(newX, newY, newWidth, newHeight) ### FocusWindow(slot) ### UnfocusWindow(slot) ### SetWindowTitle(newTitle) ### GetSkinHeight() return skin height. ### SetSkin(path) return error code ### GetSkinTitleArea() return table: ```lua { Left: number, Right: number, Top: number, Bottom: number } ``` ### Window Style ```lua syscalls.windowStyle. ``` + `FixSizes` + `NoDraw` (you must draw window manually) + `CanChangeSizes` + `WithSkin` (usually use it) + `WithSkinFixSizes` (with skin, but window size fixed) ## Graphic ### Text encoding ```lua syscalls.Encoding. ``` + `cp866` + `cp866_8x16` + `utf8` + `utf16` ### Text sizes ```lua syscalls.textSize. ``` + `6x9` (cp866 only) + `8x16` + `12x18` (cp866 only) + `16x32` + `18x27` (cp866 only) + `24x36` (cp866 only) + `24x48` + `30x45` (cp866 only) + `32x64` + `36x54` (cp866 only) + `40x80` + `42x63` (cp866 only) + `48x72` (cp866 only) + `48x96` + `56x112` + `64x128` ### DrawText(text, xPos, yPos, textColor, [textScale](#text-sizes), textLen, backgroundColor, [encoding](#text-encoding)) ### DrawTextFixSize(text, xPos, yPos, textColor, [textScale](#text-sizes), textLen, backgroundColor, [encoding](#text-encoding)) Draw text. textSize, textLen, backgroundColor, encoding are optional. ### DrawLine(x1, y1, x2, y2) ### DrawRectangle(x, y, width, height, color) ### ReadPoint(x, y) return color ## Buttons ### DefineButton(x, y, width, height, id, color) ### DeleteButton(id) ### GetButton() return pressed button or `nil` ### SetButtonStyle([style](#button-styles)) Set buttons style ### buttons button's ids that defined default by window with skin ```lua syscalls.buttons. ``` + `close` + `minimization` ### Button styles ```lua syscalls.buttonStyle. ``` + `Flat` + `Volume` ## Keyboard ### GetKey() return: + `nil` if buffer empty + if hotkey return second number + if key pressed and key input mode is ascii return string(1 char), else return [scancode](#scancodes) example: ```lua local key, hotkey = syscalls.GetKey() if key then print("key pressed") end if hotkey then print("hotkey pressed") end ``` ### SetKeyInputMode(mode) by default is `ASCII` ### GetKeyInputMode() return key input mode. isn't syscall ### Scancodes ```lua syscalls.scancode. ``` + `A` + `B` + `C` + `D` + `E` + `F` + `G` + `H` + `J` + `K` + `L` + `M` + `O` + `P` + `Q` + `S` + `T` + `U` + `W` + `X` + `Y` + `Z` + `1` + `2` + `3` + `4` + `5` + `6` + `7` + `8` + `9` + `F1` + `F2` + `F3` + `F4` + `F5` + `F6` + `F7` + `F8` + `F9` + `F10` + `F11` + `F12` + `LeftShift` + `RightShift` + `LeftAlt` + `RightAlt` + `Tab` ## SystemColors ### SystemColors type userdata #### Fields ```lua { frameArea: number, grabBar: number, grabBarButton: number, grabButtonText: number grabText: number, workArea: number, workButton: number, workButton: number, workButtonText: number, workGraph: number, workText: number } ``` #### Constructor ```lua syscalls.SystemColors.new( frameArea, grabBar, grabBarButton, grabButtonText, grabText, workArea, workButton, workButton, workButtonText, workGraph, workText ) ``` ### GetSystemColors() return [SystemColors](#systemcolors-type) ### SetSystemColors([SystemColors](#systemcolors-type)) ## Threads ### ThreadInfo(pid) return table: ```lua { name: string, pid: number, cpu_usage: number, memused: number, winXPos: number, winYPos: number, winXSize: number, winYPos: number, slotState: number, windowState: number, slotNumWindowStack: number, posInWindowStack: number, keyInputMode: number } ``` ### KillBySlot(slot) ### Slot states ```lua syscalls.slotState. ``` + `Running` + `Suspended` + `SuspendedWaitEvent` + `NormalTerm` + `ExceptTerm` + `WaitEvent` + `Free` ## Sockets ### OpenSocket([domain](#socket-types), [type](#address-families), [protocol](#ip-protocols)) return socket ```lua local socket, err = syscalls.OpenSocket( syscalls.SOCK.STREAM, syscalls.AF.INET, syscalls.IPPROTO.IP ) if err then print("Error", err) else print("Ok") end ``` ### CloseSocket(socket) ### PairSocket() ```lua local first, second = PairSocket() if first then print("OK") else print("Error:", second) end ``` ### Bind(socket, address) ### Listen(socket, backlog) ### Connect(socket, address) ### Accept(socket, , flags) ### Receive(socket, , flags) ### SetSocketOption(socket, [opt](#socket-options)) ### GetSocketOption(socket, [opt](#socket-options)) ### Socket types ```lua syscalls.SOCK. ``` + `STREAM` + `RAW` + `DGRAM` ### Address families ```lua syscalls.AF. ``` + `UNSPEC` + `LOCAL` + `INET` + `INET4` + `INET6` ### IP options ```lua syscalls.IP. ``` + `TTL` ### IP protocols ```lua syscalls.IPPROTO. ``` + `IP` + `ICMP` + `TCP` + `UDP` + `RAW` ### Socket options ```lua syscalls.SO. ``` + `BINDTODEVICE` + `NONBLOCK` ## Debug ### Registers type ```lua { eax: number ebx: number, esp: number, esi: number, edi: number, eip: number, eflags: number } ``` ### DebugPutc(char) Put char to debug board ### DebugPuts(text) Put string to debug board ### GetRegisters(pid) The process must be loaded for debugging (as stated in the general description). return registers table ### SetRegisters(pid, [registers](#registers-type)) The process must be loaded for debugging (as stated in the general description). ### Disconnect(pid) The process must be loaded for debugging (as stated in the general description). If the process was suspended, it resumes execution. ### Stop(pid) The process must be loaded for debugging (as stated in the general description). ### Continue(pid) The process must be loaded for debugging (as stated in the general description). ### ReadFromMem(pid, bytes, pointer, buffer) The process must be loaded for debugging (as stated in the general description). return or `nil` ### WriteToMem(pid, bytes, pointer, buffer) The process must be loaded for debugging (as stated in the general description). return or `nil` ### Done(pid) ### DefineBreakpoint(pid, index, condition, len) ### UndefBreakpoint(pid, index, condition, len) ## IPC ### DefineIPCBuffer(size) Define buffer for IPC receive Return [buffer](#ipc_buffer) type ### SendIPCMessage(pid, [message](#ipc_msg)) Send message to process by pid return [Error code](#ipc-error-codes) ### IPC Error codes ```lua syscalls.IPCError. ``` + `Ok` + `BufferLocked` + `BufferNotDefined` + `BufferOverflow` + `PIDNotExist` ### IPC_buffer ```lua { used: number, lock: boolean, Lock: (self: IPC_buffer) -> nil Unlock: (self: IPC_buffer) -> nil GetMessage: (self: IPC_buffer, i: number) -> IPC_msg GetLastMessage: (self: IPC_buffer) -> IPC_msg } ``` #### Lock(self) Lock buffer #### Unlock(self) Unlock buffer #### GetMessage(self, i) return [message](#ipc_msg) that were send by number i #### GetLastMessage(self) return last sended [message](#ipc_msg) ### IPC_msg ```lua { pid: number, size: number } ```