Revision: 10684
Author: acle...@google.com
Date: Tue Oct 4 02:31:04 2011
Log: Add missing Firefox 7 common include/ns*.h
http://code.google.com/p/google-web-toolkit/source/detail?r=10684
Added:
/plugin-sdks/gecko-sdks/gecko-7.0.0/include/nsAlgorithm.h
/plugin-sdks/gecko-sdks/gecko-7.0.0/include/nsCharTraits.h
/plugin-sdks/gecko-sdks/gecko-7.0.0/include/nsIDOMEventTarget.h
=======================================
--- /dev/null
+++ /plugin-sdks/gecko-sdks/gecko-7.0.0/include/nsAlgorithm.h Tue Oct 4
02:31:04 2011
@@ -0,0 +1,114 @@
+/* -*- 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) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Scott Collins <s...@mozilla.org> (original author)
+ *
+ * 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 ***** */
+
+#ifndef nsAlgorithm_h___
+#define nsAlgorithm_h___
+
+#ifndef nsCharTraits_h___
+#include "nsCharTraits.h"
+ // for |nsCharSourceTraits|, |nsCharSinkTraits|
+#endif
+
+#ifndef prtypes_h___
+#include "prtypes.h"
+ // for |PRUint32|...
+#endif
+
+#ifndef nsDebug_h___
+#include "nsDebug.h"
+ // for NS_ASSERTION
+#endif
+
+
+template <class T>
+inline
+T
+NS_ROUNDUP( const T& a, const T& b )
+ {
+ return ((a + (b - 1)) / b) * b;
+ }
+
+template <class T>
+inline
+const T&
+NS_MIN( const T& a, const T& b )
+ {
+ return b < a ? b : a;
+ }
+
+template <class T>
+inline
+const T&
+NS_MAX( const T& a, const T& b )
+ {
+ return a > b ? a : b;
+ }
+
+template <class T>
+inline
+T
+NS_ABS( const T& a )
+ {
+ return a < 0 ? -a : a;
+ }
+
+template <class InputIterator, class T>
+inline
+PRUint32
+NS_COUNT( InputIterator& first, const InputIterator& last, const T& value )
+ {
+ PRUint32 result = 0;
+ for ( ; first != last; ++first )
+ if ( *first == value )
+ ++result;
+ return result;
+ }
+
+template <class InputIterator, class OutputIterator>
+inline
+OutputIterator&
+copy_string( const InputIterator& first, const InputIterator& last,
OutputIterator& result )
+ {
+ typedef nsCharSourceTraits<InputIterator> source_traits;
+ typedef nsCharSinkTraits<OutputIterator> sink_traits;
+
+ sink_traits::write(result, source_traits::read(first),
source_traits::readable_distance(first, last));
+ return result;
+ }
+
+#endif // !defined(nsAlgorithm_h___)
=======================================
--- /dev/null
+++ /plugin-sdks/gecko-sdks/gecko-7.0.0/include/nsCharTraits.h Tue Oct 4
02:31:04 2011
@@ -0,0 +1,858 @@
+/* -*- 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) 2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ * Scott Collins <s...@mozilla.org> (original author)
+ *
+ * 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 ***** */
+
+#ifndef nsCharTraits_h___
+#define nsCharTraits_h___
+
+#include <ctype.h>
+ // for |EOF|, |WEOF|
+
+#define FORCED_CPP_2BYTE_WCHAR_T
+ // disable special optimizations for now through this hack
+
+#if defined(HAVE_CPP_2BYTE_WCHAR_T) && !defined(FORCED_CPP_2BYTE_WCHAR_T)
+#define USE_CPP_WCHAR_FUNCS
+#endif
+
+#ifdef USE_CPP_WCHAR_FUNCS
+#include <wchar.h>
+ // for |wmemset|, et al
+#endif
+
+#include <string.h>
+ // for |memcpy|, et al
+
+#ifndef nscore_h___
+#include "nscore.h"
+ // for |PRUnichar|
+#endif
+
+// This file may be used (through nsUTF8Utils.h) from non-XPCOM code, in
+// particular the standalone software updater. In that case stub out
+// the macros provided by nsDebug.h which are only usable when linking
XPCOM
+
+#ifdef NS_NO_XPCOM
+#define NS_WARNING(msg)
+#define NS_ASSERTION(cond, msg)
+#define NS_ERROR(msg)
+#else
+#ifndef nsDebug_h__
+#include "nsDebug.h"
+ // for NS_ASSERTION
+#endif
+#endif
+
+#ifdef HAVE_CPP_BOOL
+ typedef bool nsCharTraits_bool;
+#else
+ typedef PRBool nsCharTraits_bool;
+#endif
+
+/*
+ * Some macros for converting PRUnichar (UTF-16) to and from Unicode scalar
+ * values.
+ *
+ * Note that UTF-16 represents all Unicode scalar values up to U+10FFFF by
+ * using "surrogate pairs". These consist of a high surrogate, i.e. a code
+ * point in the range U+D800 - U+DBFF, and a low surrogate, i.e. a code
point
+ * in the range U+DC00 - U+DFFF, like this:
+ *
+ * U+D800 U+DC00 = U+10000
+ * U+D800 U+DC01 = U+10001
+ * ...
+ * U+DBFF U+DFFE = U+10FFFE
+ * U+DBFF U+DFFF = U+10FFFF
+ *
+ * These surrogate code points U+D800 - U+DFFF are not themselves valid
Unicode
+ * scalar values and are not well-formed UTF-16 except as high-surrogate /
+ * low-surrogate pairs.
+ */
+
+#define PLANE1_BASE PRUint32(0x00010000)
+// High surrogates are in the range 0xD800 -- OxDBFF
+#define NS_IS_HIGH_SURROGATE(u) ((PRUint32(u) & 0xFFFFFC00) == 0xD800)
+// Low surrogates are in the range 0xDC00 -- 0xDFFF
+#define NS_IS_LOW_SURROGATE(u) ((PRUint32(u) & 0xFFFFFC00) == 0xDC00)
+// Faster than testing NS_IS_HIGH_SURROGATE || NS_IS_LOW_SURROGATE
+#define IS_SURROGATE(u) ((PRUint32(u) & 0xFFFFF800) == 0xD800)
+
+// Everything else is not a surrogate: 0x000 -- 0xD7FF, 0xE000 -- 0xFFFF
+
+// N = (H - 0xD800) * 0x400 + 0x10000 + (L - 0xDC00)
+// I wonder whether we could somehow assert that H is a high surrogate
+// and L is a low surrogate
+#define SURROGATE_TO_UCS4(h, l) (((PRUint32(h) & 0x03FF) << 10) + \
+ (PRUint32(l) & 0x03FF) + PLANE1_BASE)
+
+// Extract surrogates from a UCS4 char
+// Reference: the Unicode standard 4.0, section 3.9
+// Since (c - 0x10000) >> 10 == (c >> 10) - 0x0080 and
+// 0xD7C0 == 0xD800 - 0x0080,
+// ((c - 0x10000) >> 10) + 0xD800 can be simplified to
+#define H_SURROGATE(c) PRUnichar(PRUnichar(PRUint32(c) >> 10) + \
+ PRUnichar(0xD7C0))
+// where it's to be noted that 0xD7C0 is not bitwise-OR'd
+// but added.
+
+// Since 0x10000 & 0x03FF == 0,
+// (c - 0x10000) & 0x03FF == c & 0x03FF so that
+// ((c - 0x10000) & 0x03FF) | 0xDC00 is equivalent to
+#define L_SURROGATE(c) PRUnichar(PRUnichar(PRUint32(c) & PRUint32(0x03FF))
| \
+ PRUnichar(0xDC00))
+
+#define IS_IN_BMP(ucs) (PRUint32(ucs) < PLANE1_BASE)
+#define UCS2_REPLACEMENT_CHAR PRUnichar(0xFFFD)
+
+#define UCS_END PRUint32(0x00110000)
+#define IS_VALID_CHAR(c) ((PRUint32(c) < UCS_END) && !IS_SURROGATE(c))
+#define ENSURE_VALID_CHAR(c) (IS_VALID_CHAR(c) ? (c) :
UCS2_REPLACEMENT_CHAR)
+
+template <class CharT> struct nsCharTraits {};
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharTraits<PRUnichar>
+ {
+ typedef PRUnichar char_type;
+ typedef PRUint16 unsigned_char_type;
+ typedef char incompatible_char_type;
+
+ NS_COM static char_type *sEmptyBuffer;
+
+ static
+ void
+ assign( char_type& lhs, char_type rhs )
+ {
+ lhs = rhs;
+ }
+
+
+ // integer representation of characters:
+
+#ifdef USE_CPP_WCHAR_FUNCS
+ typedef wint_t int_type;
+#else
+ typedef int int_type;
+#endif
+
+ static
+ char_type
+ to_char_type( int_type c )
+ {
+ return char_type(c);
+ }
+
+ static
+ int_type
+ to_int_type( char_type c )
+ {
+ return int_type( static_cast<unsigned_char_type>(c) );
+ }
+
+ static
+ nsCharTraits_bool
+ eq_int_type( int_type lhs, int_type rhs )
+ {
+ return lhs == rhs;
+ }
+
+
+ // |char_type| comparisons:
+
+ static
+ nsCharTraits_bool
+ eq( char_type lhs, char_type rhs )
+ {
+ return lhs == rhs;
+ }
+
+ static
+ nsCharTraits_bool
+ lt( char_type lhs, char_type rhs )
+ {
+ return lhs < rhs;
+ }
+
+
+ // operations on s[n] arrays:
+
+ static
+ char_type*
+ move( char_type* s1, const char_type* s2, size_t n )
+ {
+ return static_cast<char_type*>(memmove(s1, s2, n *
sizeof(char_type)));
+ }
+
+ static
+ char_type*
+ copy( char_type* s1, const char_type* s2, size_t n )
+ {
+ return static_cast<char_type*>(memcpy(s1, s2, n *
sizeof(char_type)));
+ }
+
+ static
+ char_type*
+ copyASCII( char_type* s1, const char* s2, size_t n )
+ {
+ for (char_type* s = s1; n--; ++s, ++s2) {
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ *s = *s2;
+ }
+ return s1;
+ }
+
+ static
+ char_type*
+ assign( char_type* s, size_t n, char_type c )
+ {
+#ifdef USE_CPP_WCHAR_FUNCS
+ return static_cast<char_type*>(wmemset(s, to_int_type(c), n));
+#else
+ char_type* result = s;
+ while ( n-- )
+ assign(*s++, c);
+ return result;
+#endif
+ }
+
+ static
+ int
+ compare( const char_type* s1, const char_type* s2, size_t n )
+ {
+#ifdef USE_CPP_WCHAR_FUNCS
+ return wmemcmp(s1, s2, n);
+#else
+ for ( ; n--; ++s1, ++s2 )
+ {
+ if ( !eq(*s1, *s2) )
+ return to_int_type(*s1) - to_int_type(*s2);
+ }
+
+ return 0;
+#endif
+ }
+
+ static
+ int
+ compareASCII( const char_type* s1, const char* s2, size_t n )
+ {
+ for ( ; n--; ++s1, ++s2 )
+ {
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ if ( !eq_int_type(to_int_type(*s1), to_int_type(*s2)) )
+ return to_int_type(*s1) - to_int_type(*s2);
+ }
+
+ return 0;
+ }
+
+ // this version assumes that s2 is null-terminated and s1 has length n.
+ // if s1 is shorter than s2 then we return -1; if s1 is longer than s2,
+ // we return 1.
+ static
+ int
+ compareASCIINullTerminated( const char_type* s1, size_t n, const char*
s2 )
+ {
+ for ( ; n--; ++s1, ++s2 )
+ {
+ if ( !*s2 )
+ return 1;
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ if ( !eq_int_type(to_int_type(*s1), to_int_type(*s2)) )
+ return to_int_type(*s1) - to_int_type(*s2);
+ }
+
+ if ( *s2 )
+ return -1;
+
+ return 0;
+ }
+
+ /**
+ * Convert c to its lower-case form, but only if the lower-case form is
+ * ASCII. Otherwise leave it alone.
+ *
+ * There are only two non-ASCII Unicode characters whose lowercase
+ * equivalents are ASCII: KELVIN SIGN and LATIN CAPITAL LETTER I WITH
+ * DOT ABOVE. So it's a simple matter to handle those explicitly.
+ */
+ static
+ char_type
+ ASCIIToLower( char_type c )
+ {
+ if (c < 0x100)
+ {
+ if (c >= 'A' && c <= 'Z')
+ return char_type(c + ('a' - 'A'));
+
+ return c;
+ }
+ else
+ {
+ if (c == 0x212A) // KELVIN SIGN
+ return 'k';
+ if (c == 0x0130) // LATIN CAPITAL LETTER I WITH DOT ABOVE
+ return 'i';
+ return c;
+ }
+ }
+
+ static
+ int
+ compareLowerCaseToASCII( const char_type* s1, const char* s2, size_t n
)
+ {
+ for ( ; n--; ++s1, ++s2 )
+ {
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ NS_ASSERTION(!(*s2 >= 'A' && *s2 <= 'Z'),
+ "Unexpected uppercase character");
+ char_type lower_s1 = ASCIIToLower(*s1);
+ if ( lower_s1 != to_char_type(*s2) )
+ return to_int_type(lower_s1) - to_int_type(*s2);
+ }
+
+ return 0;
+ }
+
+ // this version assumes that s2 is null-terminated and s1 has length n.
+ // if s1 is shorter than s2 then we return -1; if s1 is longer than s2,
+ // we return 1.
+ static
+ int
+ compareLowerCaseToASCIINullTerminated( const char_type* s1, size_t n,
const char* s2 )
+ {
+ for ( ; n--; ++s1, ++s2 )
+ {
+ if ( !*s2 )
+ return 1;
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ NS_ASSERTION(!(*s2 >= 'A' && *s2 <= 'Z'),
+ "Unexpected uppercase character");
+ char_type lower_s1 = ASCIIToLower(*s1);
+ if ( lower_s1 != to_char_type(*s2) )
+ return to_int_type(lower_s1) - to_int_type(*s2);
+ }
+
+ if ( *s2 )
+ return -1;
+
+ return 0;
+ }
+
+ static
+ size_t
+ length( const char_type* s )
+ {
+#ifdef USE_CPP_WCHAR_FUNCS
+ return wcslen(s);
+#else
+ size_t result = 0;
+ while ( !eq(*s++, char_type(0)) )
+ ++result;
+ return result;
+#endif
+ }
+
+ static
+ const char_type*
+ find( const char_type* s, size_t n, char_type c )
+ {
+#ifdef USE_CPP_WCHAR_FUNCS
+ return reinterpret_cast<const char_type*>(wmemchr(s,
to_int_type(c), n));
+#else
+ while ( n-- )
+ {
+ if ( eq(*s, c) )
+ return s;
+ ++s;
+ }
+
+ return 0;
+#endif
+ }
+
+#if 0
+ // I/O related:
+
+ typedef streamoff off_type;
+ typedef streampos pos_type;
+ typedef mbstate_t state_type;
+
+ static
+ int_type
+ eof()
+ {
+#ifdef USE_CPP_WCHAR_FUNCS
+ return WEOF;
+#else
+ return EOF;
+#endif
+ }
+
+ static
+ int_type
+ not_eof( int_type c )
+ {
+ return eq_int_type(c, eof()) ? ~eof() : c;
+ }
+
+ // static state_type get_state( pos_type );
+#endif
+ };
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharTraits<char>
+ {
+ typedef char char_type;
+ typedef unsigned char unsigned_char_type;
+ typedef PRUnichar incompatible_char_type;
+
+ NS_COM static char_type *sEmptyBuffer;
+
+ static
+ void
+ assign( char_type& lhs, char_type rhs )
+ {
+ lhs = rhs;
+ }
+
+
+ // integer representation of characters:
+
+ typedef int int_type;
+
+ static
+ char_type
+ to_char_type( int_type c )
+ {
+ return char_type(c);
+ }
+
+ static
+ int_type
+ to_int_type( char_type c )
+ {
+ return int_type( static_cast<unsigned_char_type>(c) );
+ }
+
+ static
+ nsCharTraits_bool
+ eq_int_type( int_type lhs, int_type rhs )
+ {
+ return lhs == rhs;
+ }
+
+
+ // |char_type| comparisons:
+
+ static
+ nsCharTraits_bool
+ eq( char_type lhs, char_type rhs )
+ {
+ return lhs == rhs;
+ }
+
+ static
+ nsCharTraits_bool
+ lt( char_type lhs, char_type rhs )
+ {
+ return lhs < rhs;
+ }
+
+
+ // operations on s[n] arrays:
+
+ static
+ char_type*
+ move( char_type* s1, const char_type* s2, size_t n )
+ {
+ return static_cast<char_type*>(memmove(s1, s2, n *
sizeof(char_type)));
+ }
+
+ static
+ char_type*
+ copy( char_type* s1, const char_type* s2, size_t n )
+ {
+ return static_cast<char_type*>(memcpy(s1, s2, n *
sizeof(char_type)));
+ }
+
+ static
+ char_type*
+ copyASCII( char_type* s1, const char* s2, size_t n )
+ {
+ return copy(s1, s2, n);
+ }
+
+ static
+ char_type*
+ assign( char_type* s, size_t n, char_type c )
+ {
+ return static_cast<char_type*>(memset(s, to_int_type(c), n));
+ }
+
+ static
+ int
+ compare( const char_type* s1, const char_type* s2, size_t n )
+ {
+ return memcmp(s1, s2, n);
+ }
+
+ static
+ int
+ compareASCII( const char_type* s1, const char* s2, size_t n )
+ {
+#ifdef DEBUG
+ for (size_t i = 0; i < n; ++i)
+ {
+ NS_ASSERTION(!(s2[i] & ~0x7F), "Unexpected non-ASCII
character");
+ }
+#endif
+ return compare(s1, s2, n);
+ }
+
+ // this version assumes that s2 is null-terminated and s1 has length n.
+ // if s1 is shorter than s2 then we return -1; if s1 is longer than s2,
+ // we return 1.
+ static
+ int
+ compareASCIINullTerminated( const char_type* s1, size_t n, const char*
s2 )
+ {
+ // can't use strcmp here because we don't want to stop when s1
+ // contains a null
+ for ( ; n--; ++s1, ++s2 )
+ {
+ if ( !*s2 )
+ return 1;
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ if ( *s1 != *s2 )
+ return to_int_type(*s1) - to_int_type(*s2);
+ }
+
+ if ( *s2 )
+ return -1;
+
+ return 0;
+ }
+
+ /**
+ * Convert c to its lower-case form, but only if c is ASCII.
+ */
+ static
+ char_type
+ ASCIIToLower( char_type c )
+ {
+ if (c >= 'A' && c <= 'Z')
+ return char_type(c + ('a' - 'A'));
+
+ return c;
+ }
+
+ static
+ int
+ compareLowerCaseToASCII( const char_type* s1, const char* s2, size_t n
)
+ {
+ for ( ; n--; ++s1, ++s2 )
+ {
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ NS_ASSERTION(!(*s2 >= 'A' && *s2 <= 'Z'),
+ "Unexpected uppercase character");
+ char_type lower_s1 = ASCIIToLower(*s1);
+ if ( lower_s1 != *s2 )
+ return to_int_type(lower_s1) - to_int_type(*s2);
+ }
+ return 0;
+ }
+
+ // this version assumes that s2 is null-terminated and s1 has length n.
+ // if s1 is shorter than s2 then we return -1; if s1 is longer than s2,
+ // we return 1.
+ static
+ int
+ compareLowerCaseToASCIINullTerminated( const char_type* s1, size_t n,
const char* s2 )
+ {
+ for ( ; n--; ++s1, ++s2 )
+ {
+ if ( !*s2 )
+ return 1;
+ NS_ASSERTION(!(*s2 & ~0x7F), "Unexpected non-ASCII character");
+ NS_ASSERTION(!(*s2 >= 'A' && *s2 <= 'Z'),
+ "Unexpected uppercase character");
+ char_type lower_s1 = ASCIIToLower(*s1);
+ if ( lower_s1 != *s2 )
+ return to_int_type(lower_s1) - to_int_type(*s2);
+ }
+
+ if ( *s2 )
+ return -1;
+
+ return 0;
+ }
+
+ static
+ size_t
+ length( const char_type* s )
+ {
+ return strlen(s);
+ }
+
+ static
+ const char_type*
+ find( const char_type* s, size_t n, char_type c )
+ {
+ return reinterpret_cast<const char_type*>(memchr(s,
to_int_type(c), n));
+ }
+
+#if 0
+ // I/O related:
+
+ typedef streamoff off_type;
+ typedef streampos pos_type;
+ typedef mbstate_t state_type;
+
+ static
+ int_type
+ eof()
+ {
+ return EOF;
+ }
+
+ static
+ int_type
+ not_eof( int_type c )
+ {
+ return eq_int_type(c, eof()) ? ~eof() : c;
+ }
+
+ // static state_type get_state( pos_type );
+#endif
+ };
+
+template <class InputIterator>
+struct nsCharSourceTraits
+ {
+ typedef typename InputIterator::difference_type difference_type;
+
+ static
+ PRUint32
+ readable_distance( const InputIterator& first, const InputIterator&
last )
+ {
+ // assumes single fragment
+ return PRUint32(last.get() - first.get());
+ }
+
+ static
+ const typename InputIterator::value_type*
+ read( const InputIterator& iter )
+ {
+ return iter.get();
+ }
+
+ static
+ void
+ advance( InputIterator& s, difference_type n )
+ {
+ s.advance(n);
+ }
+ };
+
+#ifdef HAVE_CPP_PARTIAL_SPECIALIZATION
+
+template <class CharT>
+struct nsCharSourceTraits<CharT*>
+ {
+ typedef ptrdiff_t difference_type;
+
+ static
+ PRUint32
+ readable_distance( CharT* s )
+ {
+ return PRUint32(nsCharTraits<CharT>::length(s));
+// return numeric_limits<PRUint32>::max();
+ }
+
+ static
+ PRUint32
+ readable_distance( CharT* first, CharT* last )
+ {
+ return PRUint32(last-first);
+ }
+
+ static
+ const CharT*
+ read( CharT* s )
+ {
+ return s;
+ }
+
+ static
+ void
+ advance( CharT*& s, difference_type n )
+ {
+ s += n;
+ }
+ };
+
+#else
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSourceTraits<const char*>
+ {
+ typedef ptrdiff_t difference_type;
+
+ static
+ PRUint32
+ readable_distance( const char* s )
+ {
+ return PRUint32(nsCharTraits<char>::length(s));
+// return numeric_limits<PRUint32>::max();
+ }
+
+ static
+ PRUint32
+ readable_distance( const char* first, const char* last )
+ {
+ return PRUint32(last-first);
+ }
+
+ static
+ const char*
+ read( const char* s )
+ {
+ return s;
+ }
+
+ static
+ void
+ advance( const char*& s, difference_type n )
+ {
+ s += n;
+ }
+ };
+
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSourceTraits<const PRUnichar*>
+ {
+ typedef ptrdiff_t difference_type;
+
+ static
+ PRUint32
+ readable_distance( const PRUnichar* s )
+ {
+ return PRUint32(nsCharTraits<PRUnichar>::length(s));
+// return numeric_limits<PRUint32>::max();
+ }
+
+ static
+ PRUint32
+ readable_distance( const PRUnichar* first, const PRUnichar* last )
+ {
+ return PRUint32(last-first);
+ }
+
+ static
+ const PRUnichar*
+ read( const PRUnichar* s )
+ {
+ return s;
+ }
+
+ static
+ void
+ advance( const PRUnichar*& s, difference_type n )
+ {
+ s += n;
+ }
+ };
+
+#endif
+
+
+template <class OutputIterator>
+struct nsCharSinkTraits
+ {
+ static
+ void
+ write( OutputIterator& iter, const typename
OutputIterator::value_type* s, PRUint32 n )
+ {
+ iter.write(s, n);
+ }
+ };
+
+#ifdef HAVE_CPP_PARTIAL_SPECIALIZATION
+
+template <class CharT>
+struct nsCharSinkTraits<CharT*>
+ {
+ static
+ void
+ write( CharT*& iter, const CharT* s, PRUint32 n )
+ {
+ nsCharTraits<CharT>::move(iter, s, n);
+ iter += n;
+ }
+ };
+
+#else
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSinkTraits<char*>
+ {
+ static
+ void
+ write( char*& iter, const char* s, PRUint32 n )
+ {
+ nsCharTraits<char>::move(iter, s, n);
+ iter += n;
+ }
+ };
+
+NS_SPECIALIZE_TEMPLATE
+struct nsCharSinkTraits<PRUnichar*>
+ {
+ static
+ void
+ write( PRUnichar*& iter, const PRUnichar* s, PRUint32 n )
+ {
+ nsCharTraits<PRUnichar>::move(iter, s, n);
+ iter += n;
+ }
+ };
+
+#endif
+
+#endif // !defined(nsCharTraits_h___)
=======================================
--- /dev/null
+++ /plugin-sdks/gecko-sdks/gecko-7.0.0/include/nsIDOMEventTarget.h Tue
Oct 4 02:31:04 2011
@@ -0,0 +1,424 @@
+/*
+ * DO NOT EDIT. THIS FILE IS GENERATED FROM
e:/builds/moz2_slave/rel-m-rel-xr-w32-bld/build/dom/interfaces/events/nsIDOMEventTarget.idl
+ */
+
+#ifndef __gen_nsIDOMEventTarget_h__
+#define __gen_nsIDOMEventTarget_h__
+
+
+#ifndef __gen_domstubs_h__
+#include "domstubs.h"
+#endif
+
+/* For IDL files that don't want to include root IDL files. */
+#ifndef NS_NO_VTABLE
+#define NS_NO_VTABLE
+#endif
+#include "nsEvent.h"
+class nsPresContext;
+class nsEventChainPreVisitor;
+class nsEventChainPostVisitor;
+struct JSContext;
+class nsEventListenerManager;
+class nsIScriptContext; /* forward declaration */
+
+class nsIDOMEventListener; /* forward declaration */
+
+class nsIDOMEvent; /* forward declaration */
+
+
+/* starting interface: nsIDOMEventTarget */
+#define NS_IDOMEVENTTARGET_IID_STR "1797d5a4-b12a-428d-9eef-a0e13839728c"
+
+#define NS_IDOMEVENTTARGET_IID \
+ {0x1797d5a4, 0xb12a, 0x428d, \
+ { 0x9e, 0xef, 0xa0, 0xe1, 0x38, 0x39, 0x72, 0x8c }}
+
+class NS_SCRIPTABLE nsIDOMEventTarget : public nsISupports {
+ public:
+
+ NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMEVENTTARGET_IID)
+
+ /**
+ * This method allows the registration of event listeners on the event
target.
+ * If an EventListener is added to an EventTarget while it is processing
an
+ * event, it will not be triggered by the current actions but may be
+ * triggered during a later stage of event flow, such as the bubbling
phase.
+ *
+ * If multiple identical EventListeners are registered on the same
+ * EventTarget with the same parameters the duplicate instances are
+ * discarded. They do not cause the EventListener to be called twice
+ * and since they are discarded they do not need to be removed with the
+ * removeEventListener method.
+ *
+ * @param type The event type for which the user is registering
+ * @param listener The listener parameter takes an interface
+ * implemented by the user which contains the methods
+ * to be called when the event occurs.
+ * @param useCapture If true, useCapture indicates that the user
+ * wishes to initiate capture. After initiating
+ * capture, all events of the specified type will be
+ * dispatched to the registered EventListener before
+ * being dispatched to any EventTargets beneath them
+ * in the tree. Events which are bubbling upward
+ * through the tree will not trigger an
+ * EventListener designated to use capture.
+ * @param wantsUntrusted If false, the listener will not receive any
+ * untrusted events (see above), if true, the
+ * listener will receive events whether or not
+ * they're trusted
+ */
+ /* [optional_argc] void addEventListener (in DOMString type, in
nsIDOMEventListener listener, [optional] in boolean useCapture, [optional]
in boolean wantsUntrusted); */
+ NS_SCRIPTABLE NS_IMETHOD AddEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture, PRBool wantsUntrusted,
PRUint8 _argc) = 0;
+
+ // non-virtual so it won't affect the vtable
+ nsresult AddEventListener(const nsAString& aType,
+ nsIDOMEventListener* aListener,
+ PRBool aUseCapture)
+ {
+ return AddEventListener(aType, aListener, aUseCapture, PR_FALSE, 1);
+ }
+ // non-virtual so it won't affect the vtable
+ nsresult AddEventListener(const nsAString& aType,
+ nsIDOMEventListener* aListener,
+ PRBool aUseCapture,
+ PRBool aWantsUntrusted)
+ {
+ return AddEventListener(aType, aListener, aUseCapture,
aWantsUntrusted, 2);
+ }
+ /**
+ * This method allows the removal of event listeners from the event
+ * target. If an EventListener is removed from an EventTarget while it
+ * is processing an event, it will not be triggered by the current
actions.
+ * EventListeners can never be invoked after being removed.
+ * Calling removeEventListener with arguments which do not identify any
+ * currently registered EventListener on the EventTarget has no effect.
+ *
+ * @param type Specifies the event type of the EventListener being
+ * removed.
+ * @param listener The EventListener parameter indicates the
+ * EventListener to be removed.
+ * @param useCapture Specifies whether the EventListener being
+ * removed was registered as a capturing listener or
+ * not. If a listener was registered twice, one with
+ * capture and one without, each must be removed
+ * separately. Removal of a capturing listener does
+ * not affect a non-capturing version of the same
+ * listener, and vice versa.
+ */
+ /* void removeEventListener (in DOMString type, in nsIDOMEventListener
listener, [optional] in boolean useCapture); */
+ NS_SCRIPTABLE NS_IMETHOD RemoveEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture) = 0;
+
+ /**
+ * This method allows the dispatch of events into the implementations
+ * event model. Events dispatched in this manner will have the same
+ * capturing and bubbling behavior as events dispatched directly by the
+ * implementation. The target of the event is the EventTarget on which
+ * dispatchEvent is called.
+ *
+ * @param evt Specifies the event type, behavior, and contextual
+ * information to be used in processing the event.
+ * @return Indicates whether any of the listeners which handled the
+ * event called preventDefault. If preventDefault was called
+ * the value is false, else the value is true.
+ * @throws UNSPECIFIED_EVENT_TYPE_ERR: Raised if the Event's type was
+ * not specified by initializing the event before
+ * dispatchEvent was called. Specification of the Event's
+ * type as null or an empty string will also trigger this
+ * exception.
+ */
+ /* boolean dispatchEvent (in nsIDOMEvent evt) raises (DOMException); */
+ NS_SCRIPTABLE NS_IMETHOD DispatchEvent(nsIDOMEvent *evt, PRBool *_retval
NS_OUTPARAM) = 0;
+
+ /**
+ * Returns the nsPIDOMEventTarget object which should be used as the
target
+ * of DOMEvents.
+ * Usually |this| is returned, but for example global object returns
+ * the outer object.
+ */
+ /* [nostdcall, notxpcom] nsIDOMEventTarget GetTargetForDOMEvent (); */
+ virtual nsIDOMEventTarget * GetTargetForDOMEvent(void) = 0;
+
+ /**
+ * Returns the nsPIDOMEventTarget object which should be used as the
target
+ * of the event and when constructing event target chain.
+ * Usually |this| is returned, but for example global object returns
+ * the inner object.
+ */
+ /* [nostdcall, notxpcom] nsIDOMEventTarget GetTargetForEventTargetChain
(); */
+ virtual nsIDOMEventTarget * GetTargetForEventTargetChain(void) = 0;
+
+ /**
+ * Called before the capture phase of the event flow.
+ * This is used to create the event target chain and implementations
+ * should set the necessary members of nsEventChainPreVisitor.
+ * At least aVisitor.mCanHandle must be set,
+ * usually also aVisitor.mParentTarget if mCanHandle is PR_TRUE.
+ * First one tells that this object can handle the aVisitor.mEvent event
and
+ * the latter one is the possible parent object for the event target
chain.
+ * @see nsEventDispatcher.h for more documentation about aVisitor.
+ *
+ * @param aVisitor the visitor object which is used to create the
+ * event target chain for event dispatching.
+ *
+ * @note Only nsEventDispatcher should call this method.
+ */
+ /* [noscript, nostdcall] void PreHandleEvent (in
nsEventChainPreVisitorRef aVisitor); */
+ virtual nsresult PreHandleEvent(nsEventChainPreVisitor & aVisitor) = 0;
+
+ /**
+ * If nsEventChainPreVisitor.mWantsWillHandleEvent is set PR_TRUE,
+ * called just before possible event handlers on this object will be
called.
+ */
+ /* [noscript, nostdcall] void WillHandleEvent (in
nsEventChainPostVisitorRef aVisitor); */
+ virtual nsresult WillHandleEvent(nsEventChainPostVisitor & aVisitor) = 0;
+
+ /**
+ * Called after the bubble phase of the system event group.
+ * The default handling of the event should happen here.
+ * @param aVisitor the visitor object which is used during post handling.
+ *
+ * @see nsEventDispatcher.h for documentation about aVisitor.
+ * @note Only nsEventDispatcher should call this method.
+ */
+ /* [noscript, nostdcall] void PostHandleEvent (in
nsEventChainPostVisitorRef aVisitor); */
+ virtual nsresult PostHandleEvent(nsEventChainPostVisitor & aVisitor) = 0;
+
+ /**
+ * Dispatch an event.
+ * @param aEvent the event that is being dispatched.
+ * @param aDOMEvent the event that is being dispatched, use if you want
to
+ * dispatch nsIDOMEvent, not only nsEvent.
+ * @param aPresContext the current presentation context, can be nsnull.
+ * @param aEventStatus the status returned from the function, can be
nsnull.
+ *
+ * @note If both aEvent and aDOMEvent are used, aEvent must be the
internal
+ * event of the aDOMEvent.
+ *
+ * If aDOMEvent is not nsnull (in which case aEvent can be nsnull) it is
used
+ * for dispatching, otherwise aEvent is used.
+ *
+ * @deprecated This method is here just until all the callers outside
Gecko
+ * have been converted to use
nsIDOMEventTarget::dispatchEvent.
+ */
+ /* [noscript, nostdcall] void DispatchDOMEvent (in nsEventPtr aEvent, in
nsIDOMEvent aDOMEvent, in nsPresContextPtr aPresContext, in
nsEventStatusPtr aEventStatus); */
+ virtual nsresult DispatchDOMEvent(nsEvent *aEvent, nsIDOMEvent
*aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) = 0;
+
+ /**
+ * Get the event listener manager, the guy you talk to to register for
events
+ * on this node.
+ * @param aMayCreate If PR_FALSE, returns a listener manager only if
+ * one already exists.
+ */
+ /* [nostdcall, notxpcom] nsEventListenerManagerPtr GetListenerManager
(in boolean aMayCreate); */
+ virtual nsEventListenerManager * GetListenerManager(PRBool aMayCreate) =
0;
+
+ /**
+ * Add an event listener for nsIID.
+ */
+ /* [noscript, nostdcall] void AddEventListenerByIID (in
nsIDOMEventListener aListener, in nsIIDRef aIID); */
+ virtual nsresult AddEventListenerByIID(nsIDOMEventListener *aListener,
const nsIID & aIID) = 0;
+
+ /**
+ * Remove event listener for nsIID.
+ */
+ /* [noscript, nostdcall] void RemoveEventListenerByIID (in
nsIDOMEventListener aListener, in nsIIDRef aIID); */
+ virtual nsresult RemoveEventListenerByIID(nsIDOMEventListener
*aListener, const nsIID & aIID) = 0;
+
+ /**
+ * Get the script context in which the event handlers should be run.
+ * May return null.
+ * @note Caller *must* check the value of aRv.
+ */
+ /* [nostdcall, notxpcom] nsIScriptContext GetContextForEventHandlers
(out nsresult aRv); */
+ virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv
NS_OUTPARAM) = 0;
+
+ /**
+ * If the method above returns null, but a success code, this method
+ * is called.
+ */
+ /* [nostdcall, notxpcom] JSContextPtr GetJSContextForEventHandlers (); */
+ virtual JSContext * GetJSContextForEventHandlers(void) = 0;
+
+};
+
+ NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMEventTarget, NS_IDOMEVENTTARGET_IID)
+
+/* Use this macro when declaring classes that implement this interface. */
+#define NS_DECL_NSIDOMEVENTTARGET \
+ NS_SCRIPTABLE NS_IMETHOD AddEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture, PRBool wantsUntrusted,
PRUint8 _argc); \
+ NS_SCRIPTABLE NS_IMETHOD RemoveEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture); \
+ NS_SCRIPTABLE NS_IMETHOD DispatchEvent(nsIDOMEvent *evt, PRBool *_retval
NS_OUTPARAM); \
+ virtual nsIDOMEventTarget * GetTargetForDOMEvent(void); \
+ virtual nsIDOMEventTarget * GetTargetForEventTargetChain(void); \
+ virtual nsresult PreHandleEvent(nsEventChainPreVisitor & aVisitor); \
+ virtual nsresult WillHandleEvent(nsEventChainPostVisitor & aVisitor); \
+ virtual nsresult PostHandleEvent(nsEventChainPostVisitor & aVisitor); \
+ virtual nsresult DispatchDOMEvent(nsEvent *aEvent, nsIDOMEvent
*aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus); \
+ virtual nsEventListenerManager * GetListenerManager(PRBool aMayCreate); \
+ virtual nsresult AddEventListenerByIID(nsIDOMEventListener *aListener,
const nsIID & aIID); \
+ virtual nsresult RemoveEventListenerByIID(nsIDOMEventListener
*aListener, const nsIID & aIID); \
+ virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv
NS_OUTPARAM); \
+ virtual JSContext * GetJSContextForEventHandlers(void);
+
+/* Use this macro to declare functions that forward the behavior of this
interface to another object. */
+#define NS_FORWARD_NSIDOMEVENTTARGET(_to) \
+ NS_SCRIPTABLE NS_IMETHOD AddEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture, PRBool wantsUntrusted,
PRUint8 _argc) { return _to AddEventListener(type, listener, useCapture,
wantsUntrusted, _argc); } \
+ NS_SCRIPTABLE NS_IMETHOD RemoveEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture) { return _to
RemoveEventListener(type, listener, useCapture); } \
+ NS_SCRIPTABLE NS_IMETHOD DispatchEvent(nsIDOMEvent *evt, PRBool *_retval
NS_OUTPARAM) { return _to DispatchEvent(evt, _retval); } \
+ virtual nsIDOMEventTarget * GetTargetForDOMEvent(void) { return _to
GetTargetForDOMEvent(); } \
+ virtual nsIDOMEventTarget * GetTargetForEventTargetChain(void) { return
_to GetTargetForEventTargetChain(); } \
+ virtual nsresult PreHandleEvent(nsEventChainPreVisitor & aVisitor) {
return _to PreHandleEvent(aVisitor); } \
+ virtual nsresult WillHandleEvent(nsEventChainPostVisitor & aVisitor) {
return _to WillHandleEvent(aVisitor); } \
+ virtual nsresult PostHandleEvent(nsEventChainPostVisitor & aVisitor) {
return _to PostHandleEvent(aVisitor); } \
+ virtual nsresult DispatchDOMEvent(nsEvent *aEvent, nsIDOMEvent
*aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) {
return _to DispatchDOMEvent(aEvent, aDOMEvent, aPresContext, aEventStatus);
} \
+ virtual nsEventListenerManager * GetListenerManager(PRBool aMayCreate) {
return _to GetListenerManager(aMayCreate); } \
+ virtual nsresult AddEventListenerByIID(nsIDOMEventListener *aListener,
const nsIID & aIID) { return _to AddEventListenerByIID(aListener, aIID); } \
+ virtual nsresult RemoveEventListenerByIID(nsIDOMEventListener
*aListener, const nsIID & aIID) { return _to
RemoveEventListenerByIID(aListener, aIID); } \
+ virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv
NS_OUTPARAM) { return _to GetContextForEventHandlers(aRv); } \
+ virtual JSContext * GetJSContextForEventHandlers(void) { return _to
GetJSContextForEventHandlers(); }
+
+/* Use this macro to declare functions that forward the behavior of this
interface to another object in a safe way. */
+#define NS_FORWARD_SAFE_NSIDOMEVENTTARGET(_to) \
+ NS_SCRIPTABLE NS_IMETHOD AddEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture, PRBool wantsUntrusted,
PRUint8 _argc) { return !_to ? NS_ERROR_NULL_POINTER :
_to->AddEventListener(type, listener, useCapture, wantsUntrusted, _argc); }
\
+ NS_SCRIPTABLE NS_IMETHOD RemoveEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture) { return !_to ?
NS_ERROR_NULL_POINTER : _to->RemoveEventListener(type, listener,
useCapture); } \
+ NS_SCRIPTABLE NS_IMETHOD DispatchEvent(nsIDOMEvent *evt, PRBool *_retval
NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER :
_to->DispatchEvent(evt, _retval); } \
+ virtual nsIDOMEventTarget * GetTargetForDOMEvent(void) { return !_to ?
NS_ERROR_NULL_POINTER : _to->GetTargetForDOMEvent(); } \
+ virtual nsIDOMEventTarget * GetTargetForEventTargetChain(void) {
return !_to ? NS_ERROR_NULL_POINTER : _to->GetTargetForEventTargetChain();
} \
+ virtual nsresult PreHandleEvent(nsEventChainPreVisitor & aVisitor) {
return !_to ? NS_ERROR_NULL_POINTER : _to->PreHandleEvent(aVisitor); } \
+ virtual nsresult WillHandleEvent(nsEventChainPostVisitor & aVisitor) {
return !_to ? NS_ERROR_NULL_POINTER : _to->WillHandleEvent(aVisitor); } \
+ virtual nsresult PostHandleEvent(nsEventChainPostVisitor & aVisitor) {
return !_to ? NS_ERROR_NULL_POINTER : _to->PostHandleEvent(aVisitor); } \
+ virtual nsresult DispatchDOMEvent(nsEvent *aEvent, nsIDOMEvent
*aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus) {
return !_to ? NS_ERROR_NULL_POINTER : _to->DispatchDOMEvent(aEvent,
aDOMEvent, aPresContext, aEventStatus); } \
+ virtual nsEventListenerManager * GetListenerManager(PRBool aMayCreate) {
return !_to ? NS_ERROR_NULL_POINTER : _to->GetListenerManager(aMayCreate);
} \
+ virtual nsresult AddEventListenerByIID(nsIDOMEventListener *aListener,
const nsIID & aIID) { return !_to ? NS_ERROR_NULL_POINTER :
_to->AddEventListenerByIID(aListener, aIID); } \
+ virtual nsresult RemoveEventListenerByIID(nsIDOMEventListener
*aListener, const nsIID & aIID) { return !_to ? NS_ERROR_NULL_POINTER :
_to->RemoveEventListenerByIID(aListener, aIID); } \
+ virtual nsIScriptContext * GetContextForEventHandlers(nsresult *aRv
NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER :
_to->GetContextForEventHandlers(aRv); } \
+ virtual JSContext * GetJSContextForEventHandlers(void) { return !_to ?
NS_ERROR_NULL_POINTER : _to->GetJSContextForEventHandlers(); }
+
+#if 0
+/* Use the code below as a template for the implementation class for this
interface. */
+
+/* Header file */
+class nsDOMEventTarget : public nsIDOMEventTarget
+{
+public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIDOMEVENTTARGET
+
+ nsDOMEventTarget();
+
+private:
+ ~nsDOMEventTarget();
+
+protected:
+ /* additional members */
+};
+
+/* Implementation file */
+NS_IMPL_ISUPPORTS1(nsDOMEventTarget, nsIDOMEventTarget)
+
+nsDOMEventTarget::nsDOMEventTarget()
+{
+ /* member initializers and constructor code */
+}
+
+nsDOMEventTarget::~nsDOMEventTarget()
+{
+ /* destructor code */
+}
+
+/* [optional_argc] void addEventListener (in DOMString type, in
nsIDOMEventListener listener, [optional] in boolean useCapture, [optional]
in boolean wantsUntrusted); */
+NS_IMETHODIMP nsDOMEventTarget::AddEventListener(const nsAString & type,
nsIDOMEventListener *listener, PRBool useCapture, PRBool wantsUntrusted,
PRUint8 _argc)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* void removeEventListener (in DOMString type, in nsIDOMEventListener
listener, [optional] in boolean useCapture); */
+NS_IMETHODIMP nsDOMEventTarget::RemoveEventListener(const nsAString &
type, nsIDOMEventListener *listener, PRBool useCapture)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* boolean dispatchEvent (in nsIDOMEvent evt) raises (DOMException); */
+NS_IMETHODIMP nsDOMEventTarget::DispatchEvent(nsIDOMEvent *evt, PRBool
*_retval NS_OUTPARAM)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [nostdcall, notxpcom] nsIDOMEventTarget GetTargetForDOMEvent (); */
+nsIDOMEventTarget * nsDOMEventTarget::GetTargetForDOMEvent()
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [nostdcall, notxpcom] nsIDOMEventTarget GetTargetForEventTargetChain
(); */
+nsIDOMEventTarget * nsDOMEventTarget::GetTargetForEventTargetChain()
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript, nostdcall] void PreHandleEvent (in nsEventChainPreVisitorRef
aVisitor); */
+nsresult nsDOMEventTarget::PreHandleEvent(nsEventChainPreVisitor &
aVisitor)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript, nostdcall] void WillHandleEvent (in
nsEventChainPostVisitorRef aVisitor); */
+nsresult nsDOMEventTarget::WillHandleEvent(nsEventChainPostVisitor &
aVisitor)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript, nostdcall] void PostHandleEvent (in
nsEventChainPostVisitorRef aVisitor); */
+nsresult nsDOMEventTarget::PostHandleEvent(nsEventChainPostVisitor &
aVisitor)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript, nostdcall] void DispatchDOMEvent (in nsEventPtr aEvent, in
nsIDOMEvent aDOMEvent, in nsPresContextPtr aPresContext, in
nsEventStatusPtr aEventStatus); */
+nsresult nsDOMEventTarget::DispatchDOMEvent(nsEvent *aEvent, nsIDOMEvent
*aDOMEvent, nsPresContext *aPresContext, nsEventStatus *aEventStatus)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [nostdcall, notxpcom] nsEventListenerManagerPtr GetListenerManager (in
boolean aMayCreate); */
+nsEventListenerManager * nsDOMEventTarget::GetListenerManager(PRBool
aMayCreate)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript, nostdcall] void AddEventListenerByIID (in
nsIDOMEventListener aListener, in nsIIDRef aIID); */
+nsresult nsDOMEventTarget::AddEventListenerByIID(nsIDOMEventListener
*aListener, const nsIID & aIID)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [noscript, nostdcall] void RemoveEventListenerByIID (in
nsIDOMEventListener aListener, in nsIIDRef aIID); */
+nsresult nsDOMEventTarget::RemoveEventListenerByIID(nsIDOMEventListener
*aListener, const nsIID & aIID)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [nostdcall, notxpcom] nsIScriptContext GetContextForEventHandlers (out
nsresult aRv); */
+nsIScriptContext * nsDOMEventTarget::GetContextForEventHandlers(nsresult
*aRv NS_OUTPARAM)
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* [nostdcall, notxpcom] JSContextPtr GetJSContextForEventHandlers (); */
+JSContext * nsDOMEventTarget::GetJSContextForEventHandlers()
+{
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+/* End of implementation class template. */
+#endif
+
+typedef nsIDOMEventTarget nsPIDOMEventTarget;
+#define NS_IMPL_DOMTARGET_DEFAULTS(_class) \
+nsPIDOMEventTarget* _class::GetTargetForDOMEvent() { return this; } \
+nsPIDOMEventTarget* _class::GetTargetForEventTargetChain() { return this;
} \
+nsresult _class::WillHandleEvent(nsEventChainPostVisitor& aVisitor) {
return NS_OK; } \
+JSContext* _class::GetJSContextForEventHandlers() { return nsnull; }
+
+#endif /* __gen_nsIDOMEventTarget_h__ */
--
http://groups.google.com/group/Google-Web-Toolkit-Contributors
