daniel/tasksoftwaretest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f8dcc01a4ad0b7fe1f44fa9fe731e08a69e11dcf
tasksoftwaretest/src/platform_native.jai
T

678 lines
25 KiB
Plaintext
Raw Blame History

// Native platform layer: Win32 window + OpenGL 3.3 core context, via Jai's Window_Creation / Input / GL modules.
// The project is a plain text file (default: project.taskforge in the working directory, or the path given
// on the command line), so it can live in your game's repository.
#import "Window_Creation";
#import "Input";
#import "GL";
#import "File";
#import "File_Utilities";
#import "Clipboard";
#import "System";
#import "Windows";
#import "Thread";
#import "Curl";
#import "Windows_Utf8";
#import "stb_image";
#import "stb_image_resize";
#import "stb_image_write";
tf_user32 :: #system_library "user32";
SetProcessDpiAwarenessContext_ :: (value: *void) -> s32 #foreign tf_user32 "SetProcessDpiAwarenessContext";
GetDpiForWindow_ :: (hwnd: HWND) -> u32 #foreign tf_user32 "GetDpiForWindow";
MsgWaitForMultipleObjects_ :: (count: u32, handles: *HANDLE, wait_all: s32, milliseconds: u32, wake_mask: u32) -> u32 #foreign tf_user32 "MsgWaitForMultipleObjects";
QS_ALLINPUT_ :: 0x04FF;
project_path: string;
server_url: string; // Set with --server; empty = local project file.
native_window: HWND;
main :: () {
args := get_command_line_arguments();
project_path = "project.taskforge";
i := 1;
while i < args.count {
if args[i] == "--sim" && i + 1 < args.count {
sim_script = args[i + 1];
i += 2;
continue;
}
if args[i] == "--server" && i + 1 < args.count {
server_url = copy_string(args[i + 1]);
while server_url.count && server_url[server_url.count - 1] == #char "/" server_url.count -= 1;
i += 2;
continue;
}
project_path = copy_string(args[i]);
i += 1;
}
SetProcessDpiAwarenessContext_(cast(*void) -4); // DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
native_window = create_window(1440, 900, "TaskForge", background_color_rgb = .[0.067, 0.075, 0.094]);
_, hdc := wgl_create_context(native_window, null, 3, 3);
gl_load(*gl);
DragAcceptFiles_(native_window, 1);
#if OS == .WINDOWS {
if wglSwapIntervalEXT wglSwapIntervalEXT(1);
}
exe_dir := path_strip_filename(get_path_of_running_executable());
font_data, ok := read_entire_file(tprint("%fonts.bin", exe_dir));
if !ok {
log_error("Missing fonts.bin next to the executable. Build with: jai build.jai");
return;
}
if server_url.count curl_global_init(CURL_GLOBAL_DEFAULT);
video_native_init();
if !app_init(font_data, server_url.count > 0) {
log_error("Failed to initialize.");
return;
}
input: Frame_Input;
idle_frames := 0;
last_mouse_x, last_mouse_y := -1.0, -1.0;
running := true;
while running {
update_window_events();
reset_per_frame_input(*input);
for event: events_this_frame {
if event.type == {
case .QUIT;
running = false;
case .KEYBOARD;
button := -1;
if event.key_code == {
case .MOUSE_BUTTON_LEFT; button = MOUSE_LEFT;
case .MOUSE_BUTTON_RIGHT; button = MOUSE_RIGHT;
case .MOUSE_BUTTON_MIDDLE; button = MOUSE_MIDDLE;
}
if button >= 0 {
if event.key_pressed {
input.mouse_down[button] = true;
input.mouse_pressed[button] = true;
} else {
input.mouse_down[button] = false;
input.mouse_released[button] = true;
}
} else if event.key_pressed {
key: Key_Press;
key.key = cast(u32) event.key_code;
if event.shift_pressed key.mods |= MOD_SHIFT;
if event.ctrl_pressed key.mods |= MOD_CTRL;
if event.alt_pressed key.mods |= MOD_ALT;
array_add(*input.keys, key);
}
case .TEXT_INPUT;
if event.utf32 >= 32 && event.utf32 != 127 array_add(*input.chars, event.utf32);
case .DRAG_AND_DROP_FILES;
for event.files queue_file_from_disk(it);
case .MOUSE_WHEEL;
if event.typical_wheel_delta {
lines := -cast(float) event.wheel_delta / cast(float) event.typical_wheel_delta;
input.wheel_y += lines;
}
}
}
input.mods = 0;
if input_button_states[Key_Code.SHIFT] & .DOWN input.mods |= MOD_SHIFT;
if input_button_states[Key_Code.CTRL] & .DOWN input.mods |= MOD_CTRL;
if input_button_states[Key_Code.ALT] & .DOWN input.mods |= MOD_ALT;
rect: RECT;
GetClientRect(native_window, *rect);
pw := rect.right - rect.left;
ph := rect.bottom - rect.top;
dpi := GetDpiForWindow_(native_window);
input.dpr = ifx dpi then dpi / 96.0 else 1.0;
if pw <= 0 || ph <= 0 {
// Minimized.
MsgWaitForMultipleObjects_(0, null, 0, 250, QS_ALLINPUT_);
continue;
}
input.width = pw / input.dpr;
input.height = ph / input.dpr;
input.time = seconds_since_init();
input.unix_time = unix_now();
input.utc_offset = utc_offset_seconds();
poll_snip();
for platform_pending_files array_add(*input.files, it);
platform_pending_files.count = 0;
if sim_script.count {
if !simulate_frame(*input, pw, ph) running = false;
} else {
mx, my := get_mouse_pointer_position(native_window, false);
input.mouse_x = mx / input.dpr;
input.mouse_y = my / input.dpr;
// If a button was released outside the window we never got the event.
if input.mouse_down[MOUSE_LEFT] && !(input_button_states[Key_Code.MOUSE_BUTTON_LEFT] & .DOWN) {
input.mouse_down[MOUSE_LEFT] = false;
input.mouse_released[MOUSE_LEFT] = true;
}
}
poll_http_jobs();
frame_start := seconds_since_init();
wants_more := app_frame(*input);
if sim_screenshot.count {
save_screenshot(sim_screenshot, pw, ph);
sim_screenshot = "";
}
SwapBuffers(hdc);
// Vsync isn't guaranteed (drivers may ignore the swap interval), so cap the frame rate ourselves.
MIN_FRAME_TIME :: 1.0 / 120.0;
elapsed := seconds_since_init() - frame_start;
if elapsed < MIN_FRAME_TIME sleep_milliseconds(cast(s32) ((MIN_FRAME_TIME - elapsed) * 1000) + 1);
if sim_script.count continue;
moved := input.mouse_x != last_mouse_x || input.mouse_y != last_mouse_y;
last_mouse_x, last_mouse_y = input.mouse_x, input.mouse_y;
if events_this_frame.count || moved || wants_more idle_frames = 0;
else idle_frames += 1;
// A task app should not burn a CPU core: sleep until input arrives (or the caret needs to blink).
if idle_frames > 2 MsgWaitForMultipleObjects_(0, null, 0, xx ifx http_jobs.count || snip_waiting then 15 else 500, QS_ALLINPUT_);
}
app_shutdown();
}
platform_load_project :: () -> string, bool {
if !file_exists(project_path) return "", false;
text, ok := read_entire_file(project_path);
return text, ok;
}
platform_save_project :: (data: string) -> bool {
// Write to a temp file first so a crash mid-write can't destroy the project.
temp_path := tprint("%.tmp", project_path);
if !write_entire_file(temp_path, data) return false;
// MoveFileW refuses to overwrite; replace the old file atomically instead.
MOVEFILE_REPLACE_EXISTING :: 0x1;
MOVEFILE_WRITE_THROUGH :: 0x8;
return MoveFileExW_(utf8_to_wide(temp_path,, temp), utf8_to_wide(project_path,, temp), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) != 0;
}
platform_storage_description :: () -> string {
return tprint("Saved to %", path_filename(project_path));
}
platform_server_label :: () -> string {
return server_url;
}
//
// HTTP (server mode): each request runs libcurl on its own thread; results are picked up by the main loop.
//
Http_Job :: struct {
tag: Http_Tag;
method: string;
key: string;
url: string;
body: string;
token: string;
status: int;
response: String_Builder;
thread: Thread;
}
http_jobs: [..] *Http_Job;
platform_http_request :: (tag: Http_Tag, method: string, path: string, body: string, token: string, key := "") {
job := New(Http_Job);
job.tag = tag;
job.method = copy_string(method);
job.key = copy_string(key);
job.url = sprint("%1%2", server_url, path);
job.body = copy_string(body);
job.token = copy_string(token);
thread_init(*job.thread, http_thread_proc);
job.thread.data = job;
thread_start(*job.thread);
array_add(*http_jobs, job);
}
http_thread_proc :: (thread: *Thread) -> s64 {
job := cast(*Http_Job) thread.data;
curl := curl_easy_init();
if !curl return 0;
defer curl_easy_cleanup(curl);
write :: (data: *u8, size: u64, count: u64, builder: *String_Builder) -> u64 #c_call {
n := size * count;
push_context { append(builder, data, cast(s64) n); }
return n;
}
headers: *curl_slist;
headers = curl_slist_append(headers, "Content-Type: text/plain; charset=utf-8");
if job.token.count headers = curl_slist_append(headers, temp_c_string(tprint("Authorization: Bearer %", job.token)));
defer curl_slist_free_all(headers);
curl_easy_setopt(curl, .URL, temp_c_string(job.url));
if job.method == "GET" {
curl_easy_setopt(curl, .HTTPGET, cast(s64) 1);
} else {
curl_easy_setopt(curl, .POST, cast(s64) 1);
curl_easy_setopt(curl, .POSTFIELDS, job.body.data);
curl_easy_setopt(curl, .POSTFIELDSIZE_LARGE, cast(s64) job.body.count);
}
curl_easy_setopt(curl, .HTTPHEADER, headers);
curl_easy_setopt(curl, .WRITEFUNCTION, write);
curl_easy_setopt(curl, .WRITEDATA, *job.response);
curl_easy_setopt(curl, .TIMEOUT, cast(s64) ifx job.tag == .BLOB_PUT || job.tag == .BLOB_GET then 600 else 20);
curl_easy_setopt(curl, .CONNECTTIMEOUT, cast(s64) 10);
if curl_easy_perform(curl) == .OK {
code: s64;
curl_easy_getinfo(curl, .RESPONSE_CODE, *code);
job.status = code;
}
return 0;
}
poll_http_jobs :: () {
i := 0;
while i < http_jobs.count {
job := http_jobs[i];
if !thread_is_done(*job.thread) {
i += 1;
continue;
}
thread_deinit(*job.thread);
array_ordered_remove_by_index(*http_jobs, i);
response := builder_to_string(*job.response);
http_on_response(job.tag, job.status, response, job.key);
free(response);
free(job.method);
free(job.key);
free(job.url);
free(job.body);
free(job.token);
free(job);
}
}
// The session token is kept per user profile, tied to the server it belongs to.
session_path :: () -> string {
home := get_home_directory();
dir := tprint("%/AppData/Roaming/TaskForge", home);
make_directory_if_it_does_not_exist(dir);
return tprint("%/session.txt", dir);
}
platform_load_session :: () -> string {
text, ok := read_entire_file(session_path(), log_errors = false);
if !ok return "";
lines := split(text, "\n",, temp);
if lines.count < 2 || lines[0] != server_url return "";
return copy_string(trim(lines[1]));
}
platform_save_session :: (token: string) {
write_entire_file(session_path(), tprint("%\n%\n", server_url, token));
}
platform_clipboard_get :: () -> string {
text := os_clipboard_get_text();
result := copy_temporary_string(text);
free(text);
return result;
}
platform_clipboard_set :: (text: string) {
os_clipboard_set_text(text);
}
platform_set_cursor :: (kind: Cursor_Kind) {
name: *s16;
if kind == {
case .HAND; name = cast(*s16) IDC_HAND;
case .TEXT; name = cast(*s16) IDC_IBEAM;
case .GRAB; name = cast(*s16) IDC_SIZEALL;
case; name = cast(*s16) IDC_ARROW;
}
SetCursor(LoadCursorW(null, name));
}
platform_export_project :: (data: string) {}
platform_request_import :: () {}
//
// Test harness: --sim "<commands>" drives the app with scripted input, one command per frame, separated by ';'.
// move X Y | down | up | click X Y | type TEXT | key CODE [MODS] | wheel LINES | wait N | shot FILE.bmp | quit
// Coordinates are logical pixels.
//
sim_script: string;
sim_screenshot: string;
sim_wait: int;
sim_pending_up: bool;
simulate_frame :: (input: *Frame_Input, pw: s32, ph: s32) -> bool {
if sim_pending_up {
sim_pending_up = false;
input.mouse_down[MOUSE_LEFT] = false;
input.mouse_released[MOUSE_LEFT] = true;
return true;
}
if sim_wait > 0 {
sim_wait -= 1;
return true;
}
while sim_script.count && (sim_script[0] == #char ";" || sim_script[0] == #char " ") advance(*sim_script);
if !sim_script.count return false;
end := find_index_from_left(sim_script, #char ";");
if end < 0 end = sim_script.count;
command := substring(sim_script, 0, end);
advance(*sim_script, end);
parts := split(command, " ",, allocator = temp);
if !parts.count return true;
if parts[0] == {
case "move";
input.mouse_x = string_to_float(parts[1]);
input.mouse_y = string_to_float(parts[2]);
case "down";
input.mouse_down[MOUSE_LEFT] = true;
input.mouse_pressed[MOUSE_LEFT] = true;
case "up";
input.mouse_down[MOUSE_LEFT] = false;
input.mouse_released[MOUSE_LEFT] = true;
case "click";
input.mouse_x = string_to_float(parts[1]);
input.mouse_y = string_to_float(parts[2]);
input.mouse_down[MOUSE_LEFT] = true;
input.mouse_pressed[MOUSE_LEFT] = true;
sim_pending_up = true;
case "type";
text := substring(command, 5, command.count);
for 0..text.count-1 array_add(*input.chars, cast(u32) text[it]);
case "key";
k: Key_Press;
k.key = cast(u32) string_to_int(parts[1]);
if parts.count > 2 k.mods = cast(u32) string_to_int(parts[2]);
array_add(*input.keys, k);
case "drop";
queue_file_from_disk(substring(command, 5, command.count));
case "wheel";
input.wheel_y += string_to_float(parts[1]);
case "wait";
sim_wait = string_to_int(parts[1]);
case "shot";
sim_screenshot = copy_string(parts[1]);
case "quit";
return false;
}
return true;
}
save_screenshot :: (path: string, w: s32, h: s32) {
pixels := NewArray(w * h * 4, u8,, allocator = temp);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0, 0, xx w, xx h, GL_BGRA, GL_UNSIGNED_BYTE, pixels.data);
// 32-bit BMP, bottom-up rows (which is what glReadPixels gives us).
b: String_Builder;
put :: (b: *String_Builder, value: $T) {
v := value;
append(b, cast(*u8) *v, size_of(T));
}
append(*b, "BM");
put(*b, cast(u32) (54 + pixels.count));
put(*b, cast(u32) 0);
put(*b, cast(u32) 54);
put(*b, cast(u32) 40);
put(*b, cast(s32) w);
put(*b, cast(s32) h);
put(*b, cast(u16) 1);
put(*b, cast(u16) 32);
put(*b, cast(u32) 0);
put(*b, cast(u32) pixels.count);
put(*b, cast(s32) 2835);
put(*b, cast(s32) 2835);
put(*b, cast(u32) 0);
put(*b, cast(u32) 0);
append(*b, pixels.data, pixels.count);
write_entire_file(path, *b);
}
//
// Media: local blob files, image decoding, clipboard screenshots, file picker, drag & drop, snipping tool.
//
tf_shell32 :: #system_library "shell32";
tf_comdlg :: #system_library "comdlg32";
tf_kernel :: #system_library "kernel32";
DragAcceptFiles_ :: (hwnd: HWND, accept: s32) #foreign tf_shell32 "DragAcceptFiles";
ShellExecuteW_ :: (hwnd: HWND, op: *u16, file: *u16, params: *u16, dir: *u16, show: s32) -> *void #foreign tf_shell32 "ShellExecuteW";
IsClipboardFormatAvailable_ :: (format: u32) -> s32 #foreign tf_user32 "IsClipboardFormatAvailable";
GetClipboardSequenceNumber_ :: () -> u32 #foreign tf_user32 "GetClipboardSequenceNumber";
OpenClipboard_ :: (hwnd: HWND) -> s32 #foreign tf_user32 "OpenClipboard";
CloseClipboard_ :: () -> s32 #foreign tf_user32 "CloseClipboard";
GetClipboardData_ :: (format: u32) -> *void #foreign tf_user32 "GetClipboardData";
GlobalLock_ :: (mem: *void) -> *u8 #foreign tf_kernel "GlobalLock";
GlobalUnlock_ :: (mem: *void) -> s32 #foreign tf_kernel "GlobalUnlock";
GlobalSize_ :: (mem: *void) -> u64 #foreign tf_kernel "GlobalSize";
GetSystemTimeAsFileTime_ :: (time: *u64) #foreign tf_kernel "GetSystemTimeAsFileTime";
GetOpenFileNameW_ :: (ofn: *Open_File_Name) -> s32 #foreign tf_comdlg "GetOpenFileNameW";
MoveFileExW_ :: (from: *u16, to: *u16, flags: u32) -> s32 #foreign tf_kernel "MoveFileExW";
CF_DIB_ :: 8;
Open_File_Name :: struct {
lStructSize: u32;
hwndOwner: HWND;
hInstance: *void;
lpstrFilter: *u16;
lpstrCustomFilter: *u16;
nMaxCustFilter: u32;
nFilterIndex: u32;
lpstrFile: *u16;
nMaxFile: u32;
lpstrFileTitle: *u16;
nMaxFileTitle: u32;
lpstrInitialDir: *u16;
lpstrTitle: *u16;
Flags: u32;
nFileOffset: u16;
nFileExtension: u16;
lpstrDefExt: *u16;
lCustData: *void;
lpfnHook: *void;
lpTemplateName: *u16;
pvReserved: *void;
dwReserved: u32;
FlagsEx: u32;
}
// Files from the picker or the snipping tool; handed to the app with the next frame's input.
platform_pending_files: [..] Input_File;
unix_now :: () -> float64 {
ft: u64;
GetSystemTimeAsFileTime_(*ft);
return cast(float64) (ft - 116444736000000000) / 10000000.0;
}
utc_offset_seconds :: () -> float64 {
now := current_time_consensus();
local := to_calendar(now, .LOCAL);
utc := to_calendar(now, .UTC);
minutes: s64 = (cast(s64) local.hour * 60 + local.minute) - (cast(s64) utc.hour * 60 + utc.minute);
if local.day_of_month_starting_at_0 != utc.day_of_month_starting_at_0 {
// Crossed midnight: the side that is "ahead" is one day later.
if local.year > utc.year || (local.year == utc.year && (local.month_starting_at_0 > utc.month_starting_at_0 ||
(local.month_starting_at_0 == utc.month_starting_at_0 && local.day_of_month_starting_at_0 > utc.day_of_month_starting_at_0)))
minutes += 24 * 60;
else
minutes -= 24 * 60;
}
return cast(float64) minutes * 60;
}
// Blobs of a local project live next to the project file.
blob_dir :: () -> string {
return tprint("%.files", project_path);
}
platform_local_blob_save :: (hash: string, data: string) {
dir := blob_dir();
make_directory_if_it_does_not_exist(dir);
path := tprint("%/%", dir, hash);
if !file_exists(path) write_entire_file(path, data);
}
platform_local_blob_load :: (hash: string) {
data, ok := read_entire_file(tprint("%/%", blob_dir(), hash), log_errors = false);
blob_loaded(hash, ok, data);
if ok free(data);
}
platform_decode_image :: (key: string, data: string) {
w, h, n: s32;
pixels := stbi_load_from_memory(data.data, cast(s32) data.count, *w, *h, *n, 4);
if !pixels {
image_decoded(key, false, 0, 0, null);
return;
}
defer stbi_image_free(pixels);
if max(w, h) > MAX_IMAGE_SIDE {
scale := cast(float) MAX_IMAGE_SIDE / max(w, h);
sw := max(cast(s32) 1, cast(s32) (w * scale));
sh := max(cast(s32) 1, cast(s32) (h * scale));
small := alloc(sw * sh * 4);
defer free(small);
stbir_resize_uint8(pixels, w, h, 0, small, sw, sh, 0, 4);
image_decoded(key, true, sw, sh, small);
} else {
image_decoded(key, true, w, h, pixels);
}
}
encode_png :: (rgba: *u8, w: s32, h: s32) -> string {
b: String_Builder;
write :: (ctx: *void, data: *void, size: s32) #c_call {
push_context { append(cast(*String_Builder) ctx, data, size); }
}
stbi_write_png_to_func(write, *b, w, h, 4, rgba, w * 4);
return builder_to_string(*b);
}
// The clipboard's bitmap as PNG bytes, or "" if it holds no image.
platform_clipboard_image :: () -> string {
if !IsClipboardFormatAvailable_(CF_DIB_) return "";
if !OpenClipboard_(native_window) return "";
defer CloseClipboard_();
handle := GetClipboardData_(CF_DIB_);
if !handle return "";
dib := GlobalLock_(handle);
if !dib return "";
defer GlobalUnlock_(handle);
total := cast(s64) GlobalSize_(handle);
header_size := (cast(*u32) dib).*;
w := (cast(*s32) (dib + 4)).*;
h := (cast(*s32) (dib + 8)).*;
bits := (cast(*u16) (dib + 14)).*;
compression := (cast(*u32) (dib + 16)).*;
if (bits != 24 && bits != 32) || w <= 0 || h == 0 return "";
offset := cast(s64) header_size;
if compression == 3 && header_size == 40 offset += 12; // BI_BITFIELDS masks follow a plain header.
bottom_up := h > 0;
height := abs(h);
stride := ((w * bits + 31) / 32) * 4;
if offset + cast(s64) stride * height > total return "";
rgba := cast(*u8) alloc(w * height * 4);
defer free(rgba);
for y: 0..height-1 {
src := dib + offset + (ifx bottom_up then height - 1 - y else y) * stride;
dst := rgba + y * w * 4;
step := bits / 8;
for x: 0..w-1 {
dst[x*4 + 0] = src[x*step + 2];
dst[x*4 + 1] = src[x*step + 1];
dst[x*4 + 2] = src[x*step + 0];
dst[x*4 + 3] = 255; // Screenshot DIBs usually carry no meaningful alpha.
}
}
return encode_png(rgba, w, xx height);
}
screenshot_name :: () -> string {
c := to_calendar(current_time_consensus(), .LOCAL);
return tprint("Screenshot %-%-% %.%.%.png", c.year, formatInt(c.month_starting_at_0 + 1, minimum_digits = 2), formatInt(c.day_of_month_starting_at_0 + 1, minimum_digits = 2),
formatInt(c.hour, minimum_digits = 2), formatInt(c.minute, minimum_digits = 2), formatInt(c.second, minimum_digits = 2));
}
platform_pick_files :: () {
buffer := NewArray(65536, u16,, temp);
filter := utf8_to_wide("Images and videos\0*.png;*.jpg;*.jpeg;*.gif;*.bmp;*.webp;*.mp4;*.mov;*.m4v;*.webm;*.mkv;*.avi\0All files\0*.*\0\0",, temp);
ofn: Open_File_Name;
ofn.lStructSize = size_of(Open_File_Name);
ofn.hwndOwner = native_window;
ofn.lpstrFilter = filter;
ofn.lpstrFile = buffer.data;
ofn.nMaxFile = xx buffer.count;
OFN_FILEMUSTEXIST :: 0x00001000;
OFN_ALLOWMULTISELECT :: 0x00000200;
OFN_EXPLORER :: 0x00080000;
OFN_NOCHANGEDIR :: 0x00000008;
ofn.Flags = OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_EXPLORER | OFN_NOCHANGEDIR;
if !GetOpenFileNameW_(*ofn) return;
// Either one full path, or a directory followed by file names, each zero terminated.
parts: [..] string;
parts.allocator = temp;
start := 0;
for i: 0..buffer.count-1 {
if buffer[i] != 0 continue;
if i == start break;
array_add(*parts, wide_to_utf8(buffer.data + start, cast(s32) (i - start),, temp));
start = i + 1;
}
paths: [..] string;
paths.allocator = temp;
if parts.count == 1 array_add(*paths, parts[0]);
else for 1..parts.count-1 array_add(*paths, tprint("%\\%", parts[0], parts[it]));
for paths queue_file_from_disk(it);
}
queue_file_from_disk :: (path: string) {
data, ok := read_entire_file(path, log_errors = false);
if !ok return;
array_add(*platform_pending_files, .{copy_string(path_filename(path)), data});
}
// Opens the Windows snipping overlay; the snip is picked up from the clipboard when it arrives.
snip_waiting: bool;
snip_sequence: u32;
snip_deadline: float64;
platform_capture_screenshot :: () {
snip_sequence = GetClipboardSequenceNumber_();
snip_waiting = true;
snip_deadline = seconds_since_init() + 120;
ShellExecuteW_(null, utf8_to_wide("open",, temp), utf8_to_wide("ms-screenclip:",, temp), null, null, 1);
}
poll_snip :: () {
if !snip_waiting return;
if seconds_since_init() > snip_deadline { snip_waiting = false; return; }
if GetClipboardSequenceNumber_() == snip_sequence return;
png := platform_clipboard_image();
if !png.count return; // Clipboard changed but no image yet (the snip may still be processing).
snip_waiting = false;
array_add(*platform_pending_files, .{copy_string(screenshot_name()), png});
}
platform_capture_label :: () -> string { return "Snip screen"; }
Reference in New Issue View Git Blame Copy Permalink