public virtual void doActions(List <WebAction> actions) { completedEventHandler = new WebBrowserDocumentCompletedEventHandler(this.pageLoaded); WebBrowser.DocumentCompleted += completedEventHandler; Queue <WebAction> activeActions = new Queue <WebAction>(actions); while (0 < activeActions.Count) { activeAction = activeActions.Dequeue(); if (activeAction.canDoAction(this)) { if (activeAction.shouldWaitAction(this)) { trigger.Reset(); WaitHandle.WaitAny(waitHandles); } activeAction.doAction(this); if (activeAction.isWaitForEvent()) { trigger.Reset(); WaitHandle.WaitAny(waitHandles); } } } completedActions(); }
private async void MainForm_Load(object sender, EventArgs e) { var wb = new WebBrowser(); TaskCompletionSource <bool> tcs = null; WebBrowserDocumentCompletedEventHandler documentCompletedHandler = (sender2, e2) => tcs.TrySetResult(true); for (int i = 0; i < 3; i++) { tcs = new TaskCompletionSource <bool>(); wb.DocumentCompleted += documentCompletedHandler; try { wb.DocumentText = leMessage; await tcs.Task; } finally { wb.DocumentCompleted -= documentCompletedHandler; } HtmlElementCollection elems = wb.Document.GetElementsByTagName("a"); foreach (HtmlElement elem in elems) { Debug.Print(elem.OuterHtml); } } }
public virtual void doActions(List <WebAction> actions) { completedEventHandler = new WebBrowserDocumentCompletedEventHandler(this.pageLoaded); WebBrowser.DocumentCompleted += completedEventHandler; activeActions = new Queue <WebAction>(actions); doNextAction(); }
/// <summary> /// /// </summary> private void Download() { try { CanDownload = false; var downloader = _options[SelectedTab].Value; var site = Utilities.GetWebsite(downloader.Url); var browser = new WebBrowser { ScriptErrorsSuppressed = true, AllowNavigation = true }; browser.Navigate(new Uri(downloader.Url)); WebBrowserDocumentCompletedEventHandler handler = null; handler = (sender, args) => { browser.DocumentCompleted -= handler; _downloaders[site].Invoke(sender, args, site, downloader); }; browser.DocumentCompleted += handler; } catch (WebException) { MessageBox.Show("Error downloading", "Error", MessageBoxButton.OK, MessageBoxImage.Error); CanDownload = true; } catch (InvalidUrlException ex) { MessageBox.Show(string.Format("{0}\n\nUrl: {1}", ex.Message, ex.Url), "Invalid Url", MessageBoxButton.OK, MessageBoxImage.Error); CanDownload = true; } }
private async Task DoNavigationAsync() { TaskCompletionSource <bool> documentCompleteTcs = null; WebBrowserDocumentCompletedEventHandler handler = delegate { if (documentCompleteTcs.Task.IsCompleted) { return; } documentCompleteTcs.SetResult(true); }; documentCompleteTcs = new TaskCompletionSource <bool>(); this.wb.DocumentCompleted += handler; // could do this.wb.Navigate(url) here this.wb.DocumentText = "<!DOCTYPE html><head><meta http-equiv='X-UA-Compatible' content='IE=edge'/></head>" + "<body><input size=50 type='text' placeholder='HTML5 if this placeholder is visible'/></body>"; await documentCompleteTcs.Task; this.wb.DocumentCompleted -= handler; dynamic document = this.wb.Document.DomDocument; dynamic navigator = document.parentWindow.navigator; var info = "\n navigator.userAgent: " + navigator.userAgent + "\n navigator.appName: " + navigator.appName + "\n document.documentMode: " + document.documentMode + "\n document.compatMode: " + document.compatMode; MessageBox.Show(info); }
public async Task NextPageAsync(string url) { _currentUrl = url; // _currentPage = await _apartment.Run(() => _browser.NavigateAsync(_currentUrl, navigationToken), navigationToken); _currentPage = await _apartment.Run(async() => { WebBrowserDocumentCompletedEventHandler handler = null; var navigateTcs = new TaskCompletionSource <bool>(); handler = (s, e) => navigateTcs.TrySetResult(true); _browser.DocumentCompleted += handler; try { using (_cancelToken.Register(() => navigateTcs.TrySetCanceled())) { _browser.Navigate(url); await navigateTcs.Task; return(_browser.Document.Body.OuterHtml); } } finally { _browser.DocumentCompleted -= handler; } }, _cancelToken); }
// navigate WebBrowser to the list of urls in a loop static async Task <object> DoWorkAsync(object[] args) { Console.WriteLine("Start working."); var wb = new WebBrowser(); wb.ScriptErrorsSuppressed = true; TaskCompletionSource <bool> tcs = null; WebBrowserDocumentCompletedEventHandler documentCompletedHandler = (s, e) => tcs.TrySetResult(true); // navigate to each URL in the list foreach (var url in args) { tcs = new TaskCompletionSource <bool>(); wb.DocumentCompleted += documentCompletedHandler; try { wb.Navigate(url.ToString()); // await for DocumentCompleted await tcs.Task; } finally { wb.DocumentCompleted -= documentCompletedHandler; } // the DOM is ready Console.WriteLine(url.ToString()); Console.WriteLine(wb.Document.Body.OuterHtml); } Console.WriteLine("End working."); return(null); }
public static async Task <Bitmap> RenderApiDump(string htmlFilePath) { var docReady = new WebBrowserDocumentCompletedEventHandler(onDocumentComplete); string fileUrl = "file://" + htmlFilePath.Replace('\\', '/'); Thread renderThread = new Thread(() => { var renderer = new WebBrowser() { Url = new Uri(fileUrl), ScrollBarsEnabled = false, }; renderer.DocumentCompleted += docReady; Application.Run(); }); renderFinished = new TaskCompletionSource <Bitmap>(); renderThread.SetApartmentState(ApartmentState.STA); renderThread.Start(); await renderFinished.Task; var apiRender = renderFinished.Task.Result; return(apiRender); }
void MainForm_Load(object senderLoad, EventArgs eLoad) { using (var apartment = new MessageLoopApartment()) { // create WebBrowser on a seprate thread with its own message loop var webBrowser = apartment.Run(() => new WebBrowser(), CancellationToken.None).Result; // navigate and wait for the result var bodyHtml = apartment.Invoke(() => { WebBrowserDocumentCompletedEventHandler handler = null; var pageLoadedTcs = new TaskCompletionSource <string>(); handler = (s, e) => { try { webBrowser.DocumentCompleted -= handler; pageLoadedTcs.SetResult(webBrowser.Document.Body.InnerHtml); } catch (Exception ex) { pageLoadedTcs.SetException(ex); } }; webBrowser.DocumentCompleted += handler; webBrowser.Navigate("http://example.com"); // return Task<string> return(pageLoadedTcs.Task); }).Result; MessageBox.Show("body content:\n" + bodyHtml); // execute some JavaScript var documentHtml = apartment.Invoke(() => { // at least one script element must be present for eval to work var scriptElement = webBrowser.Document.CreateElement("script"); webBrowser.Document.Body.AppendChild(scriptElement); // inject and run some script var scriptResult = webBrowser.Document.InvokeScript("eval", new[] { "(function(){ return document.documentElement.outerHTML; })();" }); return(scriptResult.ToString()); }); MessageBox.Show("document content:\n" + documentHtml); // dispose of webBrowser apartment.Run(() => webBrowser.Dispose(), CancellationToken.None).Wait(); webBrowser = null; } }
protected virtual void OnDocumentCompleted(WebBrowserDocumentCompletedEventArgs e) { WebBrowserDocumentCompletedEventHandler handler = (WebBrowserDocumentCompletedEventHandler)this.Events[DocumentCompletedEventKey]; if (handler != null) { handler(this, e); } }
/// <summary> /// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed. /// <example> /// webbrowserdocumentcompletedeventhandler.BeginInvoke(sender, e, callback); /// </example> /// </summary> public static IAsyncResult BeginInvoke(this WebBrowserDocumentCompletedEventHandler webbrowserdocumentcompletedeventhandler, Object sender, WebBrowserDocumentCompletedEventArgs e, AsyncCallback callback) { if (webbrowserdocumentcompletedeventhandler == null) { throw new ArgumentNullException("webbrowserdocumentcompletedeventhandler"); } return(webbrowserdocumentcompletedeventhandler.BeginInvoke(sender, e, callback, null)); }
// navigate and download async Task <string> LoadDynamicPage(string url, CancellationToken token) { // navigate and await DocumentCompleted var tcs = new TaskCompletionSource <bool>(); WebBrowserDocumentCompletedEventHandler handler = (s, arg) => tcs.TrySetResult(true); WebBrowser webBrowser = new WebBrowser(); webBrowser.ScriptErrorsSuppressed = true; webBrowser.ObjectForScripting = true; SetFeatureBrowserEmulation(); using (token.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: true)) { webBrowser.DocumentCompleted += handler; try { webBrowser.Navigate(url); await tcs.Task; // wait for DocumentCompleted } finally { webBrowser.DocumentCompleted -= handler; } } // get the root element var documentElement = webBrowser.Document.GetElementsByTagName("html")[0]; // poll the current HTML for changes asynchronosly var html = documentElement.OuterHtml; while (true) { // wait asynchronously, this will throw if cancellation requested await Task.Delay(500, token); // continue polling if the WebBrowser is still busy if (webBrowser.IsBusy) { continue; } var htmlNow = documentElement.OuterHtml; if (html == htmlNow) { break; // no changes detected, end the poll loop } html = htmlNow; } // consider the page fully rendered token.ThrowIfCancellationRequested(); return(html); }
public void setDocumentLoadHandler(Action <object, WebBrowserDocumentCompletedEventArgs> func) { //Remove the old event listener if (oldEventHandle != null) { webBrowser1.DocumentCompleted -= oldEventHandle; } oldEventHandle = new WebBrowserDocumentCompletedEventHandler(func); webBrowser1.DocumentCompleted += oldEventHandle; }
protected virtual void OnDocumentCompleted(WebBrowserDocumentCompletedEventArgs e) { WebBrowserDocumentCompletedEventHandler completedEventHandler = (WebBrowserDocumentCompletedEventHandler)this.Events[RadWebBrowserItem.DocumentCompletedEventKey]; if (completedEventHandler == null) { return; } completedEventHandler((object)this, e); }
static Task <WebBrowser> runInternal(Action action, Func <bool> QuitCondition) { try { var t = new TaskCompletionSource <WebBrowser>(); var ie = ApplyContext.Current.IE; //如果有退出条件,检查 if (QuitCondition != null) { var timer = new Timer(state => { bool result; if (ie.InvokeRequired && ie.Created) { result = (bool)ie.Invoke(QuitCondition); } else { result = QuitCondition(); } if (result) { t.TrySetResult(ie); (state as Timer).Dispose(); } }); timer.Change(1000, 1000); } WebBrowserDocumentCompletedEventHandler callBack = null; callBack = (o, e) => { if (e.Url == ie.Url && ie.ReadyState == WebBrowserReadyState.Complete) { t.TrySetResult(ie); ie.DocumentCompleted -= callBack; } }; ie.DocumentCompleted += callBack; if (action != null) { action(); } return(t.Task); } catch (Exception ex) { ApplyContext.Current.ShowMessage(ex.Message); throw; } }
/// <summary> /// /// </summary> /// <param name="sender"></param> /// <param name="args"></param> /// <param name="site"></param> /// <param name="options"></param> private void EHentaiBrowserOnDocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs args, Website site, WebsiteOptions options) { var browser = (WebBrowser)sender; if (browser.Document?.Body == null) { return; } var title = _formatters[site].Invoke(browser.DocumentTitle); Debug.WriteLine(title); var folder = Path.Combine(options.Folder, title); Directory.CreateDirectory(folder); var links = browser.Document.GetElementsByTagName("a") .OfType <HtmlElement>() .Where(e => { var href = e.GetAttribute("href"); if (string.IsNullOrEmpty(href) || href.Length <= 2) { return(false); } return ((href[href.Length - 2] == '-' || href[href.Length - 3] == '-' || href[href.Length - 4] == '-') && href.StartsWith("https://e-hentai.org/s/")); }) .Select(e => e.GetAttribute("href")) .ToList(); foreach (var link in links) { var browser1 = new WebBrowser { ScriptErrorsSuppressed = true, AllowNavigation = true }; WebBrowserDocumentCompletedEventHandler handler = null; var link1 = link; handler = (s, a) => { browser1.DocumentCompleted -= handler; ProcessEHentaiPage(s, folder, link1.Substring(link1.LastIndexOf('-') + 1), links.Count); }; browser1.DocumentCompleted += handler; browser1.Url = new Uri(link); } }
public virtual void init() { RequestContext = new Dictionary <string, object>(); Outputs = new Dictionary <string, object>(); if (MonitorTimings) { completedEventHandlerForTiming = new WebBrowserDocumentCompletedEventHandler(this.pageLoadedForMonitoring); WebBrowser.DocumentCompleted += completedEventHandlerForTiming; AccessTimes = new Stack <AccessTiming>(); } }
public static async Task <string> GetLocationChangeAsync(this WebBrowser webBrowser, string url, CancellationToken token) { // navigate and await DocumentCompleted var tcs = new TaskCompletionSource <bool>(); WebBrowserDocumentCompletedEventHandler handler = (s, arg) => tcs.TrySetResult(true); using (token.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: true)) { webBrowser.DocumentCompleted += handler; try { webBrowser.Navigate(url); await tcs.Task; // wait for DocumentCompleted } finally { webBrowser.DocumentCompleted -= handler; } } // get the root element var documentElement = webBrowser.Document.GetElementsByTagName("html")[0]; string browserUrl = webBrowser.Url.ToString(); if (browserUrl != url) { return(browserUrl); //location has already changed } // poll the current location url for changes asynchronosly while (true) { // wait asynchronously, this will throw if cancellation requested await Task.Delay(POLL_DELAY, token); // continue polling if the WebBrowser is still busy if (webBrowser.IsBusy) { continue; } string browserUrlNow = webBrowser.Url.ToString(); if (browserUrl != browserUrlNow) //change detected { browserUrl = browserUrlNow; break; } } // consider the page fully rendered token.ThrowIfCancellationRequested(); return(browserUrl); }
public static Task <Uri> DocumentCompletedAsync(this WebBrowser wb) { var tcs = new TaskCompletionSource <Uri>(); WebBrowserDocumentCompletedEventHandler handler = null; handler = (_, e) => { wb.DocumentCompleted -= handler; tcs.TrySetResult(e.Url); }; wb.DocumentCompleted += handler; return(tcs.Task); }
public static async Task <bool> GetPageAsImageAsync(string url, string path) { var tcs = new TaskCompletionSource <bool>(); //await TaskEx.Delay(1); var thread = new Thread(() => { using (var browser = new WebBrowser()) { browser.Size = new Size(1280, 768); browser.ScrollBarsEnabled = false; WebBrowserDocumentCompletedEventHandler documentCompleted = null; documentCompleted = async(o, s) => { var loadedBrowser = (WebBrowser)o; loadedBrowser.DocumentCompleted -= documentCompleted; await TaskEx.Delay(2000); //Run JS a few seconds more if (loadedBrowser.Document != null) { if (loadedBrowser.Document.Body != null) { loadedBrowser.Width = loadedBrowser.Document.Body.ScrollRectangle.Width; loadedBrowser.Height = loadedBrowser.Document.Body.ScrollRectangle.Height; } } using (var bitmap = new Bitmap(loadedBrowser.Width, loadedBrowser.Height)) { loadedBrowser.DrawToBitmap(bitmap, new Rectangle(0, 0, bitmap.Width, bitmap.Height)); bitmap.Save(path, System.Drawing.Imaging.ImageFormat.Png); } System.Windows.Forms.Application.Exit(); tcs.TrySetResult(true); }; browser.ScriptErrorsSuppressed = true; browser.DocumentCompleted += documentCompleted; browser.Navigate(url); System.Windows.Forms.Application.Run(); } //IntPtr pHandle = GetCurrentProcess(); //SetProcessWorkingSetSize(pHandle, -1, -1); }); thread.SetApartmentState(ApartmentState.STA); thread.Start(); System.Threading.Thread.SpinWait(3000); return(tcs.Task.Result); }
// asynchronous navigation async Task <string> NavigateAsync(CancellationToken ct, Action startNavigation) { var onloadTcs = new TaskCompletionSource <bool>(); EventHandler onloadEventHandler = null; WebBrowserDocumentCompletedEventHandler documentCompletedHandler = delegate { // DocumentCompleted may be called several time for the same page, // if the page has frames if (onloadEventHandler != null) { return; } // so, observe DOM onload event to make sure the document is fully loaded onloadEventHandler = (s, e) => onloadTcs.TrySetResult(true); this.webBrowser.Document.Window.AttachEventHandler("onload", onloadEventHandler); }; this.webBrowser.DocumentCompleted += documentCompletedHandler; try { using (ct.Register(() => onloadTcs.TrySetCanceled(), useSynchronizationContext: true)) { startNavigation(); // wait for DOM onload event, throw if cancelled await onloadTcs.Task; } } finally { this.webBrowser.DocumentCompleted -= documentCompletedHandler; if (onloadEventHandler != null) { this.webBrowser.Document.Window.DetachEventHandler("onload", onloadEventHandler); } } // the page has fully loaded by now // optional: let the page run its dynamic AJAX code, // we might add another timeout for this loop do { await Task.Delay(500, ct); }while (this.webBrowser.IsBusy); // return the page's HTML content return(this.webBrowser.Document.GetElementsByTagName("html")[0].OuterHtml); }
// navigate and download public static async Task <string> NavigateAsync(this WebBrowser webBrowser, string url, string targetFrameName, byte[] postData, string additionalHeaders, CancellationToken token) { // navigate and await DocumentCompleted var tcs = new TaskCompletionSource <bool>(); WebBrowserDocumentCompletedEventHandler handler = (s, arg) => tcs.TrySetResult(true); using (token.Register(() => tcs.TrySetCanceled(), useSynchronizationContext: true)) { webBrowser.DocumentCompleted += handler; try { webBrowser.Navigate(url, targetFrameName, postData, additionalHeaders); await tcs.Task; // wait for DocumentCompleted } finally { webBrowser.DocumentCompleted -= handler; } } // get the root element var documentElement = webBrowser.Document.GetElementsByTagName("html")[0]; // poll the current HTML for changes asynchronosly var html = documentElement.OuterHtml; while (true) { // wait asynchronously, this will throw if cancellation requested await Task.Delay(POLL_DELAY, token); // continue polling if the WebBrowser is still busy if (webBrowser.IsBusy) { continue; } var htmlNow = documentElement.OuterHtml; if (html == htmlNow) { break; // no changes detected, end the poll loop } html = htmlNow; } // consider the page fully rendered token.ThrowIfCancellationRequested(); return(html); }
// Async navigation public async Task NavigateAsync(CancellationToken ct, Action startNavigation, int timeout = Timeout.Infinite) { var onloadTcs = new TaskCompletionSource <bool>(); EventHandler onloadEventHandler = null; WebBrowserDocumentCompletedEventHandler documentCompletedHandler = delegate { // DocumentCompleted may be called several time for the same page, // beacuse of frames if (onloadEventHandler != null || onloadTcs == null || onloadTcs.Task.IsCompleted) { return; } // handle DOM onload event to make sure the document is fully loaded onloadEventHandler = (s, e) => onloadTcs.TrySetResult(true); this.webBrowser.Document.Window.AttachEventHandler("onload", onloadEventHandler); }; using (var cts = CancellationTokenSource.CreateLinkedTokenSource(ct)) { if (timeout != Timeout.Infinite) { cts.CancelAfter(Timeout.Infinite); } using (cts.Token.Register(() => onloadTcs.TrySetCanceled(), useSynchronizationContext: true)) { this.webBrowser.DocumentCompleted += documentCompletedHandler; try { startNavigation(); // wait for DOM onload, throw if cancelled await onloadTcs.Task; ct.ThrowIfCancellationRequested(); // let AJAX code run, throw if cancelled await Task.Delay(AJAX_DELAY, ct); } finally { this.webBrowser.DocumentCompleted -= documentCompletedHandler; if (onloadEventHandler != null) { this.webBrowser.Document.Window.DetachEventHandler("onload", onloadEventHandler); } } } } }
private TaskAwaiter<string> ProcessUrlAwaitable(WebBrowser webBrowser, string url) { TaskCompletionSource<string> taskCompletionSource = new TaskCompletionSource<string>(); var handler = new WebBrowserDocumentCompletedEventHandler((s, e) => { // TODO: put custom processing of document here taskCompletionSource.SetResult(e.Url + ": " + webBrowser.Document.Title); }); webBrowser.DocumentCompleted += handler; taskCompletionSource.Task.ContinueWith(s => { webBrowser.DocumentCompleted -= handler; }); webBrowser.Navigate(url); return taskCompletionSource.Task.GetAwaiter(); }
// this code depends on SHDocVw.dll COM interop assembly, // generate SHDocVw.dll: "tlbimp.exe ieframe.dll", // and add as a reference to the project private async void MainForm_Load(object sender, EventArgs e) { // make sure the ActiveX has been created if ((this.webBrowser.Document == null && this.webBrowser.ActiveXInstance == null)) { throw new ApplicationException("webBrowser"); } // handle NewWindow var activex = (SHDocVw.WebBrowser_V1) this.webBrowser.ActiveXInstance; activex.NewWindow += delegate(string URL, int Flags, string TargetFrameName, ref object PostData, string Headers, ref bool Processed) { Processed = true; object flags = Flags; object targetFrame = Type.Missing; object postData = PostData != null ? PostData : Type.Missing; object headers = !String.IsNullOrEmpty(Headers) ? Headers.ToString() : Type.Missing; SynchronizationContext.Current.Post(delegate { activex.Navigate(URL, ref flags, ref targetFrame, ref postData, ref headers); }, null); }; // navigate to a stream using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream)) { writer.Write(HTML_DATA); writer.Flush(); stream.Position = 0; // naviage and await DocumentCompleted var tcs = new TaskCompletionSource <bool>(); WebBrowserDocumentCompletedEventHandler handler = (s, arg) => tcs.TrySetResult(true); this.webBrowser.DocumentCompleted += handler; this.webBrowser.DocumentStream = stream; await tcs.Task; this.webBrowser.DocumentCompleted -= handler; } // click the button var button = this.webBrowser.Document.GetElementById("go"); button.InvokeMember("click"); }
public static Task SetDocumentTextAsync(this WebBrowser wb, string html) { TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(); WebBrowserDocumentCompletedEventHandler completedEvent = null; completedEvent = (sender, e) => { wb.DocumentCompleted -= completedEvent; tcs.SetResult(null); }; wb.DocumentCompleted += completedEvent; wb.ScriptErrorsSuppressed = true; wb.DocumentText = html; return(tcs.Task); }
public static Task <Uri> DocumentCompletedAsync(this WebBrowser wb, int timeout) { var tcs = new TaskCompletionSource <Uri>(); WebBrowserDocumentCompletedEventHandler handler = null; var timeoutRegistration = WithTimeout(tcs, timeout, () => wb.DocumentCompleted -= handler); handler = (_, e) => { wb.DocumentCompleted -= handler; timeoutRegistration.Unregister(); tcs.TrySetResult(e.Url); }; wb.DocumentCompleted += handler; return(tcs.Task); }
private void BrowseToResource(Renderable render) { WebBrowserDocumentCompletedEventHandler completedHandler = null; string html, script; this.SelectResources(render, out html, out script); completedHandler = (sender, e) => { this.StopListeningAndAddCommonHtmlElements(completedHandler); this.AddScriptElement(script); this.Render(render); }; this.AllowNavigation = true; this.DocumentCompleted += completedHandler; this.DocumentText = html; }
private void StopListeningAndAddCommonHtmlElements(WebBrowserDocumentCompletedEventHandler completedHandler) { // ordering of the following is IMPORTANT // stop listening this.AllowNavigation = false; this.DocumentCompleted -= completedHandler; // load our css in this.AddStyleSheet(Properties.Resources.statblock_css); // load our javascript in this.AddScriptElement(Properties.Resources.modernizr_2_6_2_js); this.AddScriptElement(Properties.Resources.underscore_js); this.AddScriptElement(Properties.Resources.knockout_3_0_0_debug_js); this.AddScriptElement(Properties.Resources.knockout_StringInterpolatingBindingProvider_js); this.AddScriptElement(Properties.Resources.ko_ninja_js); this.AddScriptElement(Properties.Resources.statblockHelpers_js); this.AddScriptElement(Properties.Resources.bindingHandlers_js); }
static Task <bool> WaitForPageLoadAsync(WebBrowser browser, CancellationToken token) { var tcs = new TaskCompletionSource <bool>(); token.Register(() => tcs.TrySetCanceled()); WebBrowserDocumentCompletedEventHandler handler = null; handler = (s, e) => { if (e.Url.AbsolutePath == "blank") { return; } browser.DocumentCompleted -= handler; tcs.TrySetResult(true); }; browser.DocumentCompleted += handler; return(tcs.Task); }
public void setCompletedListener(WebBrowserDocumentCompletedEventHandler handler) { myBrowser.DocumentCompleted += handler; }
public virtual void init() { RequestContext = new Dictionary<string, object>(); Outputs = new Dictionary<string, object>(); if (MonitorTimings) { completedEventHandlerForTiming = new WebBrowserDocumentCompletedEventHandler(this.pageLoadedForMonitoring); WebBrowser.DocumentCompleted += completedEventHandlerForTiming; AccessTimes = new Stack<AccessTiming>(); } }
/// <summary> /// Removes documentCompletedHandler from browser.DocumentCompleted, replaces it with the supplied function, and then adds it back. /// </summary> /// <param name="function"></param> private void resetdocumentCompletedHandler(WebBrowserDocumentCompletedEventHandler function) { browser.DocumentCompleted -= documentCompletedHandler; documentCompletedHandler = function; browser.DocumentCompleted += documentCompletedHandler; }
public virtual void doActions(List<WebAction> actions) { completedEventHandler = new WebBrowserDocumentCompletedEventHandler(this.pageLoaded); WebBrowser.DocumentCompleted += completedEventHandler; activeActions = new Queue<WebAction>(actions); doNextAction(); }
public virtual void doActions(List<WebAction> actions) { completedEventHandler = new WebBrowserDocumentCompletedEventHandler(this.pageLoaded); WebBrowser.DocumentCompleted += completedEventHandler; Queue<WebAction> activeActions = new Queue<WebAction>(actions); while (0 < activeActions.Count) { activeAction = activeActions.Dequeue(); if (activeAction.canDoAction(this)) { if (activeAction.shouldWaitAction(this)) { trigger.Reset(); WaitHandle.WaitAny(waitHandles); } activeAction.doAction(this); if (activeAction.isWaitForEvent()) { trigger.Reset(); WaitHandle.WaitAny(waitHandles); } } } completedActions(); }
public CompletionClosure() { done = false; Handler = new WebBrowserDocumentCompletedEventHandler(b_DocumentCompleted); }
private void StopListeningAndAddCommonHtmlElements(WebBrowserDocumentCompletedEventHandler completedHandler) { // ordering of the following is IMPORTANT // stop listening this.AllowNavigation = false; this.DocumentCompleted -= completedHandler; // load our css in this.AddStyleSheet(Properties.Resources.statblock_css); // load our javascript in this.AddScriptElement(Properties.Resources.modernizr_2_6_2_js); this.AddScriptElement(Properties.Resources.underscore_js); this.AddScriptElement(Properties.Resources.knockout_3_0_0_debug_js); this.AddScriptElement(Properties.Resources.knockout_StringInterpolatingBindingProvider_js); this.AddScriptElement(Properties.Resources.ko_ninja_js); this.AddScriptElement(Properties.Resources.statblockHelpers_js); this.AddScriptElement(Properties.Resources.bindingHandlers_js); }