rhodes 3.0.0 → 3.0.1.beta.2

data/platform/wm/rhodes/emulator/QtMainWindow.h

@@ -24,7 +24,7 @@ public:
     virtual void closeEvent(QCloseEvent *);
     void setCallback(IMainWindowCallback* callback);
     // webview
-    void navigate(QUrl url);
+    void navigate(QString url);
     void GoBack(void);
     void GoForward(void);
     void Refresh(void);

data/platform/wm/rhodes/rho/rubyext/SystemImpl.cpp

@@ -389,6 +389,11 @@ int rho_sysimpl_get_property(char* szPropName, VALUE* resValue)
 		return 1;
 	}
 
+#ifdef RHODES_EMULATOR
+    if (strcasecmp("main_window_closed",szPropName) == 0) 
+        {*resValue = rho_ruby_create_boolean(CMainWindow::mainWindowClosed); return 1;}
+#endif
+
 	if (strcasecmp("has_camera",szPropName) == 0) 
         {*resValue = rho_ruby_create_boolean(has_camera()); return 1;}
 

data/platform/wp7/RhoAppRunner/Program.cs

@@ -23,9 +23,9 @@ namespace RhoAppRunner
                 useEmulator = false;
 
             if (useEmulator)
-                WP7Device = WP7SDK.GetDevices().Single(d => d.Name == "Windows Phone 7 Emulator");
+                WP7Device = WP7SDK.GetDevices().First(d => d.Name.StartsWith("Windows Phone 7 Emulator"));
             else
-                WP7Device = WP7SDK.GetDevices().Single(d => d.Name == "Windows Phone 7 Device");
+                WP7Device = WP7SDK.GetDevices().First(d => d.Name.StartsWith("Windows Phone 7 Device"));
 
             Console.WriteLine("Connecting to Windows Phone 7 Emulator/Device...");
             WP7Device.Connect();

data/platform/wp7/RhoRubyLib/RhoRuby.cs

@@ -28,6 +28,7 @@ namespace rho
         private ScriptRuntime m_runtime;
         private ScriptEngine m_engine;
         RubyContext m_context;
+        public RubyContext rubyContext { get { return m_context; } }
         private object m_rhoframework;
 
         public WebBrowser WebBrowser{ get { return m_webBrowser; } }
@@ -175,6 +176,8 @@ namespace rho
             //m_engine.Execute("def test; while false; end; end; test();");
             //m_engine.Execute("class RecordNotFound < StandardError;end; raise RecordNotFound;");
             //m_engine.Execute("test = {}; test.__id__;");
+            //m_engine.Execute("module GeoLocation; end; def test; begin; eval(\"GeoLocation.non_exist_method();\"); rescue Exception => e; puts \"exc: #{e}\"; end; end; test();");
+            //m_engine.Execute("module GeoLocation; end; def test; GeoLocation.non_exist_method(); 123; end; begin; res = {}; res['a'] = test(); rescue Exception => e; puts \"exc: #{e}\"; end;");
 
             StreamResourceInfo sr = Application.GetResourceStream(new Uri("lib/rhoframework.rb", UriKind.Relative));
 
@@ -200,6 +203,11 @@ namespace rho
             m_engine.Operations.InvokeMember(m_rhoframework, "ui_created");
         }
 
+        public void callUIDestroyed()
+        {
+            m_engine.Operations.InvokeMember(m_rhoframework, "ui_destroyed");
+        }
+
         public void Stop()
         {
             m_runtime.Shutdown();

data/platform/wp7/RhoRubyLib/common/RhodesApp.cs

@@ -35,6 +35,7 @@ namespace rho.common
         String[] m_currentUrls = new String[5];
         private String m_strBlobsDirPath, m_strDBDirPath;
         private String m_strHomeUrl;
+        private String m_strAppBackUrl;
         ManualResetEvent m_UIWaitEvent = new ManualResetEvent(false);
         Vector<Object> m_arCallbackObjects = new Vector<Object>();
 
@@ -87,19 +88,26 @@ namespace rho.common
             RHOCONF().conflictsResolved();
         }
 
