Golang C.DWORD函数代码示例

// wraps SCardSetAttrib
func (card *Card) SetAttrib(id uint32, data []byte) error {
	r := C.SCardSetAttrib(card.handle, C.DWORD(id), (*C.BYTE)(&data[0]), C.DWORD(len(data)))
	if r != C.SCARD_S_SUCCESS {
		return newError(r)
	}
	return nil
}

// wraps SCardStatus
func (card *Card) Status() (*CardStatus, error) {
	var readerBuf [C.MAX_READERNAME + 1]byte
	var readerLen = C.DWORD(len(readerBuf))
	var state, proto C.DWORD
	var atr [C.MAX_ATR_SIZE]byte
	var atrLen = C.DWORD(len(atr))

	r := C.SCardStatus(card.handle, (C.LPSTR)(unsafe.Pointer(&readerBuf[0])), &readerLen, &state, &proto, (*C.BYTE)(&atr[0]), &atrLen)
	if r != C.SCARD_S_SUCCESS {
		return nil, scardError(r)
	}

	// strip terminating 0
	reader := readerBuf[:readerLen]
	if z := bytes.IndexByte(reader, 0); z != -1 {
		reader = reader[:z]
	}

	status := &CardStatus{
		Reader:         string(reader),
		State:          State(state),
		ActiveProtocol: Protocol(proto),
		ATR:            atr[0:atrLen],
	}

	return status, nil
}

// wraps SCardTransmit
func (card *Card) Transmit(cmd []byte) ([]byte, error) {
	var sendpci *C.SCARD_IO_REQUEST
	var recvpci C.SCARD_IO_REQUEST

	switch card.activeProtocol {
	case PROTOCOL_T0:
		sendpci = &C.g_rgSCardT0Pci
	case PROTOCOL_T1:
		sendpci = &C.g_rgSCardT1Pci
	case PROTOCOL_RAW:
		sendpci = &C.g_rgSCardRawPci
	default:
		panic("unknown protocol")
	}

	var recv [C.MAX_BUFFER_SIZE_EXTENDED]byte
	var recvlen C.DWORD = C.DWORD(len(recv))

	r := C.SCardTransmit(card.handle, sendpci, (*C.BYTE)(&cmd[0]), C.DWORD(len(cmd)), &recvpci, (*C.BYTE)(&recv[0]), &recvlen)
	if r != C.SCARD_S_SUCCESS {
		return nil, newError(r)
	}

	rsp := make([]byte, recvlen)
	copy(rsp, recv[0:recvlen])

	return rsp, nil
}

func (wi *windowInternal) switchToFullscreen(monitor *Monitor, mode VideoMode) error {
	devMode := C.DEVMODEW{
		dmSize:       C.DEVMODEW_size,
		dmPelsWidth:  C.DWORD(mode.Width),
		dmPelsHeight: C.DWORD(mode.Height),
		dmBitsPerPel: C.DWORD(mode.BitsPerPixel),
		dmFields:     C.DM_PELSWIDTH | C.DM_PELSHEIGHT | C.DM_BITSPERPEL,
	}

	// Apply fullscreen mode
	if err := ChangeDisplaySettingsExW(&monitor.internal.info.szDevice[0], &devMode, nil, C.CDS_FULLSCREEN, nil); err != nil {
		return err
	}

	// Make the window flags compatible with fullscreen mode
	C.SetWindowULong(wi.window.Handle, C.GWL_STYLE, C.WS_POPUP|C.WS_CLIPCHILDREN|C.WS_CLIPSIBLINGS)
	C.SetWindowLong(wi.window.Handle, C.GWL_EXSTYLE, C.WS_EX_APPWINDOW)

	// Resize the window so that it fits the entire screen
	C.SetWindowPos(wi.window.Handle, HWND_TOP, 0, 0, C.int(mode.Width), C.int(mode.Height), C.SWP_FRAMECHANGED)
	C.ShowWindow(wi.window.Handle, C.SW_SHOW)

	// Set this as the current fullscreen window
	wi.monitor = monitor
	wi.devMode = &devMode

	return nil
}

