rho-tau-extensions 5.5.17

data/libs/openssl.so-edge/ext/openssl-1-1-0-stable/include/ssl/statem/statem.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the OpenSSL license (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*****************************************************************************
+ *                                                                           *
+ * These enums should be considered PRIVATE to the state machine. No         *
+ * non-state machine code should need to use these                           *
+ *                                                                           *
+ *****************************************************************************/
+/*
+ * Valid return codes used for functions performing work prior to or after
+ * sending or receiving a message
+ */
+typedef enum {
+    /* Something went wrong */
+    WORK_ERROR,
+    /* We're done working and there shouldn't be anything else to do after */
+    WORK_FINISHED_STOP,
+    /* We're done working move onto the next thing */
+    WORK_FINISHED_CONTINUE,
+    /* We're working on phase A */
+    WORK_MORE_A,
+    /* We're working on phase B */
+    WORK_MORE_B
+} WORK_STATE;
+
+/* Write transition return codes */
+typedef enum {
+    /* Something went wrong */
+    WRITE_TRAN_ERROR,
+    /* A transition was successfully completed and we should continue */
+    WRITE_TRAN_CONTINUE,
+    /* There is no more write work to be done */
+    WRITE_TRAN_FINISHED
+} WRITE_TRAN;
+
+/* Message flow states */
+typedef enum {
+    /* No handshake in progress */
+    MSG_FLOW_UNINITED,
+    /* A permanent error with this connection */
+    MSG_FLOW_ERROR,
+    /* We are about to renegotiate */
+    MSG_FLOW_RENEGOTIATE,
+    /* We are reading messages */
+    MSG_FLOW_READING,
+    /* We are writing messages */
+    MSG_FLOW_WRITING,
+    /* Handshake has finished */
+    MSG_FLOW_FINISHED
+} MSG_FLOW_STATE;
+
+/* Read states */
+typedef enum {
+    READ_STATE_HEADER,
+    READ_STATE_BODY,
+    READ_STATE_POST_PROCESS
+} READ_STATE;
+
+/* Write states */
+typedef enum {
+    WRITE_STATE_TRANSITION,
+    WRITE_STATE_PRE_WORK,
+    WRITE_STATE_SEND,
+    WRITE_STATE_POST_WORK
+} WRITE_STATE;
+
+/*****************************************************************************
+ *                                                                           *
+ * This structure should be considered "opaque" to anything outside of the   *
+ * state machine. No non-state machine code should be accessing the members  *
+ * of this structure.                                                        *
+ *                                                                           *
+ *****************************************************************************/
+
+struct ossl_statem_st {
+    MSG_FLOW_STATE state;
+    WRITE_STATE write_state;
+    WORK_STATE write_state_work;
+    READ_STATE read_state;
+    WORK_STATE read_state_work;
+    OSSL_HANDSHAKE_STATE hand_state;
+    int in_init;
+    int read_state_first_init;
+    /* true when we are actually in SSL_accept() or SSL_connect() */
+    int in_handshake;
+    /* Should we skip the CertificateVerify message? */
+    unsigned int no_cert_verify;
+    int use_timer;
+#ifndef OPENSSL_NO_SCTP
+    int in_sctp_read_sock;
+#endif
+};
+typedef struct ossl_statem_st OSSL_STATEM;
+
+/*****************************************************************************
+ *                                                                           *
+ * The following macros/functions represent the libssl internal API to the   *
+ * state machine. Any libssl code may call these functions/macros            *
+ *                                                                           *
+ *****************************************************************************/
+
+__owur int ossl_statem_accept(SSL *s);
+__owur int ossl_statem_connect(SSL *s);
+void ossl_statem_clear(SSL *s);
+void ossl_statem_set_renegotiate(SSL *s);
+void ossl_statem_set_error(SSL *s);
+int ossl_statem_in_error(const SSL *s);
+void ossl_statem_set_in_init(SSL *s, int init);
+int ossl_statem_get_in_handshake(SSL *s);
+void ossl_statem_set_in_handshake(SSL *s, int inhand);
+void ossl_statem_set_hello_verify_done(SSL *s);
+__owur int ossl_statem_app_data_allowed(SSL *s);
+#ifndef OPENSSL_NO_SCTP
+void ossl_statem_set_sctp_read_sock(SSL *s, int read_sock);
+__owur int ossl_statem_in_sctp_read_sock(SSL *s);
+#endif

data/libs/openssl.so-edge/ext/openssl-1-1-0-stable/include/ssl/statem/statem_locl.h

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the OpenSSL license (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+/*****************************************************************************
+ *                                                                           *
+ * The following definitions are PRIVATE to the state machine. They should   *
+ * NOT be used outside of the state machine.                                 *
+ *                                                                           *
+ *****************************************************************************/
+
+/* Max message length definitions */
+
+/* The spec allows for a longer length than this, but we limit it */
+#define HELLO_VERIFY_REQUEST_MAX_LENGTH 258
+#define SERVER_HELLO_MAX_LENGTH         20000
+#define SERVER_KEY_EXCH_MAX_LENGTH      102400
+#define SERVER_HELLO_DONE_MAX_LENGTH    0
+#define CCS_MAX_LENGTH                  1
+/* Max should actually be 36 but we are generous */
+#define FINISHED_MAX_LENGTH             64
+
+/* Message processing return codes */
+typedef enum {
+    /* Something bad happened */
+    MSG_PROCESS_ERROR,
+    /* We've finished reading - swap to writing */
+    MSG_PROCESS_FINISHED_READING,
+    /*
+     * We've completed the main processing of this message but there is some
+     * post processing to be done.
+     */
+    MSG_PROCESS_CONTINUE_PROCESSING,
+    /* We've finished this message - read the next message */
+    MSG_PROCESS_CONTINUE_READING
+} MSG_PROCESS_RETURN;
+
+/* Flush the write BIO */
+int statem_flush(SSL *s);
+
+/*
+ * TLS/DTLS client state machine functions
+ */
+int ossl_statem_client_read_transition(SSL *s, int mt);
+WRITE_TRAN ossl_statem_client_write_transition(SSL *s);
+WORK_STATE ossl_statem_client_pre_work(SSL *s, WORK_STATE wst);
+WORK_STATE ossl_statem_client_post_work(SSL *s, WORK_STATE wst);
+int ossl_statem_client_construct_message(SSL *s);
+unsigned long ossl_statem_client_max_message_size(SSL *s);
+MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL *s, PACKET *pkt);
+WORK_STATE ossl_statem_client_post_process_message(SSL *s, WORK_STATE wst);
+
+/*
+ * TLS/DTLS server state machine functions
+ */
+int ossl_statem_server_read_transition(SSL *s, int mt);
+WRITE_TRAN ossl_statem_server_write_transition(SSL *s);
+WORK_STATE ossl_statem_server_pre_work(SSL *s, WORK_STATE wst);
+WORK_STATE ossl_statem_server_post_work(SSL *s, WORK_STATE wst);
+int ossl_statem_server_construct_message(SSL *s);
+unsigned long ossl_statem_server_max_message_size(SSL *s);
+MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL *s, PACKET *pkt);
+WORK_STATE ossl_statem_server_post_process_message(SSL *s, WORK_STATE wst);
+
+/* Functions for getting new message data */
+__owur int tls_get_message_header(SSL *s, int *mt);
+__owur int tls_get_message_body(SSL *s, unsigned long *len);
+__owur int dtls_get_message(SSL *s, int *mt, unsigned long *len);
+
+/* Message construction and processing functions */
+__owur MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt);
+__owur int tls_construct_change_cipher_spec(SSL *s);
+__owur int dtls_construct_change_cipher_spec(SSL *s);
+
+__owur int tls_construct_finished(SSL *s, const char *sender, int slen);
+__owur WORK_STATE tls_finish_handshake(SSL *s, WORK_STATE wst);
+__owur WORK_STATE dtls_wait_for_dry(SSL *s);
+
+/* some client-only functions */
+__owur int tls_construct_client_hello(SSL *s);
+__owur MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt);
+__owur int tls_construct_client_verify(SSL *s);
+__owur WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst);
+__owur int tls_construct_client_certificate(SSL *s);
+__owur int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey);
+__owur int tls_construct_client_key_exchange(SSL *s);
+__owur int tls_client_key_exchange_post_work(SSL *s);
+__owur int tls_construct_cert_status(SSL *s);
+__owur MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt);
+__owur int ssl3_check_cert_and_algorithm(SSL *s);
+#ifndef OPENSSL_NO_NEXTPROTONEG
+__owur int tls_construct_next_proto(SSL *s);
+#endif
+__owur MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt);
+
+/* some server-only functions */
+__owur MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt);
+__owur WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst);
+__owur int tls_construct_server_hello(SSL *s);
+__owur int tls_construct_hello_request(SSL *s);
+__owur int dtls_construct_hello_verify_request(SSL *s);
+__owur int tls_construct_server_certificate(SSL *s);
+__owur int tls_construct_server_key_exchange(SSL *s);
+__owur int tls_construct_certificate_request(SSL *s);
+__owur int tls_construct_server_done(SSL *s);
+__owur MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt);
+__owur MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt);
+__owur WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst);
+__owur MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt);
+#ifndef OPENSSL_NO_NEXTPROTONEG
+__owur MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt);
+#endif
+__owur int tls_construct_new_session_ticket(SSL *s);

