@interface AppleEventDelegate : NSObject

- (void)handleOpenDocuments:(NSAppleEventDescriptor *)event withReplyEvent: (NSAppleEventDescriptor *)replyEvent;

@end

@implementation AppleEventDelegate

	NSTimer *timer;

	NSMutableArray *files;

- (void)handleOpenDocuments:(NSAppleEventDescriptor *)event withReplyEvent: (NSAppleEventDescriptor *)replyEvent {

	NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

    int count = [event numberOfItems];

    int index = 1;

 	if (!files) {

		files = [NSMutableArray arrayWithCapacity:count];

		[files retain];

	}

	for (index = 1; index<=count; index++) {

		NSAppleEventDescriptor *desc = [event descriptorAtIndex:index];

		if (desc) {

			desc = [desc coerceToDescriptorType:typeFSRef];

			CFURLRef url = CFURLCreateFromFSRef(kCFAllocatorDefault, [[desc data] bytes]);

			if (url) {

				NSString *pathName = (NSString *)CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);

				[files addObject:pathName];

				[pathName release];

				CFRelease(url);

			}

		}

	}

	if (!timer) {

		timer = [NSTimer scheduledTimerWithTimeInterval: 1.0

												 target: self

											   selector: @selector(handleTimer:)

											   userInfo: nil

												repeats: YES];

	}

	[pool release];

}

- (void) handleTimer: (NSTimer *) timer {

	NSObject *delegate = [[NSApplication sharedApplication] delegate];

	if (delegate != NULL && [delegate respondsToSelector: @selector(application:openFiles:)]) {

		[delegate performSelector:@selector(application:openFiles:)	withObject:[NSApplication sharedApplication] withObject:files];

		[files release];

		[timer invalidate];

	}

}

@end

#ifndef COCOA

static CFMutableArrayRef files;

static EventHandlerRef appHandler;

static int SWT_CLASS = 'SWT-';

static int SWT_OPEN_FILE_KIND = 1;

static int SWT_OPEN_FILE_PARAM = 'odoc';

#endif

void installAppleEventHandler();

int reuseWorkbench(_TCHAR* filePath) {

	installAppleEventHandler();

	return 0;

}

static pascal OSErr openDocumentsProc(const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon);

static OSStatus appleEventProc(EventHandlerCallRef inCaller, EventRef theEvent, void* inRefcon) {

	EventRecord eventRecord;

	Boolean release = false;

	EventQueueRef queue;

	queue = GetCurrentEventQueue();

	if (IsEventInQueue (queue, theEvent)) {

		RetainEvent (theEvent);

		release = true;

		RemoveEventFromQueue (queue, theEvent);

	}

	ConvertEventRefToEventRecord (theEvent, &eventRecord);

	AEProcessAppleEvent (&eventRecord);

	if (release) ReleaseEvent (theEvent);

	return noErr;

}

static void timerProc(EventLoopTimerRef timer, void *userData) {

	EventTargetRef target = GetApplicationEventTarget();

	CFIndex count = CFArrayGetCount  (files);

	int i;

	for (i=0; i<count; i++) {

		CFStringRef file = (CFStringRef) CFArrayGetValueAtIndex(files, i);

		EventRef event = NULL;

		CreateEvent (NULL, SWT_CLASS, SWT_OPEN_FILE_KIND, 0, kEventAttributeNone, &event);

		SetEventParameter (event, SWT_OPEN_FILE_PARAM, typeCFStringRef, sizeof(file), &file);

		OSStatus status = SendEventToEventTarget(event, target);

		ReleaseEvent(event);

		if (status == eventNotHandledErr) return;

	}

	CFRelease(files);

	RemoveEventLoopTimer(timer);

	RemoveEventHandler(appHandler);

	AERemoveEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(openDocumentsProc), false);

}

