/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
module dwt.widgets.EventTable;

import dwt.widgets.Listener;
import dwt.widgets.Event;
import dwt.widgets.Listener;
import dwt.widgets.TypedListener;
import dwt.internal.SWTEventListener;
import dwt.dwthelper.System;
import dwt.SWT;
import dwt.internal.SWTEventListener;

/+
class EventTable{
    public void hook (int eventType, Listener listener) {
    }
    public void sendEvent (Event event) {}
    public bool hooks (int eventType) { return false; }
    public void unhook (int eventType, Listener listener) {}
    public void unhook (int eventType, SWTEventListener listener) {}
    public int size () { return 0;}
}
+/


/**
 * Instances of this class implement a simple
 * look up mechanism that maps an event type
 * to a listener.  Multiple listeners for the
 * same event type are supported.
 */

class EventTable {
	int [] types;
	Listener [] listeners;
	int level;

public void hook (int eventType, Listener listener) {
	if (types is null) types = new int [4];
	if (listeners is null) listeners = new Listener [4];
	int length = types.length, index = length - 1;
	while (index >= 0) {
		if (types [index] !is 0) break;
		--index;
	}
	index++;
	if (index is length) {
		int [] newTypes = new int [length + 4];
		System.arraycopy (types, 0, newTypes, 0, length);
		types = newTypes;
		Listener [] newListeners = new Listener [length + 4];
		SimpleType!(Listener).arraycopy (listeners, 0, newListeners, 0, length);
		listeners = newListeners;
	}
	types [index] = eventType;
	listeners [index] = listener;
}

public bool hooks (int eventType) {
	if (types is null) return false;
	for (int i=0; i<types.length; i++) {
		if (types [i] is eventType) return true;
	}
	return false;
}

public void sendEvent (Event event) {
	if (types is null) return;
	level += level >= 0 ? 1 : -1;
	try {
		for (int i=0; i<types.length; i++) {
			if (event.type is SWT.None) return;
			if (types [i] is event.type) {
				Listener listener = listeners [i];
				if (listener !is null) listener.handleEvent (event);
			}
		}
	} finally {
		bool compact = level < 0;
		level -= level >= 0 ? 1 : -1;
		if (compact && level is 0) {
			int index = 0;
			for (int i=0; i<types.length; i++) {
				if (types [i] !is 0) {
					types [index] = types [i];
					listeners [index] = listeners [i];
					index++;
				}
			}
			for (int i=index; i<types.length; i++) {
				types [i] = 0;
				listeners [i] = null;
			}
		}
	}
}

public int size () {
	if (types is null) return 0;
	int count = 0;
	for (int i=0; i<types.length; i++) {
		if (types [i] !is 0) count++;
	}
	return count;
}

void remove (int index) {
	if (level is 0) {
		int end = types.length - 1;
		System.arraycopy (types, index + 1, types, index, end - index);
		SimpleType!(Listener).arraycopy (listeners, index + 1, listeners, index, end - index);
		index = end;
	} else {
		if (level > 0) level = -level;
	}
	types [index] = 0;
	listeners [index] = null;
}

public void unhook (int eventType, Listener listener) {
	if (types is null) return;
	for (int i=0; i<types.length; i++) {
		if (types [i] is eventType && listeners [i] is listener) {
			remove (i);
			return;
		}
	}
}

public void unhook (int eventType, SWTEventListener listener) {
	if (types is null) return;
	for (int i=0; i<types.length; i++) {
		if (types [i] is eventType) {
			if ( auto typedListener = cast(TypedListener) listeners [i] ) {
				if (typedListener.getEventListener () is listener) {
					remove (i);
					return;
				}
			}
		}
	}
}

}