+        public void closeApp()
+        {
+            m_httpServer.stop(10);
+
+            RhoLogger.close();
+            m_UIWaitEvent.Close();
+        }
+
         public void stopApp()
         {
-            string[] ar1 = CRhoFile.enumDirectory("db");
+            //string[] ar1 = CRhoFile.enumDirectory("db");
+
+            RhoRuby.callUIDestroyed();
 
-            RhoRuby.Stop();
             SyncThread.getInstance().Destroy();
-            m_httpServer.stop(2);
             CAsyncHttp.Destroy();
 
-            RhoLogger.close();
-            m_UIWaitEvent.Close();
+            RhoRuby.Stop();
 
-            string[] ar2 = CRhoFile.enumDirectory("db");
+            //string[] ar2 = CRhoFile.enumDirectory("db");
             //int i = 0;
             //net::CAsyncHttp::Destroy();
         }
@@ -298,7 +306,10 @@ namespace rho.common
                 if (m_appMainPage.ApplicationBar == null)
                     createEmptyToolBar();
                 else
+                {
                     m_appMainPage.ApplicationBar.MenuItems.Clear();
+                    setAppBackUrl("");
+                }
 
                 m_menuItems = menuItems;
 
@@ -314,6 +325,8 @@ namespace rho.common
 
                     if (action == "close") continue;
 
+                    if (item.Text.toLowerCase() == "back" && action.toLowerCase() != "back") setAppBackUrl(action);
+
                     item.Click += delegate(object sender, EventArgs e) { processToolBarCommand(sender, e, action); };
 
                     m_appMainPage.ApplicationBar.MenuItems.Add(item);
@@ -327,6 +340,7 @@ namespace rho.common
             m_appMainPage.ApplicationBar.IsMenuEnabled = true;
             m_appMainPage.ApplicationBar.IsVisible = true;
             m_appMainPage.ApplicationBar.Opacity = 1.0;
+            setAppBackUrl("");
         }
 
         public void createToolBar(int barType, Object barParams)
@@ -406,7 +420,9 @@ namespace rho.common
             boolean callback = false;
             if (strAction == "back")
             {
-                if (m_backHistory.Count > 0)
+                if (m_strAppBackUrl.length() > 0)
+                    processToolBarCommand(this, e, m_strAppBackUrl);
+                else if (m_backHistory.Count > 0)
                 {
                     Uri destination = m_backHistory.Peek();
                     m_webBrowser.Navigate(destination);
@@ -500,5 +516,11 @@ namespace rho.common
             m_arCallbackObjects[nIndex] = null;
             return res;
         }
+
+        public void setAppBackUrl(String url)
+        {
+            m_strAppBackUrl = url;
+            m_backHistory.Clear();
+        }
     }
 }

data/platform/wp7/RhoRubyLib/db/DBAdapter.cs

