elemental.events.EventListener Java Examples

/**
 * Creates a connect to the plugin at the address. Calls the callback once the connection succeeds.
 *
 * @param address
 *         The address to connect to, may include the port
 * @param handler
 *         The handler to handle received events
 * @param callback
 *         The Runnable to call once the connection is completed
 */
public Connection(String address, ServerPacketHandler handler, final Runnable callback) {
    this.address = address;
    this.handler = handler;
    webSocket = Browser.getWindow().newWebSocket("ws://" + address + "/server/ws");
    // Work in binary instead of strings
    webSocket.setBinaryType("arraybuffer");
    webSocket.setOnopen(new EventListener() {
        @Override
        public void handleEvent(Event evt) {
            System.out.println("Connected to server");
            send(new InitConnection());
            if (callback != null) callback.run();
        }
    });
    webSocket.setOnmessage(this);
}
 

private static <T, V> void compareApplyRemove(Node element, T name, V value, What what) {
	// Fluent.console.log("removing " + name + " with " + value);
	switch (what) {
	case Attributes:
		switch ((Att) name) {
		case checked:
			((InputElement) element).setChecked(false);
			break;
		case value:
			((InputElement) element).setValue(null);
			break;
		case selectedIndex:
			// nothing to do
			// ((SelectElement) element).);
			break;
		default:
			((Element) element).removeAttribute(((Att) name).nameValid());
			break;
		}
		break;
	case Styles:
		((Element) element).getStyle().removeProperty(((Css) name).nameValid());
		break;
	case Listeners:
		element.removeEventListener((String) name, (EventListener) value);
		break;
	default:
		throw new IllegalArgumentException("Not possible");
	}
}
 

private static <T, V> void compareApplySet(Node element, T name, V value, What what) {
	// Fluent.console.log("setting " + name + " with " + value);
	switch (what) {
	case Attributes:
		switch ((Att) name) {
		case checked:
			((InputElement) element).setChecked(true);
			break;
		case value:
			((InputElement) element).setValue((String) value);
			break;
		case selectedIndex:
			((SelectElement) element).setSelectedIndex(Integer.parseInt((String) value));
		default:
			((Element) element).setAttribute(((Att) name).nameValid(), (String) value);
			break;
		}
		break;
	case Styles:
		((Element) element).getStyle().setProperty(((Css) name).nameValid(), (String) value);
		break;
	case Listeners:
		element.addEventListener((String) name, (EventListener) value);
		break;
	default:
		throw new IllegalArgumentException("Not possible");
	}
}
 

/**
 * Add or remove (by value null) an eventlistener.
 * 
 * @param name
 *            the name that should be listening too
 * @param value
 *            the low level eventlistener
 * @return this
 */
public Fluent listen(String name, EventListener value) {
	if (listeners == null) {
		listeners = new TreeMap<>();
	}
	EventListener oldValue = listeners.get(name);

	if (value != null) { // set it

		// if does not exist yet or has a different value
		if (oldValue == null || !oldValue.equals(value)) {
			listeners.put(name, value);
			if (element != null) { // if visual
				element.addEventListener(name, value);
			}
		}

	} else { // remove it

		// if old value exists
		if (oldValue != null) {
			listeners.remove(name);
			if (element != null) { // if visual
				element.removeEventListener(name, oldValue);
			}
		}
	}
	return (Fluent) this;
}
 

/**
 * Triggers an async request to load the chunk. The chunk is forwarded to all workers to be processed before being returned to the client
 *
 * @param x
 *         The chunk x position
 * @param z
 *         The chunk z position
 */
private void loadChunk(final int x, final int z) {
    final String key = chunkKey(x, z);
    if (loadingChunks.contains(key) || isLoaded(x, z)) {
        return;
    }
    final XMLHttpRequest xmlHttpRequest = Browser.getWindow().newXMLHttpRequest();
    xmlHttpRequest.open("POST", "http://" + mapViewer.getConnection().getAddress() + "/server/chunk", true);
    xmlHttpRequest.setResponseType("arraybuffer");
    xmlHttpRequest.setOnreadystatechange(new EventListener() {
        @Override
        public void handleEvent(Event evt) {
            if (xmlHttpRequest.getReadyState() != 4) return;
            if (xmlHttpRequest.getStatus() == 200) {
                // Got the chunk successfully, move on
                // to processing the chunk
                ArrayBuffer data = (ArrayBuffer) xmlHttpRequest.getResponse();
                ViewBuffer dataStream = JavascriptViewBuffer.create(data, false, 0, data.getByteLength());
                if (dataStream.getInt8(0) == 0) {
                    loadingChunks.remove(key);
                    return;
                }
                UByteBuffer sendableData = JavascriptUByteBuffer.create(data, 0, data.getByteLength());
                mapViewer.getWorkerPool().sendMessage(new ChunkLoadMessage(x, z, sendableData), true);
            } else {
                // Request failed (e.g. non-existing chunk)
                // remove from the loadingChunks set so
                // that it may be tried again
                loadingChunks.remove(key);
            }
        }
    });
    xmlHttpRequest.send(key);
}
 

/**
 * Adds the given event listener to the the last added element.
 */
public Builder on(EventType type, EventListener listener) {
    assertCurrent();

    Element element = elements.peek().element;
    type.register(element, listener);
    return this;
}
 

public final native void onopen(EventListener listener)/*-{
this.onopen = @elemental.js.dom.JsElementalMixinBase::getHandlerFor(Lelemental/events/EventListener;)(listener);		
}-*/;
 

public final native void onclose(EventListener listener) /*-{
this.onclose = @elemental.js.dom.JsElementalMixinBase::getHandlerFor(Lelemental/events/EventListener;)(listener);
}-*/;
 

public final native void onerror(EventListener listener) /*-{
this.onerror = @elemental.js.dom.JsElementalMixinBase::getHandlerFor(Lelemental/events/EventListener;)(listener);
}-*/;
 

private native void setOnMessage(EventListener eventListener)/*-{
    self.onmessage = @elemental.js.dom.JsElementalMixinBase::getHandlerFor(Lelemental/events/EventListener;)(eventListener);
}-*/;
 

/**
 * Get the eventlistener for the given eventname.
 * 
 * @param event
 *            event name
 * @return the event listener
 */
public EventListener listen(String event) {
	if (listeners == null) {
		return null;
	}
	return listeners.get(event);
}
 

/**
 * A convenient helper method for this event listener.
 * 
 * @param listener
 *            the listener
 * @return this
 */
public Fluent load(EventListener listener) {
	return listen("LOAD", listener);
}
 

/**
 * A convenient helper method for this event listener.
 * 
 * @param listener
 *            the listener
 * @return this
 */
public Fluent focus(EventListener listener) {
	return listen(Event.FOCUS, listener);
}
 

void register(Element element, EventListener listener);