Notes/refactor

Author: PeyTy

dlls/advapi32/advapi32.hexa

@@ -24,27 +24,40 @@ fun regCreateKeyExW(key SizeOfPointer, lpSubKey ConstArrayPointer<ClangWideChar>
 	// TODO
 	tofitaDebugLog("regCreateKeyExW(%S)\n".utf16(), lpSubKey as! UInt64)
 	return 0
+
 }
 
 @dllExport('RegOpenKeyExW')
 fun regOpenKeyExW(key SizeOfPointer, lpSubKey ConstArrayPointer<ClangWideChar>) SizeOfPointer {
 	// TODO
 	tofitaDebugLog("regOpenKeyExW(%S)\n".utf16(), lpSubKey as! UInt64)
 	return 0
+
 }
 
 @dllExport('RegQueryValueExW')
 fun regQueryValueExW(key SizeOfPointer, lpValueName ConstArrayPointer<ClangWideChar>) SizeOfPointer {
 	// TODO
 	tofitaDebugLog("regQueryValueExW(%S)\n".utf16(), lpValueName as! UInt64)
 	return 0
+
 }
 
 @dllExport('RegSetValueExW')
 fun regSetValueExW(key SizeOfPointer, lpValueName ConstArrayPointer<ClangWideChar>) SizeOfPointer {
 	// TODO
 	tofitaDebugLog("regSetValueExW(%S)\n".utf16(), lpValueName as! UInt64)
 	return 0
+
+
+
+
+
+
+
+
+
+
 }
 
 @linkName('_DllMainCRTStartup_TODO')
