mirror of
https://github.com/davidhalter/typeshed.git
synced 2025-12-08 21:14:48 +08:00
Split stdlib into Python 2 and 3 versions (#5442)
All new files in stdlib/@python2 are straight copies of the corresponding files in stdlib.
This commit is contained in:
Sebastian Rittau
319
stdlib/@python2/ctypes/__init__.pyi
Normal file
319
stdlib/@python2/ctypes/__init__.pyi
Normal file
@@ -0,0 +1,319 @@
|
||||
import sys
|
||||
from array import array
|
||||
from typing import (
|
||||
Any,
|
||||
Callable,
|
||||
ClassVar,
|
||||
Generic,
|
||||
Iterable,
|
||||
Iterator,
|
||||
List,
|
||||
Mapping,
|
||||
Optional,
|
||||
Sequence,
|
||||
Text,
|
||||
Tuple,
|
||||
Type,
|
||||
TypeVar,
|
||||
Union as _UnionT,
|
||||
overload,
|
||||
)
|
||||
|
||||
if sys.version_info >= (3, 9):
|
||||
from types import GenericAlias
|
||||
|
||||
_T = TypeVar("_T")
|
||||
_DLLT = TypeVar("_DLLT", bound=CDLL)
|
||||
_CT = TypeVar("_CT", bound=_CData)
|
||||
|
||||
RTLD_GLOBAL: int = ...
|
||||
RTLD_LOCAL: int = ...
|
||||
DEFAULT_MODE: int = ...
|
||||
|
||||
class CDLL(object):
|
||||
_func_flags_: ClassVar[int] = ...
|
||||
_func_restype_: ClassVar[_CData] = ...
|
||||
_name: str = ...
|
||||
_handle: int = ...
|
||||
_FuncPtr: Type[_FuncPointer] = ...
|
||||
if sys.version_info >= (3, 8):
|
||||
def __init__(
|
||||
self,
|
||||
name: Optional[str],
|
||||
mode: int = ...,
|
||||
handle: Optional[int] = ...,
|
||||
use_errno: bool = ...,
|
||||
use_last_error: bool = ...,
|
||||
winmode: Optional[int] = ...,
|
||||
) -> None: ...
|
||||
else:
|
||||
def __init__(
|
||||
self,
|
||||
name: Optional[str],
|
||||
mode: int = ...,
|
||||
handle: Optional[int] = ...,
|
||||
use_errno: bool = ...,
|
||||
use_last_error: bool = ...,
|
||||
) -> None: ...
|
||||
def __getattr__(self, name: str) -> _NamedFuncPointer: ...
|
||||
def __getitem__(self, name: str) -> _NamedFuncPointer: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
class OleDLL(CDLL): ...
|
||||
class WinDLL(CDLL): ...
|
||||
|
||||
class PyDLL(CDLL): ...
|
||||
|
||||
class LibraryLoader(Generic[_DLLT]):
|
||||
def __init__(self, dlltype: Type[_DLLT]) -> None: ...
|
||||
def __getattr__(self, name: str) -> _DLLT: ...
|
||||
def __getitem__(self, name: str) -> _DLLT: ...
|
||||
def LoadLibrary(self, name: str) -> _DLLT: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
|
||||
|
||||
cdll: LibraryLoader[CDLL] = ...
|
||||
if sys.platform == "win32":
|
||||
windll: LibraryLoader[WinDLL] = ...
|
||||
oledll: LibraryLoader[OleDLL] = ...
|
||||
pydll: LibraryLoader[PyDLL] = ...
|
||||
pythonapi: PyDLL = ...
|
||||
|
||||
# Anything that implements the read-write buffer interface.
|
||||
# The buffer interface is defined purely on the C level, so we cannot define a normal Protocol
|
||||
# for it. Instead we have to list the most common stdlib buffer classes in a Union.
|
||||
_WritableBuffer = _UnionT[bytearray, memoryview, array[Any], _CData]
|
||||
# Same as _WritableBuffer, but also includes read-only buffer types (like bytes).
|
||||
_ReadOnlyBuffer = _UnionT[_WritableBuffer, bytes]
|
||||
|
||||
class _CDataMeta(type):
|
||||
# By default mypy complains about the following two methods, because strictly speaking cls
|
||||
# might not be a Type[_CT]. However this can never actually happen, because the only class that
|
||||
# uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here.
|
||||
def __mul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ... # type: ignore
|
||||
def __rmul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ... # type: ignore
|
||||
|
||||
class _CData(metaclass=_CDataMeta):
|
||||
_b_base: int = ...
|
||||
_b_needsfree_: bool = ...
|
||||
_objects: Optional[Mapping[Any, int]] = ...
|
||||
@classmethod
|
||||
def from_buffer(cls: Type[_CT], source: _WritableBuffer, offset: int = ...) -> _CT: ...
|
||||
@classmethod
|
||||
def from_buffer_copy(cls: Type[_CT], source: _ReadOnlyBuffer, offset: int = ...) -> _CT: ...
|
||||
@classmethod
|
||||
def from_address(cls: Type[_CT], address: int) -> _CT: ...
|
||||
@classmethod
|
||||
def from_param(cls: Type[_CT], obj: Any) -> _UnionT[_CT, _CArgObject]: ...
|
||||
@classmethod
|
||||
def in_dll(cls: Type[_CT], library: CDLL, name: str) -> _CT: ...
|
||||
|
||||
class _CanCastTo(_CData): ...
|
||||
class _PointerLike(_CanCastTo): ...
|
||||
|
||||
_ECT = Callable[[Optional[Type[_CData]], _FuncPointer, Tuple[_CData, ...]], _CData]
|
||||
_PF = _UnionT[Tuple[int], Tuple[int, str], Tuple[int, str, Any]]
|
||||
|
||||
class _FuncPointer(_PointerLike, _CData):
|
||||
restype: _UnionT[Type[_CData], Callable[[int], Any], None] = ...
|
||||
argtypes: Sequence[Type[_CData]] = ...
|
||||
errcheck: _ECT = ...
|
||||
@overload
|
||||
def __init__(self, address: int) -> None: ...
|
||||
@overload
|
||||
def __init__(self, callable: Callable[..., Any]) -> None: ...
|
||||
@overload
|
||||
def __init__(self, func_spec: Tuple[_UnionT[str, int], CDLL], paramflags: Tuple[_PF, ...] = ...) -> None: ...
|
||||
@overload
|
||||
def __init__(self, vtlb_index: int, name: str, paramflags: Tuple[_PF, ...] = ..., iid: pointer[c_int] = ...) -> None: ...
|
||||
def __call__(self, *args: Any, **kwargs: Any) -> Any: ...
|
||||
|
||||
class _NamedFuncPointer(_FuncPointer):
|
||||
__name__: str
|
||||
|
||||
class ArgumentError(Exception): ...
|
||||
|
||||
def CFUNCTYPE(
|
||||
restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ...
|
||||
) -> Type[_FuncPointer]: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
def WINFUNCTYPE(
|
||||
restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ...
|
||||
) -> Type[_FuncPointer]: ...
|
||||
|
||||
def PYFUNCTYPE(restype: Optional[Type[_CData]], *argtypes: Type[_CData]) -> Type[_FuncPointer]: ...
|
||||
|
||||
class _CArgObject: ...
|
||||
|
||||
# Any type that can be implicitly converted to c_void_p when passed as a C function argument.
|
||||
# (bytes is not included here, see below.)
|
||||
_CVoidPLike = _UnionT[_PointerLike, Array[Any], _CArgObject, int]
|
||||
# Same as above, but including types known to be read-only (i. e. bytes).
|
||||
# This distinction is not strictly necessary (ctypes doesn't differentiate between const
|
||||
# and non-const pointers), but it catches errors like memmove(b'foo', buf, 4)
|
||||
# when memmove(buf, b'foo', 4) was intended.
|
||||
_CVoidConstPLike = _UnionT[_CVoidPLike, bytes]
|
||||
|
||||
def addressof(obj: _CData) -> int: ...
|
||||
def alignment(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
|
||||
def byref(obj: _CData, offset: int = ...) -> _CArgObject: ...
|
||||
|
||||
_CastT = TypeVar("_CastT", bound=_CanCastTo)
|
||||
|
||||
def cast(obj: _UnionT[_CData, _CArgObject, int], typ: Type[_CastT]) -> _CastT: ...
|
||||
def create_string_buffer(init: _UnionT[int, bytes], size: Optional[int] = ...) -> Array[c_char]: ...
|
||||
|
||||
c_buffer = create_string_buffer
|
||||
|
||||
def create_unicode_buffer(init: _UnionT[int, Text], size: Optional[int] = ...) -> Array[c_wchar]: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
def DllCanUnloadNow() -> int: ...
|
||||
def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ... # TODO not documented
|
||||
def FormatError(code: int) -> str: ...
|
||||
def GetLastError() -> int: ...
|
||||
|
||||
def get_errno() -> int: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
def get_last_error() -> int: ...
|
||||
|
||||
def memmove(dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> None: ...
|
||||
def memset(dst: _CVoidPLike, c: int, count: int) -> None: ...
|
||||
def POINTER(type: Type[_CT]) -> Type[pointer[_CT]]: ...
|
||||
|
||||
# The real ctypes.pointer is a function, not a class. The stub version of pointer behaves like
|
||||
# ctypes._Pointer in that it is the base class for all pointer types. Unlike the real _Pointer,
|
||||
# it can be instantiated directly (to mimic the behavior of the real pointer function).
|
||||
class pointer(Generic[_CT], _PointerLike, _CData):
|
||||
_type_: ClassVar[Type[_CT]] = ...
|
||||
contents: _CT = ...
|
||||
def __init__(self, arg: _CT = ...) -> None: ...
|
||||
@overload
|
||||
def __getitem__(self, i: int) -> _CT: ...
|
||||
@overload
|
||||
def __getitem__(self, s: slice) -> List[_CT]: ...
|
||||
@overload
|
||||
def __setitem__(self, i: int, o: _CT) -> None: ...
|
||||
@overload
|
||||
def __setitem__(self, s: slice, o: Iterable[_CT]) -> None: ...
|
||||
|
||||
def resize(obj: _CData, size: int) -> None: ...
|
||||
|
||||
if sys.version_info < (3,):
|
||||
def set_conversion_mode(encoding: str, errors: str) -> Tuple[str, str]: ...
|
||||
|
||||
def set_errno(value: int) -> int: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
def set_last_error(value: int) -> int: ...
|
||||
|
||||
def sizeof(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ...
|
||||
def string_at(address: _CVoidConstPLike, size: int = ...) -> bytes: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
def WinError(code: Optional[int] = ..., descr: Optional[str] = ...) -> OSError: ...
|
||||
|
||||
def wstring_at(address: _CVoidConstPLike, size: int = ...) -> str: ...
|
||||
|
||||
class _SimpleCData(Generic[_T], _CData):
|
||||
value: _T = ...
|
||||
def __init__(self, value: _T = ...) -> None: ...
|
||||
|
||||
class c_byte(_SimpleCData[int]): ...
|
||||
|
||||
class c_char(_SimpleCData[bytes]):
|
||||
def __init__(self, value: _UnionT[int, bytes] = ...) -> None: ...
|
||||
|
||||
class c_char_p(_PointerLike, _SimpleCData[Optional[bytes]]):
|
||||
def __init__(self, value: Optional[_UnionT[int, bytes]] = ...) -> None: ...
|
||||
|
||||
class c_double(_SimpleCData[float]): ...
|
||||
class c_longdouble(_SimpleCData[float]): ...
|
||||
class c_float(_SimpleCData[float]): ...
|
||||
class c_int(_SimpleCData[int]): ...
|
||||
class c_int8(_SimpleCData[int]): ...
|
||||
class c_int16(_SimpleCData[int]): ...
|
||||
class c_int32(_SimpleCData[int]): ...
|
||||
class c_int64(_SimpleCData[int]): ...
|
||||
class c_long(_SimpleCData[int]): ...
|
||||
class c_longlong(_SimpleCData[int]): ...
|
||||
class c_short(_SimpleCData[int]): ...
|
||||
class c_size_t(_SimpleCData[int]): ...
|
||||
class c_ssize_t(_SimpleCData[int]): ...
|
||||
class c_ubyte(_SimpleCData[int]): ...
|
||||
class c_uint(_SimpleCData[int]): ...
|
||||
class c_uint8(_SimpleCData[int]): ...
|
||||
class c_uint16(_SimpleCData[int]): ...
|
||||
class c_uint32(_SimpleCData[int]): ...
|
||||
class c_uint64(_SimpleCData[int]): ...
|
||||
class c_ulong(_SimpleCData[int]): ...
|
||||
class c_ulonglong(_SimpleCData[int]): ...
|
||||
class c_ushort(_SimpleCData[int]): ...
|
||||
class c_void_p(_PointerLike, _SimpleCData[Optional[int]]): ...
|
||||
class c_wchar(_SimpleCData[Text]): ...
|
||||
|
||||
class c_wchar_p(_PointerLike, _SimpleCData[Optional[Text]]):
|
||||
def __init__(self, value: Optional[_UnionT[int, Text]] = ...) -> None: ...
|
||||
|
||||
class c_bool(_SimpleCData[bool]):
|
||||
def __init__(self, value: bool = ...) -> None: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
class HRESULT(_SimpleCData[int]): ... # TODO undocumented
|
||||
|
||||
class py_object(_CanCastTo, _SimpleCData[_T]): ...
|
||||
|
||||
class _CField:
|
||||
offset: int = ...
|
||||
size: int = ...
|
||||
|
||||
class _StructUnionMeta(_CDataMeta):
|
||||
_fields_: Sequence[_UnionT[Tuple[str, Type[_CData]], Tuple[str, Type[_CData], int]]] = ...
|
||||
_pack_: int = ...
|
||||
_anonymous_: Sequence[str] = ...
|
||||
def __getattr__(self, name: str) -> _CField: ...
|
||||
|
||||
class _StructUnionBase(_CData, metaclass=_StructUnionMeta):
|
||||
def __init__(self, *args: Any, **kw: Any) -> None: ...
|
||||
def __getattr__(self, name: str) -> Any: ...
|
||||
def __setattr__(self, name: str, value: Any) -> None: ...
|
||||
|
||||
class Union(_StructUnionBase): ...
|
||||
class Structure(_StructUnionBase): ...
|
||||
class BigEndianStructure(Structure): ...
|
||||
class LittleEndianStructure(Structure): ...
|
||||
|
||||
class Array(Generic[_CT], _CData):
|
||||
_length_: ClassVar[int] = ...
|
||||
_type_: ClassVar[Type[_CT]] = ...
|
||||
raw: bytes = ... # Note: only available if _CT == c_char
|
||||
value: Any = ... # Note: bytes if _CT == c_char, Text if _CT == c_wchar, unavailable otherwise
|
||||
# TODO These methods cannot be annotated correctly at the moment.
|
||||
# All of these "Any"s stand for the array's element type, but it's not possible to use _CT
|
||||
# here, because of a special feature of ctypes.
|
||||
# By default, when accessing an element of an Array[_CT], the returned object has type _CT.
|
||||
# However, when _CT is a "simple type" like c_int, ctypes automatically "unboxes" the object
|
||||
# and converts it to the corresponding Python primitive. For example, when accessing an element
|
||||
# of an Array[c_int], a Python int object is returned, not a c_int.
|
||||
# This behavior does *not* apply to subclasses of "simple types".
|
||||
# If MyInt is a subclass of c_int, then accessing an element of an Array[MyInt] returns
|
||||
# a MyInt, not an int.
|
||||
# This special behavior is not easy to model in a stub, so for now all places where
|
||||
# the array element type would belong are annotated with Any instead.
|
||||
def __init__(self, *args: Any) -> None: ...
|
||||
@overload
|
||||
def __getitem__(self, i: int) -> Any: ...
|
||||
@overload
|
||||
def __getitem__(self, s: slice) -> List[Any]: ...
|
||||
@overload
|
||||
def __setitem__(self, i: int, o: Any) -> None: ...
|
||||
@overload
|
||||
def __setitem__(self, s: slice, o: Iterable[Any]) -> None: ...
|
||||
def __iter__(self) -> Iterator[Any]: ...
|
||||
# Can't inherit from Sized because the metaclass conflict between
|
||||
# Sized and _CData prevents using _CDataMeta.
|
||||
def __len__(self) -> int: ...
|
||||
if sys.version_info >= (3, 9):
|
||||
def __class_getitem__(cls, item: Any) -> GenericAlias: ...
|
||||
7
stdlib/@python2/ctypes/util.pyi
Normal file
7
stdlib/@python2/ctypes/util.pyi
Normal file
@@ -0,0 +1,7 @@
|
||||
import sys
|
||||
from typing import Optional
|
||||
|
||||
def find_library(name: str) -> Optional[str]: ...
|
||||
|
||||
if sys.platform == "win32":
|
||||
def find_msvcrt() -> Optional[str]: ...
|
||||
234
stdlib/@python2/ctypes/wintypes.pyi
Normal file
234
stdlib/@python2/ctypes/wintypes.pyi
Normal file
@@ -0,0 +1,234 @@
|
||||
from ctypes import (
|
||||
Array,
|
||||
Structure,
|
||||
_SimpleCData,
|
||||
c_byte,
|
||||
c_char,
|
||||
c_char_p,
|
||||
c_double,
|
||||
c_float,
|
||||
c_int,
|
||||
c_long,
|
||||
c_longlong,
|
||||
c_short,
|
||||
c_uint,
|
||||
c_ulong,
|
||||
c_ulonglong,
|
||||
c_ushort,
|
||||
c_void_p,
|
||||
c_wchar,
|
||||
c_wchar_p,
|
||||
pointer,
|
||||
)
|
||||
|
||||
BYTE = c_byte
|
||||
WORD = c_ushort
|
||||
DWORD = c_ulong
|
||||
CHAR = c_char
|
||||
WCHAR = c_wchar
|
||||
UINT = c_uint
|
||||
INT = c_int
|
||||
DOUBLE = c_double
|
||||
FLOAT = c_float
|
||||
BOOLEAN = BYTE
|
||||
BOOL = c_long
|
||||
|
||||
class VARIANT_BOOL(_SimpleCData[bool]): ...
|
||||
|
||||
ULONG = c_ulong
|
||||
LONG = c_long
|
||||
USHORT = c_ushort
|
||||
SHORT = c_short
|
||||
LARGE_INTEGER = c_longlong
|
||||
_LARGE_INTEGER = c_longlong
|
||||
ULARGE_INTEGER = c_ulonglong
|
||||
_ULARGE_INTEGER = c_ulonglong
|
||||
|
||||
OLESTR = c_wchar_p
|
||||
LPOLESTR = c_wchar_p
|
||||
LPCOLESTR = c_wchar_p
|
||||
LPWSTR = c_wchar_p
|
||||
LPCWSTR = c_wchar_p
|
||||
LPSTR = c_char_p
|
||||
LPCSTR = c_char_p
|
||||
LPVOID = c_void_p
|
||||
LPCVOID = c_void_p
|
||||
|
||||
# These two types are pointer-sized unsigned and signed ints, respectively.
|
||||
# At runtime, they are either c_[u]long or c_[u]longlong, depending on the host's pointer size
|
||||
# (they are not really separate classes).
|
||||
class WPARAM(_SimpleCData[int]): ...
|
||||
class LPARAM(_SimpleCData[int]): ...
|
||||
|
||||
ATOM = WORD
|
||||
LANGID = WORD
|
||||
COLORREF = DWORD
|
||||
LGRPID = DWORD
|
||||
LCTYPE = DWORD
|
||||
LCID = DWORD
|
||||
|
||||
HANDLE = c_void_p
|
||||
HACCEL = HANDLE
|
||||
HBITMAP = HANDLE
|
||||
HBRUSH = HANDLE
|
||||
HCOLORSPACE = HANDLE
|
||||
HDC = HANDLE
|
||||
HDESK = HANDLE
|
||||
HDWP = HANDLE
|
||||
HENHMETAFILE = HANDLE
|
||||
HFONT = HANDLE
|
||||
HGDIOBJ = HANDLE
|
||||
HGLOBAL = HANDLE
|
||||
HHOOK = HANDLE
|
||||
HICON = HANDLE
|
||||
HINSTANCE = HANDLE
|
||||
HKEY = HANDLE
|
||||
HKL = HANDLE
|
||||
HLOCAL = HANDLE
|
||||
HMENU = HANDLE
|
||||
HMETAFILE = HANDLE
|
||||
HMODULE = HANDLE
|
||||
HMONITOR = HANDLE
|
||||
HPALETTE = HANDLE
|
||||
HPEN = HANDLE
|
||||
HRGN = HANDLE
|
||||
HRSRC = HANDLE
|
||||
HSTR = HANDLE
|
||||
HTASK = HANDLE
|
||||
HWINSTA = HANDLE
|
||||
HWND = HANDLE
|
||||
SC_HANDLE = HANDLE
|
||||
SERVICE_STATUS_HANDLE = HANDLE
|
||||
|
||||
class RECT(Structure):
|
||||
left: LONG
|
||||
top: LONG
|
||||
right: LONG
|
||||
bottom: LONG
|
||||
|
||||
RECTL = RECT
|
||||
_RECTL = RECT
|
||||
tagRECT = RECT
|
||||
|
||||
class _SMALL_RECT(Structure):
|
||||
Left: SHORT
|
||||
Top: SHORT
|
||||
Right: SHORT
|
||||
Bottom: SHORT
|
||||
|
||||
SMALL_RECT = _SMALL_RECT
|
||||
|
||||
class _COORD(Structure):
|
||||
X: SHORT
|
||||
Y: SHORT
|
||||
|
||||
class POINT(Structure):
|
||||
x: LONG
|
||||
y: LONG
|
||||
|
||||
POINTL = POINT
|
||||
_POINTL = POINT
|
||||
tagPOINT = POINT
|
||||
|
||||
class SIZE(Structure):
|
||||
cx: LONG
|
||||
cy: LONG
|
||||
|
||||
SIZEL = SIZE
|
||||
tagSIZE = SIZE
|
||||
|
||||
def RGB(red: int, green: int, blue: int) -> int: ...
|
||||
|
||||
class FILETIME(Structure):
|
||||
dwLowDateTime: DWORD
|
||||
dwHighDateTime: DWORD
|
||||
|
||||
_FILETIME = FILETIME
|
||||
|
||||
class MSG(Structure):
|
||||
hWnd: HWND
|
||||
message: UINT
|
||||
wParam: WPARAM
|
||||
lParam: LPARAM
|
||||
time: DWORD
|
||||
pt: POINT
|
||||
|
||||
tagMSG = MSG
|
||||
MAX_PATH: int
|
||||
|
||||
class WIN32_FIND_DATAA(Structure):
|
||||
dwFileAttributes: DWORD
|
||||
ftCreationTime: FILETIME
|
||||
ftLastAccessTime: FILETIME
|
||||
ftLastWriteTime: FILETIME
|
||||
nFileSizeHigh: DWORD
|
||||
nFileSizeLow: DWORD
|
||||
dwReserved0: DWORD
|
||||
dwReserved1: DWORD
|
||||
cFileName: Array[CHAR]
|
||||
cAlternateFileName: Array[CHAR]
|
||||
|
||||
class WIN32_FIND_DATAW(Structure):
|
||||
dwFileAttributes: DWORD
|
||||
ftCreationTime: FILETIME
|
||||
ftLastAccessTime: FILETIME
|
||||
ftLastWriteTime: FILETIME
|
||||
nFileSizeHigh: DWORD
|
||||
nFileSizeLow: DWORD
|
||||
dwReserved0: DWORD
|
||||
dwReserved1: DWORD
|
||||
cFileName: Array[WCHAR]
|
||||
cAlternateFileName: Array[WCHAR]
|
||||
|
||||
# These pointer type definitions use pointer[...] instead of POINTER(...), to allow them
|
||||
# to be used in type annotations.
|
||||
PBOOL = pointer[BOOL]
|
||||
LPBOOL = pointer[BOOL]
|
||||
PBOOLEAN = pointer[BOOLEAN]
|
||||
PBYTE = pointer[BYTE]
|
||||
LPBYTE = pointer[BYTE]
|
||||
PCHAR = pointer[CHAR]
|
||||
LPCOLORREF = pointer[COLORREF]
|
||||
PDWORD = pointer[DWORD]
|
||||
LPDWORD = pointer[DWORD]
|
||||
PFILETIME = pointer[FILETIME]
|
||||
LPFILETIME = pointer[FILETIME]
|
||||
PFLOAT = pointer[FLOAT]
|
||||
PHANDLE = pointer[HANDLE]
|
||||
LPHANDLE = pointer[HANDLE]
|
||||
PHKEY = pointer[HKEY]
|
||||
LPHKL = pointer[HKL]
|
||||
PINT = pointer[INT]
|
||||
LPINT = pointer[INT]
|
||||
PLARGE_INTEGER = pointer[LARGE_INTEGER]
|
||||
PLCID = pointer[LCID]
|
||||
PLONG = pointer[LONG]
|
||||
LPLONG = pointer[LONG]
|
||||
PMSG = pointer[MSG]
|
||||
LPMSG = pointer[MSG]
|
||||
PPOINT = pointer[POINT]
|
||||
LPPOINT = pointer[POINT]
|
||||
PPOINTL = pointer[POINTL]
|
||||
PRECT = pointer[RECT]
|
||||
LPRECT = pointer[RECT]
|
||||
PRECTL = pointer[RECTL]
|
||||
LPRECTL = pointer[RECTL]
|
||||
LPSC_HANDLE = pointer[SC_HANDLE]
|
||||
PSHORT = pointer[SHORT]
|
||||
PSIZE = pointer[SIZE]
|
||||
LPSIZE = pointer[SIZE]
|
||||
PSIZEL = pointer[SIZEL]
|
||||
LPSIZEL = pointer[SIZEL]
|
||||
PSMALL_RECT = pointer[SMALL_RECT]
|
||||
PUINT = pointer[UINT]
|
||||
LPUINT = pointer[UINT]
|
||||
PULARGE_INTEGER = pointer[ULARGE_INTEGER]
|
||||
PULONG = pointer[ULONG]
|
||||
PUSHORT = pointer[USHORT]
|
||||
PWCHAR = pointer[WCHAR]
|
||||
PWIN32_FIND_DATAA = pointer[WIN32_FIND_DATAA]
|
||||
LPWIN32_FIND_DATAA = pointer[WIN32_FIND_DATAA]
|
||||
PWIN32_FIND_DATAW = pointer[WIN32_FIND_DATAW]
|
||||
LPWIN32_FIND_DATAW = pointer[WIN32_FIND_DATAW]
|
||||
PWORD = pointer[WORD]
|
||||
LPWORD = pointer[WORD]
|
||||
Reference in New Issue
Block a user