package com.peterfranza.gwt.mobileui.client.widgets;
 
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.user.client.ui.ScrollPanel;
 
/**
 * 
 * @author peter.franza
 *
 */
public class TouchScrollPanel extends ScrollPanel {
 
	private int initialTouchX = -1;
	private int initialTouchY = -1;
	private int initialHorizontalOffset;
	private int initialVerticalOffset;
	private boolean moved = false;
 
	{
		attachTouch(getElement());
	}
 
	public TouchScrollPanel(VerticalPanel body) {
		super(body);
	}
 
	private native void attachTouch(JavaScriptObject ele) /*-{	
		var ref = this;
		ele.ontouchstart = function(evt){
	  		evt.preventDefault();	
	  		ref.@com.orci.datagateway.OpenIMWeb.mobile.client.widgets.TouchScrollPanel::setInitialTouch(II)(evt.touches[0].screenX, evt.touches[0].screenY);
		}	
		ele.ontouchmove = function(evt){
	  		evt.preventDefault();	
	  		ref.@com.orci.datagateway.OpenIMWeb.mobile.client.widgets.TouchScrollPanel::doScroll(II)(evt.touches[0].screenX, evt.touches[0].screenY);
		}		
		ele.ontouchend = function(evt){
			evt.preventDefault();
			ref.@com.orci.datagateway.OpenIMWeb.mobile.client.widgets.TouchScrollPanel::setEndTouch(II)(evt.pageX, evt.pageY);
		}		
	}-*/;
 
	private native void fireClick(int x, int y) /*-{	
		var theTarget = $doc.elementFromPoint(x, y);
		if (theTarget.nodeType == 3) theTarget = theTarget.parentNode;
 
		var theEvent = $doc.createEvent('MouseEvents');
		theEvent.initEvent('click', true, true);
		theTarget.dispatchEvent(theEvent);
	}-*/;
 
 
	@SuppressWarnings("unused")
	private void setInitialTouch(int x, int y) {
		initialVerticalOffset = getScrollPosition();
		initialHorizontalOffset = getHorizontalScrollPosition();
 
		initialTouchX = x;
		initialTouchY = y;
		moved = false;
 
	}
 
	@SuppressWarnings("unused")
	private void doScroll(int x, int y) {
		if (initialTouchY != -1) {
			moved = true;
			int vDelta = initialTouchY - y;
			int hDelta = initialTouchX - x;
			setScrollPosition(vDelta + initialVerticalOffset);
			setHorizontalScrollPosition(hDelta + initialHorizontalOffset);
		}
	}
 
	@SuppressWarnings("unused")
	private void setEndTouch(int x, int y) {
		if (!moved) {
			fireClick(x, y);
		}
		initialTouchX = -1;
		initialTouchY = -1;
	} 
}

package com.peterfranza.gwt.cle.client;
 
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Element;
import com.google.gwt.user.client.ui.RootPanel;
 
public class JSONPLoader {
 
	private LoaderCallback callback;
 
	public void load(String jsonUrl, LoaderCallback callback) {
		this.callback = callback;
		String callbackString = "jsonLoad_" + 
			DOM.createUniqueId().replace("-", "_") + "_callback";
		String url = jsonUrl + (jsonUrl.contains("?") ? "&" : "?") 
			+ "_callback=" + callbackString;
		publishCallbackMethod(callbackString);
		Element fr1 = DOM.createElement("script");		
		fr1.setAttribute("src", url);
		RootPanel.get().getElement().appendChild(fr1);
 
	}
 
	private native void publishCallbackMethod(String callback) /*-{
		var ptr = this;
  		$wnd[callback] = function(obj) {
  			ptr.@com.peterfranza.gwt.cle.client.JSONPLoader::loadremotedata(Ljava/lang/String;Lcom/google/gwt/core/client/JavaScriptObject;)(callback, obj);
  		};
	}-*/;
 
	@SuppressWarnings("unused")
	private void loadremotedata(String cbp, JavaScriptObject obj) {
	  callback.onLoad(new JSONObject(obj));
	}
 
	public interface LoaderCallback {
		void onLoad(JSONObject object);
	}
 
}

JSONPLoader loader = new JSONPLoader();
loader.load("http://pipes.yahoo.com/pipes/pipe.run?_id=CPreCvz42xG4eaOWouNLYQ&_render=json&location=madison&section=mcy", new LoaderCallback() {
 
	@Override
	public void onLoad(JSONObject object) {
		Window.alert("loaded " + object.size());
	}
});

LoadModule dav_svn_module modules/mod_dav_svn.so
LoadModule authz_svn_module modules/mod_authz_svn.so
 