@@ -53,10 +66,10 @@ fun regSetValueExW(key SizeOfPointer, lpValueName ConstArrayPointer<ClangWideCha
 #else
 	@fastcall
 #end
-fun _DllMainCRTStartup(
-	unusedX Any,
-	unusedY Any,
-	unusedZ Any
+fun _DllMainCRTStartupTODO(
+	hinstDLL SizeOfPointer,
+	fdwReason UInt32,
+	lpvReserved SizeOfPointer
 ) Void {
-	// TODO
+	// TODO unused
 }

dlls/kernel32/kernel32.hexa

@@ -24,6 +24,7 @@ fun exitProcess(@hide exitCode UInt32) {
 fun localAlloc(flags UInt32, bytes SizeOfPointer) HLocal {
 	// TODO better way to take pointer to array element `&buffer[bufferOffset]`
 	let result = (buffer as! UInt64) + bufferOffset
+
 	bufferOffset += bytes as! UInt64 // TODO .toInt()
 
 	// Align to 8 bytes

dlls/msvcrt/msvcrt.hexa

@@ -121,9 +121,11 @@ fun _initterm(first ConstArrayPointer<PVFV>, last ConstArrayPointer<PVFV>) Void
 		if callback == null { continue }
 
 		callback()
-		tofitaDebugLog("_initterm done call (%8)\n".utf16(), callback as! UInt64)
 		tofitaDebugLog("_initterm calls (%8)".utf16(), callback as! UInt64)
+		tofitaDebugLog("_initterm done call (%8)".utf16(), callback as! UInt64)
 	}
+
+	tofitaDebugLog("_initterm all done".utf16())
 }
 
 @dllExport('_iob')
@@ -310,6 +312,7 @@ fun malloc(size SizeOfPointer) SizeOfPointer {
 	}
 
 	var stub = Malloc()
+	// TODO use HeapAlloc
 	tofitaDebugLog("[msvcrt] malloc done allocation %8".utf16(), stub as! UInt64)
 	return stub as! SizeOfPointer
 }

dlls/ntdll/ntdllMain.hexa

@@ -217,6 +217,7 @@
     STUB(OpenClipboard)
     STUB(PeekConsoleInputA)
     STUB(PostMessageW)
+	// TODO delete
     STUB(ReadConsoleA)
     STUB(RegCloseKey)
     STUB(RegCreateKeyExW)
@@ -285,7 +286,6 @@
     STUB(lstrcatW)
     STUB(lstrcpynA)
     STUB(lstrcpyW)
-    STUB(lstrlenW)
     STUB(MapVirtualKeyExW)
 
     STUB(wcschr)

dlls/user32/dialogs.hexa

@@ -59,6 +59,7 @@ class RadioGroup {
 // TODO docs
 fun dialog_GetControl32(p ConstArrayPointer<UInt16>, info DlgControlInfo, dialogEx Bool32) ConstArrayPointer<UInt16> {
 	tofitaDebugLog("dialog_GetControl32 called p = %8".utf16(), p as! UInt64)
+	tofitaDebugLog("dialog_GetControl32 called info = %8".utf16(), info as! UInt64)
 
 	var p = p
 	if dialogEx == Bool32.True {

dlls/user32/extras.hexa

@@ -793,6 +793,7 @@ fun intersectRect(lprcDst Rect, lprcSrc1 Rect, lprcSrc2 Rect) Bool32 {
 	return Bool32.False
 }
 
+// TODO move to crt
 fun max(a Int32, b Int32) Int32 {
 	return a > b ? a : b
 }
@@ -988,6 +989,8 @@ fun bitBlt(
 	}*/
 	// Handle different bit depths
 	if bppSrc == 8i16 and bppDest == 32i16 {
+		tofitaDebugLog("> bppSrc == 8i16 and bppDest == 32i16".utf16())
+
 		// 8-bit source (indexed) to 32-bit destination (RGBA)
 		if colorTable == null or colorTableSize == 0 {
 			tofitaDebugLog("> Color table missing for 8-bit source".utf16())
@@ -1023,7 +1026,7 @@ fun bitBlt(
 						)
 					}
 				} else {
-					tofitaDebugLog("> Invalid pixel index: %u".utf16(), srcPixel as! UInt64)
+					// tofitaDebugLog("> Invalid pixel index: %u".utf16(), srcPixel as! UInt64)
 					// Invalid index: use black
 					bitsDest[destPixelOffset] = 0u8
 					bitsDest[destPixelOffset + 1] = 0u8
@@ -1033,6 +1036,8 @@ fun bitBlt(
 			}
 		}
 	} else if bppSrc == 32i16 and bppDest == 32i16 {
+		tofitaDebugLog("> bppSrc == 32i16 and bppDest == 32i16".utf16())
+
 		// 32-bit to 32-bit copy
 		for row in 0 ... cy - 1 {
 			let srcOffset = ((ySrc + row) * bytesPerRowSrc + xSrc * 4) as! Int
@@ -1115,6 +1120,8 @@ fun srand(seed UInt32) Void {
 
 @dllExport('memcmp')
 fun memcmp(stub SizeOfPointer) SizeOfPointer {
+// TODO Global item `memcmp` declared in `/extras` already defined at `Hexa\library\c\c.hexa` line `493`
+// ^ must only type-check `declare` vs `fun`
 	// TODO
 	tofitaDebugLog("memcmp called".utf16())
 	return 0
@@ -1381,16 +1388,16 @@ fun lstrcmpW(lpString1 ConstArrayPointer<ClangWideChar>, lpString2 ConstArrayPoi
 
 	var i = 0
 	// TODO Hexa: `ClangWideChar.nullTerminator`
-    while lpString1[i] != 0 as! ClangWideChar or lpString2[i] != 0 as! ClangWideChar {
-        if (lpString1[i] as! UInt16) < (lpString2[i] as! UInt16) {
-            tofitaDebugLog("> lpString1 < lpString2".utf16())
-            return -1
-        } else if (lpString1[i] as! UInt16) > (lpString2[i] as! UInt16) {
-            tofitaDebugLog("> lpString1 > lpString2".utf16())
-            return 1
-        }
-        i += 1
-    }
+	while lpString1[i] != 0 as! ClangWideChar or lpString2[i] != 0 as! ClangWideChar {
+		if (lpString1[i] as! UInt16) < (lpString2[i] as! UInt16) {
+			tofitaDebugLog("> lpString1 < lpString2".utf16())
+			return - 1
+		} else if (lpString1[i] as! UInt16) > (lpString2[i] as! UInt16) {
+			tofitaDebugLog("> lpString1 > lpString2".utf16())
+			return 1
+		}
+		i += 1
+	}
 
 	tofitaDebugLog("> Strings equal".utf16())
 	return 0
@@ -1445,7 +1452,7 @@ fun vswprintf(stub SizeOfPointer) SizeOfPointer {
 @dllExport('wcsncpy')
 fun wcsncpy(dest ArrayPointer<ClangWideChar>, src ConstArrayPointer<ClangWideChar>, count SizeOfPointer) ArrayPointer<ClangWideChar> {
 	// TODO
-	tofitaDebugLog("wcsncpy called %S %u\n".utf16(), src as! UInt64, count as! UInt64)
+	tofitaDebugLog("wcsncpy called %S %u".utf16(), src as! UInt64, count as! UInt64)
 
 	var i = 0u32
 	while i < count {
@@ -1755,11 +1762,13 @@ fun getObjectW(hObject SizeOfPointer, nSize Int32, lpvObject SizeOfPointer) Int3
 		bitmap.bmWidthBytes = 72
 		bitmap.bmType = 0
 		var bmBits ArrayByValue<ClangWideChar, 8064> = [0]
+		// TODO currently `bmBits` field never used or its a unnecessary `BITMAP` type alias?
 		bitmap.bmBits = bmBits as! SizeOfPointer // TODO .address
 
 		return 0
 	}
 
+	tofitaDebugLog("> not recognised".utf16())
 	return 0
 }
 
@@ -2006,7 +2015,7 @@ fun patBlt(hdc HDc, x Int32, y Int32, cx Int32, cy Int32, dwRop RasterOperation)
 	let patternWidth = pattern.width
 	let patternHeight = pattern.height
 	let patternBits = pattern.bits
-	let patternBytesPerRow = pattern.bytesPerRow
+	let patternBytesPerRow = pattern.bytesPerRow // Should be 4 for 8-pixel monochrome (4-byte aligned)
 
 	// Get colors from DC
 	let fgColor = dc.textColor
@@ -2015,6 +2024,9 @@ fun patBlt(hdc HDc, x Int32, y Int32, cx Int32, cy Int32, dwRop RasterOperation)
 	let brushOrgY = dc.brushOrgY
 
 	// Apply pattern
+	tofitaDebugLog("> brushOrgX %d brushOrgY %d".utf16(), brushOrgX as! UInt64, brushOrgY as! UInt64)
+	tofitaDebugLog("> fgColor %8 bgColor %8".utf16(), fgColor as! UInt64, bgColor as! UInt64)
+
 	for row in 0 ... cy - 1 {
 		let destY = y + row
 		let patternY = ((row + brushOrgY) % patternHeight) as! Int32
@@ -2350,7 +2362,7 @@ fun isTextUnicode(stub SizeOfPointer) SizeOfPointer {
 	return 0
 }
 
-@dllExport('RegOpenKeyW')
+@dllExport('RegOpenKeyW') // TODO move to adv
 fun regOpenKeyW(stub SizeOfPointer) SizeOfPointer {
 	// TODO
 	tofitaDebugLog("RegOpenKeyW called".utf16())

dlls/user32/user32.header.hexa

@@ -105,16 +105,16 @@ fun gdiGetCharDimensions(
 // Win32 Spec: https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setrect
 @dllExport('SetRect')
 fun setRect(
-	lprc Rect, // LPRECT -> Pointer to ClangRect (assuming LPRECT is a pointer to a RECT structure)
-	xLeft Int, // int -> Int
+	lprc Rect?, // LPRECT -> Pointer to ClangRect
+	xLeft Int, // int -> Int // TODO remove -> comments
 	yTop Int, // int -> Int
 	xRight Int, // int -> Int
 	yBottom Int // int -> Int
 ) Bool32 // BOOL -> Bool (return type)
 {
 	tofitaDebugLog("SetRect called with lprc %8".utf16(), lprc as! UInt64)
-	tofitaDebugLog("left %d top %d".utf16(), xLeft as! UInt64, yTop as! UInt64)
-	tofitaDebugLog("right %d bottom %d".utf16(), xRight as! UInt64, yBottom as! UInt64)
+	tofitaDebugLog("> left %d top %d".utf16(), xLeft as! UInt64, yTop as! UInt64)
+	tofitaDebugLog("> right %d bottom %d".utf16(), xRight as! UInt64, yBottom as! UInt64)
 	if let rc = lprc {
 		rc.left = xLeft
 		rc.top = yTop
@@ -462,7 +462,7 @@ class ExeResourceLoader<SIZE, HEADER> {
 
 					if entry.unionName.ref.id == lpType {
 						// serialPrintf("[ExeResourceLoader] Found RT_ICON at %d offset %8\n", id as! Int, entry.unionOffset.ref.offsetToData as! UInt64)
-						tofitaDebugLog("[ExeResourceLoader] Found by type %8...\n".utf16(), lpType)
+						tofitaDebugLog("[ExeResourceLoader] Found by type %8...".utf16(), lpType)
 					} else {
 						tofitaDebugLog("[ExeResourceLoader] Ignoring by type %8...".utf16(), entry.unionName.ref.id)
 						continue
@@ -524,7 +524,7 @@ fun findResourceExW(hModule HModule, lpType ConstArrayPointer<ClangWideChar>, lp
 	var simpleResource = true
 
 	if not is_int_resource(lpName as! UInt64) {
-		tofitaDebugLog("findResourceExW lpType %S".utf16(), lpType as! UInt64)
+		tofitaDebugLog("findResourceExW lpType %8 %S".utf16(), lpType as! UInt64, lpType as! UInt64)
 		simpleResource = false
 	}
 

dlls/user32/user32.hexa

@@ -84,14 +84,16 @@ fun registerClassW(wc WindowClass) Atom {
 	}
 
 	// TODO sizeOf struct by value(!)
-	// TODO `new ClassesLinkedList()`
+	// TODO `new ClassesLinkedList()` but on the heap
 	// TODO just use Hexa Map here
 	// TODO use SEH for string pointer validation? At least check it is not null ptr
 	let className = isAtom(wc.utf16zClassName as! UInt64) ? '#' + (wc.utf16zClassName as! UInt64) : String.fromUTF16zUpTo(wc.utf16zClassName as! ConstArrayPointer<UInt16>, classNameLimit)
 	tofitaDebugLog('registerClassW className "%S"'.utf16(), className.utf16() as! UInt64)
 	let list = ClassesLinkedList(named: className)
 	list.next = null
 
+	// TODO on heap `list.wc = @heap WindowClass()` and `list.wc = @malloc/@calloc WindowClass()`
+	// ^ `@heap` is more flexible cause offers RC for native libraries memory management
 	list.wc = WindowClass()
 	// TODO `new T() { ...wc }` to make a copy
 	memcpy(list.wc as! ArrayPointer<UInt8>, wc as! ConstArrayPointer<UInt8>, sizeOf<WindowClass>() as! Int)
@@ -139,7 +141,7 @@ fun createWindowExW(
 		list = list.next
 
 		if list.name == className {
-			tofitaDebugLog("CreateWindowExW found class {%S}\n".utf16(), className.utf16() as! UInt64)
+			tofitaDebugLog("> CreateWindowExW found class \"%S\"".utf16(), className.utf16() as! UInt64)
 			found = true
 			wc = list.wc
 			break
@@ -172,6 +174,7 @@ fun createWindowExW(
 	payload.x = x
 	payload.y = y
 	// TODO test zero-width
+	// TODO Hexa: encode as `enum WindowSize { CW_USE_DEFAULT = 123 Custom = .../_ } case Custom(value):`
 	// TODO respect CW_USE_DEFAULT etc for pos and size
 	payload.nWidth = nWidth <= 0? 316 : nWidth
 	payload.nHeight = nHeight <= 0? 163 : nHeight
@@ -205,6 +208,7 @@ fun createWindowExW(
 	window.proc = wc.lpfnWndProc
 	tofitaDebugLog("> window.proc = {%8}".utf16(), window.proc as! UInt64)
 
+	// TODO `payload.x` must be updated in the syscall instead
 	window.x = x
 	window.y = y
 	window.width = payload.nWidth
@@ -430,6 +434,18 @@ fun render(window Window, msg Msg) LResult? {
 		child.clipHeight = child.height
 
 		render(child, msg)
+		// TODO Hexa: `render(child, {...msg, hwnd: child as! HWnd})` + ensure its on stack
+		// let childMsg = Msg() // TODO ensure allocated on stack
+
+		/*
+		TODO Probably adding local message queue for speed makes sense (for messages produced within the app like this one)
+
+		Correct Behavior (Win32 Standard):
+		Children don’t inherit the parent’s WM_PAINT message. Instead, when a child’s region is invalidated (e.g., via InvalidateRect(child_hwnd, ...)), the system posts a separate WM_PAINT message to the child’s HWND, which DispatchMessage routes to the child’s proc.
+		You’d see separate log entries like:
+			dispatchMessageW called (parent WM_PAINT, hwnd=parent_hwnd)
+			dispatchMessageW called (child WM_PAINT, hwnd=child_hwnd)
+		*/
 	}
 
 	return result
@@ -455,12 +471,14 @@ fun dispatchMessageW(msg Msg) LResult? {
 		} else {
 			tofitaDebugLog("> not_WM_PAINT".utf16())
 			result = window.proc(msg.hwnd, msg.message, msg.wParam, msg.lParam)
+			tofitaDebugLog(">> msg.message = %8".utf16(), msg.message as! UInt64)
+
 		}
 		// TODO result = ERROR_SUCCESS
 	} else {
 		// TODO
 	}
-	tofitaDebugLog("DispatchMessageW done".utf16())
+	tofitaDebugLog("> DispatchMessageW done".utf16())
 	return result
 }
 
@@ -843,7 +861,7 @@ fun getClipboardData(stub SizeOfPointer) SizeOfPointer {
 		i++
 	}
 
-	tofitaDebugLog("lstrlenW %S %d".utf16(), str as! UInt64, i as! UInt64)
+	tofitaDebugLog("lstrlenW '%S' %d".utf16(), str as! UInt64, i as! UInt64)
 	return i
 }
 
@@ -1180,13 +1198,15 @@ fun getClientRect(
 	lpRect Rect
 ) Bool32 {
 	tofitaDebugLog("GetClientRect called with hWnd %8 lpRect %8".utf16(), hWnd as! UInt64, lpRect as! UInt64)
+	// TODO verify that window.x and window.y are relative to the parent window’s client area (which they should be for child windows).
 	if let window = handleToWindow(hWnd) {
 		lpRect.left = window.x
 		lpRect.top = window.y
 		lpRect.right = window.width
 		lpRect.bottom = window.height
 		return Bool32.True
 	}
+
 	return Bool32.False
 }
 

dlls/user32/userMain.hexa

@@ -369,6 +369,13 @@ fun buttonWindowProcW(hWnd HWnd, uMsg Message, wParam WParam, lParam LParam) LRe
 				case _:
 					// Includes BS_PUSH_BUTTON and BS_DEF_PUSH_BUTTON
 
+					// TODO
+					// Draw push button
+					// - black frame
+					// - shadow etc.
+					// - title string
+					// - rectangle with dash line it means focus
+					// (and strong black frame for default button)
 					let r = ByValue<Rect>()
 					getClientRect(hWnd, r.ref)
 					let fmt DrawTextFormat = DrawTextFormat.DT_CENTER // TODO | DrawTextFormat.DT_VCENTER
@@ -384,6 +391,11 @@ fun buttonWindowProcW(hWnd HWnd, uMsg Message, wParam WParam, lParam LParam) LRe
 							drawTextW(hdc, title, -1, r.ref, fmt)
 						}
 					}
+
+				// TODO
+				// if focus
+				// - drawEdge(hdc, &r, BDR_RAISEDINNER, BF_MIDDLE | BF_RECT);
+				// - drawFocusRect(hdc, &r);
 			}
 
 			// TODO restore font and bkg