static pascal OSErr openDocumentsProc(const AppleEvent *theAppleEvent, AppleEvent *reply, long handlerRefcon) {

    AEDescList  docList;

    FSRef       theFSRef;

    long        index;

    long        count = 0;

    AEGetParamDesc(theAppleEvent, keyDirectObject, typeAEList, &docList);

	AECountItems(&docList, &count);

	for(index = 1; index <= count; index++) {

        AEGetNthPtr(&docList, index, typeFSRef, NULL, NULL, &theFSRef, sizeof(FSRef), NULL);

		CFURLRef url = CFURLCreateFromFSRef(kCFAllocatorDefault, &theFSRef);

		CFStringRef pathName = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);

		if (!files) {

			files = CFArrayCreateMutable(kCFAllocatorDefault, count, &kCFTypeArrayCallBacks);		

            InstallEventLoopTimer(GetMainEventLoop(), 1, 1, NewEventLoopTimerUPP(timerProc), NULL, NULL); 

		}

		CFArrayAppendValue(files, pathName);

		CFRelease(pathName);

		CFRelease(url);

    }

    AEDisposeDesc(&docList);

    return noErr;

}

void installAppleEventHandler() {

#ifdef COCOA

	NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

	AppleEventDelegate *appleEventDelegate = [[AppleEventDelegate alloc] init];

	[NSApplication sharedApplication];

	NSAppleEventManager *manager = [NSAppleEventManager sharedAppleEventManager];

	[manager setEventHandler:appleEventDelegate 

				 andSelector:@selector(handleOpenDocuments:withReplyEvent:) 

			   forEventClass:kCoreEventClass 

				  andEventID:kAEOpenDocuments];

//	[appleEventDelegate release];

	[pool release];

#else	

	EventTypeSpec kEvents[] = { {kEventClassAppleEvent, kEventAppleEvent} };

	InstallApplicationEventHandler(NewEventHandlerUPP(appleEventProc), GetEventTypeCount(kEvents), kEvents, 0, &appHandler);

	AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(openDocumentsProc), 0, false);

#endif

}

#define FILEPATH	  _T_ECLIPSE("-file")

static _TCHAR*  filePath	  = NULL;			/* file to open */

    { FILEPATH,		&filePath,		0,			2 },

	if (reuseWorkbench(filePath)) return 0;

extern int reuseWorkbench(_TCHAR* filePath);

#include <semaphore.h>

#include <fcntl.h>

static sem_t* 		mutex;

static Atom 		appAtom, launcherAtom;

static char*		file = NULL;

static int 			timerAttempts;

static struct sigaction	quitAction;

static struct sigaction	intAction;

static void catch_signal(int sig) {

	//catch signals, free the lock, reinstall the original

	//signal handlers and reraise the signal.

	sem_post(mutex);

	sem_close(mutex);

	sigaction(SIGINT, &intAction, NULL);

	sigaction(SIGQUIT, &intAction, NULL);

	raise(sig);

}

typedef  int (*LockFunc) ();

int executeWithLock (char *name, LockFunc func) {

	int 	result;

	struct 	sigaction	action;

	mutex = sem_open(name, O_CREAT|O_EXCL, S_IRWXU | S_IRWXG | S_IRWXO, 1);

	if (mutex == SEM_FAILED) {

		//create failed. Probably lock is already created so try opening the

		//existing lock.

		mutex = sem_open(name, 0);

	}

	if (mutex == SEM_FAILED) return -1; //this is an error.

	//install signal handler to free the lock if something bad

	//happens. sem_t is not freed automatically when a process ends.

	action.sa_handler = catch_signal;

	sigaction(SIGINT, &action, &intAction);

	sigaction(SIGQUIT, &action, &quitAction);

	//sem_t has no timeouts on wait. :-(

	sem_wait(mutex);

	result = func();

	sem_post(mutex);

	sem_close(mutex);

	//reinstall the original signal handlers

	sigaction(SIGINT, &intAction, NULL);

	sigaction(SIGQUIT, &quitAction, NULL);

	return result;

}

