rhodes 2.2.6 → 2.3.0.beta.1

data/platform/bb/rhodes/src/rhomobile/mapview/MapTools.java

@@ -0,0 +1,79 @@
+package rhomobile.mapview;
+
+import j2me.lang.MathEx;
+
+public class MapTools {
+	
+	private static final double LN2 = 0.693147180559945;
+
+	//================================================================
+	// Mathematical functions
+	
+	// Sine of the a
+	public static double math_sin(double a) {
+		return Math.sin(a);
+	}
+	
+	// Arc sine of the a
+	public static double math_asin(double a) {
+		//return MathUtilities.asin(a);
+		return MathEx.asin(a);
+	}
+	
+	// Exponential (base E ~ 2.718281828) of a
+	public static double math_exp(double a) {
+		//return MathUtilities.exp(a);
+		return MathEx.exp(a);
+	}
+	
+	// Natural logarithm (base E ~ 2.718281828) of a
+	public static double math_ln(double a) {
+		//return MathUtilities.log(a);
+		return MathEx.log(a);
+	}
+	
+	// Binary logarithm (base 2) of a
+	public static double math_log2(double a) {
+		return math_ln(a)/LN2;
+	}
+	
+	// 2 raised to the power of n
+	public static long math_pow2(int n) {
+		long ret;
+		for (ret = 1; n > 0; --n)
+			ret *= 2;
+		return ret;
+	}
+	
+	public static double math_pow2d(int n) {
+		double ret = 1.0;
+		if (n < 0) {
+			for (; n < 0; ++n) {
+				ret /= 2;
+			}
+		}
+		if (n > 0) {
+			for (; n > 0; --n) {
+				ret *= 2;
+			}
+		}
+		return ret;
+	}
+	
+	public static double math_sqrt(double a) {
+		return MathEx.pow(a, 0.5);
+	}
+	
+	// Hyperbolic tangent of a
+	public static double math_tanh(double a) {
+		double epx = math_exp(a);
+		double emx = math_exp(-a);
+		return (epx - emx)/(epx + emx);
+	}
+	
+	// Hyperbolic arc tangent of a
+	public static double math_atanh(double a) {
+		return 0.5*math_ln((1 + a)/(1 - a));
+	}
+	
+}

data/platform/bb/rhodes/src/rhomobile/mapview/MapView.java

@@ -8,6 +8,7 @@ import net.rim.device.api.ui.UiApplication;
 import com.xruby.runtime.builtin.ObjectFactory;
 import com.xruby.runtime.builtin.RubyArray;
 import com.xruby.runtime.builtin.RubyHash;
+import com.xruby.runtime.builtin.RubyString;
 import com.xruby.runtime.lang.RubyBasic;
 import com.xruby.runtime.lang.RubyBlock;
 import com.xruby.runtime.lang.RubyClass;
@@ -64,6 +65,10 @@ public class MapView extends RubyBasic {
 			});
 		}
 		
+		public void onChildClosed() {
+			screen = null;
+		}
+		
 		public boolean closed() {
 			return screen == null;
 		}
@@ -80,12 +85,6 @@ public class MapView extends RubyBasic {
 			return screen.getCenterLongitude();
 		}
 		
-		public void childClosed() {
-			if (screen != null) {
-				screen = null;
-			}
-		}
-		
 	};
 	
 	private static Parent parent = new Parent();
@@ -102,6 +101,7 @@ public class MapView extends RubyBasic {
 				
 				RubyHash settingsHash = null;
 				RubyArray annotationsArray = null;
+				RubyValue providerValue = null;
 				
 				Hashtable settings = new Hashtable();
 				Vector annotations = new Vector();
@@ -128,6 +128,12 @@ public class MapView extends RubyBasic {
 										"Wrong 'annotations' type, should be Array");
 							annotationsArray = (RubyArray)value;
 						}
+						else if (strKey.equals("provider")) {
+							if (!(value instanceof RubyString))
+								throw new RubyException(RubyRuntime.ArgumentErrorClass,
+										"Wrong 'provider' type, should be String");
+							providerValue = value;
+						}
 					}
 				}
 				
