[apple/cf.git] / RunLoop.subproj / CFWindowsMessageQueue.c

/*
 * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*	CFWindowsMessageQueue.c
	Copyright 1999-2002, Apple, Inc. All rights reserved.
	Responsibility: Christopher Kane
*/

#if defined(__WIN32__)

#include "CFWindowsMessageQueue.h"
#include "CFInternal.h"

extern unsigned long __CFRunLoopGetWindowsMessageQueueMask(CFRunLoopRef rl, CFStringRef mode);
extern void __CFRunLoopSetWindowsMessageQueueMask(CFRunLoopRef rl, unsigned long mask, CFStringRef mode);

struct __CFWindowsMessageQueue {
    CFRuntimeBase _base;
    CFAllocatorRef _allocator;
    CFSpinLock_t _lock;
    DWORD _mask;
    CFRunLoopSourceRef _source;
    CFMutableArrayRef _runLoops;
};

/* Bit 3 in the base reserved bits is used for invalid state */

CF_INLINE Boolean __CFWindowsMessageQueueIsValid(CFWindowsMessageQueueRef wmq) {
    return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)wmq)->_info, 3, 3);
}

CF_INLINE void __CFWindowsMessageQueueSetValid(CFWindowsMessageQueueRef wmq) {
    __CFBitfieldSetValue(((CFRuntimeBase *)wmq)->_info, 3, 3, 1);
}

CF_INLINE void __CFWindowsMessageQueueUnsetValid(CFWindowsMessageQueueRef wmq) {
    __CFBitfieldSetValue(((CFRuntimeBase *)wmq)->_info, 3, 3, 0);
}

CF_INLINE void __CFWindowsMessageQueueLock(CFWindowsMessageQueueRef wmq) {
    __CFSpinLock(&(wmq->_lock));
}

CF_INLINE void __CFWindowsMessageQueueUnlock(CFWindowsMessageQueueRef wmq) {
    __CFSpinUnlock(&(wmq->_lock));
}

CFTypeID CFWindowsMessageQueueGetTypeID(void) {
    return __kCFWindowsMessageQueueTypeID;
}

Boolean __CFWindowsMessageQueueEqual(CFTypeRef cf1, CFTypeRef cf2) {
    CFWindowsMessageQueueRef wmq1 = (CFWindowsMessageQueueRef)cf1;
    CFWindowsMessageQueueRef wmq2 = (CFWindowsMessageQueueRef)cf2;
    return (wmq1 == wmq2);
}

CFHashCode __CFWindowsMessageQueueHash(CFTypeRef cf) {
    CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
    return (CFHashCode)wmq;
}

CFStringRef __CFWindowsMessageQueueCopyDescription(CFTypeRef cf) {
#warning CF: this and many other CopyDescription functions are probably
#warning CF: broken, in that some of these fields being printed out can
#warning CF: be NULL, when the object is in the invalid state
    CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
    CFMutableStringRef result;
    result = CFStringCreateMutable(CFGetAllocator(wmq), 0);
    __CFWindowsMessageQueueLock(wmq);
#warning CF: here, and probably everywhere with a per-instance lock,
#warning CF: the locked state will always be true because we lock,
#warning CF: and you cannot call description if the object is locked;
#warning CF: probably should not lock description, and call it unsafe
    CFStringAppendFormat(result, NULL, CFSTR("<CFWindowsMessageQueue 0x%x [0x%x]>{locked = %s, valid = %s, mask = 0x%x,\n    run loops = %@}"), (UInt32)cf, (UInt32)CFGetAllocator(wmq), (wmq->_lock ? "Yes" : "No"), (__CFWindowsMessageQueueIsValid(wmq) ? "Yes" : "No"), (UInt32)wmq->_mask, wmq->_runLoops);
    __CFWindowsMessageQueueUnlock(wmq);
    return result;
}

CFAllocatorRef __CFWindowsMessageQueueGetAllocator(CFTypeRef cf) {
    CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
    return wmq->_allocator;
}

void __CFWindowsMessageQueueDeallocate(CFTypeRef cf) {
    CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
    CFAllocatorRef allocator = CFGetAllocator(wmq);
    CFAllocatorDeallocate(allocator, wmq);
    CFRelease(allocator);
}