@@ -89,8 +89,11 @@ namespace rho.db
 	public void close()
 	{ 
 		try{
-			m_dbStorage.close();
-			m_dbStorage = null;
+            if (m_dbStorage != null)
+            {
+                m_dbStorage.close();
+                m_dbStorage = null;
+            }
 		}catch(Exception exc)
 		{
     		LOG.ERROR("DB close failed.", exc);

data/platform/wp7/RhoRubyLib/logging/RhoLogger.cs

@@ -1,5 +1,7 @@
 using System;
 using rho.logging;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
 
 namespace rho.common
 {
@@ -290,6 +292,16 @@ namespace rho.common
 	    	    getLogConf().clearLog();
 	        }
 	    }
+
+        public void HandleRubyException(Exception ex, Exception rubyEx,  String message)
+        {
+            if (rubyEx == null)
+            {
+                rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+            }
+            logMessage(L_ERROR, message);
+            throw rubyEx;
+        }
 	
         public static void InitRhoLog()
         {

data/platform/wp7/RhoRubyLib/net/HttpServer.cs

@@ -87,6 +87,8 @@ namespace rho.net
         {
             RHODESAPP().startApp();
             base.run();
+
+            RHODESAPP().stopApp();
         }
 
         public override void processCommand(IQueueCommand pCmd)

data/platform/wp7/RhoRubyLib/net/NetRequest.cs

@@ -72,7 +72,7 @@ namespace rho.net
 		        {
 				    String strName = hashEnum.Current.Key;
 				    String strValue = hashEnum.Current.Value;
-                    m_webRequest.Headers[strName] = strValue;
+                    m_webRequest.Headers[strName.Replace("-", "")] = strValue;
 		        }
 			
 		    }

data/platform/wp7/RhoRubyLib/rubyext/RhoAsyncHttp.cs

@@ -3,6 +3,7 @@ using Microsoft.Scripting.Runtime;
 using IronRuby.Runtime;
 using IronRuby.Builtins;
 using System;
+using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using rho.common;
 using rho.net;
@@ -18,6 +19,9 @@ namespace rho.rubyext
 
             #region Private Implementation Details
 
+            private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+            new RhoLogger("RhoAsyncHttp");
+
             #endregion
 
             #region Private Instance & Singleton Methods
@@ -25,23 +29,64 @@ namespace rho.rubyext
             [RubyMethodAttribute("cancel", RubyMethodAttributes.PublicSingleton)]
             public static void Cancel(RubyModule/*!*/ self, [NotNull]String cancelCallback)
             {
-                if (CAsyncHttp.getInstance() != null)
-                    CAsyncHttp.getInstance().cancelRequest(cancelCallback);
+                try
+                {
+                    if (CAsyncHttp.getInstance() != null)
+                        CAsyncHttp.getInstance().cancelRequest(cancelCallback);
+                }
+                catch (Exception ex)
+                {
+                    Exception rubyEx = self.Context.CurrentException;
+                    if (rubyEx == null)
+                    {
+                        rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                    }
+                    LOG.ERROR("cancel", ex);
+                    throw rubyEx;
+                }
             }
 
             [RubyMethodAttribute("cancel", RubyMethodAttributes.PublicSingleton)]
             public static void Cancel(RubyModule/*!*/ self)
             {
-                if (CAsyncHttp.getInstance() != null)
-                    CAsyncHttp.getInstance().cancelRequest("*");
+                try
+                {
+                    if (CAsyncHttp.getInstance() != null)
+                        CAsyncHttp.getInstance().cancelRequest("*");
+                }
+                catch (Exception ex)
+                {
+                    Exception rubyEx = self.Context.CurrentException;
+                    if (rubyEx == null)
+                    {
+                        rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                    }
+                    LOG.ERROR("cancel", ex);
+                    throw rubyEx;
+                }
             }
 
             [RubyMethodAttribute("do_request", RubyMethodAttributes.PublicSingleton)]
             public static MutableString doRequest(RubyModule/*!*/ self, [NotNull]String command, Hash args)
             {
-                CAsyncHttp.Create();
-                RhoParams p = new RhoParams(args);
-                return CAsyncHttp.getInstance().addHttpCommand(new CAsyncHttp.HttpCommand(command, p));
+                MutableString res = null;
+                try
+                {
+                    CAsyncHttp.Create();
+                    RhoParams p = new RhoParams(args);
+                    res = CAsyncHttp.getInstance().addHttpCommand(new CAsyncHttp.HttpCommand(command, p));
+                }
+                catch (Exception ex)
+                {
+                    Exception rubyEx = self.Context.CurrentException;
+                    if (rubyEx == null)
+                    {
+                        rubyEx = RubyExceptionData.InitializeException(new RuntimeError(ex.Message.ToString()), ex.Message);
+                    }
+                    LOG.ERROR("do_request", ex);
+                    throw rubyEx;
+                }
+                return res;
             }
 
             #endregion

data/platform/wp7/RhoRubyLib/rubyext/RhoDatabase.cs

@@ -17,6 +17,9 @@ namespace rho.rubyext
         {
             static CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
 
+            static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+                new RhoLogger("RhoDatabase");
+
             DBAdapter m_db;
             RhoDatabase() { }
 
@@ -39,27 +42,43 @@ namespace rho.rubyext
             [RubyMethod("close")]
             public static void Close(RhoDatabase/*!*/ self)
             {
-                self.m_db.close();
+                try
+                {
+                    self.m_db.close();
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "close");
+                }
             }
 
             [RubyMethod("commit")]
             public static void Commit(RhoDatabase/*!*/ self)
             {
-                self.m_db.commit();
-
+                try
+                {
+                    self.m_db.commit();
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "commit");
+                }
             }
 
             [RubyMethod("destroy_tables")]
             public static void destroyTables(RhoDatabase/*!*/ self, RubyArray arInclude, RubyArray arExclude)
             {
-                Vector<String> vecIncludes = RhoRuby.makeVectorStringFromArray(arInclude);
-                Vector<String> vecExcludes = RhoRuby.makeVectorStringFromArray(arExclude);
-
-                self.m_db.rb_destroy_tables(vecIncludes, vecExcludes);
-
-                //throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
-                //TODO: threw ruby exception
+                try
+                {
+                    Vector<String> vecIncludes = RhoRuby.makeVectorStringFromArray(arInclude);
+                    Vector<String> vecExcludes = RhoRuby.makeVectorStringFromArray(arExclude);
 
+                    self.m_db.rb_destroy_tables(vecIncludes, vecExcludes);
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "destroy_tables");
+                }
             }
 
             [RubyMethod("execute")]
