Initial project import

tools/v/vlib/term/term_windows.c.v

@@ -0,0 +1,212 @@
+module term
+
+import os
+import time
+
+#include <conio.h>
+
+@[typedef]
+pub struct C.COORD {
+mut:
+	X i16
+	Y i16
+}
+
+@[typedef]
+pub struct C.SMALL_RECT {
+mut:
+	Left   u16
+	Top    u16
+	Right  u16
+	Bottom u16
+}
+
+// win: CONSOLE_SCREEN_BUFFER_INFO
+// https://docs.microsoft.com/en-us/windows/console/console-screen-buffer-info-str
+@[typedef]
+pub struct C.CONSOLE_SCREEN_BUFFER_INFO {
+mut:
+	dwSize              C.COORD
+	dwCursorPosition    C.COORD
+	wAttributes         u16
+	srWindow            C.SMALL_RECT
+	dwMaximumWindowSize C.COORD
+}
+
+pub union C.uChar {
+mut:
+	UnicodeChar rune
+	AsciiChar   u8
+}
+
+@[typedef]
+pub struct C.CHAR_INFO {
+mut:
+	Char       C.uChar
+	Attributes u16
+}
+
+// ref - https://docs.microsoft.com/en-us/windows/console/getconsolescreenbufferinfo
+fn C.GetConsoleScreenBufferInfo(handle C.HANDLE, info &C.CONSOLE_SCREEN_BUFFER_INFO) bool
+
+// ref - https://docs.microsoft.com/en-us/windows/console/setconsoletitle
+fn C.SetConsoleTitle(title &u16) bool
+
+// ref - https://docs.microsoft.com/en-us/windows/console/setconsolecursorposition
+fn C.SetConsoleCursorPosition(handle C.HANDLE, coord C.COORD) bool
+
+// ref - https://docs.microsoft.com/en-us/windows/console/scrollconsolescreenbuffer
+fn C.ScrollConsoleScreenBuffer(output C.HANDLE, scroll_rect &C.SMALL_RECT, clip_rect &C.SMALL_RECT, des C.COORD,
+	fill &C.CHAR_INFO) bool
+
+// get_terminal_size returns a number of columns and rows of terminal window.
+pub fn get_terminal_size() (int, int) {
+	if os.is_atty(1) > 0 && os.getenv('TERM') != 'dumb' {
+		info := C.CONSOLE_SCREEN_BUFFER_INFO{}
+		if C.GetConsoleScreenBufferInfo(C.GetStdHandle(C.STD_OUTPUT_HANDLE), &info) {
+			columns := int(info.srWindow.Right - info.srWindow.Left + 1)
+			rows := int(info.srWindow.Bottom - info.srWindow.Top + 1)
+			return columns, rows
+		}
+	}
+	return default_columns_size, default_rows_size
+}
+
+// get_cursor_position returns a Coord containing the current cursor position.
+pub fn get_cursor_position() !Coord {
+	mut res := Coord{}
+	if os.is_atty(1) > 0 && os.getenv('TERM') != 'dumb' {
+		info := C.CONSOLE_SCREEN_BUFFER_INFO{}
+		if C.GetConsoleScreenBufferInfo(C.GetStdHandle(C.STD_OUTPUT_HANDLE), &info) {
+			res.x = info.dwCursorPosition.X
+			res.y = info.dwCursorPosition.Y
+		} else {
+			return os.last_error()
+		}
+	}
+	return res
+}
+
+// set_terminal_title changes the terminal title.
+pub fn set_terminal_title(title string) bool {
+	wide_title := title.to_wide()
+	return C.SetConsoleTitle(wide_title)
+}
+
+// set_tab_title changes the terminal *tab title*, for terminal emulators that do support several tabs.
+pub fn set_tab_title(title string) bool {
+	// TODO: investigate, whether there is an API for changing just the tab title on windows yet.
+	return set_terminal_title(title)
+}
+
+// clear clears current terminal screen.
+// Implementation taken from https://docs.microsoft.com/en-us/windows/console/clearing-the-screen#example-2.
+pub fn clear() bool {
+	hconsole := C.GetStdHandle(C.STD_OUTPUT_HANDLE)
+	mut csbi := C.CONSOLE_SCREEN_BUFFER_INFO{}
+	mut scrollrect := C.SMALL_RECT{}
+	mut scrolltarget := C.COORD{}
+	mut fill := C.CHAR_INFO{}
+
+	// Get the number of character cells in the current buffer.
+	if !C.GetConsoleScreenBufferInfo(hconsole, &csbi) {
+		return false
+	}
+	// Scroll the rectangle of the entire buffer.
+	scrollrect.Left = 0
+	scrollrect.Top = 0
+	scrollrect.Right = u16(csbi.dwSize.X)
+	scrollrect.Bottom = u16(csbi.dwSize.Y)
+
+	// Scroll it upwards off the top of the buffer with a magnitude of the entire height.
+	scrolltarget.X = 0
+	scrolltarget.Y = (0 - csbi.dwSize.Y)
+
+	// Fill with empty spaces with the buffer's default text attribute.
+	fill.Char.UnicodeChar = rune(` `)
+	fill.Attributes = csbi.wAttributes
+
+	// Do the scroll
+	C.ScrollConsoleScreenBuffer(hconsole, &scrollrect, C.NULL, scrolltarget, &fill)
+
+	// Move the cursor to the top left corner too.
+	csbi.dwCursorPosition.X = 0
+	csbi.dwCursorPosition.Y = 0
+
+	C.SetConsoleCursorPosition(hconsole, csbi.dwCursorPosition)
+	return true
+}
+
+// supports_sixel returns `true` if the terminal supports Sixel graphics
+//
+// For more info on the sixel format:
+// See https://en.wikipedia.org/wiki/Sixel
+// See https://www.digiater.nl/openvms/decus/vax90b1/krypton-nasa/all-about-sixels.text
+// For more info on terminal support:
+// See https://www.arewesixelyet.com
+pub fn supports_sixel() bool {
+	// According to (2024) https://www.arewesixelyet.com/#windows-console there's no support
+	return false
+}
+
+// graphics_num_colors returns the number of color registers the terminal
+// graphic attribute is set to use. This can be useful to know if the terminal
+// is configured to support Sixel graphics.
+//
+// See "CSI ? Pi ; Pa ; Pv S" from https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+pub fn graphics_num_colors() u16 {
+	// Since this call is related to sixel terminal graphics and Windows Console and Terminal
+	// does not have support for querying the graphics setup this call returns 0
+	return 0
+}
+
+// enable_echo enable/disable echo input characters.
+pub fn enable_echo(enable bool) {
+	// no need under windows, use key_pressed func's echo
+}
+
+fn C.kbhit() bool
+fn C._getch() i32
+fn C._getche() i32
+
+// KeyPressedParams contains the optional parameters that you can pass to key_pressed.
+@[params]
+pub struct KeyPressedParams {
+pub mut:
+	blocking bool // whether to wait for a pressed key
+	echo     bool // whether to output the pressed key to stdout
+}
+
+// key_pressed gives back a single character, read from the standard input.
+// It returns -1 on error or no character in non-blocking mode
+pub fn key_pressed(params KeyPressedParams) i64 {
+	for {
+		if C.kbhit() {
+			res := if params.echo {
+				C._getche()
+			} else {
+				C._getch()
+			}
+			// see https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/getche-getwche?view=msvc-170
+			// > When _getche or _getwche reads a function key or an arrow key, the function must be called twice;
+			// > the first call returns 0 or 0xE0, and the second call returns the actual key code.
+			if res in [0, 0xe0] {
+				if C.kbhit() {
+					res2 := if params.echo {
+						C._getche()
+					} else {
+						C._getch()
+					}
+					return i64(u32(0xe0) << 16 | u32(res2))
+				}
+			}
+			return i64(res)
+		}
+		if !params.blocking {
+			// in non-blocking mode, we need to return immediately
+			return -1
+		}
+		time.sleep(1 * time.millisecond)
+	}
+	return 0
+}