data/libs/openssl.so-edge/openssl.so.rb

@@ -0,0 +1,2 @@
+$rhodes_extensions = []
+$rhodes_extensions << File.dirname(__FILE__)

data/libs/webkit.rb

@@ -0,0 +1,2 @@
+require "webkit/webkit"
+$app_config['extpaths'] << File.dirname(__FILE__)

data/libs/webkit/ext.yml

@@ -0,0 +1,4 @@
+libraries: ["webkit"]
+
+
+platforms: ['wm']

data/libs/webkit/ext/build

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+
+if [ "$RHO_PLATFORM" = "android" ]; then
+
+cd android
+rake --trace
+
+fi
+
+
+

data/libs/webkit/ext/build.bat

@@ -0,0 +1,7 @@
+
+if "%RHO_PLATFORM%" == "wm" (
+
+cd wm
+rake --trace
+
+)

data/libs/webkit/ext/wm/Rakefile

@@ -0,0 +1,61 @@
+require 'fileutils'
+
+USE_STLPORT = true
+
+
+def build_extension(name, arch)
+  objects = []
+  mkdir_p $tempdir unless File.exists? $tempdir
+
+  mkdir_p $targetdir unless File.exist? $targetdir
+
+  if ENV['RHO_PLATFORM'] == 'wm'
+    args = []
+    args << "/M4"
+    args << name + ".vcproj"
+    args << "\"Release|#{$sdk}\""
+    cmdline = "\"" + $vcbuild + "\"" + ' ' + args.join(' ')
+    puts cmdline
+    puts `#{cmdline}`
+    exit unless $? == 0
+
+    cp_r File.join($tempdir, "Release", name + ".lib"), $targetdir
+
+  elsif ENV['RHO_PLATFORM'] == 'win32'
+    args = []
+    args << "/M4"
+    args << name + ".vcxproj"
+    args << "\"Debug|Win32\""
+    cmdline = "\"" + $vcbuild + "\"" + ' ' + args.join(' ')
+    puts cmdline
+    puts `#{cmdline}`
+    exit unless $? == 0
+
+    cp_r File.join($tempdir, "Debug", name + ".lib"), $targetdir
+  end
+ 
+end
+
+namespace "build" do
+  task :config do
+    $targetdir = ENV['TARGET_TEMP_DIR']
+    raise "TARGET_TEMP_DIR is not set" if $targetdir.nil?
+    $tempdir = ENV['TEMP_FILES_DIR']
+    raise "TEMP_FILES_DIR is not set" if $tempdir.nil?
+    $rootdir = ENV['RHO_ROOT']
+    raise "RHO_ROOT is not set" if $rootdir.nil?
+
+      $vcbuild = ENV['VCBUILD']
+      raise "VCBUILD is not set" if $vcbuild.nil?
+      $sdk = ENV['SDK']
+      raise "SDK is not set" if $sdk.nil?
+
+  end
+
+  task :all => :config do
+
+    build_extension('webkit', $arch)
+  end
+end
+
+task :default => "build:all"

