rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/RhoRubyLib/sync/SyncThread.cs

@@ -0,0 +1,301 @@
+using System;
+using rho.common;
+using rho.db;
+
+namespace rho.sync
+{
+    public class SyncThread : CThreadQueue
+    {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
+		    new RhoLogger("Sync");
+        public CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
+
+	    private static int SYNC_WAIT_BEFOREKILL_SECONDS  = 3;
+	
+   	    public const int scNone = 0, scSyncAll = 1, scSyncOne = 2, scLogin = 3, scSearchOne=4; 
+    
+   	    public class SyncCommand : CThreadQueue.IQueueCommand
+   	    {
+   		    public int m_nCmdCode;
+   		    public int m_nCmdParam;
+   		    public String m_strCmdParam;
+   		    public boolean m_bShowStatus;
+   		
+   		    public SyncCommand(int nCode, int nParam, boolean bShowStatus)
+   		    {
+   			    m_nCmdCode = nCode;
+   			    m_nCmdParam = nParam;
+   			    m_bShowStatus = bShowStatus;
+   		    }
+   		    public SyncCommand(int nCode, String strParam, boolean bShowStatus)
+   		    {
+   			    m_nCmdCode = nCode;
+   			    m_strCmdParam = strParam;
+   			    m_bShowStatus = bShowStatus;
+   		    }
+	        public SyncCommand(int nCode, String strParam, int nCmdParam, boolean bShowStatus)
+	        {
+		        m_nCmdCode = nCode;
+		        m_strCmdParam = strParam;
+                m_nCmdParam = nCmdParam;
+                m_bShowStatus = bShowStatus;
+	        }
+   		
+   		    public SyncCommand(int nCode, boolean bShowStatus)
+   		    {
+   			    m_nCmdCode = nCode;
+   			    m_nCmdParam = 0;
+   			    m_bShowStatus = bShowStatus;
+   		    }
+   		
+   		    public boolean equals(IQueueCommand obj)
+   		    {
+   			    SyncCommand oSyncCmd = (SyncCommand)obj;
+   			    return m_nCmdCode == oSyncCmd.m_nCmdCode && m_nCmdParam == oSyncCmd.m_nCmdParam &&
+   				    (m_strCmdParam == oSyncCmd.m_strCmdParam ||
+   				    (m_strCmdParam != null && oSyncCmd.m_strCmdParam != null && m_strCmdParam.equals(oSyncCmd.m_strCmdParam)));  		
+   		    }
+   		
+   		    public String toString()
+   		    {
+   		        switch(m_nCmdCode)
+   		        {
+   		        case scNone:
+   		            return "CheckPollInterval";
+
+   		        case scSyncAll:
+   		            return "SyncAll";
+   		        case scSyncOne:
+   		            return "SyncOne";
+   		        case scLogin:
+   		            return "Login";
+   		        case scSearchOne:
+   		            return "Search";
+   		        }
+
+   		        return "Unknown; Code : " + m_nCmdCode;
+   		    }
+   		
+   		    public void cancel(){}
+   		
+   	    };
+
+   	    public class SyncLoginCommand : SyncCommand
+   	    {
+   		    public String m_strName, m_strPassword;
+   		    public /*common::CAutoPtr<C*/SyncNotify.SyncNotification/*>*/ m_pNotify;
+   		    public SyncLoginCommand(String name, String password, String callback, SyncNotify.SyncNotification pNotify) :
+                base(scLogin,callback,false)
+   		    {
+   			    m_strName = name;
+   			    m_strPassword = password;
+   			    m_pNotify = pNotify; 
+   		    }
+   	    };
+        public class SyncSearchCommand : SyncCommand
+        {
+	        public String m_strFrom;
+	        public boolean   m_bSyncChanges;
+	        public Vector<String> m_arSources;
+	    
+            public SyncSearchCommand(String from, String _params, Vector<String> arSources, boolean sync_changes, int nProgressStep) :
+                base(scSearchOne,_params,nProgressStep, false)
+	        {
+		        m_strFrom = from;
+		        m_bSyncChanges = sync_changes;
+		        m_arSources = arSources;
+	        }
+        };
+
+	    static SyncThread m_pInstance;
+        SyncEngine  m_oSyncEngine;
+
+        public static SyncThread getInstance(){ return m_pInstance; }
+        public static SyncEngine getSyncEngine(){ return m_pInstance!= null ? m_pInstance.m_oSyncEngine : null; }
+        public override boolean isSkipDuplicateCmd() { return true; }
+    
+	    public static SyncThread Create()
+	    {
+	        if ( m_pInstance != null) 
+	            return m_pInstance;
+	
+	        m_pInstance = new SyncThread();
+	        return m_pInstance;
+	    }
+
+	    public void Destroy()
+	    {
+	        m_oSyncEngine.exitSync();
+	        stop(SYNC_WAIT_BEFOREKILL_SECONDS);
+		
+	        if ( ClientRegister.getInstance() != null )
+	    	    ClientRegister.getInstance().Destroy();
+	    
+	        DBAdapter.closeAll();
+	    
+	        m_pInstance = null;
+	    }
+
+	    SyncThread()
+	    {
+		    base.setLogCategory(LOG.getLogCategory());
+		
+		    if( RhoConf.getInstance().isExist("sync_poll_interval") )
+			    setPollInterval(RhoConf.getInstance().getInt("sync_poll_interval"));
+
+		    m_oSyncEngine = new SyncEngine();
+		    m_oSyncEngine.setFactory();
+
+	        LOG.INFO("sync_poll_interval: " + RhoConf.getInstance().getInt("sync_poll_interval"));
+	        LOG.INFO("syncserver: " + RhoConf.getInstance().getString("syncserver"));
+	        LOG.INFO("bulksync_state: " + RhoConf.getInstance().getInt("bulksync_state"));
+	    
+	        //ClientRegister.Create();
+	    
+		    if ( RhoConf.getInstance().getString("syncserver").length() > 0 )
+			    start(epLow);
+	    }
+
+        public object getRetValue()
+        {
+            if ( isNoThreadedMode()  )
+            {
+                object res = RhoRuby.createString(getSyncEngine().getNotify().getNotifyBody());
+                getSyncEngine().getNotify().cleanNotifyBody();
+
+                return res;
+            }
+
+            return null;
+        }
+	
+        public override int getLastPollInterval()
+        {
+    	    try{
+	    	    long nowTime = (TimeInterval.getCurrentTime().toULong())/1000;
+	    	    long latestTimeUpdated = 0;
+	    	
+	    	    Vector<String> arPartNames = DBAdapter.getDBAllPartitionNames();
+	    	    for( int i = 0; i < (int)arPartNames.size(); i++ )
+	    	    {
+	    		    DBAdapter dbPart = DBAdapter.getDB((String)arPartNames.elementAt(i));
+			        IDBResult res = dbPart.executeSQL("SELECT last_updated from sources");
+			        for ( ; !res.isEnd(); res.next() )
+			        { 
+			            long timeUpdated = res.getLongByIdx(0);
+			            if ( latestTimeUpdated < timeUpdated )
+			        	    latestTimeUpdated = timeUpdated;
+			        }
+	    	    }
+	    	
+	    	    return latestTimeUpdated > 0 ? (int)(nowTime-latestTimeUpdated) : 0;
+    	    }catch(Exception exc)
+    	    {
+    		    LOG.ERROR("isStartSyncNow failed.", exc);
+    	    }
+    	    return 0;
+        }
+
+	    public override void onTimeout()//throws Exception
+	    {
+	        if ( isNoCommands() && getPollInterval()>0 )
+	            addQueueCommandInt(new SyncCommand(scSyncAll,false));
+	    }
+	
+	    void checkShowStatus(SyncCommand oSyncCmd)
+	    {
+		    boolean bShowStatus = oSyncCmd.m_bShowStatus && !this.isNoThreadedMode();
+		    m_oSyncEngine.getNotify().enableReporting(bShowStatus);
+		    if (m_oSyncEngine.getNotify().isReportingEnabled())
+			    m_statusListener.createStatusPopup(RhoAppAdapter.getMessageText("syncronizing_data"));
+	    }	
+	
+	    public override void processCommand(IQueueCommand pCmd)
+	    {
+		    SyncCommand oSyncCmd = (SyncCommand)pCmd;
+	        switch(oSyncCmd.m_nCmdCode)
+	        {
+	        case scSyncAll:
+	    	    checkShowStatus(oSyncCmd);
+	            m_oSyncEngine.doSyncAllSources();
+	            break;
+            case scSyncOne:
+	            {
+				    checkShowStatus(oSyncCmd);
+	                m_oSyncEngine.doSyncSource(new SyncEngine.SourceID(oSyncCmd.m_nCmdParam,oSyncCmd.m_strCmdParam));
+	            }
+	            break;
+	        
+	        case scSearchOne:
+		        {
+				    checkShowStatus(oSyncCmd);
+	                m_oSyncEngine.doSearch( ((SyncSearchCommand)oSyncCmd).m_arSources, oSyncCmd.m_strCmdParam, 
+	                        ((SyncSearchCommand)oSyncCmd).m_strFrom, ((SyncSearchCommand)oSyncCmd).m_bSyncChanges,
+	                        oSyncCmd.m_nCmdParam);
+		        }
+	            break;
+	        
+	        case scLogin:
+	    	    {
+	    		    SyncLoginCommand oLoginCmd = (SyncLoginCommand)oSyncCmd;
+	    		    checkShowStatus(oSyncCmd);
+	    		    m_oSyncEngine.login(oLoginCmd.m_strName, oLoginCmd.m_strPassword, oLoginCmd.m_pNotify );
+	    	    }
+	            break;
+	        
+	        }
+	    }
+
+	    static ISyncStatusListener m_statusListener = null;
+	    public boolean setStatusListener(ISyncStatusListener listener) {
+		    m_statusListener = listener;
+		    if (m_oSyncEngine != null) {
+			    m_oSyncEngine.getNotify().setSyncStatusListener(listener);
+			    return true;
+		    }
+		    return false;
+	    }
+	
+	    public override void setPollInterval(int nInterval)
+	    { 
+	        //if ( m_nPollInterval == 0 )
+	        //    m_oSyncEngine.stopSync();
+	    
+	        base.setPollInterval(nInterval);	    
+	    }
+	
+	    public static void doSyncAllSources(boolean bShowStatus)
+	    {
+		    getInstance().addQueueCommand(new SyncCommand(SyncThread.scSyncAll,bShowStatus));
+	    }
+	
+	    public static void doSyncSourceByName(String strSrcName, boolean bShowStatus)
+	    {
+		    if (bShowStatus&&(m_statusListener != null)) {
+			    m_statusListener.createStatusPopup(RhoAppAdapter.getMessageText("syncronizing_data"));
+		    }
+	        getInstance().addQueueCommand(new SyncCommand(SyncThread.scSyncOne, strSrcName, (int)0, bShowStatus ) );		
+	    }
+	
+	    public static void stopSync()
+	    {
+		    LOG.INFO("STOP sync");
+		
+		    if ( getSyncEngine().isSyncing() )
+		    {
+                LOG.INFO("STOP sync in progress.");
+
+			    getSyncEngine().stopSyncByUser();
+			    getInstance().stopWait();
+
+                while (DBAdapter.isAnyInsideTransaction())
+			        CRhoThread.sleep(100);
+		    }
+	    }
+	
+	    public void addobjectnotify_bysrcname(String strSrcName, String strObject)
+	    {
+		    getSyncEngine().getNotify().addObjectNotify(strSrcName, strObject);
+	    }
+    }
+}

