Python ctypes.wintypes.LONG Examples

def AddRef(self):
        prototype = ctypes.WINFUNCTYPE(wintypes.LONG)
        paramflags = ()
        _AddRef = prototype(IUnknown_AddRef_Idx,
                            'AddRef',
                            paramflags)
        return _AddRef(self.this) 

def Release(self):
        prototype = ctypes.WINFUNCTYPE(wintypes.LONG)
        paramflags = ()
        _Release = prototype(IUnknown_Release_Idx,
                             'Release',
                             paramflags)
        return _Release(self.this) 

def __init__(self):

		# https://github.com/wine-mirror/wine/blob/master/include/winternl.h
		self.FILE_OPEN_IF = 3

		# BOOLEAN WINAPI RtlDosPathNameToNtPathName_U(
		#	PCWSTR dos_path,
		#	PUNICODE_STRING ntpath,
		#	PWSTR* file_part,
		#	CURDIR* cd
		#	)
		self.__dos_to_nt__ = ctypes.windll.ntdll.RtlDosPathNameToNtPathName_U
		self.__dos_to_nt__.argtypes = (
			ctypes.c_void_p,
			ctypes.c_void_p,
			ctypes.c_void_p,
			ctypes.c_void_p
			)
		self.__dos_to_nt__.restype = wintypes.BOOLEAN

		# NTSTATUS CDECL wine_unix_to_nt_file_name(
		#	const ANSI_STRING *name, UNICODE_STRING *nt
		#	)
		self.__unix_to_wine__ = ctypes.cdll.ntdll.wine_unix_to_nt_file_name
		self.__unix_to_wine__.argtypes = (
			ctypes.POINTER(ANSI_STRING), ctypes.POINTER(UNICODE_STRING)
			)
		self.__unix_to_wine__.restype = wintypes.LONG # NTSTATUS https://msdn.microsoft.com/en-us/library/cc704588.aspx

		# @ cdecl wine_nt_to_unix_file_name(ptr ptr long long)
		# NTSYSAPI NTSTATUS CDECL wine_nt_to_unix_file_name(
		#	const UNICODE_STRING *nameW, ANSI_STRING *unix_name_ret,
		#	UINT disposition, BOOLEAN check_case
		# 	);
		self.__wine_to_unix__ = ctypes.cdll.ntdll.wine_nt_to_unix_file_name
		self.__wine_to_unix__.argtypes = (
			ctypes.POINTER(UNICODE_STRING), ctypes.POINTER(ANSI_STRING),
			wintypes.UINT, wintypes.BOOLEAN
			)
		self.__wine_to_unix__.restype = wintypes.LONG # NTSTATUS https://msdn.microsoft.com/en-us/library/cc704588.aspx 

def CoInitializeSecurity(sec_desc,
                         c_auth_svc,
                         as_auth_svc,
                         reserved1,
                         auth_level,
                         imp_level,
                         auth_list,
                         capibilities,
                         reserved3):
    prototype = ctypes.WINFUNCTYPE(
        HRESULT,
        ctypes.POINTER(SECURITY_DESCRIPTOR),
        wintypes.LONG,
        ctypes.POINTER(SOLE_AUTHENTICATION_SERVICE),
        wintypes.LPVOID,
        wintypes.DWORD,
        wintypes.DWORD,
        wintypes.LPVOID,
        wintypes.DWORD,
        wintypes.LPVOID
    )

    paramflags = (
        (_In_, 'pSecDesc'),
        (_In_, 'cAuthSvc'),
        (_In_, 'asAuthSvc'),
        (_In_, 'pReserved1'),
        (_In_, 'dwAuthnLevel'),
        (_In_, 'dwImpLevel'),
        (_In_, 'pAuthList'),
        (_In_, 'dwCapabilities'),
        (_In_, 'pReserved3')
    )

    _CoInitializeSecurity = prototype(('CoInitializeSecurity', ole32), paramflags)
    _CoInitializeSecurity.errcheck = RAISE_NON_ZERO_ERR

    return _CoInitializeSecurity(sec_desc,
                                 c_auth_svc,
                                 as_auth_svc,
                                 reserved1,
                                 auth_level,
                                 imp_level,
                                 auth_list,
                                 capibilities,
                                 reserved3) 

def _do_recognition(self):
        """
            Recognize speech in a loop.

            This will also call any scheduled timer functions and ensure that
            the correct window context is used.

        """

        # Register for window change events to activate/deactivate grammars
        # and rules on window changes. This is done here because the SAPI5
        # 'OnPhraseStart' grammar callback is called after grammar state
        # changes are allowed.
        WinEventProcType = WINFUNCTYPE(None, HANDLE, DWORD, HWND, LONG,
                                       LONG, DWORD, DWORD)

        self._last_foreground_window = None

        def callback(hWinEventHook, event, hwnd, idObject, idChild,
                     dwEventThread, dwmsEventTime):
            window = Window.get_foreground()
            # Note: hwnd doesn't always match window.handle, even when
            # foreground window changed (and sometimes it didn't change)
            if window != self._last_foreground_window:
                self.process_grammars_context(window)
                self._last_foreground_window = window

        def set_hook(win_event_proc, event_type):
            return windll.user32.SetWinEventHook(
                event_type, event_type, 0, win_event_proc, 0, 0,
                win32con.WINEVENT_OUTOFCONTEXT)

        win_event_proc = WinEventProcType(callback)
        windll.user32.SetWinEventHook.restype = HANDLE

        [set_hook(win_event_proc, et) for et in
         {win32con.EVENT_SYSTEM_FOREGROUND,
          win32con.EVENT_OBJECT_NAMECHANGE, }]

        # Recognize speech, call timer functions and handle window change
        # events in a loop. Stop on disconnect().
        self.speak('beginning loop!')
        while self._recognizer is not None:
            pythoncom.PumpWaitingMessages()
            self.call_timer_callback()
            time.sleep(0.005)

#---------------------------------------------------------------------------
# Make the shared engine available as Sapi5Engine, for backwards
#  compatibility.