import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
private long getDiskSize(Disk disk) {
    long result = -1l;
    Kernel32 kernel32 = Kernel32.INSTANCE;
    HANDLE diskHandle = kernel32.CreateFile(disk.path, WinNT.GENERIC_READ, WinNT.FILE_SHARE_READ, null,
            WinNT.OPEN_EXISTING, WinNT.FILE_ATTRIBUTE_NORMAL, null);
    if (WinBase.INVALID_HANDLE_VALUE.equals(diskHandle)) {
        return result;
    }
    try {
        Memory output = new Memory(Native.getNativeSize(LARGE_INTEGER.class));
        IntByReference lpBytes = new IntByReference();
        boolean success = kernel32.DeviceIoControl(diskHandle,
                WinioctlUtil.CTL_CODE(Winioctl.FILE_DEVICE_DISK, 0x17, Winioctl.METHOD_BUFFERED,
                        Winioctl.FILE_READ_ACCESS),
                null, 0, output, Native.getNativeSize(LARGE_INTEGER.class), lpBytes, null);
        // TODO: Check success?
        result = output.getLong(0);
    }
    finally {
        Kernel32Util.closeHandle(diskHandle);
    }
    return result;
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * @param process NiFi Registry Process Reference
 * @param logger  Logger Reference for Debug
 * @return        Returns pid or null in-case pid could not be determined
 * This method takes {@link Process} and {@link Logger} and returns
 * the platform specific Handle for Win32 Systems, a.k.a <b>pid</b>
 * In-case it fails to determine the pid, it will return Null.
 * Purpose for the Logger is to log any interaction for debugging.
 */
private static Long getWindowsProcessId(final Process process, final Logger logger) {
    /* determine the pid on windows plattforms */
    try {
        Field f = process.getClass().getDeclaredField("handle");
        f.setAccessible(true);
        long handl = f.getLong(process);

        Kernel32 kernel = Kernel32.INSTANCE;
        WinNT.HANDLE handle = new WinNT.HANDLE();
        handle.setPointer(Pointer.createConstant(handl));
        int ret = kernel.GetProcessId(handle);
        logger.debug("Detected pid: {}", ret);
        return Long.valueOf(ret);
    } catch (final IllegalAccessException | NoSuchFieldException nsfe) {
        logger.debug("Could not find PID for child process due to {}", nsfe);
    }
    return null;
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Finds the given process in the process list.
 *
 * @param processEntry The process entry.
 * @param filenamePattern pattern matching the filename of the process.
 * @return The found process entry.
 */
public static boolean findProcessEntry
                (final Tlhelp32.PROCESSENTRY32.ByReference processEntry,
                 final Pattern filenamePattern) {
    Kernel32 kernel32 = Native.loadLibrary(Kernel32.class, W32APIOptions.UNICODE_OPTIONS);

    WinNT.HANDLE snapshot = kernel32.CreateToolhelp32Snapshot(Tlhelp32.TH32CS_SNAPPROCESS, new WinDef.DWORD(0));

    boolean found = false;

    try {
        while (kernel32.Process32Next(snapshot, processEntry)) {
            String fname = Native.toString(processEntry.szExeFile);

            if (fname != null && filenamePattern.matcher(fname).matches()) {
                found = true;
                break;
            }
        }
    } finally {
        kernel32.CloseHandle(snapshot);
    }

    return found;
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the pattern
 * @return The pattern
 * @throws AutomationException Something went wrong getting the pattern
 */
private IUIAutomationInvokePattern getPattern() throws AutomationException {
    if (this.rawPattern != null) {
        return this.rawPattern;
    } else {
        PointerByReference pbr = new PointerByReference();

        WinNT.HRESULT result0 = this.getRawPatternPointer(pbr);

        if (COMUtils.SUCCEEDED(result0)) {
            return this.convertPointerToInterface(pbr);
        } else {
            throw new AutomationException(result0.intValue());
        }
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the pointer
 * @return Underlying pointer
 * @throws AutomationException Automation has gone wrong
 */
private IUIAutomationSelectionPattern getPattern() throws AutomationException {
    if (this.rawPattern != null) {
        return this.rawPattern;
    } else {
        PointerByReference pbr = new PointerByReference();

        WinNT.HRESULT result0 = this.getRawPatternPointer(pbr);

        if (COMUtils.SUCCEEDED(result0)) {
            return this.convertPointerToInterface(pbr);
        } else {
            throw new AutomationException(result0.intValue());
        }
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the pattern interface.
 *
 * @return The toggle pattern interface
 * @throws AutomationException Something went wrong with the automation library.
 */
private IUIAutomationTogglePattern getPattern() throws AutomationException {
    if (this.rawPattern != null) {
        return this.rawPattern;
    } else {
        PointerByReference pbr = new PointerByReference();

        WinNT.HRESULT result0 = this.getRawPatternPointer(pbr);

        if (COMUtils.SUCCEEDED(result0)) {
            return this.convertPointerToInterface(pbr);
        } else {
            throw new AutomationException(result0.intValue());
        }
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the pattern.
 * @return The pattern
 * @throws AutomationException Something went wrong getting the pattern
 */
private IUIAutomationExpandCollapsePattern getPattern()
        throws AutomationException {
    if (this.rawPattern != null) {
        return this.rawPattern;
    } else {
        PointerByReference pbr = new PointerByReference();

        WinNT.HRESULT result0 = this.getRawPatternPointer(pbr);

        if (COMUtils.SUCCEEDED(result0)) {
            return this.convertPointerToInterface(pbr);
        } else {
            throw new AutomationException(result0.intValue());
        }
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the selection container
 * @return The selection container
 * @throws AutomationException Something has gone wrong in automation
 */
public AutomationElement getSelectionContainer() throws AutomationException {
    PointerByReference pbr = new PointerByReference();

    final int res = this.getPattern().getCurrentSelectionContainer(pbr);
    if (res != 0) {
        throw new AutomationException(res);
    }

    Unknown unkConditionA = makeUnknown(pbr.getValue());
    PointerByReference pUnknownA = new PointerByReference();

    WinNT.HRESULT resultA = unkConditionA.QueryInterface(new Guid.REFIID(IUIAutomationElement.IID), pUnknownA);
    if (COMUtils.SUCCEEDED(resultA)) {
        return new AutomationElement(convertPointerToElementInterface(pUnknownA));
    } else {
        throw new AutomationException(resultA.intValue());
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the element associated with the grid cell
 * @param x X position
 * @param y Y position
 * @return The Element from the grid
 * @throws AutomationException Something amiss with automation
 */
public AutomationElement getItem(int x, int y) throws AutomationException {
    PointerByReference cell = this.getRawItem(x, y);

    Unknown uRoot = makeUnknown(cell.getValue());

    PointerByReference pbr = new PointerByReference();

    WinNT.HRESULT result0 = uRoot.QueryInterface(new Guid.REFIID(IUIAutomationElement.IID), pbr);

    if (COMUtils.SUCCEEDED(result0)) {
        return new AutomationElement(convertPointerToElementInterface(pbr));
    } else {
        throw new AutomationException(result0.intValue());
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the handle of a process from the process entry.
 *
 * @param processEntry The processEntry to use
 * @return The handle
 * @throws AutomationException Thrown if the handle cannot be determined
 */
public static WinNT.HANDLE getHandleFromProcessEntry
                (final Tlhelp32.PROCESSENTRY32.ByReference processEntry)
        throws AutomationException {
	ensureWinApiInstances();
	
    WinNT.HANDLE handle = kernel32.OpenProcess (
            0x0400 |    /* PROCESS_QUERY_INFORMATION */
            0x0800 |    /* PROCESS_SUSPEND_RESUME */
            0x0001 |    /* PROCESS_TERMINATE */
            0x00100000  /* SYNCHRONIZE */,
            false,
            processEntry.th32ProcessID.intValue());

    if (handle == null) {
        throw new AutomationException("OpenProcess failed");
    }

    return handle;
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Creates the wrapper.
 */
private void createWrapper() {
    CANALIZED_OLE32_INSTANCE = Canalizer.canalize(com.sun.jna.platform.win32.Ole32.INSTANCE);

    CANALIZED_OLE32_INSTANCE.CoInitializeEx(Pointer.NULL, Ole32.COINIT_APARTMENTTHREADED);

    PointerByReference pbr = new PointerByReference();

    WinNT.HRESULT hr = CANALIZED_OLE32_INSTANCE.CoCreateInstance(
            IUIAutomation.CLSID,
            null,
            WTypes.CLSCTX_SERVER,
            IUIAutomation.IID,
            pbr);

    COMUtils.checkRC(hr);

    unknown = new Unknown(pbr.getValue());
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Gets the raw pattern from the given element.
 * @param item The Element
 * @return The raw collapse pattern
 * @throws AutomationException Failed to get pattern
 */
public IUIAutomationExpandCollapsePattern getExpandCollapsePatternFromItem(AutomationElement item)
                    throws AutomationException {
    PointerByReference pElement = item.getPattern(PatternID.ExpandCollapse.getValue());

    Unknown unkConditionA = makeUnknown(pElement.getValue());

    PointerByReference pUnknownA = new PointerByReference();

    WinNT.HRESULT resultA = unkConditionA.QueryInterface(new Guid.REFIID(IUIAutomationExpandCollapsePattern.IID), pUnknownA);
    if (COMUtils.SUCCEEDED(resultA)) {
        return IUIAutomationExpandCollapsePatternConverter.PointerToInterface(pUnknownA);
    } else {
        throw new AutomationException("QueryInterface failed");
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
@Test
@Ignore("Need to build up the mocking")
public void test_getItem_Throws_Exception_When_Pattern_Returns_Error_From_GetItem() throws Exception {
    Grid pattern = new Grid(rawPattern);

    Grid spyPattern = Mockito.spy(pattern);

    doAnswer(invocation -> new WinNT.HRESULT(0)).when(mockUnknown).QueryInterface(any(Guid.REFIID.class), any(PointerByReference.class));

    IUIAutomationGridPattern mockGrid = Mockito.mock(IUIAutomationGridPattern.class);

    doReturn(mockUnknown)
            .when(spyPattern)
            .makeUnknown(any());

    AutomationElement element = spyPattern.getItem(0,0);
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
@Test
public void testCreateFalseCondtion() {
    UIAutomation instance = UIAutomation.getInstance();

    try {
        PointerByReference condition = instance.createFalseCondition();

        Unknown unk = new Unknown(condition.getValue());

        PointerByReference pUnknown1 = new PointerByReference();

        WinNT.HRESULT result = unk.QueryInterface(new Guid.REFIID(IUIAutomationCondition.IID), pUnknown1);

        assertTrue("Create FalseCondition:" + COMUtils.SUCCEEDED(result), COMUtils.SUCCEEDED(result));
    } catch (AutomationException ex) {
        assertTrue("Ouch", false);
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
@Test
public void testCreatePropertyCondition() {
    UIAutomation instance = UIAutomation.getInstance();

    Variant.VARIANT.ByValue variant = new Variant.VARIANT.ByValue();
    WTypes.BSTR sysAllocated = OleAuto.INSTANCE.SysAllocString("SOMETHING");
    variant.setValue(Variant.VT_BSTR, sysAllocated);

    try {
        try {
            PointerByReference pCondition = instance.createPropertyCondition(PropertyID.AutomationId.getValue(), variant);

            Unknown unk = new Unknown(pCondition.getValue());

            PointerByReference pUnknown1 = new PointerByReference();

            WinNT.HRESULT result = unk.QueryInterface(new Guid.REFIID(IUIAutomationCondition.IID), pUnknown1);

            assertTrue("CreatePropertyCondition:" + COMUtils.SUCCEEDED(result), COMUtils.SUCCEEDED(result));
        } catch (AutomationException ex) {
            assertTrue("Exception", false);
        }
    } finally {
        OleAuto.INSTANCE.SysFreeString(sysAllocated);
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
@Test
public void testCreateTrueCondition() {
    UIAutomation instance = UIAutomation.getInstance();

    try {
        PointerByReference pCondition = instance.createTrueCondition();
        PointerByReference first = new PointerByReference();

        // Check whether it is a condition

        Unknown unk = new Unknown(pCondition.getValue());
        PointerByReference pUnk = new PointerByReference();

        Guid.REFIID refiid3 = new Guid.REFIID(IUIAutomationCondition.IID);

        PointerByReference pUnknown1 = new PointerByReference();

        WinNT.HRESULT result = unk.QueryInterface(refiid3, pUnknown1);

        assertTrue("Create TrueCondition:" + COMUtils.SUCCEEDED(result), COMUtils.SUCCEEDED(result));
    } catch (AutomationException ex) {
        assertTrue("Exception", false);
    }
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
public static long freeSpace(File file)
{
	if (!file.isDirectory() || !file.exists())
		return -2;

	WinNT.LARGE_INTEGER.ByReference lpTotalNumberOfFreeBytes = new WinNT.LARGE_INTEGER.ByReference();
	lpTotalNumberOfFreeBytes.clear();

	boolean ret = Kernel32.INSTANCE.GetDiskFreeSpaceEx(file.getPath(),
			null, null, lpTotalNumberOfFreeBytes);
	if (ret)
		return lpTotalNumberOfFreeBytes.getValue();
	else
	{
		String s = Kernel32Util
				.formatMessageFromLastErrorCode(Kernel32.INSTANCE
						.GetLastError());
		log.severe("error in File.freeSpace getting for \""
				+ file.getPath() + "\" " + s);
	}

	return -1;
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
public static long totalSpace(File file)
{
	if (!file.isDirectory() || !file.exists())
		return -2;

	WinNT.LARGE_INTEGER.ByReference lpTotalNumberOfBytes = new WinNT.LARGE_INTEGER.ByReference();
	lpTotalNumberOfBytes.clear();

	boolean ret = Kernel32.INSTANCE.GetDiskFreeSpaceEx(file.getPath(),
			null, lpTotalNumberOfBytes, null);
	if (ret)
		return lpTotalNumberOfBytes.getValue();
	else
	{
		String s = Kernel32Util
				.formatMessageFromLastErrorCode(Kernel32.INSTANCE
						.GetLastError());
		log.severe("error in File.totalSpace getting for \""
				+ file.getPath() + "\" " + s);
	}

	return -1;

}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Delete a value.
 * 
 * @param rootKey
 *            root key
 * @param subKeyName
 *            key name
 * @param name
 *            value name
 * @return true on success
 */
public static boolean deleteValue(REGISTRY_ROOT_KEY rootKey, String subKeyName, String name)
{
	Advapi32 advapi32;
	HKEY handle;
	boolean ret = true;

	advapi32 = Advapi32.INSTANCE;

	handle = openKey(rootKey, subKeyName, WinNT.KEY_READ | WinNT.KEY_WRITE);

	if (handle != null)
	{
		if (advapi32.RegDeleteValue(handle, name) == WINERROR.ERROR_SUCCESS)
		{
			ret = true;
		}
		advapi32.RegCloseKey(handle);
	}
	return (ret);
}
 

import com.sun.jna.platform.win32.WinNT; //导入依赖的package包/类
/**
 * Writes a String value.
 * 
 * @param rootKey
 *            root key
 * @param subKeyName
 *            key name
 * @param name
 *            value name
 * @param value
 *            value
 * @throws java.io.UnsupportedEncodingException
 *             on error
 * @return true on success
 */
public static boolean setStringValue(REGISTRY_ROOT_KEY rootKey, String subKeyName, String name, String value) throws UnsupportedEncodingException
{
	Advapi32 advapi32;
	HKEY handle;
	byte[] data;
	boolean ret = false;

	data = Arrays.copyOf(value.getBytes("UTF-16LE"), value.length() * 2 + 2);
	advapi32 = Advapi32.INSTANCE;
	handle = openKey(rootKey, subKeyName, WinNT.KEY_READ | WinNT.KEY_WRITE);

	if (handle != null)
	{
		if (advapi32.RegSetValueEx(handle, name, 0, WinNT.REG_SZ, data, data.length) == WINERROR.ERROR_SUCCESS)
		{
			ret = true;
		}
		advapi32.RegCloseKey(handle);
	}
	return (ret);
}