forked from mirrors/gecko-dev
286 lines
12 KiB
C++
286 lines
12 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** 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 ***** */
|
|
|
|
/* loading of CSS style sheets using the network APIs */
|
|
|
|
#ifndef nsICSSLoader_h___
|
|
#define nsICSSLoader_h___
|
|
|
|
#include "nsISupports.h"
|
|
#include "nsSubstring.h"
|
|
#include "nsCompatibility.h"
|
|
|
|
class nsIAtom;
|
|
class nsIURI;
|
|
class nsICSSParser;
|
|
class nsICSSStyleSheet;
|
|
class nsPresContext;
|
|
class nsIContent;
|
|
class nsIDocument;
|
|
class nsIUnicharInputStream;
|
|
class nsICSSLoaderObserver;
|
|
class nsMediaList;
|
|
class nsICSSImportRule;
|
|
class nsIPrincipal;
|
|
|
|
// IID for the nsICSSLoader interface
|
|
// 0c6d7e76-dddc-4727-b557-7ef531127e11
|
|
#define NS_ICSS_LOADER_IID \
|
|
{ 0x0c6d7e76, 0xdddc, 0x4727, \
|
|
{ 0xb5, 0x57, 0x7e, 0xf5, 0x31, 0x12, 0x7e, 0x11 } }
|
|
|
|
typedef void (*nsCSSLoaderCallbackFunc)(nsICSSStyleSheet* aSheet, void *aData, PRBool aDidNotify);
|
|
|
|
class nsICSSLoader : public nsISupports {
|
|
public:
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICSS_LOADER_IID)
|
|
|
|
NS_IMETHOD Init(nsIDocument* aDocument) = 0;
|
|
NS_IMETHOD DropDocumentReference(void) = 0; // notification that doc is going away
|
|
|
|
NS_IMETHOD SetCaseSensitive(PRBool aCaseSensitive) = 0;
|
|
NS_IMETHOD SetCompatibilityMode(nsCompatibility aCompatMode) = 0;
|
|
NS_IMETHOD SetPreferredSheet(const nsAString& aTitle) = 0;
|
|
NS_IMETHOD GetPreferredSheet(nsAString& aTitle) = 0;
|
|
|
|
// Get/Recycle a CSS parser for general use
|
|
NS_IMETHOD GetParserFor(nsICSSStyleSheet* aSheet,
|
|
nsICSSParser** aParser) = 0;
|
|
NS_IMETHOD RecycleParser(nsICSSParser* aParser) = 0;
|
|
|
|
// XXXbz sort out what the deal is with events! When should they fire?
|
|
|
|
/**
|
|
* Load an inline style sheet. If a successful result is returned and
|
|
* *aCompleted is false, then aObserver is guaranteed to be notified
|
|
* asynchronously once the sheet is marked complete. If an error is
|
|
* returned, or if *aCompleted is true, aObserver will not be notified. In
|
|
* addition to parsing the sheet, this method will insert it into the
|
|
* stylesheet list of this CSSLoader's document.
|
|
*
|
|
* @param aElement the element linking to the stylesheet. This must not be
|
|
* null and must implement nsIStyleSheetLinkingElement.
|
|
* @param aStream the character stream that holds the stylesheet data.
|
|
* @param aLineNumber the line number at which the stylesheet data started.
|
|
* @param aTitle the title of the sheet.
|
|
* @param aMedia the media string for the sheet.
|
|
* @param aObserver the observer to notify when the load completes.
|
|
* May be null.
|
|
* @param [out] aCompleted whether parsing of the sheet completed.
|
|
* @param [out] aIsAlternate whether the stylesheet ended up being an
|
|
* alternate sheet.
|
|
*/
|
|
NS_IMETHOD LoadInlineStyle(nsIContent* aElement,
|
|
nsIUnicharInputStream* aStream,
|
|
PRUint32 aLineNumber,
|
|
const nsSubstring& aTitle,
|
|
const nsSubstring& aMedia,
|
|
nsICSSLoaderObserver* aObserver,
|
|
PRBool* aCompleted,
|
|
PRBool* aIsAlternate) = 0;
|
|
|
|
/**
|
|
* Load a linked (document) stylesheet. If a successful result is returned,
|
|
* aObserver is guaranteed to be notified asynchronously once the sheet is
|
|
* loaded and marked complete. If an error is returned, aObserver will not
|
|
* be notified. In addition to loading the sheet, this method will insert it
|
|
* into the stylesheet list of this CSSLoader's document.
|
|
*
|
|
* @param aElement the element linking to the the stylesheet. May be null.
|
|
* @param aURL the URL of the sheet.
|
|
* @param aTitle the title of the sheet.
|
|
* @param aMedia the media string for the sheet.
|
|
* @param aHasAlternateRel whether the rel for this link included
|
|
* "alternate".
|
|
* @param aObserver the observer to notify when the load completes.
|
|
* May be null.
|
|
* @param [out] aIsAlternate whether the stylesheet actually ended up beinga
|
|
* an alternate sheet. Note that this need not match
|
|
* aHasAlternateRel.
|
|
*/
|
|
NS_IMETHOD LoadStyleLink(nsIContent* aElement,
|
|
nsIURI* aURL,
|
|
const nsSubstring& aTitle,
|
|
const nsSubstring& aMedia,
|
|
PRBool aHasAlternateRel,
|
|
nsICSSLoaderObserver* aObserver,
|
|
PRBool* aIsAlternate) = 0;
|
|
|
|
/**
|
|
* Load a child (@import-ed) style sheet. In addition to loading the sheet,
|
|
* this method will insert it into the child sheet list of aParentSheet. If
|
|
* there is no sheet currently being parsed and the child sheet is not
|
|
* complete when this method returns, then when the child sheet becomes
|
|
* complete aParentSheet will be QIed to nsICSSLoaderObserver and
|
|
* asynchronously notified, just like for LoadStyleLink. Note that if the
|
|
* child sheet is already complete when this method returns, no
|
|
* nsICSSLoaderObserver notification will be sent.
|
|
*
|
|
* @param aParentSheet the parent of this child sheet
|
|
* @param aURL the URL of the child sheet
|
|
* @param aMedia the already-parsed media list for the child sheet
|
|
* @param aRule the @import rule importing this child. This is used to
|
|
* properly order the child sheet list of aParentSheet.
|
|
*/
|
|
NS_IMETHOD LoadChildSheet(nsICSSStyleSheet* aParentSheet,
|
|
nsIURI* aURL,
|
|
nsMediaList* aMedia,
|
|
nsICSSImportRule* aRule) = 0;
|
|
|
|
/**
|
|
* Synchronously load and return the stylesheet at aURL. Any child sheets
|
|
* will also be loaded synchronously. Note that synchronous loads over some
|
|
* protocols may involve spinning up a new event loop, so use of this method
|
|
* does NOT guarantee not receiving any events before the sheet loads. This
|
|
* method can be used to load sheets not associated with a document.
|
|
*
|
|
* @param aURL the URL of the sheet to load
|
|
* @param [out] aSheet the loaded, complete sheet.
|
|
* @param aEnableUnsafeRules whether unsafe rules are enabled for this
|
|
* sheet load
|
|
* Unsafe rules are rules that can violate key Gecko invariants if misused.
|
|
* In particular, most anonymous box pseudoelements must be very carefully
|
|
* styled or we will have severe problems. Therefore unsafe rules should
|
|
* never be enabled for stylesheets controlled by untrusted sites; preferably
|
|
* unsafe rules should only be enabled for agent sheets.
|
|
*
|
|
* NOTE: At the moment, this method assumes the sheet will be UTF-8, but
|
|
* ideally it would allow arbitrary encodings. Callers should NOT depend on
|
|
* non-UTF8 sheets being treated as UTF-8 by this method.
|
|
*
|
|
* NOTE: A successful return from this method doesn't indicate anything about
|
|
* whether the data could be parsed as CSS and doesn't indicate anything
|
|
* about the status of child sheets of the returned sheet.
|
|
*/
|
|
NS_IMETHOD LoadSheetSync(nsIURI* aURL, PRBool aEnableUnsafeRules,
|
|
nsICSSStyleSheet** aSheet) = 0;
|
|
|
|
/**
|
|
* As above, but aEnableUnsafeRules is assumed false.
|
|
*/
|
|
nsresult LoadSheetSync(nsIURI* aURL, nsICSSStyleSheet** aSheet) {
|
|
return LoadSheetSync(aURL, PR_FALSE, aSheet);
|
|
}
|
|
|
|
/**
|
|
* Asynchronously load the stylesheet at aURL. If a successful result is
|
|
* returned, aObserver is guaranteed to be notified asynchronously once the
|
|
* sheet is loaded and marked complete. This method can be used to load
|
|
* sheets not associated with a document.
|
|
*
|
|
* @param aURL the URL of the sheet to load
|
|
* @param aOriginPrincipal the principal to use for security checks. This
|
|
* can be null to indicate that these checks should
|
|
* be skipped.
|
|
* @param aObserver the observer to notify when the load completes.
|
|
* Must not be null.
|
|
* @param [out] aSheet the sheet to load. Note that the sheet may well
|
|
* not be loaded by the time this method returns.
|
|
*/
|
|
NS_IMETHOD LoadSheet(nsIURI* aURL,
|
|
nsIPrincipal* aOriginPrincipal,
|
|
nsICSSLoaderObserver* aObserver,
|
|
nsICSSStyleSheet** aSheet) = 0;
|
|
|
|
/**
|
|
* Same as above, to be used when the caller doesn't care about the
|
|
* not-yet-loaded sheet.
|
|
*/
|
|
NS_IMETHOD LoadSheet(nsIURI* aURL,
|
|
nsIPrincipal* aOriginPrincipal,
|
|
nsICSSLoaderObserver* aObserver) = 0;
|
|
|
|
/**
|
|
* Stop loading all sheets. All nsICSSLoaderObservers involved will be
|
|
* notified with NS_BINDING_ABORTED as the status, possibly synchronously.
|
|
*/
|
|
NS_IMETHOD Stop(void) = 0;
|
|
|
|
/**
|
|
* Stop loading one sheet. The nsICSSLoaderObserver involved will be
|
|
* notified with NS_BINDING_ABORTED as the status, possibly synchronously.
|
|
*/
|
|
NS_IMETHOD StopLoadingSheet(nsIURI* aURL) = 0;
|
|
|
|
/**
|
|
* Whether the loader is enabled or not.
|
|
* When disabled, processing of new styles is disabled and an attempt
|
|
* to do so will fail with a return code of
|
|
* NS_ERROR_NOT_AVAILABLE. Note that this DOES NOT disable
|
|
* currently loading styles or already processed styles.
|
|
*/
|
|
NS_IMETHOD GetEnabled(PRBool *aEnabled) = 0;
|
|
NS_IMETHOD SetEnabled(PRBool aEnabled) = 0;
|
|
|
|
/**
|
|
* Return true if this nsICSSLoader has pending loads (ones that would send
|
|
* notifications to an nsICSSLoaderObserver attached to this nsICSSLoader).
|
|
* If called from inside nsICSSLoaderObserver::StyleSheetLoaded, this will
|
|
* return PR_FALSE if and only if that is the last StyleSheetLoaded
|
|
* notification the CSSLoader knows it's going to send. In other words, if
|
|
* two sheets load at once (via load coalescing, e.g.), HasPendingLoads()
|
|
* will return PR_TRUE during notification for the first one, and PR_FALSE
|
|
* during notification for the second one.
|
|
*/
|
|
NS_IMETHOD_(PRBool) HasPendingLoads() = 0;
|
|
|
|
/**
|
|
* Add an observer to this nsICSSLoader. The observer will be notified for
|
|
* all loads that would have notified their own observers (even if those
|
|
* loads don't have observers attached to them). Load-specific observers
|
|
* will be notified before generic observers. The CSSLoader holds a
|
|
* reference to the observer.
|
|
*
|
|
* aObserver must not be null.
|
|
*/
|
|
NS_IMETHOD AddObserver(nsICSSLoaderObserver* aObserver) = 0;
|
|
|
|
/**
|
|
* Remove an observer added via AddObserver.
|
|
*/
|
|
NS_IMETHOD_(void) RemoveObserver(nsICSSLoaderObserver* aObserver) = 0;
|
|
};
|
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(nsICSSLoader, NS_ICSS_LOADER_IID)
|
|
|
|
nsresult
|
|
NS_NewCSSLoader(nsIDocument* aDocument, nsICSSLoader** aLoader);
|
|
|
|
nsresult
|
|
NS_NewCSSLoader(nsICSSLoader** aLoader);
|
|
|
|
#endif /* nsICSSLoader_h___ */
|