rhodes 3.3.3.beta.1 → 3.3.3.beta.2

data/platform/bb/rhodes/src/com/rho/rubyext/SignatureCapture.java

@@ -0,0 +1,314 @@
+package com.rho.rubyext;
+
+import com.rho.RhoEmptyLogger;
+import com.rho.RhoLogger;
+import com.rho.RhodesApp;
+import com.rho.db.DBAdapter;
+import com.rho.file.RhoFile;
+import com.xruby.runtime.builtin.RubyHash;
+import com.xruby.runtime.lang.RubyBlock;
+import com.xruby.runtime.lang.RubyID;
+import com.xruby.runtime.lang.RubyModule;
+import com.xruby.runtime.lang.RubyConstant;
+import com.xruby.runtime.lang.RubyException;
+import com.xruby.runtime.lang.RubyTwoArgMethod;
+import com.xruby.runtime.lang.RubyValue;
+
+import net.rim.device.api.i18n.SimpleDateFormat;
+import net.rim.device.api.system.Bitmap;
+import net.rim.device.api.system.Display;
+import net.rim.device.api.system.EncodedImage;
+import net.rim.device.api.ui.Graphics;
+import net.rim.device.api.ui.MenuItem;
+import net.rim.device.api.ui.TouchEvent;
+import net.rim.device.api.ui.TouchGesture;
+import net.rim.device.api.ui.Ui;
+import net.rim.device.api.ui.UiApplication;
+import net.rim.device.api.ui.component.BitmapField;
+import net.rim.device.api.ui.component.Dialog;
+import net.rim.device.api.ui.component.Menu;
+import net.rim.device.api.ui.container.MainScreen;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Date;
+
+import javax.microedition.io.Connector;
+import javax.microedition.io.file.FileConnection;
+
+import rhomobile.Utilities;
+
+public class SignatureCapture extends MainScreen 
+{
+	private static final RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
+		new RhoLogger("Alert");
+	
+	private static RhodesApp RHODESAPP(){ return RhodesApp.getInstance(); }
+	
+	public static final RubyID filePathID = RubyID.intern("filePath");
+	
+	private RubyHash m_hashParams;
+	private String m_strFilePath = "";
+	private boolean m_bIsCanceled = false;
+	
+	//Current Bitmap instance
+	private Bitmap _bitmap;
+	
+	//A custom BitmapField for drawing a signature 
+	private SignatureField _signatureField;
+
+	boolean isCanceled(){ return m_bIsCanceled; }
+	/**
+	 * Constructor
+	 */
+	public SignatureCapture( RubyHash hashParams ) 
+	{
+		super();
+		m_hashParams = hashParams;
+			
+		setTitle("Please Sign Your Name");
+		Ui.getUiEngineInstance().setAcceptableDirections(Display.DIRECTION_NORTH);
+		try {
+			
+			//Get the local resource background image to initialize the signature field
+			Class cl = Class.forName("com.rho.rubyext.SignatureCapture");
+			InputStream is = cl.getResourceAsStream("/background.png");
+			ByteArrayOutputStream bas = new ByteArrayOutputStream();
+			byte[] buffer = new byte[1024];
+			while (is.read(buffer) != -1) {
+				bas.write(buffer, 0, buffer.length);
+			}
+			EncodedImage image = EncodedImage.createEncodedImage(bas.toByteArray(), 0, bas.size());
+			//Set the background as the current bitmap
+			_bitmap = image.getBitmap();
+		} catch (IOException e) {
+			LOG.ERROR("Save signature failed.", e);
+		} catch (ClassNotFoundException e) {
+			LOG.ERROR("Save signature failed.", e);
+		}
+		//Create a new SignatureField with current _bitmap instance
+		_signatureField = new SignatureField(_bitmap);
+		add(_signatureField);
+	}
+
+	private static String getHashStringValue(RubyHash hash, RubyID id)
+    {
+		if ( hash == null )
+			return "";
+		
+    	RubyValue val = hash.get(id.toSymbol());
+    	
+    	return val != null && val != RubyConstant.QNIL ? val.toStr() : ""; 
+    }
+	
+	private String getFilePath()throws Exception 
+	{
+		if ( m_strFilePath.length() > 0 )
+			return m_strFilePath;
+		
+		m_strFilePath = getHashStringValue(m_hashParams, filePathID );
+		if ( m_strFilePath.length() > 0 )
+			return m_strFilePath;
+		
+		m_strFilePath = DBAdapter.makeBlobFolderName();
+		SimpleDateFormat format = 
+			new SimpleDateFormat("MMM_dd_yyyy_HH_mm_ss_zzz");
+		
+		String name = format.format(new Date());
+		name = Utilities.replaceAll(name,"/","_");
+		m_strFilePath += "image_" + name + ".png";
+		
+		return m_strFilePath;
+	}
+	
+	/** 
+	 * MenuItem to Capture the signature and save it to an image file
+	 */
+	private MenuItem _captureItem = new MenuItem("Capture", 200000, 10) {
+		public void run() {
+			//Create a new instance of the encoder to encode the bitmap into an image
+			PNGEncoder encoder = new PNGEncoder(_bitmap, true);
+			try {
+				byte[] imageBytes = encoder.encode(true);
+				EncodedImage image = EncodedImage.createEncodedImage(imageBytes, 0, imageBytes.length);
+				try {
+					String fileName = getFilePath();
+					
+					FileConnection fconn = (FileConnection) Connector.open(fileName);
+					if (!fconn.exists())
+						fconn.create();
+					DataOutputStream ds = fconn.openDataOutputStream();
+					ds.write(image.getData());
+					ds.close();
+					fconn.close();
+				} catch (Exception e) {
+					LOG.ERROR("Save signature failed.", e);
+				}
+			} catch (IOException e) {
+				LOG.ERROR("Save signature failed.", e);
+			}
+			
+			onClose();
+		}
+	};
+
+	/**
+	 * MenuItem to clear the signature field
+	 */
+	private MenuItem _clearItem = new MenuItem("Clear", 200000, 10) {
+		public void run() {
+			_signatureField.clear();
+		}
+
+	};
+
+	/**
+	 * MenuItem to close the application
+	 */
+	private MenuItem _closeItem = new MenuItem("Close", 200000, 10) {
+		public void run() {
+			m_bIsCanceled = true;
+			onClose();
+		}
+	};
+
+	/**
+	 * Create the menu
+	 */
+	protected void makeMenu(Menu menu, int instance) {
+		menu.add(_captureItem);
+		menu.add(_clearItem);
+		menu.add(_closeItem);
+	}
+
+	final class SignatureField extends BitmapField {
+
+		private Graphics _graphics;
+		
+		/**
+		 * Constructor
+		 */
+		public SignatureField(Bitmap b) {
+			this.setBitmap(b);
+			_graphics = new Graphics(b);
+		}
+
+		/**
+		 * Handle touch events
+		 */
+		protected boolean touchEvent(TouchEvent message) {
+			try {
+				if (message.getEvent() == TouchEvent.MOVE) { //Move event fired
+					//Get the move points
+					int pointsSize = message.getMovePointsSize();
+					
+					if (pointsSize > 1)
+					{
+						int[] xPoints = new int[pointsSize];
+						int[] yPoints = new int[pointsSize];
+						message.getMovePoints(1, xPoints, yPoints, null);
+						drawPath(xPoints,yPoints);
+					}
+				} else if (message.getEvent() == TouchEvent.GESTURE) { //Gesture event fired
+					TouchGesture gesture = message.getGesture();
+					if (gesture.getEvent() == TouchGesture.TAP) { //Tap Gesture
+						//Since we have a tap only draw a single point
+						int xPoint = message.getX(1);
+						int yPoint = message.getY(1);
+						drawPoint(xPoint,yPoint);
+					} else if (gesture.getEvent() == TouchGesture.SWIPE) { //Swipe Gesture
+						//Get the move points
+						int pointsSize = message.getMovePointsSize();
+						int[] xPoints = new int[pointsSize];
+						int[] yPoints = new int[pointsSize];
+						message.getMovePoints(1, xPoints, yPoints, null);
+						drawPath(xPoints,yPoints);
+					}
+				}
+			} catch (Throwable e) {
+				throw new RuntimeException(e.toString());
+			}
+			return true;
+		}
+
+		/**
+		 * Draw a path through the set of points
+		 */
+		private void drawPath(int[] xPoints, int[] yPoints) {
+			int oldColor = _graphics.getColor();
+			//Draw a path through the points 
+			_graphics.setColor(0x000000);
+			_graphics.drawPathOutline(xPoints,yPoints, null, null, false);
+			_graphics.setColor(oldColor);
+			//Repaint
+			invalidate();
+		}
+		
+		/**
+		 * Draw a point
+		 */
+		private void drawPoint(int xPoint, int yPoint) {
+			int oldColor = _graphics.getColor();
+			_graphics.setColor(0x000000);
+			_graphics.drawPoint(xPoint, yPoint);
+			_graphics.setColor(oldColor);
+			//Repaint
+			invalidate();
+		}
+		
+		/**
+		 * Clear the field
+		 */
+		private void clear() {
+			int oldColor = _graphics.getColor();
+			_graphics.setColor(0xFFFFFF);
+			_graphics.fillRect(0, 0, _bitmap.getWidth(), _bitmap.getHeight());
+			_graphics.setColor(oldColor);
+			invalidate();
+		}
+	}
+	
+	public static void initMethods(RubyModule klass) {
+		klass.getSingletonClass().defineMethod("take", new RubyTwoArgMethod() 
+		{
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) 
+			{
+				try {
+					final String strCallback = arg0.toStr();
+					final RubyHash hashParams = (RubyHash)arg1;
+					
+					LOG.INFO("take: " + strCallback);
+					
+					
+					UiApplication.getUiApplication().invokeLater( new Runnable()
+			        {
+			            public void run()
+			            {
+			                try
+			                {
+			                	SignatureCapture oSignature = new SignatureCapture(hashParams);
+			                	UiApplication.getUiApplication().pushModalScreen(oSignature);
+			                	
+			                	com.rho.FilePath oFilePath = new com.rho.FilePath( oSignature.getFilePath() );
+			                	String strStatus = oSignature.isCanceled() ? "" : ( !RhoFile.isFileExist(oSignature.getFilePath()) ? "Error" : "");
+			                	
+			                	RHODESAPP().callSignatureCallback( strCallback, oFilePath.getBaseName(), strStatus, oSignature.isCanceled() );
+			                }catch(Exception exc)
+			                {
+			                	LOG.ERROR("Display signature screen failed.", exc);
+			                }
+			            }
+			        });
+					
+					return RubyConstant.QNIL;
+				} catch(Exception e) {
+					LOG.ERROR("take failed", e);
+						throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
+			}
+		});
+	}
+}

