2 * MACDRV Cocoa event queue code
4 * Copyright 2011, 2012, 2013 Ken Thomases for CodeWeavers Inc.
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include <sys/types.h>
22 #include <sys/event.h>
24 #include <libkern/OSAtomic.h>
25 #import <Carbon/Carbon.h>
27 #include "macdrv_cocoa.h"
28 #import "cocoa_event.h"
30 #import "cocoa_window.h"
33 static NSString* const WineEventQueueThreadDictionaryKey = @"WineEventQueueThreadDictionaryKey";
35 static NSString* const WineHotKeyMacIDKey = @"macID";
36 static NSString* const WineHotKeyVkeyKey = @"vkey";
37 static NSString* const WineHotKeyModFlagsKey = @"modFlags";
38 static NSString* const WineHotKeyKeyCodeKey = @"keyCode";
39 static NSString* const WineHotKeyCarbonRefKey = @"hotKeyRef";
40 static const OSType WineHotKeySignature = 'Wine';
43 @interface MacDrvEvent : NSObject
49 - (id) initWithEvent:(macdrv_event*)event;
53 @implementation MacDrvEvent
55 - (id) initWithEvent:(macdrv_event*)inEvent
60 event = macdrv_retain_event(inEvent);
67 if (event) macdrv_release_event(event);
74 @implementation WineEventQueue
78 [self doesNotRecognizeSelector:_cmd];
83 - (id) initWithEventHandler:(macdrv_event_handler)handler
85 NSParameterAssert(handler != nil);
93 fds[0] = fds[1] = kq = -1;
95 event_handler = handler;
96 events = [[NSMutableArray alloc] init];
97 eventsLock = [[NSLock alloc] init];
99 if (!events || !eventsLock)
106 fcntl(fds[0], F_SETFD, 1) == -1 ||
107 fcntl(fds[0], F_SETFL, O_NONBLOCK) == -1 ||
108 fcntl(fds[1], F_SETFD, 1) == -1 ||
109 fcntl(fds[1], F_SETFL, O_NONBLOCK) == -1)
122 EV_SET(&kev, fds[0], EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, 0);
125 rc = kevent(kq, &kev, 1, NULL, 0, NULL);
126 } while (rc == -1 && errno == EINTR);
138 NSNumber* hotKeyMacID;
140 for (hotKeyMacID in hotKeysByMacID)
142 NSDictionary* hotKeyDict = [hotKeysByMacID objectForKey:hotKeyMacID];
143 EventHotKeyRef hotKeyRef = [[hotKeyDict objectForKey:WineHotKeyCarbonRefKey] pointerValue];
144 UnregisterEventHotKey(hotKeyRef);
146 [hotKeysByMacID release];
147 [hotKeysByWinID release];
149 [eventsLock release];
151 if (kq != -1) close(kq);
152 if (fds[0] != -1) close(fds[0]);
153 if (fds[1] != -1) close(fds[1]);
158 - (void) signalEventAvailable
165 rc = write(fds[1], &junk, 1);
166 } while (rc < 0 && errno == EINTR);
168 if (rc < 0 && errno != EAGAIN)
169 ERR(@"%@: got error writing to event queue signaling pipe: %s\n", self, strerror(errno));
172 - (void) postEventObject:(MacDrvEvent*)event
175 MacDrvEvent* lastEvent;
179 indexes = [events indexesOfObjectsPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop){
180 return ((MacDrvEvent*)obj)->event->deliver <= 0;
182 [events removeObjectsAtIndexes:indexes];
184 if ((event->event->type == MOUSE_MOVED ||
185 event->event->type == MOUSE_MOVED_ABSOLUTE) &&
186 event->event->deliver == INT_MAX &&
187 (lastEvent = [events lastObject]) &&
188 (lastEvent->event->type == MOUSE_MOVED ||
189 lastEvent->event->type == MOUSE_MOVED_ABSOLUTE) &&
190 lastEvent->event->deliver == INT_MAX &&
191 lastEvent->event->window == event->event->window &&
192 lastEvent->event->mouse_moved.drag == event->event->mouse_moved.drag)
194 if (event->event->type == MOUSE_MOVED)
196 lastEvent->event->mouse_moved.x += event->event->mouse_moved.x;
197 lastEvent->event->mouse_moved.y += event->event->mouse_moved.y;
201 lastEvent->event->type = MOUSE_MOVED_ABSOLUTE;
202 lastEvent->event->mouse_moved.x = event->event->mouse_moved.x;
203 lastEvent->event->mouse_moved.y = event->event->mouse_moved.y;
206 lastEvent->event->mouse_moved.time_ms = event->event->mouse_moved.time_ms;
209 [events addObject:event];
213 [self signalEventAvailable];
216 - (void) postEvent:(macdrv_event*)inEvent
218 MacDrvEvent* event = [[MacDrvEvent alloc] initWithEvent:inEvent];
219 [self postEventObject:event];
223 - (MacDrvEvent*) getEventMatchingMask:(macdrv_event_mask)mask
228 MacDrvEvent* ret = nil;
230 /* Clear the pipe which signals there are pending events. */
233 rc = read(fds[0], buf, sizeof(buf));
234 } while (rc > 0 || (rc < 0 && errno == EINTR));
235 if (rc == 0 || (rc < 0 && errno != EAGAIN))
238 ERR(@"%@: event queue signaling pipe unexpectedly closed\n", self);
240 ERR(@"%@: got error reading from event queue signaling pipe: %s\n", self, strerror(errno));
247 while (index < [events count])
249 MacDrvEvent* event = [events objectAtIndex:index];
250 if (event_mask_for_type(event->event->type) & mask)
252 [[event retain] autorelease];
253 [events removeObjectAtIndex:index];
255 if (event->event->deliver == INT_MAX ||
256 OSAtomicDecrement32Barrier(&event->event->deliver) >= 0)
270 - (void) discardEventsPassingTest:(BOOL (^)(macdrv_event* event))block
272 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
277 indexes = [events indexesOfObjectsPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop){
278 MacDrvEvent* event = obj;
279 return block(event->event);
282 [events removeObjectsAtIndexes:indexes];
289 - (void) discardEventsMatchingMask:(macdrv_event_mask)mask forWindow:(NSWindow*)window
291 [self discardEventsPassingTest:^BOOL (macdrv_event* event){
292 return ((event_mask_for_type(event->type) & mask) &&
293 (!window || event->window == (macdrv_window)window));
297 - (BOOL) query:(macdrv_query*)query timeout:(NSTimeInterval)timeout flags:(NSUInteger)flags
301 NSDate* timeoutDate = [NSDate dateWithTimeIntervalSinceNow:timeout];
304 type = (flags & WineQueryNoPreemptWait) ? QUERY_EVENT_NO_PREEMPT_WAIT : QUERY_EVENT;
305 event = macdrv_create_event(type, (WineWindow*)query->window);
306 event->query_event.query = macdrv_retain_query(query);
309 [self postEvent:event];
310 macdrv_release_event(event);
311 timedout = ![[WineApplicationController sharedController] waitUntilQueryDone:&query->done
313 processEvents:(flags & WineQueryProcessEvents) != 0];
314 return !timedout && query->status;
317 - (BOOL) query:(macdrv_query*)query timeout:(NSTimeInterval)timeout
319 return [self query:query timeout:timeout flags:0];
322 - (void) resetMouseEventPositions:(CGPoint)pos
326 pos = cgpoint_win_from_mac(pos);
330 for (event in events)
332 if (event->event->type == MOUSE_BUTTON)
334 event->event->mouse_button.x = pos.x;
335 event->event->mouse_button.y = pos.y;
337 else if (event->event->type == MOUSE_SCROLL)
339 event->event->mouse_scroll.x = pos.x;
340 event->event->mouse_scroll.y = pos.y;
347 - (BOOL) postHotKeyEvent:(UInt32)hotKeyNumber time:(double)time
349 NSDictionary* hotKeyDict = [hotKeysByMacID objectForKey:[NSNumber numberWithUnsignedInt:hotKeyNumber]];
354 event = macdrv_create_event(HOTKEY_PRESS, nil);
355 event->hotkey_press.vkey = [[hotKeyDict objectForKey:WineHotKeyVkeyKey] unsignedIntValue];
356 event->hotkey_press.mod_flags = [[hotKeyDict objectForKey:WineHotKeyModFlagsKey] unsignedIntValue];
357 event->hotkey_press.keycode = [[hotKeyDict objectForKey:WineHotKeyKeyCodeKey] unsignedIntValue];
358 event->hotkey_press.time_ms = [[WineApplicationController sharedController] ticksForEventTime:time];
360 [self postEvent:event];
362 macdrv_release_event(event);
365 return hotKeyDict != nil;
368 static OSStatus HotKeyHandler(EventHandlerCallRef nextHandler, EventRef theEvent, void* userData)
370 WineEventQueue* self = userData;
372 EventHotKeyID hotKeyID;
374 status = GetEventParameter(theEvent, kEventParamDirectObject, typeEventHotKeyID, NULL,
375 sizeof(hotKeyID), NULL, &hotKeyID);
378 if (hotKeyID.signature != WineHotKeySignature ||
379 ![self postHotKeyEvent:hotKeyID.id time:GetEventTime(theEvent)])
380 status = eventNotHandledErr;
386 - (void) unregisterHotKey:(unsigned int)vkey modFlags:(unsigned int)modFlags
388 NSNumber* vkeyNumber = [NSNumber numberWithUnsignedInt:vkey];
389 NSNumber* modFlagsNumber = [NSNumber numberWithUnsignedInt:modFlags];
390 NSArray* winIDPair = [NSArray arrayWithObjects:vkeyNumber, modFlagsNumber, nil];
391 NSDictionary* hotKeyDict = [hotKeysByWinID objectForKey:winIDPair];
394 EventHotKeyRef hotKeyRef = [[hotKeyDict objectForKey:WineHotKeyCarbonRefKey] pointerValue];
395 NSNumber* macID = [hotKeyDict objectForKey:WineHotKeyMacIDKey];
397 UnregisterEventHotKey(hotKeyRef);
398 [hotKeysByMacID removeObjectForKey:macID];
399 [hotKeysByWinID removeObjectForKey:winIDPair];
403 - (int) registerHotKey:(UInt32)keyCode modifiers:(UInt32)modifiers vkey:(unsigned int)vkey modFlags:(unsigned int)modFlags
405 static EventHandlerRef handler;
406 static UInt32 hotKeyNumber;
408 NSNumber* vkeyNumber;
409 NSNumber* modFlagsNumber;
411 EventHotKeyID hotKeyID;
412 EventHotKeyRef hotKeyRef;
413 NSNumber* macIDNumber;
414 NSDictionary* hotKeyDict;
418 EventTypeSpec eventType = { kEventClassKeyboard, kEventHotKeyPressed };
419 status = InstallApplicationEventHandler(HotKeyHandler, 1, &eventType, self, &handler);
422 ERR(@"InstallApplicationEventHandler() failed: %d\n", status);
424 return MACDRV_HOTKEY_FAILURE;
428 if (!hotKeysByMacID && !(hotKeysByMacID = [[NSMutableDictionary alloc] init]))
429 return MACDRV_HOTKEY_FAILURE;
430 if (!hotKeysByWinID && !(hotKeysByWinID = [[NSMutableDictionary alloc] init]))
431 return MACDRV_HOTKEY_FAILURE;
433 vkeyNumber = [NSNumber numberWithUnsignedInt:vkey];
434 modFlagsNumber = [NSNumber numberWithUnsignedInt:modFlags];
435 winIDPair = [NSArray arrayWithObjects:vkeyNumber, modFlagsNumber, nil];
436 if ([hotKeysByWinID objectForKey:winIDPair])
437 return MACDRV_HOTKEY_ALREADY_REGISTERED;
439 hotKeyID.signature = WineHotKeySignature;
440 hotKeyID.id = hotKeyNumber++;
442 status = RegisterEventHotKey(keyCode, modifiers, hotKeyID, GetApplicationEventTarget(),
443 kEventHotKeyExclusive, &hotKeyRef);
444 if (status == eventHotKeyExistsErr)
445 return MACDRV_HOTKEY_ALREADY_REGISTERED;
448 ERR(@"RegisterEventHotKey() failed: %d\n", status);
449 return MACDRV_HOTKEY_FAILURE;
452 macIDNumber = [NSNumber numberWithUnsignedInt:hotKeyID.id];
453 hotKeyDict = [NSDictionary dictionaryWithObjectsAndKeys:
454 macIDNumber, WineHotKeyMacIDKey,
455 vkeyNumber, WineHotKeyVkeyKey,
456 modFlagsNumber, WineHotKeyModFlagsKey,
457 [NSNumber numberWithUnsignedInt:keyCode], WineHotKeyKeyCodeKey,
458 [NSValue valueWithPointer:hotKeyRef], WineHotKeyCarbonRefKey,
460 [hotKeysByMacID setObject:hotKeyDict forKey:macIDNumber];
461 [hotKeysByWinID setObject:hotKeyDict forKey:winIDPair];
463 return MACDRV_HOTKEY_SUCCESS;
467 /***********************************************************************
470 * Run a block on the main thread synchronously.
472 void OnMainThread(dispatch_block_t block)
474 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
475 NSMutableDictionary* threadDict = [[NSThread currentThread] threadDictionary];
476 WineEventQueue* queue = [threadDict objectForKey:WineEventQueueThreadDictionaryKey];
477 dispatch_semaphore_t semaphore = NULL;
478 __block BOOL finished;
482 semaphore = dispatch_semaphore_create(0);
483 dispatch_retain(semaphore);
491 [queue signalEventAvailable];
494 dispatch_semaphore_signal(semaphore);
495 dispatch_release(semaphore);
503 MacDrvEvent* macDrvEvent;
507 (macDrvEvent = [queue getEventMatchingMask:event_mask_for_type(QUERY_EVENT)]))
509 queue->event_handler(macDrvEvent->event);
515 pool = [[NSAutoreleasePool alloc] init];
517 kevent(queue->kq, NULL, 0, &kev, 1, NULL);
523 dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
524 dispatch_release(semaphore);
531 /***********************************************************************
532 * macdrv_create_event_queue
534 * Register this thread with the application on the main thread, and set
535 * up an event queue on which it can deliver events to this thread.
537 macdrv_event_queue macdrv_create_event_queue(macdrv_event_handler handler)
539 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
540 NSMutableDictionary* threadDict = [[NSThread currentThread] threadDictionary];
542 WineEventQueue* queue = [threadDict objectForKey:WineEventQueueThreadDictionaryKey];
545 queue = [[[WineEventQueue alloc] initWithEventHandler:handler] autorelease];
548 if ([[WineApplicationController sharedController] registerEventQueue:queue])
549 [threadDict setObject:queue forKey:WineEventQueueThreadDictionaryKey];
556 return (macdrv_event_queue)queue;
559 /***********************************************************************
560 * macdrv_destroy_event_queue
562 * Tell the application that this thread is exiting and destroy the
563 * associated event queue.
565 void macdrv_destroy_event_queue(macdrv_event_queue queue)
567 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
568 WineEventQueue* q = (WineEventQueue*)queue;
569 NSMutableDictionary* threadDict = [[NSThread currentThread] threadDictionary];
571 [[WineApplicationController sharedController] unregisterEventQueue:q];
572 [threadDict removeObjectForKey:WineEventQueueThreadDictionaryKey];
577 /***********************************************************************
578 * macdrv_get_event_queue_fd
580 * Get the file descriptor whose readability signals that there are
581 * events on the event queue.
583 int macdrv_get_event_queue_fd(macdrv_event_queue queue)
585 WineEventQueue* q = (WineEventQueue*)queue;
589 /***********************************************************************
590 * macdrv_copy_event_from_queue
592 * Pull an event matching the event mask from the event queue and store
593 * it in the event record pointed to by the event parameter. If a
594 * matching event was found, return non-zero; otherwise, return 0.
596 * The caller is responsible for calling macdrv_release_event on any
597 * event returned by this function.
599 int macdrv_copy_event_from_queue(macdrv_event_queue queue,
600 macdrv_event_mask mask, macdrv_event **event)
602 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
603 WineEventQueue* q = (WineEventQueue*)queue;
605 MacDrvEvent* macDrvEvent = [q getEventMatchingMask:mask];
607 *event = macdrv_retain_event(macDrvEvent->event);
610 return (macDrvEvent != nil);
613 /***********************************************************************
614 * macdrv_create_event
616 macdrv_event* macdrv_create_event(int type, WineWindow* window)
620 event = calloc(1, sizeof(*event));
622 event->deliver = INT_MAX;
624 event->window = (macdrv_window)[window retain];
628 /***********************************************************************
629 * macdrv_retain_event
631 macdrv_event* macdrv_retain_event(macdrv_event *event)
633 OSAtomicIncrement32Barrier(&event->refs);
637 /***********************************************************************
638 * macdrv_release_event
640 * Decrements the reference count of an event. If the count falls to
641 * zero, cleans up any resources, such as allocated memory or retained
642 * objects, held by the event and deallocates it
644 void macdrv_release_event(macdrv_event *event)
646 if (OSAtomicDecrement32Barrier(&event->refs) <= 0)
648 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
653 if (event->im_set_text.text)
654 CFRelease(event->im_set_text.text);
656 case KEYBOARD_CHANGED:
657 CFRelease(event->keyboard_changed.uchr);
658 CFRelease(event->keyboard_changed.input_source);
661 case QUERY_EVENT_NO_PREEMPT_WAIT:
662 macdrv_release_query(event->query_event.query);
664 case WINDOW_GOT_FOCUS:
665 [(NSMutableSet*)event->window_got_focus.tried_windows release];
669 [(WineWindow*)event->window release];
676 /***********************************************************************
677 * macdrv_create_query
679 macdrv_query* macdrv_create_query(void)
683 query = calloc(1, sizeof(*query));
688 /***********************************************************************
689 * macdrv_retain_query
691 macdrv_query* macdrv_retain_query(macdrv_query *query)
693 OSAtomicIncrement32Barrier(&query->refs);
697 /***********************************************************************
698 * macdrv_release_query
700 void macdrv_release_query(macdrv_query *query)
702 if (OSAtomicDecrement32Barrier(&query->refs) <= 0)
706 case QUERY_DRAG_OPERATION:
707 if (query->drag_operation.pasteboard)
708 CFRelease(query->drag_operation.pasteboard);
710 case QUERY_DRAG_DROP:
711 if (query->drag_drop.pasteboard)
712 CFRelease(query->drag_drop.pasteboard);
714 case QUERY_PASTEBOARD_DATA:
715 if (query->pasteboard_data.type)
716 CFRelease(query->pasteboard_data.type);
719 [(WineWindow*)query->window release];
724 /***********************************************************************
725 * macdrv_set_query_done
727 void macdrv_set_query_done(macdrv_query *query)
729 macdrv_retain_query(query);
735 macdrv_release_query(query);
737 event = [NSEvent otherEventWithType:NSApplicationDefined
740 timestamp:[[NSProcessInfo processInfo] systemUptime]
743 subtype:WineApplicationEventWakeQuery
746 [NSApp postEvent:event atStart:TRUE];
753 /***********************************************************************
754 * macdrv_register_hot_key
756 int macdrv_register_hot_key(macdrv_event_queue q, unsigned int vkey, unsigned int mod_flags,
757 unsigned int keycode, unsigned int modifiers)
759 WineEventQueue* queue = (WineEventQueue*)q;
763 ret = [queue registerHotKey:keycode modifiers:modifiers vkey:vkey modFlags:mod_flags];
770 /***********************************************************************
771 * macdrv_unregister_hot_key
773 void macdrv_unregister_hot_key(macdrv_event_queue q, unsigned int vkey, unsigned int mod_flags)
775 WineEventQueue* queue = (WineEventQueue*)q;
778 [queue unregisterHotKey:vkey modFlags:mod_flags];