static int setAppWindowProperty() {

	Window appWindow;

	GdkWindow *propWindow;

	GdkAtom propAtom;

	char *propVal;

	//Look for the SWT window. If it's there, set a property on it.

	appWindow = XGetSelectionOwner(GDK_DISPLAY(), appAtom);

	if (appWindow) {

		propWindow = gdk_window_foreign_new (appWindow);

		propAtom = gdk_atom_intern("org.eclipse.swt.filePath.message", FALSE);

		//append a colon delimiter in case more than one file gets

		//appended to the app windows property.

		if (file != NULL) {

			propVal = malloc((_tcslen(file) + 2) * sizeof(char));

			_stprintf(propVal, _T_ECLIPSE("%s%s"), file, ":");

		} else {

			propVal = malloc(2);

			_stprintf(propVal, _T_ECLIPSE("%s"), ":");

		}

		gdk_property_change(propWindow, propAtom, propAtom, 8, GDK_PROP_MODE_APPEND, (guchar *)propVal, _tcslen(propVal));

		free(propVal);

		return 1;

	}

	return 0;

}

int setWindowProperty() {

	char	*mutexPrefix = "SWT_Window_";

	char 	*appName;

	int 	result;

	appName = malloc((_tcslen(mutexPrefix) + _tcslen(getOfficialName()) + 1) * sizeof(char));

	_stprintf(appName, _T_ECLIPSE("%s%s"), mutexPrefix, getOfficialName());

	result = executeWithLock(appName, setAppWindowProperty);

	XSync (GDK_DISPLAY (), False);

	free(appName);

	return result;

}

static gboolean timerProc (gpointer data) {

	//try to se the app window property. If unsuccessfull return

	//true to reschedule the timer. Try 60 times (1 minute) max.

	timerAttempts ++;

	return !setWindowProperty() && timerAttempts < 60;

}

void findWindow() {

	//try setWindowProperty every second until it succeeds

	//or a minute has passed.

	int count = 0;

	while (count < 60 && !setWindowProperty()) {

		count++;

		sleep(1);

	}

}

int createLauncherWindow() {

	Window 		window, launcherWindow;

	//check if a launcher window exists. If none exists, we know we are the

	//first and we should be launching the app.

	window = XGetSelectionOwner(GDK_DISPLAY(), launcherAtom);

	if (window == 0) {

		//create a launcher window that other processes can find.

		launcherWindow = XCreateWindow(GDK_DISPLAY(), RootWindow(GDK_DISPLAY(), DefaultScreen(GDK_DISPLAY())), -10, -10, 1, 1, 0, 0,

				InputOnly, CopyFromParent, (unsigned long) 0, (XSetWindowAttributes *)NULL);

		//for some reason Set and Get are both necessary. Set alone does nothing.

		XSetSelectionOwner(GDK_DISPLAY(), launcherAtom, launcherWindow, CurrentTime);

		XGetSelectionOwner(GDK_DISPLAY(), launcherAtom);

		//add a timeout to set the property on the apps window once the app is launched.

		if (file != NULL) {

			timerAttempts = 0;

			g_timeout_add(1000, timerProc, 0);

		}

		return 0;

	}

	return 1;

}

int reuseWorkbench(char* filePath) {

	char	*mutexPrefix = "SWT_Window_";

	char	*mutexSuffix = "_Launcher";

	char	*appName, *launcherName;

	int 	result = 0;

	if(initWindowSystem(&initialArgc, initialArgv, 1) != 0)

		return -1;

	file = filePath;

	//App name is defined in SWT as well. Values must be consistent.

	appName = malloc((_tcslen(mutexPrefix) + _tcslen(getOfficialName()) + 1) * sizeof(char));

	_stprintf(appName, _T_ECLIPSE("%s%s"), mutexPrefix, getOfficialName());

	appAtom = XInternAtom(GDK_DISPLAY(), appName, FALSE);

	free(appName);

	launcherName = malloc((_tcslen(mutexPrefix) + _tcslen(getOfficialName()) + _tcslen(mutexSuffix) + 1) * sizeof(char));

	_stprintf(launcherName, _T_ECLIPSE("%s%s%s"), mutexPrefix, getOfficialName(), mutexSuffix);

	launcherAtom = XInternAtom(GDK_DISPLAY(), launcherName, FALSE);

	//check if app is already running. Just set property if it is.

	if (setWindowProperty()) return 1;

	result = executeWithLock(launcherName, createLauncherWindow);

	free(launcherName);

	if (result == 1) {

		//The app is already being launched in another process.

		//Wait for it to complete, set the property on its window,

		//and exit this process.

		if (file != NULL) findWindow();

		result = 1;

	}

	return result;

}