data/platform/wp7/WPApplication.sln

@@ -0,0 +1,50 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010 Express for Windows Phone
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WPApplication", "WPApplication\WPApplication.csproj", "{5C1CD2E9-92F9-460A-9606-9F01AF614428}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		FxCop|Any CPU = FxCop|Any CPU
+		Release|Any CPU = Release|Any CPU
+		Silverlight3Debug|Any CPU = Silverlight3Debug|Any CPU
+		Silverlight3Release|Any CPU = Silverlight3Release|Any CPU
+		Silverlight4Debug|Any CPU = Silverlight4Debug|Any CPU
+		Silverlight4Release|Any CPU = Silverlight4Release|Any CPU
+		v2Debug|Any CPU = v2Debug|Any CPU
+		v2Release|Any CPU = v2Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.FxCop|Any CPU.ActiveCfg = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.FxCop|Any CPU.Build.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.FxCop|Any CPU.Deploy.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Release|Any CPU.Deploy.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight3Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight3Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight3Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight3Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight3Release|Any CPU.Build.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight3Release|Any CPU.Deploy.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight4Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight4Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight4Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight4Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight4Release|Any CPU.Build.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.Silverlight4Release|Any CPU.Deploy.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.v2Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.v2Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.v2Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.v2Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.v2Release|Any CPU.Build.0 = Release|Any CPU
+		{5C1CD2E9-92F9-460A-9606-9F01AF614428}.v2Release|Any CPU.Deploy.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

