zmc
2023-08-08 e792e9a60d958b93aef96050644f369feb25d61b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
#
# (C) Copyright 2014 Enthought, Inc., Austin, TX
# All right reserved.
#
# This file is open source software distributed according to the terms in
# LICENSE.txt
#
""" A module, encapsulating the Windows Win32 API. """
 
from __future__ import absolute_import
 
from win32ctypes.core import (
    _common, _dll, _resource, _system_information, _backend, _time)
from win32ctypes.pywin32.pywintypes import pywin32error as _pywin32error
 
LOAD_LIBRARY_AS_DATAFILE = 0x2
LANG_NEUTRAL = 0x00
 
 
def LoadLibraryEx(fileName, handle, flags):
    """ Loads the specified DLL, and returns the handle.
 
    Parameters
    ----------
    fileName : unicode
        The filename of the module to load.
 
    handle : int
        Reserved, always zero.
 
    flags : int
        The action to be taken when loading the module.
 
    Returns
    -------
    handle : hModule
        The handle of the loaded module
 
    """
    if not handle == 0:
        raise ValueError("handle != 0 not supported")
    with _pywin32error():
        return _dll._LoadLibraryEx(fileName, 0, flags)
 
 
def EnumResourceTypes(hModule):
    """ Enumerates resource types within a module.
 
    Parameters
    ----------
    hModule : handle
        The handle to the module.
 
    Returns
    -------
    resource_types : list
       The list of resource types in the module.
 
    """
    resource_types = []
 
    def callback(hModule, type_, param):
        resource_types.append(type_)
        return True
 
    with _pywin32error():
        _resource._EnumResourceTypes(
            hModule, _resource.ENUMRESTYPEPROC(callback), 0)
    return resource_types
 
 
def EnumResourceNames(hModule, resType):
    """ Enumerates all the resources of the specified type within a module.
 
    Parameters
    ----------
    hModule : handle
        The handle to the module.
    resType : str : int
        The type or id of resource to enumerate.
 
    Returns
    -------
    resource_names : list
       The list of resource names (unicode strings) of the specific
       resource type in the module.
 
    """
    resource_names = []
 
    def callback(hModule, type_, type_name, param):
        resource_names.append(type_name)
        return True
 
    with _pywin32error():
        _resource._EnumResourceNames(
            hModule, resType, _resource.ENUMRESNAMEPROC(callback), 0)
    return resource_names
 
 
def EnumResourceLanguages(hModule, lpType, lpName):
    """ List languages of a resource module.
 
    Parameters
    ----------
    hModule : handle
        Handle to the resource module.
 
    lpType : str : int
        The type or id of resource to enumerate.
 
    lpName : str : int
        The type or id of resource to enumerate.
 
    Returns
    -------
    resource_languages : list
        List of the resource language ids.
 
    """
    resource_languages = []
 
    def callback(hModule, type_name, res_name, language_id, param):
        resource_languages.append(language_id)
        return True
 
    with _pywin32error():
        _resource._EnumResourceLanguages(
            hModule, lpType, lpName, _resource.ENUMRESLANGPROC(callback), 0)
    return resource_languages
 
 
def LoadResource(hModule, type, name, language=LANG_NEUTRAL):
    """ Find and Load a resource component.
 
    Parameters
    ----------
    handle : hModule
        The handle of the module containing the resource.
        Use None for current process executable.
 
    type : str : int
        The type of resource to load.
 
    name : str : int
        The name or Id of the resource to load.
 
    language : int
        Language to use, default is LANG_NEUTRAL.
 
    Returns
    -------
    resource : bytes
        The byte string blob of the resource
 
    """
    with _pywin32error():
        hrsrc = _resource._FindResourceEx(hModule, type, name, language)
        size = _resource._SizeofResource(hModule, hrsrc)
        hglob = _resource._LoadResource(hModule, hrsrc)
        if _backend == 'ctypes':
            pointer = _common.cast(
                _resource._LockResource(hglob), _common.c_char_p)
        else:
            pointer = _resource._LockResource(hglob)
        return _common._PyBytes_FromStringAndSize(pointer, size)
 
 
def FreeLibrary(hModule):
    """ Free the loaded dynamic-link library (DLL) module.
 
    If necessary, decrements its reference count.
 
    Parameters
    ----------
    handle : hModule
        The handle to the library as returned by the LoadLibrary function.
 
    """
    with _pywin32error():
        return _dll._FreeLibrary(hModule)
 
 
def GetTickCount():
    """ The number of milliseconds that have elapsed since startup
 
    Returns
    -------
    counts : int
        The millisecond counts since system startup.
    """
    return _time._GetTickCount()
 
 
def BeginUpdateResource(filename, delete):
    """ Get a handle that can be used by the :func:`UpdateResource`.
 
    Parameters
    ----------
    fileName : unicode
        The filename of the module to load.
    delete : bool
        When true all existing resources are deleted
 
    Returns
    -------
    result : hModule
        Handle of the resource.
 
    """
    with _pywin32error():
        return _resource._BeginUpdateResource(filename, delete)
 
 
def EndUpdateResource(handle, discard):
    """ End the update resource of the handle.
 
    Parameters
    ----------
    handle : hModule
        The handle of the resource as it is returned
        by :func:`BeginUpdateResource`
 
    discard : bool
        When True all writes are discarded.
 
    """
    with _pywin32error():
        _resource._EndUpdateResource(handle, discard)
 
 
def UpdateResource(handle, type, name, data, language=LANG_NEUTRAL):
    """ Update a resource.
 
    Parameters
    ----------
    handle : hModule
        The handle of the resource file as returned by
        :func:`BeginUpdateResource`.
 
    type : str : int
        The type of resource to update.
 
    name : str : int
        The name or Id of the resource to update.
 
    data : bytes
        A bytes like object is expected.
 
        .. note::
          PyWin32 version 219, on Python 2.7, can handle unicode inputs.
          However, the data are stored as bytes and it is not really
          possible to convert the information back into the original
          unicode string. To be consistent with the Python 3 behaviour
          of PyWin32, we raise an error if the input cannot be
          converted to `bytes`.
 
    language : int
        Language to use, default is LANG_NEUTRAL.
 
    """
    with _pywin32error():
        try:
            lp_data = bytes(data)
        except UnicodeEncodeError:
            raise TypeError(
                "a bytes-like object is required, not a 'unicode'")
        _resource._UpdateResource(
            handle, type, name, language, lp_data, len(lp_data))
 
 
def GetWindowsDirectory():
    """ Get the ``Windows`` directory.
 
    Returns
    -------
    result : str
        The path to the ``Windows`` directory.
 
    """
    with _pywin32error():
        # Note: pywin32 returns str on py27, unicode (which is str) on py3
        return str(_system_information._GetWindowsDirectory())
 
 
def GetSystemDirectory():
    """ Get the ``System`` directory.
 
    Returns
    -------
    result : str
        The path to the ``System`` directory.
 
    """
    with _pywin32error():
        # Note: pywin32 returns str on py27, unicode (which is str) on py3
        return str(_system_information._GetSystemDirectory())