@@ -189,10 +195,7 @@ public class MapView extends RubyBasic {
 									
 									String strHKey = hKey.toString();
 									if (strHKey.equals("center")) {
-										Annotation ann = new Annotation();
-										ann.type = "center";
-										ann.street_address = hValue.toString();
-										annotations.addElement(ann);
+										settings.put("center", hValue.toString());
 									}
 									else if (strHKey.equals("radius")) {
 										String strHValue = hValue.toString();
@@ -214,7 +217,6 @@ public class MapView extends RubyBasic {
 				if (annotationsArray != null) {
 					for (int i = 0; i != annotationsArray.size(); ++i) {
 						Annotation annotation = new Annotation();
-						annotation.type = "ann";
 						RubyValue val = annotationsArray.get(i);
 						if (!(val instanceof RubyHash))
 							throw new RubyException(RubyRuntime.ArgumentErrorClass,
@@ -274,7 +276,28 @@ public class MapView extends RubyBasic {
 					}
 				}
 				
-				parent.create("google", settings, annotations);
+				String providerId = "google";
+				
+				/*
+				if (providerHash != null) {
+					RubyArray arKeys = providerHash.keys();
+					RubyArray arValues = providerHash.values();
+					for (int i = 0; i != arKeys.size(); ++i) {
+						RubyValue key = arKeys.get(i);
+						RubyValue value = arValues.get(i);
+						if (key == null || value == null)
+							continue;
+						String strKey = key.toString();
+						
+						if (strKey.equals("id"))
+							providerId = value.toString().toLowerCase();
+					}
+				}
+				*/
+				if (providerValue != null)
+					providerId = providerValue.toString().toLowerCase();
+				
+				parent.create(providerId, settings, annotations);
 				
 				return RubyConstant.QNIL;
 			}

data/platform/bb/rhodes/src/rhomobile/mapview/MapViewParent.java

@@ -1,5 +1,6 @@
 package rhomobile.mapview;
 
 public interface MapViewParent {
-	public void childClosed();
+	public void onChildClosed();
+	public void close();
 }

data/platform/bb/rhodes/src/rhomobile/mapview/MapViewScreen.java

@@ -6,15 +6,21 @@ import java.util.Vector;
 
 import com.rho.RhoEmptyLogger;
 import com.rho.RhoLogger;
+import com.rho.rubyext.WebView;
 
 import net.rim.device.api.system.Application;
+import net.rim.device.api.system.Bitmap;
 import net.rim.device.api.system.Display;
 import net.rim.device.api.system.KeypadListener;
+import net.rim.device.api.ui.Color;
 import net.rim.device.api.ui.Graphics;
 import net.rim.device.api.ui.MenuItem;
-import net.rim.device.api.ui.container.MainScreen;
+//import net.rim.device.api.ui.TouchEvent;
+import net.rim.device.api.ui.UiApplication;
+//import net.rim.device.api.ui.container.MainScreen;
+import com.rho.RhoMainScreen;
 
-public class MapViewScreen extends MainScreen {
+public class MapViewScreen extends RhoMainScreen {
 	
 	private static final RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
 		new RhoLogger("MapViewScreen");
@@ -27,14 +33,20 @@ public class MapViewScreen extends MainScreen {
 	
 	private static final int MOVE_TIMEOUT_DOUBLING = 300;
 	
+	// Sensivity of annotations area (in pixels)
+	private static final int ANNOTATION_SENSIVITY_AREA_RADIUS = 64;
+	
 	private static final MapProvider[] providers = {
-		//new BBMapProvider(),
-		new GoogleMapProvider()
+		new GoogleMapProvider(),
+		new ESRIMapProvider()
 	};
 	
-	private MapViewParent parent;
+	private MapViewParent mapParent;
 	private MapProvider mapProvider;
 	private RhoMapField mapField;
+	private GeoCoding mapGeoCoding;
+	private Vector annotations = new Vector();
+	private Annotation mSelectedAnnotation;
 	
 	private int mode;
 	
@@ -42,6 +54,20 @@ public class MapViewScreen extends MainScreen {
 	private int prevDx = 0;
 	private int prevDy = 0;
 	
+	private Bitmap mapPinImage;
+	
+	private boolean mTouchDown = false;
+	private int mTouchX;
+	private int mTouchY;
+	
+	private class Rect
+	{
+		public int left, right, top, bottom;
+		
+		boolean isInside( int x, int y){ return x >= left && x <= right && y >= top && y<=bottom;}
+	};
+	Rect mCalloutRect;
+	
 	private class PanModeMenuItem extends MenuItem {
 		
 		private MapViewScreen screen;
@@ -74,15 +100,25 @@ public class MapViewScreen extends MainScreen {
 		super(DEFAULT_MENU | DEFAULT_CLOSE);
 		addMenuItem(new PanModeMenuItem(this, 0, 100));
 		addMenuItem(new ZoomModeMenuItem(this, 1, 100));
-		parent = p;
+		
+		mapPinImage = Bitmap.getBitmapResource("mappin.png");
+		
+		mapParent = p;
 		createMapProvider(providerName);
-		createUI(settings, annotations);
+
+		mapGeoCoding = new GoogleGeoCoding();
+		
+		createUI(settings);
+
+		this.annotations = annotations;
+		handleAnnotations();
 	}
 	
 	public void close() {
 		mapField.close();
+		mapGeoCoding.stop();
+		mapParent.onChildClosed();
 		super.close();
-		parent.childClosed();
 	}
 	
 	private void setMode(int m) {
@@ -102,7 +138,7 @@ public class MapViewScreen extends MainScreen {
 			throw new IllegalArgumentException("Unknown map provider: " + providerName);
 	}
 	
-	private void createUI(Hashtable settings, Vector annotations) {
+	private void createUI(Hashtable settings) {
 		synchronized (Application.getEventLock()) {
 			mapField = mapProvider.createMap();
 			mapField.setPreferredSize(Display.getWidth(), Display.getHeight());
@@ -138,12 +174,14 @@ public class MapViewScreen extends MainScreen {
 			mapField.setZoom(zoom);
 		}
 		
-		// Annotations
-		Enumeration e = annotations.elements();
-		while (e.hasMoreElements()) {
-			Annotation ann = (Annotation)e.nextElement();
-			if (ann != null)
-				mapField.addAnnotation(ann);
+		String center = (String)settings.get("center");
+		if (center != null) {
+			mapGeoCoding.resolve(center, new GeoCoding.OnGeocodingDone() {
+				public void onSuccess(double latitude, double longitude) {
+					mapField.moveTo(latitude, longitude);
+				}
+				public void onError(String description) {}
+			});
 		}
 		
 		mode = PAN_MODE;
@@ -151,6 +189,31 @@ public class MapViewScreen extends MainScreen {
 		mapField.redraw();
 	}
 	
+	private void handleAnnotations() {
+		Enumeration e = annotations.elements();
+		while (e.hasMoreElements()) {
+			final Annotation ann = (Annotation)e.nextElement();
+			if (ann == null)
+				continue;
+			if (ann.street_address == null && ann.coordinates == null)
+				continue;
+			if (ann.street_address != null && ann.street_address.length() > 0)
+				mapGeoCoding.resolve(ann.street_address, new GeoCoding.OnGeocodingDone() {
+					public void onSuccess(double latitude, double longitude) {
+						ann.coordinates = new Annotation.Coordinates(latitude, longitude);
+						UiApplication.getUiApplication().invokeLater(new Runnable() {
+							public void run() {
+								invalidate();
+							}
+						});
+					}
+					public void onError(String description) {
+						ann.street_address = null;
+					}
+				});
+		}
+	}
+	
 	/**
 	 * Handle trackball click events.
 	 * @see net.rim.device.api.ui.Screen#invokeAction(int)
@@ -175,8 +238,29 @@ public class MapViewScreen extends MainScreen {
 	protected void paint(Graphics graphics) {
 		super.paint(graphics);
 		
-		// TODO: draw overlays here
-		graphics.setColor(0x00000000); // Black
+		// Draw annotations
+		int pinWidth = mapPinImage.getWidth();
+		int pinHeight = mapPinImage.getHeight();
+		Enumeration e = annotations.elements();
+		while (e.hasMoreElements()) {
+			Annotation ann = (Annotation)e.nextElement();
+			if (ann == null || ann.coordinates == null)
+				continue;
+			
+			long x = mapField.toScreenCoordinateX(ann.coordinates.longitude);
+			if (x + pinWidth/2 < 0 || x - pinWidth/2 > mapField.getWidth())
+				continue;
+			long y = mapField.toScreenCoordinateY(ann.coordinates.latitude);
+			if (y + pinHeight/2 < 0 || y - pinHeight/2 > mapField.getHeight())
+				continue;
+			
+			graphics.drawBitmap((int)(x - pinWidth/2), (int)(y - pinHeight/2), pinWidth, pinHeight, mapPinImage, 0, 0);
+		}
+		
+		if (mSelectedAnnotation != null)
+			drawTitle(graphics, mSelectedAnnotation);
+		
+		graphics.setColor(Color.BLACK);
 		
 		// Draw current mode
 		String strMode  = null;
@@ -186,17 +270,103 @@ public class MapViewScreen extends MainScreen {
 			strMode = "Zoom mode";
 		
 		if (strMode != null) {
-			// Detect drawn text width
-			int x = mapField.getLeft() + mapField.getWidth()/2;
-			int y = mapField.getTop() + mapField.getHeight() + 20;
-			int tw = graphics.drawText(strMode, x, y);
+			// Detect drawn text size
+			int tw = graphics.getFont().getAdvance(strMode);
+			int th = graphics.getFont().getHeight();
 			// Actual drawing
-			x -= tw/2;
-			y -= 60;
+			int x = mapField.getLeft() + mapField.getWidth()/2 - tw/2;
+			int y = mapField.getTop() + mapField.getHeight() - th - 10; 
 			tw = graphics.drawText(strMode, x, y);
 		}
 	}
 	
+	private void fillRectWithRoundedCorners(Graphics graphics, int left, int top, int width, int height, int roundRadius) {
+		final int r = roundRadius;
+		final int d = r*2;
+		
+		final int right = left + width;
+		final int bottom = top + height;
+		
+		graphics.fillArc(left - r, top - r, d, d, 90, 90);
+		graphics.fillArc(left - r, bottom - r, d, d, 180, 90);
+		graphics.fillArc(right - r, bottom - r, d, d, 270, 90);
+		graphics.fillArc(right - r, top - r, d, d, 0, 90);
+		
+		graphics.fillRect(left - r, top, r, bottom - top);
+		graphics.fillRect(right, top, r, bottom - top);
+		graphics.fillRect(left, top - r, right - left, r);
+		graphics.fillRect(left, bottom, right - left, r);
+		
+		graphics.fillRect(left, top, right - left, bottom - top);
+	}
+	
+	private void drawRectWithRoundedCorners(Graphics graphics, int left, int top, int width, int height, int roundRadius) {
+		final int r = roundRadius;
+		final int d = r*2;
+		
+		final int right = left + width;
+		final int bottom = top + height;
+		
+		graphics.drawArc(left - r, top - r, d, d, 90, 90);
+		graphics.drawArc(left - r, bottom - r, d, d, 180, 90);
+		graphics.drawArc(right - r, bottom - r, d, d, 270, 90);
+		graphics.drawArc(right - r, top - r, d, d, 0, 90);
+		
+		graphics.drawLine(left - r, top, left - r, bottom);
+		graphics.drawLine(right + r, top, right + r, bottom);
+		graphics.drawLine(left, top - r, right, top - r);
+		graphics.drawLine(left, bottom + r, right, bottom + r);
+	}
+	
+	private void drawTitle(Graphics graphics, Annotation ann) 
+	{
+		int nLines = 1;
+		if ( ann.title.length()>0 && ann.subtitle.length()>0 )
+			nLines++;
+		
+		int width = graphics.getFont().getAdvance(ann.title);
+		int wSubtitle = graphics.getFont().getAdvance(ann.subtitle);
+		if ( wSubtitle > width )
+			width = wSubtitle;
+		
+		int height = graphics.getFont().getHeight()*nLines;
+		
+		int annX = (int)mapField.toScreenCoordinateX(ann.coordinates.longitude);
+		int annY = (int)mapField.toScreenCoordinateY(ann.coordinates.latitude);
+		
+		int left = annX - width/2;
+		int top = annY - height - 7*(mapPinImage.getHeight()/8);
+
+		mCalloutRect = new Rect();
+		mCalloutRect.left = left;
+		mCalloutRect.top = top;
+		mCalloutRect.right = left+width;
+		mCalloutRect.bottom = top+height;
+		
+		final int roundRadius = 6;
+		
+		// Shadow
+		graphics.setColor(Color.GRAY);
+		fillRectWithRoundedCorners(graphics, left + 4, top + 4, width, height, roundRadius);
+		// Actual shape
+		graphics.setColor(Color.WHITE);
+		fillRectWithRoundedCorners(graphics, left, top, width, height, roundRadius);
+		graphics.setColor(Color.BLACK);
+		drawRectWithRoundedCorners(graphics, left, top, width, height, roundRadius);
+		
+		graphics.setColor(Color.BLACK);
+		
+		if ( ann.title.length() > 0 )
+		{
+			graphics.drawText(ann.title, left, top);
+			top += height/2;
+		}
+		
+		if ( ann.subtitle.length() > 0 )
+			graphics.drawText(ann.subtitle, left, top);
+		
+	}
+	
 	private int calcDxSmooth(int dx, long curTime) {
 		int newDx;
 		if (curTime > prevMoveTime + MOVE_TIMEOUT_DOUBLING) {
@@ -247,23 +417,10 @@ public class MapViewScreen extends MainScreen {
 		return calcDySmooth(dy, curTime);
 	}
 	
-	protected boolean navigationMovement(int dx, int dy, int status, int time) {
-		if ((status & KeypadListener.STATUS_TRACKWHEEL) == 0 &&
-				(status & KeypadListener.STATUS_FOUR_WAY) == 0)
-			return false;
-
+	private void handleMove(int dx, int dy) {
 		if (mode == PAN_MODE) {
-			long curTime = System.currentTimeMillis();
-			int newDx = calcDx(dx, curTime);
-			int newDy = calcDy(dy, curTime);
-			
-			prevMoveTime = curTime;
-			
-			//int newDx = dx*10;
-			//int newDy = dy*10;
-			
-			//LOG.TRACE("Scroll by " + newDx + "," + newDy);
-			mapField.move(newDx, newDy);
+			//LOG.TRACE("Scroll by " + dx + "," + dy);
+			mapField.move(dx, dy);
 			mapField.redraw();
 		}
 		else if (mode == ZOOM_MODE && dy != 0) {
@@ -282,19 +439,129 @@ public class MapViewScreen extends MainScreen {
 			mapField.setZoom(newZoom);
 			mapField.redraw();
 		}
+	}
+	
+	private void handleClick(int x, int y) 
+	{
+		Annotation old_selectedAnnotation = mSelectedAnnotation;
+		if ( mSelectedAnnotation != null && mCalloutRect!=null && mCalloutRect.isInside(x, y) )
+		{
+			
+		}else
+			mSelectedAnnotation = getCurrentAnnotation(x, y);
+		
+		if (mSelectedAnnotation != null && old_selectedAnnotation != null && mSelectedAnnotation.equals(old_selectedAnnotation)) 
+		{
+			// We have clicked already selected annotation
+			WebView.navigate(mSelectedAnnotation.url);
+			mapParent.close();
+			mSelectedAnnotation = null;
+		}
+		invalidate();
+	}
+	
+	protected boolean navigationMovement(int dx, int dy, int status, int time) {
+		if ((status & KeypadListener.STATUS_TRACKWHEEL) == 0 &&
+				(status & KeypadListener.STATUS_FOUR_WAY) == 0)
+			return false;
+
+		if (mode == PAN_MODE) {
+			long curTime = System.currentTimeMillis();
+			dx = calcDx(dx, curTime);
+			dy = calcDy(dy, curTime);
+			prevMoveTime = curTime;
+		}
+		
+		handleMove(dx, dy);
+		
 		return true;
 	}
 	
 	protected boolean trackwheelClick(int status, int time) {
-		if (mapField.handleClick()) {
-			if (mapField.needToClose())
-				this.close();
+		int x = getWidth()/2;
+		int y = getHeight()/2;
+		handleClick(x, y);
+		return true;
+	}
+	
+	protected boolean onTouchClick(int x, int y)
+	{ 
+		handleClick(x, y);
+		return true; 
+	}
+	
+	protected boolean onTouchDown(int x, int y)
+	{ 
+		mTouchDown = true;
+		mTouchX = x;
+		mTouchY = y;
+		return false; 
+	}
+	
+	protected boolean onTouchUp(int x, int y)
+	{ 
+		mTouchDown = false;
+		return false; 
+	}
+	
+	protected boolean onTouchMove(int x, int y)
+	{ 
+		if (mTouchDown) 
+		{
+			int dx = x - mTouchX;
+			int dy = y - mTouchY;
+			if (mode == PAN_MODE) {
+				dx = -dx;
+				dy = -dy;
+			}
+			
+			handleMove(dx, dy);
+			
+			mTouchX = x;
+			mTouchY = y;
+			return true;
 		}
 		
-		invalidate();
-		return true;
+		return false; 
 	}
 	
+/*	
+	protected boolean touchEvent(TouchEvent message) {
+		switch (message.getEvent()) {
+		case TouchEvent.CLICK:
+			handleClick(message.getX(1), message.getY(1));
+			return true;
+		case TouchEvent.DOWN:
+			mTouchDown = true;
+			mTouchX = message.getX(1);
+			mTouchY = message.getY(1);
+			break;
+		case TouchEvent.UP:
+			mTouchDown = false;
+			break; 
+		case TouchEvent.MOVE:
+			if (mTouchDown) {
+				int x = message.getX(1);
+				int y = message.getY(1);
+				
+				int dx = x - mTouchX;
+				int dy = y - mTouchY;
+				if (mode == PAN_MODE) {
+					dx = -dx;
+					dy = -dy;
+				}
+				
+				handleMove(dx, dy);
+				
+				mTouchX = x;
+				mTouchY = y;
+				return true;
+			}
+		}
+		
+		return super.touchEvent(message);
+	}*/
+	
 	public double getCenterLatitude() {
 		return mapField.getCenterLatitude();
 	}
@@ -302,4 +569,29 @@ public class MapViewScreen extends MainScreen {
 	public double getCenterLongitude() {
 		return mapField.getCenterLongitude();
 	}
+	
+	private Annotation getCurrentAnnotation(int x, int y) {
+		// return current annotation (point we are under now)
+		Enumeration e = annotations.elements();
+		while (e.hasMoreElements()) {
+			Annotation a = (Annotation)e.nextElement();
+			Annotation.Coordinates coords = a.coordinates;
+			if (coords == null)
+				continue;
+			
+			long annX = mapField.toScreenCoordinateX(coords.longitude);
+			long annY = mapField.toScreenCoordinateY(coords.latitude);
+			annY -= mapPinImage.getHeight()/2;
+			
+			long deltaX = (long)x - annX;
+			long deltaY = (long)y - annY;
+			
+			double distance = MapTools.math_sqrt(deltaX*deltaX + deltaY*deltaY);
+			if ((int)distance > ANNOTATION_SENSIVITY_AREA_RADIUS)
+				continue;
+			
+			return a;
+		}
+		return null;
+	}
 }

data/platform/bb/rhodes/src/rhomobile/mapview/RhoMapField.java

@@ -8,14 +8,8 @@ public interface RhoMapField {
 	
 	public Field getBBField();
 	
-	public boolean handleClick();
-	
-	public boolean needToClose();
-	
 	public void redraw();
 	
-	public void addAnnotation(Annotation ann);
-	
 	public void setPreferredSize(int width, int height);
 	public void move(int dx, int dy);
 	public void moveTo(double latitude, double longitude);
@@ -41,5 +35,8 @@ public interface RhoMapField {
 	
 	public double getCenterLatitude();
 	public double getCenterLongitude();
+	
+	public long toScreenCoordinateX(double longitude);
+	public long toScreenCoordinateY(double latitude);
 
 }