internal object InvokeInternal(string name, params object [] args) { CheckName(name); CheckHandle(); int length = args == null ? 0 : args.Length; object result = null; Mono.Value res; Mono.Value [] vargs = new Mono.Value [length]; for (int i = 0; i < length; i++) { ScriptObjectHelper.ToValue(ref vargs [i], args [i]); } if (!NativeMethods.html_object_invoke(PluginHost.Handle, Handle, name, vargs, (uint)length, out res)) { throw new InvalidOperationException(); } using (res) if (res.k != Mono.Kind.INVALID) { result = ScriptObjectHelper.FromValue(res); } return(result); }
internal object InvokeSelfInternal(params object [] args) { CheckHandle(); int length = args == null ? 0 : args.Length; object result = null; Mono.Value res; Mono.Value [] vargs = new Mono.Value [length]; for (int i = 0; i < length; i++) { ScriptObjectHelper.ToValue(ref vargs [i], args [i]); } try { if (!NativeMethods.html_object_invoke_self(PluginHost.Handle, Handle, vargs, (uint)length, out res)) { throw new InvalidOperationException(); } if (res.k != Mono.Kind.INVALID) { result = ScriptObjectHelper.FromValue(res); } } finally { res.Dispose(); foreach (var v in vargs) { v.Dispose(); } } return(result); }
public static async Task <BrowserInformation> GetBrowserInformation() { if (browserInfoFunction == null) { browserInfoFunction = await WebSharp.CreateJavaScriptFunction( @"return function (data, callback) { try { let browserInfo = {}; browserInfo['appName'] = navigator.appName; //browserInfo['appVersion'] = navigator.appVersion; browserInfo['appVersion'] = process.versions.chrome; browserInfo['userAgent'] = navigator.userAgent; browserInfo['platform'] = navigator.platform; browserInfo['cookieEnabled'] = navigator.cookieEnabled; browserInfo['appCodeName'] = navigator.appCodeName; callback(null, browserInfo); } catch (e) { callback(e, null); } }"); } var eval = await browserInfoFunction(null); if (eval != null) { var bi = new BrowserInformation(); ScriptObjectHelper.DictionaryToScriptableType((IDictionary <string, object>)eval, bi); return(bi); } return(default(BrowserInformation)); }
internal object Invoke(object evt) { var eventArgs = new HtmlEventArgs(); if (evt != null) { var dict = (IDictionary <string, object>)((object[])evt)[0]; ScriptObjectHelper.DictionaryToScriptableType(dict, eventArgs); } EventHandlers?.Invoke(this.Source, eventArgs); if (EventHandlers == null) { try { var eventDelegate = (MulticastDelegate)Source.GetType().GetTypeInfo().GetField(EventName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).GetValue(Source); eventDelegate.DynamicInvoke(new object[] { Source, EventArgs.Empty }); } catch (Exception exc) { // We get an exception if there is nothing to invoke Console.WriteLine($"exception {exc.Message}"); } } return(null); }
bool SetPropertyFromUnmanaged(string scriptAlias, IntPtr[] uargs, int arg_count, ref Value value) { if (ManagedObject is IDictionary) { IDictionary dic = ManagedObject as IDictionary; dic[scriptAlias] = ScriptObjectHelper.FromValue(value); return(true); } else if (properties != null && properties.ContainsKey(scriptAlias)) { object[] args = new object[arg_count + 1]; for (int i = 0; i < arg_count; i++) { if (uargs[i] == IntPtr.Zero) { args[i] = null; } else { Value val = (Value)Marshal.PtrToStructure(uargs[i], typeof(Value)); args[i] = ScriptObjectHelper.FromValue(val); } } args[arg_count] = ScriptObjectHelper.FromValue(value); SetProperty(scriptAlias, args); return(true); } else if (events != null && events.ContainsKey(scriptAlias)) { if (arg_count != 0) { throw new InvalidOperationException("arg count != 0"); } EventInfo einfo = events[scriptAlias]; if (value.k != Kind.NPOBJ) { throw new InvalidOperationException("html bridge only allows function objects as event delegates"); } ScriptObject event_object = ScriptObjectHelper.FromValue(value) as ScriptObject; if (event_object == null) { RemoveEventHandler(scriptAlias, null); } else { AddEventHandler(scriptAlias, event_object, einfo); } return(true); } else { return(false); } }
internal void Invoke(string name, object[] args, ref Value ret) { if (methods != null && methods.ContainsKey(name)) { foreach (Method method in methods[name]) { if (method.method != null) { if (ValidateArguments(method.method, args)) { object rv = Invoke(method.method, method.obj, args); if (method.method.ReturnType != typeof(void)) { ScriptObjectHelper.ToValue(ref ret, rv); } return; } } } } Console.WriteLine("ScriptObject.Invoke: NOT IMPLEMENTED: {0}", name.ToLower()); }
bool GetPropertyFromUnmanaged(string scriptAlias, IntPtr[] uargs, int arg_count, ref Value value) { object[] args; if (ManagedObject is IDictionary && scriptAlias != "item") { args = new object[] { scriptAlias }; scriptAlias = "item"; } else { args = new object[arg_count]; for (int i = 0; i < arg_count; i++) { if (uargs[i] == IntPtr.Zero) { args[i] = null; } else { Value val = (Value)Marshal.PtrToStructure(uargs[i], typeof(Value)); args[i] = ScriptObjectHelper.FromValue(val); } } } object v = GetProperty(scriptAlias, args); ScriptObjectHelper.ToValue(ref value, v); return(true); }
internal T GetProperty <T> (string name) { object o = GetProperty(name); ScriptObjectHelper.TryChangeType(o, typeof(T), null, out o); return((T)o); }
public async Task <LoginItemSettings> GetLoginItemSettings() { var settings = await Invoke <object>("getLoginItemSettings"); var lis = new LoginItemSettings(); ScriptObjectHelper.DictionaryToScriptableType((System.Collections.Generic.IDictionary <string, object>)settings, lis); return(lis); }
internal static void SetPropertyInternal(IntPtr h, string name, object value) { CheckName(name); Mono.Value dp = new Mono.Value(); ScriptObjectHelper.ToValue(ref dp, value); using (dp) { NativeMethods.html_object_set_property(PluginHost.Handle, h, name, ref dp); } }
internal bool ValidateArguments(MethodInfo mi, object[] args) { if (mi.GetParameters().Length != args.Length) { int required_paramcount = 0; bool optional_param = false; foreach (ParameterInfo p in mi.GetParameters()) { if (IsOptional(p)) { optional_param = true; break; } required_paramcount++; } // if we don't supply enough required arguments, we fail regardless of optional parameters. if (required_paramcount > args.Length) { return(false); } // if we don't have optional parameters, make sure we don't supply more than the required arguments. if (!optional_param && args.Length > required_paramcount) { return(false); } } // TODO: refactor this, the js binder is doing this work already ParameterInfo[] parms = mi.GetParameters(); for (int i = 0; i < parms.Length; i++) { if (IsOptional(parms[i])) { break; } if (args[i] == null) { continue; } Type cstype = parms[i].ParameterType; object ret; if (ScriptObjectHelper.TryChangeType(args[i], cstype, CultureInfo.CurrentUICulture, out ret)) { continue; } } return(true); }
public override object Invoke(string name, params object [] args) { // this should likely call an Invoke overload passing ManagedObject in, instead of "this", // but we already do the book keeping in the base class, so do we need this method at all? Value v = new Value(); base.Invoke(name, args, ref v); return(ScriptObjectHelper.FromValue(v)); }
public async Task <Location> GetLocation() { var location = await GetProperty <object>("location"); if (location != null) { var loc = new Location(); ScriptObjectHelper.DictionaryToScriptableType((IDictionary <string, object>)location, loc); return(loc); } return(default(Location)); }
public async Task <Bookmark> ReadBookmark(ClipboardType type = ClipboardType.None) { var result = await Invoke <object>("readBookmark", type == ClipboardType.Selection? "selection" : string.Empty); var bm = new Bookmark(); if (result != null) { ScriptObjectHelper.DictionaryToScriptableType((System.Collections.Generic.IDictionary <string, object>)result, bm); } return(bm); }
async Task <object> MenuItemClicked(object[] mi) { try { var menuItemSelected = (MenuItem)(ScriptObjectHelper.AnonymousObjectToScriptObjectProxy(mi[0])); console.Log($"MenuItem: {await menuItemSelected.GetLabel()} was selected and the item is checked {await menuItemSelected.GetChecked()}"); } catch (Exception exc) { System.Console.WriteLine(exc); } return(null); }
internal static object GetPropertyInternal(IntPtr h, string name) { object result = null; CheckName(name); Mono.Value res; NativeMethods.html_object_get_property(PluginHost.Handle, h, name, out res); using (res) if (res.k != Mono.Kind.INVALID) { result = ScriptObjectHelper.FromValue(res); } return(result); }
public async Task <bool> DispatchEvent(Events.Event evt) { if (evt == null) { throw new ArgumentNullException(nameof(evt)); } var parm = new { handle = Handle, eventArg = ScriptObjectHelper.ScriptableTypeToDictionary(evt) }; return(await WebSharp.Bridge.JavaScriptBridge.websharp_dispatchEvent(parm)); }
internal object Invoke(object evt) { var eventArgs = new HtmlEventArgs(); defaultPrevented = false; cancelBubble = false; eventArgs.PreventDefaultAction = () => { defaultPrevented = true; }; eventArgs.StopPropagationAction = () => { cancelBubble = true; }; if (evt != null) { try { var dict = (IDictionary <string, object>)((object[])evt)[0]; ScriptObjectHelper.DictionaryToScriptableType(dict, eventArgs); if (eventArgs.DataTransfer != null) { dropEffect = eventArgs.DataTransfer.DropEffectValue; eventArgs.DataTransfer.DropEffectAction = (eff) => { dropEffect = eff; }; } } catch (Exception evtExc) { Console.WriteLine($"Error parsing HtmlEventArgs: {evtExc.Message}"); } } EventHandlers?.Invoke(this.Source, eventArgs); if (EventHandlers == null) { try { var eventDelegate = (MulticastDelegate)Source.GetType().GetTypeInfo().GetField(EventName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).GetValue(Source); eventDelegate.DynamicInvoke(new object[] { Source, EventArgs.Empty }); } catch (Exception exc) { // We get an exception if there is nothing to invoke Console.WriteLine($"WebSharpHtmlEvent Invoke Exception {exc.Message}"); } } return(null); }
bool InvokeFromUnmanaged(string name, IntPtr[] uargs, int arg_count, ref Value return_value) { object[] args = new object[arg_count]; for (int i = 0; i < arg_count; i++) { if (uargs[i] == IntPtr.Zero) { args[i] = null; } else { Value v = (Value)Marshal.PtrToStructure(uargs[i], typeof(Value)); args[i] = ScriptObjectHelper.FromValue(v); } } Invoke(name, args, ref return_value); return(true); }
public object Eval(string code) { if (code == null) { throw new ArgumentNullException("code"); } if (code.Length == 0) { throw new ArgumentException("code"); } IntPtr result; result = Mono.NativeMethods.plugin_instance_evaluate(PluginHost.Handle, code); if (result != IntPtr.Zero) { Value v = (Value)Marshal.PtrToStructure(result, typeof(Value)); return(ScriptObjectHelper.FromValue(v)); } return(null); }
/// <summary> /// Default entry into managed code. /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task <object> Invoke(object input) { if (console == null) { console = await WebSharpJs.NodeJS.Console.Instance(); } try { ipcRenderer = await IpcRenderer.Create(); document = await HtmlPage.GetDocument(); var form = await document.QuerySelector("form"); // Input fields source = await form.QuerySelector("input[name=\"source\"]"); destination = await form.QuerySelector("input[name=\"destination\"]"); name = await form.QuerySelector("input[name=\"name\"]"); // Buttons btnSource = await document.GetElementById("chooseSource"); btnDestination = await document.GetElementById("chooseDestination"); btnSubmit = await form.QuerySelector("button[type=\"submit\"]"); // Handle input fields await source.AttachEvent(HtmlEventNames.Input, updateUI); await source.AttachEvent(HtmlEventNames.Change, updateUI); await destination.AttachEvent(HtmlEventNames.Input, updateUI); await destination.AttachEvent(HtmlEventNames.Change, updateUI); await name.AttachEvent(HtmlEventNames.Input, updateUI); // Handle buttons await btnSource.AttachEvent(HtmlEventNames.Click, handleSource); await btnDestination.AttachEvent(HtmlEventNames.Click, handleDestination); // Handle form Submit await form.AttachEvent(HtmlEventNames.Submit, async (s, e) => { e.PreventDefault(); await ToggleUI(true); // Send off the convert request await ipcRenderer.Send("submitform", await source.GetProperty <string>("value"), await destination.GetProperty <string>("value"), await name.GetProperty <string>("value") ); } ); await ipcRenderer.AddListener("gotMetaData", new IpcRendererEventListener( async(result) => { var state = result.CallbackState as object[]; var ipcMainEvent = (IpcRendererEvent)state[0]; var parms = state[1] as object[]; var audio = ScriptObjectHelper.AnonymousObjectToScriptableType <Audio>(parms[0]); var video = ScriptObjectHelper.AnonymousObjectToScriptableType <Video>(parms[1]); var duration = TimeSpan.Parse(parms[2].ToString()); await updateInfo(audio, video, duration); } ) ); await ipcRenderer.AddListener("completed", new IpcRendererEventListener( async(result) => { await ToggleUI(false); } ) ); await console.Log($"Hello: {input}"); } catch (Exception exc) { await console.Log($"extension exception: {exc.Message}"); } return(null); }