// wraps SCardTransmit
func (card *Card) Transmit(cmd []byte) ([]byte, error) {
	var sendpci C.SCARD_IO_REQUEST
	var recvpci C.SCARD_IO_REQUEST

	switch card.activeProtocol {
	case PROTOCOL_T0:
		sendpci.dwProtocol = C.SCARD_PROTOCOL_T0
	case PROTOCOL_T1:
		sendpci.dwProtocol = C.SCARD_PROTOCOL_T1
	default:
		panic("unknown protocol")
	}
	sendpci.cbPciLength = C.sizeof_SCARD_IO_REQUEST

	var recv [C.MAX_BUFFER_SIZE_EXTENDED]byte
	var recvlen C.DWORD = C.DWORD(len(recv))

	r := C.SCardTransmit(card.handle, &sendpci, (*C.BYTE)(&cmd[0]), C.DWORD(len(cmd)), &recvpci, (*C.BYTE)(&recv[0]), &recvlen)
	if r != C.SCARD_S_SUCCESS {
		return nil, scardError(r)
	}

	rsp := make([]byte, recvlen)
	copy(rsp, recv[0:recvlen])

	return rsp, nil
}

func getNativeName(DeviceInfoSet C.HDEVINFO, DeviceInfoData C.PSP_DEVINFO_DATA) (string, error) {
	key := C.SetupDiOpenDevRegKey(DeviceInfoSet, DeviceInfoData, C.DICS_FLAG_GLOBAL, 0, C.DIREG_DEV, C.KEY_READ)
	defer C.RegCloseKey(key)
	if C.is_INVALID_HANDLE_VALUE(unsafe.Pointer(key)) != C.FALSE {
		return "", errors.New(fmt.Sprintf("Reg error: %d", int(C.GetLastError())))
	}

	var i C.DWORD = 0
	var keyType C.DWORD = 0
	buffKeyName := make([]C.CHAR, 16384)
	buffKeyVal := make([]C.BYTE, 16384)
	for {
		var lenKeyName C.DWORD = C.DWORD(cap(buffKeyName))
		var lenKeyValue C.DWORD = C.DWORD(cap(buffKeyVal))
		ret := C.RegEnumValue(key, i, &buffKeyName[0], &lenKeyName, (*C.DWORD)(nil), &keyType, &buffKeyVal[0], &lenKeyValue)
		i++
		if ret == C.ERROR_SUCCESS {
			if keyType == C.REG_SZ {
				itemName := C.GoString((*C.char)(&buffKeyName[0]))
				itemValue := C.GoString((*C.char)(unsafe.Pointer((&buffKeyVal[0]))))

				if strings.Contains(itemName, "PortName") {
					return itemValue, nil
				}
			}
		} else {
			break
		}
	}

	return "", errors.New("Empty response")
}

// WriteToSoundBuffer locks the sound buffer and writes the given data into it,
// starting at the given byte offset. The buffer is a ring buffer so writing
// outside the bounds will wrap around and continue writing to the beginning.
func WriteToSoundBuffer(data []byte, offset uint) error {
	buffer := C.CString(string(data))
	defer C.free(unsafe.Pointer(buffer))
	var errContext C.int
	result := C.copyToSoundBuffer(C.DWORD(offset), buffer, C.DWORD(len(data)), &errContext)
	return makeError("writeToSoundBuffer", result, errContext)
}

func (device Device) GetPredefinedGuidAndPathProperty(
	prop, obj, how int,
) (
	guid GUID,
	path string,
	err error,
) {
	var cProp C.DIPROPGUIDANDPATH
	cProp.diph.dwSize = C.sizeof_DIPROPGUIDANDPATH
	cProp.diph.dwHeaderSize = C.sizeof_DIPROPHEADER
	cProp.diph.dwObj = C.DWORD(obj)
	cProp.diph.dwHow = C.DWORD(how)
	err = toGetPropError(C.IDirectInputDevice8GetPredefinedProperty(
		device.handle,
		unsafe.Pointer(uintptr(prop)),
		&cProp.diph,
	))
	guid.fromC(&cProp.guidClass)
	var buf [maxPath]uint16
	length := 0
	for ; length < maxPath; length++ {
		buf[length] = uint16(cProp.wszPath[length])
		if cProp.wszPath[length] == 0 {
			break
		}
	}
	path = syscall.UTF16ToString(buf[:length])
	return
}

func virtualKeyCodeToSF(vkey C.WPARAM, flags C.LPARAM) Key {
	if key, ok := keyboard_vkeys_map[C.int(vkey)]; ok {
		return key
	}

	switch vkey {
	// Check the scancode to distinguish between left and right shift
	case C.VK_SHIFT:
		scancode := C.UINT((flags & (0xFF << 16)) >> 16)
		if scancode == lShift {
			return KeyLShift
		}
		return KeyRShift

	// Check the "extended" flag to distinguish between left and right alt
	case C.VK_MENU:
		if C.__HIWORD(C.DWORD(flags))&C.KF_EXTENDED != 0 {
			return KeyRAlt
		}
		return KeyLAlt

	// Check the "extended" flag to distinguish between left and right control
	case C.VK_CONTROL:
		if C.__HIWORD(C.DWORD(flags))&C.KF_EXTENDED != 0 {
			return KeyRControl
		}
		return KeyLControl

	}

	return KeyUnknown
}

