Javascript Window.Opener Object Null on .NET WebBrowser Control New Window

javascriptnetwebbrowser-controlwebformswindow.opener

Well I have a Pop up in the WebBroswer control of the .NET Framework that I capture with the NewWindow event handler like so.

WebBrowser w = new WebBrowser();
SHDocVw.WebBrowser_V1 web = (SHDocVw.WebBrowser_V1)w.ActiveXInstance;
web.NewWindow += new SHDocVw.DWebBrowserEvents_NewWindowEventHandler(web_NewWindow);

The new Popup is in a new form with a new instance of the WebBrowser control.

void web_NewWindow(string URL, int Flags, string TargetFrameName, ref object PostData, string Headers, ref bool Processed)
    {
        Processed = true;
        WebBrowser w2 = new WebBrowser();

        Form PopUp = new Form();
        PopUp.Controls.Clear();
        PopUp.Controls.Add(w2);
        w2.Dock = DockStyle.Fill;
        PopUp.Show();
        w2.Navigate(URL);
        w2.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(w2_DocumentCompleted);
    }

My problem is that the Window.Opener object is null in the process.

The page uses that field to return the user back to the original window and fills some values on the form.

Is there anyway to pass the Window.Opener object from one WebBrowser control to the next? Seems impossible that this will work but I have to try.

Thanks

Best Answer

Yes, there is way to pass the Window.Opener object from one WebBrowser control to the next.
See code below for details.

public class WebBrowserTest
{
    private WebBrowser _wParent;

    // entry point
    public void Navigate(string url)
    {
        _wParent = new WebBrowser();
        SHDocVw.WebBrowser_V1 v1 = (SHDocVw.WebBrowser_V1)w.ActiveXInstance;
        v1.NewWindow += v1_NewWindow;
    }

    private void v1_NewWindow(string URL, int Flags, string TargetFrameName, ref object PostData, string Headers, ref bool Processed)
    {
        // tell, that we'll open new page by ourselves
        Processed = true;

        // open page by ourselves
        WebBrowser w2 = new WebBrowser();
        w2.Navigate(url);

        // wait for document will be loaded to do some magic stuff then
        w2.DocumentCompleted += w2_DocumentCompleted;
    }

    // sets opener for popup window
    // after document in popup window was loaded
    private void w2_DocumentCompleted(object sender, EventArgs e)
    {
        WebBrowser popup = (WebBrowser)sender;
        SetOpener(_wparent, popup);
    }

    // My most favorite method :)
    // Contains exactly that hack, we're talking about
    private void SetOpener(WebBrowser opener, WebBrowser popup)
    {    
        HtmlWindow htmlPopup = popup.Document.Window;
        HtmlWindow htmlOpener = opener.Document.Window;

        // let the dark magic begin

        // actually, WebBrowser control is .NET wrapper around IE COM interfaces
        // we can get a bit closer to them access by getting reference to 
        // "mshtml.IHTMLWindow2" field via Reflection
        FieldInfo fi = htmlPopup.GetType().GetField("htmlWindow2", BindingFlags.Instance | BindingFlags.NonPublic);

        mshtml.IHTMLWindow2 htmlPopup2 = (mshtml.IHTMLWindow2)fi.GetValue(htmlPopup);
        mshtml.IHTMLWindow2 htmlOpener2 = (mshtml.IHTMLWindow2)fi.GetValue(htmlOpener);

        // opener is set here
        htmlPopup2.window.opener = htmlOpener2.window.self;
    }
}

p.s. I understand, chances, that it's still actual, are very small, but, anyway =)

Related Solutions

Javascript – Length of a JavaScript object

The most robust answer (i.e. that captures the intent of what you're trying to do while causing the fewest bugs) would be:

Object.size = function(obj) {
  var size = 0,
    key;
  for (key in obj) {
    if (obj.hasOwnProperty(key)) size++;
  }
  return size;
};

// Get the size of an object
const myObj = {}
var size = Object.size(myObj);

There's a sort of convention in JavaScript that you don't add things to Object.prototype, because it can break enumerations in various libraries. Adding methods to Object is usually safe, though.

Here's an update as of 2016 and widespread deployment of ES5 and beyond. For IE9+ and all other modern ES5+ capable browsers, you can use Object.keys() so the above code just becomes:

var size = Object.keys(myObj).length;

This doesn't have to modify any existing prototype since Object.keys() is now built-in.

Edit: Objects can have symbolic properties that can not be returned via Object.key method. So the answer would be incomplete without mentioning them.

Symbol type was added to the language to create unique identifiers for object properties. The main benefit of the Symbol type is the prevention of overwrites.

Object.keys or Object.getOwnPropertyNames does not work for symbolic properties. To return them you need to use Object.getOwnPropertySymbols.

var person = {
  [Symbol('name')]: 'John Doe',
  [Symbol('age')]: 33,
  "occupation": "Programmer"
};

const propOwn = Object.getOwnPropertyNames(person);
console.log(propOwn.length); // 1

let propSymb = Object.getOwnPropertySymbols(person);
console.log(propSymb.length); // 2

Javascript – the most efficient way to deep clone an object in JavaScript

Native deep cloning

It's called "structured cloning", works experimentally in Node 11 and later, and hopefully will land in browsers. See this answer for more details.

Fast cloning with data loss - JSON.parse/stringify

If you do not use Dates, functions, undefined, Infinity, RegExps, Maps, Sets, Blobs, FileLists, ImageDatas, sparse Arrays, Typed Arrays or other complex types within your object, a very simple one liner to deep clone an object is:

JSON.parse(JSON.stringify(object))

const a = {
  string: 'string',
  number: 123,
  bool: false,
  nul: null,
  date: new Date(),  // stringified
  undef: undefined,  // lost
  inf: Infinity,  // forced to 'null'
  re: /.*/,  // lost
}
console.log(a);
console.log(typeof a.date);  // Date object
const clone = JSON.parse(JSON.stringify(a));
console.log(clone);
console.log(typeof clone.date);  // result of .toISOString()

See Corban's answer for benchmarks.

Reliable cloning using a library

Since cloning objects is not trivial (complex types, circular references, function etc.), most major libraries provide function to clone objects. Don't reinvent the wheel - if you're already using a library, check if it has an object cloning function. For example,

lodash - cloneDeep; can be imported separately via the lodash.clonedeep module and is probably your best choice if you're not already using a library that provides a deep cloning function
AngularJS - angular.copy
jQuery - jQuery.extend(true, { }, oldObject); .clone() only clones DOM elements
just library - just-clone; Part of a library of zero-dependency npm modules that do just do one thing. Guilt-free utilities for every occasion.

ES6 (shallow copy)

For completeness, note that ES6 offers two shallow copy mechanisms: Object.assign() and the spread syntax. which copies values of all enumerable own properties from one object to another. For example:

var A1 = {a: "2"};
var A2 = Object.assign({}, A1);
var A3 = {...A1};  // Spread Syntax