data/platform/wp7/WPApplication/App.xaml

@@ -0,0 +1,19 @@
+<Application 
+    x:Class="WPApplication.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"       
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
+    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone">
+
+    <!--Application Resources-->
+    <Application.Resources>
+    </Application.Resources>
+
+    <Application.ApplicationLifetimeObjects>
+        <!--Required object that handles lifetime events for the application-->
+        <shell:PhoneApplicationService 
+            Launching="Application_Launching" Closing="Application_Closing" 
+            Activated="Application_Activated" Deactivated="Application_Deactivated"/>
+    </Application.ApplicationLifetimeObjects>
+
+</Application>

data/platform/wp7/WPApplication/App.xaml.cs

@@ -0,0 +1,211 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using Microsoft.Phone.Controls;
+using Microsoft.Phone.Shell;
+
+using Microsoft.Scripting.Hosting;
+using Microsoft.Scripting;
+using System.Windows.Resources;
+using System.IO;
+
+namespace WPApplication
+{
+    public partial class App : Application
+    {
+        /// <summary>
+        /// Provides easy access to the root frame of the Phone Application.
+        /// </summary>
+        /// <returns>The root frame of the Phone Application.</returns>
+        public PhoneApplicationFrame RootFrame { get; private set; }
+
+        /// <summary>
+        /// Constructor for the Application object.
+        /// </summary>
+        public App()
+        {
+            // Global handler for uncaught exceptions. 
+            UnhandledException += Application_UnhandledException;
+
+            // Show graphics profiling information while debugging.
+            if (System.Diagnostics.Debugger.IsAttached)
+            {
+                // Display the current frame rate counters.
+                Application.Current.Host.Settings.EnableFrameRateCounter = true;
+
+                // Show the areas of the app that are being redrawn in each frame.
+                //Application.Current.Host.Settings.EnableRedrawRegions = true;
+
+                // Enable non-production analysis visualization mode, 
+                // which shows areas of a page that are being GPU accelerated with a colored overlay.
+                //Application.Current.Host.Settings.EnableCacheVisualization = true;
+            }
+
+            // Standard Silverlight initialization
+            InitializeComponent();
+
+            // Phone-specific initialization
+            InitializePhoneApplication();
+        }
+
+        public class RhoHost : ScriptHost
+        {
+            private readonly PlatformAdaptationLayer/*!*/ _pal;
+
+            public RhoHost()
+            {
+                _pal = new WP_PlatformAdaptationLayer();
+            }
+
+            public override PlatformAdaptationLayer PlatformAdaptationLayer
+            {
+                get { return _pal; }
+            }
+        }
+
+        ScriptRuntime _runtime;
+        ScriptEngine _engine;
+
+        private void initRuby()
+        {
+            ScriptRuntimeSetup runtimeSetup = ScriptRuntimeSetup.ReadConfiguration();
+            var languageSetup = IronRuby.RubyHostingExtensions.AddRubySetup(runtimeSetup);
+
+            runtimeSetup.DebugMode = false;
+            runtimeSetup.PrivateBinding = false;
+            runtimeSetup.HostType = typeof(RhoHost);
+
+            //runtimeSetup.HostArguments = new object[] { testCase.Options };
+            languageSetup.Options["NoAdaptiveCompilation"] = false;
+            languageSetup.Options["CompilationThreshold"] = 0;
+            languageSetup.Options["Verbosity"] = 2;
+
+            _runtime = IronRuby.Ruby.CreateRuntime(runtimeSetup);
+            _engine = IronRuby.Ruby.GetEngine(_runtime);
+
+            System.Collections.ObjectModel.Collection<string> paths = new System.Collections.ObjectModel.Collection<string>();
+            paths.Add("lib");
+            paths.Add("apps/app");
+            _engine.SetSearchPaths(paths);
+
+            //IronRuby.Runtime.Loader
+            //context.Loader.LoadAssembly(assemblyName.ConvertToString(), initializer, true, true);
+            //IronRuby.Libraries
+            //IronRuby.StandardLibrary.StringScanner.StringScannerLibraryInitializer
+        }
+
+        object _rhoframework;
+        private void RhoRubyStart()
+        {
+            string code = "def foo; 'haha'; end; foo()";
+            //string code = "class MyClass; def initialize(arg1); end; end; MyClass.new('');";
+            
+            StreamResourceInfo sr = Application.GetResourceStream(new Uri("rho/lib/rhoframework.rb", UriKind.Relative));
+            using (System.IO.BinaryReader br = new BinaryReader(sr.Stream))
+            {
+                char[] str = br.ReadChars((int)sr.Stream.Length);
+                code = new string(str);
+            }
+
+            ScriptSource src = _engine.CreateScriptSourceFromString(code);
+            if (src == null)
+                return;
+
+            _rhoframework = src.Execute(_engine.CreateScope());
+            if (_rhoframework == null)
+                return;
+
+        }
+
+        // Code to execute when the application is launching (eg, from Start)
+        // This code will not execute when the application is reactivated
+        private void Application_Launching(object sender, LaunchingEventArgs e)
+        {
+            initRuby();
+            RhoRubyStart();
+        }
+
+        // Code to execute when the application is activated (brought to foreground)
+        // This code will not execute when the application is first launched
+        private void Application_Activated(object sender, ActivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is deactivated (sent to background)
+        // This code will not execute when the application is closing
+        private void Application_Deactivated(object sender, DeactivatedEventArgs e)
+        {
+        }
+
+        // Code to execute when the application is closing (eg, user hit Back)
+        // This code will not execute when the application is deactivated
+        private void Application_Closing(object sender, ClosingEventArgs e)
+        {
+        }
+
+        // Code to execute if a navigation fails
+        private void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
+        {
+            if (System.Diagnostics.Debugger.IsAttached)
+            {
+                // A navigation has failed; break into the debugger
+                System.Diagnostics.Debugger.Break();
+            }
+        }
+
+        // Code to execute on Unhandled Exceptions
+        private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
+        {
+            if (System.Diagnostics.Debugger.IsAttached)
+            {
+                // An unhandled exception has occurred; break into the debugger
+                System.Diagnostics.Debugger.Break();
+            }
+        }
+
+        #region Phone application initialization
+
+        // Avoid double-initialization
+        private bool phoneApplicationInitialized = false;
+
+        // Do not add any additional code to this method
+        private void InitializePhoneApplication()
+        {
+            if (phoneApplicationInitialized)
+                return;
+
+            // Create the frame but don't set it as RootVisual yet; this allows the splash
+            // screen to remain active until the application is ready to render.
+            RootFrame = new PhoneApplicationFrame();
+            RootFrame.Navigated += CompleteInitializePhoneApplication;
+
+            // Handle navigation failures
+            RootFrame.NavigationFailed += RootFrame_NavigationFailed;
+
+            // Ensure we don't initialize again
+            phoneApplicationInitialized = true;
+        }
+
+        // Do not add any additional code to this method
+        private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
+        {
+            // Set the root visual to allow the application to render
+            if (RootVisual != RootFrame)
+                RootVisual = RootFrame;
+
+            // Remove this handler since it is no longer needed
+            RootFrame.Navigated -= CompleteInitializePhoneApplication;
+        }
+
+        #endregion
+    }
+}