CFWindowsMessageQueueRef CFWindowsMessageQueueCreate(CFAllocatorRef allocator, DWORD mask) {
    CFWindowsMessageQueueRef memory;
    UInt32 size;
    size = sizeof(struct __CFWindowsMessageQueue);
    allocator = (NULL == allocator) ? CFRetain(__CFGetDefaultAllocator()) : CFRetain(allocator);
    memory = CFAllocatorAllocate(allocator, size, 0);
    if (NULL == memory) {
	CFRelease(allocator);
	return NULL;
    }
    __CFGenericInitBase(memory, NULL, __kCFWindowsMessageQueueTypeID);
    memory->_allocator = allocator;
    __CFWindowsMessageQueueSetValid(memory);
    memory->_lock = 0;
    memory->_mask = mask;
    memory->_source = NULL;
    memory->_runLoops = CFArrayCreateMutable(allocator, 0, NULL);
    return memory;
}

void CFWindowsMessageQueueInvalidate(CFWindowsMessageQueueRef wmq) {
    __CFGenericValidateType(wmq, __kCFWindowsMessageQueueTypeID);
    CFRetain(wmq);
    __CFWindowsMessageQueueLock(wmq);
    if (__CFWindowsMessageQueueIsValid(wmq)) {
	SInt32 idx;
	__CFWindowsMessageQueueUnsetValid(wmq);
	for (idx = CFArrayGetCount(wmq->_runLoops); idx--;) {
	    CFRunLoopWakeUp((CFRunLoopRef)CFArrayGetValueAtIndex(wmq->_runLoops, idx));
	}
	CFRelease(wmq->_runLoops);
	wmq->_runLoops = NULL;
	if (NULL != wmq->_source) {
	    CFRunLoopSourceInvalidate(wmq->_source);
	    CFRelease(wmq->_source);
	    wmq->_source = NULL;
	}
    }
    __CFWindowsMessageQueueUnlock(wmq);
    CFRelease(wmq);
}

Boolean CFWindowsMessageQueueIsValid(CFWindowsMessageQueueRef wmq) {
    __CFGenericValidateType(wmq, __kCFWindowsMessageQueueTypeID);
    return __CFWindowsMessageQueueIsValid(wmq);
}

DWORD CFWindowsMessageQueueGetMask(CFWindowsMessageQueueRef wmq) {
    __CFGenericValidateType(wmq, __kCFWindowsMessageQueueTypeID);
    return wmq->_mask;
}

static void __CFWindowsMessageQueueSchedule(void *info, CFRunLoopRef rl, CFStringRef mode) {
    CFWindowsMessageQueueRef wmq = info;
    __CFWindowsMessageQueueLock(wmq);
    if (__CFWindowsMessageQueueIsValid(wmq)) {
	unsigned long mask;
	CFArrayAppendValue(wmq->_runLoops, rl);
	mask = __CFRunLoopGetWindowsMessageQueueMask(rl, mode);
	mask |= wmq->_mask;
	__CFRunLoopSetWindowsMessageQueueMask(rl, mask, mode);
    }
    __CFWindowsMessageQueueUnlock(wmq);
}

static void __CFWindowsMessageQueueCancel(void *info, CFRunLoopRef rl, CFStringRef mode) {
    CFWindowsMessageQueueRef wmq = info;
    __CFWindowsMessageQueueLock(wmq);
#warning CF: should fix up run loop modes mask here, if not done
#warning CF: previously by the invalidation, where it should also
#warning CF: be done
    if (NULL != wmq->_runLoops) {
	SInt32 idx = CFArrayGetFirstIndexOfValue(wmq->_runLoops, CFRangeMake(0, CFArrayGetCount(wmq->_runLoops)), rl);
	if (0 <= idx) CFArrayRemoveValueAtIndex(wmq->_runLoops, idx);
    }
    __CFWindowsMessageQueueUnlock(wmq);
}

