ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-17 00:11:25 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
2afe4bea67ff50c2ad41ff7c3ba7fbdc18748746
Odin/core/os/os_essence.odin
T

1351 lines
62 KiB
Odin
Raw Blame History

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,
}
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,
}
EsStandardFont :: enum {
ES_STANDARD_FONT_REGULAR,
ES_STANDARD_FONT_BOLD,
ES_STANDARD_FONT_MONOSPACED,
}
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,
}
EsDrawMode :: enum {
ES_DRAW_MODE_REPEAT_FIRST = 1 ,
ES_DRAW_MODE_STRECH,
ES_DRAW_MODE_REPEAT,
ES_DRAW_MODE_NONE,
}
EsClipboardFormat :: enum {
ES_CLIPBOARD_FORMAT_EMPTY,
ES_CLIPBOARD_FORMAT_TEXT,
ES_CLIPBOARD_FORMAT_FILE_LIST,
}
EsColorFormat :: enum {
ES_COLOR_FORMAT_32_XRGB,
}
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,
}
EsWindowStyle :: enum {
ES_WINDOW_NORMAL,
ES_WINDOW_CONTAINER,
ES_WINDOW_MENU,
}
ES_NODE_FILE :: (0);
ES_NODE_DIRECTORY :: (0x4000);
ES_NODE_INVALID :: (0x8000);
EsBatchCall :: struct {
index :EsSyscallType,
stopBatchIfError :bool,
using _ : struct #raw_union {
argument0 :uintptr,
returnValue :uintptr,
},
argument1 :uintptr,
argument2 :uintptr,
argument3 :uintptr,
}
EsThreadInformation :: struct {
handle :EsHandle,
tid :uintptr,
}
EsProcessInformation :: struct {
handle :EsHandle,
pid :uintptr,
mainThread :EsThreadInformation,
}
EsUniqueIdentifier :: struct {
using _ : struct #raw_union {
d :[16]u8,
},
}
EsNodeInformation :: struct {
handle :EsHandle,
type :EsNodeType,
using _ : struct #raw_union {
fileSize :EsFileOffset,
directoryChildren :EsFileOffset,
},
}
EsDirectoryChild :: struct {
name :[ES_MAX_DIRECTORY_CHILD_NAME_LENGTH]i8,
nameBytes :uintptr,
information :EsNodeInformation,
}
EsPoint :: struct {
x :i32,
y :i32,
}
EsRectangle :: struct {
left :i32,
right :i32,
top :i32,
bottom :i32,
}
EsRectangle16 :: struct {
left :i16,
right :i16,
top :i16,
bottom :i16,
}
EsColor :: struct {
using _ : struct #raw_union {
using _ : struct {
blue :u8,
green :u8,
red :u8,
},
combined :u32,
},
}
EsLinearBuffer :: struct {
width :uintptr,
height :uintptr,
stride :uintptr,
colorFormat :EsColorFormat,
handle :EsHandle,
flags :u32,
}
_EsRectangleAndColor :: struct {
rectangle :EsRectangle,
color :EsColor,
}
_EsStyledBoxData :: struct {
backgroundColor :u32,
borderColor :u32,
borderSize :u8,
cornerRadius :u8,
roundedCornersToExclude :u8,
ox :i32,
oy :i32,
width :i32,
height :i32,
clip :EsRectangle,
}
_EsInstanceCreateRemoteArguments :: struct {
what :^i8,
argument :^i8,
whatBytes :uintptr,
argumentBytes :uintptr,
modalWindowParent :EsHandle,
apiInstance :^rawptr,
}
_EsDrawSurfaceArguments :: struct {
source :EsRectangle,
destination :EsRectangle,
border :EsRectangle,
alpha :u16,
}
EsSpinlock :: struct {
state :u8,
}
EsMutex :: struct {
event :EsHandle,
spinlock :EsSpinlock,
state :u8,
queued :u32,
}
EsCrashReason :: struct {
errorCode :EsError,
}
EsProcessState :: struct {
crashReason :EsCrashReason,
creationArgument :EsGeneric,
id :uintptr,
executableState :uintptr,
flags :u8,
}
EsIORequestProgress :: struct {
accessed :EsFileOffset,
progress :EsFileOffset,
completed :bool,
cancelled :bool,
error :EsError,
}
EsClipboardHeader :: struct {
customBytes :uintptr,
format :EsClipboardFormat,
textBytes :uintptr,
unused :uintptr,
}
EsPainter :: struct {
surface :EsHandle,
clip :EsRectangle,
offsetX :i32,
offsetY :i32,
}
EsMessage :: struct {
type :EsMessageType,
_context :EsGeneric,
using _ : struct #raw_union {
_argument :^rawptr,
mouseMoved : struct {
oldPositionX :i32,
newPositionX :i32,
oldPositionY :i32,
newPositionY :i32,
newPositionXScreen :i32,
newPositionYScreen :i32,
},
mouseDragged : struct {
oldPositionX :i32,
newPositionX :i32,
oldPositionY :i32,
newPositionY :i32,
originalPositionX :i32,
originalPositionY :i32,
},
mousePressed : struct {
positionX :i32,
positionY :i32,
positionXScreen :i32,
positionYScreen :i32,
clickChainCount :u8,
activationClick :u8,
alt :u8,
ctrl :u8,
shift :u8,
},
keyboard : struct {
scancode :u32,
alt :u8,
ctrl :u8,
shift :u8,
numpad :u8,
notHandledBy :EsObject,
},
crash : struct {
reason :EsCrashReason,
process :EsHandle,
processNameBuffer :EsHandle,
processNameBytes :uintptr,
pid :uintptr,
},
clipboard :EsClipboardHeader,
receive : struct {
buffer :EsHandle,
bytes :uintptr,
},
animate : struct {
deltaMcs :i64,
waitMcs :i64,
complete :bool,
},
systemConstantUpdated : struct {
index :uintptr,
newValue :u64,
},
desktopExecute : struct {
whatBuffer :EsHandle,
argumentBuffer :EsHandle,
mailslot :EsHandle,
whatBytes :uintptr,
argumentBytes :uintptr,
modalWindowParent :u64,
},
dockedWindowCreate : struct {
pipe :EsHandle,
},
taskbar : struct {
id :u64,
buffer :EsHandle,
bytes :uintptr,
},
windowResized : struct {
content :EsRectangle,
},
painter :^EsPainter,
measure : struct {
width :i32,
height :i32,
},
child :EsObject,
size : struct {
width :i32,
height :i32,
},
hitTest : struct {
x :i32,
y :i32,
inside :bool,
},
zOrder : struct {
index :uintptr,
child :^EsElement,
},
scrollbarMoved : struct {
scroll :i32,
},
ensureVisible : struct {
child :^EsElement,
},
cursorStyle :EsCursorStyle,
getItemContent : struct {
mask :u32,
index :EsListViewIndex,
column :EsListViewIndex,
group :EsListViewIndex,
text :^i8,
textBytes :uintptr,
iconHash :u32,
iconWidth :u16,
iconHeight :u16,
indentation :u16,
spaceAfterIcon :u16,
},
accessItemState : struct {
mask :u32,
state :u32,
iIndexFrom :EsListViewIndex,
eIndexTo :EsListViewIndex,
group :EsListViewIndex,
},
measureItemHeight : struct {
iIndexFrom :EsListViewIndex,
eIndexTo :EsListViewIndex,
group :EsListViewIndex,
height :i32,
},
layoutItem : struct {
index :EsListViewIndex,
group :EsListViewIndex,
knownIndex :EsListViewIndex,
knownGroup :EsListViewIndex,
bounds :EsRectangle,
},
toggleItemDisclosure : struct {
index :EsListViewIndex,
group :EsListViewIndex,
},
findItem : struct {
type :u8,
backwards :u8,
inclusive :bool,
indexFrom :EsListViewIndex,
groupFrom :EsListViewIndex,
foundIndex :EsListViewIndex,
foundGroup :EsListViewIndex,
using _ : struct #raw_union {
using _ : struct {
prefix :^i8,
prefixBytes :uintptr,
},
using _ : struct {
yPosition :i32,
yPositionOfIndexFrom :i32,
offsetIntoItem :i32,
},
},
},
listViewColumn : struct {
index :EsListViewIndex,
descending :bool,
},
setItemVisibility : struct {
index :EsListViewIndex,
group :EsListViewIndex,
visible :bool,
},
setItemPosition : struct {
index :EsListViewIndex,
group :EsListViewIndex,
bounds :EsRectangle,
},
listViewPaint : struct {
surface :EsHandle,
bounds :EsRectangle,
clip :EsRectangle,
index :EsListViewIndex,
group :EsListViewIndex,
column :EsListViewIndex,
_internal :^rawptr,
},
},
}
EsDebuggerMessage :: struct {
process :EsHandle,
reason :EsCrashReason,
}
EsDriveInformation :: struct {
name :[64]i8,
nameBytes :uintptr,
mountpoint :[256]i8,
mountpointBytes :uintptr,
}
EsSnapshotProcessesItem :: struct {
pid :i64,
memoryUsage :i64,
cpuTimeSlices :i64,
name :[ES_SNAPSHOT_MAX_PROCESS_NAME_LENGTH]i8,
nameLength :uintptr,
internal :u64,
}
EsSystemInformation :: struct {
processCount :uintptr,
threadCount :uintptr,
handleCount :uintptr,
commitLimit :uintptr,
commit :uintptr,
countZeroedPages :uintptr,
countFreePages :uintptr,
countStandbyPages :uintptr,
countModifiedPages :uintptr,
countActivePages :uintptr,
coreHeapSize :uintptr,
coreHeapAllocations :uintptr,
fixedHeapSize :uintptr,
fixedHeapAllocations :uintptr,
coreRegions :uintptr,
kernelRegions :uintptr,
}
EsSnapshotProcesses :: struct {
count :uintptr,
processes :[]EsSnapshotProcessesItem,
}
_EsPOSIXSyscall :: struct {
index :int,
arguments :[7]int,
}
EsProcessCreationArguments :: struct {
executablePath :^i8,
executablePathBytes :uintptr,
environmentBlock :^rawptr,
environmentBlockBytes :uintptr,
creationArgument :EsGeneric,
permissions :u64,
}
_EsUserLoginArguments :: struct {
name :^i8,
nameBytes :uintptr,
home :^i8,
homeBytes :uintptr,
}
EsInstance :: struct {
_private :^rawptr,
}
EsListViewColumn :: struct {
title :^i8,
titleBytes :uintptr,
width :i32,
minimumWidth :i32,
flags :u32,
}
EsListViewStyle :: struct {
flags :u32,
fixedWidth :i32,
fixedHeight :i32,
groupHeaderHeight :i32,
gapX :i32,
gapY :i32,
margin :EsRectangle16,
columns :^EsListViewColumn,
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)))))(); }
//////////////////////////////////////////////////////
Handle :: distinct i32;
Errno :: distinct i32;
INVALID_HANDLE :: ~Handle(0);
stdin: Handle = 0;
stdout: Handle = 1;
stderr: Handle = 2;
O_RDONLY :: 0x00000;
O_WRONLY :: 0x00001;
O_RDWR :: 0x00002;
O_CREATE :: 0x00040;
O_EXCL :: 0x00080;
O_NOCTTY :: 0x00100;
O_TRUNC :: 0x00200;
O_NONBLOCK :: 0x00800;
O_APPEND :: 0x00400;
O_SYNC :: 0x01000;
O_ASYNC :: 0x02000;
O_CLOEXEC :: 0x80000;
ERROR_UNSUPPORTED :: 1;
read :: proc(fd: Handle, data: []byte) -> (int, Errno) {
return -1, ERROR_UNSUPPORTED;
}
write :: proc(fd: Handle, data: []byte) -> (int, Errno) {
return -1, ERROR_UNSUPPORTED;
}
open :: proc(path: string, flags: int = O_RDONLY, mode: int = 0) -> (Handle, Errno) {
return -1, ERROR_UNSUPPORTED;
}
close :: proc(fd: Handle) -> Errno {
return ERROR_UNSUPPORTED;
}
file_size :: proc(fd: Handle) -> (i64, Errno) {
return 0, ERROR_UNSUPPORTED;
}
heap_alloc :: proc(size: int) -> rawptr {
return nil;
}
heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
return nil;
}
heap_free :: proc(ptr: rawptr) {
}
current_thread_id :: proc "contextless" () -> int {
// return int(EsThreadGetID(ES_CURRENT_THREAD));
return -1;
}
OS :: "essence";
Reference in New Issue View Git Blame Copy Permalink