func (device Device) GetPredefinedStringProperty(
	prop, obj, how int,
) (
	value string,
	err error,
) {
	var cProp C.DIPROPSTRING
	cProp.diph.dwSize = C.sizeof_DIPROPSTRING
	cProp.diph.dwHeaderSize = C.sizeof_DIPROPHEADER
	cProp.diph.dwObj = C.DWORD(obj)
	cProp.diph.dwHow = C.DWORD(how)
	err = toGetPropError(C.IDirectInputDevice8GetPredefinedProperty(
		device.handle,
		unsafe.Pointer(uintptr(prop)),
		&cProp.diph,
	))
	var buf [maxPath]uint16
	length := 0
	for ; length < maxPath; length++ {
		buf[length] = uint16(cProp.wsz[length])
		if cProp.wsz[length] == 0 {
			break
		}
	}
	value = syscall.UTF16ToString(buf[:length])
	return
}

func NewPlayer(sampleRate, channelNum, bytesPerSample int) (*Player, error) {
	numBlockAlign := channelNum * bytesPerSample
	f := C.WAVEFORMATEX{
		wFormatTag:      C.WAVE_FORMAT_PCM,
		nChannels:       C.WORD(channelNum),
		nSamplesPerSec:  C.DWORD(sampleRate),
		nAvgBytesPerSec: C.DWORD(sampleRate * numBlockAlign),
		wBitsPerSample:  C.WORD(bytesPerSample * 8),
		nBlockAlign:     C.WORD(numBlockAlign),
	}
	var w C.HWAVEOUT
	if err := C.waveOutOpen(&w, C.WAVE_MAPPER, &f, 0, 0, C.CALLBACK_NULL); err != C.MMSYSERR_NOERROR {
		return nil, fmt.Errorf("driver: waveOutOpen error: %d", err)
	}
	p := &Player{
		out:     w,
		buffer:  []byte{},
		headers: make([]*header, numHeader),
	}
	for i := 0; i < numHeader; i++ {
		var err error
		p.headers[i], err = newHeader(w, bufferSize)
		if err != nil {
			return nil, err
		}
	}
	return p, nil
}

func NewPropDword(obj, how int, data uint32) propHeader {
	var p C.DIPROPDWORD
	p.diph.dwSize = C.sizeof_DIPROPDWORD
	p.diph.dwHeaderSize = C.sizeof_DIPROPHEADER
	p.diph.dwObj = C.DWORD(obj)
	p.diph.dwHow = C.DWORD(how)
	p.dwData = C.DWORD(data)
	return &propDword{p}
}

func NewPropPointer(obj, how int, data uintptr) propHeader {
	var p C.DIPROPPOINTER
	p.diph.dwSize = C.sizeof_DIPROPPOINTER
	p.diph.dwHeaderSize = C.sizeof_DIPROPHEADER
	p.diph.dwObj = C.DWORD(obj)
	p.diph.dwHow = C.DWORD(how)
	p.uData = C.UINT_PTR(data)
	return &propPointer{p}
}

func NewPropRange(obj, how, min, max int) propHeader {
	var p C.DIPROPRANGE
	p.diph.dwSize = C.sizeof_DIPROPRANGE
	p.diph.dwHeaderSize = C.sizeof_DIPROPHEADER
	p.diph.dwObj = C.DWORD(obj)
	p.diph.dwHow = C.DWORD(how)
	p.lMin = C.LONG(min)
	p.lMax = C.LONG(max)
	return &propRange{p}
}

// AcquireCtx acquires new CSP context from container name, provider name,
// type and flags. Empty strings for container and provider
// names are typically used for CryptVerifyContext flag setting. Created context
// must be eventually released with its Close method.
func AcquireCtx(container, provider string, provType ProvType, flags CryptFlag) (*Ctx, error) {
	var hprov C.HCRYPTPROV
	cContainer := charPtr(container)
	cProvider := charPtr(provider)
	defer freePtr(cContainer)
	defer freePtr(cProvider)

	if C.CryptAcquireContext(&hprov, cContainer, cProvider, C.DWORD(provType), C.DWORD(flags)) == 0 {
		return nil, getErr("Error acquiring context")
	}
	return &Ctx{hProv: hprov}, nil
}