LDAPConnectionTimeout 15
 
LDAPSharedCacheSize 200000
LDAPCacheEntries 1024
LDAPCacheTTL 600
LDAPOpCacheEntries 1024
LDAPOpCacheTTL 600
 
  <Location /server/cache-info>
   SetHandler ldap-status
  </Location>
 
  <Location /svn>
    DAV svn
    SVNPath /subversion/repos
    SVNListParentPath on
 
    AuthzSVNAccessFile /subversion/svnauthorz
    Satisfy Any
    AuthType Basic
    AuthName "Members Only"
    AuthzLDAPAuthoritative off
    AuthBasicProvider ldap
    AuthLDAPBindDN "svn.user@domain.com"
    AuthLDAPBindPassword "svn.user.password"
    AuthLDAPURL "ldap://<ldapserverip>/DC=domain,DC=com?sAMAccountName?sub?(objectClass=user)"
    Require valid-user
 </Location>

[Fri Apr 30 09:21:46 2010] [warn] [client 192.168.100.105] [22578] auth_ldap authenticate: user peter.franza authentication failed; URI /svnad/projects/ [ldap_search_ext_s() for user failed][Operations error], referer: http://svn/svnad/projects/

REFERRALS off

public class Replicator {
	private final AsyncDatagramServer aserver;
 
	public Replicator(final int port, 
			final Collection<DataSinkPoint> endPoints) throws Exception {
		aserver = new AsyncDatagramServer(port, 
				new AsyncDatagramServer.AsyncDatagramServerListener() {
 
			@Override
			public void recieveDatagram(ByteBuffer buffer) {
				try {
					for(final DataSinkPoint d: endPoints) {
						d.send(buffer.duplicate());
					}
				} catch (final Exception e) {
					e.printStackTrace();
				}
			}
		});
	}
 
	private static class AsyncDatagramServer {
 
		private boolean running = true;
 
		public AsyncDatagramServer(final int port, 
				final AsyncDatagramServerListener listener) throws Exception {
 
			new Thread(){
 
				@Override
				public void run() {
					try {
						startSocket(port, listener);
					} catch (final Exception e) {
						throw new RuntimeException(e);
					}
				}
 
			}.start();
 
		}
 
		public interface AsyncDatagramServerListener {
			void recieveDatagram(ByteBuffer buffer);
		}
 
		public void shutdown() {
			running = false;
		}
 
		private void startSocket(final int port,
				AsyncDatagramServerListener listener) throws IOException,
				SocketException, ClosedChannelException, Exception {
			DatagramChannel serverChannel = DatagramChannel.open();
			Selector selector = Selector.open();
			DatagramSocket sock = serverChannel.socket();
			sock.setReuseAddress(true);
			sock.bind (new InetSocketAddress (port));
			serverChannel.configureBlocking (false);
			serverChannel.register(selector, SelectionKey.OP_READ);
			ByteBuffer buffer = ByteBuffer.allocate(2048);
 
			while (running) {
				if(selector.select(500) > 0) {
					processData(listener, selector, buffer);
				}
			}
 
			selector.close();
			serverChannel.close();
		}
 
		private void processData(AsyncDatagramServerListener listener,
				Selector selector, ByteBuffer buffer) throws Exception {
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
 
			while (it.hasNext()) {
				final SelectionKey key = it.next();
 
				if (key.isReadable()) {
					DatagramChannel channel = 
						(DatagramChannel) key.channel();
					buffer.clear();
					if (channel.receive(buffer) != null) {
						buffer.flip();
						listener.recieveDatagram(buffer.duplicate());
					}
				}
				it.remove();
			}
		}
 
 
 
	}
 
	public void shutdown() {
		aserver.shutdown();
	}
 
	public interface DataSinkPoint {
		void send(ByteBuffer buffer) throws IOException;
	}
 
	private static class DataSinkPointImpl implements DataSinkPoint {
		private final DatagramSocket socket;
 
		public DataSinkPointImpl(SocketAddress address) throws Exception {
			socket = new DatagramSocket();
			socket.connect(address);
		}
 
		@Override
		public void send(ByteBuffer buffer) throws IOException {
			socket.send(new DatagramPacket(buffer.array(),
					0, buffer.limit()));
		}
 
	}
 
}

public static void main(String[] args) throws Exception {
	Collection<DataSinkPoint> endPoints = new ArrayList<DataSinkPoint>();
	for(int i = 4000; i < 5000; i++) {
		endPoints.add(new DataSinkPointImpl(
				new InetSocketAddress("127.0.0.1", i)));
	}
 
	final Replicator r = new Replicator(3000, endPoints);
	Thread.sleep(5000);
	r.shutdown();
	System.out.println("done.");
}

