func toShort(path string) (string, error) {
	p := syscall.StringToUTF16(path)
	b := p // GetShortPathName says we can reuse buffer
	n, err := syscall.GetShortPathName(&p[0], &b[0], uint32(len(b)))
	if err != nil {
		return "", err
	}
	if n > uint32(len(b)) {
		b = make([]uint16, n)
		n, err = syscall.GetShortPathName(&p[0], &b[0], uint32(len(b)))
		if err != nil {
			return "", err
		}
	}
	return syscall.UTF16ToString(b), nil
}
Пример #2
0
func getTuntapComponentId() (string, error) {
	adapters, err := registry.OpenKey(registry.LOCAL_MACHINE, ADAPTER_KEY, registry.READ)
	if err != nil {
		return "", err
	}
	var i uint32
	for ; i < 1000; i++ {
		var name_length uint32 = TAPWIN32_MAX_REG_SIZE
		buf := make([]uint16, name_length)
		if err = syscall.RegEnumKeyEx(
			syscall.Handle(adapters),
			i,
			&buf[0],
			&name_length,
			nil,
			nil,
			nil,
			nil); err != nil {
			return "", err
		}
		key_name := syscall.UTF16ToString(buf[:])
		adapter, err := registry.OpenKey(adapters, key_name, registry.READ)
		if err != nil {
			return "", err
		}
		name := syscall.StringToUTF16("ComponentId")
		name2 := syscall.StringToUTF16("NetCfgInstanceId")
		var valtype uint32
		var component_id = make([]byte, TAPWIN32_MAX_REG_SIZE)
		var componentLen = uint32(len(component_id))
		if err = syscall.RegQueryValueEx(
			syscall.Handle(adapter),
			&name[0],
			nil,
			&valtype,
			&component_id[0],
			&componentLen); err != nil {
			return "", err
		}

		if unicodeTostring(component_id) == TUNTAP_COMPONENT_ID {
			var valtype uint32
			var netCfgInstanceId = make([]byte, TAPWIN32_MAX_REG_SIZE)
			var netCfgInstanceIdLen = uint32(len(netCfgInstanceId))
			if err = syscall.RegQueryValueEx(
				syscall.Handle(adapter),
				&name2[0],
				nil,
				&valtype,
				&netCfgInstanceId[0],
				&netCfgInstanceIdLen); err != nil {
				return "", err
			}
			fmt.Println("Device:", unicodeTostring(netCfgInstanceId))
			return unicodeTostring(netCfgInstanceId), nil
		}
	}
	return "", errors.New("not found component id")
}
Пример #3
0
func (p *Printer) StartDocument(name, datatype string) error {
	d := DOC_INFO_1{
		DocName:    &(syscall.StringToUTF16(name))[0],
		OutputFile: nil,
		Datatype:   &(syscall.StringToUTF16(datatype))[0],
	}
	return StartDocPrinter(p.h, 1, &d)
}
Пример #4
0
func (ni *NotifyIcon) showMessage(title, info string, iconType uint32) error {
	nid := ni.notifyIconData()
	nid.UFlags = NIF_INFO
	nid.DwInfoFlags = iconType
	copy(nid.SzInfoTitle[:], syscall.StringToUTF16(title))
	copy(nid.SzInfo[:], syscall.StringToUTF16(info))

	if !Shell_NotifyIcon(NIM_MODIFY, nid) {
		return newError("Shell_NotifyIcon")
	}

	return nil
}
Пример #5
0
// if not existing, creating new one.
func EditVariable(etype EnvType, varName string, varValue string) error {
	var rootkey HKEY
	var subkey string

	if etype == 0 {
		rootkey = HKEY_CURRENT_USER
		subkey = USR_SUBKEY
	} else {
		rootkey = HKEY_LOCAL_MACHINE
		subkey = SYS_SUBKEY
	}

	var mykey HKEY

	if ret := RegOpenKeyEx(rootkey, syscall.StringToUTF16Ptr(subkey), 0, KEY_WRITE, &mykey); ret != ERROR_SUCCESS {
		return errors.New(fmt.Sprintf("EditVariable error, RegOpenKeyEx = %d", ret))
	}

	dataType := REG_SZ
	if strings.Index(varValue, "%") != -1 {
		dataType = REG_EXPAND_SZ
	}

	if ret := RegSetValueEx(mykey,
		syscall.StringToUTF16Ptr(varName),
		0,
		uint64(dataType),
		(*byte)(unsafe.Pointer(syscall.StringToUTF16Ptr(varValue))),
		// In Bytes.
		uint32(len(syscall.StringToUTF16(varValue))*2)); ret != ERROR_SUCCESS {
		return errors.New(fmt.Sprintf("EditVariable error, RegSetValueEx = %d", ret))
	}
	return nil
}
Пример #6
0
func (this *Font) createForDPI(dpi int) w32.HFONT {
	var lf w32.LOGFONT

	lf.Height = -w32.MulDiv(this.pointSize, dpi, 72)
	if this.style&FontBold > 0 {
		lf.Weight = w32.FW_BOLD
	} else {
		lf.Weight = w32.FW_NORMAL
	}
	if this.style&FontItalic > 0 {
		lf.Italic = 1
	}
	if this.style&FontUnderline > 0 {
		lf.Underline = 1
	}
	if this.style&FontStrikeOut > 0 {
		lf.StrikeOut = 1
	}
	lf.CharSet = w32.DEFAULT_CHARSET
	lf.OutPrecision = w32.OUT_TT_PRECIS
	lf.ClipPrecision = w32.CLIP_DEFAULT_PRECIS
	lf.Quality = w32.CLEARTYPE_QUALITY
	lf.PitchAndFamily = w32.VARIABLE_PITCH | w32.FF_SWISS

	src := syscall.StringToUTF16(this.family)
	dest := lf.FaceName[:]
	copy(dest, src)

	return w32.CreateFontIndirect(&lf)
}
Пример #7
0
func (k *Key) setString(name string, value string, valtype uint32) error {
	buf := syscall.StringToUTF16(value)
	return winapi.RegSetValueEx(
		k.Handle, syscall.StringToUTF16Ptr(name),
		0, valtype,
		(*byte)(unsafe.Pointer(&buf[0])), uint32(len(buf)*2))
}
Пример #8
0
Файл: font.go Проект: wiloe/walk
func (f *Font) createForDPI(dpi int) HFONT {
	var lf LOGFONT

	lf.LfHeight = -MulDiv(int32(f.pointSize), int32(dpi), 72)
	if f.style&FontBold > 0 {
		lf.LfWeight = FW_BOLD
	} else {
		lf.LfWeight = FW_NORMAL
	}
	if f.style&FontItalic > 0 {
		lf.LfItalic = 1
	}
	if f.style&FontUnderline > 0 {
		lf.LfUnderline = 1
	}
	if f.style&FontStrikeOut > 0 {
		lf.LfStrikeOut = 1
	}
	lf.LfCharSet = DEFAULT_CHARSET
	lf.LfOutPrecision = OUT_TT_PRECIS
	lf.LfClipPrecision = CLIP_DEFAULT_PRECIS
	lf.LfQuality = CLEARTYPE_QUALITY
	lf.LfPitchAndFamily = VARIABLE_PITCH | FF_SWISS

	src := syscall.StringToUTF16(f.family)
	dest := lf.LfFaceName[:]
	copy(dest, src)

	return CreateFontIndirect(&lf)
}
Пример #9
0
// Remove removes the named file or directory.
// If there is an error, it will be of type *PathError.
func Remove(name string) error {
	p := &syscall.StringToUTF16(name)[0]

	// Go file interface forces us to know whether
	// name is a file or directory. Try both.
	e := syscall.DeleteFile(p)
	if e == nil {
		return nil
	}
	e1 := syscall.RemoveDirectory(p)
	if e1 == nil {
		return nil
	}

	// Both failed: figure out which error to return.
	if e1 != e {
		a, e2 := syscall.GetFileAttributes(p)
		if e2 != nil {
			e = e2
		} else {
			if a&syscall.FILE_ATTRIBUTE_DIRECTORY != 0 {
				e = e1
			}
		}
	}
	return &PathError{"remove", name, e}
}
Пример #10
0
func (wb *WidgetBase) calculateTextSizeImpl(text string) Size {
	hdc := GetDC(wb.hWnd)
	if hdc == 0 {
		newError("GetDC failed")
		return Size{}
	}
	defer ReleaseDC(wb.hWnd, hdc)

	hFontOld := SelectObject(hdc, HGDIOBJ(wb.Font().handleForDPI(0)))
	defer SelectObject(hdc, hFontOld)

	var size Size
	lines := strings.Split(text, "\n")

	for _, line := range lines {
		var s SIZE
		str := syscall.StringToUTF16(strings.TrimRight(line, "\r "))

		if !GetTextExtentPoint32(hdc, &str[0], int32(len(str)-1), &s) {
			newError("GetTextExtentPoint32 failed")
			return Size{}
		}

		size.Width = maxi(size.Width, int(s.CX))
		size.Height += int(s.CY)
	}

	return size
}
Пример #11
0
func (lb *ListBox) calculateMaxItemTextWidth() int {
	hdc := win.GetDC(lb.hWnd)
	if hdc == 0 {
		newError("GetDC failed")
		return -1
	}
	defer win.ReleaseDC(lb.hWnd, hdc)

	hFontOld := win.SelectObject(hdc, win.HGDIOBJ(lb.Font().handleForDPI(0)))
	defer win.SelectObject(hdc, hFontOld)

	var maxWidth int

	if lb.model == nil {
		return -1
	}
	count := lb.model.ItemCount()
	for i := 0; i < count; i++ {
		item := lb.itemString(i)
		var s win.SIZE
		str := syscall.StringToUTF16(item)

		if !win.GetTextExtentPoint32(hdc, &str[0], int32(len(str)-1), &s) {
			newError("GetTextExtentPoint32 failed")
			return -1
		}

		maxWidth = maxi(maxWidth, int(s.CX))
	}

	return maxWidth
}
Пример #12
0
// Use to write string value to windows registry the HKEY in the next definition HHLM, HKCU, HKCC, HKCR, HKU
func WriteStringReg(hkey, path, name, val string) (err error) {
	var handle syscall.Handle
	switch hkey {
	case "HKLM":
		err = syscall.RegOpenKeyEx(syscall.HKEY_LOCAL_MACHINE, syscall.StringToUTF16Ptr(""), 0, syscall.KEY_CREATE_SUB_KEY, &handle)
	case "HKCC":
		err = syscall.RegOpenKeyEx(syscall.HKEY_CURRENT_CONFIG, syscall.StringToUTF16Ptr(""), 0, syscall.KEY_CREATE_SUB_KEY, &handle)
	case "HKCR":
		err = syscall.RegOpenKeyEx(syscall.HKEY_CLASSES_ROOT, syscall.StringToUTF16Ptr(""), 0, syscall.KEY_CREATE_SUB_KEY, &handle)
	case "HKCU":
		err = syscall.RegOpenKeyEx(syscall.HKEY_CURRENT_USER, syscall.StringToUTF16Ptr(""), 0, syscall.KEY_CREATE_SUB_KEY, &handle)
	case "HKU":
		err = syscall.RegOpenKeyEx(syscall.HKEY_USERS, syscall.StringToUTF16Ptr(""), 0, syscall.KEY_CREATE_SUB_KEY, &handle)
	default:
		err = errors.New("Unknown HKEY: " + hkey)
		return
	}
	if err != nil {
		return
	}
	defer syscall.RegCloseKey(handle)
	var d uint32
	err = winapi.RegCreateKeyEx(handle, syscall.StringToUTF16Ptr(path), 0, nil, winapi.REG_OPTION_NON_VOLATILE, syscall.KEY_ALL_ACCESS, nil, &handle, &d)
	if err != nil {
		return
	}
	buf := syscall.StringToUTF16(val)
	err = winapi.RegSetValueEx(handle, syscall.StringToUTF16Ptr(name), 0, syscall.REG_SZ, (*byte)(unsafe.Pointer(&buf[0])), uint32(len(buf)*2))
	return
}
Пример #13
0
func (w *Window) AddTrayIcon(ico Icon, tip string) {
	if w.trayIconData != nil {
		return
	}

	w.trayIconData = &w32.NOTIFYICONDATA{
		/* Size */ uint32(unsafe.Sizeof(*w.trayIconData)),
		/* Wnd */ w.handle,
		/* ID */ 1,
		/* Flags */ w32.NIF_MESSAGE | w32.NIF_ICON | w32.NIF_TIP | w32.NIF_SHOWTIP,
		/* CallbackMessage */ WM_TRAYICON,
		/* Icon */ w32.HICON(ico),
		/* Tip */ [128]uint16{},
		/* State */ 0,
		/* StateMask */ 0,
		/* Info */ [256]uint16{},
		/* TimeoutOrVersion */ w32.NOTIFYICON_VERSION_4,
		/* InfoTitle */ [64]uint16{},
		/* InfoFlags */ 0,
		/* Item */ w32.GUID{},
		/* BalloonIcon */ 0,
	}

	tipbuf := syscall.StringToUTF16(tip)
	copy(w.trayIconData.Tip[:], tipbuf)

	w32.Shell_NotifyIcon(w32.NIM_ADD, w.trayIconData)
}
Пример #14
0
func (cb *ComboBox) calculateMaxItemTextWidth() int {
	hdc := GetDC(cb.hWnd)
	if hdc == 0 {
		newError("GetDC failed")
		return -1
	}
	defer ReleaseDC(cb.hWnd, hdc)

	hFontOld := SelectObject(hdc, HGDIOBJ(cb.Font().handleForDPI(0)))
	defer SelectObject(hdc, hFontOld)

	var maxWidth int

	count := cb.model.ItemCount()
	for i := 0; i < count; i++ {
		var s SIZE
		str := syscall.StringToUTF16(cb.itemString(i))

		if !GetTextExtentPoint32(hdc, &str[0], int32(len(str)-1), &s) {
			newError("GetTextExtentPoint32 failed")
			return -1
		}

		maxWidth = maxi(maxWidth, int(s.CX))
	}

	return maxWidth
}
Пример #15
0
func genOFN(parent Controller, title, filter string, filterIndex uint, initialDir string, buf []uint16) *w32.OPENFILENAME {
	var ofn w32.OPENFILENAME
	ofn.StructSize = uint32(unsafe.Sizeof(ofn))
	ofn.Owner = parent.Handle()

	if filter != "" {
		filterBuf := make([]uint16, len(filter)+1)
		copy(filterBuf, syscall.StringToUTF16(filter))
		// Replace '|' with the expcted '\0'
		for i, c := range filterBuf {
			if byte(c) == '|' {
				filterBuf[i] = uint16(0)
			}
		}
		ofn.Filter = &filterBuf[0]
		ofn.FilterIndex = uint32(filterIndex)
	}

	ofn.File = &buf[0]
	ofn.MaxFile = uint32(len(buf))

	if initialDir != "" {
		ofn.InitialDir = syscall.StringToUTF16Ptr(initialDir)
	}
	if title != "" {
		ofn.Title = syscall.StringToUTF16Ptr(title)
	}

	ofn.Flags = w32.OFN_FILEMUSTEXIST

	return &ofn
}
Пример #16
0
func open(path string, flag int, perm os.FileMode) (*os.File, error) {
	if path == "" {
		return nil, fmt.Errorf("cannot open empty filename")
	}
	var access uint32
	switch flag {
	case syscall.O_RDONLY:
		access = syscall.GENERIC_READ
	case syscall.O_WRONLY:
		access = syscall.GENERIC_WRITE
	case syscall.O_RDWR:
		access = syscall.GENERIC_READ | syscall.GENERIC_WRITE
	case syscall.O_WRONLY | syscall.O_CREAT:
		access = syscall.GENERIC_ALL
	default:
		panic(fmt.Errorf("flag %v is not supported", flag))
	}
	fd, err := syscall.CreateFile(&(syscall.StringToUTF16(path)[0]),
		access,
		syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE,
		nil,
		syscall.OPEN_ALWAYS,
		syscall.FILE_ATTRIBUTE_NORMAL,
		0)
	if err != nil {
		return nil, err
	}
	return os.NewFile(uintptr(fd), path), nil
}
Пример #17
0
func MakeDoubleNullTerminatedLpstr(items ...string) *uint16 {
	chars := []uint16{}
	for _, s := range items {
		chars = append(chars, syscall.StringToUTF16(s)...)
	}
	chars = append(chars, 0)
	return &chars[0]
}
Пример #18
0
func GetAllMediaIDs(printerName string, port string) ([]int, error) {
	//port, err := GetPrinterPort(printerName)
	res, err := DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_PAPERS, nil, nil)
	var numSizes int = int(res)
	if err != nil || numSizes <= 0 {
		return nil, err
	}
	buf := make([]uint16, numSizes)
	_, err = DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_PAPERS, &buf[0], nil)
	if err != nil {
		return nil, err
	}
	mediaIDs := make([]int, numSizes)
	for i, mediaID := range buf {
		mediaIDs[i] = int(mediaID)
	}
	return mediaIDs, nil
}
Пример #19
0
func Open(name string) (*Printer, error) {
	var p Printer
	// TODO: implement pDefault parameter
	err := OpenPrinter(&(syscall.StringToUTF16(name))[0], &p.h, 0)
	if err != nil {
		return nil, err
	}
	return &p, nil
}
Пример #20
0
func GetAllResolutions(printerName string, port string) ([]int, error) {
	//port, err := GetPrinterPort(printerName)
	res, err := DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_ENUMRESOLUTIONS, nil, nil)
	var nResolutions int = int(res)
	if err != nil || nResolutions <= 0 {
		return nil, err
	}
	buf := make([]uint, nResolutions*2)
	_, err = DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_ENUMRESOLUTIONS, (*uint16)(unsafe.Pointer(&buf[0])), nil)
	if err != nil {
		return nil, err
	}
	resolutions := make([]int, nResolutions*2)
	for i, resolution := range buf {
		resolutions[i] = int(resolution)
	}
	return resolutions, nil
}
Пример #21
0
func GetAllMediaSizes(printerName string, port string) ([]int, error) {
	//port, err := GetPrinterPort(printerName)
	res, err := DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_PAPERSIZE, nil, nil)
	var nPapers int = int(res)
	if err != nil || nPapers <= 0 {
		return nil, err
	}
	buf := make([]Point, nPapers)
	_, err = DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_PAPERSIZE, (*uint16)(unsafe.Pointer(&buf[0])), nil)
	if err != nil {
		return nil, err
	}
	mediaSizes := make([]int, nPapers*2)
	for i, mediaID := range buf {
		mediaSizes[i*2] = int(mediaID.X)
		mediaSizes[i*2+1] = int(mediaID.Y)
	}
	return mediaSizes, nil
}
Пример #22
0
func (dlg *FileDialog) show(owner RootWidget, fun func(ofn *OPENFILENAME) bool) (accepted bool, err error) {
	ofn := new(OPENFILENAME)

	ofn.LStructSize = uint32(unsafe.Sizeof(*ofn))
	if owner != nil {
		ofn.HwndOwner = owner.Handle()
	}

	filter := make([]uint16, len(dlg.Filter)+2)
	copy(filter, syscall.StringToUTF16(dlg.Filter))
	// Replace '|' with the expected '\0'.
	for i, c := range filter {
		if byte(c) == '|' {
			filter[i] = uint16(0)
		}
	}
	ofn.LpstrFilter = &filter[0]
	ofn.NFilterIndex = uint32(dlg.FilterIndex)

	filePath := make([]uint16, 1024)
	copy(filePath, syscall.StringToUTF16(dlg.FilePath))
	ofn.LpstrFile = &filePath[0]
	ofn.NMaxFile = uint32(len(filePath))

	ofn.LpstrInitialDir = syscall.StringToUTF16Ptr(dlg.InitialDirPath)
	ofn.LpstrTitle = syscall.StringToUTF16Ptr(dlg.Title)
	ofn.Flags = OFN_FILEMUSTEXIST

	if !fun(ofn) {
		errno := CommDlgExtendedError()
		if errno != 0 {
			err = newError(fmt.Sprintf("Error %d", errno))
		}
		return
	}

	dlg.FilePath = syscall.UTF16ToString(filePath)

	accepted = true

	return
}
Пример #23
0
func MakeFileMutex(filename string) *FileMutex {
	if filename == "" {
		return &FileMutex{fd: INVALID_FILE_HANDLE}
	}
	fd, err := syscall.CreateFile(&(syscall.StringToUTF16(filename)[0]), syscall.GENERIC_READ|syscall.GENERIC_WRITE,
		syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE, nil, syscall.OPEN_ALWAYS, syscall.FILE_ATTRIBUTE_NORMAL, 0)
	if err != nil {
		panic(err)
	}
	return &FileMutex{fd: fd}
}
Пример #24
0
func (tp *TabPage) tcItem() *win.TCITEM {
	text := syscall.StringToUTF16(tp.Title())

	item := &win.TCITEM{
		Mask:       win.TCIF_TEXT,
		PszText:    &text[0],
		CchTextMax: int32(len(text)),
	}

	return item
}
Пример #25
0
func GetAllMediaNames(printerName string, port string) ([]string, error) {
	//port, err := GetPrinterPort(printerName)
	paperNameLength := 64
	res, err := DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_PAPERNAMES, nil, nil)
	var nReturned int = int(res)
	if err != nil || nReturned <= 0 {
		return nil, err
	}
	buf := make([]uint16, nReturned*paperNameLength)
	_, err = DeviceCapabilities(&(syscall.StringToUTF16(printerName))[0], &(syscall.StringToUTF16(port))[0], DC_PAPERNAMES, &buf[0], nil)
	if err != nil {
		return nil, err
	}
	names := make([]string, 0)
	for i := 0; i < nReturned; i++ {
		name := syscall.UTF16ToString(buf[i*paperNameLength : (i+1)*paperNameLength])
		names = append(names, name)
	}
	return names, err
}
Пример #26
0
func (l *locker) Lock(lockfilename string) error {
	if l.fd != INVALID_FILE_HANDLE {
		return ErrFailedToAcquireLock
	}

	var flags uint32
	if l.nonblock {
		flags = LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY
	} else {
		flags = LOCKFILE_EXCLUSIVE_LOCK
	}

	if lockfilename == "" {
		return ErrLockFileEmpty
	}
	fd, err := syscall.CreateFile(&(syscall.StringToUTF16(lockfilename)[0]), syscall.GENERIC_READ|syscall.GENERIC_WRITE,
		syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE, nil, syscall.OPEN_ALWAYS, syscall.FILE_ATTRIBUTE_NORMAL, 0)
	if err != nil {
		return fmt.Errorf("setlock: fatal: unable to open %s: temporary failure", lockfilename)
	}

	if fd == INVALID_FILE_HANDLE {
		return ErrFailedToAcquireLock
	}
	defer func() {
		// Close this descriptor if we failed to lock
		if l.fd == INVALID_FILE_HANDLE {
			// l.fd is not set, I guess we didn't suceed
			syscall.CloseHandle(fd)
		}
	}()

	var ol syscall.Overlapped
	var mu sync.RWMutex
	mu.Lock()
	defer mu.Unlock()

	r1, _, _ := syscall.Syscall6(
		procLockFileEx.Addr(),
		6,
		uintptr(fd), // handle
		uintptr(flags),
		uintptr(0), // reserved
		uintptr(1), // locklow
		uintptr(0), // lockhigh
		uintptr(unsafe.Pointer(&ol)),
	)
	if r1 == 0 {
		return ErrFailedToAcquireLock
	}

	l.fd = fd
	return nil
}
Пример #27
0
func set(hkey HKEY, path, key, value string) {
	v := syscall.StringToUTF16(value)
	with(hkey, path, func(subkey HKEY) {
		RegSetValueEx.Call(
			uintptr(subkey),
			uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(key))),
			0,
			uintptr(REG_EXPAND_SZ),
			uintptr(unsafe.Pointer(&v[0])),
			uintptr(len(v)*2),
		)
	})
}
Пример #28
0
func (tw *TabWidget) tcitemFromPage(page *TabPage) *win.TCITEM {
	imageIndex, _ := tw.imageIndex(page.image)
	text := syscall.StringToUTF16(page.title)

	item := &win.TCITEM{
		Mask:       win.TCIF_IMAGE | win.TCIF_TEXT,
		IImage:     imageIndex,
		PszText:    &text[0],
		CchTextMax: int32(len(text)),
	}

	return item
}
Пример #29
0
func ListToEnvironmentBlock(list *[]string) *uint16 {
	if list == nil {
		return nil
	}

	size := 1
	for _, v := range *list {
		size += len(syscall.StringToUTF16(v))
	}

	result := make([]uint16, size)

	tail := 0

	for _, v := range *list {
		uline := syscall.StringToUTF16(v)
		copy(result[tail:], uline)
		tail += len(uline)
	}

	result[tail] = 0

	return &result[0]
}
Пример #30
0
func (p *PrinterInfo) hDevNames() HGLOBAL {
	driverName := syscall.StringToUTF16(p.driverName)
	printerName := syscall.StringToUTF16(UTF16PtrToString(p.printerNamePtr()))
	outputPort := syscall.StringToUTF16(p.outputPort)

	driverLen := len(driverName) + 1
	printerLen := len(printerName) + 1
	portLen := len(outputPort) + 1

	var dn DEVNAMES
	hDevNames := GlobalAlloc(GHND, uintptr(unsafe.Sizeof(dn)+(driverLen+printerLen+portLen)*2))
	devNames := (*DEVNAMES)(GlobalLock(hDevNames))
	defer GlobalUnlock(hDevNames)

	devNames.WDriverOffset = uint16(unsafe.Sizeof(*devNames) / 2)
	devNames.WDeviceOffset = devNames.WDriverOffset + uint16(driverLen)
	devNames.WOutputOffset = devNames.WDeviceOffset + uint16(printerLen)

	MoveMemory(unsafe.Pointer(uintptr(unsafe.Pointer(devNames))+uintptr(devNames.WDriverOffset)), unsafe.Pointer(&driverName[0]), uintptr(driverLen*2))
	MoveMemory(unsafe.Pointer(uintptr(unsafe.Pointer(devNames))+uintptr(devNames.WDeviceOffset)), unsafe.Pointer(&printerName[0]), uintptr(printerLen*2))
	MoveMemory(unsafe.Pointer(uintptr(unsafe.Pointer(devNames))+uintptr(devNames.WOutputOffset)), unsafe.Pointer(&outputPort[0]), uintptr(portLen*2))

	return hDevNames
}