DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Untracked file

nsIDOMCSSCounterStyleRule

Macros

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
/*
 * DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsIDOMCSSCounterStyleRule.idl
 */

#ifndef __gen_nsIDOMCSSCounterStyleRule_h__
#define __gen_nsIDOMCSSCounterStyleRule_h__


#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif

/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif

/* starting interface:    nsIDOMCSSCounterStyleRule */
#define NS_IDOMCSSCOUNTERSTYLERULE_IID_STR "9b5e48ce-d84c-4e31-aff5-34e9f4141313"

#define NS_IDOMCSSCOUNTERSTYLERULE_IID \
  {0x9b5e48ce, 0xd84c, 0x4e31, \
    { 0xaf, 0xf5, 0x34, 0xe9, 0xf4, 0x14, 0x13, 0x13 }}

class NS_NO_VTABLE nsIDOMCSSCounterStyleRule : public nsISupports {
 public:

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMCSSCOUNTERSTYLERULE_IID)

  /* attribute DOMString name; */
  NS_IMETHOD GetName(nsAString & aName) = 0;
  NS_IMETHOD SetName(const nsAString & aName) = 0;

  /* attribute DOMString system; */
  NS_IMETHOD GetSystem(nsAString & aSystem) = 0;
  NS_IMETHOD SetSystem(const nsAString & aSystem) = 0;

  /* attribute DOMString symbols; */
  NS_IMETHOD GetSymbols(nsAString & aSymbols) = 0;
  NS_IMETHOD SetSymbols(const nsAString & aSymbols) = 0;

  /* attribute DOMString additiveSymbols; */
  NS_IMETHOD GetAdditiveSymbols(nsAString & aAdditiveSymbols) = 0;
  NS_IMETHOD SetAdditiveSymbols(const nsAString & aAdditiveSymbols) = 0;

  /* attribute DOMString negative; */
  NS_IMETHOD GetNegative(nsAString & aNegative) = 0;
  NS_IMETHOD SetNegative(const nsAString & aNegative) = 0;

  /* attribute DOMString prefix; */
  NS_IMETHOD GetPrefix(nsAString & aPrefix) = 0;
  NS_IMETHOD SetPrefix(const nsAString & aPrefix) = 0;

  /* attribute DOMString suffix; */
  NS_IMETHOD GetSuffix(nsAString & aSuffix) = 0;
  NS_IMETHOD SetSuffix(const nsAString & aSuffix) = 0;

  /* attribute DOMString range; */
  NS_IMETHOD GetRange(nsAString & aRange) = 0;
  NS_IMETHOD SetRange(const nsAString & aRange) = 0;

  /* attribute DOMString pad; */
  NS_IMETHOD GetPad(nsAString & aPad) = 0;
  NS_IMETHOD SetPad(const nsAString & aPad) = 0;

  /* attribute DOMString speakAs; */
  NS_IMETHOD GetSpeakAs(nsAString & aSpeakAs) = 0;
  NS_IMETHOD SetSpeakAs(const nsAString & aSpeakAs) = 0;

  /* attribute DOMString fallback; */
  NS_IMETHOD GetFallback(nsAString & aFallback) = 0;
  NS_IMETHOD SetFallback(const nsAString & aFallback) = 0;

};

  NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMCSSCounterStyleRule, NS_IDOMCSSCOUNTERSTYLERULE_IID)

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIDOMCSSCOUNTERSTYLERULE \
  NS_IMETHOD GetName(nsAString & aName) override; \
  NS_IMETHOD SetName(const nsAString & aName) override; \
  NS_IMETHOD GetSystem(nsAString & aSystem) override; \
  NS_IMETHOD SetSystem(const nsAString & aSystem) override; \
  NS_IMETHOD GetSymbols(nsAString & aSymbols) override; \
  NS_IMETHOD SetSymbols(const nsAString & aSymbols) override; \
  NS_IMETHOD GetAdditiveSymbols(nsAString & aAdditiveSymbols) override; \
  NS_IMETHOD SetAdditiveSymbols(const nsAString & aAdditiveSymbols) override; \
  NS_IMETHOD GetNegative(nsAString & aNegative) override; \
  NS_IMETHOD SetNegative(const nsAString & aNegative) override; \
  NS_IMETHOD GetPrefix(nsAString & aPrefix) override; \
  NS_IMETHOD SetPrefix(const nsAString & aPrefix) override; \
  NS_IMETHOD GetSuffix(nsAString & aSuffix) override; \
  NS_IMETHOD SetSuffix(const nsAString & aSuffix) override; \
  NS_IMETHOD GetRange(nsAString & aRange) override; \
  NS_IMETHOD SetRange(const nsAString & aRange) override; \
  NS_IMETHOD GetPad(nsAString & aPad) override; \
  NS_IMETHOD SetPad(const nsAString & aPad) override; \
  NS_IMETHOD GetSpeakAs(nsAString & aSpeakAs) override; \
  NS_IMETHOD SetSpeakAs(const nsAString & aSpeakAs) override; \
  NS_IMETHOD GetFallback(nsAString & aFallback) override; \
  NS_IMETHOD SetFallback(const nsAString & aFallback) override; 

