winapi_ui_automation/um/
synchapi.rs

1// Licensed under the Apache License, Version 2.0
2// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4// All files in the project carrying such notice may not be copied, modified, or distributed
5// except according to those terms.
6//! ApiSet Contract for api-ms-win-core-synch-l1
7use shared::basetsd::SIZE_T;
8use shared::minwindef::{BOOL, DWORD, LPLONG, LPVOID, PBOOL, ULONG};
9use um::minwinbase::{
10    LPCRITICAL_SECTION, LPSECURITY_ATTRIBUTES, PCRITICAL_SECTION, PREASON_CONTEXT,
11};
12use um::winnt::{
13    BOOLEAN, HANDLE, LARGE_INTEGER, LONG, LPCSTR, LPCWSTR, PRTL_BARRIER, PRTL_RUN_ONCE,
14    PVOID, RTL_BARRIER, RTL_CONDITION_VARIABLE, RTL_CONDITION_VARIABLE_INIT,
15    RTL_RUN_ONCE, RTL_SRWLOCK, RTL_SRWLOCK_INIT, VOID
16};
17pub const SRWLOCK_INIT: SRWLOCK = RTL_SRWLOCK_INIT;
18pub type SRWLOCK = RTL_SRWLOCK;
19pub type PSRWLOCK = *mut RTL_SRWLOCK;
20extern "system" {
21    pub fn InitializeSRWLock(
22        SRWLock: PSRWLOCK,
23    );
24    pub fn ReleaseSRWLockExclusive(
25        SRWLock: PSRWLOCK,
26    );
27    pub fn ReleaseSRWLockShared(
28        SRWLock: PSRWLOCK,
29    );
30    pub fn AcquireSRWLockExclusive(
31        SRWLock: PSRWLOCK,
32    );
33    pub fn AcquireSRWLockShared(
34        SRWLock: PSRWLOCK,
35    );
36    pub fn TryAcquireSRWLockExclusive(
37        SRWLock: PSRWLOCK,
38    ) -> BOOLEAN;
39    pub fn TryAcquireSRWLockShared(
40        SRWLock: PSRWLOCK,
41    ) -> BOOLEAN;
42    pub fn InitializeCriticalSection(
43        lpCriticalSection: LPCRITICAL_SECTION,
44    );
45    pub fn EnterCriticalSection(
46        lpCriticalSection: LPCRITICAL_SECTION,
47    );
48    pub fn LeaveCriticalSection(
49        lpCriticalSection: LPCRITICAL_SECTION,
50    );
51    pub fn InitializeCriticalSectionAndSpinCount(
52        lpCriticalSection: LPCRITICAL_SECTION,
53        dwSpinCount: DWORD,
54    ) -> BOOL;
55    pub fn InitializeCriticalSectionEx(
56        lpCriticalSection: LPCRITICAL_SECTION,
57        dwSpinCount: DWORD,
58        Flags: DWORD,
59    ) -> BOOL;
60    pub fn SetCriticalSectionSpinCount(
61        lpCriticalSection: LPCRITICAL_SECTION,
62        dwSpinCount: DWORD,
63    ) -> DWORD;
64    pub fn TryEnterCriticalSection(
65        lpCriticalSection: LPCRITICAL_SECTION,
66    ) -> BOOL;
67    pub fn DeleteCriticalSection(
68        lpCriticalSection: LPCRITICAL_SECTION,
69    );
70}
71pub type INIT_ONCE = RTL_RUN_ONCE;
72pub type PINIT_ONCE = PRTL_RUN_ONCE;
73pub type LPINIT_ONCE = PRTL_RUN_ONCE;
74//pub const INIT_ONCE_STATIC_INIT: INIT_ONCE = RTL_RUN_ONCE_INIT;
75//pub const INIT_ONCE_CHECK_ONLY: ULONG = RTL_RUN_ONCE_CHECK_ONLY;
76//pub const INIT_ONCE_ASYNC: ULONG = RTL_RUN_ONCE_ASYNC;
77//pub const INIT_ONCE_INIT_FAILED: ULONG = RTL_RUN_ONCE_INIT_FAILED;
78//pub const INIT_ONCE_CTX_RESERVED_BITS: usize = RTL_RUN_ONCE_CTX_RESERVED_BITS;
79FN!{stdcall PINIT_ONCE_FN(
80    InitOnce: PINIT_ONCE,
81    Parameter: PVOID,
82    Context: *mut PVOID,
83) -> BOOL}
84extern "system" {
85    pub fn InitOnceInitialize(
86        InitOnce: PINIT_ONCE,
87    );
88    pub fn InitOnceExecuteOnce(
89        InitOnce: PINIT_ONCE,
90        InitFn: PINIT_ONCE_FN,
91        Parameter: PVOID,
92        Context: *mut LPVOID,
93    ) -> BOOL;
94    pub fn InitOnceBeginInitialize(
95        lpInitOnce: LPINIT_ONCE,
96        dwFlags: DWORD,
97        fPending: PBOOL,
98        lpContext: *mut LPVOID,
99    ) -> BOOL;
100    pub fn InitOnceComplete(
101        lpInitOnce: LPINIT_ONCE,
102        dwFlags: DWORD,
103        lpContext: LPVOID,
104    ) -> BOOL;
105}
106pub type CONDITION_VARIABLE = RTL_CONDITION_VARIABLE;
107pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE;
108pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = RTL_CONDITION_VARIABLE_INIT;
109//pub const CONDITION_VARIABLE_LOCKMODE_SHARED: ULONG = RTL_CONDITION_VARIABLE_LOCKMODE_SHARED;
110extern "system" {
111    pub fn InitializeConditionVariable(
112        ConditionVariable: PCONDITION_VARIABLE,
113    );
114    pub fn WakeConditionVariable(
115        ConditionVariable: PCONDITION_VARIABLE,
116    );
117    pub fn WakeAllConditionVariable(
118        ConditionVariable: PCONDITION_VARIABLE,
119    );
120    pub fn SleepConditionVariableCS(
121        ConditionVariable: PCONDITION_VARIABLE,
122        CriticalSection: PCRITICAL_SECTION,
123        dwMilliseconds: DWORD,
124    ) -> BOOL;
125    pub fn SleepConditionVariableSRW(
126        ConditionVariable: PCONDITION_VARIABLE,
127        SRWLock: PSRWLOCK,
128        dwMilliseconds: DWORD,
129        Flags: ULONG,
130    ) -> BOOL;
131    pub fn SetEvent(
132        hEvent: HANDLE,
133    ) -> BOOL;
134    pub fn ResetEvent(
135        hEvent: HANDLE,
136    ) -> BOOL;
137    pub fn ReleaseSemaphore(
138        hSemaphore: HANDLE,
139        lReleaseCount: LONG,
140        lpPreviousCount: LPLONG,
141    ) -> BOOL;
142    pub fn ReleaseMutex(
143        hMutex: HANDLE,
144    ) -> BOOL;
145    pub fn WaitForSingleObject(
146        hHandle: HANDLE,
147        dwMilliseconds: DWORD,
148    ) -> DWORD;
149    pub fn SleepEx(
150        dwMilliseconds: DWORD,
151        bAlertable: BOOL,
152    ) -> DWORD;
153    pub fn WaitForSingleObjectEx(
154        hHandle: HANDLE,
155        dwMilliseconds: DWORD,
156        bAlertable: BOOL,
157    ) -> DWORD;
158    pub fn WaitForMultipleObjectsEx(
159        nCount: DWORD,
160        lpHandles: *const HANDLE,
161        bWaitAll: BOOL,
162        dwMilliseconds: DWORD,
163        bAlertable: BOOL,
164    ) -> DWORD;
165}
166//pub const MUTEX_MODIFY_STATE: DWORD = MUTANT_QUERY_STATE;
167//pub const MUTEX_ALL_ACCESS: DWORD = MUTANT_ALL_ACCESS;
168extern "system" {
169    pub fn CreateMutexA(
170        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
171        bInitialOwner: BOOL,
172        lpName: LPCSTR,
173    ) -> HANDLE;
174    pub fn CreateMutexW(
175        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
176        bInitialOwner: BOOL,
177        lpName: LPCWSTR,
178    ) -> HANDLE;
179    pub fn OpenMutexW(
180        dwDesiredAccess: DWORD,
181        bInheritHandle: BOOL,
182        lpName: LPCWSTR,
183    ) -> HANDLE;
184    pub fn CreateEventA(
185        lpEventAttributes: LPSECURITY_ATTRIBUTES,
186        bManualReset: BOOL,
187        bInitialState: BOOL,
188        lpName: LPCSTR,
189    ) -> HANDLE;
190    pub fn CreateEventW(
191        lpEventAttributes: LPSECURITY_ATTRIBUTES,
192        bManualReset: BOOL,
193        bInitialState: BOOL,
194        lpName: LPCWSTR,
195    ) -> HANDLE;
196    pub fn OpenEventA(
197        dwDesiredAccess: DWORD,
198        bInheritHandle: BOOL,
199        lpName: LPCSTR,
200    ) -> HANDLE;
201    pub fn OpenEventW(
202        dwDesiredAccess: DWORD,
203        bInheritHandle: BOOL,
204        lpName: LPCWSTR,
205    ) -> HANDLE;
206    pub fn OpenSemaphoreW(
207        dwDesiredAccess: DWORD,
208        bInheritHandle: BOOL,
209        lpName: LPCWSTR,
210    ) -> HANDLE;
211}
212FN!{stdcall PTIMERAPCROUTINE(
213    lpArgToCompletionRoutine: LPVOID,
214    dwTimerLowValue: DWORD,
215    dwTimerHighValue: DWORD,
216) -> ()}
217extern "system" {
218    pub fn OpenWaitableTimerW(
219        dwDesiredAccess: DWORD,
220        bInheritHandle: BOOL,
221        lpTimerName: LPCWSTR,
222    ) -> HANDLE;
223    pub fn SetWaitableTimerEx(
224        hTimer: HANDLE,
225        lpDueTime: *const LARGE_INTEGER,
226        lPeriod: LONG,
227        pfnCompletionRoutine: PTIMERAPCROUTINE,
228        lpArgToCompletionRoutine: LPVOID,
229        WakeContext: PREASON_CONTEXT,
230        TolerableDelay: ULONG,
231    ) -> BOOL;
232    pub fn SetWaitableTimer(
233        hTimer: HANDLE,
234        lpDueTime: *const LARGE_INTEGER,
235        lPeriod: LONG,
236        pfnCompletionRoutine: PTIMERAPCROUTINE,
237        lpArgToCompletionRoutine: LPVOID,
238        fResume: BOOL,
239    ) -> BOOL;
240    pub fn CancelWaitableTimer(
241        hTimer: HANDLE,
242    ) -> BOOL;
243}
244pub const CREATE_MUTEX_INITIAL_OWNER: DWORD = 0x00000001;
245extern "system" {
246    pub fn CreateMutexExA(
247        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
248        lpName: LPCSTR,
249        dwFlags: DWORD,
250        dwDesiredAccess: DWORD,
251    ) -> HANDLE;
252    pub fn CreateMutexExW(
253        lpMutexAttributes: LPSECURITY_ATTRIBUTES,
254        lpName: LPCWSTR,
255        dwFlags: DWORD,
256        dwDesiredAccess: DWORD,
257    ) -> HANDLE;
258}
259pub const CREATE_EVENT_MANUAL_RESET: DWORD = 0x00000001;
260pub const CREATE_EVENT_INITIAL_SET: DWORD = 0x00000002;
261extern "system" {
262    pub fn CreateEventExA(
263        lpEventAttributes: LPSECURITY_ATTRIBUTES,
264        lpName: LPCSTR,
265        dwFlags: DWORD,
266        dwDesiredAccess: DWORD,
267    ) -> HANDLE;
268    pub fn CreateEventExW(
269        lpEventAttributes: LPSECURITY_ATTRIBUTES,
270        lpName: LPCWSTR,
271        dwFlags: DWORD,
272        dwDesiredAccess: DWORD,
273    ) -> HANDLE;
274    pub fn CreateSemaphoreExW(
275        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
276        lInitialCount: LONG,
277        lMaximumCount: LONG,
278        lpName: LPCWSTR,
279        dwFlags: DWORD,
280        dwDesiredAccess: DWORD,
281    ) -> HANDLE;
282}
283pub const CREATE_WAITABLE_TIMER_MANUAL_RESET: DWORD = 0x00000001;
284extern "system" {
285    pub fn CreateWaitableTimerExW(
286        lpTimerAttributes: LPSECURITY_ATTRIBUTES,
287        lpTimerName: LPCWSTR,
288        dwFlags: DWORD,
289        dwDesiredAccess: DWORD,
290    ) -> HANDLE;
291}
292pub type SYNCHRONIZATION_BARRIER = RTL_BARRIER;
293pub type PSYNCHRONIZATION_BARRIER = PRTL_BARRIER;
294pub type LPSYNCHRONIZATION_BARRIER = PRTL_BARRIER;
295pub const SYNCHRONIZATION_BARRIER_FLAGS_SPIN_ONLY: DWORD = 0x01;
296pub const SYNCHRONIZATION_BARRIER_FLAGS_BLOCK_ONLY: DWORD = 0x02;
297pub const SYNCHRONIZATION_BARRIER_FLAGS_NO_DELETE: DWORD = 0x04;
298extern "system" {
299    pub fn EnterSynchronizationBarrier(
300        lpBarrier: LPSYNCHRONIZATION_BARRIER,
301        dwFlags: DWORD,
302    ) -> BOOL;
303    pub fn InitializeSynchronizationBarrier(
304        lpBarrier: LPSYNCHRONIZATION_BARRIER,
305        lTotalThreads: LONG,
306        lSpinCount: LONG,
307    ) -> BOOL;
308    pub fn DeleteSynchronizationBarrier(
309        lpBarrier: LPSYNCHRONIZATION_BARRIER,
310    ) -> BOOL;
311    pub fn Sleep(
312        dwMilliseconds: DWORD,
313    );
314    pub fn WaitOnAddress(
315        Address: *mut VOID,
316        CompareAddress: PVOID,
317        AddressSize: SIZE_T,
318        dwMilliseconds: DWORD,
319    ) -> BOOL;
320    pub fn WakeByAddressSingle(
321        Address: PVOID,
322    );
323    pub fn WakeByAddressAll(
324        Address: PVOID,
325    );
326    pub fn SignalObjectAndWait(
327        hObjectToSignal: HANDLE,
328        hObjectToWaitOn: HANDLE,
329        dwMilliseconds: DWORD,
330        bAlertable: BOOL,
331    ) -> DWORD;
332    pub fn WaitForMultipleObjects(
333        nCount: DWORD,
334        lpHandles: *const HANDLE,
335        bWaitAll: BOOL,
336        dwMilliseconds: DWORD,
337    ) -> DWORD;
338    pub fn CreateSemaphoreW(
339        lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
340        lInitialCount: LONG,
341        lMaximumCount: LONG,
342        lpName: LPCWSTR,
343    ) -> HANDLE;
344    pub fn CreateWaitableTimerW(
345        lpTimerAttributes: LPSECURITY_ATTRIBUTES,
346        bManualReset: BOOL,
347        lpTimerName: LPCWSTR,
348    ) -> HANDLE;
349}
winapi_ui_automation/um/synchapi.rs

winapi_ui_automation/um/
synchapi.rs