data/libs/webkit/ext/wm/RhoMsgs.cpp

@@ -0,0 +1,17 @@
+#include <windows.h>
+
+//#include "common/app_build_capabilities.h"
+#include "RhoMsgs.h"
+
+//#ifdef APP_BUILD_CAPABILITY_WEBKIT_BROWSER 
+UINT WM_BROWSER_ONDOCUMENTCOMPLETE      = ::RegisterWindowMessage(L"RHODES_WM_BROWSER_ONDOCUMENTCOMPLETE");
+UINT WM_BROWSER_ONNAVIGATECOMPLETE      = ::RegisterWindowMessage(L"RHODES_WM_BROWSER_ONNAVIGATECOMPLETE");
+UINT WM_BROWSER_ONTITLECHANGE           = ::RegisterWindowMessage(L"RHODES_WM_BROWSER_ONTITLECHANGE");
+UINT WM_BROWSER_ONBEFORENAVIGATE        = ::RegisterWindowMessage(L"RHODES_WM_BROWSER_ONBEFORENAVIGATE");
+UINT WM_BROWSER_ONNAVIGATIONTIMEOUT     = ::RegisterWindowMessage(L"RHODES_WM_BROWSER_ONNAVIGATIONTIMEOUT");
+UINT WM_BROWSER_ONNAVIGATIONERROR       = ::RegisterWindowMessage(L"RHODES_WM_BROWSER_ONNAVIGATIONERROR");
+UINT WM_BROWSER_ONSETSIPSTATE           = ::RegisterWindowMessage(L"RHODES_WM_BROWSER_ONSETSIPSTATE");
+UINT WM_BROWSER_ONALERTPOPUP            = ::RegisterWindowMessage(L"WM_BROWSER_ONALERTPOPUP");
+UINT WM_BROWSER_ONAUTHENTICATIONREQUEST = ::RegisterWindowMessage(L"WM_BROWSER_ONAUTHENTICATIONREQUEST");
+//UINT WM_BROWSER_ONGPSDATA               = ::RegisterWindowMessage(L"WM_BROWSER_ONGPSDATA");
+//#endif

data/libs/webkit/ext/wm/RhoMsgs.h

@@ -0,0 +1,14 @@
+#pragma once
+
+//#ifdef APP_BUILD_CAPABILITY_WEBKIT_BROWSER
+extern UINT WM_BROWSER_ONDOCUMENTCOMPLETE;
+extern UINT WM_BROWSER_ONNAVIGATECOMPLETE;
+extern UINT WM_BROWSER_ONTITLECHANGE;
+extern UINT WM_BROWSER_ONBEFORENAVIGATE;
+extern UINT WM_BROWSER_ONNAVIGATIONTIMEOUT;
+extern UINT WM_BROWSER_ONSETSIPSTATE;
+extern UINT WM_BROWSER_ONALERTPOPUP;
+extern UINT WM_BROWSER_ONNAVIGATIONERROR;
+extern UINT WM_BROWSER_ONAUTHENTICATIONREQUEST;
+//extern UINT WM_BROWSER_ONGPSDATA;
+//#endif //APP_BUILD_CAPABILITY_WEBKIT_BROWSER

data/libs/webkit/ext/wm/RhoWKBrowserEngine.cpp

