Refactoring for Maintainability and further development

Author: Didier Gehéniau

AUTHORS

@@ -19,6 +19,7 @@ Carl Kittelberger <[email protected]>
 Carlos Cobo <[email protected]>
 Cary Cherng <[email protected]>
 Cory Redmond <[email protected]>
+D4v1dW3bb
 David Porter <[email protected]>
 Dmitry Bagdanov <[email protected]>
 gonutz
@@ -32,3 +33,4 @@ ryujimiya <[email protected]>
 Simon Rozman <[email protected]>
 Tiago Carvalho <[email protected]>
 wsf01 <[email protected]>
+

README.mdown

@@ -1,15 +1,14 @@
 About win
 =========
 
-win is a Windows API wrapper package for Go.
+winapi is a Windows API wrapper package for Go.
+It's a refactored version of the gitcom repository [win](https://github.com/lxn/win)
 
-Originally part of [walk](https://github.com/lxn/walk), it is now a separate
-project.
 
 Setup
 =====
 
 Make sure you have a working Go installation.
 See [Getting Started](http://golang.org/doc/install.html)
 
-Now run `go get github.com/lxn/win`
+Now run `go get github.com/D4v1dW3bb/winapi`

advapi32.go

@@ -0,0 +1,45 @@
+// Copyright 2010 The win Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package advapi32
+
+// Button control messages
+const KEY_READ REGSAM = 0x20019
+const KEY_WRITE REGSAM = 0x20006
+
+const (
+	HKEY_CLASSES_ROOT     HKEY = 0x80000000
+	HKEY_CURRENT_USER     HKEY = 0x80000001
+	HKEY_LOCAL_MACHINE    HKEY = 0x80000002
+	HKEY_USERS            HKEY = 0x80000003
+	HKEY_PERFORMANCE_DATA HKEY = 0x80000004
+	HKEY_CURRENT_CONFIG   HKEY = 0x80000005
+	HKEY_DYN_DATA         HKEY = 0x80000006
+)
+
+const (
+	ERROR_NO_MORE_ITEMS = 259
+)
+
+const (
+	REG_NONE      uint64 = 0 // No value type
+	REG_SZ               = 1 // Unicode nul terminated string
+	REG_EXPAND_SZ        = 2 // Unicode nul terminated string
+
+	// (with environment variable references)
+	REG_BINARY                     = 3 // Free form binary
+	REG_DWORD                      = 4 // 32-bit number
+	REG_DWORD_LITTLE_ENDIAN        = 4 // 32-bit number (same as REG_DWORD)
+	REG_DWORD_BIG_ENDIAN           = 5 // 32-bit number
+	REG_LINK                       = 6 // Symbolic Link (unicode)
+	REG_MULTI_SZ                   = 7 // Multiple Unicode strings
+	REG_RESOURCE_LIST              = 8 // Resource list in the resource map
+	REG_FULL_RESOURCE_DESCRIPTOR   = 9 // Resource list in the hardware description
+	REG_RESOURCE_REQUIREMENTS_LIST = 10
+	REG_QWORD                      = 11 // 64-bit number
+	REG_QWORD_LITTLE_ENDIAN        = 11 // 64-bit number (same as REG_QWORD)
+
+)

advapi32/advapi32_const.go

@@ -0,0 +1,70 @@
+// Copyright 2010 The win Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package advapi32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func RegCloseKey(hKey HKEY) int32 {
+	ret, _, _ := syscall.Syscall(regCloseKey.Addr(), 1,
+		uintptr(hKey),
+		0,
+		0)
+
+	return int32(ret)
+}
+
+func RegOpenKeyEx(hKey HKEY, lpSubKey *uint16, ulOptions uint32, samDesired REGSAM, phkResult *HKEY) int32 {
+	ret, _, _ := syscall.Syscall6(regOpenKeyEx.Addr(), 5,
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(lpSubKey)),
+		uintptr(ulOptions),
+		uintptr(samDesired),
+		uintptr(unsafe.Pointer(phkResult)),
+		0)
+
+	return int32(ret)
+}
+
+func RegQueryValueEx(hKey HKEY, lpValueName *uint16, lpReserved, lpType *uint32, lpData *byte, lpcbData *uint32) int32 {
+	ret, _, _ := syscall.Syscall6(regQueryValueEx.Addr(), 6,
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(lpValueName)),
+		uintptr(unsafe.Pointer(lpReserved)),
+		uintptr(unsafe.Pointer(lpType)),
+		uintptr(unsafe.Pointer(lpData)),
+		uintptr(unsafe.Pointer(lpcbData)))
+
+	return int32(ret)
+}
+
+func RegEnumValue(hKey HKEY, index uint32, lpValueName *uint16, lpcchValueName *uint32, lpReserved, lpType *uint32, lpData *byte, lpcbData *uint32) int32 {
+	ret, _, _ := syscall.Syscall9(regEnumValue.Addr(), 8,
+		uintptr(hKey),
+		uintptr(index),
+		uintptr(unsafe.Pointer(lpValueName)),
+		uintptr(unsafe.Pointer(lpcchValueName)),
+		uintptr(unsafe.Pointer(lpReserved)),
+		uintptr(unsafe.Pointer(lpType)),
+		uintptr(unsafe.Pointer(lpData)),
+		uintptr(unsafe.Pointer(lpcbData)),
+		0)
+	return int32(ret)
+}
+
+func RegSetValueEx(hKey HKEY, lpValueName *uint16, lpReserved, lpDataType uint64, lpData *byte, cbData uint32) int32 {
+	ret, _, _ := syscall.Syscall6(regSetValueEx.Addr(), 6,
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(lpValueName)),
+		uintptr(lpReserved),
+		uintptr(lpDataType),
+		uintptr(unsafe.Pointer(lpData)),
+		uintptr(cbData))
+	return int32(ret)
+}

advapi32/advapi32_func.go

@@ -0,0 +1,33 @@
+// Copyright 2010 The win Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package advapi32
+
+import "golang.org/x/sys/windows"
+
+var (
+	// Library
+	libadvapi32 *windows.LazyDLL
+
+	// Functions
+	regCloseKey     *windows.LazyProc
+	regOpenKeyEx    *windows.LazyProc
+	regQueryValueEx *windows.LazyProc
+	regEnumValue    *windows.LazyProc
+	regSetValueEx   *windows.LazyProc
+)
+
+func init() {
+	// Library
+	libadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
+
+	// Functions
+	regCloseKey = libadvapi32.NewProc("RegCloseKey")
+	regOpenKeyEx = libadvapi32.NewProc("RegOpenKeyExW")
+	regQueryValueEx = libadvapi32.NewProc("RegQueryValueExW")
+	regEnumValue = libadvapi32.NewProc("RegEnumValueW")
+	regSetValueEx = libadvapi32.NewProc("RegSetValueExW")
+}

advapi32/advapi32_main.go

@@ -0,0 +1,15 @@
+// Copyright 2010 The win Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package advapi32
+
+import "github.com/D4v1dW3bb/winapi/handle"
+
+type (
+	ACCESS_MASK uint32
+	HKEY        handle.HANDLE
+	REGSAM      ACCESS_MASK
+)