static void __CFWindowsMessageQueuePerform(void *info) {
    CFWindowsMessageQueueRef wmq = info;
    MSG msg;
    __CFWindowsMessageQueueLock(wmq);
    if (!__CFWindowsMessageQueueIsValid(wmq)) {
	__CFWindowsMessageQueueUnlock(wmq);
	return;
    }
    __CFWindowsMessageQueueUnlock(wmq);
    if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE | PM_NOYIELD)) {
	TranslateMessage(&msg);
	DispatchMessage(&msg);
    }
}

CFRunLoopSourceRef CFWindowsMessageQueueCreateRunLoopSource(CFAllocatorRef allocator, CFWindowsMessageQueueRef wmq, CFIndex order) {
    CFRunLoopSourceRef result = NULL;
    __CFWindowsMessageQueueLock(wmq);
    if (NULL == wmq->_source) {
	CFRunLoopSourceContext context;
	context.version = 0;
	context.info = (void *)wmq;
	context.retain = (const void *(*)(const void *))CFRetain;
	context.release = (void (*)(const void *))CFRelease;
	context.copyDescription = (CFStringRef (*)(const void *))__CFWindowsMessageQueueCopyDescription;
	context.equal = (Boolean (*)(const void *, const void *))__CFWindowsMessageQueueEqual;
	context.hash = (CFHashCode (*)(const void *))__CFWindowsMessageQueueHash;
	context.schedule = __CFWindowsMessageQueueSchedule;
	context.cancel = __CFWindowsMessageQueueCancel;
	context.perform = __CFWindowsMessageQueuePerform;
	wmq->_source = CFRunLoopSourceCreate(allocator, order, &context);
    }
    CFRetain(wmq->_source);	/* This retain is for the receiver */
    result = wmq->_source;
    __CFWindowsMessageQueueUnlock(wmq);
    return result;
}

#endif
Commit	Line	Data
9ce05555 A	1	/*
	2	* Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
	7	*
	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/* CFWindowsMessageQueue.c
	26	Copyright 1999-2002, Apple, Inc. All rights reserved.
	27	Responsibility: Christopher Kane
	28	*/
	29
	30	#if defined(__WIN32__)
	31
	32	#include "CFWindowsMessageQueue.h"
	33	#include "CFInternal.h"
	34
	35	extern unsigned long __CFRunLoopGetWindowsMessageQueueMask(CFRunLoopRef rl, CFStringRef mode);
	36	extern void __CFRunLoopSetWindowsMessageQueueMask(CFRunLoopRef rl, unsigned long mask, CFStringRef mode);
	37
	38	struct __CFWindowsMessageQueue {
	39	CFRuntimeBase _base;
	40	CFAllocatorRef _allocator;
	41	CFSpinLock_t _lock;
	42	DWORD _mask;
	43	CFRunLoopSourceRef _source;
	44	CFMutableArrayRef _runLoops;
	45	};
	46
	47	/* Bit 3 in the base reserved bits is used for invalid state */
	48
	49	CF_INLINE Boolean __CFWindowsMessageQueueIsValid(CFWindowsMessageQueueRef wmq) {
	50	return (Boolean)__CFBitfieldGetValue(((const CFRuntimeBase *)wmq)->_info, 3, 3);
	51	}
	52
	53	CF_INLINE void __CFWindowsMessageQueueSetValid(CFWindowsMessageQueueRef wmq) {
	54	__CFBitfieldSetValue(((CFRuntimeBase *)wmq)->_info, 3, 3, 1);
	55	}
	56
	57	CF_INLINE void __CFWindowsMessageQueueUnsetValid(CFWindowsMessageQueueRef wmq) {
	58	__CFBitfieldSetValue(((CFRuntimeBase *)wmq)->_info, 3, 3, 0);
	59	}
	60
	61	CF_INLINE void __CFWindowsMessageQueueLock(CFWindowsMessageQueueRef wmq) {
	62	__CFSpinLock(&(wmq->_lock));
	63	}
	64