data/platform/bb/rhodes/src/com/rho/rubyext/WebView.java

@@ -45,7 +45,7 @@ public class WebView
 		RhodesApplication.getInstance().navigateUrl(url);
 	}
 	
-	public static void initMethods(RubyClass klass) {
+	public static void initMethods(RubyModule klass) {
 		klass.getSingletonClass().defineMethod("refresh", new RubyNoArgMethod() {
 			protected RubyValue run(RubyValue receiver, RubyBlock block) 
 			{

data/platform/iphone/Classes/AppManager/AppManager.m

@@ -53,6 +53,8 @@
 static bool UnzipApplication(const char* appRoot, const void* zipbuf, unsigned int ziplen);
 //const char* RhoGetRootPath();
 
+VALUE rho_sys_has_wifi_network();
+VALUE rho_sys_has_cell_network();
 
 
 BOOL isPathIsSymLink(NSFileManager *fileManager, NSString* path) {
@@ -493,6 +495,11 @@ const char* rho_native_rhopath()
 	return root;
 }
 
+const char* rho_native_reruntimepath()
+{
+    return rho_native_rhopath();
+}
+
 const char* rho_native_rhouserpath() 
 {
     BOOL user_path_in_root = NO;
@@ -717,6 +724,10 @@ int rho_sysimpl_get_property(char* szPropName, VALUE* resValue)
     }
     else if (strcasecmp("has_network", szPropName) == 0)
         {*resValue = rho_sys_has_network(); return 1; }
+    else if (strcasecmp("has_wifi_network", szPropName) == 0)
+    {*resValue = rho_sys_has_wifi_network(); return 1; }
+    else if (strcasecmp("has_cell_network", szPropName) == 0)
+    {*resValue = rho_sys_has_cell_network(); return 1; }
     else if (strcasecmp("has_camera", szPropName) == 0) {
         int has_camera = [UIImagePickerController isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera];
         *resValue = rho_ruby_create_boolean(has_camera);

data/platform/iphone/Classes/Rhodes.m

@@ -636,7 +636,7 @@ static Rhodes *instance = NULL;
     NSLog(@"Init delegates");
     dateTimePickerDelegate = [[DateTimePickerDelegate alloc] init];
     pickImageDelegate = [[PickImageDelegate alloc] init];
-    signatureDelegate = [[SignatureDelegate alloc] init];
+    signatureDelegate = [SignatureDelegate getSharedInstance];
     nvDelegate = [[NVDelegate alloc] init];
     
 #ifdef APP_BUILD_CAPABILITY_PUSH    

data/platform/iphone/Classes/Signature/SignatureDelegate.h

@@ -27,6 +27,7 @@
 #import <UIKit/UIKit.h>
 #import <Foundation/Foundation.h>
 #import "RhoDelegate.h"
+#import "SignatureView.h"
 #import "SignatureViewController.h"
 
 @interface SignatureDelegate : RhoDelegate {
@@ -37,9 +38,12 @@
     unsigned int penColor;
     float penWidth;
     unsigned int bgColor;
+    SignatureView* signatureInlineView;
 }
 
 
++(id) getSharedInstance;
+
 -(void)doDone:(UIImage*)image;
 -(void)doCancel;
 -(void)setSignatureViewControllerValue:(SignatureViewController *)svc;
@@ -51,6 +55,6 @@
 -(void)setPenWidth:(float)value;
 -(void)setBgColor:(unsigned int)value;
 
-
+-(void)hideSignatureInlineView;
 
 @end

data/platform/iphone/Classes/Signature/SignatureDelegate.m

@@ -30,14 +30,26 @@
 #import "common/RhodesApp.h"
 #include "ruby/ext/rho/rhoruby.h"
 
+SignatureDelegate* ourSD = nil;
+
 
 @implementation SignatureDelegate
 
++(id) getSharedInstance
+{
+    if (ourSD == nil) {
+        ourSD = [[SignatureDelegate alloc] init];
+    }
+    return ourSD;
+}
+
+
 -(id) init
 {
     if (self = [super init])
     {
         signatureViewController = nil;
+        signatureInlineView = nil;
         parentView = nil;
         prevView = nil;
         imageFormat = nil;
@@ -139,6 +151,83 @@
     prevView = nil;
 }
 
+-(void)hideSignatureInlineViewCommand
+{
+    if (signatureInlineView != nil) {
+        [signatureInlineView removeFromSuperview];
+        [signatureInlineView release];
+        signatureInlineView = nil;
+    }
+}
+
+-(void)hideSignatureInlineView
+{
+    [self performSelectorOnMainThread:@selector(hideSignatureInlineViewCommand) withObject:nil waitUntilDone:NO];
+}
+
+
+-(void)showSignatureInlineViewCommand:(SignatureViewProperties*)properties
+{
+    [self hideSignatureInlineViewCommand];
+    
+    CGRect rect;
+    
+    rect.origin.x = properties.left;
+    rect.origin.y = properties.top;
+    rect.size.width = properties.width;
+    rect.size.height = properties.height;
+    
+    signatureInlineView = [[SignatureView alloc] initWithFrame:rect];
+
+    [signatureInlineView setPenColor:properties.penColor];
+    [signatureInlineView setPenWidth:properties.penWidth];
+    [signatureInlineView setBgColor:properties.bgColor];
+    
+    signatureInlineView.opaque = NO;
+    signatureInlineView.backgroundColor = [UIColor colorWithWhite:1 alpha:0];
+
+    
+    UIWebView* webView = [[[Rhodes sharedInstance] mainView] getWebView:-1];
+    if (webView != nil) {
+        UIView* v = webView;//[[webView subviews] objectAtIndex:0];
+        //UIView* v = [[webView subviews] objectAtIndex:0];
+        [v addSubview:signatureInlineView];
+        [v bringSubviewToFront:signatureInlineView];
+        [v setNeedsDisplay];
+    }
+}
+
+
+-(void)showSignatureInlineView:(SignatureViewProperties*)properties
+{
+    [self performSelectorOnMainThread:@selector(showSignatureInlineViewCommand:) withObject:properties waitUntilDone:NO];
+}
+
+-(void)clearSignatureInlineViewCommand
+{
+    if (signatureInlineView != nil) {
+        [signatureInlineView doClear];
+    }
+}
+
+-(void)clearSignatureInlineView
+{
+    [self performSelectorOnMainThread:@selector(clearSignatureInlineViewCommand) withObject:nil waitUntilDone:NO];
+}
+
+-(void)captureInlineSignatureCommand
+{
+    if (signatureInlineView != nil) {
+        UIImage* img = [signatureInlineView makeUIImage];
+        [self hideSignatureInlineViewCommand];
+        [self useImage:img];
+    }
+}
+
+-(void)captureInlineSignature
+{
+    [self performSelectorOnMainThread:@selector(captureInlineSignatureCommand) withObject:nil waitUntilDone:NO];
+}
 
 
 @end
@@ -184,24 +273,116 @@ void rho_signature_take(char* callback_url, rho_param* p) {
 	Rhodes* rho = [Rhodes sharedInstance];
 	SignatureDelegate* deleg = rho.signatureDelegate; 
 	[deleg setImageFormat:iformat];
-    [deleg setPenColor:(unsigned int)[ns_penColor longLongValue]];
+    [deleg setPenColor:((unsigned int)[ns_penColor longLongValue] | 0xFF000000)];
     [deleg setPenWidth:[ns_penWidth floatValue]];
-    [deleg setBgColor:(unsigned int)[ns_bgColor longLongValue]];
+    [deleg setBgColor:((unsigned int)[ns_bgColor longLongValue] | 0xFF000000)];
     [[Rhodes sharedInstance] performSelectorOnMainThread:@selector(takeSignature:)
                                               withObject:url waitUntilDone:NO];
 }
 
+
 void rho_signature_visible(bool b, rho_param* p)
 {
-    //TODO: rho_signature_visible
+    if (!b) {
+        SignatureDelegate* deleg = [SignatureDelegate getSharedInstance]; 
+        [deleg hideSignatureInlineView]; 
+        return;
+    }
+    
+    
+    char* image_format = 0;
+    char* penColor = 0;
+    char* penWidth = 0;
+    char* bgColor = 0;
+    char* left = 0;
+    char* top = 0;
+    char* width = 0;
+    char* height = 0;
+    
+    if (p)
+    {
+        rho_param* pFF = rho_param_hash_get(p, "imageFormat");
+        if ( pFF )
+            image_format = pFF->v.string;
+        pFF = rho_param_hash_get(p, "penColor");
+        if ( pFF )
+            penColor = pFF->v.string;
+        pFF = rho_param_hash_get(p, "penWidth");
+        if ( pFF )
+            penWidth = pFF->v.string;
+        pFF = rho_param_hash_get(p, "bgColor");
+        if ( pFF )
+            bgColor = pFF->v.string;
+        pFF = rho_param_hash_get(p, "left");
+        if ( pFF )
+            left = pFF->v.string;
+        pFF = rho_param_hash_get(p, "top");
+        if ( pFF )
+            top = pFF->v.string;
+        pFF = rho_param_hash_get(p, "width");
+        if ( pFF )
+            width = pFF->v.string;
+        pFF = rho_param_hash_get(p, "height");
+        if ( pFF )
+            height = pFF->v.string;
+    }
+
+    if (!image_format)
+        image_format = "png";
+    if (!penColor)
+        penColor = "0xFF66009A";
+    if (!penWidth)
+        penWidth = "3";
+    if (!bgColor)
+        bgColor = "0xFFFFFFFF";
+    if (!left)
+        left = "0";
+    if (!top)
+        top = "0";
+    if (!width)
+        width = "100";
+    if (!height)
+        height = "100";
+    
+    NSString *iformat = [NSString stringWithUTF8String:image_format];
+    NSString* ns_penColor = [NSString stringWithUTF8String:penColor];
+    NSString* ns_penWidth = [NSString stringWithUTF8String:penWidth];
+    NSString* ns_bgColor = [NSString stringWithUTF8String:bgColor];
+    NSString* ns_left = [NSString stringWithUTF8String:left];
+    NSString* ns_top = [NSString stringWithUTF8String:top];
+    NSString* ns_width = [NSString stringWithUTF8String:width];
+    NSString* ns_height = [NSString stringWithUTF8String:height];
+    
+    SignatureViewProperties* props = [[SignatureViewProperties alloc] init];
+
+    props.penColor = (unsigned int)[ns_penColor longLongValue];
+    props.penWidth = (float)[ns_penWidth floatValue];
+    props.bgColor = (unsigned int)[ns_bgColor longLongValue];
+    props.left = (int)[ns_left longLongValue];
+    props.top = (int)[ns_top longLongValue];
+    props.width = (int)[ns_width longLongValue];
+    props.height = (int)[ns_height longLongValue];
+    
+	SignatureDelegate* deleg = [SignatureDelegate getSharedInstance]; 
+
+    [deleg setImageFormat:iformat];
+
+    [deleg showSignatureInlineView:props];
+    
 }
 
 void rho_signature_capture(const char* callback_url) 
 {
-    //TODO: rho_signature_capture
+	SignatureDelegate* deleg = [SignatureDelegate getSharedInstance]; 
+    
+    [deleg setPostUrl:[NSString stringWithUTF8String:callback_url]];
+        
+    [deleg captureInlineSignature];
 }
 
 void rho_signature_clear() 
 {
-    //TODO: rho_signature_clear
+	SignatureDelegate* deleg = [SignatureDelegate getSharedInstance]; 
+    [deleg clearSignatureInlineView];
+    
 }