import java.io.IOException;
import java.io.InputStream;
 
public class BitArrayInputStream {
 
	private final BitDirection direction;
	private final InputStream inputStream;
	private int currentByte;
	private int currentPosition = -1;
 
	public BitArrayInputStream(InputStream inputStream) {
		this(BitDirection.HIGHLOW, inputStream);
	}
 
	public BitArrayInputStream(BitDirection direction,
			InputStream inputStream) {
		this.inputStream = inputStream;
		this.direction = direction;
	}
 
	public int readBit() throws IOException {
		if(currentPosition == -1) {
			currentByte = inputStream.read();
			if(currentByte == -1) {
				return -1;
			}
			currentPosition = 0;
		}
 
		int c = -1;
 
		if(direction.equals(BitDirection.HIGHLOW)) {
			c = (currentByte << currentPosition & 0x80) >> 7;
		} else {
			c = currentByte >> currentPosition & 0x1;
		}
 
		currentPosition += 1;
		if(currentPosition >= 8) {
			currentPosition = -1;
		}
 
		return c;
	}
 
	public static enum BitDirection {HIGHLOW, LOWHIGH}
 
}

public class BitArrayInputStreamTest extends TestCase {
 
	public void testInit() throws Exception {
		assertNotNull(new BitArrayInputStream(null));
	}
 
	public void testReadBits() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(
				new ByteArrayInputStream(new byte[] {(byte) 0xA3}));
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
 
	}
 
	public void testReadBitsLowHigh() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(BitDirection.LOWHIGH,
				new ByteArrayInputStream(new byte[] {(byte) 0xA3}));
 
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
 
 
	}
 
	public void testReadBitsEnd() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(
				new ByteArrayInputStream(new byte[] {(byte) 0xA3}));
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
		assertEquals(-1, i.readBit());
 
 
	}
 
	public void testReadBitsMultiByte() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(
				new ByteArrayInputStream(
                                  new byte[] {(byte) 0xA3, (byte) 0xB6}));
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
	}
 
}

public static String convertIntegerToIp(long ip) {
     StringBuffer buf = new StringBuffer();
      buf.append(((ip >> 24 ) & 0xFF)).append(".")
          .append(((ip >> 16 ) & 0xFF)).append(".")
          .append(((ip >>  8 ) & 0xFF)).append(".")
          .append(( ip        & 0xFF));		
      return buf.toString();
}
 
 public static long convertStringToIntegerIp(String ip) {
     String[] parts = ip.split("\\.");
     return (Long.valueOf(parts[0]) << 24) +
              (Long.valueOf(parts[1]) << 16) +
              (Long.valueOf(parts[2]) << 8) +
              (Long.valueOf(parts[3]));
 }

package com.peterfranza.synchro;
 
public class AsyncExecutor {
 
	private static java.util.concurrent.ExecutorService pool = 
		java.util.concurrent.Executors.newCachedThreadPool();
 
	public synchronized static void asyncExecuteTask(
			final Runnable task, 
			final long timeout, 
			final AsyncExecutorCallback callback) {
		pool.execute(new Runnable() {
 
			@Override
			public void run() {
				java.util.concurrent.Future<AsyncExecutorCallback> marker = 
					pool.submit(task, callback);
				try {
					marker.get(timeout, 
						java.util.concurrent.TimeUnit.MILLISECONDS)
						.taskCompleted();
				} catch (Exception e) {
                                        marker.cancel(true);
					callback.taskFailed();
				} 
			}
 
		});
	}
 
	public interface AsyncExecutorCallback {
		void taskCompleted();
		void taskFailed();
	}
 
}

package com.peterfranza.synchro;
 
import com.peterfranza.synchro.AsyncExecutor.AsyncExecutorCallback;
 
public class Usage {
 
	public static void main(String[] args) {
 
		AsyncExecutorCallback callback = new AsyncExecutorCallback() {
 
			@Override
			public void taskCompleted() {
				System.out.println("Task Completed");
			}
 
			@Override
			public void taskFailed() {
				System.out.println("Task Failed");
			}
 
		};
 
		AsyncExecutor.asyncExecuteTask(new QuickTask(), 1000, callback);
		AsyncExecutor.asyncExecuteTask(new LongTask(), 1000, callback);
	}
 
 
	private static class QuickTask implements Runnable {
		public void run() {
			try {Thread.sleep(10);}
			catch(Exception e){}
		}		
	}
 
	private static class LongTask implements Runnable {
		public void run() {
			try {Thread.sleep(100000);}
			catch(Exception e){}
		}		
	}
}