65	CF_INLINE void __CFWindowsMessageQueueUnlock(CFWindowsMessageQueueRef wmq) {
66	__CFSpinUnlock(&(wmq->_lock));
67	}
68
69	CFTypeID CFWindowsMessageQueueGetTypeID(void) {
70	return __kCFWindowsMessageQueueTypeID;
71	}
72
73	Boolean __CFWindowsMessageQueueEqual(CFTypeRef cf1, CFTypeRef cf2) {
74	CFWindowsMessageQueueRef wmq1 = (CFWindowsMessageQueueRef)cf1;
75	CFWindowsMessageQueueRef wmq2 = (CFWindowsMessageQueueRef)cf2;
76	return (wmq1 == wmq2);
77	}
78
79	CFHashCode __CFWindowsMessageQueueHash(CFTypeRef cf) {
80	CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
81	return (CFHashCode)wmq;
82	}
83
84	CFStringRef __CFWindowsMessageQueueCopyDescription(CFTypeRef cf) {
85	#warning CF: this and many other CopyDescription functions are probably
86	#warning CF: broken, in that some of these fields being printed out can
87	#warning CF: be NULL, when the object is in the invalid state
88	CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
89	CFMutableStringRef result;
90	result = CFStringCreateMutable(CFGetAllocator(wmq), 0);
91	__CFWindowsMessageQueueLock(wmq);
92	#warning CF: here, and probably everywhere with a per-instance lock,
93	#warning CF: the locked state will always be true because we lock,
94	#warning CF: and you cannot call description if the object is locked;
95	#warning CF: probably should not lock description, and call it unsafe
96	CFStringAppendFormat(result, NULL, CFSTR("<CFWindowsMessageQueue 0x%x [0x%x]>{locked = %s, valid = %s, mask = 0x%x,\n run loops = %@}"), (UInt32)cf, (UInt32)CFGetAllocator(wmq), (wmq->_lock ? "Yes" : "No"), (__CFWindowsMessageQueueIsValid(wmq) ? "Yes" : "No"), (UInt32)wmq->_mask, wmq->_runLoops);
97	__CFWindowsMessageQueueUnlock(wmq);
98	return result;
99	}
100
101	CFAllocatorRef __CFWindowsMessageQueueGetAllocator(CFTypeRef cf) {
102	CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
103	return wmq->_allocator;
104	}
105
106	void __CFWindowsMessageQueueDeallocate(CFTypeRef cf) {
107	CFWindowsMessageQueueRef wmq = (CFWindowsMessageQueueRef)cf;
108	CFAllocatorRef allocator = CFGetAllocator(wmq);
109	CFAllocatorDeallocate(allocator, wmq);
110	CFRelease(allocator);
111	}
112
113	CFWindowsMessageQueueRef CFWindowsMessageQueueCreate(CFAllocatorRef allocator, DWORD mask) {
114	CFWindowsMessageQueueRef memory;
115	UInt32 size;
116	size = sizeof(struct __CFWindowsMessageQueue);
117	allocator = (NULL == allocator) ? CFRetain(__CFGetDefaultAllocator()) : CFRetain(allocator);
118	memory = CFAllocatorAllocate(allocator, size, 0);
119	if (NULL == memory) {
120	CFRelease(allocator);
121	return NULL;
122	}
123	__CFGenericInitBase(memory, NULL, __kCFWindowsMessageQueueTypeID);
124	memory->_allocator = allocator;
125	__CFWindowsMessageQueueSetValid(memory);
126	memory->_lock = 0;
127	memory->_mask = mask;
128	memory->_source = NULL;
129	memory->_runLoops = CFArrayCreateMutable(allocator, 0, NULL);
130	return memory;
131	}
132
133	void CFWindowsMessageQueueInvalidate(CFWindowsMessageQueueRef wmq) {
134	__CFGenericValidateType(wmq, __kCFWindowsMessageQueueTypeID);
135	CFRetain(wmq);
136	__CFWindowsMessageQueueLock(wmq);
137	if (__CFWindowsMessageQueueIsValid(wmq)) {
138	SInt32 idx;
139	__CFWindowsMessageQueueUnsetValid(wmq);
140	for (idx = CFArrayGetCount(wmq->_runLoops); idx--;) {
141	CFRunLoopWakeUp((CFRunLoopRef)CFArrayGetValueAtIndex(wmq->_runLoops, idx));
142	}
143	CFRelease(wmq->_runLoops);
144	wmq->_runLoops = NULL;
145	if (NULL != wmq->_source) {
146	CFRunLoopSourceInvalidate(wmq->_source);
147	CFRelease(wmq->_source);
148	wmq->_source = NULL;
149	}
150	}
151	__CFWindowsMessageQueueUnlock(wmq);
152	CFRelease(wmq);
153	}
154
155	Boolean CFWindowsMessageQueueIsValid(CFWindowsMessageQueueRef wmq) {
156	__CFGenericValidateType(wmq, __kCFWindowsMessageQueueTypeID);
157	return __CFWindowsMessageQueueIsValid(wmq);
158	}
159
160	DWORD CFWindowsMessageQueueGetMask(CFWindowsMessageQueueRef wmq) {
161	__CFGenericValidateType(wmq, __kCFWindowsMessageQueueTypeID);
162	return wmq->_mask;
163	}
164
165	static void __CFWindowsMessageQueueSchedule(void *info, CFRunLoopRef rl, CFStringRef mode) {
166	CFWindowsMessageQueueRef wmq = info;
167	__CFWindowsMessageQueueLock(wmq);
168	if (__CFWindowsMessageQueueIsValid(wmq)) {
169	unsigned long mask;
170	CFArrayAppendValue(wmq->_runLoops, rl);
171	mask = __CFRunLoopGetWindowsMessageQueueMask(rl, mode);
172	mask \|= wmq->_mask;
173	__CFRunLoopSetWindowsMessageQueueMask(rl, mask, mode);
174	}
175	__CFWindowsMessageQueueUnlock(wmq);
176	}
177
178	static void __CFWindowsMessageQueueCancel(void *info, CFRunLoopRef rl, CFStringRef mode) {
179	CFWindowsMessageQueueRef wmq = info;
180	__CFWindowsMessageQueueLock(wmq);
181	#warning CF: should fix up run loop modes mask here, if not done
182	#warning CF: previously by the invalidation, where it should also
183	#warning CF: be done
184	if (NULL != wmq->_runLoops) {
185	SInt32 idx = CFArrayGetFirstIndexOfValue(wmq->_runLoops, CFRangeMake(0, CFArrayGetCount(wmq->_runLoops)), rl);
186	if (0 <= idx) CFArrayRemoveValueAtIndex(wmq->_runLoops, idx);
187	}
188	__CFWindowsMessageQueueUnlock(wmq);
189	}
190
191	static void __CFWindowsMessageQueuePerform(void *info) {
192	CFWindowsMessageQueueRef wmq = info;
193	MSG msg;
194	__CFWindowsMessageQueueLock(wmq);
195	if (!__CFWindowsMessageQueueIsValid(wmq)) {
196	__CFWindowsMessageQueueUnlock(wmq);
197	return;
198	}
199	__CFWindowsMessageQueueUnlock(wmq);
200	if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE \| PM_NOYIELD)) {
201	TranslateMessage(&msg);
202	DispatchMessage(&msg);
203	}
204	}
205
206	CFRunLoopSourceRef CFWindowsMessageQueueCreateRunLoopSource(CFAllocatorRef allocator, CFWindowsMessageQueueRef wmq, CFIndex order) {
207	CFRunLoopSourceRef result = NULL;
208	__CFWindowsMessageQueueLock(wmq);
209	if (NULL == wmq->_source) {
210	CFRunLoopSourceContext context;
211	context.version = 0;
212	context.info = (void *)wmq;
213	context.retain = (const void ()(const void *))CFRetain;
214	context.release = (void ()(const void ))CFRelease;
215	context.copyDescription = (CFStringRef ()(const void ))__CFWindowsMessageQueueCopyDescription;
216	context.equal = (Boolean ()(const void , const void *))__CFWindowsMessageQueueEqual;
217	context.hash = (CFHashCode ()(const void ))__CFWindowsMessageQueueHash;
218	context.schedule = __CFWindowsMessageQueueSchedule;
219	context.cancel = __CFWindowsMessageQueueCancel;
220	context.perform = __CFWindowsMessageQueuePerform;
221	wmq->_source = CFRunLoopSourceCreate(allocator, order, &context);
222	}
223	CFRetain(wmq->_source); /* This retain is for the receiver */
224	result = wmq->_source;
225	__CFWindowsMessageQueueUnlock(wmq);
226	return result;
227	}
228
229	#endif
230