2001-08-05 01:19:53 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
|
|
*
|
2004-04-18 01:52:36 +04:00
|
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
2001-08-05 01:19:53 +04:00
|
|
|
*
|
2004-04-18 01:52:36 +04:00
|
|
|
* 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.
|
2001-08-05 01:19:53 +04:00
|
|
|
*
|
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 01:52:36 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Boris Zbarsky <bzbarsky@mit.edu>.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 2001
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
2001-08-05 01:19:53 +04:00
|
|
|
*
|
|
|
|
* Contributor(s):
|
2008-07-26 20:14:48 +04:00
|
|
|
* L. David Baron <dbaron@dbaron.org>, Mozilla Corporation
|
2004-04-18 01:52:36 +04:00
|
|
|
*
|
|
|
|
* 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 ***** */
|
2006-03-25 08:47:31 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* representation of media lists used when linking to style sheets or by
|
|
|
|
* @media rules
|
|
|
|
*/
|
|
|
|
|
2005-03-30 04:36:57 +04:00
|
|
|
#ifndef nsIMediaList_h_
|
|
|
|
#define nsIMediaList_h_
|
2001-08-05 01:19:53 +04:00
|
|
|
|
2005-03-30 04:36:57 +04:00
|
|
|
#include "nsIDOMMediaList.h"
|
2008-07-26 20:14:48 +04:00
|
|
|
#include "nsTArray.h"
|
2005-03-30 04:36:57 +04:00
|
|
|
#include "nsIAtom.h"
|
2008-07-26 20:14:48 +04:00
|
|
|
#include "nsCSSValue.h"
|
|
|
|
|
2005-03-30 04:36:57 +04:00
|
|
|
class nsPresContext;
|
2010-05-12 00:41:47 +04:00
|
|
|
class nsCSSStyleSheet;
|
2010-05-12 00:41:47 +04:00
|
|
|
class nsAString;
|
|
|
|
struct nsMediaFeature;
|
2001-08-05 01:19:53 +04:00
|
|
|
|
2008-07-26 20:14:48 +04:00
|
|
|
struct nsMediaExpression {
|
|
|
|
enum Range { eMin, eMax, eEqual };
|
|
|
|
|
|
|
|
const nsMediaFeature *mFeature;
|
|
|
|
Range mRange;
|
|
|
|
nsCSSValue mValue;
|
|
|
|
|
|
|
|
// aActualValue must be obtained from mFeature->mGetter
|
|
|
|
PRBool Matches(nsPresContext* aPresContext,
|
|
|
|
const nsCSSValue& aActualValue) const;
|
|
|
|
};
|
|
|
|
|
2008-07-26 20:14:48 +04:00
|
|
|
/**
|
|
|
|
* An nsMediaQueryResultCacheKey records what feature/value combinations
|
|
|
|
* a set of media query results are valid for. This allows the caller
|
|
|
|
* to quickly learn whether a prior result of media query evaluation is
|
|
|
|
* still valid (e.g., due to a window size change) without rerunning all
|
|
|
|
* of the evaluation and rebuilding the list of rules.
|
|
|
|
*
|
|
|
|
* This object may not be used after any media rules in any of the
|
|
|
|
* sheets it was given to have been modified. However, this is
|
|
|
|
* generally not a problem since ClearRuleCascades is called on the
|
|
|
|
* sheet whenever this happens, and these objects are stored inside the
|
|
|
|
* rule cascades. (FIXME: We're not actually doing this all the time.)
|
|
|
|
*
|
|
|
|
* The implementation could be further optimized in the future to store
|
|
|
|
* ranges (combinations of less-than, less-than-or-equal, greater-than,
|
|
|
|
* greater-than-or-equal, equal, not-equal, present, not-present) for
|
|
|
|
* each feature rather than simply storing the list of expressions.
|
|
|
|
* However, this requires combining any such ranges.
|
|
|
|
*/
|
|
|
|
class nsMediaQueryResultCacheKey {
|
|
|
|
public:
|
|
|
|
nsMediaQueryResultCacheKey(nsIAtom* aMedium)
|
|
|
|
: mMedium(aMedium)
|
|
|
|
{}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Record that aExpression was tested while building the cached set
|
|
|
|
* that this cache key is for, and that aExpressionMatches was whether
|
|
|
|
* it matched.
|
|
|
|
*/
|
|
|
|
void AddExpression(const nsMediaExpression* aExpression,
|
|
|
|
PRBool aExpressionMatches);
|
|
|
|
PRBool Matches(nsPresContext* aPresContext) const;
|
|
|
|
private:
|
|
|
|
struct ExpressionEntry {
|
|
|
|
// FIXME: if we were better at maintaining invariants about clearing
|
|
|
|
// rule cascades when media lists change, this could be a |const
|
|
|
|
// nsMediaExpression*| instead.
|
|
|
|
nsMediaExpression mExpression;
|
|
|
|
PRBool mExpressionMatches;
|
|
|
|
};
|
|
|
|
struct FeatureEntry {
|
|
|
|
const nsMediaFeature *mFeature;
|
|
|
|
nsTArray<ExpressionEntry> mExpressions;
|
|
|
|
};
|
|
|
|
nsCOMPtr<nsIAtom> mMedium;
|
|
|
|
nsTArray<FeatureEntry> mFeatureCache;
|
|
|
|
};
|
|
|
|
|
2008-07-26 20:14:48 +04:00
|
|
|
class nsMediaQuery {
|
|
|
|
public:
|
|
|
|
nsMediaQuery()
|
|
|
|
: mNegated(PR_FALSE)
|
|
|
|
, mHasOnly(PR_FALSE)
|
|
|
|
, mTypeOmitted(PR_FALSE)
|
|
|
|
, mHadUnknownExpression(PR_FALSE)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
// for Clone only
|
|
|
|
nsMediaQuery(const nsMediaQuery& aOther)
|
|
|
|
: mNegated(aOther.mNegated)
|
|
|
|
, mHasOnly(aOther.mHasOnly)
|
|
|
|
, mTypeOmitted(aOther.mTypeOmitted)
|
|
|
|
, mHadUnknownExpression(aOther.mHadUnknownExpression)
|
|
|
|
, mMediaType(aOther.mMediaType)
|
|
|
|
// Clone checks the result of this deep copy for allocation failure
|
|
|
|
, mExpressions(aOther.mExpressions)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
void SetNegated() { mNegated = PR_TRUE; }
|
|
|
|
void SetHasOnly() { mHasOnly = PR_TRUE; }
|
|
|
|
void SetTypeOmitted() { mTypeOmitted = PR_TRUE; }
|
|
|
|
void SetHadUnknownExpression() { mHadUnknownExpression = PR_TRUE; }
|
|
|
|
void SetType(nsIAtom* aMediaType) {
|
|
|
|
NS_ASSERTION(aMediaType,
|
|
|
|
"expected non-null");
|
|
|
|
mMediaType = aMediaType;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return a new nsMediaExpression in the array for the caller to fill
|
|
|
|
// in. The caller must either fill it in completely, or call
|
|
|
|
// SetHadUnknownExpression on this nsMediaQuery.
|
|
|
|
// Returns null on out-of-memory.
|
|
|
|
nsMediaExpression* NewExpression() { return mExpressions.AppendElement(); }
|
|
|
|
|
|
|
|
void AppendToString(nsAString& aString) const;
|
|
|
|
|
|
|
|
nsMediaQuery* Clone() const;
|
|
|
|
|
|
|
|
// Does this query apply to the presentation?
|
2008-07-26 20:14:48 +04:00
|
|
|
PRBool Matches(nsPresContext* aPresContext,
|
|
|
|
nsMediaQueryResultCacheKey& aKey) const;
|
2008-07-26 20:14:48 +04:00
|
|
|
|
|
|
|
private:
|
|
|
|
PRPackedBool mNegated;
|
|
|
|
PRPackedBool mHasOnly; // only needed for serialization
|
|
|
|
PRPackedBool mTypeOmitted; // only needed for serialization
|
|
|
|
PRPackedBool mHadUnknownExpression;
|
|
|
|
nsCOMPtr<nsIAtom> mMediaType;
|
|
|
|
nsTArray<nsMediaExpression> mExpressions;
|
|
|
|
};
|
|
|
|
|
2005-03-30 04:36:57 +04:00
|
|
|
class nsMediaList : public nsIDOMMediaList {
|
2001-08-05 01:19:53 +04:00
|
|
|
public:
|
2005-03-30 04:36:57 +04:00
|
|
|
nsMediaList();
|
2001-08-05 01:19:53 +04:00
|
|
|
|
2005-03-30 04:36:57 +04:00
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
|
|
|
|
NS_DECL_NSIDOMMEDIALIST
|
|
|
|
|
|
|
|
nsresult GetText(nsAString& aMediaText);
|
|
|
|
nsresult SetText(const nsAString& aMediaText);
|
2008-07-26 20:14:48 +04:00
|
|
|
PRBool Matches(nsPresContext* aPresContext,
|
|
|
|
nsMediaQueryResultCacheKey& aKey);
|
2010-05-12 00:41:47 +04:00
|
|
|
nsresult SetStyleSheet(nsCSSStyleSheet* aSheet);
|
2008-07-26 20:14:48 +04:00
|
|
|
nsresult AppendQuery(nsAutoPtr<nsMediaQuery>& aQuery) {
|
|
|
|
// Takes ownership of aQuery (if it succeeds)
|
|
|
|
if (!mArray.AppendElement(aQuery.get())) {
|
|
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
aQuery.forget();
|
|
|
|
return NS_OK;
|
2005-03-30 04:36:57 +04:00
|
|
|
}
|
2001-08-05 01:19:53 +04:00
|
|
|
|
2005-03-30 04:36:57 +04:00
|
|
|
nsresult Clone(nsMediaList** aResult);
|
2001-09-05 04:00:18 +04:00
|
|
|
|
2008-07-26 20:14:48 +04:00
|
|
|
PRInt32 Count() { return mArray.Length(); }
|
|
|
|
nsMediaQuery* MediumAt(PRInt32 aIndex) { return mArray[aIndex]; }
|
|
|
|
void Clear() { mArray.Clear(); mIsEmpty = PR_TRUE; }
|
|
|
|
// a media list with no items may not represent the lack of a media
|
|
|
|
// list; it could represent the empty string or something with parser
|
|
|
|
// errors, which means that the media list should never match
|
|
|
|
void SetNonEmpty() { mIsEmpty = PR_FALSE; }
|
2005-03-30 04:36:57 +04:00
|
|
|
|
2005-03-30 05:42:06 +04:00
|
|
|
protected:
|
2005-03-30 04:36:57 +04:00
|
|
|
~nsMediaList();
|
|
|
|
|
|
|
|
nsresult Delete(const nsAString & aOldMedium);
|
|
|
|
nsresult Append(const nsAString & aOldMedium);
|
|
|
|
|
2008-07-26 20:14:48 +04:00
|
|
|
nsTArray<nsAutoPtr<nsMediaQuery> > mArray;
|
|
|
|
PRBool mIsEmpty;
|
2005-03-30 04:36:57 +04:00
|
|
|
// not refcounted; sheet will let us know when it goes away
|
|
|
|
// mStyleSheet is the sheet that needs to be dirtied when this medialist
|
|
|
|
// changes
|
|
|
|
nsCSSStyleSheet* mStyleSheet;
|
|
|
|
};
|
|
|
|
#endif /* !defined(nsIMediaList_h_) */
|