WindowBase abstract#

Top-level container for a browser tab or window.

In a web browser, a WindowBase object represents any browser window. This object contains the window's state and its relation to other windows, such as which window opened this window.

Note: This class represents any window, while Window is used to access the properties and content of the current window or tab.

See also#

• Window

Other resources#

• DOM Window from MDN.
• Window from the W3C.

Constructors#

WindowBase()#

Properties#

closed no setter#

Indicates whether this window has been closed.

print(window.closed); // 'false'
window.close();
print(window.closed); // 'true'

MDN does not have compatibility info on this attribute, and therefore is marked nullable.

bool? get closed;

hashCode no setter inherited#

The hash code for this object.

A hash code is a single integer which represents the state of the object that affects operator == comparisons.

All objects have hash codes. The default hash code implemented by Object represents only the identity of the object, the same way as the default operator == implementation only considers objects equal if they are identical (see identityHashCode).

If operator == is overridden to use the object state instead, the hash code must also be changed to represent that state, otherwise the object cannot be used in hash based data structures like the default Set and Map implementations.

Hash codes must be the same for objects that are equal to each other according to operator ==. The hash code of an object should only change if the object changes in a way that affects equality. There are no further requirements for the hash codes. They need not be consistent between executions of the same program and there are no distribution guarantees.

Objects that are not equal are allowed to have the same hash code. It is even technically allowed that all instances have the same hash code, but if clashes happen too often, it may reduce the efficiency of hash-based data structures like HashSet or HashMap.

If a subclass overrides hashCode, it should override the operator == operator as well to maintain consistency.

Inherited from Object.

external int get hashCode;

history no setter#

The current session history for this window.

Other resources

• Session history and navigation specification from WHATWG.

HistoryBase get history;

location no setter#

The current location of this window.

Location currentLocation = window.location;
print(currentLocation.href); // 'http://www.example.com:80/'

LocationBase get location;

on no setter inherited#

This is an ease-of-use accessor for event streams which should only be used when an explicit accessor is not available.

Inherited from EventTarget.

Events get on => new Events(this);

opener no setter#

A reference to the window that opened this one.

Window thisWindow = window;
WindowBase otherWindow = thisWindow.open('http://www.example.com/', 'foo');
print(otherWindow.opener == thisWindow); // 'true'

WindowBase? get opener;

parent no setter#

A reference to the parent of this window.

If this WindowBase has no parent, parent will return a reference to the WindowBase itself.

IFrameElement myIFrame = new IFrameElement();
window.document.body.elements.add(myIFrame);
print(myIframe.contentWindow.parent == window) // 'true'

print(window.parent == window) // 'true'

WindowBase? get parent;

runtimeType no setter inherited#

A representation of the runtime type of the object.

Inherited from Object.

external Type get runtimeType;

top no setter#

A reference to the topmost window in the window hierarchy.

If this WindowBase is the topmost WindowBase, top will return a reference to the WindowBase itself.

// Add an IFrame to the current window.
IFrameElement myIFrame = new IFrameElement();
window.document.body.elements.add(myIFrame);

// Add an IFrame inside of the other IFrame.
IFrameElement innerIFrame = new IFrameElement();
myIFrame.elements.add(innerIFrame);

print(myIframe.contentWindow.top == window) // 'true'
print(innerIFrame.contentWindow.top == window) // 'true'

print(window.top == window) // 'true'

WindowBase? get top;

Methods#

addEventListener() inherited#

Inherited from EventTarget.

void addEventListener(
  String type,
  EventListener? listener, [
  bool? useCapture,
]) {
  // TODO(leafp): This check is avoid a bug in our dispatch code when
  // listener is null.  The browser treats this call as a no-op in this
  // case, so it's fine to short-circuit it, but we should not have to.
  if (listener != null) {
    _addEventListener(type, listener, useCapture);
  }
}

close()#

Closes the window.

This method should only succeed if the WindowBase object is script-closeable and the window calling close is allowed to navigate the window.

A window is script-closeable if it is either a window that was opened by another window, or if it is a window with only one document in its history.

A window might not be allowed to navigate, and therefore close, another window due to browser security features.

var other = window.open('http://www.example.com', 'foo');
// Closes other window, as it is script-closeable.
other.close();
print(other.closed); // 'true'

var newLocation = window.location
    ..href = 'http://www.mysite.com';
window.location = newLocation;
// Does not close this window, as the history has changed.
window.close();
print(window.closed); // 'false'

See also:

• Window close discussion from the W3C

void close();

dispatchEvent() inherited#

Inherited from EventTarget.

bool dispatchEvent(Event event) native;

noSuchMethod() inherited#

Invoked when a nonexistent method or property is accessed.

A dynamic member invocation can attempt to call a member which doesn't exist on the receiving object. Example:

dynamic object = 1;
object.add(42); // Statically allowed, run-time error

This invalid code will invoke the noSuchMethod method of the integer 1 with an Invocation representing the .add(42) call and arguments (which then throws).

Classes can override noSuchMethod to provide custom behavior for such invalid dynamic invocations.

A class with a non-default noSuchMethod invocation can also omit implementations for members of its interface. Example:

class MockList<T> implements List<T> {
  noSuchMethod(Invocation invocation) {
    log(invocation);
    super.noSuchMethod(invocation); // Will throw.
  }
}
void main() {
  MockList().add(42);
}

This code has no compile-time warnings or errors even though the MockList class has no concrete implementation of any of the List interface methods. Calls to List methods are forwarded to noSuchMethod, so this code will log an invocation similar to Invocation.method(#add, [42]) and then throw.

If a value is returned from noSuchMethod, it becomes the result of the original invocation. If the value is not of a type that can be returned by the original invocation, a type error occurs at the invocation.

The default behavior is to throw a NoSuchMethodError.

Inherited from Object.

@pragma("vm:entry-point")
@pragma("wasm:entry-point")
external dynamic noSuchMethod(Invocation invocation);

postMessage()#

Sends a cross-origin message.

Other resources

• window.postMessage from MDN.
• Cross-document messaging from WHATWG.

void postMessage(
  var message,
  String targetOrigin, [
  List<MessagePort>? messagePorts,
]);

removeEventListener() inherited#

Inherited from EventTarget.

void removeEventListener(
  String type,
  EventListener? listener, [
  bool? useCapture,
]) {
  // TODO(leafp): This check is avoid a bug in our dispatch code when
  // listener is null.  The browser treats this call as a no-op in this
  // case, so it's fine to short-circuit it, but we should not have to.
  if (listener != null) {
    _removeEventListener(type, listener, useCapture);
  }
}

toString() inherited#

A string representation of this object.

Some classes have a default textual representation, often paired with a static parse function (like int.parse). These classes will provide the textual representation as their string representation.

Other classes have no meaningful textual representation that a program will care about. Such classes will typically override toString to provide useful information when inspecting the object, mainly for debugging or logging.

Inherited from Object.

external String toString();

Operators#

operator ==() inherited#

The equality operator.

The default behavior for all Objects is to return true if and only if this object and other are the same object.

Override this method to specify a different equality relation on a class. The overriding method must still be an equivalence relation. That is, it must be:

• Total: It must return a boolean for all arguments. It should never throw.

• Reflexive: For all objects o, o == o must be true.

• Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must either both be true, or both be false.

• Transitive: For all objects o1, o2, and o3, if o1 == o2 and o2 == o3 are true, then o1 == o3 must be true.

The method should also be consistent over time, so whether two objects are equal should only change if at least one of the objects was modified.

If a subclass overrides the equality operator, it should override the hashCode method as well to maintain consistency.

Inherited from Object.

external bool operator ==(Object other);