/* Use this macro when declaring the members of this interface when the
   class doesn't implement the interface. This is useful for forwarding. */
#define NS_DECL_NON_VIRTUAL_NSIDOMCSSCOUNTERSTYLERULE \
  nsresult GetName(nsAString & aName); \
  nsresult SetName(const nsAString & aName); \
  nsresult GetSystem(nsAString & aSystem); \
  nsresult SetSystem(const nsAString & aSystem); \
  nsresult GetSymbols(nsAString & aSymbols); \
  nsresult SetSymbols(const nsAString & aSymbols); \
  nsresult GetAdditiveSymbols(nsAString & aAdditiveSymbols); \
  nsresult SetAdditiveSymbols(const nsAString & aAdditiveSymbols); \
  nsresult GetNegative(nsAString & aNegative); \
  nsresult SetNegative(const nsAString & aNegative); \
  nsresult GetPrefix(nsAString & aPrefix); \
  nsresult SetPrefix(const nsAString & aPrefix); \
  nsresult GetSuffix(nsAString & aSuffix); \
  nsresult SetSuffix(const nsAString & aSuffix); \
  nsresult GetRange(nsAString & aRange); \
  nsresult SetRange(const nsAString & aRange); \
  nsresult GetPad(nsAString & aPad); \
  nsresult SetPad(const nsAString & aPad); \
  nsresult GetSpeakAs(nsAString & aSpeakAs); \
  nsresult SetSpeakAs(const nsAString & aSpeakAs); \
  nsresult GetFallback(nsAString & aFallback); \
  nsresult SetFallback(const nsAString & aFallback); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIDOMCSSCOUNTERSTYLERULE(_to) \
  NS_IMETHOD GetName(nsAString & aName) override { return _to GetName(aName); } \
  NS_IMETHOD SetName(const nsAString & aName) override { return _to SetName(aName); } \
  NS_IMETHOD GetSystem(nsAString & aSystem) override { return _to GetSystem(aSystem); } \
  NS_IMETHOD SetSystem(const nsAString & aSystem) override { return _to SetSystem(aSystem); } \
  NS_IMETHOD GetSymbols(nsAString & aSymbols) override { return _to GetSymbols(aSymbols); } \
  NS_IMETHOD SetSymbols(const nsAString & aSymbols) override { return _to SetSymbols(aSymbols); } \
  NS_IMETHOD GetAdditiveSymbols(nsAString & aAdditiveSymbols) override { return _to GetAdditiveSymbols(aAdditiveSymbols); } \
  NS_IMETHOD SetAdditiveSymbols(const nsAString & aAdditiveSymbols) override { return _to SetAdditiveSymbols(aAdditiveSymbols); } \
  NS_IMETHOD GetNegative(nsAString & aNegative) override { return _to GetNegative(aNegative); } \
  NS_IMETHOD SetNegative(const nsAString & aNegative) override { return _to SetNegative(aNegative); } \
  NS_IMETHOD GetPrefix(nsAString & aPrefix) override { return _to GetPrefix(aPrefix); } \
  NS_IMETHOD SetPrefix(const nsAString & aPrefix) override { return _to SetPrefix(aPrefix); } \
  NS_IMETHOD GetSuffix(nsAString & aSuffix) override { return _to GetSuffix(aSuffix); } \
  NS_IMETHOD SetSuffix(const nsAString & aSuffix) override { return _to SetSuffix(aSuffix); } \
  NS_IMETHOD GetRange(nsAString & aRange) override { return _to GetRange(aRange); } \
  NS_IMETHOD SetRange(const nsAString & aRange) override { return _to SetRange(aRange); } \
  NS_IMETHOD GetPad(nsAString & aPad) override { return _to GetPad(aPad); } \
  NS_IMETHOD SetPad(const nsAString & aPad) override { return _to SetPad(aPad); } \
  NS_IMETHOD GetSpeakAs(nsAString & aSpeakAs) override { return _to GetSpeakAs(aSpeakAs); } \
  NS_IMETHOD SetSpeakAs(const nsAString & aSpeakAs) override { return _to SetSpeakAs(aSpeakAs); } \
  NS_IMETHOD GetFallback(nsAString & aFallback) override { return _to GetFallback(aFallback); } \
  NS_IMETHOD SetFallback(const nsAString & aFallback) override { return _to SetFallback(aFallback); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIDOMCSSCOUNTERSTYLERULE(_to) \
  NS_IMETHOD GetName(nsAString & aName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetName(aName); } \
  NS_IMETHOD SetName(const nsAString & aName) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetName(aName); } \
  NS_IMETHOD GetSystem(nsAString & aSystem) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSystem(aSystem); } \
  NS_IMETHOD SetSystem(const nsAString & aSystem) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSystem(aSystem); } \
  NS_IMETHOD GetSymbols(nsAString & aSymbols) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSymbols(aSymbols); } \
  NS_IMETHOD SetSymbols(const nsAString & aSymbols) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSymbols(aSymbols); } \
  NS_IMETHOD GetAdditiveSymbols(nsAString & aAdditiveSymbols) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAdditiveSymbols(aAdditiveSymbols); } \
  NS_IMETHOD SetAdditiveSymbols(const nsAString & aAdditiveSymbols) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAdditiveSymbols(aAdditiveSymbols); } \
  NS_IMETHOD GetNegative(nsAString & aNegative) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetNegative(aNegative); } \
  NS_IMETHOD SetNegative(const nsAString & aNegative) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetNegative(aNegative); } \
  NS_IMETHOD GetPrefix(nsAString & aPrefix) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPrefix(aPrefix); } \
  NS_IMETHOD SetPrefix(const nsAString & aPrefix) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPrefix(aPrefix); } \
  NS_IMETHOD GetSuffix(nsAString & aSuffix) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSuffix(aSuffix); } \
  NS_IMETHOD SetSuffix(const nsAString & aSuffix) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSuffix(aSuffix); } \
  NS_IMETHOD GetRange(nsAString & aRange) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRange(aRange); } \
  NS_IMETHOD SetRange(const nsAString & aRange) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetRange(aRange); } \
  NS_IMETHOD GetPad(nsAString & aPad) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPad(aPad); } \
  NS_IMETHOD SetPad(const nsAString & aPad) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetPad(aPad); } \
  NS_IMETHOD GetSpeakAs(nsAString & aSpeakAs) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSpeakAs(aSpeakAs); } \
  NS_IMETHOD SetSpeakAs(const nsAString & aSpeakAs) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSpeakAs(aSpeakAs); } \
  NS_IMETHOD GetFallback(nsAString & aFallback) override { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFallback(aFallback); } \
  NS_IMETHOD SetFallback(const nsAString & aFallback) override { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFallback(aFallback); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsDOMCSSCounterStyleRule : public nsIDOMCSSCounterStyleRule
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIDOMCSSCOUNTERSTYLERULE

  nsDOMCSSCounterStyleRule();

private:
  ~nsDOMCSSCounterStyleRule();

protected:
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS(nsDOMCSSCounterStyleRule, nsIDOMCSSCounterStyleRule)

nsDOMCSSCounterStyleRule::nsDOMCSSCounterStyleRule()
{
  /* member initializers and constructor code */
}

nsDOMCSSCounterStyleRule::~nsDOMCSSCounterStyleRule()
{
  /* destructor code */
}

/* attribute DOMString name; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetName(nsAString & aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetName(const nsAString & aName)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString system; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetSystem(nsAString & aSystem)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetSystem(const nsAString & aSystem)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString symbols; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetSymbols(nsAString & aSymbols)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetSymbols(const nsAString & aSymbols)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString additiveSymbols; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetAdditiveSymbols(nsAString & aAdditiveSymbols)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetAdditiveSymbols(const nsAString & aAdditiveSymbols)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString negative; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetNegative(nsAString & aNegative)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetNegative(const nsAString & aNegative)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString prefix; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetPrefix(nsAString & aPrefix)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetPrefix(const nsAString & aPrefix)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString suffix; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetSuffix(nsAString & aSuffix)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetSuffix(const nsAString & aSuffix)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString range; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetRange(nsAString & aRange)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetRange(const nsAString & aRange)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString pad; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetPad(nsAString & aPad)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetPad(const nsAString & aPad)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString speakAs; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetSpeakAs(nsAString & aSpeakAs)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetSpeakAs(const nsAString & aSpeakAs)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute DOMString fallback; */
NS_IMETHODIMP nsDOMCSSCounterStyleRule::GetFallback(nsAString & aFallback)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMCSSCounterStyleRule::SetFallback(const nsAString & aFallback)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


#endif /* __gen_nsIDOMCSSCounterStyleRule_h__ */