bool ILifeSpanHandler.DoClose(IWebBrowser browserControl, IBrowser browser)
{
//The default CEF behaviour (return false) will send a OS close notification (e.g. WM_CLOSE).
//See the doc for this method for full details.
//return true here to handle closing yourself (no WM_CLOSE will be sent).
return true;
}
void IDisplayHandler.OnFullscreenModeChange(IWebBrowser browserControl, IBrowser browser, bool fullscreen)
{
var chromiumWebBrowser = (ChromiumWebBrowser)browserControl;
chromiumWebBrowser.InvokeOnUiThreadIfRequired(() =>
{
if (fullscreen)
{
parent = chromiumWebBrowser.Parent;
parent.Controls.Remove(chromiumWebBrowser);
fullScreenForm = new Form();
fullScreenForm.FormBorderStyle = FormBorderStyle.None;
fullScreenForm.WindowState = FormWindowState.Maximized;
fullScreenForm.Controls.Add(chromiumWebBrowser);
fullScreenForm.ShowDialog(parent.FindForm());
}
else
{
fullScreenForm.Controls.Remove(chromiumWebBrowser);
parent.Controls.Add(chromiumWebBrowser);
fullScreenForm.Close();
fullScreenForm.Dispose();
fullScreenForm = null;
}
});
}
public bool OnBeforeBrowse(IWebBrowser browser, IRequest request, bool isRedirect)
{
if (request.Url.ToLower() != "http://www.google.com/")
{
try
{
if (PluginSettings.Instance.OpenInInternalBrowser)
{
_parent.BeginInvoke((Action)(() =>
{
Utils.BasePlugin.Plugin p = Utils.PluginSupport.PluginByName(_core, "GlobalcachingApplication.Plugins.Browser.BrowserPlugin") as Utils.BasePlugin.Plugin;
if (p != null)
{
var m = p.GetType().GetMethod("OpenNewBrowser");
m.Invoke(p, new object[] { request.Url.ToString() });
}
}));
}
else
{
System.Diagnostics.Process.Start(request.Url.ToString());
}
return true;
}
catch
{
}
}
return false;
}
void IRequestHandler.OnResourceResponse(IWebBrowser browser, string url, int status, string statusText, string mimeType, WebHeaderCollection headers)
{
if (url.Contains("battlelog-web-plugins"))
{
this.InitUpdateWebPlugin(url);
}
}
public bool OnBeforeContextMenu(IWebBrowser browser, IContextMenuParams parameters)
{
if (parameters.IsEditable)
return true;
return false;
}
public ChatDocument(IInlineUploadViewFactory factory, IWebBrowser browser, IPasteViewFactory pasteViewFactory)
{
_factory = factory;
_browser = browser;
_pasteViewFactory = pasteViewFactory;
_handlers = new Dictionary<MessageType, Action<Message, User, Paragraph>>
{
{MessageType.TextMessage, FormatUserMessage},
{MessageType.TimestampMessage, FormatTimestampMessage},
{MessageType.LeaveMessage, FormatLeaveMessage},
{MessageType.KickMessage, FormatKickMessage},
{MessageType.PasteMessage, FormatPasteMessage},
{MessageType.EnterMessage, FormatEnterMessage},
{MessageType.UploadMessage, FormatUploadMessage},
{MessageType.TweetMessage, FormatTweetMessage},
{MessageType.AdvertisementMessage, FormatAdvertisementMessage},
{MessageType.TopicChangeMessage, FormatTopicChangeMessage}
};
FontSize = 14;
FontFamily = new FontFamily("Segoe UI");
AddHandler(Hyperlink.RequestNavigateEvent, new RequestNavigateEventHandler(NavigateToLink));
}
internal ContinuousConsoleRunner(
ILogger logger,
IEventSubscriptionManager eventSubscriptionManager,
IEventPublisher eventPublisher ,
string xapPath,
ClientTestRunConfiguration clientTestRunConfiguration,
IWebServer webServer,
IWebBrowser webBrowser)
{
_xapPath = xapPath;
_webServer = webServer;
_xapFileBuildChangedMonitor = new XapFileBuildChangedMonitor(eventPublisher, _xapPath);
_continuousRunnerThread = new Thread(() =>
{
using (var runner = new ContinuousTestRunner(logger, eventSubscriptionManager, eventPublisher, webBrowser, clientTestRunConfiguration, _xapPath))
{
string line;
while (!(line = System.Console.ReadLine()).Equals("exit", StringComparison.OrdinalIgnoreCase))
{
runner.ForceFilteredTest(line);
}
}
});
}
public bool OnBeforeResourceLoad(IWebBrowser browser, IRequestResponse requestResponse)
{
Assembly asm = Assembly.GetExecutingAssembly();
string MIME = "application/octet-stream";
string requestURL = requestResponse.Request.Url, _lower = requestURL.ToLower();
if ((_lower == manifestProtocol + "postdata" || _lower.StartsWith(manifestProtocol + "postdata?"))
&& PostContentReceived != null)
PostContentReceived(browser, new ContentReceivedEventArgs(requestResponse.Request.Body));
if (requestURL.Contains('?'))
requestURL = requestURL.Substring(0, requestURL.IndexOf('?'));
_lower = requestURL.ToLower();
if (_lower.StartsWith(manifestProtocol)) {
if (_lower.EndsWith(".html") || _lower.EndsWith(".htm"))
MIME = "text/html";
else if (_lower.EndsWith(".css"))
MIME = "text/css";
else if (_lower.EndsWith(".js"))
MIME = "text/javascript";
else if (_lower.EndsWith(".txt"))
MIME = "text/plain";
requestURL = requestURL.Substring(manifestProtocol.Length);
if (requestURL == "res/lang.js")
requestURL = strings.script_path;
requestURL = requestURL.Replace('/', '.').Replace(' ', '_');
try {
requestResponse.RespondWith(asm.GetManifestResourceStream(asm.GetName().Name + "." + requestURL), MIME);
} catch { }
}
return false;
}
void IContextMenuHandler.OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model)
{
//Removing existing menu item
model.Remove(CefMenuCommand.ViewSource); // Remove "View Source" option
model.Remove(CefMenuCommand.Print);
//Add new custom menu items
model.AddItem((CefMenuCommand)ViewSource, "View Page Source");
if (parameters.TypeFlags.HasFlag(ContextMenuType.Media) && parameters.HasImageContents)
{
if(OsirtHelper.HasJpegExtension(parameters.SourceUrl))
{
model.AddItem((CefMenuCommand)ViewImageExifData, "View image EXIF data");
}
model.AddItem((CefMenuCommand)MenuSaveImage, "Save image");
model.AddItem((CefMenuCommand)CopyImgLocation, "Copy image location to clipboard");
model.AddItem((CefMenuCommand)ReverseImageSearch, "Reverse image search using TinEye");
}
if(OsirtHelper.IsOnYouTube(browserControl.Address))
{
model.AddItem((CefMenuCommand)SaveYouTubeVideo, "Extract YouTube video");
}
if (OsirtHelper.IsOnFacebook(browserControl.Address))
{
model.AddItem((CefMenuCommand)ViewFacebookId, "Show Facebook profile ID");
}
if(!string.IsNullOrEmpty(parameters.UnfilteredLinkUrl))
{
model.AddItem((CefMenuCommand)26501, "Open link in new tab");
}
}
public IResourceHandler GetResourceHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request)
{
// Every time we request the main GPM page allow another JS injection
if (Regex.Match(request.Url, @"^http[s]?://play\.google\.com/music/listen", RegexOptions.IgnoreCase).Success)
{
firstJSOnly = true;
}
if (Regex.Match(request.Url, @"\.js", RegexOptions.IgnoreCase).Success && Regex.Match(request.Url, @"http", RegexOptions.IgnoreCase).Success && firstJSOnly)
{
firstJSOnly = false;
using (WebClient webClient = new WebClient())
{
// These are the JS files to inject into GPM
string custom_interface = Properties.Resources.custom_interface;
return ResourceHandler.FromStream(new MemoryStream(Encoding.UTF8.GetBytes(
webClient.DownloadString(request.Url) + ";window.onload=function(){csharpinterface.showApp();};document.addEventListener('DOMContentLoaded', function () {" +
"window.OBSERVER = setInterval(function() { if (document.getElementById('material-vslider')) { clearInterval(window.OBSERVER); " +
Properties.Resources.gmusic_min + Properties.Resources.gmusic_theme_min + Properties.Resources.gmusic_mini_player_min +
this.getInitCode() +
custom_interface +
"}}, 10);});")), webClient.ResponseHeaders["Content-Type"]);
}
}
return null;
}
CefReturnValue IRequestHandler.OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IRequestCallback callback)
{
using (callback)
{
if (request.Method == "POST")
{
using (var postData = request.PostData)
{
var elements = postData.Elements;
var charSet = request.GetCharSet();
foreach (var element in elements)
{
if (element.Type == PostDataElementType.Bytes)
{
var body = element.GetBody(charSet);
}
}
}
}
//Note to Redirect simply set the request Url
//if (request.Url.StartsWith("https://www.google.com", StringComparison.OrdinalIgnoreCase))
//{
// request.Url = "https://github.com/";
//}
//Callback in async fashion
//callback.Continue(true);
//return CefReturnValue.ContinueAsync;
}
return CefReturnValue.Continue;
}
bool IRequestHandler.OnBeforeBrowse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request,
bool isRedirect) {
if (!frame.IsMain || CommonUrls.IsWithSixUrl(request.Url) || IsAuthUrl(new Uri(request.Url)))
return false;
OpenInSystemBrowser(request.Url);
return true;
}
CefReturnValue IRequestHandler.OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame,
IRequest request, IRequestCallback callback) {
if (CommonUrls.IsWithSixUrl(request.Url)) {
var headers = request.Headers;
headers[Common.ClientHeader] = DomainEvilGlobal.SecretData.UserInfo.ClientId.ToString();
headers[Common.ClientHeaderV] = Common.App.ProductVersion;
request.Headers = headers;
}
return CefReturnValue.Continue;
//Example of how to set Referer
// Same should work when setting any header
// For this example only set Referer when using our custom scheme
var url = new Uri(request.Url);
if (url.Scheme == "customscheme") // CefSharpSchemeHandlerFactory.SchemeName
{
var headers = request.Headers;
headers["Referer"] = "http://google.com";
request.Headers = headers;
}
//NOTE: If you do not wish to implement this method returning false is the default behaviour
// We also suggest you explicitly Dispose of the callback as it wraps an unmanaged resource.
//callback.Dispose();
//return false;
//NOTE: When executing the callback in an async fashion need to check to see if it's disposed
if (!callback.IsDisposed) {
using (callback) {
if (request.Method == "POST") {
using (var postData = request.PostData) {
if (postData != null) {
var elements = postData.Elements;
var charSet = request.GetCharSet();
foreach (var element in elements) {
if (element.Type == PostDataElementType.Bytes) {
var body = element.GetBody(charSet);
}
}
}
}
}
//Note to Redirect simply set the request Url
//if (request.Url.StartsWith("https://www.google.com", StringComparison.OrdinalIgnoreCase))
//{
// request.Url = "https://github.com/";
//}
//Callback in async fashion
//callback.Continue(true);
//return CefReturnValue.ContinueAsync;
}
}
return CefReturnValue.Continue;
}
public bool OnJSDialog(IWebBrowser browserControl, IBrowser browser, string originUrl, string acceptLang, CefJsDialogType dialogType, string messageText, string defaultPromptText, IJsDialogCallback callback, ref bool suppressMessage)
{
switch (dialogType)
{
case CefJsDialogType.Alert:
MessageBox.Show(messageText);
suppressMessage = true;
return false;
case CefJsDialogType.Confirm:
var dr = MessageBox.Show(messageText, "提示", MessageBoxButton.YesNo);
if (dr == MessageBoxResult.Yes)
callback.Continue(true);
else
callback.Continue(false);
suppressMessage = false;
return true;
case CefJsDialogType.Prompt:
MessageBox.Show("系统不支持prompt形式的提示框", "UTMP系统提示");
break;
}
//如果suppressMessage被设置为true，并且函数返回值为false，将阻止页面打开JS的弹出窗口。
//如果suppressMessage被设置为false，并且函数返回值也是false，页面将会打开这个JS弹出窗口。
suppressMessage = true;
return false;
}
/// <inheritdoc/>>
public bool OnKeyEvent(IWebBrowser browserControl, IBrowser browser, KeyType type, int windowsKeyCode, int nativeKeyCode, CefEventFlags modifiers, bool isSystemKey)
{
bool result = false;
Debug.WriteLine(String.Format("OnKeyEvent: KeyType: {0} 0x{1:X} Modifiers: {2}", type, windowsKeyCode, modifiers));
// TODO: Handle MessageNeeded cases here somehow.
return result;
}
public bool OnBeforePopup(IWebBrowser rpBrowserControl, IBlinkBrowser rpBrowser, IFrame rpFrame, string rpTargetUrl, string rpTargetFrameName, WindowOpenDisposition rpTargetDisposition, bool rpUserGesture, IPopupFeatures rpPopupFeatures, IWindowInfo rpWindowInfo, IBrowserSettings rpBrowserSettings, ref bool rrpNoJavascriptAccess, out IWebBrowser ropNewBrowser)
{
rpBrowserControl.Load(rpTargetUrl);
ropNewBrowser = rpBrowserControl;
return true;
}
bool ILifeSpanHandler.OnBeforePopup(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, string targetFrameName, WindowOpenDisposition targetDisposition, bool userGesture, IPopupFeatures popupFeatures, IWindowInfo windowInfo, IBrowserSettings browserSettings, ref bool noJavascriptAccess, out IWebBrowser newBrowser)
{
newBrowser = null;
//browserControl.Load(targetUrl);
OpenInNewTab?.Invoke(this, new NewTabEventArgs(targetUrl)); //this breaks when there are multiple window.open calls from JS.
return true;
}
public bool OnBeforeContextMenu(IWebBrowser browser, IContextMenuParams parameters)
{
Console.WriteLine("Context menu opened");
Console.WriteLine(parameters.MisspelledWord);
return true;
}
public IResourceHandler GetResourceHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request)
{
// Every time we request the main GPM page allow another JS injection
if (Regex.Match(request.Url, @"^http[s]?://play\.google\.com/music/listen", RegexOptions.IgnoreCase).Success)
{
firstJSOnly = true;
}
if (Regex.Match(request.Url, @"\.js", RegexOptions.IgnoreCase).Success && Regex.Match(request.Url, @"http", RegexOptions.IgnoreCase).Success && firstJSOnly)
{
firstJSOnly = false;
using (WebClient webClient = new WebClient())
{
// These are the JS files to inject into GPM
string dark_theme = Google_Play_Music.Properties.Resources.dark_theme;
string custom_interface = Google_Play_Music.Properties.Resources.custom_interface;
string mini_player = Google_Play_Music.Properties.Resources.mini_player;
Color c = Properties.Settings.Default.CustomColor;
string RGB = "#" + c.R.ToString("X2") + c.G.ToString("X2") + c.B.ToString("X2");
string custom_color = ";(function() {window.CustomColor = '" + RGB + "';})();";
bool controlsOnHover = Properties.Settings.Default.HoverControls;
string controlsOnHoverJS = ";(function() {window.hoverControls = " + controlsOnHover.ToString().ToLower() + ";})();";
string setInitialZoomJS = ";(function() {csharpinterface.setInitialZoom();})();";
return ResourceHandler.FromStream(new MemoryStream(Encoding.UTF8.GetBytes(webClient.DownloadString(request.Url) + ";" + custom_color + controlsOnHoverJS + setInitialZoomJS + dark_theme + custom_interface + mini_player)), webClient.ResponseHeaders["Content-Type"]);
}
}
return null;
}
bool IGeolocationHandler.OnRequestGeolocationPermission(IWebBrowser browserControl, IBrowser browser, string requestingUrl, int requestId, IGeolocationCallback callback)
{
//You can execute the callback inline
//callback.Continue(true);
//return true;
//You can execute the callback in an `async` fashion
//Open a message box on the `UI` thread and ask for user input.
//You can open a form, or do whatever you like, just make sure you either
//execute the callback or call `Dispose` as it's an `unmanaged` wrapper.
var chromiumWebBrowser = (ChromiumWebBrowser)browserControl;
chromiumWebBrowser.Dispatcher.BeginInvoke((Action)(() =>
{
//Callback wraps an unmanaged resource, so we'll make sure it's Disposed (calling Continue will also Dipose of the callback, it's safe to dispose multiple times).
using (callback)
{
var result = MessageBox.Show(String.Format("{0} wants to use your computer's location. Allow? ** You must set your Google API key in CefExample.Init() for this to work. **", requestingUrl), "Geolocation", MessageBoxButton.YesNo);
//Execute the callback, to allow/deny the request.
callback.Continue(result == MessageBoxResult.Yes);
}
}));
//Yes we'd like to hadle this request ourselves.
return true;
}
public bool OnJSPrompt(IWebBrowser browser, string url, string message, string defaultValue, out bool retval, out string result)
{
retval = false;
result = null;
return false;
}
public bool OnBeforePopup(IWebBrowser c_web, string sourceUrl, string targetUrl, ref int x, ref int y, ref int width, ref int height)
{
if (targetUrl.Contains("create#instanceId") == false && Properties.Settings.Default.ctrlsetting == 0 && targetUrl.Contains("pages") == true || targetUrl.Contains("create#instanceId") == false && Properties.Settings.Default.ctrlsetting == 0 && targetUrl.Contains("numbers") == true || targetUrl.Contains("create#instanceId") == false && Properties.Settings.Default.ctrlsetting == 0 && targetUrl.Contains("keynote") == true)
{
Application.Current.Dispatcher.Invoke(new Action(() =>
{
DelayAction(500, new Action(() =>
{
pressenter();
}));
DelayAction(600, new Action(() =>
{
var popupmain = new popupmain(targetUrl);
popupmain.Show();
}));
}));
return true;
}
else
{
return false;
}
}
public bool OnBeforeResourceLoad(IWebBrowser browser, IRequestResponse requestResponse)
{
/*
* Called on the IO thread before a resource is loaded. To allow the resource to load normally return false.
* To redirect the resource to a new url populate the |redirectUrl| value and return false.
* To specify data for the resource return a CefStream object in |resourceStream|, use the |response| object to set mime type,
* HTTP status code and optional header values, and return false. To cancel loading of the resource return true.
* Any modifications to |request| will be observed. If the URL in |request| is changed and |redirectUrl| is also set,
* the URL in |request| will be used.
*/
if (requestResponse.Request.Url.StartsWith(m_InternalDomain))
{
var requestUri = requestResponse.Request.Url.Replace(m_InternalDomain, String.Empty);
HttpResponseMessage response = m_Server(requestUri);
//TODO: Copy to separate memory stream so we can dispose of parent HttpResponseMessage
var responseContent = response.Content.ReadAsStreamAsync().Result;
var responseHeaders = response.Headers.ToDictionary(x => x.Key, x => x.Value.First());
var responseMime = response.IsSuccessStatusCode
? response.Content.Headers.ContentType.MediaType
: "text/html"; //CEFSharp demands a MimeType of some kind...
requestResponse.RespondWith(responseContent, responseMime, String.Empty, (int) response.StatusCode, responseHeaders);
}
return false;
}
public bool OnBeforePopup(IWebBrowser browser, string url, ref int x, ref int y, ref int width, ref int height)
{
try {
Process.Start(url);
} catch { }
return true;
}
private static BindingInfo getBinding (IWebBrowser control)
{
if (!boundControls.ContainsKey (control))
return null;
BindingInfo info = boundControls[control] as BindingInfo;
return info;
}
bool IContextMenuHandler.OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, int commandId, CefEventFlags eventFlags)
{
if (commandId == (int)CefMenuCommand.Reload)
{
browser.Reload();
}
return false;
}
void IContextMenuHandler.OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, IContextMenuParams parameters, IMenuModel model)
{
Console.WriteLine("Context menu opened");
Console.WriteLine(parameters.MisspelledWord);
//To disable context mode then clear
// model.Clear();
}
bool IRequestHandler.GetAuthCredentials(IWebBrowser browserControl, IBrowser browser, IFrame frame, bool isProxy, string host, int port, string realm, string scheme, IAuthCallback callback)
{
//NOTE: If you do not wish to implement this method returning false is the default behaviour
// We also suggest you explicitly Dispose of the callback as it wraps an unmanaged resource.
callback.Dispose();
return false;
}
public bool OnJSBeforeUnload(IWebBrowser browser, string message, bool isReload, out bool allowUnload)
{
//NOTE: Setting allowUnload to false will cancel the unload request
allowUnload = false;
//NOTE: Returning false will trigger the default behaviour, you need to return true to handle yourself.
return false;
}
IResourceHandler IResourceHandlerFactory.GetResourceHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request)
{
if (request.Url.Contains("zeldaADPCM5bit.swf"))
{
return new FlashResourceHandler();
}
return null;
}
/// <summary>
/// Change the ZoomLevel to the specified value. Can be set to 0.0 to clear the zoom level.
/// </summary>
/// <remarks>
/// If called on the CEF UI thread the change will be applied immediately.
/// Otherwise, the change will be applied asynchronously on the CEF UI thread.
/// The CEF UI thread is different to the WPF/WinForms UI Thread
/// </remarks>
/// <param name="browser">The ChromiumWebBrowser instance this method extends</param>
/// <param name="zoomLevel">zoom level</param>
public static void SetZoomLevel(this IWebBrowser browser, double zoomLevel)
{
var cefBrowser = browser.GetBrowser();
cefBrowser.SetZoomLevel(zoomLevel);
}
/// <summary>
/// Called when an external drag event enters the browser window.
/// </summary>
/// <param name="chromiumWebBrowser">the ChromiumWebBrowser control</param>
/// <param name="browser">the browser object</param>
/// <param name="dragData">contains the drag event data</param>
/// <param name="mask">represents the type of drag operation</param>
/// <returns>Return false for default drag handling behavior or true to cancel the drag event. </returns>
bool IDragHandler.OnDragEnter(IWebBrowser chromiumWebBrowser, IBrowser browser, IDragData dragData, DragOperationsMask mask)
{
return(OnDragEnter(chromiumWebBrowser, browser, dragData, mask));
}
/// <summary>
/// Called whenever draggable regions for the browser window change.
/// These can be specified using the '-webkit-app-region: drag/no-drag' CSS-property.
/// If draggable regions are never defined in a document this method will also never be called.
/// If the last draggable region is removed from a document this method will be called with an empty IList.
/// </summary>
/// <param name="chromiumWebBrowser">the ChromiumWebBrowser control</param>
/// <param name="browser">the browser object</param>
/// <param name="frame">The frame</param>
/// <param name="regions">List of <see cref="DraggableRegion"/> objects or null if last region was removed.</param>
void IDragHandler.OnDraggableRegionsChanged(IWebBrowser chromiumWebBrowser, IBrowser browser, IFrame frame, IList <DraggableRegion> regions)
{
OnDraggableRegionsChanged(chromiumWebBrowser, browser, frame, regions);
}
/// <summary>
/// Called whenever draggable regions for the browser window change.
/// These can be specified using the '-webkit-app-region: drag/no-drag' CSS-property.
/// If draggable regions are never defined in a document this method will also never be called.
/// If the last draggable region is removed from a document this method will be called with an empty IList.
/// </summary>
/// <param name="chromiumWebBrowser">the ChromiumWebBrowser control</param>
/// <param name="browser">the browser object</param>
/// <param name="frame">The frame</param>
/// <param name="regions">List of <see cref="DraggableRegion"/> objects or null if last region was removed.</param>
protected virtual void OnDraggableRegionsChanged(IWebBrowser chromiumWebBrowser, IBrowser browser, IFrame frame, IList <DraggableRegion> regions)
{
}
/// <summary>
/// Evaluate some Javascript code in the context of this WebBrowser. The script will be executed asynchronously and the
/// method returns a Task encapsulating the response from the Javascript
/// This simple helper extension will encapsulate params in single quotes (unless int, uint, etc)
/// </summary>
/// <param name="browser">The ChromiumWebBrowser instance this method extends</param>
/// <param name="methodName">The javascript method name to execute</param>
/// <param name="args">the arguments to be passed as params to the method</param>
/// <returns><see cref="Task{JavascriptResponse}"/> that can be awaited to perform the script execution</returns>
public static Task <JavascriptResponse> EvaluateScriptAsync(this IWebBrowser browser, string methodName, params object[] args)
{
return(browser.EvaluateScriptAsync(null, methodName, args));
}
public bool OnCertificateError(IWebBrowser browserControl, IBrowser browser, CefErrorCode errorCode, string requestUrl, ISslInfo sslInfo, IRequestCallback callback)
{
return true;
}
public bool GetAuthCredentials(IWebBrowser browserControl, IBrowser browser, IFrame frame, bool isProxy,
string host, int port, string realm, string scheme, IAuthCallback callback)
{
return false;
}
/// <summary>
/// Execute some Javascript code in the context of this WebBrowser. As the method name implies, the script will be
/// executed asynchronously, and the method therefore returns before the script has actually been executed.
/// This simple helper extension will encapsulate params in single quotes (unless int, uint, etc)
/// </summary>
/// <param name="browser">The ChromiumWebBrowser instance this method extends</param>
/// <param name="methodName">The javascript method name to execute</param>
/// <param name="args">the arguments to be passed as params to the method. Args are encoded using <see cref="EncodeScriptParam"/>,
/// you can provide a custom implementation if you require a custom implementation</param>
public static void ExecuteScriptAsync(this IWebBrowser browser, string methodName, params object[] args)
{
var script = GetScriptForJavascriptMethodWithArgs(methodName, args);
browser.ExecuteScriptAsync(script);
}
/// <summary>
/// Registers and loads a <see cref="ResourceHandler"/> that represents the HTML content.
/// </summary>
/// <remarks>
/// `Cef` Native `LoadHtml` is unpredictable and only works sometimes, this method wraps
/// the provided HTML in a <see cref="ResourceHandler"/> and loads the provided url using
/// the <see cref="IWebBrowser.Load"/> method.
/// Defaults to using <see cref="Encoding.UTF8"/> for character encoding
/// The url must start with a valid schema, other uri's such as about:blank are invalid
/// A valid example looks like http://test/page
/// </remarks>
/// <param name="browser">The ChromiumWebBrowser instance this method extends</param>
/// <param name="html">The HTML content.</param>
/// <param name="url">The URL that will be treated as the address of the content.</param>
/// <returns>returns false if the Url was not successfully parsed into a Uri</returns>
public static bool LoadHtml(this IWebBrowser browser, string html, string url)
{
return(browser.LoadHtml(html, url, Encoding.UTF8));
}
/// <summary>
/// Loads html as Data Uri
/// See https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs for details
/// If base64Encode is false then html will be Uri encoded
/// </summary>
/// <param name="browser">The ChromiumWebBrowser instance this method extends</param>
/// <param name="html">Html to load as data uri.</param>
/// <param name="base64Encode">if true the html string will be base64 encoded using UTF8 encoding.</param>
public static void LoadHtml(this IWebBrowser browser, string html, bool base64Encode = false)
{
var htmlString = new HtmlString(html, base64Encode);
browser.Load(htmlString.ToDataUriString());
}
public static void RegisterAsyncJsObject(this IWebBrowser webBrowser, string name, object objectToBind, BindingOptions options = null)
{
throw new NotImplementedException("This method has been removed, see https://github.com/cefsharp/CefSharp/issues/2990 for details on migrating your code.");
}
public static void SetAsPopup(this IWebBrowser browser)
{
var internalBrowser = (IWebBrowserInternal)browser;
internalBrowser.HasParent = true;
}
/// <summary>
/// Reloads the page being displayed. This method will use data from the browser's cache, if available.
/// </summary>
public static void Reload(this IWebBrowser browser)
{
browser.Reload(false);
}
public bool OnProtocolExecution(IWebBrowser browserControl, IBrowser browser, string url)
{
return false;
}
public void OnPluginCrashed(IWebBrowser browserControl, IBrowser browser, string pluginPath)
{
}
public bool OnSelectClientCertificate(IWebBrowser browserControl, IBrowser browser, bool isProxy, string host, int port, X509Certificate2Collection certificates, ISelectClientCertificateCallback callback)
{
return true;
}
public bool OnOpenUrlFromTab(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, WindowOpenDisposition targetDisposition, bool userGesture)
{
return false;
}
void IRenderProcessMessageHandler.OnContextReleased(IWebBrowser browserControl, IBrowser browser, IFrame frame)
{
//The V8Context is about to be released, use this notification to cancel any long running tasks your might have
}
public bool OnResourceResponse(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response)
{
return false; ;
}
/// <summary>
/// Shortcut method to get the browser IBrowserHost
/// </summary>
/// <param name="browser">The ChromiumWebBrowser instance this method extends</param>
/// <returns>browserHost or null</returns>
public static IBrowserHost GetBrowserHost(this IWebBrowser browser)
{
var cefBrowser = browser.GetBrowser();
return(cefBrowser == null ? null : cefBrowser.GetHost());
}
void IRenderProcessMessageHandler.OnFocusedNodeChanged(IWebBrowser browserControl, IBrowser browser, IFrame frame, IDomNode node)
{
var message = node == null ? "lost focus" : node.ToString();
Console.WriteLine("OnFocusedNodeChanged() - " + message);
}
public void OnResourceRedirect(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response, ref string newUrl)
{
}
public bool OnDragEnter(IWebBrowser browser, IDragData dragData, DragOperationsMask mask)
{
return(false);
}
public void OnResourceLoadComplete(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IResponse response, UrlRequestStatus status, long receivedContentLength)
{
}
public void OnRenderViewReady(IWebBrowser browserControl, IBrowser browser)
{
}
public void OnRenderProcessTerminated(IWebBrowser browserControl, IBrowser browser, CefTerminationStatus status)
{
}
/// <summary>
/// Called when an external drag event enters the browser window.
/// </summary>
/// <param name="chromiumWebBrowser">the ChromiumWebBrowser control</param>
/// <param name="browser">the browser object</param>
/// <param name="dragData">contains the drag event data</param>
/// <param name="mask">represents the type of drag operation</param>
/// <returns>Return false for default drag handling behavior or true to cancel the drag event. </returns>
protected virtual bool OnDragEnter(IWebBrowser chromiumWebBrowser, IBrowser browser, IDragData dragData, DragOperationsMask mask)
{
return(false);
}
public bool OnQuotaRequest(IWebBrowser browserControl, IBrowser browser, string originUrl, long newSize, IRequestCallback callback)
{
return false;
}
/// <summary>
/// Evaluate some Javascript code in the context of this WebBrowser using the specified timeout. The script will be executed asynchronously and the
/// method returns a Task encapsulating the response from the Javascript
/// This simple helper extension will encapsulate params in single quotes (unless int, uint, etc).
/// </summary>
/// <param name="browser">The ChromiumWebBrowser instance this method extends</param>
/// <param name="timeout">The timeout after which the Javascript code execution should be aborted.</param>
/// <param name="methodName">The javascript method name to execute</param>
/// <param name="args">the arguments to be passed as params to the method. Args are encoded using <see cref="EncodeScriptParam"/>,
/// you can provide a custom implementation if you require a custom implementation</param>
/// <returns><see cref="Task{JavascriptResponse}"/> that can be awaited to perform the script execution</returns>
public static Task <JavascriptResponse> EvaluateScriptAsync(this IWebBrowser browser, TimeSpan?timeout, string methodName, params object[] args)
{
var script = GetScriptForJavascriptMethodWithArgs(methodName, args);
return(browser.EvaluateScriptAsync(script, timeout));
}
/// <summary>
/// Asynchronously gets the current Zoom Level.
/// </summary>
public static Task <double> GetZoomLevelAsync(this IWebBrowser browser)
{
var cefBrowser = browser.GetBrowser();
return(cefBrowser.GetZoomLevelAsync());
}
