Sweden-Number/dlls/winemac.drv/cocoa_event.m

577 lines
16 KiB
Objective-C

/*
* MACDRV Cocoa event queue code
*
* Copyright 2011, 2012, 2013 Ken Thomases for CodeWeavers Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <sys/types.h>
#include <sys/event.h>
#include <sys/time.h>
#include <libkern/OSAtomic.h>
#include "macdrv_cocoa.h"
#import "cocoa_event.h"
#import "cocoa_app.h"
#import "cocoa_window.h"
static NSString* const WineEventQueueThreadDictionaryKey = @"WineEventQueueThreadDictionaryKey";
@interface MacDrvEvent : NSObject
{
@public
macdrv_event* event;
}
- (id) initWithEvent:(macdrv_event*)event;
@end
@implementation MacDrvEvent
- (id) initWithEvent:(macdrv_event*)inEvent
{
self = [super init];
if (self)
{
event = macdrv_retain_event(inEvent);
}
return self;
}
- (void) dealloc
{
if (event) macdrv_release_event(event);
[super dealloc];
}
@end
@implementation WineEventQueue
- (id) init
{
[self doesNotRecognizeSelector:_cmd];
[self release];
return nil;
}
- (id) initWithEventHandler:(macdrv_event_handler)handler
{
NSParameterAssert(handler != nil);
self = [super init];
if (self != nil)
{
struct kevent kev;
int rc;
fds[0] = fds[1] = kq = -1;
event_handler = handler;
events = [[NSMutableArray alloc] init];
eventsLock = [[NSLock alloc] init];
if (!events || !eventsLock)
{
[self release];
return nil;
}
if (pipe(fds) ||
fcntl(fds[0], F_SETFD, 1) == -1 ||
fcntl(fds[0], F_SETFL, O_NONBLOCK) == -1 ||
fcntl(fds[1], F_SETFD, 1) == -1 ||
fcntl(fds[1], F_SETFL, O_NONBLOCK) == -1)
{
[self release];
return nil;
}
kq = kqueue();
if (kq < 0)
{
[self release];
return nil;
}
EV_SET(&kev, fds[0], EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, 0);
do
{
rc = kevent(kq, &kev, 1, NULL, 0, NULL);
} while (rc == -1 && errno == EINTR);
if (rc == -1)
{
[self release];
return nil;
}
}
return self;
}
- (void) dealloc
{
[events release];
[eventsLock release];
if (kq != -1) close(kq);
if (fds[0] != -1) close(fds[0]);
if (fds[1] != -1) close(fds[1]);
[super dealloc];
}
- (void) signalEventAvailable
{
char junk = 1;
int rc;
do
{
rc = write(fds[1], &junk, 1);
} while (rc < 0 && errno == EINTR);
if (rc < 0 && errno != EAGAIN)
ERR(@"%@: got error writing to event queue signaling pipe: %s\n", self, strerror(errno));
}
- (void) postEventObject:(MacDrvEvent*)event
{
MacDrvEvent* lastEvent;
[eventsLock lock];
if ((event->event->type == MOUSE_MOVED ||
event->event->type == MOUSE_MOVED_ABSOLUTE) &&
(lastEvent = [events lastObject]) &&
(lastEvent->event->type == MOUSE_MOVED ||
lastEvent->event->type == MOUSE_MOVED_ABSOLUTE) &&
lastEvent->event->window == event->event->window &&
lastEvent->event->mouse_moved.drag == event->event->mouse_moved.drag)
{
if (event->event->type == MOUSE_MOVED)
{
lastEvent->event->mouse_moved.x += event->event->mouse_moved.x;
lastEvent->event->mouse_moved.y += event->event->mouse_moved.y;
}
else
{
lastEvent->event->type = MOUSE_MOVED_ABSOLUTE;
lastEvent->event->mouse_moved.x = event->event->mouse_moved.x;
lastEvent->event->mouse_moved.y = event->event->mouse_moved.y;
}
lastEvent->event->mouse_moved.time_ms = event->event->mouse_moved.time_ms;
}
else
[events addObject:event];
[eventsLock unlock];
[self signalEventAvailable];
}
- (void) postEvent:(macdrv_event*)inEvent
{
MacDrvEvent* event = [[MacDrvEvent alloc] initWithEvent:inEvent];
[self postEventObject:event];
[event release];
}
- (MacDrvEvent*) getEventMatchingMask:(macdrv_event_mask)mask
{
char buf[512];
int rc;
NSUInteger index;
MacDrvEvent* ret = nil;
/* Clear the pipe which signals there are pending events. */
do
{
rc = read(fds[0], buf, sizeof(buf));
} while (rc > 0 || (rc < 0 && errno == EINTR));
if (rc == 0 || (rc < 0 && errno != EAGAIN))
{
if (rc == 0)
ERR(@"%@: event queue signaling pipe unexpectedly closed\n", self);
else
ERR(@"%@: got error reading from event queue signaling pipe: %s\n", self, strerror(errno));
return nil;
}
[eventsLock lock];
index = 0;
while (index < [events count])
{
MacDrvEvent* event = [events objectAtIndex:index];
if (event_mask_for_type(event->event->type) & mask)
{
[[event retain] autorelease];
[events removeObjectAtIndex:index];
if (event->event->deliver == INT_MAX ||
OSAtomicDecrement32Barrier(&event->event->deliver) >= 0)
{
ret = event;
break;
}
}
else
index++;
}
[eventsLock unlock];
return ret;
}
- (void) discardEventsMatchingMask:(macdrv_event_mask)mask forWindow:(NSWindow*)window
{
NSIndexSet* indexes;
[eventsLock lock];
indexes = [events indexesOfObjectsPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop){
MacDrvEvent* event = obj;
return ((event_mask_for_type(event->event->type) & mask) &&
(!window || event->event->window == (macdrv_window)window));
}];
[events removeObjectsAtIndexes:indexes];
[eventsLock unlock];
}
- (BOOL) query:(macdrv_query*)query timeout:(NSTimeInterval)timeout processEvents:(BOOL)processEvents
{
macdrv_event* event;
NSDate* timeoutDate = [NSDate dateWithTimeIntervalSinceNow:timeout];
BOOL timedout;
event = macdrv_create_event(QUERY_EVENT, (WineWindow*)query->window);
event->query_event.query = macdrv_retain_query(query);
query->done = FALSE;
[self postEvent:event];
macdrv_release_event(event);
timedout = ![[WineApplicationController sharedController] waitUntilQueryDone:&query->done
timeout:timeoutDate
processEvents:processEvents];
return !timedout && query->status;
}
- (BOOL) query:(macdrv_query*)query timeout:(NSTimeInterval)timeout
{
return [self query:query timeout:timeout processEvents:FALSE];
}
- (void) resetMouseEventPositions:(CGPoint)pos
{
MacDrvEvent* event;
[eventsLock lock];
for (event in events)
{
if (event->event->type == MOUSE_BUTTON)
{
event->event->mouse_button.x = pos.x;
event->event->mouse_button.y = pos.y;
}
else if (event->event->type == MOUSE_SCROLL)
{
event->event->mouse_scroll.x = pos.x;
event->event->mouse_scroll.y = pos.y;
}
}
[eventsLock unlock];
}
/***********************************************************************
* OnMainThread
*
* Run a block on the main thread synchronously.
*/
void OnMainThread(dispatch_block_t block)
{
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
NSMutableDictionary* threadDict = [[NSThread currentThread] threadDictionary];
WineEventQueue* queue = [threadDict objectForKey:WineEventQueueThreadDictionaryKey];
__block BOOL finished;
if (!queue)
{
/* Fall back to synchronous dispatch without handling query events. */
dispatch_sync(dispatch_get_main_queue(), block);
[pool release];
return;
}
finished = FALSE;
OnMainThreadAsync(^{
block();
finished = TRUE;
[queue signalEventAvailable];
});
while (!finished)
{
MacDrvEvent* macDrvEvent;
struct kevent kev;
while (!finished &&
(macDrvEvent = [queue getEventMatchingMask:event_mask_for_type(QUERY_EVENT)]))
{
queue->event_handler(macDrvEvent->event);
}
if (!finished)
{
[pool release];
pool = [[NSAutoreleasePool alloc] init];
kevent(queue->kq, NULL, 0, &kev, 1, NULL);
}
}
[pool release];
}
/***********************************************************************
* macdrv_create_event_queue
*
* Register this thread with the application on the main thread, and set
* up an event queue on which it can deliver events to this thread.
*/
macdrv_event_queue macdrv_create_event_queue(macdrv_event_handler handler)
{
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
NSMutableDictionary* threadDict = [[NSThread currentThread] threadDictionary];
WineEventQueue* queue = [threadDict objectForKey:WineEventQueueThreadDictionaryKey];
if (!queue)
{
queue = [[[WineEventQueue alloc] initWithEventHandler:handler] autorelease];
if (queue)
{
if ([[WineApplicationController sharedController] registerEventQueue:queue])
[threadDict setObject:queue forKey:WineEventQueueThreadDictionaryKey];
else
queue = nil;
}
}
[pool release];
return (macdrv_event_queue)queue;
}
/***********************************************************************
* macdrv_destroy_event_queue
*
* Tell the application that this thread is exiting and destroy the
* associated event queue.
*/
void macdrv_destroy_event_queue(macdrv_event_queue queue)
{
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
WineEventQueue* q = (WineEventQueue*)queue;
NSMutableDictionary* threadDict = [[NSThread currentThread] threadDictionary];
[[WineApplicationController sharedController] unregisterEventQueue:q];
[threadDict removeObjectForKey:WineEventQueueThreadDictionaryKey];
[pool release];
}
/***********************************************************************
* macdrv_get_event_queue_fd
*
* Get the file descriptor whose readability signals that there are
* events on the event queue.
*/
int macdrv_get_event_queue_fd(macdrv_event_queue queue)
{
WineEventQueue* q = (WineEventQueue*)queue;
return q->fds[0];
}
/***********************************************************************
* macdrv_copy_event_from_queue
*
* Pull an event matching the event mask from the event queue and store
* it in the event record pointed to by the event parameter. If a
* matching event was found, return non-zero; otherwise, return 0.
*
* The caller is responsible for calling macdrv_release_event on any
* event returned by this function.
*/
int macdrv_copy_event_from_queue(macdrv_event_queue queue,
macdrv_event_mask mask, macdrv_event **event)
{
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
WineEventQueue* q = (WineEventQueue*)queue;
MacDrvEvent* macDrvEvent = [q getEventMatchingMask:mask];
if (macDrvEvent)
*event = macdrv_retain_event(macDrvEvent->event);
[pool release];
return (macDrvEvent != nil);
}
/***********************************************************************
* macdrv_create_event
*/
macdrv_event* macdrv_create_event(int type, WineWindow* window)
{
macdrv_event *event;
event = calloc(1, sizeof(*event));
event->refs = 1;
event->deliver = INT_MAX;
event->type = type;
event->window = (macdrv_window)[window retain];
return event;
}
/***********************************************************************
* macdrv_retain_event
*/
macdrv_event* macdrv_retain_event(macdrv_event *event)
{
OSAtomicIncrement32Barrier(&event->refs);
return event;
}
/***********************************************************************
* macdrv_release_event
*
* Decrements the reference count of an event. If the count falls to
* zero, cleans up any resources, such as allocated memory or retained
* objects, held by the event and deallocates it
*/
void macdrv_release_event(macdrv_event *event)
{
if (OSAtomicDecrement32Barrier(&event->refs) <= 0)
{
NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
switch (event->type)
{
case IM_SET_TEXT:
if (event->im_set_text.text)
CFRelease(event->im_set_text.text);
break;
case KEYBOARD_CHANGED:
CFRelease(event->keyboard_changed.uchr);
break;
case QUERY_EVENT:
macdrv_release_query(event->query_event.query);
break;
case WINDOW_GOT_FOCUS:
[(NSMutableSet*)event->window_got_focus.tried_windows release];
break;
}
[(WineWindow*)event->window release];
free(event);
[pool release];
}
}
/***********************************************************************
* macdrv_create_query
*/
macdrv_query* macdrv_create_query(void)
{
macdrv_query *query;
query = calloc(1, sizeof(*query));
query->refs = 1;
return query;
}
/***********************************************************************
* macdrv_retain_query
*/
macdrv_query* macdrv_retain_query(macdrv_query *query)
{
OSAtomicIncrement32Barrier(&query->refs);
return query;
}
/***********************************************************************
* macdrv_release_query
*/
void macdrv_release_query(macdrv_query *query)
{
if (OSAtomicDecrement32Barrier(&query->refs) <= 0)
{
switch (query->type)
{
case QUERY_DRAG_OPERATION:
if (query->drag_operation.pasteboard)
CFRelease(query->drag_operation.pasteboard);
break;
case QUERY_DRAG_DROP:
if (query->drag_drop.pasteboard)
CFRelease(query->drag_drop.pasteboard);
break;
case QUERY_PASTEBOARD_DATA:
if (query->pasteboard_data.type)
CFRelease(query->pasteboard_data.type);
break;
}
[(WineWindow*)query->window release];
free(query);
}
}
/***********************************************************************
* macdrv_set_query_done
*/
void macdrv_set_query_done(macdrv_query *query)
{
macdrv_retain_query(query);
OnMainThreadAsync(^{
NSEvent* event;
query->done = TRUE;
macdrv_release_query(query);
event = [NSEvent otherEventWithType:NSApplicationDefined
location:NSZeroPoint
modifierFlags:0
timestamp:[[NSProcessInfo processInfo] systemUptime]
windowNumber:0
context:nil
subtype:WineApplicationEventWakeQuery
data1:0
data2:0];
[NSApp postEvent:event atStart:TRUE];
});
}
@end