#include <gdk/gdkx.h>

#include "eclipseShm.h"

/* Define local variables for communicating with running eclipse instance. */

static HANDLE	mutex;

static UINT		findWindowTimeout = 1000;

static UINT_PTR findWindowTimerId = 97;

static UINT		timerCount = 0;

static _TCHAR*	openFilePath;

static void CALLBACK findWindowProc(HWND hwnd, UINT message, UINT idTimer, DWORD dwTime);

static void sendOpenFileMessage(HWND window) {

	_TCHAR* id;

	UINT msg;

	int size = (_tcslen(openFilePath) + 1) * sizeof(_TCHAR);

	DWORD wParam;

#ifdef WIN64

	DWORDLONG lParam;

#else

	DWORD lParam;

#endif

	createSharedData(&id, size);

	setSharedData(id, openFilePath);

	msg = RegisterWindowMessage(_T("SWT_FILEOPEN"));

	_stscanf(id, _T_ECLIPSE("%lx_%lx"), &wParam, &lParam);

	SendMessage(window, msg, wParam, lParam);

	destroySharedData(id);

}

static int findSWTMessageWindow(int startTimer) {

	HWND window;

	_TCHAR *windowTitle, *windowPrefix, *name;

	int result = 0;

	windowPrefix = _T("SWT_Window_");

	name = getOfficialName();

	windowTitle = malloc((_tcslen(windowPrefix) + _tcslen(name) + 1) * sizeof(_TCHAR));

	_stprintf(windowTitle, _T_ECLIPSE("%s%s"), windowPrefix, name);

	window = FindWindow(NULL, windowTitle);

	free(windowTitle);

	if (window != NULL) {

		sendOpenFileMessage(window);

		ReleaseMutex(mutex);

		CloseHandle(mutex);

		result = 1;

	} else {

		if (startTimer) {

			initWindowSystem(0, NULL, 0);

			SetTimer( topWindow, findWindowTimerId, findWindowTimeout, findWindowProc );

		}

	}

	return result;

}

static void CALLBACK findWindowProc(HWND hwnd, UINT message, UINT idTimer, DWORD dwTime) {

	if (findSWTMessageWindow(0)) {

		KillTimer(hwnd, findWindowTimerId);

		return;

	}

	if (timerCount++ >= 60) {

		KillTimer(hwnd, findWindowTimerId);

		ReleaseMutex(mutex);

		CloseHandle(mutex);

	}

}

int reuseWorkbench(_TCHAR* filePath) {

	_TCHAR*   mutexPrefix = _T("SWT_Mutex_");

	_TCHAR*   mutexName, *name;

	DWORD 		result=0, lock;

	openFilePath = filePath;

	name = getOfficialName();

	mutexName = malloc((_tcslen(mutexPrefix) + _tcslen(name)  + 1) * sizeof(_TCHAR));

	_stprintf(mutexName, _T_ECLIPSE("%s%s"), mutexPrefix, name);

	mutex = CreateMutex(NULL, FALSE, mutexName);

	free(mutexName);

	if (mutex == NULL) return -1;

	//wait for up to 1 minute

	lock = WaitForSingleObject(mutex, 60*1000);

	if (lock == WAIT_OBJECT_0) {

		result = findSWTMessageWindow(1);

	} else {

		CloseHandle(mutex);

	}

	return result;

}