@@ -0,0 +1,736 @@
+#include "stdafx.h"
+
+//#define USINGOUTPROCESSENGINE 1
+
+//#include "common/app_build_capabilities.h"
+#include "common/SplashScreen.h"
+#include "common/RhodesApp.h"
+#include "common/RhoStd.h"
+#include "common/StringConverter.h"
+#include "common/StringConverter.h"
+#include "common/version.h"
+#include "RhoWKBrowserEngine.h"
+#include "RhoMsgs.h"
+
+ 
+#include "logging/RhoLog.h"
+#include "common/app_build_configs.h"
+
+
+#define CAMERAWND_CLASSNAME TEXT("Camera View")
+
+extern "C" HWND rho_wmimpl_get_mainwnd();
+extern "C" HINSTANCE rho_wmimpl_get_appinstance();
+extern "C" LRESULT rho_wmimpl_draw_splash_screen(HWND hWnd);
+extern "C" LRESULT rho_wm_appmanager_ProcessOnTopMostWnd( WPARAM wParam, LPARAM lParam )
+{
+	return S_OK;
+}
+extern "C" void rho_title_change(const int tabIndex, const char* strTitle);
+extern "C" double rho_wmimpl_get_pagezoom()
+{
+	return 0;
+}
+
+//Used for getting the editable window handle
+HWND m_hEditableWindow = NULL;
+//Used for checking whether the focus is on editable field or not.
+BOOL g_EditableControlHasFocus = FALSE; //Initially it will be initialised with FALSE
+
+//Application Quitting is true or false
+bool appQuitted = false;
+
+//  DCC - For Testing Only
+int REPLACE_WITH_ACTUAL_TAB_ID = 0;
+
+class CSRCExtChecker
+{
+    LPTSTR mTokenValue;    
+  public:
+	CSRCExtChecker();
+    LPVOID getTokenValue();
+    void setTokenValue(LPVOID lpValue);   
+};
+
+CSRCExtChecker::CSRCExtChecker(){
+        mTokenValue = L"";
+}
+LPVOID CSRCExtChecker::getTokenValue(){
+	if(mTokenValue)
+        return mTokenValue;
+	return NULL;
+}
+void CSRCExtChecker::setTokenValue(LPVOID lpValue){
+	if(lpValue)
+        mTokenValue = (LPTSTR)lpValue;
+}
+
+namespace rho
+{
+IMPLEMENT_LOGCLASS(CRhoWKBrowserEngine,"WKEngine");
+
+WNDPROC CRhoWKBrowserEngine::m_WebKitOwnerProc = 0;
+CRhoWKBrowserEngine* CRhoWKBrowserEngine::m_pInstance = 0;
+
+LRESULT CALLBACK onTopmostWnd(EngineEventID eeID, LPARAM value, int tabIndex)
+{
+    LOG(INFO) + "onTopmostWnd";
+
+	// The engine needs to navigate to a page before it can provide the topmost window.
+	// We cannot call preload until we have a valid window handle
+	// If all of the instances have been loaded then the meta event and navigate event will be registered 
+	
+	return PostMessage(rho_wmimpl_get_mainwnd(),PB_ONTOPMOSTWINDOW,(LPARAM)tabIndex,(WPARAM)value);
+}
+
+LRESULT CALLBACK WK_ExitHandler(EngineEventID eeID, LPARAM value, int tabIndex)
+{
+    RHODESAPP().getExtManager().quitApp();
+    return (LRESULT)TRUE;
+}
+
+CRhoWKBrowserEngine* CRhoWKBrowserEngine::getInstance()
+{
+    return m_pInstance;
+}
+
+CRhoWKBrowserEngine* CRhoWKBrowserEngine::getInstance(HWND hParentWnd, HINSTANCE hInstance)
+{
+    if (!m_pInstance)
+        m_pInstance = new CRhoWKBrowserEngine(hParentWnd, hInstance);
+    return m_pInstance;
+}
+
+BOOL CRhoWKBrowserEngine::LoadWKDLL(WCHAR *path)
+{
+	m_hWKInstance = LoadLibrary(path);
+	if(m_hWKInstance)
+	{
+		m_pWKInitialize = (PWKINITIALIZE) GetProcAddress(m_hWKInstance, L"initialize");
+		m_pWKCleanUp = (PWKCLEANUP)    GetProcAddress(m_hWKInstance, L"cleanup");
+		m_pWKCreate = (PWKCREATE) GetProcAddress(m_hWKInstance, L"create");
+		m_pWKDestroy = (PWKDESTROY) GetProcAddress(m_hWKInstance, L"destroy");
+		m_pWKLoad = (PWKLOAD) GetProcAddress(m_hWKInstance, L"load");
+		m_pWKReload = (PWKRELOAD) GetProcAddress(m_hWKInstance, L"reload");
+		m_pWKStop = (PWKSTOP) GetProcAddress(m_hWKInstance, L"stop");
+		m_pWKRegisterForEvent = (PWKREGISTERFOREVENT) GetProcAddress(m_hWKInstance, L"RegisterForEvent");
+		m_pWKGetWKWindow = (PWGETWKWINDOW) GetProcAddress(m_hWKInstance, L"getWKWindow");
+		m_pWKJSInvoke = (PWKJSINVOKE) GetProcAddress(m_hWKInstance, L"jsInvoke");
+		m_pWKForward = (PWKFORWARD) GetProcAddress(m_hWKInstance, L"forward");
+		m_pWKResize = (PWKRESIZE) GetProcAddress(m_hWKInstance, L"resize");
+		m_pWKZoomPage = (PWKZOOMPAGE) GetProcAddress(m_hWKInstance, L"zoomPage");
+		m_pWKZoomText = (PWKZOOMTEXT) GetProcAddress(m_hWKInstance, L"zoomText");
+		m_pWKGetTextZoom = (PWKGETTEXTZOOM) GetProcAddress(m_hWKInstance, L"getTextZoom");
+		m_pWKBack = (PWKBACK) GetProcAddress(m_hWKInstance, L"back");
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+CRhoWKBrowserEngine::CRhoWKBrowserEngine(HWND hParentWnd, HINSTANCE hInstance)
+{	
+	LOG(INFO) + RHO_VERSION;
+
+
+	m_hParentWnd = hParentWnd;
+	//g_hBaseWnd = hParentWnd;
+	m_bLoadingComplete = false;
+	m_bLicenseChecked = false;
+	m_pInstance = this;
+
+	//webkit engine started, hence setting it to false
+	appQuitted = false;
+
+	/*HMODULE hModule = GetModuleHandleW(NULL);
+	WCHAR path[MAX_PATH];
+	GetModuleFileNameW(hModule, path, MAX_PATH);
+	WCHAR *pPath = wcsrchr(path, L'\\');
+	wsprintf(pPath, L"rhowebkit.dll");*/
+
+	if (LoadWKDLL(L"rhowebkit.dll") && m_pWKInitialize(hInstance) == S_OK)
+	{
+		m_pWKRegisterForEvent(EEID_TOPMOSTHWNDAVAILABLE, rho::onTopmostWnd);
+		m_pWKCreate(hParentWnd, true);
+	}
+	else
+	{
+		RHODESAPP().getExtManager().quitApp();
+	}
+	LOG(INFO) + "END WebKit";
+}
+
+CRhoWKBrowserEngine::~CRhoWKBrowserEngine(void)
+{
+	//application quitting hence setting it to true
+	appQuitted = true;
+	m_pWKDestroy(0);//implement multuple tab support
+	m_pWKCleanUp();
+}
+
+extern "C" bool isApplicationQuitting(){
+	return appQuitted;
+}
+
+BOOL CRhoWKBrowserEngine::Navigate(LPCTSTR szURL, int iTabID)
+{
+    LOG(INFO) + "Navigate :" + szURL;
+
+    BOOL res;
+
+#ifdef _DEBUG
+	//  DCC Testing the multi tab interface
+	if (wcsstr(szURL, L"createTab1") != 0)
+	{
+		//  Design is to always specify bForeground as False
+		int ret = NewTab();
+		//  TODO - NewTab should be blocking.  Since it isn't currently this doesn't work.
+		SwitchTab(1);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"navigateTab1") != 0)
+	{
+		REPLACE_WITH_ACTUAL_TAB_ID = 1;
+		LRESULT ret2 = Navigate(L"file:///he/miscellaneous/alerts.htm", 0);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"createTab2") != 0)
+	{
+		int ret = NewTab();
+		SwitchTab(2);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"navigateTab2") != 0)
+	{
+		REPLACE_WITH_ACTUAL_TAB_ID = 2;
+		LRESULT ret2 = Navigate(L"file:///he/miscellaneous/jserrors.htm", 0);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"switch0") != 0)
+	{
+		REPLACE_WITH_ACTUAL_TAB_ID = 0;
+		SwitchTab(0);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"switch1") != 0)
+	{
+		REPLACE_WITH_ACTUAL_TAB_ID = 1;
+		SwitchTab(1);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"switch2") != 0)
+	{
+		REPLACE_WITH_ACTUAL_TAB_ID = 2;
+		SwitchTab(2);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"close1") != 0)
+	{
+		CloseTab(1);
+		return TRUE;
+	}
+	else if (wcsstr(szURL, L"close2") != 0)
+	{
+		CloseTab(2);
+		return TRUE;
+	}
+#endif
+
+    if (wcslen(szURL) >= wcslen(L"javascript:") && wcsnicmp(szURL, L"javascript:", 11) == 0) {
+        res = m_pWKStop(iTabID);
+        if (res)
+            res = m_pWKJSInvoke(iTabID, szURL+11);
+    } else {
+        res = m_pWKLoad(szURL, iTabID);
+        //SetFocus(m_pWKGetWKWindow(iTabID));
+        InvalidateRect(m_pWKGetWKWindow(iTabID), NULL, FALSE);
+    }
+    return res;
+}
+
+HWND CRhoWKBrowserEngine::GetHTMLWND(int iTabID)
+{
+	return m_pWKGetWKWindow(iTabID);
+}
+
+//  Creates a new Tab and returns the newly created tab ID, will be -1 in case of error.
+int CRhoWKBrowserEngine::NewTab()
+{
+	int iNewTab = m_pWKCreate(m_hParentWnd, true);
+	ZoomPageOnTab((float)rho_wmimpl_get_pagezoom(),iNewTab);
+	return iNewTab;
+}
+
+//  Switches to the specified tab ID, returns the ID of the previous tab 
+//  or -1 in case of error
+int CRhoWKBrowserEngine::SwitchTab(int iTabID)
+{
+	if (iTabID >= 0){
+		ZoomPageOnTab((float)rho_wmimpl_get_pagezoom(),iTabID);
+		return m_pWKSwitch(iTabID);
+	}
+	else
+		return -1;
+}
+
+BOOL CRhoWKBrowserEngine::CloseTab(int iTabID)
+{
+	if (iTabID <= 0)
+	{
+		LOG(WARNING) + "ID of Tab to close must be positive and non-zero";
+		return FALSE;
+	}
+	return m_pWKDestroy(iTabID);
+}
+
+BOOL CRhoWKBrowserEngine::ResizeOnTab(int iInstID,RECT rcNewSize)
+{
+	ZoomPageOnTab((float)rho_wmimpl_get_pagezoom(),iInstID);
+    return m_pWKResize(iInstID,rcNewSize);
+}
+
+BOOL CRhoWKBrowserEngine::BackOnTab(int iInstID,int iPagesBack/* = 1*/)
+{
+	ZoomPageOnTab((float)rho_wmimpl_get_pagezoom(),iInstID);   
+	BOOL bRes = m_pWKBack(iInstID,iPagesBack);
+    if ( bRes )
+        InvalidateRect(m_pWKGetWKWindow(iInstID), NULL, FALSE);
+
+    return bRes;
+}
+
+BOOL CRhoWKBrowserEngine::ForwardOnTab(int iInstID)
+{
+	ZoomPageOnTab((float)rho_wmimpl_get_pagezoom(),iInstID);
+    BOOL bRes = m_pWKForward(iInstID);
+
+    if ( bRes )
+        InvalidateRect(m_pWKGetWKWindow(iInstID), NULL, FALSE);
+
+    return bRes;
+}
+
+BOOL CRhoWKBrowserEngine::ReloadOnTab(bool bFromCache, UINT iTab)
+{
+	ZoomPageOnTab((float)rho_wmimpl_get_pagezoom(),iTab);
+    BOOL bRes = m_pWKReload(bFromCache, iTab);
+    if ( bRes )
+        InvalidateRect(m_pWKGetWKWindow(iTab), NULL, FALSE);
+
+    return bRes;
+}
+
+BOOL CRhoWKBrowserEngine::StopOnTab(UINT iTab)
+{
+	ZoomPageOnTab((float)rho_wmimpl_get_pagezoom(),iTab);
+    return m_pWKStop(iTab);
+}
+
+BOOL CRhoWKBrowserEngine::ZoomPageOnTab(float fZoom, UINT iTab)
+{
+    return m_pWKZoomPage(fZoom, iTab);
+}
+
+BOOL CRhoWKBrowserEngine::ZoomTextOnTab(int nZoom, UINT iTab)
+{
+    return m_pWKZoomText((TextZoomValue)nZoom, iTab);
+}
+
+int CRhoWKBrowserEngine::GetTextZoomOnTab(UINT iTab)
+{
+    TextZoomValue eZoomLevel;
+    m_pWKGetTextZoom(&eZoomLevel, iTab);
+    return eZoomLevel;
+}
+
+BOOL CRhoWKBrowserEngine::NavigateToHtml(LPCTSTR szHtml)
+{
+    //return m_pEngine->NavigateToHtml(szHtml);
+    //TODO: NavigateToHtml
+
+    return FALSE;
+}
+
+bool CRhoWKBrowserEngine::isExistJavascript(const wchar_t* szJSFunction, int index)
+{
+    ///return m_pWKJSExist(index, szJSFunction) == TRUE ? true : false;
+	return true;
+}
+
+void CRhoWKBrowserEngine::executeJavascript(const wchar_t* szJSFunction, int index)
+{
+    StringW strUrlW;
+    if(_memicmp(szJSFunction,L"JavaScript:",11*2) != 0)
+        strUrlW = L"javascript:";	
+
+    strUrlW += szJSFunction;
+	StringW find = L"\"";
+	StringW replace = L"'";
+    findAndReplace<StringW>(strUrlW, find, replace);
+    m_pWKJSInvoke(index, strUrlW.c_str() );
+}
+
+void CRhoWKBrowserEngine::setBrowserGesturing(bool bEnableGesturing)
+{
+   ///m_pWKSetGesturing(bEnableGesturing);
+}
+
+void CRhoWKBrowserEngine::NotifyEngineOfSipPosition()
+{
+    ///m_pWKNotifyOfSipPosition();
+}
+
+void CRhoWKBrowserEngine::setNavigationTimeout(unsigned int dwMilliseconds)
+{
+    ///m_pWKSetNavTimeout(dwMilliseconds);
+}
+
+BOOL CRhoWKBrowserEngine::GetTitleOnTab(LPTSTR szURL, UINT iMaxLen, UINT iTab)
+{
+    return true;//m_pWKGetTitle(szURL, iMaxLen, iTab);
+}
+
+LRESULT CALLBACK CRhoWKBrowserEngine::WK_HTMLWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	if( !getInstance()->m_bLoadingComplete && message == WM_PAINT)
+    {
+		if ( rho_wmimpl_draw_splash_screen(getInstance()->GetHTMLWND(RHODESAPP().getExtManager().getCurrentTabID())) )
+            return 0;
+    }
+	
+	if(RHODESAPP().m_cameraOpened)
+	{
+		HWND hwndCamera = FindWindow(CAMERAWND_CLASSNAME, NULL);
+		if (NULL != hwndCamera)
+			SetActiveWindow(hwndCamera);
+	}
+
+	// Pass message to original window procedure
+	//return CallWindowProc (m_WebKitOwnerProc, hwnd, message, wParam, lParam);
+
+    LRESULT result = CallWindowProc (m_WebKitOwnerProc, hwnd, message, wParam, lParam);
+    MSG msg = {0};
+    msg.hwnd = hwnd;
+    msg.lParam = lParam;
+    msg.message = message;
+    msg.wParam = wParam;
+    RHODESAPP().getExtManager().onHTMLWndMsg(msg);
+    return result;
+}
+
+BOOL CALLBACK CRhoWKBrowserEngine::WK_WMMsgHandler(int iTabID,LPMSG pMsg)
+{
+	/******** THIS CANNOT STAY HERE, AS THE FUNCTION BELOW IT WOULD NEVER EXECUTE*********/ 
+	MSG msg = *pMsg;
+	if(pMsg->message == WM_PAINT)
+	{
+		return RHODESAPP().getExtManager().onHTMLWndMsg(msg);
+	}
+
+	/*
+	if (pMsg->message == WM_KILLFOCUS)
+	{
+		if (CRhoWKBrowserConfig::getInstance()->getFullScreen())
+		{
+			HWND taskbarWnd = FindWindow(L"HHTaskBar", NULL);
+			ShowWindow(taskbarWnd, SW_HIDE);
+			return FALSE;
+		}
+	}
+	*/
+  
+	if( !getInstance()->m_bLoadingComplete && pMsg->message == WM_PAINT)
+	{
+	   if ( rho_wmimpl_draw_splash_screen(getInstance()->GetHTMLWND(RHODESAPP().getExtManager().getCurrentTabID())) )
+		  return FALSE;
+	}
+  
+	if(RHODESAPP().m_cameraOpened)
+	{
+		HWND hwndCamera = FindWindow(CAMERAWND_CLASSNAME, NULL);
+		if (NULL != hwndCamera)
+			SetActiveWindow(hwndCamera);
+	}
+
+	if(RHODESAPP().isWebkitOutofProcess())
+		return RHODESAPP().getExtManager().onWndMsg(msg);
+	else
+		return FALSE;
+	
+}
+
+LRESULT CALLBACK CRhoWKBrowserEngine::WK_GetEngineConfig(int iInstID, LPCTSTR tcSetting, TCHAR* tcValue)
+{
+	/*LPCTSTR tcValueRead;
+
+    tcValueRead = CRhoWKBrowserConfig::getInstance()->getConfig()->GetAppSettingPtr(iInstID, tcSetting, L"Value");
+	if (tcValueRead != NULL)
+		wcscpy(tcValue, tcValueRead);
+	else
+		tcValue = NULL;
+
+    LOG(INFO) + "WebKit Settings: " + tcSetting + "=" + (tcValue ? tcValue : L"NULL");*/
+
+	return S_OK;
+} 
+
+LRESULT CALLBACK onNavEvent(EngineEventID eeID, LPARAM value, int tabIndex)
+{
+	BOOL bOk = FALSE;
+	DWORD dwRes = WAIT_FAILED;
+    HWND parentHWND = CRhoWKBrowserEngine::getInstance()->GetParentHWND();
+	switch(eeID)
+	{
+    case EEID_TITLECHANGE:
+        rho_title_change(tabIndex, (char*)value/*rho::common::convertToStringA((LPCTSTR)value).c_str()*/);
+        break;
+	/*case EEID_BEFORENAVIGATE:		
+	g_EditableControlHasFocus = FALSE;
+        if ( !CRhoWKBrowserEngine::getInstance()->getWKConfig()->isHybridApp() )
+            PostMessage(parentHWND, WM_BROWSER_ONBEFORENAVIGATE, (WPARAM)tabIndex, (LPARAM)_tcsdup( (LPCTSTR)value) );
+        else
+        { 
+            if ( CRhoWKBrowserEngine::getInstance()->getWebKitEngine()->Navigable((LPCTSTR)value) )
+                PostMessage(parentHWND, WM_BROWSER_ONBEFORENAVIGATE, (WPARAM)tabIndex, (LPARAM)_tcsdup( (LPCTSTR)value));
+            else
+                RHODESAPP().getExtManager().OnLicenseError((LPCTSTR)value);
+        }
+        break;*/
+    case EEID_NAVIGATECOMPLETE:
+        PostMessage(parentHWND, WM_BROWSER_ONNAVIGATECOMPLETE, (WPARAM)tabIndex, (LPARAM)_tcsdup( (LPCTSTR)value) );
+        break;
+	case EEID_DOCUMENTCOMPLETE:
+		{
+			LOG(INFO) + "before calling dominjector ";
+			RHODESAPP().getExtManager().getEngineEventMngr().injectDOMElements();
+			PostMessage(parentHWND, WM_BROWSER_ONDOCUMENTCOMPLETE, (WPARAM)tabIndex, (LPARAM)_tcsdup( (LPCTSTR)value));
+
+            if ( !CRhoWKBrowserEngine::getInstance()->m_bLoadingComplete )
+            {
+                CRhoWKBrowserEngine::getInstance()->m_bLoadingComplete = true;
+                InvalidateRect(CRhoWKBrowserEngine::getInstance()->GetHTMLWND(RHODESAPP().getExtManager().getCurrentTabID()), NULL, FALSE);
+            }
+
+			break;
+		}
+    case EEID_NAVIGATIONERROR:
+		//Check for common protocols
+		if (
+			(_tcsncmp((LPCTSTR)value,TEXT("tel:"),4) == 0) ||
+			(_tcsncmp((LPCTSTR)value,TEXT("sms:"),4) == 0) ||
+			(_tcsncmp((LPCTSTR)value,TEXT("mailto:"),7) == 0))
+			{
+				SHELLEXECUTEINFO	shInfo;
+	
+				//Run the Program
+				ZeroMemory(&shInfo,sizeof(shInfo));
+				shInfo.cbSize = sizeof(shInfo);
+				shInfo.fMask  = SEE_MASK_FLAG_NO_UI | SEE_MASK_NOCLOSEPROCESS;
+				shInfo.lpVerb   = L"open";
+				shInfo.lpFile = (LPCTSTR)value;
+				shInfo.nShow  = SW_SHOWNORMAL;
+				ShellExecuteEx(&shInfo);
+				CloseHandle(shInfo.hProcess);
+				PostMessage(parentHWND, WM_BROWSER_ONDOCUMENTCOMPLETE, tabIndex, (LPARAM)_tcsdup( (LPCTSTR)value) );
+				return S_OK;
+			}
+
+        LOG(ERROR) + "Navigation error: " + (LPCTSTR)value;
+
+        PostMessage(parentHWND, WM_BROWSER_ONNAVIGATIONERROR, (WPARAM)tabIndex, (LPARAM)_tcsdup( (LPCTSTR)value));
+        return S_OK;
+        break;
+    case EEID_NAVIGATIONTIMEOUT:
+        PostMessage(parentHWND, WM_BROWSER_ONNAVIGATIONTIMEOUT, (WPARAM)tabIndex, (LPARAM)_tcsdup( (LPCTSTR)value));
+        return S_OK;
+        break;	
+    }
+
+    return S_OK;
+}
+
+LRESULT CALLBACK onFieldFocus(EngineEventID eeID, LPARAM value, int tabIndex)
+{
+    g_EditableControlHasFocus = (BOOL)value;
+	m_hEditableWindow = GetFocus();
+    return PostMessage(rho_wmimpl_get_mainwnd(), WM_BROWSER_ONSETSIPSTATE, (WPARAM)tabIndex, value);
+}
+
+LRESULT CALLBACK onConsoleMessage(EngineEventID eeID, LPARAM value, int tabIndex)
+{
+    LOG(INFO) + "JS Log: " + (LPCTSTR)value;
+
+    return S_OK;
+}
+
+LRESULT CRhoWKBrowserEngine::ProcessOnTopMostWnd(HWND hWnd, int tabIndex)
+{
+    LOG(INFO) + "ProcessOnTopMostWnd";
+
+	
+	if(tabIndex)return S_OK;//only register on the first tab created, which will be 0 
+		
+	if(!m_pWKRegisterForEvent(EEID_ENGINE_EXIT,WK_ExitHandler)){
+		return S_FALSE;
+	}
+	
+	if(!m_pWKRegisterForEvent(EEID_DOCUMENTCOMPLETE,onNavEvent)){
+		return S_FALSE;
+	}
+	if(!m_pWKRegisterForEvent(EEID_NAVIGATECOMPLETE,onNavEvent)){
+		return S_FALSE;
+	}
+	if(!m_pWKRegisterForEvent(EEID_BEFORENAVIGATE,onNavEvent)){
+		return S_FALSE;
+	}	
+
+	if(!m_pWKRegisterForEvent(EEID_TITLECHANGE,onNavEvent)){
+		return S_FALSE;
+	}
+
+	//Fired when the page load takes longer than the value specified by 'NavTimeout' in the config file
+	if(!m_pWKRegisterForEvent(EEID_NAVIGATIONTIMEOUT,onNavEvent)){
+		return S_FALSE;
+	}
+	//  Fired when the engine indicates an editable field has been clicked on
+	if (!m_pWKRegisterForEvent(EEID_SETSIPSTATE, onFieldFocus))
+	{
+	}
+	//  Fired when the engine gives us a console log message (JS error or window.console.log)
+	if (!m_pWKRegisterForEvent(EEID_CONSOLEMESSAGE, onConsoleMessage))
+	{
+	}
+
+	//Fired if there is an error navigating to the page, for example attempting to navigate to http://www.symbol.com if the device does not have a network connection.
+	if(!m_pWKRegisterForEvent(EEID_NAVIGATIONERROR,onNavEvent)){
+		return S_FALSE;
+	}
+
+    return S_OK;
+}
+
+LRESULT CRhoWKBrowserEngine::OnWebKitMessages(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
+{
+	int iTabID;
+	LPTSTR pStr;
+
+    bHandled = TRUE;
+
+    switch (uMsg) 
+    {
+		
+		case PB_ONTOPMOSTWINDOW:
+        {
+            LOG(INFO) + "START WK_ONTOPMOSTWINDOW";
+			/*return*/ CRhoWKBrowserEngine::ProcessOnTopMostWnd((HWND)lParam,(int)wParam); 
+			//LRESULT rtRes = g_pAppManager->ProcessOnTopMostWnd((HWND)lParam,(int)wParam); 
+            LRESULT rtRes = rho_wm_appmanager_ProcessOnTopMostWnd(wParam, lParam);
+			//if(rtRes == S_FALSE){
+			//	PostMessage(PB_GEN_QUIT,0,0);//we have not successfully processed the topMostWindow so shutdown
+			//}
+            LOG(INFO) + "END WK_ONTOPMOSTWINDOW";
+			return rtRes;
+            break;
+        }		
+		case PB_WINDOW_RESTORE:
+			//  The window has been restored 
+			//BrowserRestore(0, NULL);
+	        ShowWindow(m_pWKGetWKWindow(RHODESAPP().getExtManager().getCurrentTabID()), SW_RESTORE);
+	        //  Hide the Start Bar
+	        //PBScreenMode(g_bFullScreen, FALSE);
+	        SetForegroundWindow(m_pWKGetWKWindow(RHODESAPP().getExtManager().getCurrentTabID()));
+	        EnableWindow(m_pWKGetWKWindow(RHODESAPP().getExtManager().getCurrentTabID()), TRUE);
+
+            //RHODESAPP().getExtManager().OnWindowChanged((LPVOID) WK_WINRESTORED);
+            
+			break;
+		case PB_SCREEN_ORIENTATION_CHANGED:
+            RHODESAPP().getExtManager().OnWindowChanged((LPVOID) lParam);
+			//g_bLeftRotated = wParam == TYPEHERE?TRUE:FALSE;//update the global
+			//use a thread so that we don't hold up the message pump
+			//CloseHandle(CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) WindowChangedThread,(LPVOID) lParam, 0, 0));
+			break;
+
+    }
+
+    return 0;
+}
+
+void CRhoWKBrowserEngine::RunMessageLoop(CMainWindow& mainWnd)
+{
+	//tPB_PreprocessMessage lpPreprocessMessage = m_pEngine->GetlpPreprocessMessage();
+
+	//LRESULT preProcRes;
+    MSG msg;
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        //In the case of webkit inprocess, On keydown, it invokes RunMessageLoop followed by  WK_WMMsgHandler.     
+        //In the case of webkit outprocess, whenever Ehkio window has the focus, it invokes only WK_WMMsgHandler.
+        //But whenever webkit loses focus and MainWindow gets the focus, WM_KEYDOWN message will invoke RunMessageLoop and 
+        //it won't invoke WK_WMMsgHandler
+        //We have lots of logic sucha as camera logic inside WK_WMMsgHandler, so we have to explicitly 
+        //invoke this method if focus is with MainWindow
+        if(RHODESAPP().isWebkitOutofProcess())
+        {
+            //we reach here for outproc, WK_WMMsgHandler internally handover the message to extention manager
+            WK_WMMsgHandler(0,&msg);
+        }
+        else
+        {
+        	if((WM_KEYDOWN == msg.message)||((WM_KEYUP == msg.message))||((WM_CHAR == msg.message)))
+			{
+				if(msg.wParam==VK_BACK)
+				{
+					HWND checkCurrentWindow = GetActiveWindow();
+					HWND checkIsParentHWND = CRhoWKBrowserEngine::getInstance()->GetParentHWND();
+					if(!g_EditableControlHasFocus && (checkCurrentWindow == checkIsParentHWND))
+					{
+						continue;	
+					}
+				}
+				if(g_EditableControlHasFocus)
+				{
+					HWND checkFocusWindow = GetFocus();
+					if(m_hEditableWindow)
+					{
+						if(m_hEditableWindow != checkFocusWindow)
+						{
+							SetFocus(m_hEditableWindow);
+						}
+					}
+				}
+			}
+				
+			//we reach here, only in the case of inproc
+			if( RHODESAPP().getExtManager().onWndMsg(msg) )
+				continue;
+        }
+
+
+	    if (!TranslateAccelerator(msg.hwnd, 0, &msg))
+        //if (!mainWnd.TranslateAccelerator(&msg))
+	    {
+		    TranslateMessage(&msg);
+		    DispatchMessage(&msg);
+	    }		
+    }
+}
+
+void CRhoWKBrowserEngine::SetCookie(char* url, char* cookie)
+{
+    // can't implement: no webkit method exposed!
+}
+
+void CRhoWKBrowserEngine::OnDocumentComplete(LPCTSTR url)
+{
+}
+
+}
+
+rho::IBrowserEngine* rho_wmimpl_get_webkitBrowserEngine(HWND hwndParent, HINSTANCE rhoAppInstance)
+{
+    return rho::CRhoWKBrowserEngine::getInstance(hwndParent, rhoAppInstance);
+}
+