@@ -117,45 +136,93 @@ namespace rho.rubyext
                     return retArr;
                 }catch (Exception exc)
                 {
-                    //TODO: throw ruby exception
-                    throw exc;
+                    LOG.HandleRubyException(exc, RhoRuby.rubyContext.CurrentException, "execute");
+                    return null;
                 }
             }
 
             [RubyMethod("is_ui_waitfordb")]
             public static Boolean isUiWaitForDb(RhoDatabase/*!*/ self)
             {
-                return self.m_db.isUIWaitDB();
+                Boolean res = false;
+                try
+                {
+                    res = self.m_db.isUIWaitDB();
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "is_ui_waitfordb");
+                }
+
+                return res;
             }
 
             [RubyMethod("lock_db")]
             public static void Lock(RhoDatabase/*!*/ self)
             {
-                self.m_db.Lock();
+                try
+                {
+                    self.m_db.Lock();
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "lock_db");
+                }
             }
 
             [RubyMethod("rollback")]
             public static void Rollback(RhoDatabase/*!*/ self)
             {
-                self.m_db.rollback();
+                try
+                {
+                    self.m_db.rollback();
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "rollback");
+                }
             }
 
             [RubyMethod("start_transaction")]
             public static void startTransaction(RhoDatabase/*!*/ self)
             {
-                self.m_db.startTransaction();
+                try
+                {
+                    self.m_db.startTransaction();
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "start_transaction");
+                }
             }
 
             [RubyMethod("table_exist?")]
             public static Boolean isTableExist(RhoDatabase/*!*/ self, MutableString/*!*/ tblName)
             {
-                return self.m_db.isTableExist( tblName.ToString() );
+                Boolean res = false;
+                try
+                {
+                    res = self.m_db.isTableExist(tblName.ToString());
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "table_exist?");
+                }
+
+                return res;
             }
 
             [RubyMethod("unlock_db")]
             public static void Unlock(RhoDatabase/*!*/ self)
             {
-                self.m_db.Unlock();
+                try
+                {
+                    self.m_db.Unlock();
+                }
+                catch (Exception ex)
+                {
+                    LOG.HandleRubyException(ex, RhoRuby.rubyContext.CurrentException, "unlock_db");
+                }
             }
 
             #endregion