| /* -*- Mode: C++; tab-width: 2; 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) 1999 |
| * the Initial Developer. All Rights Reserved. |
| * |
| * Contributor(s): |
| * |
| * 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 ***** */ |
| |
| #include "nsISupports.idl" |
| |
| interface nsIURIContentListener; |
| interface nsIURI; |
| interface nsILoadGroup; |
| interface nsIProgressEventSink; |
| interface nsIChannel; |
| interface nsIRequest; |
| interface nsIStreamListener; |
| interface nsIInputStream; |
| interface nsIInterfaceRequestor; |
| |
| /** |
| * The uri dispatcher is responsible for taking uri's, determining |
| * the content and routing the opened url to the correct content |
| * handler. |
| * |
| * When you encounter a url you want to open, you typically call |
| * openURI, passing it the content listener for the window the uri is |
| * originating from. The uri dispatcher opens the url to discover the |
| * content type. It then gives the content listener first crack at |
| * handling the content. If it doesn't want it, the dispatcher tries |
| * to hand it off one of the registered content listeners. This allows |
| * running applications the chance to jump in and handle the content. |
| * |
| * If that also fails, then the uri dispatcher goes to the registry |
| * looking for the preferred content handler for the content type |
| * of the uri. The content handler may create an app instance |
| * or it may hand the contents off to a platform specific plugin |
| * or helper app. Or it may hand the url off to an OS registered |
| * application. |
| */ |
| [scriptable, uuid(2f7e8051-f1c9-4bcc-8584-9cfd5849e343)] |
| interface nsIURILoader : nsISupports |
| { |
| /** |
| * @name Flags for opening URIs. |
| */ |
| /* @{ */ |
| /** |
| * Should the content be displayed in a container that prefers the |
| * content-type, or will any container do. |
| */ |
| const unsigned long IS_CONTENT_PREFERRED = 1 << 0; |
| /** |
| * If this flag is set, only the listener of the specified window context will |
| * be considered for content handling; if it refuses the load, an error will |
| * be indicated. |
| */ |
| const unsigned long DONT_RETARGET = 1 << 1; |
| /* @} */ |
| |
| /** |
| * As applications such as messenger and the browser are instantiated, |
| * they register content listener's with the uri dispatcher corresponding |
| * to content windows within that application. |
| * |
| * Note to self: we may want to optimize things a bit more by requiring |
| * the content types the registered content listener cares about. |
| * |
| * @param aContentListener |
| * The listener to register. This listener must implement |
| * nsISupportsWeakReference. |
| * |
| * @see the nsIURILoader class description |
| */ |
| void registerContentListener (in nsIURIContentListener aContentListener); |
| void unRegisterContentListener (in nsIURIContentListener aContentListener); |
| |
| /** |
| * OpenURI requires the following parameters..... |
| * @param aChannel |
| * The channel that should be opened. This must not be asyncOpen'd yet! |
| * If a loadgroup is set on the channel, it will get replaced with a |
| * different one. |
| * @param aIsContentPreferred |
| * Should the content be displayed in a container that prefers the |
| * content-type, or will any container do. |
| * @param aWindowContext |
| * If you are running the url from a doc shell or a web shell, this is |
| * your window context. If you have a content listener you want to |
| * give first crack to, the uri loader needs to be able to get it |
| * from the window context. We will also be using the window context |
| * to get at the progress event sink interface. |
| * <b>Must not be null!</b> |
| */ |
| void openURI(in nsIChannel aChannel, |
| in boolean aIsContentPreferred, |
| in nsIInterfaceRequestor aWindowContext); |
| |
| /** |
| * Loads data from a channel. This differs from openURI in that the channel |
| * may already be opened, and that it returns a stream listener into which the |
| * caller should pump data. The caller is responsible for opening the channel |
| * and pumping the channel's data into the returned stream listener. |
| * |
| * Note: If the channel already has a loadgroup, it will be replaced with the |
| * window context's load group, or null if the context doesn't have one. |
| * |
| * If the window context's nsIURIContentListener refuses the load immediately |
| * (e.g. in nsIURIContentListener::onStartURIOpen), this method will return |
| * NS_ERROR_WONT_HANDLE_CONTENT. At that point, the caller should probably |
| * cancel the channel if it's already open (this method will not cancel the |
| * channel). |
| * |
| * If flags include DONT_RETARGET, and the content listener refuses the load |
| * during onStartRequest (e.g. in canHandleContent/isPreferred), then the |
| * returned stream listener's onStartRequest method will return |
| * NS_ERROR_WONT_HANDLE_CONTENT. |
| * |
| * @param aChannel |
| * The channel that should be loaded. The channel may already be |
| * opened. It must not be closed (i.e. this must be called before the |
| * channel calls onStopRequest on its stream listener). |
| * @param aFlags |
| * Combination (bitwise OR) of the flags specified above. 0 indicates |
| * default handling. |
| * @param aWindowContext |
| * If you are running the url from a doc shell or a web shell, this is |
| * your window context. If you have a content listener you want to |
| * give first crack to, the uri loader needs to be able to get it |
| * from the window context. We will also be using the window context |
| * to get at the progress event sink interface. |
| * <b>Must not be null!</b> |
| */ |
| nsIStreamListener openChannel(in nsIChannel aChannel, |
| in unsigned long aFlags, |
| in nsIInterfaceRequestor aWindowContext); |
| |
| /** |
| * Stops an in progress load |
| */ |
| void stop(in nsISupports aLoadCookie); |
| }; |
| |