From 1e53a6fa9635988a55071f0f05c6b29bd9320414 Mon Sep 17 00:00:00 2001 From: nakst Date: Wed, 18 Sep 2019 16:19:19 +0100 Subject: [PATCH] updated os_essence.odin --- core/os/os_essence.odin | 2936 +++++++++++++++++++++++++++------------ 1 file changed, 2013 insertions(+), 923 deletions(-) diff --git a/core/os/os_essence.odin b/core/os/os_essence.odin index e087a3de3..d11c0503b 100644 --- a/core/os/os_essence.odin +++ b/core/os/os_essence.odin @@ -1,646 +1,1721 @@ package os; -EsData :: struct { _private : [4]rawptr, } -EsGeneric :: rawptr; -EsElement :: struct { _private : u8, }; -EsObject :: rawptr; -EsLongDouble :: struct { value : [10]u8, }; -EsNodeType :: u64; -EsError :: int; -EsHandle :: uint; -EsResponse :: i32; -EsFileOffset :: u64; -EsListViewIndex :: i32; -EsThreadEntryFunction :: distinct #type proc (EsGeneric); -EsComparisonCallbackFunction :: distinct #type proc (rawptr, rawptr, EsGeneric) -> i32; -EsSwapCallbackFunction :: distinct #type proc (rawptr, rawptr, EsGeneric); -EsCRTComparisonCallback :: distinct #type proc (rawptr, rawptr) -> i32; -EsMessageCallbackFunction :: distinct #type proc (EsObject, ^EsMessage, ^EsResponse); -EsUICallbackFunction :: distinct #type proc (^EsElement, ^EsMessage, ^EsResponse); -ES_SCANCODE_A :: (0x1C); -ES_SCANCODE_B :: (0x32); -ES_SCANCODE_C :: (0x21); -ES_SCANCODE_D :: (0x23); -ES_SCANCODE_E :: (0x24); -ES_SCANCODE_F :: (0x2B); -ES_SCANCODE_G :: (0x34); -ES_SCANCODE_H :: (0x33); -ES_SCANCODE_I :: (0x43); -ES_SCANCODE_J :: (0x3B); -ES_SCANCODE_K :: (0x42); -ES_SCANCODE_L :: (0x4B); -ES_SCANCODE_M :: (0x3A); -ES_SCANCODE_N :: (0x31); -ES_SCANCODE_O :: (0x44); -ES_SCANCODE_P :: (0x4D); -ES_SCANCODE_Q :: (0x15); -ES_SCANCODE_R :: (0x2D); -ES_SCANCODE_S :: (0x1B); -ES_SCANCODE_T :: (0x2C); -ES_SCANCODE_U :: (0x3C); -ES_SCANCODE_V :: (0x2A); -ES_SCANCODE_W :: (0x1D); -ES_SCANCODE_X :: (0x22); -ES_SCANCODE_Y :: (0x35); -ES_SCANCODE_Z :: (0x1A); -ES_SCANCODE_0 :: (0x45); -ES_SCANCODE_1 :: (0x16); -ES_SCANCODE_2 :: (0x1E); -ES_SCANCODE_3 :: (0x26); -ES_SCANCODE_4 :: (0x25); -ES_SCANCODE_5 :: (0x2E); -ES_SCANCODE_6 :: (0x36); -ES_SCANCODE_7 :: (0x3D); -ES_SCANCODE_8 :: (0x3E); -ES_SCANCODE_9 :: (0x46); -ES_SCANCODE_CAPS_LOCK :: (0x58); -ES_SCANCODE_SCROLL_LOCK :: (0x7E); -ES_SCANCODE_NUM_LOCK :: (0x77) ; -ES_SCANCODE_LEFT_SHIFT :: (0x12); -ES_SCANCODE_LEFT_CTRL :: (0x14); -ES_SCANCODE_LEFT_ALT :: (0x11); -ES_SCANCODE_LEFT_FLAG :: (0x11F); -ES_SCANCODE_RIGHT_SHIFT :: (0x59); -ES_SCANCODE_RIGHT_CTRL :: (0x114); -ES_SCANCODE_RIGHT_ALT :: (0x111); -ES_SCANCODE_PAUSE :: (0xE1); -ES_SCANCODE_CONTEXT_MENU :: (0x127); -ES_SCANCODE_BACKSPACE :: (0x66); -ES_SCANCODE_ESCAPE :: (0x76); -ES_SCANCODE_INSERT :: (0x170); -ES_SCANCODE_HOME :: (0x16C); -ES_SCANCODE_PAGE_UP :: (0x17D); -ES_SCANCODE_DELETE :: (0x171); -ES_SCANCODE_END :: (0x169); -ES_SCANCODE_PAGE_DOWN :: (0x17A); -ES_SCANCODE_UP_ARROW :: (0x175); -ES_SCANCODE_LEFT_ARROW :: (0x16B); -ES_SCANCODE_DOWN_ARROW :: (0x172); -ES_SCANCODE_RIGHT_ARROW :: (0x174); -ES_SCANCODE_SPACE :: (0x29); -ES_SCANCODE_TAB :: (0x0D); -ES_SCANCODE_ENTER :: (0x5A); -ES_SCANCODE_SLASH :: (0x4A); -ES_SCANCODE_BACKSLASH :: (0x5D); -ES_SCANCODE_LEFT_BRACE :: (0x54); -ES_SCANCODE_RIGHT_BRACE :: (0x5B); -ES_SCANCODE_EQUALS :: (0x55); -ES_SCANCODE_BACKTICK :: (0x0E); -ES_SCANCODE_HYPHEN :: (0x4E); -ES_SCANCODE_SEMICOLON :: (0x4C); -ES_SCANCODE_QUOTE :: (0x52); -ES_SCANCODE_COMMA :: (0x41); -ES_SCANCODE_PERIOD :: (0x49); -ES_SCANCODE_NUM_DIVIDE :: (0x14A); -ES_SCANCODE_NUM_MULTIPLY :: (0x7C); -ES_SCANCODE_NUM_SUBTRACT :: (0x7B); -ES_SCANCODE_NUM_ADD :: (0x79); -ES_SCANCODE_NUM_ENTER :: (0x15A); -ES_SCANCODE_NUM_POINT :: (0x71); -ES_SCANCODE_NUM_0 :: (0x70); -ES_SCANCODE_NUM_1 :: (0x69); -ES_SCANCODE_NUM_2 :: (0x72); -ES_SCANCODE_NUM_3 :: (0x7A); -ES_SCANCODE_NUM_4 :: (0x6B); -ES_SCANCODE_NUM_5 :: (0x73); -ES_SCANCODE_NUM_6 :: (0x74); -ES_SCANCODE_NUM_7 :: (0x6C); -ES_SCANCODE_NUM_8 :: (0x75); -ES_SCANCODE_NUM_9 :: (0x7D); -ES_SCANCODE_PRINT_SCREEN_1 :: (0x112) ; -ES_SCANCODE_PRINT_SCREEN_2 :: (0x17C); -ES_SCANCODE_F1 :: (0x05); -ES_SCANCODE_F2 :: (0x06); -ES_SCANCODE_F3 :: (0x04); -ES_SCANCODE_F4 :: (0x0C); -ES_SCANCODE_F5 :: (0x03); -ES_SCANCODE_F6 :: (0x0B); -ES_SCANCODE_F7 :: (0x83); -ES_SCANCODE_F8 :: (0x0A); -ES_SCANCODE_F9 :: (0x01); -ES_SCANCODE_F10 :: (0x09); -ES_SCANCODE_F11 :: (0x78); -ES_SCANCODE_F12 :: (0x07); -ES_SCANCODE_ACPI_POWER :: (0x137); -ES_SCANCODE_ACPI_SLEEP :: (0x13F); -ES_SCANCODE_ACPI_WAKE :: (0x15E); -ES_SCANCODE_MM_NEXT :: (0x14D); -ES_SCANCODE_MM_PREVIOUS :: (0x115); -ES_SCANCODE_MM_STOP :: (0x13B); -ES_SCANCODE_MM_PAUSE :: (0x134); -ES_SCANCODE_MM_MUTE :: (0x123); -ES_SCANCODE_MM_QUIETER :: (0x121); -ES_SCANCODE_MM_LOUDER :: (0x132); -ES_SCANCODE_MM_SELECT :: (0x150); -ES_SCANCODE_MM_EMAIL :: (0x148); -ES_SCANCODE_MM_CALC :: (0x12B); -ES_SCANCODE_MM_FILES :: (0x140); -ES_SCANCODE_WWW_SEARCH :: (0x110); -ES_SCANCODE_WWW_HOME :: (0x13A); -ES_SCANCODE_WWW_BACK :: (0x138); -ES_SCANCODE_WWW_FORWARD :: (0x130); -ES_SCANCODE_WWW_STOP :: (0x128); -ES_SCANCODE_WWW_REFRESH :: (0x120); -ES_SCANCODE_WWW_STARRED :: (0x118); -ES_PROCESS_STATE_ALL_THREADS_TERMINATED :: (1); -ES_PROCESS_STATE_TERMINATING :: (2); -ES_PROCESS_STATE_CRASHED :: (4); -ES_FLAGS_DEFAULT :: (0); -ES_SUCCESS :: (-1); -ES_ERROR_BUFFER_TOO_SMALL :: (-2); -ES_ERROR_UNKNOWN_OPERATION_FAILURE :: (-7); -ES_ERROR_NO_MESSAGES_AVAILABLE :: (-9); -ES_ERROR_MESSAGE_QUEUE_FULL :: (-10); -ES_ERROR_MESSAGE_NOT_HANDLED_BY_GUI :: (-13); -ES_ERROR_PATH_NOT_WITHIN_MOUNTED_VOLUME :: (-14); -ES_ERROR_PATH_NOT_TRAVERSABLE :: (-15); -ES_ERROR_FILE_ALREADY_EXISTS :: (-19); -ES_ERROR_FILE_DOES_NOT_EXIST :: (-20); -ES_ERROR_DRIVE_ERROR_FILE_DAMAGED :: (-21) ; -ES_ERROR_ACCESS_NOT_WITHIN_FILE_BOUNDS :: (-22) ; -ES_ERROR_FILE_PERMISSION_NOT_GRANTED :: (-23); -ES_ERROR_FILE_IN_EXCLUSIVE_USE :: (-24); -ES_ERROR_FILE_CANNOT_GET_EXCLUSIVE_USE :: (-25); -ES_ERROR_INCORRECT_NODE_TYPE :: (-26); -ES_ERROR_EVENT_NOT_SET :: (-27); -ES_ERROR_TIMEOUT_REACHED :: (-29); -ES_ERROR_REQUEST_CLOSED_BEFORE_COMPLETE :: (-30); -ES_ERROR_NO_CHARACTER_AT_COORDINATE :: (-31); -ES_ERROR_FILE_ON_READ_ONLY_VOLUME :: (-32); -ES_ERROR_USER_CANCELED_IO :: (-33); -ES_ERROR_INVALID_DIMENSIONS :: (-34); -ES_ERROR_DRIVE_CONTROLLER_REPORTED :: (-35); -ES_ERROR_COULD_NOT_ISSUE_PACKET :: (-36); -ES_ERROR_HANDLE_TABLE_FULL :: (-37); -ES_ERROR_COULD_NOT_RESIZE_FILE :: (-38); -ES_ERROR_DIRECTORY_NOT_EMPTY :: (-39); -ES_ERROR_UNSUPPORTED_FILESYSTEM :: (-40); -ES_ERROR_NODE_ALREADY_DELETED :: (-41); -ES_ERROR_NODE_IS_ROOT :: (-42); -ES_ERROR_VOLUME_MISMATCH :: (-43); -ES_ERROR_TARGET_WITHIN_SOURCE :: (-44); -ES_ERROR_TARGET_INVALID_TYPE :: (-45); -ES_ERROR_NOTHING_TO_DRAW :: (-46); -ES_ERROR_MALFORMED_NODE_PATH :: (-47); -ES_ERROR_OUT_OF_CACHE_RESOURCES :: (-48); -ES_ERROR_TARGET_IS_SOURCE :: (-49); -ES_ERROR_INVALID_NAME :: (-50); -ES_ERROR_CORRUPT_DATA :: (-51); -ES_ERROR_INSUFFICIENT_RESOURCES :: (-52); -ES_ERROR_UNSUPPORTED_FEATURE :: (-53); -ES_ERROR_FILE_TOO_FRAGMENTED :: (-54); -ES_ERROR_DRIVE_FULL :: (-55); -ES_ERROR_COULD_NOT_RESOLVE_SYMBOL :: (-56); -ES_ERROR_ALREADY_EMBEDDED :: (-57); -ES_SYSTEM_CONSTANT_TIME_STAMP_UNITS_PER_MICROSECOND :: (0); -ES_SYSTEM_CONSTANT_NO_FANCY_GRAPHICS :: (2); -ES_SYSTEM_CONSTANT_REPORTED_PROBLEMS :: (3); -ES_INVALID_HANDLE :: ((EsHandle) (0)); -ES_CURRENT_THREAD :: ((EsHandle) (0x10)); -ES_CURRENT_PROCESS :: ((EsHandle) (0x11)); -ES_SURFACE_UI_SHEET :: ((EsHandle) (0x20)); -ES_SURFACE_WALLPAPER :: ((EsHandle) (0x21)); -ES_DRAW_ALPHA_OVERWRITE :: (0x100); -ES_DRAW_ALPHA_FULL :: (0x200) ; -ES_WAIT_NO_TIMEOUT :: (-1); -ES_MAX_WAIT_COUNT :: (16); -ES_MAX_DIRECTORY_CHILD_NAME_LENGTH :: (256); -ES_PROCESS_EXECUTABLE_NOT_LOADED :: 0; -ES_PROCESS_EXECUTABLE_FAILED_TO_LOAD :: 1; -ES_PROCESS_EXECUTABLE_LOADED :: 2; -ES_SNAPSHOT_MAX_PROCESS_NAME_LENGTH :: (80); -ES_SYSTEM_SNAPSHOT_PROCESSES :: (1); -ES_SYSTEM_SNAPSHOT_DRIVES :: (2); -ES_NOT_HANDLED :: (-1); -ES_HANDLED :: (0); -ES_REJECTED :: (-2); -ES_SHARED_MEMORY_MAXIMUM_SIZE :: ( (1024) * 1024 * 1024 * 1024); -ES_SHARED_MEMORY_NAME_MAX_LENGTH :: (32); -ES_MAP_OBJECT_ALL :: (0); -ES_DRAW_STRING_HALIGN_LEFT :: (1); -ES_DRAW_STRING_HALIGN_RIGHT :: (2); -ES_DRAW_STRING_HALIGN_CENTER :: (3); -ES_DRAW_STRING_VALIGN_TOP :: (4); -ES_DRAW_STRING_VALIGN_BOTTOM :: (8); -ES_DRAW_STRING_VALIGN_CENTER :: (12); -ES_DRAW_STRING_CLIP :: (0); -ES_DRAW_STRING_WORD_WRAP :: (16); -ES_DRAW_STRING_ELLIPSIS :: (32); -ES_NODE_READ_NONE :: (0x0); -ES_NODE_READ_BLOCK :: (0x1); -ES_NODE_READ_ACCESS :: (0x2); -ES_NODE_READ_EXCLUSIVE :: (0x3); -ES_NODE_WRITE_NONE :: (0x00); -ES_NODE_WRITE_BLOCK :: (0x10); -ES_NODE_WRITE_ACCESS :: (0x20); -ES_NODE_WRITE_EXCLUSIVE :: (0x30); -ES_NODE_RESIZE_NONE :: (0x000); -ES_NODE_RESIZE_BLOCK :: (0x100); -ES_NODE_RESIZE_ACCESS :: (0x200); -ES_NODE_RESIZE_EXCLUSIVE :: (0x300); -ES_NODE_FAIL_IF_FOUND :: (0x1000); -ES_NODE_FAIL_IF_NOT_FOUND :: (0x2000); -ES_NODE_CREATE_DIRECTORIES :: (0x8000) ; -ES_NODE_POSIX_NAMESPACE :: (0x10000) ; -ES_DIRECTORY_CHILDREN_UNKNOWN :: ( (-1)); -ES_MEMORY_OPEN_FAIL_IF_FOUND :: (0x1000); -ES_MEMORY_OPEN_FAIL_IF_NOT_FOUND :: (0x2000); -ES_MAP_OBJECT_READ_WRITE :: (0); -ES_MAP_OBJECT_READ_ONLY :: (1); -ES_MAP_OBJECT_COPY_ON_WRITE :: (2); -ES_BOX_STYLE_OUTWARDS :: (0x01) ; -ES_BOX_STYLE_INWARDS :: (0x02) ; -ES_BOX_STYLE_NEUTRAL :: (0x03) ; -ES_BOX_STYLE_FLAT :: (0x04) ; -ES_BOX_STYLE_NONE :: (0x05) ; -ES_BOX_STYLE_SELECTED :: (0x06) ; -ES_BOX_STYLE_PUSHED :: (0x07) ; -ES_BOX_STYLE_DOTTED :: (0x80); -ES_BOX_COLOR_GRAY :: (0xC0C0C0); -ES_BOX_COLOR_DARK_GRAY :: (0x808080); -ES_BOX_COLOR_WHITE :: (0xFFFFFF); -ES_BOX_COLOR_BLUE :: (0x000080); -ES_BOX_COLOR_TRANSPARENT :: (0xFF00FF); -ES_BOX_COLOR_BLACK :: (0x000000); -ES_STRING_FORMAT_ENOUGH_SPACE :: ( (-1)); -ES_POSIX_SYSCALL_GET_POSIX_FD_PATH :: (0x10000); -ES_SURFACE_FULL_ALPHA :: (1); -ES_PERMISSION_ACCESS_SYSTEM_FILES :: (1 << 0); -ES_PERMISSION_ACCESS_USER_FILES :: (1 << 1); -ES_PERMISSION_PROCESS_CREATE :: (1 << 2); -ES_PERMISSION_PROCESS_OPEN :: (1 << 3); -ES_PERMISSION_SCREEN_MODIFY :: (1 << 4) ; -ES_PERMISSION_SHUTDOWN :: (1 << 5); -ES_PERMISSION_TAKE_SYSTEM_SNAPSHOT :: (1 << 6); -ES_PERMISSION_WINDOW_OPEN :: (1 << 7); -ES_PERMISSION_ALL :: ( (-1)); -ES_PERMISSION_INHERIT :: ( (1 << 63)); -ES_PANEL_WRAP :: ( (0x0001) << 32); -ES_PANEL_H_LEFT :: ( (0x0010) << 32); -ES_PANEL_H_RIGHT :: ( (0x0020) << 32); -ES_PANEL_H_CENTER :: ( (0x0040) << 32); -ES_PANEL_H_JUSTIFY :: ( (0x0080) << 32); -ES_PANEL_V_TOP :: ( (0x0100) << 32); -ES_PANEL_V_BOTTOM :: ( (0x0200) << 32); -ES_PANEL_V_CENTER :: ( (0x0400) << 32); -ES_PANEL_V_JUSTIFY :: ( (0x0800) << 32); -ES_PANEL_H_SCROLL :: ( (0x1000) << 32); -ES_PANEL_V_SCROLL :: ( (0x2000) << 32); -ES_CELL_H_PUSH :: ( (0x0001) << 16); -ES_CELL_H_EXPAND :: ( (0x0002) << 16); -ES_CELL_H_LEFT :: ( (0x0004) << 16); -ES_CELL_H_RIGHT :: ( (0x0008) << 16); -ES_CELL_H_SHRINK :: ( (0x0010) << 16); -ES_CELL_V_PUSH :: ( (0x0100) << 16); -ES_CELL_V_EXPAND :: ( (0x0200) << 16); -ES_CELL_V_TOP :: ( (0x0400) << 16); -ES_CELL_V_BOTTOM :: ( (0x0800) << 16); -ES_CELL_V_SHRINK :: ( (0x1000) << 16); -ES_CELL_NEW_BAND :: ( (0x8000) << 16); -ES_CELL_HIDDEN :: ( (0xFFFF) << 16); -ES_ELEMENT_DO_NOT_FREE_STYLE_OVERRIDE :: (1 << 0); -ES_ELEMENT_RICH_TEXT :: (1 << 1); -ES_ELEMENT_FOCUSABLE :: (1 << 2); -ES_ELEMENT_Z_STACK :: (1 << 3) ; -ES_ELEMENT_HIDDEN :: (1 << 4); -ES_ELEMENT_USE_CHILD_AS_PARENT :: (1 << 5) ; -ES_TEXTBOX_MULTILINE :: (1 << 0); -ES_TEXTBOX_BORDERED :: (1 << 1); -ES_BUTTON_DEFAULT :: ( (1) << 32); -ES_BUTTON_DANGEROUS :: ( (1) << 33); -ES_SCROLLBAR_VERTICAL :: ( (0) << 32); -ES_SCROLLBAR_HORIZONTAL :: ( (1) << 32); -ES_LIST_VIEW_INDEX_GROUP_HEADER :: (-1); -ES_LIST_VIEW_ITEM_CONTENT_TEXT :: (1 << 0); -ES_LIST_VIEW_ITEM_CONTENT_ICON :: (1 << 1); -ES_LIST_VIEW_ITEM_CONTENT_INDENTATION :: (1 << 2); -ES_LIST_VIEW_ITEM_STATE_SELECTED :: (1 << 0); -ES_LIST_VIEW_ITEM_STATE_CHECKED :: (1 << 1); -ES_LIST_VIEW_ITEM_STATE_HIDDEN :: (1 << 2); -ES_LIST_VIEW_ITEM_STATE_EXPANDABLE :: (1 << 3); -ES_LIST_VIEW_ITEM_STATE_CHECKABLE :: (1 << 4); -ES_LIST_VIEW_ITEM_STATE_DROP_TARGET :: (1 << 5); -ES_LIST_VIEW_ITEM_STATE_COLLAPSABLE :: (1 << 6); -ES_LIST_VIEW_ITEM_STATE_PARTIAL_CHECK :: (1 << 7); -ES_LIST_VIEW_ITEM_STATE_DRAG_SOURCE :: (1 << 8); -ES_LIST_VIEW_ITEM_STATE_CUT :: (1 << 9); -ES_LIST_VIEW_FIND_ITEM_FROM_Y_POSITION :: (0); -ES_LIST_VIEW_FIND_ITEM_FROM_TEXT_PREFIX :: (1); -ES_LIST_VIEW_FIND_ITEM_NON_HIDDEN :: (2); -ES_LIST_VIEW_FIND_ITEM_PARENT :: (3); -ES_LIST_VIEW_COLUMN_DEFAULT_WIDTH_PRIMARY :: (300); -ES_LIST_VIEW_COLUMN_DEFAULT_WIDTH_SECONDARY :: (150); -ES_LIST_VIEW_COLUMN_PRIMARY :: (1); -ES_LIST_VIEW_COLUMN_RIGHT_ALIGNED :: (2); -ES_LIST_VIEW_COLUMN_SORT_ASCENDING :: (8); -ES_LIST_VIEW_COLUMN_SORT_DESCENDING :: (16); -ES_LIST_VIEW_COLUMN_SORTABLE :: (32); -ES_LIST_VIEW_SINGLE_SELECT :: (1 << 0) ; -ES_LIST_VIEW_MULTI_SELECT :: (1 << 1) ; -ES_LIST_VIEW_HAS_COLUMNS :: (1 << 2) ; -ES_LIST_VIEW_HAS_GROUPS :: (1 << 3) ; -ES_LIST_VIEW_FIXED_HEIGHT :: (1 << 4) ; -ES_LIST_VIEW_VARIABLE_HEIGHT :: (1 << 5) ; -ES_LIST_VIEW_TREE :: (1 << 6) ; -ES_LIST_VIEW_TILED :: (1 << 7) ; -ES_LIST_VIEW_ALT_BACKGROUND :: (1 << 8) ; -ES_LIST_VIEW_BORDERED :: (1 << 9) ; -ES_LIST_VIEW_NO_BACKGROUND :: (1 << 10) ; -ES_LIST_VIEW_DROP_TARGET_ORDERED :: (1 << 11) ; -ES_LIST_VIEW_DROP_TARGET_UNORDERED :: (1 << 12) ; -ES_LIST_VIEW_ROW_DIVIDERS :: (1 << 13) ; -ES_LIST_VIEW_STATIC_GROUP_HEADERS :: (1 << 14) ; -ES_LIST_VIEW_COLLAPSABLE_GROUPS :: (1 << 15) ; -ES_LIST_VIEW_INTERNAL_SELECTION_STORAGE :: (1 << 16) ; -ES_LIST_VIEW_HAND_CURSOR :: (1 << 17) ; -ES_LIST_VIEW_NO_ITEM_BACKGROUNDS :: (1 << 18) ; -ES_LIST_VIEW_RICH_TEXT :: (1 << 20) ; -ES_LIST_VIEW_LABELS_BELOW :: (1 << 21) ; -ES_LIST_VIEW_MAXIMUM_ITEMS :: (10 * 1000 * 1000); -ES_LIST_VIEW_MAXIMUM_GROUPS :: (10 * 1000); -ES_LIST_VIEW_TRANSITION_BACKWARDS :: (1); -ES_LIST_VIEW_TRANSITION_DRAW_NEW_CONTENTS_ONCE :: (2) ; -EsFatalError :: enum { - ES_FATAL_ERROR_INVALID_BUFFER, - ES_FATAL_ERROR_UNKNOWN_SYSCALL, - ES_FATAL_ERROR_INVALID_MEMORY_REGION, - ES_FATAL_ERROR_MEMORY_REGION_LOCKED_BY_KERNEL, - ES_FATAL_ERROR_PATH_LENGTH_EXCEEDS_LIMIT, - ES_FATAL_ERROR_INVALID_HANDLE, - ES_FATAL_ERROR_MUTEX_NOT_ACQUIRED_BY_THREAD, - ES_FATAL_ERROR_MUTEX_ALREADY_ACQUIRED, - ES_FATAL_ERROR_BUFFER_NOT_ACCESSIBLE, - ES_FATAL_ERROR_SHARED_MEMORY_REGION_TOO_LARGE, - ES_FATAL_ERROR_SHARED_MEMORY_STILL_MAPPED, - ES_FATAL_ERROR_COULD_NOT_LOAD_FONT, - ES_FATAL_ERROR_COULD_NOT_DRAW_FONT, - ES_FATAL_ERROR_COULD_NOT_ALLOCATE_MEMORY, - ES_FATAL_ERROR_INCORRECT_FILE_ACCESS, - ES_FATAL_ERROR_TOO_MANY_WAIT_OBJECTS, - ES_FATAL_ERROR_INCORRECT_NODE_TYPE, - ES_FATAL_ERROR_PROCESSOR_EXCEPTION, - ES_FATAL_ERROR_UNKNOWN, - ES_FATAL_ERROR_RECURSIVE_BATCH, - ES_FATAL_ERROR_CORRUPT_HEAP, - ES_FATAL_ERROR_CORRUPT_LINKED_LIST, - ES_FATAL_ERROR_INDEX_OUT_OF_BOUNDS, - ES_FATAL_ERROR_INVALID_STRING_LENGTH, - ES_FATAL_ERROR_SPINLOCK_NOT_ACQUIRED, - ES_FATAL_ERROR_UNKNOWN_SNAPSHOT_TYPE, - ES_FATAL_ERROR_PROCESS_ALREADY_ATTACHED, - ES_FATAL_ERROR_INTERNAL, - ES_FATAL_ERROR_INSUFFICIENT_PERMISSIONS, - ES_FATAL_ERROR_ABORT, - ES_FATAL_ERROR_COUNT, +Data :: struct { _private : [4]rawptr, } +Generic :: rawptr; +Element :: struct { _private : u8, }; +Object :: rawptr; +LongDouble :: struct { value : [10]u8, }; +NodeType :: u64; +Error :: int; +Handle :: uint; +Response :: i32; +FileOffset :: u64; +ListViewIndex :: i32; +ThreadEntryFunction :: distinct #type proc (Generic); +ComparisonCallbackFunction :: distinct #type proc (rawptr, rawptr, Generic) -> i32; +SwapCallbackFunction :: distinct #type proc (rawptr, rawptr, Generic); +CRTComparisonCallback :: distinct #type proc (rawptr, rawptr) -> i32; +MessageCallbackFunction :: distinct #type proc (Object, ^Message, ^Response); +UICallbackFunction :: distinct #type proc (^Element, ^Message, ^Response); +Window :: struct { using element : Element, }; +Panel :: struct { using element : Element, }; +Scrollbar :: struct { using element : Element, }; +Button :: struct { using element : Element, }; +Textbox :: struct { using element : Element, }; +ListView :: struct { using element : Element, }; +NumericEntry :: struct { using element : Element, }; +Menu :: struct { using element : Element, }; +MenuCallbackFunction :: distinct #type proc (^Element, Generic); +INSTANCE_TYPE :: Instance; +SCANCODE_A :: (0x1C); +SCANCODE_B :: (0x32); +SCANCODE_C :: (0x21); +SCANCODE_D :: (0x23); +SCANCODE_E :: (0x24); +SCANCODE_F :: (0x2B); +SCANCODE_G :: (0x34); +SCANCODE_H :: (0x33); +SCANCODE_I :: (0x43); +SCANCODE_J :: (0x3B); +SCANCODE_K :: (0x42); +SCANCODE_L :: (0x4B); +SCANCODE_M :: (0x3A); +SCANCODE_N :: (0x31); +SCANCODE_O :: (0x44); +SCANCODE_P :: (0x4D); +SCANCODE_Q :: (0x15); +SCANCODE_R :: (0x2D); +SCANCODE_S :: (0x1B); +SCANCODE_T :: (0x2C); +SCANCODE_U :: (0x3C); +SCANCODE_V :: (0x2A); +SCANCODE_W :: (0x1D); +SCANCODE_X :: (0x22); +SCANCODE_Y :: (0x35); +SCANCODE_Z :: (0x1A); +SCANCODE_0 :: (0x45); +SCANCODE_1 :: (0x16); +SCANCODE_2 :: (0x1E); +SCANCODE_3 :: (0x26); +SCANCODE_4 :: (0x25); +SCANCODE_5 :: (0x2E); +SCANCODE_6 :: (0x36); +SCANCODE_7 :: (0x3D); +SCANCODE_8 :: (0x3E); +SCANCODE_9 :: (0x46); +SCANCODE_CAPS_LOCK :: (0x58); +SCANCODE_SCROLL_LOCK :: (0x7E); +SCANCODE_NUM_LOCK :: (0x77) ; +SCANCODE_LEFT_SHIFT :: (0x12); +SCANCODE_LEFT_CTRL :: (0x14); +SCANCODE_LEFT_ALT :: (0x11); +SCANCODE_LEFT_FLAG :: (0x11F); +SCANCODE_RIGHT_SHIFT :: (0x59); +SCANCODE_RIGHT_CTRL :: (0x114); +SCANCODE_RIGHT_ALT :: (0x111); +SCANCODE_PAUSE :: (0xE1); +SCANCODE_CONTEXT_MENU :: (0x127); +SCANCODE_BACKSPACE :: (0x66); +SCANCODE_ESCAPE :: (0x76); +SCANCODE_INSERT :: (0x170); +SCANCODE_HOME :: (0x16C); +SCANCODE_PAGE_UP :: (0x17D); +SCANCODE_DELETE :: (0x171); +SCANCODE_END :: (0x169); +SCANCODE_PAGE_DOWN :: (0x17A); +SCANCODE_UP_ARROW :: (0x175); +SCANCODE_LEFT_ARROW :: (0x16B); +SCANCODE_DOWN_ARROW :: (0x172); +SCANCODE_RIGHT_ARROW :: (0x174); +SCANCODE_SPACE :: (0x29); +SCANCODE_TAB :: (0x0D); +SCANCODE_ENTER :: (0x5A); +SCANCODE_SLASH :: (0x4A); +SCANCODE_BACKSLASH :: (0x5D); +SCANCODE_LEFT_BRACE :: (0x54); +SCANCODE_RIGHT_BRACE :: (0x5B); +SCANCODE_EQUALS :: (0x55); +SCANCODE_BACKTICK :: (0x0E); +SCANCODE_HYPHEN :: (0x4E); +SCANCODE_SEMICOLON :: (0x4C); +SCANCODE_QUOTE :: (0x52); +SCANCODE_COMMA :: (0x41); +SCANCODE_PERIOD :: (0x49); +SCANCODE_NUM_DIVIDE :: (0x14A); +SCANCODE_NUM_MULTIPLY :: (0x7C); +SCANCODE_NUM_SUBTRACT :: (0x7B); +SCANCODE_NUM_ADD :: (0x79); +SCANCODE_NUM_ENTER :: (0x15A); +SCANCODE_NUM_POINT :: (0x71); +SCANCODE_NUM_0 :: (0x70); +SCANCODE_NUM_1 :: (0x69); +SCANCODE_NUM_2 :: (0x72); +SCANCODE_NUM_3 :: (0x7A); +SCANCODE_NUM_4 :: (0x6B); +SCANCODE_NUM_5 :: (0x73); +SCANCODE_NUM_6 :: (0x74); +SCANCODE_NUM_7 :: (0x6C); +SCANCODE_NUM_8 :: (0x75); +SCANCODE_NUM_9 :: (0x7D); +SCANCODE_PRINT_SCREEN_1 :: (0x112) ; +SCANCODE_PRINT_SCREEN_2 :: (0x17C); +SCANCODE_F1 :: (0x05); +SCANCODE_F2 :: (0x06); +SCANCODE_F3 :: (0x04); +SCANCODE_F4 :: (0x0C); +SCANCODE_F5 :: (0x03); +SCANCODE_F6 :: (0x0B); +SCANCODE_F7 :: (0x83); +SCANCODE_F8 :: (0x0A); +SCANCODE_F9 :: (0x01); +SCANCODE_F10 :: (0x09); +SCANCODE_F11 :: (0x78); +SCANCODE_F12 :: (0x07); +SCANCODE_ACPI_POWER :: (0x137); +SCANCODE_ACPI_SLEEP :: (0x13F); +SCANCODE_ACPI_WAKE :: (0x15E); +SCANCODE_MM_NEXT :: (0x14D); +SCANCODE_MM_PREVIOUS :: (0x115); +SCANCODE_MM_STOP :: (0x13B); +SCANCODE_MM_PAUSE :: (0x134); +SCANCODE_MM_MUTE :: (0x123); +SCANCODE_MM_QUIETER :: (0x121); +SCANCODE_MM_LOUDER :: (0x132); +SCANCODE_MM_SELECT :: (0x150); +SCANCODE_MM_EMAIL :: (0x148); +SCANCODE_MM_CALC :: (0x12B); +SCANCODE_MM_FILES :: (0x140); +SCANCODE_WWW_SEARCH :: (0x110); +SCANCODE_WWW_HOME :: (0x13A); +SCANCODE_WWW_BACK :: (0x138); +SCANCODE_WWW_FORWARD :: (0x130); +SCANCODE_WWW_STOP :: (0x128); +SCANCODE_WWW_REFRESH :: (0x120); +SCANCODE_WWW_STARRED :: (0x118); +PROCESS_STATE_ALL_THREADS_TERMINATED :: (1); +PROCESS_STATE_TERMINATING :: (2); +PROCESS_STATE_CRASHED :: (4); +FLAGS_DEFAULT :: (0); +SUCCESS :: (-1); +ERROR_BUFFER_TOO_SMALL :: (-2); +ERROR_UNKNOWN_OPERATION_FAILURE :: (-7); +ERROR_NO_MESSAGES_AVAILABLE :: (-9); +ERROR_MESSAGE_QUEUE_FULL :: (-10); +ERROR_MESSAGE_NOT_HANDLED_BY_GUI :: (-13); +ERROR_PATH_NOT_WITHIN_MOUNTED_VOLUME :: (-14); +ERROR_PATH_NOT_TRAVERSABLE :: (-15); +ERROR_FILE_ALREADY_EXISTS :: (-19); +ERROR_FILE_DOES_NOT_EXIST :: (-20); +ERROR_DRIVE_ERROR_FILE_DAMAGED :: (-21) ; +ERROR_ACCESS_NOT_WITHIN_FILE_BOUNDS :: (-22) ; +ERROR_FILE_PERMISSION_NOT_GRANTED :: (-23); +ERROR_FILE_IN_EXCLUSIVE_USE :: (-24); +ERROR_FILE_CANNOT_GET_EXCLUSIVE_USE :: (-25); +ERROR_INCORRECT_NODE_TYPE :: (-26); +ERROR_EVENT_NOT_SET :: (-27); +ERROR_TIMEOUT_REACHED :: (-29); +ERROR_REQUEST_CLOSED_BEFORE_COMPLETE :: (-30); +ERROR_NO_CHARACTER_AT_COORDINATE :: (-31); +ERROR_FILE_ON_READ_ONLY_VOLUME :: (-32); +ERROR_USER_CANCELED_IO :: (-33); +ERROR_INVALID_DIMENSIONS :: (-34); +ERROR_DRIVE_CONTROLLER_REPORTED :: (-35); +ERROR_COULD_NOT_ISSUE_PACKET :: (-36); +ERROR_HANDLE_TABLE_FULL :: (-37); +ERROR_COULD_NOT_RESIZE_FILE :: (-38); +ERROR_DIRECTORY_NOT_EMPTY :: (-39); +ERROR_UNSUPPORTED_FILESYSTEM :: (-40); +ERROR_NODE_ALREADY_DELETED :: (-41); +ERROR_NODE_IS_ROOT :: (-42); +ERROR_VOLUME_MISMATCH :: (-43); +ERROR_TARGET_WITHIN_SOURCE :: (-44); +ERROR_TARGET_INVALID_TYPE :: (-45); +ERROR_NOTHING_TO_DRAW :: (-46); +ERROR_MALFORMED_NODE_PATH :: (-47); +ERROR_OUT_OF_CACHE_RESOURCES :: (-48); +ERROR_TARGET_IS_SOURCE :: (-49); +ERROR_INVALID_NAME :: (-50); +ERROR_CORRUPT_DATA :: (-51); +ERROR_INSUFFICIENT_RESOURCES :: (-52); +ERROR_UNSUPPORTED_FEATURE :: (-53); +ERROR_FILE_TOO_FRAGMENTED :: (-54); +ERROR_DRIVE_FULL :: (-55); +ERROR_COULD_NOT_RESOLVE_SYMBOL :: (-56); +ERROR_ALREADY_EMBEDDED :: (-57); +SYSTEM_CONSTANT_TIME_STAMP_UNITS_PER_MICROSECOND :: (0); +SYSTEM_CONSTANT_NO_FANCY_GRAPHICS :: (2); +SYSTEM_CONSTANT_REPORTED_PROBLEMS :: (3); +SYSTEM_CONSTANT_RIGHT_TO_LEFT :: (4); +INVALID_HANDLE :: ((Handle) (0)); +CURRENT_THREAD :: ((Handle) (0x10)); +CURRENT_PROCESS :: ((Handle) (0x11)); +SURFACE_UI_SHEET :: ((Handle) (0x20)); +SURFACE_WALLPAPER :: ((Handle) (0x21)); +DRAW_ALPHA_OVERWRITE :: (0x100); +DRAW_ALPHA_FULL :: (0x200) ; +WAIT_NO_TIMEOUT :: (-1); +MAX_WAIT_COUNT :: (16); +MAX_DIRECTORY_CHILD_NAME_LENGTH :: (256); +PROCESS_EXECUTABLE_NOT_LOADED :: 0; +PROCESS_EXECUTABLE_FAILED_TO_LOAD :: 1; +PROCESS_EXECUTABLE_LOADED :: 2; +SNAPSHOT_MAX_PROCESS_NAME_LENGTH :: (80); +SYSTEM_SNAPSHOT_PROCESSES :: (1); +SYSTEM_SNAPSHOT_DRIVES :: (2); +NOT_HANDLED :: (-1); +HANDLED :: (0); +REJECTED :: (-2); +SHARED_MEMORY_MAXIMUM_SIZE :: ( (1024) * 1024 * 1024 * 1024); +SHARED_MEMORY_NAME_MAX_LENGTH :: (32); +MAP_OBJECT_ALL :: (0); +DRAW_STRING_HALIGN_LEFT :: (1); +DRAW_STRING_HALIGN_RIGHT :: (2); +DRAW_STRING_HALIGN_CENTER :: (3); +DRAW_STRING_VALIGN_TOP :: (4); +DRAW_STRING_VALIGN_BOTTOM :: (8); +DRAW_STRING_VALIGN_CENTER :: (12); +DRAW_STRING_CLIP :: (0); +DRAW_STRING_WORD_WRAP :: (16); +DRAW_STRING_ELLIPSIS :: (32); +NODE_READ_NONE :: (0x0); +NODE_READ_BLOCK :: (0x1); +NODE_READ_ACCESS :: (0x2); +NODE_READ_EXCLUSIVE :: (0x3); +NODE_WRITE_NONE :: (0x00); +NODE_WRITE_BLOCK :: (0x10); +NODE_WRITE_ACCESS :: (0x20); +NODE_WRITE_EXCLUSIVE :: (0x30); +NODE_RESIZE_NONE :: (0x000); +NODE_RESIZE_BLOCK :: (0x100); +NODE_RESIZE_ACCESS :: (0x200); +NODE_RESIZE_EXCLUSIVE :: (0x300); +NODE_FAIL_IF_FOUND :: (0x1000); +NODE_FAIL_IF_NOT_FOUND :: (0x2000); +NODE_CREATE_DIRECTORIES :: (0x8000) ; +NODE_POSIX_NAMESPACE :: (0x10000) ; +DIRECTORY_CHILDREN_UNKNOWN :: ( (-1)); +MEMORY_OPEN_FAIL_IF_FOUND :: (0x1000); +MEMORY_OPEN_FAIL_IF_NOT_FOUND :: (0x2000); +MAP_OBJECT_READ_WRITE :: (0); +MAP_OBJECT_READ_ONLY :: (1); +MAP_OBJECT_COPY_ON_WRITE :: (2); +BOX_STYLE_OUTWARDS :: (0x01) ; +BOX_STYLE_INWARDS :: (0x02) ; +BOX_STYLE_NEUTRAL :: (0x03) ; +BOX_STYLE_FLAT :: (0x04) ; +BOX_STYLE_NONE :: (0x05) ; +BOX_STYLE_SELECTED :: (0x06) ; +BOX_STYLE_PUSHED :: (0x07) ; +BOX_STYLE_DOTTED :: (0x80); +BOX_COLOR_GRAY :: (0xC0C0C0); +BOX_COLOR_DARK_GRAY :: (0x808080); +BOX_COLOR_WHITE :: (0xFFFFFF); +BOX_COLOR_BLUE :: (0x000080); +BOX_COLOR_TRANSPARENT :: (0xFF00FF); +BOX_COLOR_BLACK :: (0x000000); +STRING_FORMAT_ENOUGH_SPACE :: ( (-1)); +POSIX_SYSCALL_GET_POSIX_FD_PATH :: (0x10000); +PERMISSION_ACCESS_SYSTEM_FILES :: (1 << 0); +PERMISSION_ACCESS_USER_FILES :: (1 << 1); +PERMISSION_PROCESS_CREATE :: (1 << 2); +PERMISSION_PROCESS_OPEN :: (1 << 3); +PERMISSION_SCREEN_MODIFY :: (1 << 4) ; +PERMISSION_SHUTDOWN :: (1 << 5); +PERMISSION_TAKE_SYSTEM_SNAPSHOT :: (1 << 6); +PERMISSION_WINDOW_OPEN :: (1 << 7); +PERMISSION_ALL :: ( (-1)); +PERMISSION_INHERIT :: ( (1 << 63)); +PANEL_STYLE_DEFAULT :: "Panel.Default"; +PANEL_STYLE_MENU_COLUMN :: "Panel.Menu.Column"; +PANEL_WRAP :: ( (0x0001) << 32); +PANEL_H_LEFT :: ( (0x0010) << 32); +PANEL_H_RIGHT :: ( (0x0020) << 32); +PANEL_H_CENTER :: ( (0x0040) << 32); +PANEL_H_JUSTIFY :: ( (0x0080) << 32); +PANEL_V_TOP :: ( (0x0100) << 32); +PANEL_V_BOTTOM :: ( (0x0200) << 32); +PANEL_V_CENTER :: ( (0x0400) << 32); +PANEL_V_JUSTIFY :: ( (0x0800) << 32); +PANEL_H_SCROLL :: ( (0x1000) << 32); +PANEL_V_SCROLL :: ( (0x2000) << 32); +CELL_H_PUSH :: ( (0x0001) << 16); +CELL_H_EXPAND :: ( (0x0002) << 16); +CELL_H_LEFT :: ( (0x0004) << 16); +CELL_H_RIGHT :: ( (0x0008) << 16); +CELL_H_SHRINK :: ( (0x0010) << 16); +CELL_V_PUSH :: ( (0x0100) << 16); +CELL_V_EXPAND :: ( (0x0200) << 16); +CELL_V_TOP :: ( (0x0400) << 16); +CELL_V_BOTTOM :: ( (0x0800) << 16); +CELL_V_SHRINK :: ( (0x1000) << 16); +CELL_NEW_BAND :: ( (0x8000) << 16); +CELL_HIDDEN :: ( (0xFFFF) << 16); +ELEMENT_DO_NOT_FREE_STYLE_OVERRIDE :: (1 << 0); +ELEMENT_RICH_TEXT :: (1 << 1); +ELEMENT_FOCUSABLE :: (1 << 2); +ELEMENT_Z_STACK :: (1 << 3) ; +ELEMENT_HIDDEN :: (1 << 4); +ELEMENT_USE_CHILD_AS_PARENT :: (1 << 5) ; +ELEMENT_DISABLED :: (1 << 6); +ELEMENT_WINDOW_COORDS_FOR_MOUSE :: (1 << 7) ; +TEXTBOX_MULTILINE :: (1 << 0); +TEXTBOX_BORDERED :: (1 << 1); +BUTTON_DEFAULT :: ( (1) << 32); +BUTTON_DANGEROUS :: ( (1) << 33); +BUTTON_MENU_ITEM :: ( (1) << 34); +BUTTON_NOT_FOCUSABLE :: ( (1) << 35); +BUTTON_TOOLBAR :: ( (1) << 36); +SCROLLBAR_VERTICAL :: ( (0) << 32); +SCROLLBAR_HORIZONTAL :: ( (1) << 32); +LIST_VIEW_INDEX_GROUP_HEADER :: (-1); +LIST_VIEW_ITEM_CONTENT_TEXT :: (1 << 0); +LIST_VIEW_ITEM_CONTENT_ICON :: (1 << 1); +LIST_VIEW_ITEM_CONTENT_INDENTATION :: (1 << 2); +LIST_VIEW_ITEM_STATE_SELECTED :: (1 << 0); +LIST_VIEW_ITEM_STATE_CHECKED :: (1 << 1); +LIST_VIEW_ITEM_STATE_HIDDEN :: (1 << 2); +LIST_VIEW_ITEM_STATE_EXPANDABLE :: (1 << 3); +LIST_VIEW_ITEM_STATE_CHECKABLE :: (1 << 4); +LIST_VIEW_ITEM_STATE_DROP_TARGET :: (1 << 5); +LIST_VIEW_ITEM_STATE_COLLAPSABLE :: (1 << 6); +LIST_VIEW_ITEM_STATE_PARTIAL_CHECK :: (1 << 7); +LIST_VIEW_ITEM_STATE_DRAG_SOURCE :: (1 << 8); +LIST_VIEW_ITEM_STATE_CUT :: (1 << 9); +LIST_VIEW_FIND_ITEM_FROM_Y_POSITION :: (0); +LIST_VIEW_FIND_ITEM_FROM_TEXT_PREFIX :: (1); +LIST_VIEW_FIND_ITEM_NON_HIDDEN :: (2); +LIST_VIEW_FIND_ITEM_PARENT :: (3); +LIST_VIEW_COLUMN_DEFAULT_WIDTH_PRIMARY :: (270); +LIST_VIEW_COLUMN_DEFAULT_WIDTH_SECONDARY :: (130); +LIST_VIEW_COLUMN_PRIMARY :: (1); +LIST_VIEW_COLUMN_RIGHT_ALIGNED :: (2); +LIST_VIEW_COLUMN_SORT_ASCENDING :: (8); +LIST_VIEW_COLUMN_SORT_DESCENDING :: (16); +LIST_VIEW_COLUMN_SORTABLE :: (32); +LIST_VIEW_SINGLE_SELECT :: ( (1) << 32) ; +LIST_VIEW_MULTI_SELECT :: ( (1) << 33) ; +LIST_VIEW_HAS_COLUMNS :: ( (1) << 34) ; +LIST_VIEW_HAS_GROUPS :: ( (1) << 35) ; +LIST_VIEW_FIXED_HEIGHT :: ( (1) << 36) ; +LIST_VIEW_VARIABLE_HEIGHT :: ( (1) << 37) ; +LIST_VIEW_TREE :: ( (1) << 38) ; +LIST_VIEW_TILED :: ( (1) << 39) ; +LIST_VIEW_BORDERED :: ( (1) << 41) ; +LIST_VIEW_DROP_TARGET_ORDERED :: ( (1) << 43) ; +LIST_VIEW_DROP_TARGET_UNORDERED :: ( (1) << 44) ; +LIST_VIEW_ROW_DIVIDERS :: ( (1) << 45) ; +LIST_VIEW_STATIC_GROUP_HEADERS :: ( (1) << 46) ; +LIST_VIEW_COLLAPSABLE_GROUPS :: ( (1) << 47) ; +LIST_VIEW_INTERNAL_SELECTION_STORAGE :: ( (1) << 48) ; +LIST_VIEW_HAND_CURSOR :: ( (1) << 49) ; +LIST_VIEW_NO_ITEM_BACKGROUNDS :: ( (1) << 50) ; +LIST_VIEW_RICH_TEXT :: ( (1) << 52) ; +LIST_VIEW_LABELS_BELOW :: ( (1) << 53) ; +LIST_VIEW_MAXIMUM_ITEMS :: (10 * 1000 * 1000); +LIST_VIEW_MAXIMUM_GROUPS :: (10 * 1000); +LIST_VIEW_TRANSITION_BACKWARDS :: (1); +LIST_VIEW_TRANSITION_DRAW_NEW_CONTENTS_ONCE :: (2) ; +MENU_AT_CURSOR :: (1 << 0); +StandardIcon :: enum { + ICON_ACTION_UNAVAILABLE_SYMBOLIC, + ICON_ADDRESS_BOOK_NEW, + ICON_ADDRESS_BOOK_NEW_SYMBOLIC, + ICON_ALIGN_HORIZONTAL_CENTER, + ICON_ALIGN_HORIZONTAL_CENTER_SYMBOLIC, + ICON_ALIGN_HORIZONTAL_LEFT, + ICON_ALIGN_HORIZONTAL_LEFT_SYMBOLIC, + ICON_ALIGN_HORIZONTAL_LEFT_TO_ANCHOR, + ICON_ALIGN_HORIZONTAL_LEFT_TO_ANCHOR_SYMBOLIC, + ICON_ALIGN_HORIZONTAL_RIGHT, + ICON_ALIGN_HORIZONTAL_RIGHT_SYMBOLIC, + ICON_ALIGN_HORIZONTAL_RIGHT_TO_ANCHOR, + ICON_ALIGN_HORIZONTAL_RIGHT_TO_ANCHOR_SYMBOLIC, + ICON_ALIGN_VERTICAL_BOTTOM, + ICON_ALIGN_VERTICAL_BOTTOM_SYMBOLIC, + ICON_ALIGN_VERTICAL_BOTTOM_TO_ANCHOR, + ICON_ALIGN_VERTICAL_BOTTOM_TO_ANCHOR_SYMBOLIC, + ICON_ALIGN_VERTICAL_CENTER, + ICON_ALIGN_VERTICAL_CENTER_SYMBOLIC, + ICON_ALIGN_VERTICAL_TOP, + ICON_ALIGN_VERTICAL_TOP_SYMBOLIC, + ICON_ALIGN_VERTICAL_TOP_TO_ANCHOR, + ICON_ALIGN_VERTICAL_TOP_TO_ANCHOR_SYMBOLIC, + ICON_APPLICATION_ADD_SYMBOLIC, + ICON_APPOINTMENT_NEW, + ICON_APPOINTMENT_NEW_SYMBOLIC, + ICON_APPOINTMENT_SYMBOLIC, + ICON_BOOKMARK_NEW, + ICON_BOOKMARK_NEW_SYMBOLIC, + ICON_CALL_START, + ICON_CALL_START_SYMBOLIC, + ICON_CALL_STOP, + ICON_CALL_STOP_SYMBOLIC, + ICON_COLOR_FILL, + ICON_COLOR_GRADIENT, + ICON_COLOR_GRADIENT_MESH, + ICON_COLOR_SELECT_SYMBOLIC, + ICON_CONTACT_NEW, + ICON_CONTACT_NEW_SYMBOLIC, + ICON_DISTRIBUTE_HORIZONTAL_CENTER, + ICON_DISTRIBUTE_HORIZONTAL_GAPS, + ICON_DISTRIBUTE_HORIZONTAL_LEFT, + ICON_DISTRIBUTE_HORIZONTAL_RIGHT, + ICON_DISTRIBUTE_VERTICAL_BOTTOM, + ICON_DISTRIBUTE_VERTICAL_CENTER, + ICON_DISTRIBUTE_VERTICAL_GAPS, + ICON_DISTRIBUTE_VERTICAL_TOP, + ICON_DOCUMENT_EDIT, + ICON_DOCUMENT_EDIT_SYMBOLIC, + ICON_DOCUMENT_EXPORT, + ICON_DOCUMENT_EXPORT_SYMBOLIC, + ICON_DOCUMENT_IMPORT, + ICON_DOCUMENT_IMPORT_SYMBOLIC, + ICON_DOCUMENT_NEW, + ICON_DOCUMENT_NEW_SYMBOLIC, + ICON_DOCUMENT_OPEN_RECENT, + ICON_DOCUMENT_OPEN_RECENT_SYMBOLIC, + ICON_DOCUMENT_OPEN_SYMBOLIC, + ICON_DOCUMENT_PAGE_SETUP, + ICON_DOCUMENT_PAGE_SETUP_SYMBOLIC, + ICON_DOCUMENT_PRINT_PREVIEW, + ICON_DOCUMENT_PRINT_PREVIEW_SYMBOLIC, + ICON_DOCUMENT_PRINT_SYMBOLIC, + ICON_DOCUMENT_PROPERTIES, + ICON_DOCUMENT_PROPERTIES_SYMBOLIC, + ICON_DOCUMENT_REVERT, + ICON_DOCUMENT_REVERT_SYMBOLIC, + ICON_DOCUMENT_SAVE_AS, + ICON_DOCUMENT_SAVE_AS_SYMBOLIC, + ICON_DOCUMENT_SAVE_SYMBOLIC, + ICON_DOCUMENT_SEND, + ICON_DOCUMENT_SEND_SYMBOLIC, + ICON_DRAW_CUBOID, + ICON_DRAW_ELLIPSE, + ICON_DRAW_ERASER, + ICON_DRAW_FREEHAND, + ICON_DRAW_PATH, + ICON_DRAW_POLYGON_STAR, + ICON_DRAW_RECTANGLE, + ICON_DRAW_SPIRAL, + ICON_DRAW_TEXT, + ICON_EDIT_CLEAR, + ICON_EDIT_CLEAR_ALL_SYMBOLIC, + ICON_EDIT_CLEAR_SYMBOLIC, + ICON_EDIT_COPY, + ICON_EDIT_COPY_SYMBOLIC, + ICON_EDIT_CUT, + ICON_EDIT_CUT_SYMBOLIC, + ICON_EDIT_DELETE_SYMBOLIC, + ICON_EDIT_FIND, + ICON_EDIT_FIND_REPLACE, + ICON_EDIT_FIND_REPLACE_SYMBOLIC, + ICON_EDIT_FIND_SYMBOLIC, + ICON_EDIT_FLAG, + ICON_EDIT_FLAG_SYMBOLIC, + ICON_EDIT_MARK, + ICON_EDIT_PASTE, + ICON_EDIT_PASTE_SYMBOLIC, + ICON_EDIT_REDO, + ICON_EDIT_REDO_SYMBOLIC, + ICON_EDIT_SELECT_ALL, + ICON_EDIT_SELECT_ALL_SYMBOLIC, + ICON_EDIT_SELECT_SYMBOLIC, + ICON_EDIT_UNDO, + ICON_EDIT_UNDO_ARCHIVE, + ICON_EDIT_UNDO_SYMBOLIC, + ICON_ERROR_CORRECT_SYMBOLIC, + ICON_EVENT_NEW, + ICON_FIND_LOCATION, + ICON_FIND_LOCATION_SYMBOLIC, + ICON_FOLDER_COPY, + ICON_FOLDER_MOVE, + ICON_FOLDER_NEW, + ICON_FOLDER_NEW_SYMBOLIC, + ICON_FONT_SELECT_SYMBOLIC, + ICON_FORMAT_INDENT_LESS, + ICON_FORMAT_INDENT_LESS_SYMBOLIC, + ICON_FORMAT_INDENT_MORE, + ICON_FORMAT_INDENT_MORE_SYMBOLIC, + ICON_FORMAT_JUSTIFY_CENTER, + ICON_FORMAT_JUSTIFY_CENTER_SYMBOLIC, + ICON_FORMAT_JUSTIFY_FILL, + ICON_FORMAT_JUSTIFY_FILL_SYMBOLIC, + ICON_FORMAT_JUSTIFY_LEFT, + ICON_FORMAT_JUSTIFY_LEFT_SYMBOLIC, + ICON_FORMAT_JUSTIFY_RIGHT, + ICON_FORMAT_JUSTIFY_RIGHT_SYMBOLIC, + ICON_FORMAT_TEXT_BOLD, + ICON_FORMAT_TEXT_BOLD_ES_SYMBOLIC, + ICON_FORMAT_TEXT_BOLD_FR_SYMBOLIC, + ICON_FORMAT_TEXT_BOLD_SYMBOLIC, + ICON_FORMAT_TEXT_CLEAR_FORMATTING_SYMBOLIC, + ICON_FORMAT_TEXT_DIRECTION_LTR_SYMBOLIC, + ICON_FORMAT_TEXT_HIGHLIGHT, + ICON_FORMAT_TEXT_ITALIC, + ICON_FORMAT_TEXT_ITALIC_ES_SYMBOLIC, + ICON_FORMAT_TEXT_ITALIC_SYMBOLIC, + ICON_FORMAT_TEXT_LARGER_SYMBOLIC, + ICON_FORMAT_TEXT_NONE, + ICON_FORMAT_TEXT_SMALLER_SYMBOLIC, + ICON_FORMAT_TEXT_STRIKETHROUGH, + ICON_FORMAT_TEXT_STRIKETHROUGH_FR_SYMBOLIC, + ICON_FORMAT_TEXT_STRIKETHROUGH_SYMBOLIC, + ICON_FORMAT_TEXT_UNDERLINE, + ICON_FORMAT_TEXT_UNDERLINE_FR_SYMBOLIC, + ICON_FORMAT_TEXT_UNDERLINE_SYMBOLIC, + ICON_GO_BOTTOM, + ICON_GO_BOTTOM_SYMBOLIC, + ICON_GO_DOWN, + ICON_GO_DOWN_SYMBOLIC, + ICON_GO_FIRST, + ICON_GO_FIRST_SYMBOLIC, + ICON_GO_HOME_SYMBOLIC, + ICON_GO_JUMP, + ICON_GO_JUMP_SYMBOLIC, + ICON_GO_LAST, + ICON_GO_LAST_SYMBOLIC, + ICON_GO_NEXT, + ICON_GO_NEXT_SYMBOLIC, + ICON_GO_PREVIOUS, + ICON_GO_PREVIOUS_SYMBOLIC, + ICON_GO_TOP, + ICON_GO_TOP_SYMBOLIC, + ICON_GO_UP, + ICON_GO_UP_SYMBOLIC, + ICON_HELP_ABOUT, + ICON_HELP_ABOUT_SYMBOLIC, + ICON_HELP_CONTENTS, + ICON_HELP_CONTENTS_SYMBOLIC, + ICON_HELP_INFO_SYMBOLIC, + ICON_IMAGE_ADJUST, + ICON_IMAGE_AUTO_ADJUST, + ICON_IMAGE_CROP, + ICON_IMAGE_CROP_SYMBOLIC, + ICON_IMAGE_RED_EYE, + ICON_IMAGE_RED_EYE_SYMBOLIC, + ICON_INSERT_IMAGE, + ICON_INSERT_IMAGE_SYMBOLIC, + ICON_INSERT_LINK, + ICON_INSERT_LINK_SYMBOLIC, + ICON_INSERT_OBJECT, + ICON_INSERT_OBJECT_SYMBOLIC, + ICON_INSERT_TEXT_SYMBOLIC, + ICON_LIST_ADD, + ICON_LIST_ADD_SYMBOLIC, + ICON_LIST_REMOVE, + ICON_LIST_REMOVE_SYMBOLIC, + ICON_MAIL_ARCHIVE, + ICON_MAIL_FORWARD, + ICON_MAIL_FORWARD_SYMBOLIC, + ICON_MAIL_MARK_IMPORTANT, + ICON_MAIL_MARK_IMPORTANT_SYMBOLIC, + ICON_MAIL_MARK_JUNK, + ICON_MAIL_MARK_JUNK_SYMBOLIC, + ICON_MAIL_MARK_NOTJUNK, + ICON_MAIL_MARK_NOTJUNK_SYMBOLIC, + ICON_MAIL_MESSAGE_NEW, + ICON_MAIL_MESSAGE_NEW_SYMBOLIC, + ICON_MAIL_MOVE, + ICON_MAIL_MOVE_SYMBOLIC, + ICON_MAIL_REPLY_ALL, + ICON_MAIL_REPLY_ALL_SYMBOLIC, + ICON_MAIL_REPLY_SENDER, + ICON_MAIL_REPLY_SENDER_SYMBOLIC, + ICON_MAIL_SEND, + ICON_MAIL_SEND_RECEIVE_SYMBOLIC, + ICON_MAIL_SEND_SYMBOLIC, + ICON_MARK_LOCATION_SYMBOLIC, + ICON_MEDIA_EJECT, + ICON_MEDIA_EJECT_SYMBOLIC, + ICON_MEDIA_EQ_SYMBOLIC, + ICON_MEDIA_PLAYBACK_PAUSE, + ICON_MEDIA_PLAYBACK_PAUSE_SYMBOLIC, + ICON_MEDIA_PLAYBACK_START, + ICON_MEDIA_PLAYBACK_START_SYMBOLIC, + ICON_MEDIA_PLAYBACK_STOP, + ICON_MEDIA_PLAYBACK_STOP_SYMBOLIC, + ICON_MEDIA_RECORD, + ICON_MEDIA_RECORD_SYMBOLIC, + ICON_MEDIA_SEEK_BACKWARD, + ICON_MEDIA_SEEK_BACKWARD_SYMBOLIC, + ICON_MEDIA_SEEK_FORWARD, + ICON_MEDIA_SEEK_FORWARD_SYMBOLIC, + ICON_MEDIA_SKIP_BACKWARD, + ICON_MEDIA_SKIP_FORWARD, + ICON_MEDIA_VIEW_SUBTITLES_SYMBOLIC, + ICON_NODE_ADD, + ICON_NODE_ALIGN_HORIZONTAL, + ICON_NODE_ALIGN_VERTICAL, + ICON_NODE_BREAK, + ICON_NODE_CUSP, + ICON_NODE_DELETE, + ICON_NODE_DELETE_SEGMENT, + ICON_NODE_DISTRIBUTE_HORIZONTAL, + ICON_NODE_DISTRIBUTE_VERTICAL, + ICON_NODE_INSERT, + ICON_NODE_JOIN, + ICON_NODE_JOIN_SEGMENT, + ICON_NODE_SMOOTH, + ICON_NODE_SYMMETRIC, + ICON_OBJECT_FLIP_HORIZONTAL, + ICON_OBJECT_FLIP_HORIZONTAL_SYMBOLIC, + ICON_OBJECT_FLIP_VERTICAL, + ICON_OBJECT_FLIP_VERTICAL_SYMBOLIC, + ICON_OBJECT_GROUP, + ICON_OBJECT_GROUP_SYMBOLIC, + ICON_OBJECT_INVERSE, + ICON_OBJECT_INVERSE_SYMBOLIC, + ICON_OBJECT_MERGE, + ICON_OBJECT_ROTATE_LEFT, + ICON_OBJECT_ROTATE_LEFT_SYMBOLIC, + ICON_OBJECT_ROTATE_RIGHT, + ICON_OBJECT_ROTATE_RIGHT_SYMBOLIC, + ICON_OBJECT_SELECT_SYMBOLIC, + ICON_OBJECT_STRAIGHTEN, + ICON_OBJECT_TO_PATH, + ICON_OBJECT_UNGROUP, + ICON_OBJECT_UNGROUP_SYMBOLIC, + ICON_OPEN_MENU, + ICON_OPEN_MENU_SYMBOLIC, + ICON_PAN_DOWN_SYMBOLIC, + ICON_PAN_END_SYMBOLIC, + ICON_PAN_START_SYMBOLIC, + ICON_PAN_UP_SYMBOLIC, + ICON_PANE_HIDE_SYMBOLIC, + ICON_PANE_SHOW_SYMBOLIC, + ICON_PATH_BREAK_APART, + ICON_PATH_BREAK_APART_SYMBOLIC, + ICON_PATH_COMBINE, + ICON_PATH_COMBINE_SYMBOLIC, + ICON_PATH_DIFFERENCE, + ICON_PATH_DIFFERENCE_SYMBOLIC, + ICON_PATH_DIVISION, + ICON_PATH_DIVISION_SYMBOLIC, + ICON_PATH_EXCLUSION, + ICON_PATH_EXCLUSION_SYMBOLIC, + ICON_PATH_INTERSECTION, + ICON_PATH_INTERSECTION_SYMBOLIC, + ICON_PATH_UNION, + ICON_PATH_UNION_SYMBOLIC, + ICON_PROCESS_STOP, + ICON_PROCESS_STOP_SYMBOLIC, + ICON_SEGMENT_CURVE, + ICON_SEGMENT_LINE, + ICON_SELECTION_ADD, + ICON_SELECTION_BOTTOM, + ICON_SELECTION_BOTTOM_SYMBOLIC, + ICON_SELECTION_CHECKED, + ICON_SELECTION_END_SYMBOLIC, + ICON_SELECTION_LOWER, + ICON_SELECTION_LOWER_SYMBOLIC, + ICON_SELECTION_RAISE, + ICON_SELECTION_RAISE_SYMBOLIC, + ICON_SELECTION_REMOVE, + ICON_SELECTION_START_SYMBOLIC, + ICON_SELECTION_TOP, + ICON_SELECTION_TOP_SYMBOLIC, + ICON_SEND_TO, + ICON_SEND_TO_SYMBOLIC, + ICON_STAR_NEW_SYMBOLIC, + ICON_STROKE_TO_PATH, + ICON_SYSTEM_LOCK_SCREEN, + ICON_SYSTEM_LOCK_SCREEN_SYMBOLIC, + ICON_SYSTEM_LOG_OUT, + ICON_SYSTEM_REBOOT, + ICON_SYSTEM_RUN, + ICON_SYSTEM_RUN_SYMBOLIC, + ICON_SYSTEM_SHUTDOWN, + ICON_SYSTEM_SHUTDOWN_SYMBOLIC, + ICON_SYSTEM_SUSPEND, + ICON_TAB_NEW_SYMBOLIC, + ICON_TAG_NEW, + ICON_TAG_NEW_SYMBOLIC, + ICON_TOOL_MEASURE, + ICON_TOOL_NODE_EDITOR, + ICON_TOOLS_CHECK_SPELLING_SYMBOLIC, + ICON_TOOLS_TIMER_SYMBOLIC, + ICON_VIEW_COLUMN_SYMBOLIC, + ICON_VIEW_CONTINUOUS_SYMBOLIC, + ICON_VIEW_DUAL_SYMBOLIC, + ICON_VIEW_FILTER_SYMBOLIC, + ICON_VIEW_FULLSCREEN_SYMBOLIC, + ICON_VIEW_GRID_SYMBOLIC, + ICON_VIEW_LIST_COMPACT_SYMBOLIC, + ICON_VIEW_LIST_IMAGES_SYMBOLIC, + ICON_VIEW_LIST_SYMBOLIC, + ICON_VIEW_LIST_VIDEO_SYMBOLIC, + ICON_VIEW_MORE_HORIZONTAL_SYMBOLIC, + ICON_VIEW_MORE_SYMBOLIC, + ICON_VIEW_PAGED_SYMBOLIC, + ICON_VIEW_PIN_SYMBOLIC, + ICON_VIEW_REFRESH, + ICON_VIEW_REFRESH_SYMBOLIC, + ICON_VIEW_RESTORE_SYMBOLIC, + ICON_VIEW_SORT_ASCENDING_SYMBOLIC, + ICON_VIEW_SORT_DESCENDING_SYMBOLIC, + ICON_WINDOW_CLOSE, + ICON_WINDOW_CLOSE_SYMBOLIC, + ICON_WINDOW_MAXIMIZE_SYMBOLIC, + ICON_WINDOW_MINIMIZE_SYMBOLIC, + ICON_WINDOW_NEW, + ICON_WINDOW_NEW_SYMBOLIC, + ICON_WINDOW_POP_OUT_SYMBOLIC, + ICON_WINDOW_RESTORE_SYMBOLIC, + ICON_ZOOM_FIT_BEST, + ICON_ZOOM_FIT_BEST_SYMBOLIC, + ICON_ZOOM_IN, + ICON_ZOOM_IN_SYMBOLIC, + ICON_ZOOM_ORIGINAL, + ICON_ZOOM_ORIGINAL_SYMBOLIC, + ICON_ZOOM_OUT, + ICON_ZOOM_OUT_SYMBOLIC, + ICON_ACCESSORIES_CALCULATOR, + ICON_ACCESSORIES_CALCULATOR_SYMBOLIC, + ICON_ACCESSORIES_SCREENSHOT, + ICON_ACCESSORIES_TEXT_EDITOR, + ICON_ACCESSORIES_TEXT_EDITOR_SYMBOLIC, + ICON_APPLICATION_DEFAULT_ICON, + ICON_ARCHIVE_MANAGER, + ICON_INTERNET_CHAT, + ICON_INTERNET_CHAT_SYMBOLIC, + ICON_INTERNET_MAIL, + ICON_INTERNET_MAIL_SYMBOLIC, + ICON_INTERNET_NEWS_READER, + ICON_INTERNET_NEWS_READER_SYMBOLIC, + ICON_INTERNET_WEB_BROWSER, + ICON_INTERNET_WEB_BROWSER_SYMBOLIC, + ICON_MULTIMEDIA_AUDIO_PLAYER, + ICON_MULTIMEDIA_PHOTO_MANAGER, + ICON_MULTIMEDIA_VIDEO_PLAYER, + ICON_OFFICE_ADDRESS_BOOK, + ICON_OFFICE_CALENDAR, + ICON_OFFICE_CALENDAR_SYMBOLIC, + ICON_ONBOARD, + ICON_POSTSCRIPT_VIEWER, + ICON_PREFERENCES_DESKTOP, + ICON_PREFERENCES_DESKTOP_FONT, + ICON_SYSTEM_FILE_MANAGER, + ICON_SYSTEM_OS_INSTALLER, + ICON_SYSTEM_SOFTWARE_INSTALL, + ICON_SYSTEM_SOFTWARE_INSTALL_SYMBOLIC, + ICON_SYSTEM_SOFTWARE_UPDATE, + ICON_SYSTEM_USERS, + ICON_SYSTEM_USERS_SYMBOLIC, + ICON_UTILITIES_SYSTEM_MONITOR, + ICON_UTILITIES_TERMINAL, + ICON_UTILITIES_TERMINAL_SYMBOLIC, + ICON_APPLICATIONS_ACCESSORIES, + ICON_APPLICATIONS_AUDIO_SYMBOLIC, + ICON_APPLICATIONS_DEVELOPMENT, + ICON_APPLICATIONS_DEVELOPMENT_SYMBOLIC, + ICON_APPLICATIONS_EDUCATION, + ICON_APPLICATIONS_EDUCATION_SYMBOLIC, + ICON_APPLICATIONS_ENGINEERING_SYMBOLIC, + ICON_APPLICATIONS_FONTS, + ICON_APPLICATIONS_GAMES, + ICON_APPLICATIONS_GAMES_SYMBOLIC, + ICON_APPLICATIONS_GRAPHICS, + ICON_APPLICATIONS_GRAPHICS_SYMBOLIC, + ICON_APPLICATIONS_INTERFACEDESIGN, + ICON_APPLICATIONS_INTERNET_SYMBOLIC, + ICON_APPLICATIONS_MULTIMEDIA, + ICON_APPLICATIONS_MULTIMEDIA_SYMBOLIC, + ICON_APPLICATIONS_OFFICE, + ICON_APPLICATIONS_OFFICE_SYMBOLIC, + ICON_APPLICATIONS_OTHER, + ICON_APPLICATIONS_OTHER_SYMBOLIC, + ICON_APPLICATIONS_PHOTOGRAPHY, + ICON_APPLICATIONS_SCIENCE, + ICON_APPLICATIONS_SCIENCE_SYMBOLIC, + ICON_APPLICATIONS_UTILITIES, + ICON_APPLICATIONS_UTILITIES_SYMBOLIC, + ICON_APPLICATIONS_VIDEO_SYMBOLIC, + ICON_BUG, + ICON_BUG_SYMBOLIC, + ICON_EMOJI_ACTIVITY_SYMBOLIC, + ICON_EMOJI_BODY_SYMBOLIC, + ICON_EMOJI_FOOD_SYMBOLIC, + ICON_EMOJI_NATURE_SYMBOLIC, + ICON_EMOJI_OBJECTS_SYMBOLIC, + ICON_EMOJI_TRAVEL_SYMBOLIC, + ICON_EVENT_BIRTHDAY_SYMBOLIC, + ICON_PREFERENCES_BLUETOOTH_SYMBOLIC, + ICON_PREFERENCES_COLOR, + ICON_PREFERENCES_COLOR_SYMBOLIC, + ICON_PREFERENCES_DESKTOP_ACCESSIBILITY, + ICON_PREFERENCES_DESKTOP_ACCESSIBILITY_POINTING, + ICON_PREFERENCES_DESKTOP_ACCESSIBILITY_SYMBOLIC, + ICON_PREFERENCES_DESKTOP_ACCESSIBILITY_ZOOM, + ICON_PREFERENCES_DESKTOP_APPLICATIONS, + ICON_PREFERENCES_DESKTOP_DISPLAY, + ICON_PREFERENCES_DESKTOP_DISPLAY_SYMBOLIC, + ICON_PREFERENCES_DESKTOP_KEYBOARD, + ICON_PREFERENCES_DESKTOP_KEYBOARD_SYMBOLIC, + ICON_PREFERENCES_DESKTOP_LOCALE, + ICON_PREFERENCES_DESKTOP_LOCALE_SYMBOLIC, + ICON_PREFERENCES_DESKTOP_ONLINE_ACCOUNTS, + ICON_PREFERENCES_DESKTOP_ONLINE_ACCOUNTS_SYMBOLIC, + ICON_PREFERENCES_DESKTOP_PERIPHERALS, + ICON_PREFERENCES_DESKTOP_SOUND, + ICON_PREFERENCES_DESKTOP_WALLPAPER, + ICON_PREFERENCES_OTHER_SYMBOLIC, + ICON_PREFERENCES_SYSTEM, + ICON_PREFERENCES_SYSTEM_NETWORK, + ICON_PREFERENCES_SYSTEM_NETWORK_SYMBOLIC, + ICON_PREFERENCES_SYSTEM_NOTIFICATIONS, + ICON_PREFERENCES_SYSTEM_PARENTAL_CONTROL_SYMBOLIC, + ICON_PREFERENCES_SYSTEM_PARENTAL_CONTROLS, + ICON_PREFERENCES_SYSTEM_POWER, + ICON_PREFERENCES_SYSTEM_POWER_SYMBOLIC, + ICON_PREFERENCES_SYSTEM_PRIVACY_HOUSEKEEPING, + ICON_PREFERENCES_SYSTEM_SHARING, + ICON_PREFERENCES_SYSTEM_SHARING_SYMBOLIC, + ICON_PREFERENCES_SYSTEM_TIME, + ICON_PREFERENCES_SYSTEM_TIME_SYMBOLIC, + ICON_PREFERENCES_SYSTEM_WINDOWS, + ICON_AC_ADAPTER_SYMBOLIC, + ICON_AUDIO_CARD_SYMBOLIC, + ICON_AUDIO_HEADPHONES, + ICON_AUDIO_HEADPHONES_SYMBOLIC, + ICON_AUDIO_HEADSET_SYMBOLIC, + ICON_AUDIO_HEADSETS, + ICON_AUDIO_INPUT_MICROPHONE, + ICON_AUDIO_INPUT_MICROPHONE_SYMBOLIC, + ICON_AUDIO_SPEAKER_CENTER, + ICON_AUDIO_SPEAKER_CENTER_BACK, + ICON_AUDIO_SPEAKER_CENTER_BACK_TESTING, + ICON_AUDIO_SPEAKER_CENTER_TESTING, + ICON_AUDIO_SPEAKER_LEFT, + ICON_AUDIO_SPEAKER_LEFT_BACK, + ICON_AUDIO_SPEAKER_LEFT_BACK_TESTING, + ICON_AUDIO_SPEAKER_LEFT_SIDE, + ICON_AUDIO_SPEAKER_LEFT_SIDE_TESTING, + ICON_AUDIO_SPEAKER_LEFT_TESTING, + ICON_AUDIO_SPEAKER_RIGHT, + ICON_AUDIO_SPEAKER_RIGHT_BACK, + ICON_AUDIO_SPEAKER_RIGHT_BACK_TESTING, + ICON_AUDIO_SPEAKER_RIGHT_SIDE, + ICON_AUDIO_SPEAKER_RIGHT_SIDE_TESTING, + ICON_AUDIO_SPEAKER_RIGHT_TESTING, + ICON_AUDIO_SPEAKERS, + ICON_AUDIO_SPEAKERS_SYMBOLIC, + ICON_AUDIO_SUBWOOFER, + ICON_AUDIO_SUBWOOFER_TESTING, + ICON_BATTERY, + ICON_BATTERY_SYMBOLIC, + ICON_BLUETOOTH, + ICON_BLUETOOTH_SYMBOLIC, + ICON_CAMERA_PHOTO, + ICON_CAMERA_PHOTO_SYMBOLIC, + ICON_CAMERA_VIDEO, + ICON_CAMERA_VIDEO_SYMBOLIC, + ICON_CAMERA_WEB, + ICON_CAMERA_WEB_SYMBOLIC, + ICON_COLORIMETER_COLORHUG_SYMBOLIC, + ICON_COMPUTER_LAPTOP, + ICON_COMPUTER_LAPTOP_SYMBOLIC, + ICON_DISPLAY_PROJECTOR_SYMBOLIC, + ICON_DRIVE_HARDDISK, + ICON_DRIVE_HARDDISK_IEEE1394_SYMBOLIC, + ICON_DRIVE_HARDDISK_SOLIDSTATE, + ICON_DRIVE_HARDDISK_SOLIDSTATE_SYMBOLIC, + ICON_DRIVE_HARDDISK_SYMBOLIC, + ICON_DRIVE_MULTIDISK_SYMBOLIC, + ICON_DRIVE_OPTICAL_SYMBOLIC, + ICON_DRIVE_REMOVABLE_MEDIA, + ICON_DRIVE_REMOVABLE_MEDIA_SYMBOLIC, + ICON_DRIVE_REMOVABLE_MEDIA_USB, + ICON_FINGERPRINT, + ICON_FINGERPRINT_SYMBOLIC, + ICON_GNOME_DEV_PRINTER_NEW, + ICON_INPUT_DIALPAD_SYMBOLIC, + ICON_INPUT_GAMING, + ICON_INPUT_GAMING_SYMBOLIC, + ICON_INPUT_KEYBOARD, + ICON_INPUT_KEYBOARD_SYMBOLIC, + ICON_INPUT_MOUSE, + ICON_INPUT_MOUSE_SYMBOLIC, + ICON_INPUT_TABLET, + ICON_INPUT_TABLET_SYMBOLIC, + ICON_INPUT_TOUCHPAD, + ICON_INPUT_TOUCHPAD_SYMBOLIC, + ICON_MEDIA_FLASH_CF, + ICON_MEDIA_FLASH_MS, + ICON_MEDIA_FLASH_SYMBOLIC, + ICON_MEDIA_FLOPPY_SYMBOLIC, + ICON_MEDIA_MEMORY, + ICON_MEDIA_MEMORY_SD, + ICON_MEDIA_MEMORY_SEMBOLIC, + ICON_MEDIA_MEMORY_SM, + ICON_MEDIA_OPTICAL, + ICON_MEDIA_OPTICAL_SYMBOLIC, + ICON_MEDIA_REMOVABLE_SYMBOLIC, + ICON_MEDIA_TAPE_SYMBOLIC, + ICON_MEDIA_ZIP_SYMBOLIC, + ICON_MODEM, + ICON_MODEM_SYMBOLIC, + ICON_MULTIMEDIA_PLAYER, + ICON_MULTIMEDIA_PLAYER_SYMBOLIC, + ICON_NETWORK_CELLULAR, + ICON_NETWORK_FIREWALL, + ICON_NETWORK_VPN, + ICON_NETWORK_WIRED, + ICON_NETWORK_WIRELESS, + ICON_NETWORK_WIRELESS_HOTSPOT, + ICON_NM_DEVICE_WWAN, + ICON_PDA_SYMBOLIC, + ICON_PHONE, + ICON_PHONE_SYMBOLIC, + ICON_PRINTER, + ICON_PRINTER_NETWORK, + ICON_PRINTER_SYMBOLIC, + ICON_SCANNER, + ICON_SCANNER_SYMBOLIC, + ICON_TABLET, + ICON_TABLET_SYMBOLIC, + ICON_TV_SYMBOLIC, + ICON_UNINTERRUPTIBLE_POWER_SUPPLY, + ICON_UNINTERRUPTIBLE_POWER_SUPPLY_SYMBOLIC, + ICON_VIDEO_DISPLAY, + ICON_VIDEO_DISPLAY_SYMBOLIC, + ICON_EMBLEM_DEFAULT_SYMBOLIC, + ICON_EMBLEM_DOCUMENTS_SYMBOLIC, + ICON_EMBLEM_FAVORITE_SYMBOLIC, + ICON_EMBLEM_IMPORTANT_SYMBOLIC, + ICON_EMBLEM_MUSIC_SYMBOLIC, + ICON_EMBLEM_OK_SYMBOLIC, + ICON_EMBLEM_PHOTOS_SYMBOLIC, + ICON_EMBLEM_READONLY, + ICON_EMBLEM_SHARED_SYMBOLIC, + ICON_EMBLEM_SYMBOLIC_LINK, + ICON_EMBLEM_SYNCHRONIZED, + ICON_EMBLEM_SYNCHRONIZING_SYMBOLIC, + ICON_EMBLEM_UNREADABLE, + ICON_EMBLEM_VIDEOS_SYMBOLIC, + ICON_FACE_ANGEL, + ICON_FACE_ANGEL_SYMBOLIC, + ICON_FACE_ANGRY, + ICON_FACE_ANGRY_SYMBOLIC, + ICON_FACE_COOL, + ICON_FACE_COOL_SYMBOLIC, + ICON_FACE_CRYING, + ICON_FACE_CRYING_SYMBOLIC, + ICON_FACE_DEVILISH, + ICON_FACE_DEVILISH_SYMBOLIC, + ICON_FACE_EMBARRASSED, + ICON_FACE_EMBARRASSED_SYMBOLIC, + ICON_FACE_HEART, + ICON_FACE_HEART_BROKEN, + ICON_FACE_HEART_BROKEN_SYMBOLIC, + ICON_FACE_HEART_SYMBOLIC, + ICON_FACE_KISS, + ICON_FACE_KISS_SYMBOLIC, + ICON_FACE_LAUGH, + ICON_FACE_LAUGH_SYMBOLIC, + ICON_FACE_MONKEY_SYMBOLIC, + ICON_FACE_PLAIN, + ICON_FACE_PLAIN_SYMBOLIC, + ICON_FACE_RASPBERRY, + ICON_FACE_RASPBERRY_SYMBOLIC, + ICON_FACE_SAD, + ICON_FACE_SAD_SYMBOLIC, + ICON_FACE_SICK, + ICON_FACE_SICK_SYMBOLIC, + ICON_FACE_SMILE, + ICON_FACE_SMILE_BIG, + ICON_FACE_SMILE_BIG_SYMBOLIC, + ICON_FACE_SMILE_SYMBOLIC, + ICON_FACE_SMIRK, + ICON_FACE_SMIRK_SYMBOLIC, + ICON_FACE_SURPRISE, + ICON_FACE_SURPRISE_SYMBOLIC, + ICON_FACE_TIRED, + ICON_FACE_TIRED_SYMBOLIC, + ICON_FACE_UNCERTAIN, + ICON_FACE_UNCERTAIN_SYMBOLIC, + ICON_FACE_WINK, + ICON_FACE_WINK_SYMBOLIC, + ICON_FACE_WORRIED, + ICON_FACE_WORRIED_SYMBOLIC, + ICON_APPLICATION_CERTIFICATE_SYMBOLIC, + ICON_APPLICATION_EPUB_ZIP, + ICON_APPLICATION_ILLUSTRATOR, + ICON_APPLICATION_JAVASCRIPT, + ICON_APPLICATION_MSWORD, + ICON_APPLICATION_OCTET_STREAM, + ICON_APPLICATION_PDF, + ICON_APPLICATION_PGP, + ICON_APPLICATION_RSS_XML_SYMBOLIC, + ICON_APPLICATION_VND, + ICON_APPLICATION_X_APPLIANCE_SYMBOLIC, + ICON_APPLICATION_X_BITTORRENT, + ICON_APPLICATION_X_CD_IMAGE, + ICON_APPLICATION_X_DESKTOP, + ICON_APPLICATION_X_EXECUTABLE_SYMBOLIC, + ICON_APPLICATION_X_FICTIONBOOK_XML, + ICON_APPLICATION_X_FIRMWARE, + ICON_APPLICATION_X_FIRMWARE_SYMBOLIC, + ICON_APPLICATION_X_FLASH_VIDEO, + ICON_APPLICATION_X_MS_DOS_EXECUTABLE, + ICON_APPLICATION_X_PARTIAL_DOWNLOAD, + ICON_APPLICATION_X_PHP, + ICON_APPLICATION_X_RUBY, + ICON_AUDIO_X_GENERIC, + ICON_AUDIO_X_GENERIC_SYMBOLIC, + ICON_AUDIO_X_PLAYLIST, + ICON_EXTENSION, + ICON_FONT_X_GENERIC, + ICON_FONT_X_GENERIC_SYMBOLIC, + ICON_IMAGE_VND, + ICON_IMAGE_X_GENERIC, + ICON_IMAGE_X_GENERIC_SYMBOLIC, + ICON_IMAGE_X_XCF, + ICON_INTERNET_FEED, + ICON_MODEL, + ICON_OFFICE_CONTACT, + ICON_OFFICE_DATABASE, + ICON_PACKAGE_X_GENERIC, + ICON_PACKAGE_X_GENERIC_SYMBOLIC, + ICON_PAYMENT_CARD, + ICON_PAYMENT_CARD_AMEX, + ICON_PAYMENT_CARD_DINERS_CLUB, + ICON_PAYMENT_CARD_DISCOVER, + ICON_PAYMENT_CARD_JCB, + ICON_PAYMENT_CARD_MASTERCARD, + ICON_PAYMENT_CARD_SYMBOLIC, + ICON_PAYMENT_CARD_UNIONPAY, + ICON_PAYMENT_CARD_VISA, + ICON_TEXT, + ICON_TEXT_CSS, + ICON_TEXT_HTML, + ICON_TEXT_HTML_SYMBOLIC, + ICON_TEXT_MARKDOWN, + ICON_TEXT_X_BIBTEX, + ICON_TEXT_X_CHANGELOG, + ICON_TEXT_X_CHDR, + ICON_TEXT_X_COPYING, + ICON_TEXT_X_COPYING_SYMBOLIC, + ICON_TEXT_X_CSRC, + ICON_TEXT_X_GENERIC_SYMBOLIC, + ICON_TEXT_X_GENERIC_TEMPLATE, + ICON_TEXT_X_GETTEXT_TRANSLATION, + ICON_TEXT_X_GETTEXT_TRANSLATION_TEMPLATE, + ICON_TEXT_X_GO, + ICON_TEXT_X_INSTALL, + ICON_TEXT_X_MAKEFILE, + ICON_TEXT_X_PREVIEW, + ICON_TEXT_X_PYTHON, + ICON_TEXT_X_README, + ICON_TEXT_X_SASS, + ICON_TEXT_X_SCRIPT, + ICON_TEXT_X_SSA, + ICON_TEXT_X_TEX, + ICON_TEXT_X_VALA, + ICON_UNKNOWN, + ICON_VIDEO_X_GENERIC, + ICON_VIDEO_X_GENERIC_SYMBOLIC, + ICON_X_OFFICE_ADDRESS_BOOK_SYMBOLIC, + ICON_X_OFFICE_DOCUMENT, + ICON_X_OFFICE_DOCUMENT_SYMBOLIC, + ICON_X_OFFICE_DOCUMENT_TEMPLATE, + ICON_X_OFFICE_DRAWING, + ICON_X_OFFICE_DRAWING_SYMBOLIC, + ICON_X_OFFICE_DRAWING_TEMPLATE, + ICON_X_OFFICE_PRESENTATION, + ICON_X_OFFICE_PRESENTATION_SYMBOLIC, + ICON_X_OFFICE_PRESENTATION_TEMPLATE, + ICON_X_OFFICE_SPREADSHEET, + ICON_X_OFFICE_SPREADSHEET_SYMBOLIC, + ICON_X_OFFICE_SPREADSHEET_TEMPLATE, + ICON_BOOKMARK_MISSING, + ICON_DISTRIBUTOR_LOGO, + ICON_DISTRIBUTOR_LOGO_SYMBOLIC, + ICON_FOLDER, + ICON_FOLDER_DOCUMENTS, + ICON_FOLDER_DOCUMENTS_OPEN, + ICON_FOLDER_DOCUMENTS_SYMBOLIC, + ICON_FOLDER_DOWNLOAD, + ICON_FOLDER_DOWNLOAD_OPEN, + ICON_FOLDER_DOWNLOAD_SYMBOLIC, + ICON_FOLDER_MUSIC, + ICON_FOLDER_MUSIC_OPEN, + ICON_FOLDER_MUSIC_SYMBOLIC, + ICON_FOLDER_OPEN, + ICON_FOLDER_PICTURES, + ICON_FOLDER_PICTURES_OPEN, + ICON_FOLDER_PICTURES_SYMBOLIC, + ICON_FOLDER_PUBLICSHARE, + ICON_FOLDER_PUBLICSHARE_OPEN, + ICON_FOLDER_PUBLICSHARE_SYMBOLIC, + ICON_FOLDER_RECENT, + ICON_FOLDER_RECENT_SYMBOLIC, + ICON_FOLDER_REMOTE, + ICON_FOLDER_REMOTE_OPEN, + ICON_FOLDER_SAVED_SEARCH, + ICON_FOLDER_SYMBOLIC, + ICON_FOLDER_TAG, + ICON_FOLDER_TEMPLATES, + ICON_FOLDER_TEMPLATES_OPEN, + ICON_FOLDER_TEMPLATES_SYMBOLIC, + ICON_FOLDER_VIDEOS, + ICON_FOLDER_VIDEOS_OPEN, + ICON_FOLDER_VIDEOS_SYMBOLIC, + ICON_INTERNET_RADIO, + ICON_INTERNET_RADIO_SYMBOLIC, + ICON_LIBRARY_AUDIOBOOK, + ICON_LIBRARY_PLACES, + ICON_LIBRARY_PODCAST, + ICON_MAIL_INBOX, + ICON_MAIL_INBOX_SYMBOLIC, + ICON_MAIL_MAILBOX, + ICON_MAIL_MAILBOX_SYMBOLIC, + ICON_MAIL_OUTBOX, + ICON_MAIL_OUTBOX_SYMBOLIC, + ICON_NETWORK_SERVER_SYMBOLIC, + ICON_PLAYLIST, + ICON_PLAYLIST_AUTOMATIC, + ICON_PLAYLIST_QUEUE, + ICON_PLAYLIST_QUEUE_SYMBOLIC, + ICON_PLAYLIST_SIMILAR, + ICON_PLAYLIST_SYMBOLIC, + ICON_TAG_SYMBOLIC, + ICON_USER_BOOKMARKS_SYMBOLIC, + ICON_USER_HOME, + ICON_USER_HOME_OPEN, + ICON_USER_HOME_SYMBOLIC, + ICON_USER_TRASH, + ICON_USER_TRASH_FULL, + ICON_USER_TRASH_SYMBOLIC, + ICON_AIRPLANE_MODE, + ICON_AIRPLANE_MODE_SYMBOLIC, + ICON_ALARM_SYMBOLIC, + ICON_APPOINTMENT_MISSED, + ICON_APPOINTMENT_MISSED_SYMBOLIC, + ICON_APPOINTMENT_SOON, + ICON_APPOINTMENT_SOON_SYMBOLIC, + ICON_AUDIO_VOLUME_HIGH_SYMBOLIC, + ICON_AUDIO_VOLUME_LOW_SYMBOLIC, + ICON_AUDIO_VOLUME_MEDIUM_SYMBOLIC, + ICON_AUDIO_VOLUME_MUTED_BLOCKING_SYMBOLIC, + ICON_AUDIO_VOLUME_MUTED_SYMBOLIC, + ICON_AVATAR_DEFAULT, + ICON_AVATAR_DEFAULT_SYMBOLIC, + ICON_BATTERY_AC_ADAPTER, + ICON_BATTERY_AC_ADAPTER_SYMBOLIC, + ICON_BATTERY_CAUTION, + ICON_BATTERY_CAUTION_CHARGING, + ICON_BATTERY_CAUTION_CHARGING_SYMBOLIC, + ICON_BATTERY_CAUTION_SYMBOLIC, + ICON_BATTERY_EMPTY, + ICON_BATTERY_EMPTY_CHARGING, + ICON_BATTERY_EMPTY_CHARGING_SYMBOLIC, + ICON_BATTERY_EMPTY_SYMBOLIC, + ICON_BATTERY_FULL, + ICON_BATTERY_FULL_CHARGED, + ICON_BATTERY_FULL_CHARGED_SYMBOLIC, + ICON_BATTERY_FULL_CHARGING, + ICON_BATTERY_FULL_CHARGING_SYMBOLIC, + ICON_BATTERY_FULL_SYMBOLIC, + ICON_BATTERY_GOOD, + ICON_BATTERY_GOOD_CHARGING, + ICON_BATTERY_GOOD_CHARGING_SYMBOLIC, + ICON_BATTERY_GOOD_SYMBOLIC, + ICON_BATTERY_LOW, + ICON_BATTERY_LOW_CHARGING, + ICON_BATTERY_LOW_CHARGING_SYMBOLIC, + ICON_BATTERY_LOW_SYMBOLIC, + ICON_BATTERY_MISSING, + ICON_BATTERY_MISSING_SYMBOLIC, + ICON_BLUETOOTH_ACTIVE_SYMBOLIC, + ICON_BLUETOOTH_DISABLED, + ICON_BLUETOOTH_DISABLED_10_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_20_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_30_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_40_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_50_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_60_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_70_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_80_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_90_SYMBOLIC, + ICON_BLUETOOTH_DISABLED_SYMBOLIC, + ICON_BLUETOOTH_PAIRED_SYMBOLIC, + ICON_CALL_MISSED_SYMBOLIC, + ICON_CHANGES_ALLOW, + ICON_CHANGES_ALLOW_SYMBOLIC, + ICON_CHANGES_PREVENT_SYMBOLIC, + ICON_CHANNEL_INSECURE_SYMBOLIC, + ICON_CHANNEL_SECURE_SYMBOLIC, + ICON_CHECK_ACTIVE_SYMBOLIC, + ICON_CHECK_MIXED_SYMBOLIC, + ICON_CHECKBOX_CHECKED_SYMBOLIC, + ICON_CHECKBOX_MIXED_SYMBOLIC, + ICON_CHECKBOX_SYMBOLIC, + ICON_COMPUTER_FAIL_SYMBOLIC, + ICON_CONTENT_LOADING_SYMBOLIC, + ICON_DAYTIME_SUNRISE_SYMBOLIC, + ICON_DAYTIME_SUNSET_SYMBOLIC, + ICON_DIALOG_ERROR, + ICON_DIALOG_ERROR_SYMBOLIC, + ICON_DIALOG_INFORMATION, + ICON_DIALOG_INFORMATION_SYMBOLIC, + ICON_DIALOG_PASSWORD, + ICON_DIALOG_PASSWORD_SYMBOLIC, + ICON_DIALOG_WARNING, + ICON_DIALOG_WARNING_SYMBOLIC, + ICON_DISPLAY_BRIGHTNESS_SYMBOLIC, + ICON_FOLDER_OPEN_SYMBOLIC, + ICON_FOLDER_VISITING_SYMBOLIC, + ICON_IMAGE_LOADING, + ICON_IMAGE_MISSING, + ICON_INPUT_KEYBOARD_CAPSLOCK_SYMBOLIC, + ICON_INPUT_KEYBOARD_NUMLOCK_SYMBOLIC, + ICON_KEYBOARD_BRIGHTNESS_SYMBOLIC, + ICON_LOCATION_ACTIVE_SYMBOLIC, + ICON_LOCATION_DISABLED_SYMBOLIC, + ICON_LOCATION_INACTIVE_SYMBOLIC, + ICON_LOCKED, + ICON_MAIL_ATTACHMENT_SYMBOLIC, + ICON_MAIL_FORWARDED_SYMBOLIC, + ICON_MAIL_IMPORTANT_SYMBOLIC, + ICON_MAIL_READ_SYMBOLIC, + ICON_MAIL_REPLIED_SYMBOLIC, + ICON_MAIL_UNREAD, + ICON_MAIL_UNREAD_SYMBOLIC, + ICON_MEDIA_PLAYLIST_CONSECUTIVE_SYMBOLIC, + ICON_MEDIA_PLAYLIST_NO_REPEAT_SYMBOLIC, + ICON_MEDIA_PLAYLIST_REPEAT, + ICON_MEDIA_PLAYLIST_REPEAT_SONG_SYMBOLIC, + ICON_MEDIA_PLAYLIST_REPEAT_SYMBOLIC, + ICON_MEDIA_PLAYLIST_SHUFFLE_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_HIGH_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_LOW_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MEDIUM_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_10_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_20_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_30_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_40_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_50_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_60_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_70_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_80_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_90_SYMBOLIC, + ICON_MICROPHONE_SENSITIVITY_MUTED_SYMBOLIC, + ICON_NETWORK_CELLULAR_ACQUIRING_SYMBOLIC, + ICON_NETWORK_CELLULAR_CONNECTED_SYMBOLIC, + ICON_NETWORK_CELLULAR_NO_ROUTE_SYMBOLIC, + ICON_NETWORK_CELLULAR_OFFLINE_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_EXCELLENT_SECURE_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_EXCELLENT_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_GOOD_SECURE_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_GOOD_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_NONE_SECURE_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_NONE_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_OK_SECURE_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_OK_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_WEAK_SECURE_SYMBOLIC, + ICON_NETWORK_CELLULAR_SIGNAL_WEAK_SYMBOLIC, + ICON_NETWORK_ERROR, + ICON_NETWORK_ERROR_SYMBOLIC, + ICON_NETWORK_IDLE, + ICON_NETWORK_OFFLINE_SYMBOLIC, + ICON_NETWORK_VPN_ACQUIRING_SYMBOLIC, + ICON_NETWORK_VPN_LOCK_SYMBOLIC, + ICON_NETWORK_VPN_SYMBOLIC, + ICON_NETWORK_WIRED_ACQUIRING_SYMBOLIC, + ICON_NETWORK_WIRED_DISCONNECTED, + ICON_NETWORK_WIRED_NO_ROUTE_SYMBOLIC, + ICON_NETWORK_WIRED_OFFLINE_SYMBOLIC, + ICON_NETWORK_WIRED_SYMBOLIC, + ICON_NETWORK_WIRELESS_ACQUIRING_SYMBOLIC, + ICON_NETWORK_WIRELESS_CONNECTED_SYMBOLIC, + ICON_NETWORK_WIRELESS_ENCRYPTED_SYMBOLIC, + ICON_NETWORK_WIRELESS_HOTSPOT_SYMBOLIC, + ICON_NETWORK_WIRELESS_NO_ROUTE_SYMBOLIC, + ICON_NETWORK_WIRELESS_OFFLINE_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_EXCELLENT_SECURE_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_EXCELLENT_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_GOOD_SECURE_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_GOOD_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_NONE_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_OK_SECURE_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_OK_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_WEAK_SECURE_SYMBOLIC, + ICON_NETWORK_WIRELESS_SIGNAL_WEAK_SYMBOLIC, + ICON_NETWORK_WIRELESS_SYMBOLIC, + ICON_NIGHT_LIGHT, + ICON_NIGHT_LIGHT_DISABLED_10_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_20_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_30_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_40_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_50_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_60_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_70_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_80_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_90_SYMBOLIC, + ICON_NIGHT_LIGHT_DISABLED_SYMBOLIC, + ICON_NIGHT_LIGHT_SYMBOLIC, + ICON_NM_NO_CONNECTION, + ICON_NM_SIGNAL_0, + ICON_NM_SIGNAL_0_SECURE, + ICON_NM_SIGNAL_100, + ICON_NM_SIGNAL_100_SECURE, + ICON_NM_SIGNAL_25, + ICON_NM_SIGNAL_25_SECURE, + ICON_NM_SIGNAL_50, + ICON_NM_SIGNAL_50_SECURE, + ICON_NM_SIGNAL_75, + ICON_NM_SIGNAL_75_SECURE, + ICON_NM_VPN_ACTIVE_LOCK, + ICON_NM_VPN_LOCK, + ICON_NON_STARRED, + ICON_NON_STARRED_SYMBOLIC, + ICON_NOTIFICATION_AUDIO_VOLUME_HIGH, + ICON_NOTIFICATION_AUDIO_VOLUME_LOW, + ICON_NOTIFICATION_AUDIO_VOLUME_MEDIUM, + ICON_NOTIFICATION_AUDIO_VOLUME_MUTED, + ICON_NOTIFICATION_DEVICE_EJECT, + ICON_NOTIFICATION_DISABLED, + ICON_NOTIFICATION_DISABLED_10_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_20_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_30_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_40_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_50_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_60_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_70_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_80_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_90_SYMBOLIC, + ICON_NOTIFICATION_DISABLED_SYMBOLIC, + ICON_NOTIFICATION_DISPLAY_BRIGHTNESS, + ICON_NOTIFICATION_KEYBOARD_BRIGHTNESS, + ICON_NOTIFICATION_NETWORK_ETHERNET_DISCONNECTED, + ICON_NOTIFICATION_NETWORK_WIRED, + ICON_NOTIFICATION_NETWORK_WIRELESS, + ICON_NOTIFICATION_NETWORK_WIRELESS_DISCONNECTED, + ICON_NOTIFICATION_NETWORK_WIRELESS_DISCONNECTED_SYMBOLIC, + ICON_NOTIFICATION_NETWORK_WIRELESS_SYMBOLIC, + ICON_NOTIFICATION_NEW_10_SYMBOLIC, + ICON_NOTIFICATION_NEW_20_SYMBOLIC, + ICON_NOTIFICATION_NEW_30_SYMBOLIC, + ICON_NOTIFICATION_NEW_40_SYMBOLIC, + ICON_NOTIFICATION_NEW_50_SYMBOLIC, + ICON_NOTIFICATION_NEW_60_SYMBOLIC, + ICON_NOTIFICATION_NEW_70_SYMBOLIC, + ICON_NOTIFICATION_NEW_80_SYMBOLIC, + ICON_NOTIFICATION_NEW_90_SYMBOLIC, + ICON_NOTIFICATION_NEW_SYMBOLIC, + ICON_NOTIFICATION_SYMBOLIC, + ICON_PAGER_CHECKED_SYMBOLIC, + ICON_PRINTER_ERROR, + ICON_PRINTER_ERROR_SYMBOLIC, + ICON_PRINTER_PRINTING_SYMBOLIC, + ICON_PRINTER_WARNING_SYMBOLIC, + ICON_PROCESS_COMPLETED, + ICON_PROCESS_COMPLETED_SYMBOLIC, + ICON_PROCESS_ERROR_SYMBOLIC, + ICON_PROCESS_WORKING_SYMBOLIC, + ICON_RADIO_CHECKED_SYMBOLIC, + ICON_RADIO_MIXED_SYMBOLIC, + ICON_RADIO_SYMBOLIC, + ICON_ROTATION_ALLOWED_SYMBOLIC, + ICON_ROTATION_LOCKED_SYMBOLIC, + ICON_SECURITY_HIGH, + ICON_SECURITY_HIGH_SYMBOLIC, + ICON_SECURITY_LOW, + ICON_SECURITY_LOW_SYMBOLIC, + ICON_SECURITY_MEDIUM, + ICON_SECURITY_MEDIUM_SYMBOLIC, + ICON_SEMI_STARRED, + ICON_SEMI_STARRED_SYMBOLIC, + ICON_SOFTWARE_UPDATE_AVAILABLE_SYMBOLIC, + ICON_SOFTWARE_UPDATE_URGENT_SYMBOLIC, + ICON_STARRED, + ICON_STARRED_SYMBOLIC, + ICON_TASK_DUE_SYMBOLIC, + ICON_TASK_PAST_DUE_SYMBOLIC, + ICON_TOUCHPAD_DISABLED_SYMBOLIC, + ICON_USER_AVAILABLE, + ICON_USER_AVAILABLE_SYMBOLIC, + ICON_USER_AWAY, + ICON_USER_AWAY_SYMBOLIC, + ICON_USER_BUSY, + ICON_USER_BUSY_SYMBOLIC, + ICON_USER_IDLE_SYMBOLIC, + ICON_USER_INVISIBLE, + ICON_USER_INVISIBLE_SYMBOLIC, + ICON_USER_OFFLINE, + ICON_USER_OFFLINE_SYMBOLIC, + ICON_USER_STATUS_PENDING_SYMBOLIC, + ICON_USER_TRASH_FULL_SYMBOLIC, + ICON_USER_TYPING, + ICON_VIEW_PRIVATE, + ICON_VIEW_PRIVATE_SYMBOLIC, + ICON_VIEW_WRAPPED_SYMBOLIC, + ICON_WEATHER_CLEAR_NIGHT_SYMBOLIC, + ICON_WEATHER_CLEAR_SYMBOLIC, + ICON_WEATHER_FEW_CLOUDS_NIGHT_SYMBOLIC, + ICON_WEATHER_FEW_CLOUDS_SYMBOLIC, + ICON_WEATHER_FOG_NIGHT_SYMBOLIC, + ICON_WEATHER_FOG_SYMBOLIC, + ICON_WEATHER_OVERCAST_NIGHT_SYMBOLIC, + ICON_WEATHER_OVERCAST_SYMBOLIC, + ICON_WEATHER_SEVERE_ALERT_SYMBOLIC, + ICON_WEATHER_SHOWERS_NIGHT_SYMBOLIC, + ICON_WEATHER_SHOWERS_SCATTERED_NIGHT_SYMBOLIC, + ICON_WEATHER_SHOWERS_SCATTERED_SYMBOLIC, + ICON_WEATHER_SHOWERS_SYMBOLIC, + ICON_WEATHER_SNOW_NIGHT_SYMBOLIC, + ICON_WEATHER_SNOW_SYMBOLIC, + ICON_WEATHER_STORM_NIGHT_SYMBOLIC, + ICON_WEATHER_STORM_SYMBOLIC, + ICON_WEATHER_STORM_TORNADO_NIGHT_SYMBOLIC, + ICON_WEATHER_STORM_TORNADO_SYMBOLIC, + ICON_WEATHER_WINDY_SYMBOLIC, } -EsSyscallType :: enum { - ES_SYSCALL_ALLOCATE, - ES_SYSCALL_FREE, - ES_SYSCALL_SHARE_MEMORY, - ES_SYSCALL_MAP_OBJECT, - ES_SYSCALL_OPEN_SHARED_MEMORY, - ES_SYSCALL_CREATE_PROCESS, - ES_SYSCALL_GET_CREATION_ARGUMENT, - ES_SYSCALL_TERMINATE_THREAD, - ES_SYSCALL_CREATE_THREAD, - ES_SYSCALL_WAIT, - ES_SYSCALL_TERMINATE_PROCESS, - ES_SYSCALL_CREATE_EVENT, - ES_SYSCALL_SET_EVENT, - ES_SYSCALL_RESET_EVENT, - ES_SYSCALL_POLL_EVENT, - ES_SYSCALL_PAUSE_PROCESS, - ES_SYSCALL_CRASH_PROCESS, - ES_SYSCALL_GET_THREAD_ID, - ES_SYSCALL_GET_PROCESS_STATE, - ES_SYSCALL_YIELD_SCHEDULER, - ES_SYSCALL_SLEEP, - ES_SYSCALL_OPEN_PROCESS, - ES_SYSCALL_SET_TLS, - ES_SYSCALL_TIMER_SET, - ES_SYSCALL_TIMER_CREATE, - ES_SYSCALL_GET_PROCESS_STATUS, - ES_SYSCALL_CREATE_SURFACE, - ES_SYSCALL_GET_LINEAR_BUFFER, - ES_SYSCALL_INVALIDATE_RECTANGLE, - ES_SYSCALL_COPY_TO_SCREEN, - ES_SYSCALL_FORCE_SCREEN_UPDATE, - ES_SYSCALL_FILL_RECTANGLE, - ES_SYSCALL_COPY_SURFACE, - ES_SYSCALL_CLEAR_MODIFIED_REGION, - ES_SYSCALL_DRAW_SURFACE, - ES_SYSCALL_REDRAW_ALL, - ES_SYSCALL_DRAW_BOX, - ES_SYSCALL_DRAW_BITMAP, - ES_SYSCALL_SURFACE_RESET, - ES_SYSCALL_SURFACE_SHARE, - ES_SYSCALL_DRAW_STYLED_BOX, - ES_SYSCALL_SURFACE_SCROLL, - ES_SYSCALL_RESIZE_SURFACE, - ES_SYSCALL_GET_MESSAGE, - ES_SYSCALL_POST_MESSAGE, - ES_SYSCALL_POST_MESSAGE_REMOTE, - ES_SYSCALL_WAIT_MESSAGE, - ES_SYSCALL_CREATE_WINDOW, - ES_SYSCALL_UPDATE_WINDOW, - ES_SYSCALL_SET_CURSOR_STYLE, - ES_SYSCALL_MOVE_WINDOW, - ES_SYSCALL_GET_WINDOW_BOUNDS, - ES_SYSCALL_RESET_CLICK_CHAIN, - ES_SYSCALL_GET_CURSOR_POSITION, - ES_SYSCALL_SET_CURSOR_POSITION, - ES_SYSCALL_COPY, - ES_SYSCALL_GET_CLIPBOARD_HEADER, - ES_SYSCALL_PASTE_TEXT, - ES_SYSCALL_SET_FOCUSED_WINDOW, - ES_SYSCALL_SET_WINDOW_TITLE, - ES_SYSCALL_GET_SCREEN_BOUNDS, - ES_SYSCALL_WINDOW_OPEN, - ES_SYSCALL_WINDOW_SET_BLEND_BOUNDS, - ES_SYSCALL_WINDOW_GET_BLEND_BOUNDS, - ES_SYSCALL_WINDOW_GET_ID, - ES_SYSCALL_SET_WINDOW_ALPHA, - ES_SYSCALL_DOCKED_WINDOW_CREATE, - ES_SYSCALL_WINDOW_SHARE, - ES_SYSCALL_SET_EMBED_WINDOW, - ES_SYSCALL_OPEN_NODE, - ES_SYSCALL_READ_FILE_SYNC, - ES_SYSCALL_WRITE_FILE_SYNC, - ES_SYSCALL_RESIZE_FILE, - ES_SYSCALL_REFRESH_NODE_INFORMATION, - ES_SYSCALL_ENUMERATE_DIRECTORY_CHILDREN, - ES_SYSCALL_DELETE_NODE, - ES_SYSCALL_MOVE_NODE, - ES_SYSCALL_READ_CONSTANT_BUFFER, - ES_SYSCALL_SHARE_CONSTANT_BUFFER, - ES_SYSCALL_CREATE_CONSTANT_BUFFER, - ES_SYSCALL_EXECUTE, - ES_SYSCALL_INSTANCE_CREATE_REMOTE, - ES_SYSCALL_MAILSLOT_SEND_DATA, - ES_SYSCALL_MAILSLOT_SEND_MESSAGE, - ES_SYSCALL_MAILSLOT_SHARE, - ES_SYSCALL_PIPE_CREATE, - ES_SYSCALL_PIPE_WRITE, - ES_SYSCALL_PIPE_READ, - ES_SYSCALL_USER_GET_HOME_FOLDER, - ES_SYSCALL_USER_LOGIN, - ES_SYSCALL_GET_SYSTEM_CONSTANTS, - ES_SYSCALL_TAKE_SYSTEM_SNAPSHOT, - ES_SYSCALL_SET_SYSTEM_CONSTANT, - ES_SYSCALL_GET_SYSTEM_INFORMATION, - ES_SYSCALL_PRINT, - ES_SYSCALL_CLOSE_HANDLE, - ES_SYSCALL_BATCH, - ES_SYSCALL_SHUTDOWN, - ES_SYSCALL_POSIX, - ES_SYSCALL_COUNT, +FatalError :: enum { + FATAL_ERROR_INVALID_BUFFER, + FATAL_ERROR_UNKNOWN_SYSCALL, + FATAL_ERROR_INVALID_MEMORY_REGION, + FATAL_ERROR_MEMORY_REGION_LOCKED_BY_KERNEL, + FATAL_ERROR_PATH_LENGTH_EXCEEDS_LIMIT, + FATAL_ERROR_INVALID_HANDLE, + FATAL_ERROR_MUTEX_NOT_ACQUIRED_BY_THREAD, + FATAL_ERROR_MUTEX_ALREADY_ACQUIRED, + FATAL_ERROR_BUFFER_NOT_ACCESSIBLE, + FATAL_ERROR_SHARED_MEMORY_REGION_TOO_LARGE, + FATAL_ERROR_SHARED_MEMORY_STILL_MAPPED, + FATAL_ERROR_COULD_NOT_LOAD_FONT, + FATAL_ERROR_COULD_NOT_DRAW_FONT, + FATAL_ERROR_COULD_NOT_ALLOCATE_MEMORY, + FATAL_ERROR_INCORRECT_FILE_ACCESS, + FATAL_ERROR_TOO_MANY_WAIT_OBJECTS, + FATAL_ERROR_INCORRECT_NODE_TYPE, + FATAL_ERROR_PROCESSOR_EXCEPTION, + FATAL_ERROR_UNKNOWN, + FATAL_ERROR_RECURSIVE_BATCH, + FATAL_ERROR_CORRUPT_HEAP, + FATAL_ERROR_CORRUPT_LINKED_LIST, + FATAL_ERROR_INDEX_OUT_OF_BOUNDS, + FATAL_ERROR_INVALID_STRING_LENGTH, + FATAL_ERROR_SPINLOCK_NOT_ACQUIRED, + FATAL_ERROR_UNKNOWN_SNAPSHOT_TYPE, + FATAL_ERROR_PROCESS_ALREADY_ATTACHED, + FATAL_ERROR_INTERNAL, + FATAL_ERROR_INSUFFICIENT_PERMISSIONS, + FATAL_ERROR_ABORT, + FATAL_ERROR_COUNT, } -EsStandardFont :: enum { - ES_STANDARD_FONT_REGULAR, - ES_STANDARD_FONT_BOLD, - ES_STANDARD_FONT_MONOSPACED, +SyscallType :: enum { + SYSCALL_ALLOCATE, + SYSCALL_FREE, + SYSCALL_SHARE_MEMORY, + SYSCALL_MAP_OBJECT, + SYSCALL_OPEN_SHARED_MEMORY, + SYSCALL_CREATE_PROCESS, + SYSCALL_GET_CREATION_ARGUMENT, + SYSCALL_TERMINATE_THREAD, + SYSCALL_CREATE_THREAD, + SYSCALL_WAIT, + SYSCALL_TERMINATE_PROCESS, + SYSCALL_CREATE_EVENT, + SYSCALL_SET_EVENT, + SYSCALL_RESET_EVENT, + SYSCALL_POLL_EVENT, + SYSCALL_PAUSE_PROCESS, + SYSCALL_CRASH_PROCESS, + SYSCALL_GET_THREAD_ID, + SYSCALL_GET_PROCESS_STATE, + SYSCALL_YIELD_SCHEDULER, + SYSCALL_SLEEP, + SYSCALL_OPEN_PROCESS, + SYSCALL_SET_TLS, + SYSCALL_TIMER_SET, + SYSCALL_TIMER_CREATE, + SYSCALL_GET_PROCESS_STATUS, + SYSCALL_CREATE_SURFACE, + SYSCALL_GET_LINEAR_BUFFER, + SYSCALL_INVALIDATE_RECTANGLE, + SYSCALL_COPY_TO_SCREEN, + SYSCALL_FORCE_SCREEN_UPDATE, + SYSCALL_FILL_RECTANGLE, + SYSCALL_COPY_SURFACE, + SYSCALL_CLEAR_MODIFIED_REGION, + SYSCALL_DRAW_SURFACE, + SYSCALL_REDRAW_ALL, + SYSCALL_DRAW_BOX, + SYSCALL_DRAW_BITMAP, + SYSCALL_SURFACE_RESET, + SYSCALL_SURFACE_SHARE, + SYSCALL_DRAW_STYLED_BOX, + SYSCALL_SURFACE_SCROLL, + SYSCALL_RESIZE_SURFACE, + SYSCALL_GET_MESSAGE, + SYSCALL_POST_MESSAGE, + SYSCALL_POST_MESSAGE_REMOTE, + SYSCALL_WAIT_MESSAGE, + SYSCALL_CREATE_WINDOW, + SYSCALL_UPDATE_WINDOW, + SYSCALL_SET_CURSOR_STYLE, + SYSCALL_MOVE_WINDOW, + SYSCALL_GET_WINDOW_BOUNDS, + SYSCALL_RESET_CLICK_CHAIN, + SYSCALL_GET_CURSOR_POSITION, + SYSCALL_SET_CURSOR_POSITION, + SYSCALL_COPY, + SYSCALL_GET_CLIPBOARD_HEADER, + SYSCALL_PASTE_TEXT, + SYSCALL_SET_FOCUSED_WINDOW, + SYSCALL_SET_WINDOW_TITLE, + SYSCALL_GET_SCREEN_BOUNDS, + SYSCALL_WINDOW_OPEN, + SYSCALL_WINDOW_SET_BLEND_BOUNDS, + SYSCALL_WINDOW_GET_BLEND_BOUNDS, + SYSCALL_WINDOW_GET_ID, + SYSCALL_SET_WINDOW_ALPHA, + SYSCALL_DOCKED_WINDOW_CREATE, + SYSCALL_WINDOW_SHARE, + SYSCALL_SET_EMBED_WINDOW, + SYSCALL_OPEN_NODE, + SYSCALL_READ_FILE_SYNC, + SYSCALL_WRITE_FILE_SYNC, + SYSCALL_RESIZE_FILE, + SYSCALL_REFRESH_NODE_INFORMATION, + SYSCALL_ENUMERATE_DIRECTORY_CHILDREN, + SYSCALL_DELETE_NODE, + SYSCALL_MOVE_NODE, + SYSCALL_READ_CONSTANT_BUFFER, + SYSCALL_SHARE_CONSTANT_BUFFER, + SYSCALL_CREATE_CONSTANT_BUFFER, + SYSCALL_EXECUTE, + SYSCALL_INSTANCE_CREATE_REMOTE, + SYSCALL_MAILSLOT_SEND_DATA, + SYSCALL_MAILSLOT_SEND_MESSAGE, + SYSCALL_MAILSLOT_SHARE, + SYSCALL_PIPE_CREATE, + SYSCALL_PIPE_WRITE, + SYSCALL_PIPE_READ, + SYSCALL_USER_GET_HOME_FOLDER, + SYSCALL_USER_LOGIN, + SYSCALL_GET_SYSTEM_CONSTANTS, + SYSCALL_TAKE_SYSTEM_SNAPSHOT, + SYSCALL_SET_SYSTEM_CONSTANT, + SYSCALL_GET_SYSTEM_INFORMATION, + SYSCALL_PRINT, + SYSCALL_CLOSE_HANDLE, + SYSCALL_BATCH, + SYSCALL_SHUTDOWN, + SYSCALL_POSIX, + SYSCALL_COUNT, } -EsMessageType :: enum { - ES_MESSAGE_WM_START = 0x1000, - ES_MESSAGE_MOUSE_MOVED = 0x1001, - ES_MESSAGE_WINDOW_ACTIVATED = 0x1003, - ES_MESSAGE_WINDOW_DEACTIVATED = 0x1004, - ES_MESSAGE_WINDOW_DESTROYED = 0x1005, - ES_MESSAGE_MOUSE_EXIT = 0x1006 , - ES_MESSAGE_CLICK_REPEAT = 0x1009, - ES_MESSAGE_WINDOW_RESIZED = 0x100B, - ES_MESSAGE_MOUSE_LEFT_PRESSED = 0x100C , - ES_MESSAGE_MOUSE_LEFT_RELEASED = 0x100D, - ES_MESSAGE_MOUSE_RIGHT_PRESSED = 0x100E, - ES_MESSAGE_MOUSE_RIGHT_RELEASED = 0x100F, - ES_MESSAGE_MOUSE_MIDDLE_PRESSED = 0x1010, - ES_MESSAGE_MOUSE_MIDDLE_RELEASED = 0x1011 , - ES_MESSAGE_KEY_PRESSED = 0x1012, - ES_MESSAGE_KEY_RELEASED = 0x1013, - ES_MESSAGE_UPDATE_WINDOW = 0x1014, - ES_MESSAGE_WM_END = 0x13FF, - ES_MESSAGE_PAINT = 0x2000 , - ES_MESSAGE_DESTROY = 0x2001 , - ES_MESSAGE_MEASURE = 0x2002 , - ES_MESSAGE_SIZE = 0x2003 , - ES_MESSAGE_ADD_CHILD = 0x2004 , - ES_MESSAGE_REMOVE_CHILD = 0x2005 , - ES_MESSAGE_HIT_TEST = 0x2006 , - ES_MESSAGE_HOVERED_START = 0x2007 , - ES_MESSAGE_HOVERED_END = 0x2008 , - ES_MESSAGE_PRESSED_START = 0x2009 , - ES_MESSAGE_PRESSED_END = 0x200A , - ES_MESSAGE_FOCUSED_START = 0x200B , - ES_MESSAGE_FOCUSED_END = 0x200C , - ES_MESSAGE_FOCUS_WITHIN_START = 0x200D , - ES_MESSAGE_FOCUS_WITHIN_END = 0x200E , - ES_MESSAGE_Z_ORDER = 0x2010 , - ES_MESSAGE_ANIMATE = 0x2011 , - ES_MESSAGE_MOUSE_DRAGGED = 0x2012 , - ES_MESSAGE_KEY_TYPED = 0x2013 , - ES_MESSAGE_PAINT_BACKGROUND = 0x2014 , - ES_MESSAGE_PAINT_FOREGROUND = 0x2015 , - ES_MESSAGE_ENSURE_VISIBLE = 0x2016 , - ES_MESSAGE_GET_CURSOR = 0x2017 , - ES_MESSAGE_WINDOW_CREATED = 0x2018 , - ES_MESSAGE_CLICKED = 0x3000 , - ES_MESSAGE_SCROLLBAR_MOVED = 0x3001 , - ES_MESSAGE_RECALCULATE_CONTENT_SIZE = 0x3002 , - ES_MESSAGE_DESKTOP_EXECUTE = 0x4800, - ES_MESSAGE_POWER_BUTTON_PRESSED = 0x4801, - ES_MESSAGE_TASKBAR_WINDOW_ADD = 0x4804, - ES_MESSAGE_TASKBAR_WINDOW_REMOVE = 0x4805, - ES_MESSAGE_TASKBAR_WINDOW_ACTIVATE = 0x4806, - ES_MESSAGE_TASKBAR_WINDOW_SET_TITLE = 0x4807, - ES_MESSAGE_DOCKED_WINDOW_CREATE = 0x4808, - ES_MESSAGE_PROGRAM_CRASH = 0x4C00, - ES_MESSAGE_PROGRAM_FAILED_TO_START = 0x4C01, - ES_MESSAGE_RECEIVE_DATA = 0x5100, - ES_MESSAGE_MAILSLOT_CLOSED = 0x5101, - ES_MESSAGE_CLIPBOARD_UPDATED = 0x5001, - ES_MESSAGE_SYSTEM_CONSTANT_UPDATED = 0x5004, - ES_MESSAGE_TIMER = 0x5006, - ES_MESSAGE_OBJECT_DESTROY = 0x5007, - ES_MESSAGE_LIST_VIEW_GET_ITEM_CONTENT = 0x6000, - ES_MESSAGE_LIST_VIEW_SET_ITEM_STATE = 0x6001, - ES_MESSAGE_LIST_VIEW_GET_ITEM_STATE = 0x6002, - ES_MESSAGE_LIST_VIEW_PAINT_ITEM = 0x6003 , - ES_MESSAGE_LIST_VIEW_PAINT_CELL = 0x6004 , - ES_MESSAGE_LIST_VIEW_SORT_COLUMN = 0x6005, - ES_MESSAGE_LIST_VIEW_CHOOSE_ITEM = 0x6006, - ES_MESSAGE_LIST_VIEW_FIND_ITEM = 0x6007, - ES_MESSAGE_LIST_VIEW_TOGGLE_DISCLOSURE = 0x6008, - ES_MESSAGE_LIST_VIEW_MEASURE_ITEM_HEIGHT = 0x6009, - ES_MESSAGE_LIST_VIEW_LAYOUT_ITEM = 0x600A, - ES_MESSAGE_LIST_VIEW_SET_ITEM_VISIBILITY = 0x600B, - ES_MESSAGE_LIST_VIEW_RELAY_MESSAGE = 0x600C, - ES_MESSAGE_LIST_VIEW_SET_ITEM_POSITION = 0x600D, - ES_MESSAGE_USER_START = 0x8000, - ES_MESSAGE_USER_END = 0xBFFF, +StandardFont :: enum { + STANDARD_FONT_REGULAR, + STANDARD_FONT_BOLD, + STANDARD_FONT_MONOSPACED, } -EsDrawMode :: enum { - ES_DRAW_MODE_REPEAT_FIRST = 1 , - ES_DRAW_MODE_STRECH, - ES_DRAW_MODE_REPEAT, - ES_DRAW_MODE_NONE, +MessageType :: enum { + MESSAGE_WM_START = 0x1000, + MESSAGE_MOUSE_MOVED = 0x1001, + MESSAGE_WINDOW_ACTIVATED = 0x1003, + MESSAGE_WINDOW_DEACTIVATED = 0x1004, + MESSAGE_WINDOW_DESTROYED = 0x1005, + MESSAGE_MOUSE_EXIT = 0x1006 , + MESSAGE_CLICK_REPEAT = 0x1009, + MESSAGE_WINDOW_RESIZED = 0x100B, + MESSAGE_MOUSE_LEFT_PRESSED = 0x100C , + MESSAGE_MOUSE_LEFT_RELEASED = 0x100D, + MESSAGE_MOUSE_RIGHT_PRESSED = 0x100E, + MESSAGE_MOUSE_RIGHT_RELEASED = 0x100F, + MESSAGE_MOUSE_MIDDLE_PRESSED = 0x1010, + MESSAGE_MOUSE_MIDDLE_RELEASED = 0x1011 , + MESSAGE_KEY_PRESSED = 0x1012, + MESSAGE_KEY_RELEASED = 0x1013, + MESSAGE_UPDATE_WINDOW = 0x1014, + MESSAGE_WM_END = 0x13FF, + MESSAGE_PAINT = 0x2000 , + MESSAGE_DESTROY = 0x2001 , + MESSAGE_MEASURE = 0x2002 , + MESSAGE_SIZE = 0x2003 , + MESSAGE_ADD_CHILD = 0x2004 , + MESSAGE_REMOVE_CHILD = 0x2005 , + MESSAGE_HIT_TEST = 0x2006 , + MESSAGE_HOVERED_START = 0x2007 , + MESSAGE_HOVERED_END = 0x2008 , + MESSAGE_PRESSED_START = 0x2009 , + MESSAGE_PRESSED_END = 0x200A , + MESSAGE_FOCUSED_START = 0x200B , + MESSAGE_FOCUSED_END = 0x200C , + MESSAGE_FOCUS_WITHIN_START = 0x200D , + MESSAGE_FOCUS_WITHIN_END = 0x200E , + MESSAGE_Z_ORDER = 0x2010 , + MESSAGE_ANIMATE = 0x2011 , + MESSAGE_MOUSE_DRAGGED = 0x2012 , + MESSAGE_KEY_TYPED = 0x2013 , + MESSAGE_PAINT_BACKGROUND = 0x2014 , + MESSAGE_PAINT_FOREGROUND = 0x2015 , + MESSAGE_ENSURE_VISIBLE = 0x2016 , + MESSAGE_GET_CURSOR = 0x2017 , + MESSAGE_WINDOW_CREATED = 0x2018 , + MESSAGE_CLICKED = 0x3000 , + MESSAGE_SCROLLBAR_MOVED = 0x3001 , + MESSAGE_RECALCULATE_CONTENT_SIZE = 0x3002 , + MESSAGE_TEXTBOX_UPDATED = 0x3003 , + MESSAGE_DESKTOP_EXECUTE = 0x4800, + MESSAGE_POWER_BUTTON_PRESSED = 0x4801, + MESSAGE_TASKBAR_WINDOW_ADD = 0x4804, + MESSAGE_TASKBAR_WINDOW_REMOVE = 0x4805, + MESSAGE_TASKBAR_WINDOW_ACTIVATE = 0x4806, + MESSAGE_TASKBAR_WINDOW_SET_TITLE = 0x4807, + MESSAGE_DOCKED_WINDOW_CREATE = 0x4808, + MESSAGE_PROGRAM_CRASH = 0x4C00, + MESSAGE_PROGRAM_FAILED_TO_START = 0x4C01, + MESSAGE_RECEIVE_DATA = 0x5100, + MESSAGE_MAILSLOT_CLOSED = 0x5101, + MESSAGE_CLIPBOARD_UPDATED = 0x5001, + MESSAGE_SYSTEM_CONSTANT_UPDATED = 0x5004, + MESSAGE_TIMER = 0x5006, + MESSAGE_OBJECT_DESTROY = 0x5007, + MESSAGE_LIST_VIEW_GET_ITEM_CONTENT = 0x6000, + MESSAGE_LIST_VIEW_SET_ITEM_STATE = 0x6001, + MESSAGE_LIST_VIEW_GET_ITEM_STATE = 0x6002, + MESSAGE_LIST_VIEW_PAINT_ITEM = 0x6003 , + MESSAGE_LIST_VIEW_PAINT_CELL = 0x6004 , + MESSAGE_LIST_VIEW_SORT_COLUMN = 0x6005, + MESSAGE_LIST_VIEW_CHOOSE_ITEM = 0x6006, + MESSAGE_LIST_VIEW_FIND_ITEM = 0x6007, + MESSAGE_LIST_VIEW_TOGGLE_DISCLOSURE = 0x6008, + MESSAGE_LIST_VIEW_MEASURE_ITEM_HEIGHT = 0x6009, + MESSAGE_LIST_VIEW_LAYOUT_ITEM = 0x600A, + MESSAGE_LIST_VIEW_SET_ITEM_VISIBILITY = 0x600B, + MESSAGE_LIST_VIEW_RELAY_MESSAGE = 0x600C, + MESSAGE_LIST_VIEW_SET_ITEM_POSITION = 0x600D, + MESSAGE_PROGRAM_START = 0x7000, + MESSAGE_PROGRAM_EXIT = 0x7001, + MESSAGE_USER_START = 0x8000, + MESSAGE_USER_END = 0xBFFF, } -EsClipboardFormat :: enum { - ES_CLIPBOARD_FORMAT_EMPTY, - ES_CLIPBOARD_FORMAT_TEXT, - ES_CLIPBOARD_FORMAT_FILE_LIST, +DrawMode :: enum { + DRAW_MODE_REPEAT_FIRST = 1 , + DRAW_MODE_STRECH, + DRAW_MODE_REPEAT, + DRAW_MODE_NONE, } -EsColorFormat :: enum { - ES_COLOR_FORMAT_32_XRGB, +ClipboardFormat :: enum { + CLIPBOARD_FORMAT_EMPTY, + CLIPBOARD_FORMAT_TEXT, + CLIPBOARD_FORMAT_FILE_LIST, } -EsCursorStyle :: enum { - ES_CURSOR_NORMAL, - ES_CURSOR_TEXT, - ES_CURSOR_RESIZE_VERTICAL, - ES_CURSOR_RESIZE_HORIZONTAL, - ES_CURSOR_RESIZE_DIAGONAL_1, - ES_CURSOR_RESIZE_DIAGONAL_2, - ES_CURSOR_SPLIT_VERTICAL, - ES_CURSOR_SPLIT_HORIZONTAL, - ES_CURSOR_HAND_HOVER, - ES_CURSOR_HAND_DRAG, - ES_CURSOR_HAND_POINT, - ES_CURSOR_SCROLL_UP_LEFT, - ES_CURSOR_SCROLL_UP, - ES_CURSOR_SCROLL_UP_RIGHT, - ES_CURSOR_SCROLL_LEFT, - ES_CURSOR_SCROLL_CENTER, - ES_CURSOR_SCROLL_RIGHT, - ES_CURSOR_SCROLL_DOWN_LEFT, - ES_CURSOR_SCROLL_DOWN, - ES_CURSOR_SCROLL_DOWN_RIGHT, - ES_CURSOR_SELECT_LINES, - ES_CURSOR_DROP_TEXT, - ES_CURSOR_CROSS_HAIR_PICK, - ES_CURSOR_CROSS_HAIR_RESIZE, - ES_CURSOR_MOVE_HOVER, - ES_CURSOR_MOVE_DRAG, - ES_CURSOR_ROTATE_HOVER, - ES_CURSOR_ROTATE_DRAG, - ES_CURSOR_BLANK, +ColorFormat :: enum { + COLOR_FORMAT_32_XRGB, } -EsWindowStyle :: enum { - ES_WINDOW_NORMAL, - ES_WINDOW_CONTAINER, - ES_WINDOW_MENU, +CursorStyle :: enum { + CURSOR_NORMAL, + CURSOR_TEXT, + CURSOR_RESIZE_VERTICAL, + CURSOR_RESIZE_HORIZONTAL, + CURSOR_RESIZE_DIAGONAL_1, + CURSOR_RESIZE_DIAGONAL_2, + CURSOR_SPLIT_VERTICAL, + CURSOR_SPLIT_HORIZONTAL, + CURSOR_HAND_HOVER, + CURSOR_HAND_DRAG, + CURSOR_HAND_POINT, + CURSOR_SCROLL_UP_LEFT, + CURSOR_SCROLL_UP, + CURSOR_SCROLL_UP_RIGHT, + CURSOR_SCROLL_LEFT, + CURSOR_SCROLL_CENTER, + CURSOR_SCROLL_RIGHT, + CURSOR_SCROLL_DOWN_LEFT, + CURSOR_SCROLL_DOWN, + CURSOR_SCROLL_DOWN_RIGHT, + CURSOR_SELECT_LINES, + CURSOR_DROP_TEXT, + CURSOR_CROSS_HAIR_PICK, + CURSOR_CROSS_HAIR_RESIZE, + CURSOR_MOVE_HOVER, + CURSOR_MOVE_DRAG, + CURSOR_ROTATE_HOVER, + CURSOR_ROTATE_DRAG, + CURSOR_BLANK, } -ES_NODE_FILE :: (0); -ES_NODE_DIRECTORY :: (0x4000); -ES_NODE_INVALID :: (0x8000); -EsBatchCall :: struct { - index :EsSyscallType, +WindowStyle :: enum { + WINDOW_NORMAL, + WINDOW_CONTAINER, + WINDOW_MENU, +} + +NODE_FILE :: (0); +NODE_DIRECTORY :: (0x4000); +NODE_INVALID :: (0x8000); +BatchCall :: struct { + index :SyscallType, stopBatchIfError :bool, using _ : struct #raw_union { argument0 :uintptr, @@ -652,60 +1727,57 @@ EsBatchCall :: struct { argument3 :uintptr, } -EsThreadInformation :: struct { - handle :EsHandle, +ThreadInformation :: struct { + handle :Handle, tid :uintptr, } -EsProcessInformation :: struct { - handle :EsHandle, +ProcessInformation :: struct { + handle :Handle, pid :uintptr, - mainThread :EsThreadInformation, + mainThread :ThreadInformation, } -EsUniqueIdentifier :: struct { +UniqueIdentifier :: struct { using _ : struct #raw_union { d :[16]u8, }, } -EsNodeInformation :: struct { - handle :EsHandle, - type :EsNodeType, - using _ : struct #raw_union { - fileSize :EsFileOffset, - directoryChildren :EsFileOffset, - }, - +NodeInformation :: struct { + handle :Handle, + type :NodeType, + fileSize :FileOffset, + directoryChildren :FileOffset, } -EsDirectoryChild :: struct { - name :[ES_MAX_DIRECTORY_CHILD_NAME_LENGTH]i8, +DirectoryChild :: struct { + name :[MAX_DIRECTORY_CHILD_NAME_LENGTH]i8, nameBytes :uintptr, - information :EsNodeInformation, + information :NodeInformation, } -EsPoint :: struct { +Point :: struct { x :i32, y :i32, } -EsRectangle :: struct { +Rectangle :: struct { left :i32, right :i32, top :i32, bottom :i32, } -EsRectangle16 :: struct { +Rectangle16 :: struct { left :i16, right :i16, top :i16, bottom :i16, } -EsColor :: struct { +Color :: struct { using _ : struct #raw_union { using _ : struct { blue :u8, @@ -718,97 +1790,97 @@ EsColor :: struct { } -EsLinearBuffer :: struct { +LinearBuffer :: struct { width :uintptr, height :uintptr, stride :uintptr, - colorFormat :EsColorFormat, - handle :EsHandle, - flags :u32, + colorFormat :ColorFormat, + handle :Handle, } -_EsRectangleAndColor :: struct { - rectangle :EsRectangle, - color :EsColor, +RectangleAndColor :: struct { + rectangle :Rectangle, + color :Color, } -_EsStyledBoxData :: struct { +StyledBoxData :: struct { backgroundColor :u32, borderColor :u32, - borderSize :u8, + borders :Rectangle16, cornerRadius :u8, roundedCornersToExclude :u8, ox :i32, oy :i32, width :i32, height :i32, - clip :EsRectangle, + clip :Rectangle, } -_EsInstanceCreateRemoteArguments :: struct { +InstanceCreateRemoteArguments :: struct { what :^i8, argument :^i8, whatBytes :uintptr, argumentBytes :uintptr, - modalWindowParent :EsHandle, + modalWindowParent :Handle, apiInstance :^rawptr, } -_EsDrawSurfaceArguments :: struct { - source :EsRectangle, - destination :EsRectangle, - border :EsRectangle, +DrawSurfaceArguments :: struct { + source :Rectangle, + destination :Rectangle, + border :Rectangle, alpha :u16, } -EsSpinlock :: struct { +Spinlock :: struct { state :u8, } -EsMutex :: struct { - event :EsHandle, - spinlock :EsSpinlock, +Mutex :: struct { + event :Handle, + spinlock :Spinlock, state :u8, queued :u32, } -EsCrashReason :: struct { - errorCode :EsError, +CrashReason :: struct { + errorCode :Error, } -EsProcessState :: struct { - crashReason :EsCrashReason, - creationArgument :EsGeneric, +ProcessState :: struct { + crashReason :CrashReason, + creationArgument :Generic, id :uintptr, executableState :uintptr, flags :u8, } -EsIORequestProgress :: struct { - accessed :EsFileOffset, - progress :EsFileOffset, +IORequestProgress :: struct { + accessed :FileOffset, + progress :FileOffset, completed :bool, cancelled :bool, - error :EsError, + error :Error, } -EsClipboardHeader :: struct { +ClipboardHeader :: struct { customBytes :uintptr, - format :EsClipboardFormat, + format :ClipboardFormat, textBytes :uintptr, unused :uintptr, } -EsPainter :: struct { - surface :EsHandle, - clip :EsRectangle, +Painter :: struct { + surface :Handle, + clip :Rectangle, offsetX :i32, offsetY :i32, + fullAlpha :bool, } -EsMessage :: struct { - type :EsMessageType, - _context :EsGeneric, +Message :: struct { + type :MessageType, + _context :Generic, using _ : struct #raw_union { _argument :^rawptr, mouseMoved : struct { @@ -847,20 +1919,20 @@ EsMessage :: struct { ctrl :u8, shift :u8, numpad :u8, - notHandledBy :EsObject, + notHandledBy :Object, }, crash : struct { - reason :EsCrashReason, - process :EsHandle, - processNameBuffer :EsHandle, + reason :CrashReason, + process :Handle, + processNameBuffer :Handle, processNameBytes :uintptr, pid :uintptr, }, - clipboard :EsClipboardHeader, + clipboard :ClipboardHeader, receive : struct { - buffer :EsHandle, + buffer :Handle, bytes :uintptr, }, @@ -876,35 +1948,35 @@ EsMessage :: struct { }, desktopExecute : struct { - whatBuffer :EsHandle, - argumentBuffer :EsHandle, - mailslot :EsHandle, + whatBuffer :Handle, + argumentBuffer :Handle, + mailslot :Handle, whatBytes :uintptr, argumentBytes :uintptr, modalWindowParent :u64, }, dockedWindowCreate : struct { - pipe :EsHandle, + pipe :Handle, }, taskbar : struct { id :u64, - buffer :EsHandle, + buffer :Handle, bytes :uintptr, }, windowResized : struct { - content :EsRectangle, + content :Rectangle, }, - painter :^EsPainter, + painter :^Painter, measure : struct { width :i32, height :i32, }, - child :EsObject, + child :Object, size : struct { width :i32, height :i32, @@ -918,7 +1990,7 @@ EsMessage :: struct { zOrder : struct { index :uintptr, - child :^EsElement, + child :^Element, }, scrollbarMoved : struct { @@ -926,20 +1998,19 @@ EsMessage :: struct { }, ensureVisible : struct { - child :^EsElement, + child :^Element, }, - cursorStyle :EsCursorStyle, + cursorStyle :CursorStyle, getItemContent : struct { mask :u32, - index :EsListViewIndex, - column :EsListViewIndex, - group :EsListViewIndex, + index :ListViewIndex, + column :ListViewIndex, + group :ListViewIndex, text :^i8, textBytes :uintptr, - iconHash :u32, - iconWidth :u16, - iconHeight :u16, + iconID :u16, + iconSize :u16, indentation :u16, spaceAfterIcon :u16, }, @@ -947,39 +2018,39 @@ EsMessage :: struct { accessItemState : struct { mask :u32, state :u32, - iIndexFrom :EsListViewIndex, - eIndexTo :EsListViewIndex, - group :EsListViewIndex, + iIndexFrom :ListViewIndex, + eIndexTo :ListViewIndex, + group :ListViewIndex, }, measureItemHeight : struct { - iIndexFrom :EsListViewIndex, - eIndexTo :EsListViewIndex, - group :EsListViewIndex, + iIndexFrom :ListViewIndex, + eIndexTo :ListViewIndex, + group :ListViewIndex, height :i32, }, layoutItem : struct { - index :EsListViewIndex, - group :EsListViewIndex, - knownIndex :EsListViewIndex, - knownGroup :EsListViewIndex, - bounds :EsRectangle, + index :ListViewIndex, + group :ListViewIndex, + knownIndex :ListViewIndex, + knownGroup :ListViewIndex, + bounds :Rectangle, }, toggleItemDisclosure : struct { - index :EsListViewIndex, - group :EsListViewIndex, + index :ListViewIndex, + group :ListViewIndex, }, findItem : struct { type :u8, backwards :u8, inclusive :bool, - indexFrom :EsListViewIndex, - groupFrom :EsListViewIndex, - foundIndex :EsListViewIndex, - foundGroup :EsListViewIndex, + indexFrom :ListViewIndex, + groupFrom :ListViewIndex, + foundIndex :ListViewIndex, + foundGroup :ListViewIndex, using _ : struct #raw_union { using _ : struct { prefix :^i8, @@ -997,58 +2068,57 @@ EsMessage :: struct { }, listViewColumn : struct { - index :EsListViewIndex, + index :ListViewIndex, descending :bool, }, setItemVisibility : struct { - index :EsListViewIndex, - group :EsListViewIndex, + index :ListViewIndex, + group :ListViewIndex, visible :bool, }, setItemPosition : struct { - index :EsListViewIndex, - group :EsListViewIndex, - bounds :EsRectangle, + index :ListViewIndex, + group :ListViewIndex, + bounds :Rectangle, }, listViewPaint : struct { - surface :EsHandle, - bounds :EsRectangle, - clip :EsRectangle, - index :EsListViewIndex, - group :EsListViewIndex, - column :EsListViewIndex, - _internal :^rawptr, + painter :^Painter, + width :i32, + height :i32, + index :ListViewIndex, + group :ListViewIndex, + column :ListViewIndex, }, }, } -EsDebuggerMessage :: struct { - process :EsHandle, - reason :EsCrashReason, +DebuggerMessage :: struct { + process :Handle, + reason :CrashReason, } -EsDriveInformation :: struct { +DriveInformation :: struct { name :[64]i8, nameBytes :uintptr, mountpoint :[256]i8, mountpointBytes :uintptr, } -EsSnapshotProcessesItem :: struct { +SnapshotProcessesItem :: struct { pid :i64, memoryUsage :i64, cpuTimeSlices :i64, - name :[ES_SNAPSHOT_MAX_PROCESS_NAME_LENGTH]i8, + name :[SNAPSHOT_MAX_PROCESS_NAME_LENGTH]i8, nameLength :uintptr, internal :u64, } -EsSystemInformation :: struct { +SystemInformation :: struct { processCount :uintptr, threadCount :uintptr, handleCount :uintptr, @@ -1067,37 +2137,37 @@ EsSystemInformation :: struct { kernelRegions :uintptr, } -EsSnapshotProcesses :: struct { +SnapshotProcesses :: struct { count :uintptr, - processes :[]EsSnapshotProcessesItem, + processes :[]SnapshotProcessesItem, } -_EsPOSIXSyscall :: struct { +POSIXSyscall :: struct { index :int, arguments :[7]int, } -EsProcessCreationArguments :: struct { +ProcessCreationArguments :: struct { executablePath :^i8, executablePathBytes :uintptr, environmentBlock :^rawptr, environmentBlockBytes :uintptr, - creationArgument :EsGeneric, + creationArgument :Generic, permissions :u64, } -_EsUserLoginArguments :: struct { +UserLoginArguments :: struct { name :^i8, nameBytes :uintptr, home :^i8, homeBytes :uintptr, } -EsInstance :: struct { +Instance :: struct { _private :^rawptr, } -EsListViewColumn :: struct { +ListViewColumn :: struct { title :^i8, titleBytes :uintptr, width :i32, @@ -1105,193 +2175,207 @@ EsListViewColumn :: struct { flags :u32, } -EsListViewStyle :: struct { - flags :u32, +ListViewStyle :: struct { fixedWidth :i32, fixedHeight :i32, groupHeaderHeight :i32, gapX :i32, gapY :i32, - margin :EsRectangle16, - columns :^EsListViewColumn, + margin :Rectangle16, + columns :^ListViewColumn, columnCount :uintptr, emptyMessage :^i8, emptyMessageBytes :uintptr, } -EsBatch :: inline proc (calls :^EsBatchCall, count :uintptr){ ((proc (^EsBatchCall, uintptr))(rawptr(uintptr(0x1000 + 0 * size_of(int)))))(calls, count); } -EsProcessCreate :: inline proc (executablePath :^i8, executablePathLength :uintptr, information :^EsProcessInformation, argument :EsGeneric) -> EsError{ return ((proc (^i8, uintptr, ^EsProcessInformation, EsGeneric) -> EsError)(rawptr(uintptr(0x1000 + 1 * size_of(int)))))(executablePath, executablePathLength, information, argument); } -EsThreadCreate :: inline proc (entryFunction :EsThreadEntryFunction, information :^EsThreadInformation, argument :EsGeneric) -> EsError{ return ((proc (EsThreadEntryFunction, ^EsThreadInformation, EsGeneric) -> EsError)(rawptr(uintptr(0x1000 + 2 * size_of(int)))))(entryFunction, information, argument); } -EsSurfaceCreate :: inline proc (width :uintptr, height :uintptr, flags :u32) -> EsHandle{ return ((proc (uintptr, uintptr, u32) -> EsHandle)(rawptr(uintptr(0x1000 + 3 * size_of(int)))))(width, height, flags); } -EsEventCreate :: inline proc (autoReset :bool) -> EsHandle{ return ((proc (bool) -> EsHandle)(rawptr(uintptr(0x1000 + 4 * size_of(int)))))(autoReset); } -EsThreadLocalStorageSetAddress :: inline proc (address :^rawptr){ ((proc (^rawptr))(rawptr(uintptr(0x1000 + 5 * size_of(int)))))(address); } -EsConstantBufferRead :: inline proc (constantBuffer :EsHandle, output :^rawptr){ ((proc (EsHandle, ^rawptr))(rawptr(uintptr(0x1000 + 6 * size_of(int)))))(constantBuffer, output); } -EsConstantBufferShare :: inline proc (constantBuffer :EsHandle, targetProcess :EsHandle) -> EsHandle{ return ((proc (EsHandle, EsHandle) -> EsHandle)(rawptr(uintptr(0x1000 + 7 * size_of(int)))))(constantBuffer, targetProcess); } -EsConstantBufferCreate :: inline proc (data :^rawptr, dataBytes :uintptr, targetProcess :EsHandle) -> EsHandle{ return ((proc (^rawptr, uintptr, EsHandle) -> EsHandle)(rawptr(uintptr(0x1000 + 8 * size_of(int)))))(data, dataBytes, targetProcess); } -EsProcessOpen :: inline proc (pid :u64) -> EsHandle{ return ((proc (u64) -> EsHandle)(rawptr(uintptr(0x1000 + 9 * size_of(int)))))(pid); } -EsHandleClose :: inline proc (handle :EsHandle) -> EsError{ return ((proc (EsHandle) -> EsError)(rawptr(uintptr(0x1000 + 10 * size_of(int)))))(handle); } -EsTakeSystemSnapshot :: inline proc (type :i32, bufferSize :^uintptr) -> EsHandle{ return ((proc (i32, ^uintptr) -> EsHandle)(rawptr(uintptr(0x1000 + 11 * size_of(int)))))(type, bufferSize); } -EsGetSystemInformation :: inline proc (systemInformation :^EsSystemInformation){ ((proc (^EsSystemInformation))(rawptr(uintptr(0x1000 + 12 * size_of(int)))))(systemInformation); } -EsNodeOpen :: inline proc (path :^i8, pathLength :uintptr, flags :u64, information :^EsNodeInformation) -> EsError{ return ((proc (^i8, uintptr, u64, ^EsNodeInformation) -> EsError)(rawptr(uintptr(0x1000 + 13 * size_of(int)))))(path, pathLength, flags, information); } -EsNodeFindUniqueName :: inline proc (buffer :^i8, originalBytes :uintptr, bufferBytes :uintptr) -> uintptr{ return ((proc (^i8, uintptr, uintptr) -> uintptr)(rawptr(uintptr(0x1000 + 14 * size_of(int)))))(buffer, originalBytes, bufferBytes); } -EsFileReadAll :: inline proc (filePath :^i8, filePathLength :uintptr, fileSize :^uintptr){ ((proc (^i8, uintptr, ^uintptr))(rawptr(uintptr(0x1000 + 15 * size_of(int)))))(filePath, filePathLength, fileSize); } -EsFileReadSync :: inline proc (file :EsHandle, offset :EsFileOffset, size :uintptr, buffer :^rawptr) -> uintptr{ return ((proc (EsHandle, EsFileOffset, uintptr, ^rawptr) -> uintptr)(rawptr(uintptr(0x1000 + 16 * size_of(int)))))(file, offset, size, buffer); } -EsFileWriteSync :: inline proc (file :EsHandle, offset :EsFileOffset, size :uintptr, buffer :^rawptr) -> uintptr{ return ((proc (EsHandle, EsFileOffset, uintptr, ^rawptr) -> uintptr)(rawptr(uintptr(0x1000 + 17 * size_of(int)))))(file, offset, size, buffer); } -EsFileResize :: inline proc (file :EsHandle, newSize :EsFileOffset) -> EsError{ return ((proc (EsHandle, EsFileOffset) -> EsError)(rawptr(uintptr(0x1000 + 18 * size_of(int)))))(file, newSize); } -EsNodeRefreshInformation :: inline proc (information :^EsNodeInformation){ ((proc (^EsNodeInformation))(rawptr(uintptr(0x1000 + 19 * size_of(int)))))(information); } -EsDirectoryEnumerateChildren :: inline proc (directory :EsHandle, buffer :^EsDirectoryChild, bufferCount :uintptr) -> int{ return ((proc (EsHandle, ^EsDirectoryChild, uintptr) -> int)(rawptr(uintptr(0x1000 + 20 * size_of(int)))))(directory, buffer, bufferCount); } -EsNodeDelete :: inline proc (node :EsHandle) -> EsError{ return ((proc (EsHandle) -> EsError)(rawptr(uintptr(0x1000 + 21 * size_of(int)))))(node); } -EsNodeMove :: inline proc (node :EsHandle, newDirectory :EsHandle, newName :^i8, newNameLength :uintptr) -> EsError{ return ((proc (EsHandle, EsHandle, ^i8, uintptr) -> EsError)(rawptr(uintptr(0x1000 + 22 * size_of(int)))))(node, newDirectory, newName, newNameLength); } -EsThreadTerminate :: inline proc (thread :EsHandle){ ((proc (EsHandle))(rawptr(uintptr(0x1000 + 23 * size_of(int)))))(thread); } -EsProcessTerminate :: inline proc (process :EsHandle, status :i32){ ((proc (EsHandle, i32))(rawptr(uintptr(0x1000 + 24 * size_of(int)))))(process, status); } -EsProcessTerminateCurrent :: inline proc (){ ((proc ())(rawptr(uintptr(0x1000 + 25 * size_of(int)))))(); } -EsProcessPause :: inline proc (process :EsHandle, resume :bool){ ((proc (EsHandle, bool))(rawptr(uintptr(0x1000 + 26 * size_of(int)))))(process, resume); } -EsProcessCrash :: inline proc (error :EsError, message :^i8, messageBytes :uintptr){ ((proc (EsError, ^i8, uintptr))(rawptr(uintptr(0x1000 + 27 * size_of(int)))))(error, message, messageBytes); } -EsThreadGetID :: inline proc (thread :EsHandle) -> uintptr{ return ((proc (EsHandle) -> uintptr)(rawptr(uintptr(0x1000 + 28 * size_of(int)))))(thread); } -EsProcessGetID :: inline proc (process :EsHandle) -> uintptr{ return ((proc (EsHandle) -> uintptr)(rawptr(uintptr(0x1000 + 29 * size_of(int)))))(process); } -EsSpinlockRelease :: inline proc (spinlock :^EsSpinlock){ ((proc (^EsSpinlock))(rawptr(uintptr(0x1000 + 30 * size_of(int)))))(spinlock); } -EsSpinlockAcquire :: inline proc (spinlock :^EsSpinlock){ ((proc (^EsSpinlock))(rawptr(uintptr(0x1000 + 31 * size_of(int)))))(spinlock); } -EsMutexRelease :: inline proc (mutex :^EsMutex){ ((proc (^EsMutex))(rawptr(uintptr(0x1000 + 32 * size_of(int)))))(mutex); } -EsMutexAcquire :: inline proc (mutex :^EsMutex){ ((proc (^EsMutex))(rawptr(uintptr(0x1000 + 33 * size_of(int)))))(mutex); } -EsMutexDestroy :: inline proc (mutex :^EsMutex){ ((proc (^EsMutex))(rawptr(uintptr(0x1000 + 34 * size_of(int)))))(mutex); } -EsSchedulerYield :: inline proc (){ ((proc ())(rawptr(uintptr(0x1000 + 35 * size_of(int)))))(); } -EsEventSet :: inline proc (event :EsHandle){ ((proc (EsHandle))(rawptr(uintptr(0x1000 + 36 * size_of(int)))))(event); } -EsEventReset :: inline proc (event :EsHandle){ ((proc (EsHandle))(rawptr(uintptr(0x1000 + 37 * size_of(int)))))(event); } -EsEventPoll :: inline proc (event :EsHandle) -> EsError{ return ((proc (EsHandle) -> EsError)(rawptr(uintptr(0x1000 + 38 * size_of(int)))))(event); } -EsWait :: inline proc (objects :^EsHandle, objectCount :uintptr, timeoutMs :uintptr) -> uintptr{ return ((proc (^EsHandle, uintptr, uintptr) -> uintptr)(rawptr(uintptr(0x1000 + 39 * size_of(int)))))(objects, objectCount, timeoutMs); } -EsSleep :: inline proc (milliseconds :u64){ ((proc (u64))(rawptr(uintptr(0x1000 + 40 * size_of(int)))))(milliseconds); } -EsMemoryOpen :: inline proc (size :uintptr, name :^i8, nameLength :uintptr, flags :u32) -> EsHandle{ return ((proc (uintptr, ^i8, uintptr, u32) -> EsHandle)(rawptr(uintptr(0x1000 + 41 * size_of(int)))))(size, name, nameLength, flags); } -EsMemoryShare :: inline proc (sharedMemoryRegion :EsHandle, targetProcess :EsHandle, readOnly :bool) -> EsHandle{ return ((proc (EsHandle, EsHandle, bool) -> EsHandle)(rawptr(uintptr(0x1000 + 42 * size_of(int)))))(sharedMemoryRegion, targetProcess, readOnly); } -EsObjectMap :: inline proc (object :EsHandle, offset :uintptr, size :uintptr, flags :u32){ ((proc (EsHandle, uintptr, uintptr, u32))(rawptr(uintptr(0x1000 + 43 * size_of(int)))))(object, offset, size, flags); } -EsMemoryAllocate :: inline proc (size :uintptr){ ((proc (uintptr))(rawptr(uintptr(0x1000 + 44 * size_of(int)))))(size); } -EsMemoryFree :: inline proc (address :^rawptr) -> EsError{ return ((proc (^rawptr) -> EsError)(rawptr(uintptr(0x1000 + 45 * size_of(int)))))(address); } -EsGetCreationArgument :: inline proc (object :EsHandle) -> EsGeneric{ return ((proc (EsHandle) -> EsGeneric)(rawptr(uintptr(0x1000 + 46 * size_of(int)))))(object); } -EsProcessGetState :: inline proc (process :EsHandle, state :^EsProcessState){ ((proc (EsHandle, ^EsProcessState))(rawptr(uintptr(0x1000 + 47 * size_of(int)))))(process, state); } -EsSurfaceGetLinearBuffer :: inline proc (surface :EsHandle, linearBuffer :^EsLinearBuffer){ ((proc (EsHandle, ^EsLinearBuffer))(rawptr(uintptr(0x1000 + 48 * size_of(int)))))(surface, linearBuffer); } -EsRectangleInvalidate :: inline proc (surface :EsHandle, rectangle :EsRectangle){ ((proc (EsHandle, EsRectangle))(rawptr(uintptr(0x1000 + 49 * size_of(int)))))(surface, rectangle); } -EsCopyToScreen :: inline proc (source :EsHandle, point :EsPoint, depth :u16){ ((proc (EsHandle, EsPoint, u16))(rawptr(uintptr(0x1000 + 50 * size_of(int)))))(source, point, depth); } -EsForceScreenUpdate :: inline proc (){ ((proc ())(rawptr(uintptr(0x1000 + 51 * size_of(int)))))(); } -EsDrawRectangle :: inline proc (surface :EsHandle, rectangle :EsRectangle, color :EsColor){ ((proc (EsHandle, EsRectangle, EsColor))(rawptr(uintptr(0x1000 + 52 * size_of(int)))))(surface, rectangle, color); } -EsDrawRectangleClipped :: inline proc (surface :EsHandle, rectangle :EsRectangle, color :EsColor, clipRegion :EsRectangle){ ((proc (EsHandle, EsRectangle, EsColor, EsRectangle))(rawptr(uintptr(0x1000 + 53 * size_of(int)))))(surface, rectangle, color, clipRegion); } -EsDrawSurfaceBlit :: inline proc (destination :EsHandle, source :EsHandle, destinationPoint :EsPoint){ ((proc (EsHandle, EsHandle, EsPoint))(rawptr(uintptr(0x1000 + 54 * size_of(int)))))(destination, source, destinationPoint); } -EsDrawSurface :: inline proc (destination :EsHandle, source :EsHandle, destinationRegion :EsRectangle, sourceRegion :EsRectangle, borderRegion :EsRectangle, mode :EsDrawMode, alpha :u16) -> EsError{ return ((proc (EsHandle, EsHandle, EsRectangle, EsRectangle, EsRectangle, EsDrawMode, u16) -> EsError)(rawptr(uintptr(0x1000 + 55 * size_of(int)))))(destination, source, destinationRegion, sourceRegion, borderRegion, mode, alpha); } -EsDrawSurfaceClipped :: inline proc (destination :EsHandle, source :EsHandle, destinationRegion :EsRectangle, sourceRegion :EsRectangle, borderRegion :EsRectangle, mode :EsDrawMode, alpha :u16, clipRegion :EsRectangle) -> EsError{ return ((proc (EsHandle, EsHandle, EsRectangle, EsRectangle, EsRectangle, EsDrawMode, u16, EsRectangle) -> EsError)(rawptr(uintptr(0x1000 + 56 * size_of(int)))))(destination, source, destinationRegion, sourceRegion, borderRegion, mode, alpha, clipRegion); } -EsDrawBitmap :: inline proc (destination :EsHandle, destinationPoint :EsPoint, bitmap :^rawptr, width :uintptr, height :uintptr, stride :uintptr, colorFormat :EsColorFormat){ ((proc (EsHandle, EsPoint, ^rawptr, uintptr, uintptr, uintptr, EsColorFormat))(rawptr(uintptr(0x1000 + 57 * size_of(int)))))(destination, destinationPoint, bitmap, width, height, stride, colorFormat); } -EsSurfaceClearInvalidatedRegion :: inline proc (surface :EsHandle){ ((proc (EsHandle))(rawptr(uintptr(0x1000 + 58 * size_of(int)))))(surface); } -EsRectangleClip :: inline proc (parent :EsRectangle, rectangle :EsRectangle, output :^EsRectangle) -> bool{ return ((proc (EsRectangle, EsRectangle, ^EsRectangle) -> bool)(rawptr(uintptr(0x1000 + 59 * size_of(int)))))(parent, rectangle, output); } -EsDrawBox :: inline proc (surface :EsHandle, rectangle :EsRectangle, style :u8, color :u32, clipRegion :EsRectangle){ ((proc (EsHandle, EsRectangle, u8, u32, EsRectangle))(rawptr(uintptr(0x1000 + 60 * size_of(int)))))(surface, rectangle, style, color, clipRegion); } -EsRedrawAll :: inline proc (){ ((proc ())(rawptr(uintptr(0x1000 + 61 * size_of(int)))))(); } -EsMessagePost :: inline proc (message :^EsMessage) -> EsError{ return ((proc (^EsMessage) -> EsError)(rawptr(uintptr(0x1000 + 62 * size_of(int)))))(message); } -EsMessagePostRemote :: inline proc (process :EsHandle, message :^EsMessage) -> EsError{ return ((proc (EsHandle, ^EsMessage) -> EsError)(rawptr(uintptr(0x1000 + 63 * size_of(int)))))(process, message); } -EsExtractArguments :: inline proc (string :^i8, bytes :uintptr, delimiterByte :u8, replacementDelimiter :u8, argvAllocated :uintptr, argv :^^i8, argc :^uintptr) -> bool{ return ((proc (^i8, uintptr, u8, u8, uintptr, ^^i8, ^uintptr) -> bool)(rawptr(uintptr(0x1000 + 64 * size_of(int)))))(string, bytes, delimiterByte, replacementDelimiter, argvAllocated, argv, argc); } -EsCStringLength :: inline proc (string :^i8) -> uintptr{ return ((proc (^i8) -> uintptr)(rawptr(uintptr(0x1000 + 65 * size_of(int)))))(string); } -EsStringLength :: inline proc (string :^i8, end :u8) -> uintptr{ return ((proc (^i8, u8) -> uintptr)(rawptr(uintptr(0x1000 + 66 * size_of(int)))))(string, end); } -EsMemoryCopy :: inline proc (destination :^rawptr, source :^rawptr, bytes :uintptr){ ((proc (^rawptr, ^rawptr, uintptr))(rawptr(uintptr(0x1000 + 67 * size_of(int)))))(destination, source, bytes); } -EsMemoryMove :: inline proc (_start :^rawptr, _end :^rawptr, amount :int, zeroEmptySpace :bool){ ((proc (^rawptr, ^rawptr, int, bool))(rawptr(uintptr(0x1000 + 68 * size_of(int)))))(_start, _end, amount, zeroEmptySpace); } -EsMemoryCopyReverse :: inline proc (_destination :^rawptr, _source :^rawptr, bytes :uintptr){ ((proc (^rawptr, ^rawptr, uintptr))(rawptr(uintptr(0x1000 + 69 * size_of(int)))))(_destination, _source, bytes); } -EsMemoryZero :: inline proc (destination :^rawptr, bytes :uintptr){ ((proc (^rawptr, uintptr))(rawptr(uintptr(0x1000 + 70 * size_of(int)))))(destination, bytes); } -EsMemoryCompare :: inline proc (a :^rawptr, b :^rawptr, bytes :uintptr) -> i32{ return ((proc (^rawptr, ^rawptr, uintptr) -> i32)(rawptr(uintptr(0x1000 + 71 * size_of(int)))))(a, b, bytes); } -EsMemorySumBytes :: inline proc (data :^u8, bytes :uintptr) -> u8{ return ((proc (^u8, uintptr) -> u8)(rawptr(uintptr(0x1000 + 72 * size_of(int)))))(data, bytes); } -EsPrintDirect :: inline proc (string :^i8, stringLength :uintptr){ ((proc (^i8, uintptr))(rawptr(uintptr(0x1000 + 73 * size_of(int)))))(string, stringLength); } -EsStringFormat :: inline proc (buffer :^i8, bufferLength :uintptr, format :^i8, args : ..any) -> uintptr{ return ((proc (^i8, uintptr, ^i8, ..any) -> uintptr)(rawptr(uintptr(0x1000 + 74 * size_of(int)))))(buffer, bufferLength, format, ); } -EsStringFormatAppend :: inline proc (buffer :^i8, bufferLength :uintptr, bufferPosition :^uintptr, format :^i8, args : ..any){ ((proc (^i8, uintptr, ^uintptr, ^i8, ..any))(rawptr(uintptr(0x1000 + 75 * size_of(int)))))(buffer, bufferLength, bufferPosition, format, ); } -EsPrintHelloWorld :: inline proc (){ ((proc ())(rawptr(uintptr(0x1000 + 76 * size_of(int)))))(); } -EsGetRandomByte :: inline proc () -> u8{ return ((proc () -> u8)(rawptr(uintptr(0x1000 + 77 * size_of(int)))))(); } -EsSort :: inline proc (_base :^rawptr, nmemb :uintptr, size :uintptr, compar :EsComparisonCallbackFunction, argument :EsGeneric){ ((proc (^rawptr, uintptr, uintptr, EsComparisonCallbackFunction, EsGeneric))(rawptr(uintptr(0x1000 + 78 * size_of(int)))))(_base, nmemb, size, compar, argument); } -EsSortWithSwapCallback :: inline proc (_base :^rawptr, nmemb :uintptr, size :uintptr, compar :EsComparisonCallbackFunction, argument :EsGeneric, swap :EsSwapCallbackFunction){ ((proc (^rawptr, uintptr, uintptr, EsComparisonCallbackFunction, EsGeneric, EsSwapCallbackFunction))(rawptr(uintptr(0x1000 + 79 * size_of(int)))))(_base, nmemb, size, compar, argument, swap); } -EsStringCompare :: inline proc (s1 :^i8, s2 :^i8, length1 :uintptr, length2 :uintptr) -> i32{ return ((proc (^i8, ^i8, uintptr, uintptr) -> i32)(rawptr(uintptr(0x1000 + 80 * size_of(int)))))(s1, s2, length1, length2); } -EsIntegerParse :: inline proc (text :^i8, bytes :uintptr) -> i64{ return ((proc (^i8, uintptr) -> i64)(rawptr(uintptr(0x1000 + 81 * size_of(int)))))(text, bytes); } -EsCRTmemset :: inline proc (s :^rawptr, c :i32, n :uintptr){ ((proc (^rawptr, i32, uintptr))(rawptr(uintptr(0x1000 + 82 * size_of(int)))))(s, c, n); } -EsCRTmemcpy :: inline proc (dest :^rawptr, src :^rawptr, n :uintptr){ ((proc (^rawptr, ^rawptr, uintptr))(rawptr(uintptr(0x1000 + 83 * size_of(int)))))(dest, src, n); } -EsCRTmemmove :: inline proc (dest :^rawptr, src :^rawptr, n :uintptr){ ((proc (^rawptr, ^rawptr, uintptr))(rawptr(uintptr(0x1000 + 84 * size_of(int)))))(dest, src, n); } -EsCRTstrlen :: inline proc (s :^i8) -> uintptr{ return ((proc (^i8) -> uintptr)(rawptr(uintptr(0x1000 + 85 * size_of(int)))))(s); } -EsCRTstrnlen :: inline proc (s :^i8, maxlen :uintptr) -> uintptr{ return ((proc (^i8, uintptr) -> uintptr)(rawptr(uintptr(0x1000 + 86 * size_of(int)))))(s, maxlen); } -EsCRTmalloc :: inline proc (size :uintptr){ ((proc (uintptr))(rawptr(uintptr(0x1000 + 87 * size_of(int)))))(size); } -EsCRTcalloc :: inline proc (num :uintptr, size :uintptr){ ((proc (uintptr, uintptr))(rawptr(uintptr(0x1000 + 88 * size_of(int)))))(num, size); } -EsCRTfree :: inline proc (ptr :^rawptr){ ((proc (^rawptr))(rawptr(uintptr(0x1000 + 89 * size_of(int)))))(ptr); } -EsCRTabs :: inline proc (n :i32) -> i32{ return ((proc (i32) -> i32)(rawptr(uintptr(0x1000 + 90 * size_of(int)))))(n); } -EsCRTrealloc :: inline proc (ptr :^rawptr, size :uintptr){ ((proc (^rawptr, uintptr))(rawptr(uintptr(0x1000 + 91 * size_of(int)))))(ptr, size); } -EsCRTgetenv :: inline proc (name :^i8) -> ^i8{ return ((proc (^i8) -> ^i8)(rawptr(uintptr(0x1000 + 92 * size_of(int)))))(name); } -EsCRTstrncmp :: inline proc (s1 :^i8, s2 :^i8, n :uintptr) -> i32{ return ((proc (^i8, ^i8, uintptr) -> i32)(rawptr(uintptr(0x1000 + 93 * size_of(int)))))(s1, s2, n); } -EsCRTmemcmp :: inline proc (s1 :^rawptr, s2 :^rawptr, n :uintptr) -> i32{ return ((proc (^rawptr, ^rawptr, uintptr) -> i32)(rawptr(uintptr(0x1000 + 94 * size_of(int)))))(s1, s2, n); } -EsCRTqsort :: inline proc (_base :^rawptr, nmemb :uintptr, size :uintptr, compar :EsCRTComparisonCallback){ ((proc (^rawptr, uintptr, uintptr, EsCRTComparisonCallback))(rawptr(uintptr(0x1000 + 95 * size_of(int)))))(_base, nmemb, size, compar); } -EsCRTstrcmp :: inline proc (s1 :^i8, s2 :^i8) -> i32{ return ((proc (^i8, ^i8) -> i32)(rawptr(uintptr(0x1000 + 96 * size_of(int)))))(s1, s2); } -EsCRTstrstr :: inline proc (haystack :^i8, needle :^i8) -> ^i8{ return ((proc (^i8, ^i8) -> ^i8)(rawptr(uintptr(0x1000 + 97 * size_of(int)))))(haystack, needle); } -EsCRTstrcpy :: inline proc (dest :^i8, src :^i8) -> ^i8{ return ((proc (^i8, ^i8) -> ^i8)(rawptr(uintptr(0x1000 + 98 * size_of(int)))))(dest, src); } -EsCRTisalpha :: inline proc (c :i32) -> i32{ return ((proc (i32) -> i32)(rawptr(uintptr(0x1000 + 99 * size_of(int)))))(c); } -EsCRTmemchr :: inline proc (_s :^rawptr, _c :i32, n :uintptr){ ((proc (^rawptr, i32, uintptr))(rawptr(uintptr(0x1000 + 100 * size_of(int)))))(_s, _c, n); } -EsCRTisdigit :: inline proc (c :i32) -> i32{ return ((proc (i32) -> i32)(rawptr(uintptr(0x1000 + 101 * size_of(int)))))(c); } -EsCRTstrcat :: inline proc (dest :^i8, src :^i8) -> ^i8{ return ((proc (^i8, ^i8) -> ^i8)(rawptr(uintptr(0x1000 + 102 * size_of(int)))))(dest, src); } -EsCRTtolower :: inline proc (c :i32) -> i32{ return ((proc (i32) -> i32)(rawptr(uintptr(0x1000 + 103 * size_of(int)))))(c); } -EsCRTstrncpy :: inline proc (dest :^i8, src :^i8, n :uintptr) -> ^i8{ return ((proc (^i8, ^i8, uintptr) -> ^i8)(rawptr(uintptr(0x1000 + 104 * size_of(int)))))(dest, src, n); } -EsCRTstrtoul :: inline proc (nptr :^i8, endptr :^^i8, base :i32) -> u64{ return ((proc (^i8, ^^i8, i32) -> u64)(rawptr(uintptr(0x1000 + 105 * size_of(int)))))(nptr, endptr, base); } -EsExecute :: inline proc (what :^i8, whatBytes :uintptr, argument :^i8, argumentBytes :uintptr){ ((proc (^i8, uintptr, ^i8, uintptr))(rawptr(uintptr(0x1000 + 106 * size_of(int)))))(what, whatBytes, argument, argumentBytes); } -EsAbort :: inline proc (){ ((proc ())(rawptr(uintptr(0x1000 + 107 * size_of(int)))))(); } -EsMailslotSendData :: inline proc (mailslot :EsHandle, data :^rawptr, bytes :uintptr) -> bool{ return ((proc (EsHandle, ^rawptr, uintptr) -> bool)(rawptr(uintptr(0x1000 + 108 * size_of(int)))))(mailslot, data, bytes); } -EsCRTfloorf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 109 * size_of(int)))))(x); } -EsCRTceilf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 110 * size_of(int)))))(x); } -EsCRTsinf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 111 * size_of(int)))))(x); } -EsCRTcosf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 112 * size_of(int)))))(x); } -EsCRTatan2f :: inline proc (y :f32, x :f32) -> f32{ return ((proc (f32, f32) -> f32)(rawptr(uintptr(0x1000 + 113 * size_of(int)))))(y, x); } -EsCRTfmodf :: inline proc (x :f32, y :f32) -> f32{ return ((proc (f32, f32) -> f32)(rawptr(uintptr(0x1000 + 114 * size_of(int)))))(x, y); } -EsCRTacosf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 115 * size_of(int)))))(x); } -EsCRTasinf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 116 * size_of(int)))))(x); } -EsCRTatanf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 117 * size_of(int)))))(x); } -EsRandomSeed :: inline proc (x :u64){ ((proc (u64))(rawptr(uintptr(0x1000 + 118 * size_of(int)))))(x); } -EsCRTsqrtf :: inline proc (x :f32) -> f32{ return ((proc (f32) -> f32)(rawptr(uintptr(0x1000 + 119 * size_of(int)))))(x); } -EsCRTsqrtl :: inline proc (x :EsLongDouble) -> EsLongDouble{ return ((proc (EsLongDouble) -> EsLongDouble)(rawptr(uintptr(0x1000 + 120 * size_of(int)))))(x); } -EsCRTfabsl :: inline proc (x :EsLongDouble) -> EsLongDouble{ return ((proc (EsLongDouble) -> EsLongDouble)(rawptr(uintptr(0x1000 + 121 * size_of(int)))))(x); } -_EsSyscall :: inline proc (a :uintptr, b :uintptr, c :uintptr, d :uintptr, e :uintptr, f :uintptr) -> uintptr{ return ((proc (uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) -> uintptr)(rawptr(uintptr(0x1000 + 122 * size_of(int)))))(a, b, c, d, e, f); } -EsProcessorReadTimeStamp :: inline proc () -> u64{ return ((proc () -> u64)(rawptr(uintptr(0x1000 + 123 * size_of(int)))))(); } -EsHeapAllocate :: inline proc (size :uintptr, zeroMemory :bool){ ((proc (uintptr, bool))(rawptr(uintptr(0x1000 + 124 * size_of(int)))))(size, zeroMemory); } -EsHeapFree :: inline proc (address :^rawptr){ ((proc (^rawptr))(rawptr(uintptr(0x1000 + 125 * size_of(int)))))(address); } -EsPrint :: inline proc (format :^i8, args : ..any){ ((proc (^i8, ..any))(rawptr(uintptr(0x1000 + 126 * size_of(int)))))(format, ); } -EsMemoryFill :: inline proc (from :^rawptr, to :^rawptr, byte :u8){ ((proc (^rawptr, ^rawptr, u8))(rawptr(uintptr(0x1000 + 127 * size_of(int)))))(from, to, byte); } -EsInitialiseCStandardLibrary :: inline proc (argc :^i32, argv :^^^i8){ ((proc (^i32, ^^^i8))(rawptr(uintptr(0x1000 + 128 * size_of(int)))))(argc, argv); } -EsMakeLinuxSystemCall2 :: inline proc (n :int, a1 :int, a2 :int, a3 :int, a4 :int, a5 :int, a6 :int) -> int{ return ((proc (int, int, int, int, int, int, int) -> int)(rawptr(uintptr(0x1000 + 129 * size_of(int)))))(n, a1, a2, a3, a4, a5, a6); } -EsProcessCreate2 :: inline proc (arguments :^EsProcessCreationArguments, information :^EsProcessInformation) -> EsError{ return ((proc (^EsProcessCreationArguments, ^EsProcessInformation) -> EsError)(rawptr(uintptr(0x1000 + 130 * size_of(int)))))(arguments, information); } -EsCRTatoi :: inline proc (string :^i8) -> i32{ return ((proc (^i8) -> i32)(rawptr(uintptr(0x1000 + 131 * size_of(int)))))(string); } -EsProcessGetExitStatus :: inline proc (process :EsHandle) -> i32{ return ((proc (EsHandle) -> i32)(rawptr(uintptr(0x1000 + 132 * size_of(int)))))(process); } -EsSurfaceReset :: inline proc (surface :EsHandle){ ((proc (EsHandle))(rawptr(uintptr(0x1000 + 133 * size_of(int)))))(surface); } -EsTimerCreate :: inline proc () -> EsHandle{ return ((proc () -> EsHandle)(rawptr(uintptr(0x1000 + 134 * size_of(int)))))(); } -EsTimerSet :: inline proc (handle :EsHandle, afterMs :u64, object :EsObject, argument :EsGeneric){ ((proc (EsHandle, u64, EsObject, EsGeneric))(rawptr(uintptr(0x1000 + 135 * size_of(int)))))(handle, afterMs, object, argument); } -EsFileWriteAll :: inline proc (filePath :^i8, filePathLength :uintptr, data :^rawptr, fileSize :uintptr) -> EsError{ return ((proc (^i8, uintptr, ^rawptr, uintptr) -> EsError)(rawptr(uintptr(0x1000 + 136 * size_of(int)))))(filePath, filePathLength, data, fileSize); } -EsUserGetHomeFolder :: inline proc (buffer :^i8, bufferBytes :uintptr) -> uintptr{ return ((proc (^i8, uintptr) -> uintptr)(rawptr(uintptr(0x1000 + 137 * size_of(int)))))(buffer, bufferBytes); } -EsAssert :: inline proc (expression :bool, failureMessage :^i8){ ((proc (bool, ^i8))(rawptr(uintptr(0x1000 + 138 * size_of(int)))))(expression, failureMessage); } -EsResizeArray :: inline proc (array :^^rawptr, allocated :^uintptr, needed :uintptr, itemSize :uintptr){ ((proc (^^rawptr, ^uintptr, uintptr, uintptr))(rawptr(uintptr(0x1000 + 139 * size_of(int)))))(array, allocated, needed, itemSize); } -EsMessageLoopEnter :: inline proc (callback :EsMessageCallbackFunction){ ((proc (EsMessageCallbackFunction))(rawptr(uintptr(0x1000 + 140 * size_of(int)))))(callback); } -_EsInstanceCreate :: inline proc (bytes :uintptr) -> ^EsInstance{ return ((proc (uintptr) -> ^EsInstance)(rawptr(uintptr(0x1000 + 141 * size_of(int)))))(bytes); } -EsMouseGetPosition :: inline proc (relativeWindow :^EsElement) -> EsPoint{ return ((proc (^EsElement) -> EsPoint)(rawptr(uintptr(0x1000 + 142 * size_of(int)))))(relativeWindow); } -EsMouseSetPosition :: inline proc (relativeWindow :^EsElement, x :i32, y :i32){ ((proc (^EsElement, i32, i32))(rawptr(uintptr(0x1000 + 143 * size_of(int)))))(relativeWindow, x, y); } -EsNewWindow :: inline proc (instance :^EsInstance, style :EsWindowStyle) -> ^EsElement{ return ((proc (^EsInstance, EsWindowStyle) -> ^EsElement)(rawptr(uintptr(0x1000 + 144 * size_of(int)))))(instance, style); } -EsNewPanel :: inline proc (parent :^EsElement, style :EsData, flags :u64) -> ^EsElement{ return ((proc (^EsElement, EsData, u64) -> ^EsElement)(rawptr(uintptr(0x1000 + 145 * size_of(int)))))(parent, style, flags); } -EsNewScrollbar :: inline proc (parent :^EsElement, flags :u64, userCallback :EsUICallbackFunction, _context :EsGeneric) -> ^EsElement{ return ((proc (^EsElement, u64, EsUICallbackFunction, EsGeneric) -> ^EsElement)(rawptr(uintptr(0x1000 + 146 * size_of(int)))))(parent, flags, userCallback, _context); } -EsNewButton :: inline proc (parent :^EsElement, label :^i8, labelBytes :int, flags :u64, userCallback :EsUICallbackFunction, _context :EsGeneric) -> ^EsElement{ return ((proc (^EsElement, ^i8, int, u64, EsUICallbackFunction, EsGeneric) -> ^EsElement)(rawptr(uintptr(0x1000 + 147 * size_of(int)))))(parent, label, labelBytes, flags, userCallback, _context); } -EsNewTextbox :: inline proc (parent :^EsElement, flags :u64, userCallback :EsUICallbackFunction, _context :EsGeneric) -> ^EsElement{ return ((proc (^EsElement, u64, EsUICallbackFunction, EsGeneric) -> ^EsElement)(rawptr(uintptr(0x1000 + 148 * size_of(int)))))(parent, flags, userCallback, _context); } -EsNewNumericEntry :: inline proc (parent :^EsElement, flags :u64, userCallback :EsUICallbackFunction, _context :EsGeneric) -> ^EsElement{ return ((proc (^EsElement, u64, EsUICallbackFunction, EsGeneric) -> ^EsElement)(rawptr(uintptr(0x1000 + 149 * size_of(int)))))(parent, flags, userCallback, _context); } -EsNewListView :: inline proc (parent :^EsElement, flags :u64, style :^EsListViewStyle, userCallback :EsUICallbackFunction, _context :EsGeneric) -> ^EsElement{ return ((proc (^EsElement, u64, ^EsListViewStyle, EsUICallbackFunction, EsGeneric) -> ^EsElement)(rawptr(uintptr(0x1000 + 150 * size_of(int)))))(parent, flags, style, userCallback, _context); } -EsElementGetInstance :: inline proc (element :^EsElement) -> ^EsInstance{ return ((proc (^EsElement) -> ^EsInstance)(rawptr(uintptr(0x1000 + 151 * size_of(int)))))(element); } -EsElementFocus :: inline proc (element :^EsElement, ensureVisible :bool){ ((proc (^EsElement, bool))(rawptr(uintptr(0x1000 + 152 * size_of(int)))))(element, ensureVisible); } -EsScrollbarSetMeasurements :: inline proc (scrollbar :^EsElement, viewportSize :i32, contentSize :i32){ ((proc (^EsElement, i32, i32))(rawptr(uintptr(0x1000 + 153 * size_of(int)))))(scrollbar, viewportSize, contentSize); } -EsScrollbarSetPosition :: inline proc (scrollbar :^EsElement, position :f32, sendMovedMessage :bool, smoothScroll :bool){ ((proc (^EsElement, f32, bool, bool))(rawptr(uintptr(0x1000 + 154 * size_of(int)))))(scrollbar, position, sendMovedMessage, smoothScroll); } -EsWindowGetBounds :: inline proc (window :^EsElement, bounds :^EsRectangle){ ((proc (^EsElement, ^EsRectangle))(rawptr(uintptr(0x1000 + 155 * size_of(int)))))(window, bounds); } -EsListViewInsert :: inline proc (listView :^EsElement, group :EsListViewIndex, index :EsListViewIndex, count :uintptr){ ((proc (^EsElement, EsListViewIndex, EsListViewIndex, uintptr))(rawptr(uintptr(0x1000 + 156 * size_of(int)))))(listView, group, index, count); } -EsListViewInsertGroup :: inline proc (listView :^EsElement, group :EsListViewIndex){ ((proc (^EsElement, EsListViewIndex))(rawptr(uintptr(0x1000 + 157 * size_of(int)))))(listView, group); } -EsListViewRemove :: inline proc (listView :^EsElement, group :EsListViewIndex, index :EsListViewIndex, count :int, removedHeight :i32){ ((proc (^EsElement, EsListViewIndex, EsListViewIndex, int, i32))(rawptr(uintptr(0x1000 + 158 * size_of(int)))))(listView, group, index, count, removedHeight); } -EsListViewRemoveGroup :: inline proc (listView :^EsElement, group :EsListViewIndex){ ((proc (^EsElement, EsListViewIndex))(rawptr(uintptr(0x1000 + 159 * size_of(int)))))(listView, group); } -EsListViewInvalidate :: inline proc (listView :^EsElement, deltaHeight :i32, recalculateHeight :bool){ ((proc (^EsElement, i32, bool))(rawptr(uintptr(0x1000 + 160 * size_of(int)))))(listView, deltaHeight, recalculateHeight); } -EsListViewEnsureVisible :: inline proc (listView :^EsElement, group :EsListViewIndex, index :EsListViewIndex){ ((proc (^EsElement, EsListViewIndex, EsListViewIndex))(rawptr(uintptr(0x1000 + 161 * size_of(int)))))(listView, group, index); } -EsListViewResetSearchBuffer :: inline proc (object :^EsElement){ ((proc (^EsElement))(rawptr(uintptr(0x1000 + 162 * size_of(int)))))(object); } -EsDataParse :: inline proc (cFormat :^i8, args : ..any) -> EsData{ return ((proc (^i8, ..any) -> EsData)(rawptr(uintptr(0x1000 + 163 * size_of(int)))))(cFormat, ); } -EsDataNone :: inline proc () -> EsData{ return ((proc () -> EsData)(rawptr(uintptr(0x1000 + 164 * size_of(int)))))(); } +NumericEntryProperties :: struct { + value :i32, + dp :i32, + delta :i32, + speed :i32, + minimum :i32, + maximum :i32, + cPrefix :^i8, + cSuffix :^i8, +} + +Batch :: inline proc (calls :^BatchCall, count :uintptr){ addr := 0x1000 + 0 * size_of(int); ((proc (^BatchCall, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(calls, count); } +ProcessCreate :: inline proc (executablePath :^i8, executablePathLength :uintptr, information :^ProcessInformation, argument :Generic) -> Error{ addr := 0x1000 + 1 * size_of(int); return ((proc (^i8, uintptr, ^ProcessInformation, Generic) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(executablePath, executablePathLength, information, argument); } +ThreadCreate :: inline proc (entryFunction :ThreadEntryFunction, information :^ThreadInformation, argument :Generic) -> Error{ addr := 0x1000 + 2 * size_of(int); return ((proc (ThreadEntryFunction, ^ThreadInformation, Generic) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(entryFunction, information, argument); } +SurfaceCreate :: inline proc (width :uintptr, height :uintptr, flags :u32) -> Handle{ addr := 0x1000 + 3 * size_of(int); return ((proc (uintptr, uintptr, u32) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(width, height, flags); } +EventCreate :: inline proc (autoReset :bool) -> Handle{ addr := 0x1000 + 4 * size_of(int); return ((proc (bool) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(autoReset); } +ThreadLocalStorageSetAddress :: inline proc (address :^rawptr){ addr := 0x1000 + 5 * size_of(int); ((proc (^rawptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(address); } +ConstantBufferRead :: inline proc (constantBuffer :Handle, output :^rawptr){ addr := 0x1000 + 6 * size_of(int); ((proc (Handle, ^rawptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(constantBuffer, output); } +ConstantBufferShare :: inline proc (constantBuffer :Handle, targetProcess :Handle) -> Handle{ addr := 0x1000 + 7 * size_of(int); return ((proc (Handle, Handle) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(constantBuffer, targetProcess); } +ConstantBufferCreate :: inline proc (data :^rawptr, dataBytes :uintptr, targetProcess :Handle) -> Handle{ addr := 0x1000 + 8 * size_of(int); return ((proc (^rawptr, uintptr, Handle) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(data, dataBytes, targetProcess); } +ProcessOpen :: inline proc (pid :u64) -> Handle{ addr := 0x1000 + 9 * size_of(int); return ((proc (u64) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(pid); } +HandleClose :: inline proc (handle :Handle) -> Error{ addr := 0x1000 + 10 * size_of(int); return ((proc (Handle) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(handle); } +TakeSystemSnapshot :: inline proc (type :i32, bufferSize :^uintptr) -> Handle{ addr := 0x1000 + 11 * size_of(int); return ((proc (i32, ^uintptr) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(type, bufferSize); } +GetSystemInformation :: inline proc (systemInformation :^SystemInformation){ addr := 0x1000 + 12 * size_of(int); ((proc (^SystemInformation))(rawptr(((^uintptr)(uintptr(addr)))^)))(systemInformation); } +NodeOpen :: inline proc (path :^i8, pathLength :uintptr, flags :u64, information :^NodeInformation) -> Error{ addr := 0x1000 + 13 * size_of(int); return ((proc (^i8, uintptr, u64, ^NodeInformation) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(path, pathLength, flags, information); } +NodeFindUniqueName :: inline proc (buffer :^i8, originalBytes :uintptr, bufferBytes :uintptr) -> uintptr{ addr := 0x1000 + 14 * size_of(int); return ((proc (^i8, uintptr, uintptr) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(buffer, originalBytes, bufferBytes); } +FileReadAll :: inline proc (filePath :^i8, filePathLength :uintptr, fileSize :^uintptr){ addr := 0x1000 + 15 * size_of(int); ((proc (^i8, uintptr, ^uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(filePath, filePathLength, fileSize); } +FileReadSync :: inline proc (file :Handle, offset :FileOffset, size :uintptr, buffer :^rawptr) -> uintptr{ addr := 0x1000 + 16 * size_of(int); return ((proc (Handle, FileOffset, uintptr, ^rawptr) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(file, offset, size, buffer); } +FileWriteSync :: inline proc (file :Handle, offset :FileOffset, size :uintptr, buffer :^rawptr) -> uintptr{ addr := 0x1000 + 17 * size_of(int); return ((proc (Handle, FileOffset, uintptr, ^rawptr) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(file, offset, size, buffer); } +FileResize :: inline proc (file :Handle, newSize :FileOffset) -> Error{ addr := 0x1000 + 18 * size_of(int); return ((proc (Handle, FileOffset) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(file, newSize); } +NodeRefreshInformation :: inline proc (information :^NodeInformation){ addr := 0x1000 + 19 * size_of(int); ((proc (^NodeInformation))(rawptr(((^uintptr)(uintptr(addr)))^)))(information); } +DirectoryEnumerateChildren :: inline proc (directory :Handle, buffer :^DirectoryChild, bufferCount :uintptr) -> int{ addr := 0x1000 + 20 * size_of(int); return ((proc (Handle, ^DirectoryChild, uintptr) -> int)(rawptr(((^uintptr)(uintptr(addr)))^)))(directory, buffer, bufferCount); } +NodeDelete :: inline proc (node :Handle) -> Error{ addr := 0x1000 + 21 * size_of(int); return ((proc (Handle) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(node); } +NodeMove :: inline proc (node :Handle, newDirectory :Handle, newName :^i8, newNameLength :uintptr) -> Error{ addr := 0x1000 + 22 * size_of(int); return ((proc (Handle, Handle, ^i8, uintptr) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(node, newDirectory, newName, newNameLength); } +ThreadTerminate :: inline proc (thread :Handle){ addr := 0x1000 + 23 * size_of(int); ((proc (Handle))(rawptr(((^uintptr)(uintptr(addr)))^)))(thread); } +ProcessTerminate :: inline proc (process :Handle, status :i32){ addr := 0x1000 + 24 * size_of(int); ((proc (Handle, i32))(rawptr(((^uintptr)(uintptr(addr)))^)))(process, status); } +ProcessTerminateCurrent :: inline proc (){ addr := 0x1000 + 25 * size_of(int); ((proc ())(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +ProcessPause :: inline proc (process :Handle, resume :bool){ addr := 0x1000 + 26 * size_of(int); ((proc (Handle, bool))(rawptr(((^uintptr)(uintptr(addr)))^)))(process, resume); } +ProcessCrash :: inline proc (error :Error, message :^i8, messageBytes :uintptr){ addr := 0x1000 + 27 * size_of(int); ((proc (Error, ^i8, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(error, message, messageBytes); } +ThreadGetID :: inline proc (thread :Handle) -> uintptr{ addr := 0x1000 + 28 * size_of(int); return ((proc (Handle) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(thread); } +ProcessGetID :: inline proc (process :Handle) -> uintptr{ addr := 0x1000 + 29 * size_of(int); return ((proc (Handle) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(process); } +SpinlockRelease :: inline proc (spinlock :^Spinlock){ addr := 0x1000 + 30 * size_of(int); ((proc (^Spinlock))(rawptr(((^uintptr)(uintptr(addr)))^)))(spinlock); } +SpinlockAcquire :: inline proc (spinlock :^Spinlock){ addr := 0x1000 + 31 * size_of(int); ((proc (^Spinlock))(rawptr(((^uintptr)(uintptr(addr)))^)))(spinlock); } +MutexRelease :: inline proc (mutex :^Mutex){ addr := 0x1000 + 32 * size_of(int); ((proc (^Mutex))(rawptr(((^uintptr)(uintptr(addr)))^)))(mutex); } +MutexAcquire :: inline proc (mutex :^Mutex){ addr := 0x1000 + 33 * size_of(int); ((proc (^Mutex))(rawptr(((^uintptr)(uintptr(addr)))^)))(mutex); } +MutexDestroy :: inline proc (mutex :^Mutex){ addr := 0x1000 + 34 * size_of(int); ((proc (^Mutex))(rawptr(((^uintptr)(uintptr(addr)))^)))(mutex); } +SchedulerYield :: inline proc (){ addr := 0x1000 + 35 * size_of(int); ((proc ())(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +EventSet :: inline proc (event :Handle){ addr := 0x1000 + 36 * size_of(int); ((proc (Handle))(rawptr(((^uintptr)(uintptr(addr)))^)))(event); } +EventReset :: inline proc (event :Handle){ addr := 0x1000 + 37 * size_of(int); ((proc (Handle))(rawptr(((^uintptr)(uintptr(addr)))^)))(event); } +EventPoll :: inline proc (event :Handle) -> Error{ addr := 0x1000 + 38 * size_of(int); return ((proc (Handle) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(event); } +Wait :: inline proc (objects :^Handle, objectCount :uintptr, timeoutMs :uintptr) -> uintptr{ addr := 0x1000 + 39 * size_of(int); return ((proc (^Handle, uintptr, uintptr) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(objects, objectCount, timeoutMs); } +Sleep :: inline proc (milliseconds :u64){ addr := 0x1000 + 40 * size_of(int); ((proc (u64))(rawptr(((^uintptr)(uintptr(addr)))^)))(milliseconds); } +MemoryOpen :: inline proc (size :uintptr, name :^i8, nameLength :uintptr, flags :u32) -> Handle{ addr := 0x1000 + 41 * size_of(int); return ((proc (uintptr, ^i8, uintptr, u32) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(size, name, nameLength, flags); } +MemoryShare :: inline proc (sharedMemoryRegion :Handle, targetProcess :Handle, readOnly :bool) -> Handle{ addr := 0x1000 + 42 * size_of(int); return ((proc (Handle, Handle, bool) -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(sharedMemoryRegion, targetProcess, readOnly); } +ObjectMap :: inline proc (object :Handle, offset :uintptr, size :uintptr, flags :u32){ addr := 0x1000 + 43 * size_of(int); ((proc (Handle, uintptr, uintptr, u32))(rawptr(((^uintptr)(uintptr(addr)))^)))(object, offset, size, flags); } +MemoryAllocate :: inline proc (size :uintptr){ addr := 0x1000 + 44 * size_of(int); ((proc (uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(size); } +MemoryFree :: inline proc (address :^rawptr) -> Error{ addr := 0x1000 + 45 * size_of(int); return ((proc (^rawptr) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(address); } +GetCreationArgument :: inline proc (object :Handle) -> Generic{ addr := 0x1000 + 46 * size_of(int); return ((proc (Handle) -> Generic)(rawptr(((^uintptr)(uintptr(addr)))^)))(object); } +ProcessGetState :: inline proc (process :Handle, state :^ProcessState){ addr := 0x1000 + 47 * size_of(int); ((proc (Handle, ^ProcessState))(rawptr(((^uintptr)(uintptr(addr)))^)))(process, state); } +SurfaceGetLinearBuffer :: inline proc (surface :Handle, linearBuffer :^LinearBuffer){ addr := 0x1000 + 48 * size_of(int); ((proc (Handle, ^LinearBuffer))(rawptr(((^uintptr)(uintptr(addr)))^)))(surface, linearBuffer); } +RectangleInvalidate :: inline proc (surface :Handle, rectangle :Rectangle){ addr := 0x1000 + 49 * size_of(int); ((proc (Handle, Rectangle))(rawptr(((^uintptr)(uintptr(addr)))^)))(surface, rectangle); } +CopyToScreen :: inline proc (source :Handle, point :Point, depth :u16){ addr := 0x1000 + 50 * size_of(int); ((proc (Handle, Point, u16))(rawptr(((^uintptr)(uintptr(addr)))^)))(source, point, depth); } +ForceScreenUpdate :: inline proc (){ addr := 0x1000 + 51 * size_of(int); ((proc ())(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +DrawRectangle :: inline proc (surface :Handle, rectangle :Rectangle, color :Color){ addr := 0x1000 + 52 * size_of(int); ((proc (Handle, Rectangle, Color))(rawptr(((^uintptr)(uintptr(addr)))^)))(surface, rectangle, color); } +DrawRectangleClipped :: inline proc (surface :Handle, rectangle :Rectangle, color :Color, clipRegion :Rectangle){ addr := 0x1000 + 53 * size_of(int); ((proc (Handle, Rectangle, Color, Rectangle))(rawptr(((^uintptr)(uintptr(addr)))^)))(surface, rectangle, color, clipRegion); } +DrawSurfaceBlit :: inline proc (destination :Handle, source :Handle, destinationPoint :Point){ addr := 0x1000 + 54 * size_of(int); ((proc (Handle, Handle, Point))(rawptr(((^uintptr)(uintptr(addr)))^)))(destination, source, destinationPoint); } +DrawSurface :: inline proc (destination :Handle, source :Handle, destinationRegion :Rectangle, sourceRegion :Rectangle, borderRegion :Rectangle, mode :DrawMode, alpha :u16) -> Error{ addr := 0x1000 + 55 * size_of(int); return ((proc (Handle, Handle, Rectangle, Rectangle, Rectangle, DrawMode, u16) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(destination, source, destinationRegion, sourceRegion, borderRegion, mode, alpha); } +DrawSurfaceClipped :: inline proc (destination :Handle, source :Handle, destinationRegion :Rectangle, sourceRegion :Rectangle, borderRegion :Rectangle, mode :DrawMode, alpha :u16, clipRegion :Rectangle) -> Error{ addr := 0x1000 + 56 * size_of(int); return ((proc (Handle, Handle, Rectangle, Rectangle, Rectangle, DrawMode, u16, Rectangle) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(destination, source, destinationRegion, sourceRegion, borderRegion, mode, alpha, clipRegion); } +DrawBitmap :: inline proc (destination :Handle, destinationPoint :Point, bitmap :^rawptr, width :uintptr, height :uintptr, stride :uintptr, colorFormat :ColorFormat){ addr := 0x1000 + 57 * size_of(int); ((proc (Handle, Point, ^rawptr, uintptr, uintptr, uintptr, ColorFormat))(rawptr(((^uintptr)(uintptr(addr)))^)))(destination, destinationPoint, bitmap, width, height, stride, colorFormat); } +SurfaceClearInvalidatedRegion :: inline proc (surface :Handle){ addr := 0x1000 + 58 * size_of(int); ((proc (Handle))(rawptr(((^uintptr)(uintptr(addr)))^)))(surface); } +RectangleClip :: inline proc (parent :Rectangle, rectangle :Rectangle, output :^Rectangle) -> bool{ addr := 0x1000 + 59 * size_of(int); return ((proc (Rectangle, Rectangle, ^Rectangle) -> bool)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, rectangle, output); } +DrawBox :: inline proc (surface :Handle, rectangle :Rectangle, style :u8, color :u32, clipRegion :Rectangle){ addr := 0x1000 + 60 * size_of(int); ((proc (Handle, Rectangle, u8, u32, Rectangle))(rawptr(((^uintptr)(uintptr(addr)))^)))(surface, rectangle, style, color, clipRegion); } +RedrawAll :: inline proc (){ addr := 0x1000 + 61 * size_of(int); ((proc ())(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +MessagePost :: inline proc (message :^Message) -> Error{ addr := 0x1000 + 62 * size_of(int); return ((proc (^Message) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(message); } +MessagePostRemote :: inline proc (process :Handle, message :^Message) -> Error{ addr := 0x1000 + 63 * size_of(int); return ((proc (Handle, ^Message) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(process, message); } +ExtractArguments :: inline proc (string :^i8, bytes :uintptr, delimiterByte :u8, replacementDelimiter :u8, argvAllocated :uintptr, argv :^^i8, argc :^uintptr) -> bool{ addr := 0x1000 + 64 * size_of(int); return ((proc (^i8, uintptr, u8, u8, uintptr, ^^i8, ^uintptr) -> bool)(rawptr(((^uintptr)(uintptr(addr)))^)))(string, bytes, delimiterByte, replacementDelimiter, argvAllocated, argv, argc); } +CStringLength :: inline proc (string :^i8) -> uintptr{ addr := 0x1000 + 65 * size_of(int); return ((proc (^i8) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(string); } +StringLength :: inline proc (string :^i8, end :u8) -> uintptr{ addr := 0x1000 + 66 * size_of(int); return ((proc (^i8, u8) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(string, end); } +MemoryCopy :: inline proc (destination :^rawptr, source :^rawptr, bytes :uintptr){ addr := 0x1000 + 67 * size_of(int); ((proc (^rawptr, ^rawptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(destination, source, bytes); } +MemoryMove :: inline proc (_start :^rawptr, _end :^rawptr, amount :int, zeroEmptySpace :bool){ addr := 0x1000 + 68 * size_of(int); ((proc (^rawptr, ^rawptr, int, bool))(rawptr(((^uintptr)(uintptr(addr)))^)))(_start, _end, amount, zeroEmptySpace); } +MemoryCopyReverse :: inline proc (_destination :^rawptr, _source :^rawptr, bytes :uintptr){ addr := 0x1000 + 69 * size_of(int); ((proc (^rawptr, ^rawptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(_destination, _source, bytes); } +MemoryZero :: inline proc (destination :^rawptr, bytes :uintptr){ addr := 0x1000 + 70 * size_of(int); ((proc (^rawptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(destination, bytes); } +MemoryCompare :: inline proc (a :^rawptr, b :^rawptr, bytes :uintptr) -> i32{ addr := 0x1000 + 71 * size_of(int); return ((proc (^rawptr, ^rawptr, uintptr) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(a, b, bytes); } +MemorySumBytes :: inline proc (data :^u8, bytes :uintptr) -> u8{ addr := 0x1000 + 72 * size_of(int); return ((proc (^u8, uintptr) -> u8)(rawptr(((^uintptr)(uintptr(addr)))^)))(data, bytes); } +PrintDirect :: inline proc (string :^i8, stringLength :uintptr){ addr := 0x1000 + 73 * size_of(int); ((proc (^i8, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(string, stringLength); } +StringFormat :: inline proc (buffer :^i8, bufferLength :uintptr, format :^i8, args : ..any) -> uintptr{ addr := 0x1000 + 74 * size_of(int); return ((proc (^i8, uintptr, ^i8, ..any) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(buffer, bufferLength, format, ); } +StringFormatAppend :: inline proc (buffer :^i8, bufferLength :uintptr, bufferPosition :^uintptr, format :^i8, args : ..any){ addr := 0x1000 + 75 * size_of(int); ((proc (^i8, uintptr, ^uintptr, ^i8, ..any))(rawptr(((^uintptr)(uintptr(addr)))^)))(buffer, bufferLength, bufferPosition, format, ); } +PrintHelloWorld :: inline proc (){ addr := 0x1000 + 76 * size_of(int); ((proc ())(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +GetRandomByte :: inline proc () -> u8{ addr := 0x1000 + 77 * size_of(int); return ((proc () -> u8)(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +Sort :: inline proc (_base :^rawptr, nmemb :uintptr, size :uintptr, compar :ComparisonCallbackFunction, argument :Generic){ addr := 0x1000 + 78 * size_of(int); ((proc (^rawptr, uintptr, uintptr, ComparisonCallbackFunction, Generic))(rawptr(((^uintptr)(uintptr(addr)))^)))(_base, nmemb, size, compar, argument); } +SortWithSwapCallback :: inline proc (_base :^rawptr, nmemb :uintptr, size :uintptr, compar :ComparisonCallbackFunction, argument :Generic, swap :SwapCallbackFunction){ addr := 0x1000 + 79 * size_of(int); ((proc (^rawptr, uintptr, uintptr, ComparisonCallbackFunction, Generic, SwapCallbackFunction))(rawptr(((^uintptr)(uintptr(addr)))^)))(_base, nmemb, size, compar, argument, swap); } +StringCompare :: inline proc (s1 :^i8, s2 :^i8, length1 :uintptr, length2 :uintptr) -> i32{ addr := 0x1000 + 80 * size_of(int); return ((proc (^i8, ^i8, uintptr, uintptr) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(s1, s2, length1, length2); } +IntegerParse :: inline proc (text :^i8, bytes :uintptr) -> i64{ addr := 0x1000 + 81 * size_of(int); return ((proc (^i8, uintptr) -> i64)(rawptr(((^uintptr)(uintptr(addr)))^)))(text, bytes); } +CRTmemset :: inline proc (s :^rawptr, c :i32, n :uintptr){ addr := 0x1000 + 82 * size_of(int); ((proc (^rawptr, i32, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(s, c, n); } +CRTmemcpy :: inline proc (dest :^rawptr, src :^rawptr, n :uintptr){ addr := 0x1000 + 83 * size_of(int); ((proc (^rawptr, ^rawptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(dest, src, n); } +CRTmemmove :: inline proc (dest :^rawptr, src :^rawptr, n :uintptr){ addr := 0x1000 + 84 * size_of(int); ((proc (^rawptr, ^rawptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(dest, src, n); } +CRTstrlen :: inline proc (s :^i8) -> uintptr{ addr := 0x1000 + 85 * size_of(int); return ((proc (^i8) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(s); } +CRTstrnlen :: inline proc (s :^i8, maxlen :uintptr) -> uintptr{ addr := 0x1000 + 86 * size_of(int); return ((proc (^i8, uintptr) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(s, maxlen); } +CRTmalloc :: inline proc (size :uintptr){ addr := 0x1000 + 87 * size_of(int); ((proc (uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(size); } +CRTcalloc :: inline proc (num :uintptr, size :uintptr){ addr := 0x1000 + 88 * size_of(int); ((proc (uintptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(num, size); } +CRTfree :: inline proc (ptr :^rawptr){ addr := 0x1000 + 89 * size_of(int); ((proc (^rawptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(ptr); } +CRTabs :: inline proc (n :i32) -> i32{ addr := 0x1000 + 90 * size_of(int); return ((proc (i32) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(n); } +CRTrealloc :: inline proc (ptr :^rawptr, size :uintptr){ addr := 0x1000 + 91 * size_of(int); ((proc (^rawptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(ptr, size); } +CRTgetenv :: inline proc (name :^i8) -> ^i8{ addr := 0x1000 + 92 * size_of(int); return ((proc (^i8) -> ^i8)(rawptr(((^uintptr)(uintptr(addr)))^)))(name); } +CRTstrncmp :: inline proc (s1 :^i8, s2 :^i8, n :uintptr) -> i32{ addr := 0x1000 + 93 * size_of(int); return ((proc (^i8, ^i8, uintptr) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(s1, s2, n); } +CRTmemcmp :: inline proc (s1 :^rawptr, s2 :^rawptr, n :uintptr) -> i32{ addr := 0x1000 + 94 * size_of(int); return ((proc (^rawptr, ^rawptr, uintptr) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(s1, s2, n); } +CRTqsort :: inline proc (_base :^rawptr, nmemb :uintptr, size :uintptr, compar :CRTComparisonCallback){ addr := 0x1000 + 95 * size_of(int); ((proc (^rawptr, uintptr, uintptr, CRTComparisonCallback))(rawptr(((^uintptr)(uintptr(addr)))^)))(_base, nmemb, size, compar); } +CRTstrcmp :: inline proc (s1 :^i8, s2 :^i8) -> i32{ addr := 0x1000 + 96 * size_of(int); return ((proc (^i8, ^i8) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(s1, s2); } +CRTstrstr :: inline proc (haystack :^i8, needle :^i8) -> ^i8{ addr := 0x1000 + 97 * size_of(int); return ((proc (^i8, ^i8) -> ^i8)(rawptr(((^uintptr)(uintptr(addr)))^)))(haystack, needle); } +CRTstrcpy :: inline proc (dest :^i8, src :^i8) -> ^i8{ addr := 0x1000 + 98 * size_of(int); return ((proc (^i8, ^i8) -> ^i8)(rawptr(((^uintptr)(uintptr(addr)))^)))(dest, src); } +CRTisalpha :: inline proc (c :i32) -> i32{ addr := 0x1000 + 99 * size_of(int); return ((proc (i32) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(c); } +CRTmemchr :: inline proc (_s :^rawptr, _c :i32, n :uintptr){ addr := 0x1000 + 100 * size_of(int); ((proc (^rawptr, i32, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(_s, _c, n); } +CRTisdigit :: inline proc (c :i32) -> i32{ addr := 0x1000 + 101 * size_of(int); return ((proc (i32) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(c); } +CRTstrcat :: inline proc (dest :^i8, src :^i8) -> ^i8{ addr := 0x1000 + 102 * size_of(int); return ((proc (^i8, ^i8) -> ^i8)(rawptr(((^uintptr)(uintptr(addr)))^)))(dest, src); } +CRTtolower :: inline proc (c :i32) -> i32{ addr := 0x1000 + 103 * size_of(int); return ((proc (i32) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(c); } +CRTstrncpy :: inline proc (dest :^i8, src :^i8, n :uintptr) -> ^i8{ addr := 0x1000 + 104 * size_of(int); return ((proc (^i8, ^i8, uintptr) -> ^i8)(rawptr(((^uintptr)(uintptr(addr)))^)))(dest, src, n); } +CRTstrtoul :: inline proc (nptr :^i8, endptr :^^i8, base :i32) -> u64{ addr := 0x1000 + 105 * size_of(int); return ((proc (^i8, ^^i8, i32) -> u64)(rawptr(((^uintptr)(uintptr(addr)))^)))(nptr, endptr, base); } +Execute :: inline proc (what :^i8, whatBytes :uintptr, argument :^i8, argumentBytes :uintptr){ addr := 0x1000 + 106 * size_of(int); ((proc (^i8, uintptr, ^i8, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(what, whatBytes, argument, argumentBytes); } +Abort :: inline proc (){ addr := 0x1000 + 107 * size_of(int); ((proc ())(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +MailslotSendData :: inline proc (mailslot :Handle, data :^rawptr, bytes :uintptr) -> bool{ addr := 0x1000 + 108 * size_of(int); return ((proc (Handle, ^rawptr, uintptr) -> bool)(rawptr(((^uintptr)(uintptr(addr)))^)))(mailslot, data, bytes); } +CRTfloorf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 109 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTceilf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 110 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTsinf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 111 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTcosf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 112 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTatan2f :: inline proc (y :f32, x :f32) -> f32{ addr := 0x1000 + 113 * size_of(int); return ((proc (f32, f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(y, x); } +CRTfmodf :: inline proc (x :f32, y :f32) -> f32{ addr := 0x1000 + 114 * size_of(int); return ((proc (f32, f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x, y); } +CRTacosf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 115 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTasinf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 116 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTatanf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 117 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +RandomSeed :: inline proc (x :u64){ addr := 0x1000 + 118 * size_of(int); ((proc (u64))(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTsqrtf :: inline proc (x :f32) -> f32{ addr := 0x1000 + 119 * size_of(int); return ((proc (f32) -> f32)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTsqrtl :: inline proc (x :LongDouble) -> LongDouble{ addr := 0x1000 + 120 * size_of(int); return ((proc (LongDouble) -> LongDouble)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +CRTfabsl :: inline proc (x :LongDouble) -> LongDouble{ addr := 0x1000 + 121 * size_of(int); return ((proc (LongDouble) -> LongDouble)(rawptr(((^uintptr)(uintptr(addr)))^)))(x); } +Syscall :: inline proc (a :uintptr, b :uintptr, c :uintptr, d :uintptr, e :uintptr, f :uintptr) -> uintptr{ addr := 0x1000 + 122 * size_of(int); return ((proc (uintptr, uintptr, uintptr, uintptr, uintptr, uintptr) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(a, b, c, d, e, f); } +ProcessorReadTimeStamp :: inline proc () -> u64{ addr := 0x1000 + 123 * size_of(int); return ((proc () -> u64)(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +HeapAllocate :: inline proc (size :uintptr, zeroMemory :bool){ addr := 0x1000 + 124 * size_of(int); ((proc (uintptr, bool))(rawptr(((^uintptr)(uintptr(addr)))^)))(size, zeroMemory); } +HeapFree :: inline proc (address :^rawptr){ addr := 0x1000 + 125 * size_of(int); ((proc (^rawptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(address); } +Print :: inline proc (format :^i8, args : ..any){ addr := 0x1000 + 126 * size_of(int); ((proc (^i8, ..any))(rawptr(((^uintptr)(uintptr(addr)))^)))(format, ); } +MemoryFill :: inline proc (from :^rawptr, to :^rawptr, byte :u8){ addr := 0x1000 + 127 * size_of(int); ((proc (^rawptr, ^rawptr, u8))(rawptr(((^uintptr)(uintptr(addr)))^)))(from, to, byte); } +InitialiseCStandardLibrary :: inline proc (argc :^i32, argv :^^^i8){ addr := 0x1000 + 128 * size_of(int); ((proc (^i32, ^^^i8))(rawptr(((^uintptr)(uintptr(addr)))^)))(argc, argv); } +MakeLinuxSystemCall2 :: inline proc (n :int, a1 :int, a2 :int, a3 :int, a4 :int, a5 :int, a6 :int) -> int{ addr := 0x1000 + 129 * size_of(int); return ((proc (int, int, int, int, int, int, int) -> int)(rawptr(((^uintptr)(uintptr(addr)))^)))(n, a1, a2, a3, a4, a5, a6); } +ProcessCreate2 :: inline proc (arguments :^ProcessCreationArguments, information :^ProcessInformation) -> Error{ addr := 0x1000 + 130 * size_of(int); return ((proc (^ProcessCreationArguments, ^ProcessInformation) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(arguments, information); } +CRTatoi :: inline proc (string :^i8) -> i32{ addr := 0x1000 + 131 * size_of(int); return ((proc (^i8) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(string); } +ProcessGetExitStatus :: inline proc (process :Handle) -> i32{ addr := 0x1000 + 132 * size_of(int); return ((proc (Handle) -> i32)(rawptr(((^uintptr)(uintptr(addr)))^)))(process); } +SurfaceReset :: inline proc (surface :Handle){ addr := 0x1000 + 133 * size_of(int); ((proc (Handle))(rawptr(((^uintptr)(uintptr(addr)))^)))(surface); } +TimerCreate :: inline proc () -> Handle{ addr := 0x1000 + 134 * size_of(int); return ((proc () -> Handle)(rawptr(((^uintptr)(uintptr(addr)))^)))(); } +TimerSet :: inline proc (handle :Handle, afterMs :u64, object :Object, argument :Generic){ addr := 0x1000 + 135 * size_of(int); ((proc (Handle, u64, Object, Generic))(rawptr(((^uintptr)(uintptr(addr)))^)))(handle, afterMs, object, argument); } +FileWriteAll :: inline proc (filePath :^i8, filePathLength :uintptr, data :^rawptr, fileSize :uintptr) -> Error{ addr := 0x1000 + 136 * size_of(int); return ((proc (^i8, uintptr, ^rawptr, uintptr) -> Error)(rawptr(((^uintptr)(uintptr(addr)))^)))(filePath, filePathLength, data, fileSize); } +UserGetHomeFolder :: inline proc (buffer :^i8, bufferBytes :uintptr) -> uintptr{ addr := 0x1000 + 137 * size_of(int); return ((proc (^i8, uintptr) -> uintptr)(rawptr(((^uintptr)(uintptr(addr)))^)))(buffer, bufferBytes); } +Assert :: inline proc (expression :bool, failureMessage :^i8){ addr := 0x1000 + 138 * size_of(int); ((proc (bool, ^i8))(rawptr(((^uintptr)(uintptr(addr)))^)))(expression, failureMessage); } +ResizeArray :: inline proc (array :^^rawptr, allocated :^uintptr, needed :uintptr, itemSize :uintptr){ addr := 0x1000 + 139 * size_of(int); ((proc (^^rawptr, ^uintptr, uintptr, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(array, allocated, needed, itemSize); } +MessageLoopEnter :: inline proc (callback :MessageCallbackFunction = nil){ addr := 0x1000 + 140 * size_of(int); ((proc (MessageCallbackFunction))(rawptr(((^uintptr)(uintptr(addr)))^)))(callback); } +InstanceCreate :: inline proc (bytes :uintptr) -> ^Instance{ addr := 0x1000 + 141 * size_of(int); return ((proc (uintptr) -> ^Instance)(rawptr(((^uintptr)(uintptr(addr)))^)))(bytes); } +MouseGetPosition :: inline proc (relativeWindow :^Window = nil) -> Point{ addr := 0x1000 + 142 * size_of(int); return ((proc (^Window) -> Point)(rawptr(((^uintptr)(uintptr(addr)))^)))(relativeWindow); } +MouseSetPosition :: inline proc (relativeWindow :^Window, x :i32, y :i32){ addr := 0x1000 + 143 * size_of(int); ((proc (^Window, i32, i32))(rawptr(((^uintptr)(uintptr(addr)))^)))(relativeWindow, x, y); } +NewPanel :: inline proc (parent :^Element, cStyle :^i8, flags :u64 = FLAGS_DEFAULT) -> ^Panel{ addr := 0x1000 + 144 * size_of(int); return ((proc (^Element, ^i8, u64) -> ^Panel)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, cStyle, flags); } +NewCustomPanel :: inline proc (parent :^Element, style :Data, flags :u64 = FLAGS_DEFAULT) -> ^Panel{ addr := 0x1000 + 145 * size_of(int); return ((proc (^Element, Data, u64) -> ^Panel)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, style, flags); } +NewWindow :: inline proc (instance :^Instance, style :WindowStyle = WindowStyle.WINDOW_NORMAL) -> ^Window{ addr := 0x1000 + 146 * size_of(int); return ((proc (^Instance, WindowStyle) -> ^Window)(rawptr(((^uintptr)(uintptr(addr)))^)))(instance, style); } +NewScrollbar :: inline proc (parent :^Element, flags :u64 = FLAGS_DEFAULT, userCallback :UICallbackFunction = nil, _context :Generic = nil) -> ^Scrollbar{ addr := 0x1000 + 147 * size_of(int); return ((proc (^Element, u64, UICallbackFunction, Generic) -> ^Scrollbar)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, flags, userCallback, _context); } +NewButton :: inline proc (parent :^Element, label :^i8 = nil, labelBytes :int = -1, flags :u64 = FLAGS_DEFAULT, userCallback :UICallbackFunction = nil, _context :Generic = nil) -> ^Button{ addr := 0x1000 + 148 * size_of(int); return ((proc (^Element, ^i8, int, u64, UICallbackFunction, Generic) -> ^Button)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, label, labelBytes, flags, userCallback, _context); } +NewTextbox :: inline proc (parent :^Element, flags :u64 = FLAGS_DEFAULT, userCallback :UICallbackFunction = nil, _context :Generic = nil) -> ^Textbox{ addr := 0x1000 + 149 * size_of(int); return ((proc (^Element, u64, UICallbackFunction, Generic) -> ^Textbox)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, flags, userCallback, _context); } +NewNumericEntry :: inline proc (parent :^Element, flags :u64 = FLAGS_DEFAULT, userCallback :UICallbackFunction = nil, _context :Generic = nil) -> ^NumericEntry{ addr := 0x1000 + 150 * size_of(int); return ((proc (^Element, u64, UICallbackFunction, Generic) -> ^NumericEntry)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, flags, userCallback, _context); } +NewListView :: inline proc (parent :^Element, flags :u64 = FLAGS_DEFAULT, style :^ListViewStyle = nil, userCallback :UICallbackFunction = nil, _context :Generic = nil) -> ^ListView{ addr := 0x1000 + 151 * size_of(int); return ((proc (^Element, u64, ^ListViewStyle, UICallbackFunction, Generic) -> ^ListView)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, flags, style, userCallback, _context); } +NewMenu :: inline proc (parent :^Element, flags :u64 = FLAGS_DEFAULT, userCallback :MenuCallbackFunction = nil, _context :Generic = nil) -> ^Menu{ addr := 0x1000 + 152 * size_of(int); return ((proc (^Element, u64, MenuCallbackFunction, Generic) -> ^Menu)(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, flags, userCallback, _context); } +NewMenuItem :: inline proc (parent :^Element, flags :u64, label :^i8, labelBytes :int = -1, callback :MenuCallbackFunction = nil, _context :Generic = nil){ addr := 0x1000 + 153 * size_of(int); ((proc (^Element, u64, ^i8, int, MenuCallbackFunction, Generic))(rawptr(((^uintptr)(uintptr(addr)))^)))(parent, flags, label, labelBytes, callback, _context); } +ElementGetInstance :: inline proc (element :^Element) -> ^INSTANCE_TYPE{ addr := 0x1000 + 154 * size_of(int); return ((proc (^Element) -> ^INSTANCE_TYPE)(rawptr(((^uintptr)(uintptr(addr)))^)))(element); } +ElementFocus :: inline proc (element :^Element, ensureVisible :bool){ addr := 0x1000 + 155 * size_of(int); ((proc (^Element, bool))(rawptr(((^uintptr)(uintptr(addr)))^)))(element, ensureVisible); } +ElementSetDisabled :: inline proc (element :^Element, disabled :bool){ addr := 0x1000 + 156 * size_of(int); ((proc (^Element, bool))(rawptr(((^uintptr)(uintptr(addr)))^)))(element, disabled); } +ElementSetCallback :: inline proc (element :^Element, callback :UICallbackFunction, _context :Generic){ addr := 0x1000 + 157 * size_of(int); ((proc (^Element, UICallbackFunction, Generic))(rawptr(((^uintptr)(uintptr(addr)))^)))(element, callback, _context); } +ScrollbarSetMeasurements :: inline proc (scrollbar :^Scrollbar, viewportSize :i32, contentSize :i32){ addr := 0x1000 + 158 * size_of(int); ((proc (^Scrollbar, i32, i32))(rawptr(((^uintptr)(uintptr(addr)))^)))(scrollbar, viewportSize, contentSize); } +ScrollbarSetPosition :: inline proc (scrollbar :^Scrollbar, position :f32, sendMovedMessage :bool, smoothScroll :bool){ addr := 0x1000 + 159 * size_of(int); ((proc (^Scrollbar, f32, bool, bool))(rawptr(((^uintptr)(uintptr(addr)))^)))(scrollbar, position, sendMovedMessage, smoothScroll); } +WindowGetBounds :: inline proc (window :^Window) -> Rectangle{ addr := 0x1000 + 160 * size_of(int); return ((proc (^Window) -> Rectangle)(rawptr(((^uintptr)(uintptr(addr)))^)))(window); } +WindowGetToolbar :: inline proc (window :^Window) -> ^Element{ addr := 0x1000 + 161 * size_of(int); return ((proc (^Window) -> ^Element)(rawptr(((^uintptr)(uintptr(addr)))^)))(window); } +ListViewInsert :: inline proc (listView :^ListView, group :ListViewIndex, index :ListViewIndex, count :uintptr){ addr := 0x1000 + 162 * size_of(int); ((proc (^ListView, ListViewIndex, ListViewIndex, uintptr))(rawptr(((^uintptr)(uintptr(addr)))^)))(listView, group, index, count); } +ListViewInsertGroup :: inline proc (listView :^ListView, group :ListViewIndex){ addr := 0x1000 + 163 * size_of(int); ((proc (^ListView, ListViewIndex))(rawptr(((^uintptr)(uintptr(addr)))^)))(listView, group); } +ListViewRemove :: inline proc (listView :^ListView, group :ListViewIndex, index :ListViewIndex, count :int, removedHeight :i32){ addr := 0x1000 + 164 * size_of(int); ((proc (^ListView, ListViewIndex, ListViewIndex, int, i32))(rawptr(((^uintptr)(uintptr(addr)))^)))(listView, group, index, count, removedHeight); } +ListViewRemoveGroup :: inline proc (listView :^ListView, group :ListViewIndex){ addr := 0x1000 + 165 * size_of(int); ((proc (^ListView, ListViewIndex))(rawptr(((^uintptr)(uintptr(addr)))^)))(listView, group); } +ListViewInvalidate :: inline proc (listView :^ListView, deltaHeight :i32, recalculateHeight :bool){ addr := 0x1000 + 166 * size_of(int); ((proc (^ListView, i32, bool))(rawptr(((^uintptr)(uintptr(addr)))^)))(listView, deltaHeight, recalculateHeight); } +ListViewEnsureVisible :: inline proc (listView :^ListView, group :ListViewIndex, index :ListViewIndex){ addr := 0x1000 + 167 * size_of(int); ((proc (^ListView, ListViewIndex, ListViewIndex))(rawptr(((^uintptr)(uintptr(addr)))^)))(listView, group, index); } +ListViewResetSearchBuffer :: inline proc (listView :^ListView){ addr := 0x1000 + 168 * size_of(int); ((proc (^ListView))(rawptr(((^uintptr)(uintptr(addr)))^)))(listView); } +ButtonSetIcon :: inline proc (button :^Button, iconID :u32){ addr := 0x1000 + 169 * size_of(int); ((proc (^Button, u32))(rawptr(((^uintptr)(uintptr(addr)))^)))(button, iconID); } +DataParse :: inline proc (cFormat :^i8, args : ..any) -> Data{ addr := 0x1000 + 170 * size_of(int); return ((proc (^i8, ..any) -> Data)(rawptr(((^uintptr)(uintptr(addr)))^)))(cFormat, ); } + ////////////////////////////////////////////////////// -Handle :: distinct i32; Errno :: distinct i32; -INVALID_HANDLE :: ~Handle(0); - stdin: Handle = 0; stdout: Handle = 1; stderr: Handle = 2; @@ -1309,6 +2393,7 @@ O_SYNC :: 0x01000; O_ASYNC :: 0x02000; O_CLOEXEC :: 0x80000; +ERROR_SUCCESS :: 0; ERROR_UNSUPPORTED :: 1; read :: proc(fd: Handle, data: []byte) -> (int, Errno) { @@ -1316,11 +2401,16 @@ read :: proc(fd: Handle, data: []byte) -> (int, Errno) { } write :: proc(fd: Handle, data: []byte) -> (int, Errno) { + if (fd == stdout) { + PrintDirect((^i8)(&data[0]), (uintptr)(len(data))); + return len(data), ERROR_SUCCESS; + } + return -1, ERROR_UNSUPPORTED; } open :: proc(path: string, flags: int = O_RDONLY, mode: int = 0) -> (Handle, Errno) { - return -1, ERROR_UNSUPPORTED; + return INVALID_HANDLE, ERROR_UNSUPPORTED; } close :: proc(fd: Handle) -> Errno {