/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is mozilla.org code. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Radha Kulkarni * * Alternatively, the contents of this file may be used under the terms of * either of the GNU General Public License Version 2 or later (the "GPL"), * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /** * The interface to nsISHentry. Each document or subframe in * Session History will have a nsISHEntry associated with it which will * hold all information required to recreate the document from history * */ #include "nsIHistoryEntry.idl" interface nsILayoutHistoryState; interface nsIContentViewer; interface nsIURI; interface nsIInputStream; interface nsIDocShellTreeItem; interface nsISupportsArray; interface nsIStructuredCloneContainer; interface nsIBFCacheEntry; %{C++ struct nsIntRect; class nsDocShellEditorData; class nsSHEntryShared; %} [ref] native nsIntRect(nsIntRect); [ptr] native nsDocShellEditorDataPtr(nsDocShellEditorData); [ptr] native nsSHEntryShared(nsSHEntryShared); [scriptable, uuid(6443FD72-A50F-4B8B-BB82-BB1FA04CB15D)] interface nsISHEntry : nsIHistoryEntry { /** URI for the document */ void setURI(in nsIURI aURI); /** Referrer URI */ attribute nsIURI referrerURI; /** Content viewer, for fast restoration of presentation */ attribute nsIContentViewer contentViewer; /** Whether the content viewer is marked "sticky" */ attribute boolean sticky; /** Saved state of the global window object */ attribute nsISupports windowState; /** * Saved position and dimensions of the content viewer; we must adjust the * root view's widget accordingly if this has changed when the presentation * is restored. */ [noscript] void getViewerBounds(in nsIntRect bounds); [noscript] void setViewerBounds([const] in nsIntRect bounds); /** * Saved child docshells corresponding to contentViewer. The child shells * are restored as children of the parent docshell, in this order, when the * parent docshell restores a saved presentation. */ /** Append a child shell to the end of our list. */ void addChildShell(in nsIDocShellTreeItem shell); /** * Get the child shell at |index|; returns null if |index| is out of bounds. */ nsIDocShellTreeItem childShellAt(in long index); /** * Clear the child shell list. */ void clearChildShells(); /** Saved refresh URI list for the content viewer */ attribute nsISupportsArray refreshURIList; /** * Ensure that the cached presentation members are self-consistent. * If either |contentViewer| or |windowState| are null, then all of the * following members are cleared/reset: * contentViewer, sticky, windowState, viewerBounds, childShells, * refreshURIList. */ void syncPresentationState(); /** Title for the document */ void setTitle(in AString aTitle); /** Post Data for the document */ attribute nsIInputStream postData; /** LayoutHistoryState for scroll position and form values */ attribute nsILayoutHistoryState layoutHistoryState; /** parent of this entry */ attribute nsISHEntry parent; /** * The loadType for this entry. This is typically loadHistory except * when reload is pressed, it has the appropriate reload flag */ attribute unsigned long loadType; /** * An ID to help identify this entry from others during * subframe navigation */ attribute unsigned long ID; /** attribute to set and get the cache key for the entry */ attribute nsISupports cacheKey; /** attribute to indicate whether layoutHistoryState should be saved */ attribute boolean saveLayoutStateFlag; /** attribute to indicate whether the page is already expired in cache */ attribute boolean expirationStatus; /** * attribute to indicate the content-type of the document that this * is a session history entry for */ attribute ACString contentType; /** * If we created this SHEntry via history.pushState or modified it via * history.replaceState, and if we changed the SHEntry's URI via the * push/replaceState call, and if the SHEntry's new URI differs from its * old URI by more than just the hash, then we set this field to true. * * Additionally, if this SHEntry was created by calling pushState from a * SHEntry whose URI was modified, this SHEntry's URIWasModified field is * true. * */ attribute boolean URIWasModified; /** Set/Get scrollers' positon in anchored pages */ void setScrollPosition(in long x, in long y); void getScrollPosition(out long x, out long y); /** Additional ways to create an entry */ [noscript] void create(in nsIURI URI, in AString title, in nsIInputStream inputStream, in nsILayoutHistoryState layoutHistoryState, in nsISupports cacheKey, in ACString contentType, in nsISupports owner, in unsigned long long docshellID, in boolean dynamicCreation); nsISHEntry clone(); /** Attribute that indicates if this entry is for a subframe navigation */ void setIsSubFrame(in boolean aFlag); /** Return any content viewer present in or below this node in the nsSHEntry tree. This will differ from contentViewer in the case where a child nsSHEntry has the content viewer for this tree. */ nsIContentViewer getAnyContentViewer(out nsISHEntry ownerEntry); /** * Get the owner, if any, that was associated with the channel * that the document that was loaded to create this history entry * came from. */ attribute nsISupports owner; /** * Get/set data associated with this history state via a pushState() call, * serialized using structured clone. **/ attribute nsIStructuredCloneContainer stateData; /** * Gets the owning pointer to the editor data assosicated with * this shistory entry. This forgets its pointer, so free it when * you're done. */ [noscript, notxpcom] nsDocShellEditorDataPtr forgetEditorData(); /** * Sets the owning pointer to the editor data assosicated with * this shistory entry. Unless forgetEditorData() is called, this * shentry will destroy the editor data when it's destroyed. */ [noscript, notxpcom] void setEditorData(in nsDocShellEditorDataPtr aData); /** Returns true if this shistory entry is storing a detached editor. */ [noscript, notxpcom] boolean hasDetachedEditor(); /** * Returns true if the related docshell was added because of * dynamic addition of an iframe/frame. */ boolean isDynamicallyAdded(); /** * Returns true if any of the child entries returns true * when isDynamicallyAdded is called on it. */ boolean hasDynamicallyAddedChild(); /** * The history ID of the docshell. */ attribute unsigned long long docshellID; readonly attribute nsIBFCacheEntry BFCacheEntry; /** * Does this SHEntry point to the given BFCache entry? If so, evicting * the BFCache entry will evict the SHEntry, since the two entries * correspond to the same document. */ [notxpcom, noscript] boolean hasBFCacheEntry(in nsIBFCacheEntry aEntry); /** * Adopt aEntry's BFCacheEntry, so now both this and aEntry point to * aEntry's BFCacheEntry. */ void adoptBFCacheEntry(in nsISHEntry aEntry); /** * Create a new BFCache entry and drop our reference to our old one. This * call unlinks this SHEntry from any other SHEntries for its document. */ void abandonBFCacheEntry(); /** * Does this SHEntry correspond to the same document as aEntry? This is * true iff the two SHEntries have the same BFCacheEntry. So in * particular, sharesDocumentWith(aEntry) is guaranteed to return true if * it's preceeded by a call to adoptBFCacheEntry(aEntry). */ boolean sharesDocumentWith(in nsISHEntry aEntry); }; [scriptable, uuid(bb66ac35-253b-471f-a317-3ece940f04c5)] interface nsISHEntryInternal : nsISupports { [notxpcom] void RemoveFromBFCacheAsync(); [notxpcom] void RemoveFromBFCacheSync(); /** * A number that is assigned by the sHistory when the entry is activated */ attribute unsigned long lastTouched; /** * Some state, particularly that related to the back/forward cache, is * shared between SHEntries which correspond to the same document. This * method gets a pointer to that shared state. * * This shared state is the SHEntry's BFCacheEntry. So * hasBFCacheEntry(getSharedState()) is guaranteed to return true. */ [noscript, notxpcom] nsSHEntryShared getSharedState(); }; %{ C++ // {BFD1A791-AD9F-11d3-BDC7-0050040A9B44} #define NS_SHENTRY_CID \ {0xbfd1a791, 0xad9f, 0x11d3, {0xbd, 0xc7, 0x0, 0x50, 0x4, 0xa, 0x9b, 0x44}} #define NS_SHENTRY_CONTRACTID \ "@mozilla.org/browser/session-history-entry;1" %}