Index

Found 1275 pages:

#	Page	Tags and summary
1	XPCOM	Add-ons, Extensions, Landing, Mozilla, XPCOM
		XPCOM is a cross platform component object model, similar to Microsoft COM. It has multiple language bindings, allowing XPCOM components to be used and implemented in JavaScript, Java, and Python in addition to C++.
2	Accessing the Windows Registry Using XPCOM	Add-ons, Code snippets, Extensions, NeedsClassification, Windows Registry
		When implementing Windows-specific functionality, it is often useful to access the Windows registry for information about the environment or other installed programs. To this end, there exist XPCOM interfaces to read and write registry data. This article will show you how to use the available interfaces in several Mozilla products.
3	Aggregating the In-Memory Datasource	RDF
		No summary!
4	Binary compatibility	XPCOM
		If Mozilla decides to upgrade to a compiler that does not have the same ABI as the current version, any built component may fail. It is a possiblity that is introduced when upgrading to a new compiler without recompiling everything. Effectively, it is a different platform.
5	Bundling multiple binary components
		Binary XPCOM components are sometimes required to implement low-level features for extensions. Since binary components are linked against a single Gecko SDK, a dependency to a particular version of Gecko is created. If the component uses only "frozen" XPCOM interfaces, there is a good chance the same binary component will work with different versions of Gecko (version 1.8 and 1.9, for example). The more likely case is that the component uses "unfrozen" interfaces and those interfaces can change between Gecko versions. This can create a difficult situation for extension developers trying to support multiple Gecko versions (Firefox 2 and 3, for example).
6	Creating a Python XPCOM component	Guide, NeedsHelp, PyXPCOM, XPCOM, XPCOM:Language Bindings
		Creating Applications with Mozilla already provides a tutorial for making a simple JavaScript or C++ component (implementing the nsISimple interface). Here is how to make the same component in Python using PyXPCOM.
7	Fun With XBL and XPConnect	XBL, XPCOM, XPCOM:Language Bindings, XPConnect
		No summary!
8	Generating GUIDs	Add-ons, Developing Mozilla, Developing_Mozilla:Tools, Extensions, Tools, XPCOM
		GUIDs are used in Mozilla programming for identifying several types of entities, including XPCOM Interfaces (this type of GUIDs is callled IID), components (CID), and legacy add-ons—like extensions and themes—that were created prior to Firefox 1.5. Add-ons can (and should) be identified with IDs of the form extensionname@organization.tld since Firefox 1.5.
9	Generic factory	XPCOM
		Most XPCOM factories can be very simple. Rick Potts wrote a templated-based generic factory (nsFactory<t>) that simplifies the factory creation process that just requires writing a CreateInstance() method. The new nsIGenericFactory interface takes this a step further, by providing a single interface that can be reused anytime a simple implementation of nsIFactory is needed. Here is the interface, and a description of its use.</t>
10	How To Pass an XPCOM Object to a New Window	NeedsExample, NeedsHelp
		If you want to be able to call functions within an XPCOM object from a XUL window's code, you can do so if you pass the XPCOM object as one of the arguments to the window creation method.
11	How to build a binary XPCOM component using Visual Studio	Add-ons, Extensions, XPCOM
		This is a simple tutorial for building XPCOM objects in C++ using Visual Studio. XPCOM is Mozilla’s cross platform component object model, similar to Microsoft’s COM technology. XPCOM components can be implemented in C, C++, and JavaScript, and can be used from C, C++, and JavaScript. That means you can call JavaScript methods from C++ and vice versa. For more information on the workings of XPCOM look elsewhere.
12	Index
		Found 1275 pages:
13	Interfacing with the XPCOM cycle collector	Firefox 3, XPCOM
		This is a quick overview of the cycle collector introduced into XPCOM for Firefox 3, including a description of the steps involved in modifying an existing C++ class to participate in XPCOM cycle collection. If you have a class that you think is involved in a cyclical-ownership leak, this page is for you.
14	Introduction to XPCOM for the DOM	Developing Mozilla
		Warning: this document has not yet been reviewed by the DOM gurus, it might contain some errors.
15	Language bindings	Embedding, Landing, Mozilla, XPCOM, XPCOM:Language Bindings
		An XPCOM Language Binding is a bridge between a particular language and XPCOM to provide access to XPCOM objects from that language, and to let modules written in that language be used as XPCOM objects by all other languages for which there are XPCOM bindings.
16	Components object	DOM, Gecko, XPCOM:Language Bindings, XPConnect
		The Components object is the object through which XPConnect functionality is reflected into JavaScript. The Components object is actually a native instance of the nsIXPCComponents interface which is reflected into JavaScript as a top level object using XPConnect.
17	Components.Constructor	XPCOM:Language Bindings, XPConnect
		Creates a JavaScript function which can be used to create or construct new instances of XPCOM components.
18	Components.Exception	XPCOM:Language Bindings, XPConnect
		Components.Exception is a JavaScript constructor to create nsIXPCException objects. These exception objects may be thrown when implementing xpcom interfaces in JavaScript, and they can provide better diagnostics in the error console if not caught than simply throwing an nsresult's value will.
19	Components.ID	XPCOM:Language Bindings, XPConnect
		Components.ID is a constructor that creates native objects that conform to the nsIJSID interface.
20	Components.classes	XPCOM:Language Bindings, XPConnect
		Components.classes is a read-only object whose properties are classes indexed by ContractID.
21	Components.classesByID	XPCOM:Language Bindings, XPConnect
		Components.classesByID is a read-only object whose properties are classes indexed by CID.
22	Components.interfaces	XPCOM:Language Bindings, XPConnect
		Components.interfaces is a read-only object whose properties are interfaces indexed by their names.
23	Components.interfacesByID	XPCOM:Language Bindings, XPConnect
		Components.interfacesByID is a read-only array of classes indexed by IID.
24	Components.isSuccessCode	XPCOM, XPCOM:Language Bindings, XPConnect
		Determines whether a given XPCOM return code (that is, an nsresult value) indicates the success or failure of an operation, returning true or false respectively.
25	Components.lastResult	XPCOM:Language Bindings, XPConnect
		No summary!
26	Components.manager	XPCOM:Language Bindings, XPConnect
		Components.manager is a convenience reflection of the global native component manager service. The scriptable methods on the nsIComponentManager interface can be called directly on this object.
27	Components.results	XPCOM:Language Bindings, XPConnect
		Components.results is a read-only object whose properties are the names listed as the first parameters of the macros in js/xpconnect/src/xpc.msg (also at Table Of Errors), with the value of each corresponding to that constant's value.
28	Components.returnCode	XPCOM:Language Bindings, XPConnect
		No summary!
29	Components.stack	XPCOM:Language Bindings, XPConnect
		Components.stack is a read only property of type nsIStackFrame (IDL definition) that represents a snapshot of the current JavaScript callstack. This can be used for various diagnostic purposes.
30	Components.utils	XPCOM:Language Bindings, XPConnect
		Components.utils is a collection of various useful XPConnect features. Its interface is defined at js/xpconnect/idl/xpccomponents.idl.
31	Components.utils.Sandbox	NeedsMarkupWork, Reference, Référence(2), XPCOM:Language Bindings, XPConnect
		Components.utils.Sandbox is used to create a sandbox object for use with evalInSandbox().
32	Components.utils.cloneInto
		This function provides a safe way to take an object defined in a privileged scope and create a structured clone of it in a less-privileged scope. It returns a reference to the clone:
33	Components.utils.createObjectIn	Add-ons, Developing Mozilla, Extensions, JavaScript, Reference, Référence(2), XPCOM:Language Bindings, XPConnect
		Components.utils.createObjectIn creates a new JavaScript object in the scope of the specified object's compartment.
34	Components.utils.evalInSandbox	Add-ons, Developing Mozilla, Extensions, JavaScript, XPCOM:Language Bindings, XPConnect
		The evalInSandbox() function enables you to evaluate JavaScript code inside a sandbox you've previously created using the Components.utils.Sandbox constructor.
35	Components.utils.evalInWindow
		This function enables code running in a more-privileged JavaScript context to evaluate a string in a less-privileged JavaScript context. The result is structured cloned back to the original context, unless it is native (for example, if it returns a DOM node, this is not structured cloned, because the original context will see that through an XrayWrapper already), so it's guaranteed to behave predictably. This is useful for privileged code, such as add-on code, to access variables and APIs defined in web content.
36	Components.utils.exportFunction	API, Add-ons, Components, Extensions, Language Bindings, Method, Mozilla, Non-standard, Reference, WebExtensions, XPCOM
		This function provides a safe way to expose a function from a privileged scope to a less-privileged scope.
37	Components.utils.forceGC	NeedsContent, XPCOM, XPCOM:Language Bindings, XPConnect
		Components.utils.forceGC lets scripts force a garbage collection cycle. The Mozilla JavaScript engine will perform garbage collection automatically when the JavaScript heap grows beyond a certain size. This mechanism doesn't account for any native (C++) XPCOM objects hanging off JavaScript objects though. In many cases a JavaScript application will have internal knowledge of JavaScript objects referencing large (trees of) XPCOM objects and know when they are no longer reachable. In this case it can be important to be able to force a garbage collection cycle from JavaScript.
38	Components.utils.getGlobalForObject	Add-ons, Developing Mozilla, Extensions, JavaScript, XPCOM:Language Bindings, XPConnect
		This method is used to determine the global object with which an object is associated. This is the global object in place at the time the object was created, which is to say the global object used when executing the script that created the object.
39	Components.utils.getWeakReference	XPCOM, XPCOM:Language Bindings, XPConnect
		This method was introduced in Firefox 3 and is used for obtaining a weak reference for an object. To obtain the object reference, you have to call get() on the resulting object.
40	Components.utils.import	NeedsContent, XPCOM:Language Bindings, XPConnect
		Components.utils.import was introduced in Firefox 3 and is used for sharing code between different scopes easily. For example, you can import XPCOMUtils.jsm to avoid copy/pasting long XPCOM component registration boilerplate in your component files.
41	Components.utils.importGlobalProperties
		Imports various objects into a system scope.
42	Components.utils.isXrayWrapper
		When privileged JavaScript in Gecko accesses objects belonging to less-privileged code (such as untrusted web content), it does so, by default, with "Xray vision": a mechanism that filters out certain changes to the objects that could cause them to behave in unexpected ways. For example, privileged code using an Xray to a DOM object sees only the original, native version of the DOM object. Any expando properties are not visible, and if any native properties have been redefined, this has no effect.
43	Components.utils.makeObjectPropsNormal	Add-ons, Developing Mozilla, Extensions, JavaScript, NeedsTechnicalReview, XPCOM:Language Bindings, XPConnect
		Ensures that the specified object's methods are all in the object's scope, and aren't cross-component wrappers.
44	Components.utils.reportError	XPCOM:Language Bindings, XPConnect
		Components.utils.reportError reports a JavaScript Error object to the Error Console, and returns. It is meant for use by extension developers who have exception handler blocks which want to "eat" an exception, but still want to report it to the console.
45	Components.utils.schedulePreciseGC	Guide, NeedsContent, XPCOM, XPCOM:Language Bindings, XPConnect
		This method lets scripts schedule a garbage collection cycle. The garbage collection cycle will occur sometime in the future, when no JavaScript code is executing. This is useful particularly when testing for memory leaks, because normal garbage collection is conservative when JavaScript code is running to ensure that in-use memory isn't inadvertently collected.
46	Components.utils.setGCZeal	NeedsTechnicalReview, XPCOM, XPCOM:Language Bindings, XPConnect
		This method lets scripts set the zeal level for garbage collection. You can get details on what this method does in JS_SetGCZeal. This method calls through to that thusly:
47	Components.utils.unload	Modules
		Components.utils.unload was introduced in Firefox 7 and is used to unload JavaScript code modules. This can be particularly handy with restartless (boostrapped) extensions, so that you can unload an old version of a code module when a new version of your add-on is installed.
48	Components.utils.unwaiveXrays
		Undo a previous call to Components.utils.waiveXrays(), restoring Xray vision for the caller.
49	Components.utils.waiveXrays
		Waives Xray vision for an object, giving the caller a transparent wrapper to the underlying object.
50	JavaXPCOM	Embedding, Java, JavaXPCOM, Mozilla, XPCOM, XPCOM:Language Bindings
		JavaXPCOM allows for communication between Java and XPCOM, such that a Java application can access XPCOM objects, and XPCOM can access any Java class that implements an XPCOM interface. JavaXPCOM is not actively maintained.
51	Development	JavaXPCOM, XPCOM:Language Bindings
		No summary!
52	Examples	JavaXPCOM, XPCOM:Language Bindings
		No summary!
53	Other Resources	JavaXPCOM, XPCOM:Language Bindings
		No summary!
54	PlXPCOM	Guide, Mozilla, PlXPCOM, XPCOM, XPCOM:Language Bindings
		plXPCOM (Perl XPCOM) provides language bindings letting you use XPCOM from Perl code. The resources here provide information about this language binding and how to use it.
55	PyXPCOM	Landing, Mozilla, PyXPCOM, XPCOM, XPCOM:Language Bindings
		PyXPCOM allows for communication between Python and XPCOM, such that a Python application can access XPCOM objects, and XPCOM can access any Python class that implements an XPCOM interface. PyXPCOM is actively used in ActiveState Komodo products, for example.
56	Community	PyXPCOM, XPCOM:Language Bindings
		No summary!
57	RbXPCOM	Guide, Mozilla, RbXPCOM, XPCOM, XPCOM:Language Bindings
		RbXPCOM (Ruby Cross-Platform COM) provides bindings between the popular Ruby programming language and XPCOM. You can find additional information using the resource links below.
58	XPConnect	Landing, Mozilla, XPCOM, XPCOM:Language Bindings, XPConnect
		XPConnect is a bridge between JavaScript and XPCOM. With XPConnect, you can use XPCOM components from JavaScript code, and interact with JavaScript objects from within XPCOM components. XPConnect is part of Firefox and is actively used in XUL applications.
59	Architecture basics	Guide, NeedsContent, XPCOM, XPCOM:Language Bindings, XPConnect
		XPCOM is like COM, for Windows. It lets you get pointers to components inside Mozilla, and it lets you talk about their interfaces as well.
60	Using components	Deprecated, Guide, NeedsContent, XPCOM, XPCOM:Language Bindings, XPConnect
		XPConnect works transparently in Mozilla and xpcshell to give you access to XPCOM components.
61	XPConnect wrappers	Guide, NeedsContent, XPCOM, XPCOM:Language Bindings, XPConnect
		This document is a high-level overview of XPConnect wrapper objects (for the more technical description see XPConnect security membranes). For practical advice on dealing with wrappers, see Safely accessing content DOM from chrome.
62	appShellService	XPCOM:Language Bindings, XPConnect
		Quitting Mozilla:
63	nsIProfile	Interfaces, XPCOM, XPCOM:Language Bindings, XPConnect
		This interface is obsolete; you should use nsIToolkitProfileService instead; however, reference documentation for nsIProfile is available if you're working with old code.
64	nsIRegistry	XPCOM:Language Bindings, XPConnect
		nsIRegistry on MXR
65	xpcshell	Automated testing, Developing Mozilla, Guide, JavaScript, JavaScript:Tools, Tools, XPCOM, XPCOM:Language Bindings, XPConnect
		xpcshell is an XPConnect-enabled JavaScript Shell. It is a console application that lets you run JavaScript code. Unlike the ordinary JS shell (js), xpcshell lets the scripts running in it access XPCOM functionality.
66	HOWTO
		Problem
67	Profiling XPCShell
		Sometimes, you might want to get a performance profile of a certain piece of JavaScript (like an XPCOM module), to see which part takes the most time. You could use Venkman for that. But sometimes, Venkman gives too much noise (because it also profiles chrome code). Or you might want to have a more reproducible testcase. In those cases, an xpcshell script can help. You can just call the code you want to test. But then, you can't use the Venkman UI.
68	WithJSModulesAndChrome
		Moved to HOWTO
69	XPCShell Reference	Automated testing, Developing Mozilla, JavaScript, JavaScript:Tools, Tools, XPCOM:Language Bindings, XPConnect
		The command-line syntax for xpcshell is:
70	XPCshell Test Manifest Expressions	QA, Testing
		XPCShell unit tests are run by specifying them in a manifest file. You can add conditions to tests in order to control when tests get run. The conditions accept a simple boolean expression syntax, described here.
71	Monitoring HTTP activity	HTTP
		Gecko includes the nsIHttpActivityObserver interface, which you can implement in your code to monitor HTTP transactions in real time, receiving a callback as the transactions take place.
72	Observer Notifications	XPCOM, XPCOM:Add-ons
		The following are topics that you can observe during the course of an application. Unless otherwise noted you register for the topics using the nsIObserverService.
73	Setting HTTP request headers	Add-ons, Extensions, HTTP, XUL, XULRunner
		HTTP is one of the core technologies behind the Web. In addition to the actual content, some important information is passed with HTTP headers for both HTTP requests and responses.
74	Storage	Guide, Interfaces, Storage, Toolkit API
		Storage is a SQLite database API. It is available to trusted callers, meaning extensions and Firefox components only.
75	Performance	Storage, Toolkit API
		mozStorage uses SQLite as the database backend. It has generally good performance for a small embedded database. However, many things cause various database operations to be slow.
76	Warnings	Storage, Warnings
		Storage sometimes warns about things to stderr. This page is designed to help explain the cause and possible solutions for these warnings.
77	The Thread Manager	Firefox 3, Threads
		The Thread Manager, introduced in Firefox 3, offers an easy to use mechanism for creating threads and dispatching events to them for processing.
78	Troubleshooting XPCOM components registration	Add-ons, Extensions, XPCOM
		Often the first time you create an XPCOM component, it may fail to register correctly.
79	Using nsCOMPtr	XPCOM
		This document is the sum total of everything written down about nsCOMPtr. If you have a question about nsCOMPtr, and this document doesn't answer it, there probably isn't a document that answers it. You'll have to turn to the XPCOM newsgroup or another experienced nsCOMPtr user, or find the answer by experimentation.
80	Frequently Asked Questions	XPCOM
		This section will help you if you're fixing a broken build, or have what you think is a quick obvious question, and you don't have time to read the Reference Manual. This FAQ usually just refers back directly to the appropriate answer, there. If you're looking here just to learn about nsCOMPtrs, you'll get a better introduction in the Getting Started Guide.
81	Getting Started Guide	XPCOM
		An nsCOMPtr is an owning reference. Whatever it points to has been AddRefed, counting the nsCOMPtr as one of its `owners'. An nsCOMPtr always calls Release before letting go, whether the nsCOMPtr is letting go so that it can point to a different object, or because the nsCOMPtr is going out of scope. Any time a new value is assigned into an nsCOMPtr, the nsCOMPtr automatically always Releases its old referent, if any, and (unless you tell it you already have) AddRefs the new.
82	Reference Manual	XPCOM
		This section will help you if you're already familiar with nsCOMPtr but you need details. If you've never use nsCOMPtrs before, you might want to read the Getting Started Guide first. If you're trying to fix a broken build, the FAQ might lead you to the answer more quickly.
83	Status, Recent Changes, and Plans	XPCOM
		No summary!
84	Using nsIClassInfo	XPCOM
		If you use a C++ class which implements nsIClassInfo from JavaScript, then you don't have to explicitly call QueryInterface on the JavaScript object to access the object's interfaces.
85	Using nsIDirectoryService	Extensions, Guide, XPCOM
		nsDirectoryService implements the nsIProperties interface. This implementation will allow you to Get(), Set(), Define(), and Undefine() nsIFile.
86	Using nsIPasswordManager	Guide, Interfaces, Login Manager, Security
		The code on this page will work with applications using Toolkit 1.8 and below such as Firefox 2.0.0.x and Thunderbird 2.0.0.x. For similar functionality in Toolkit 1.9, see Using nsILoginManager.
87	Using nsISimpleEnumerator
		No summary!
88	Using the Gecko SDK	Add-ons, Developing Mozilla, Extensions, Gecko, NeedsContent
		No summary!
89	Using the clipboard	Add-ons, Clipboard, Extensions, Guide, Mozilla, XPCOM
		This section provides information about cutting, copying, and pasting to and from the clipboard.
90	Weak reference	XPCOM
		In XPCOM, a weak reference is a special object that contains a pointer to an XPCOM object, but doesnot keep that object alive. If the referent object is destroyed before the weak reference, the pointer inside the weak reference is set to nsnull.
91	Working with Multiple Versions of Interfaces	Add-ons, Extensions, XPCOM
		In this short note we illustrate how one can update an XPCOM module in order for it to work in both Firefox 2 and Firefox 3, even if the interfaces have changed in the interim.
92	Working with out parameters	Add-ons, Extensions, XPCOM:Language Bindings, XPConnect
		No summary!
93	XPCOM ABI	XPCOM
		XPCOM ABI is the binary interface of XPCOM components. While XPCOM components written in a scripting language (such as JavaScript) can be moved across platforms (such as Windows and OS X) without adaptation, those written in a compiled language (such as C++) require recompilation when moving to a different platform. Often, compiled XPCOM components are called 'binary' or 'native'.
94	XPCOM Thread Synchronization	Thread_Synchronization, Threads, XPCOM
		XPCOM thread synchronization primitives have the same semantics as those in NSPR, and each method of these synchronization objects (e.g. Mutex::Lock()) has a matching function in NSPR (PR_Lock()). This is no accident, as mozilla:: primitives are merely bare-minimum wrappers around NSPR's.
95	XPCOM category image-sniffing-services	Add-ons, Extensions, NeedsContent
		In versions of Firefox prior to Firefox 3, extensions could add decoders for new image types. However, such decoders relied on servers sending correct MIME types; images sent with incorrect MIME types would not be correctly displayed.
96	XPCOM glue	Guide, XPCOM, XPCOM glue
		The XPCOM Glue is a static library which component developers and embedders can link against. It allows developers to link only against the frozen XPCOM method symbols and maintain compatibility with multiple versions of XPCOM.
97	XPCOM Glue without mozalloc
		Starting with XULRunner 2.0, the frozen linkage dependent glue (xpcomglue_s.lib on Windows, libxpcomglue_s.a on Linux and Mac) is dependent on the new infallible memory allocation routines (mozalloc). Since these routines didn't exist prior to XULRunner 2.0, XPCOM components that link against the frozen linkage dependent glue will not be compatible with XULRunner applications prior to 2.0.
98	XPCOM guide	Add-ons, Extensions, Guide, Landing, Mozilla, XPCOM
		These articles provide tutorials and usage documentation for XPCOM, including how to use it in your own projects and how to build XPCOM components for your Firefox add-ons and the like.
99	Avoiding leaks in JavaScript XPCOM components	Add-ons, Developing Mozilla, Extensions, Mozilla, NeedsUpdate, Obsolete, XPCOM, XPCOM:Language Bindings, XPConnect
		Programmers writing and reviewing JavaScript code in Mozilla should understand how code using XPCOM in JavaScript can leak so that they can avoid leaks. This document attempts to help them do so, first by explaining the underlying concepts, and second by describing a number of common JavaScript patterns that cause leaks.
100	Creating XPCOM components	Deprecated, Guide, NeedsMarkupWork, XPCOM
		This guide is about Gecko, and about creating XPCOM components for Gecko-based applications.
101	An Overview of XPCOM	XPCOM
		This is a book about XPCOM. The book is presented as a tutorial about creating XPCOM components, but it covers all major aspects, concepts, and terminology of the XPCOM component model along the way.
102	Building the WebLock UI	XPCOM
		Up until now, we've been building a component that can be installed in any Gecko application. The XPCOM interfaces and tools you've used have been general, cross-platform, and available in the Gecko Runtime Environment or in any Gecko-based application after Mozilla 1.2 (when the GRE began to be used).
103	Component Internals	Obsolete, XPCOM
		Let's start by examining how XPCOM components are written in C++. The most common type of component is one that is written in C++ and compiled into a shared library (a DLL on a Windows system or a DSO on Unix).
104	Creating the Component Code	XPCOM
		This chapter goes over the basic code required to handle the relationship between your component and XPCOM. Having the component found and registered properly is the goal of this first chapter of the tutorial. In the subsequent chapters, we can begin to work on the example WebLock component functionality itself.
105	Finishing the Component	XPCOM
		At this point you have created most of the infrastructure of the component. The component will be recognized by XPCOM and registered with the Category Manager so that it starts up when XPCOM initializes. When the component starts up, it populates a list of URLs read in from a file stored next to the Gecko binary on the local system.
106	Packaging WebLock	XPCOM
		In this final part of the tutorial, we'll put all of the pieces of the web locking component - the library itself, the type library, the header file, and the user interface resources - into a package that can be installed on other systems. The first section, Component Installation Overview, describes the general installation process in Mozilla. The following sections describe the steps you can take to organize the WebLock component for distribution and installation.
107	Preface	Guide, XPCOM
		This is a book about Gecko, and about creating XPCOM components for Gecko-based applications. Though the emphasis is on the practical steps you take to make your C++ code into a component that can be used in Gecko, we hope that these steps will also give us an occasion to discuss all of the tools, techniques, and technologies that make up XPCOM. Accordingly, the book is arranged so that you can follow along and create your own components or learn about different XPCOM topics individually, as in a reference work. For example, the introduction includes a discussion of components and what they are, and the first chapter - in which you compile the basic code and register it with Mozilla - prompts a discussion of the relationship between components and modules, of XPCOM interfaces, and of the registration process in general.
108	Resources	Guide, XPCOM
		This last section of the book provides a list of resources referred to in the tutorial and other links that may be useful to the Gecko developer.
109	Setting up the Gecko SDK	NeedsUpdate, Tutorial, XPCOM
		This chapter provides basic setup information for the Gecko Software Development Kit (SDK) used to build the WebLock component in this tutorial. The following four sections tell the developer how to download and organize the Gecko SDK and create a new project in which components like WebLock can be created.
110	Starting WebLock	XPCOM
		In this chapter, we begin to design and implement the web locking functionality itself. We have already created a module that implements most of the generic component functionality (e.g. registration). This chapter will focus on the functionality that actually handles the web locking.
111	Using XPCOM Components	XPCOM
		Applications like the Mozilla browser are sophisticated, modularized clients of XPCOM components. In fact, virtually all of the functionality that you associate with a browser - navigation, window management, managing cookies, bookmarks, security, searching, rendering, and other features - is defined in XPCOM components and accessed by means of those component interfaces. Mozilla is made of XPCOM components.
112	Using XPCOM Utilities to Make Things Easier	NeedsUpdate, XPCOM
		This chapter goes back over the code you've already created in the first part of the tutorial (see webLock1.cpp in the previous chapter) and uses XPCOM tools that make coding a lot easier and more efficient. It also introduces a basic string type that is used with many of the APIs in both XPCOM and Gecko.
113	Detailed XPCOM hashtable guide	Guide, XPCOM
		A hashtable is a data construct that stores a set of items. Each item has a key that identifies the item. Items are found, added, and removed from the hashtable by using the key. Hashtables may seem like arrays, but there are important differences:
114	How to build an XPCOM component in JavaScript	Add-ons, Extensions, JavaScript, Tutorial, XPCOM
		If you are looking for Add-on SDK solution for XPCOM JavaScript components then check out platform/xpcom module first.
115	Inheriting from implementation classes	XPCOM
		Given that IDL interfaces map to abstract classes in C++, a common problem when dealing with IDL is when you have an IDL inheritance hierarchy, and a corresponding C++ implementation hierarchy, you run into multiple inheritance. That's not inherently multiple inheritance, though, because you only mix in interfaces (i.e. the problem would not exist with Java's interfaces).
116	Making cross-thread calls using runnables	Guide, Threads, XPCOM
		In the Mozilla platform, most activities such as layout, DOM operations, content JavaScript, and chrome JavaScript run on the main thread. However, it may be useful for C++ code in the Mozilla platform to run tasks on another thread.
117	Mozilla internal string guide	Guide, XPCOM
		Most of the Mozilla code uses a C++ class hierarchy to pass string data, rather than using raw pointers. This guide documents the string classes which are visible to code within the Mozilla codebase (code which is linked into libxul).
118	Receiving startup notifications	Component Manager, Embedding Mozilla, NeedsUpdate, XPCOM
		Sometimes it's necessary for XPCOM components to receive notifications as to the progress of the application's startup process, so they can start new services at appropriate times, for example.
119	XPCOM Stream Guide	Guide, NeedsContent, XPCOM
		In Mozilla code, a stream is an object which represents access to a sequence of characters. It is not that sequence of characters, though: the characters may not all be available when you read from the stream.
120	XPCOM array guide	Guide, NeedsContent, NeedsMarkupWork, XPCOM
		Mozilla has many array classes because each array is optimized for a particular usage pattern. This guide describes the available arrays as well as the enumerator classes that can be used to get to them. In this document the term Array refers to a container for multiple objects with a numeric, zero-based index.
121	XPCOM changes in Gecko 2.0	Gecko 2.0, XPCOM
		Several changes that affect XPCOM component compatibility are taking place in Gecko 2. This article details those changes, and provides suggestions for how to update your code.
122	XPCOM hashtable guide
		A hashtable is a data construct that stores a set of items. Each item has a key that identifies the item. Items are found, added, and removed from the hashtable by using the key. Hashtables may seem like arrays, but there are important differences:
123	mozilla::services namespace	Developing Mozilla, XPCOM
		The services C++ namespace offers an easy and efficient alternative for obtaining a service as compared to the indirect XPCOM approach: GetService(), CallGetService(), etc methods are expensive and should be avoided when possible.
124	XPCOM ownership guidelines	XPCOM
		...naturally. If you create a temporary object, obviously it's up to you to destroy it. That's a sure sign of ownership. If you create an object with a longer lifespan, you will own it until you give ownership away.
125	XPCOM reference	Add-ons, Extensions, Landing, Mozilla, Reference, XPCOM
		This reference describes the interfaces and functions provided by the XPCOM library. In addition, it details the various helper classes and functions, as well as the components, provided by the XPCOM glue library. The contents herein are oriented primarily toward extension developers and people embedding XPCOM in other projects.
126	Core XPCOM functions	Functions, Landing, Mozilla, XPCOM
		XPCOM provides a number of global functions which are used to initialize and shut down the XPCOM library, as well as to allocate memory, get access to services, and to instantiate interfaces.
127	NS_Alloc	Functions, Functions:Frozen, NeedsRelocation, Reference, Référence(2), XPCOM, XPCOM API Reference
		Infallibly allocates a block of memory using the XPCOM memory manager.
128	NS_Free	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		Frees a block of memory using the XPCOM memory manager.
129	NS_GetComponentManager	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetComponentManager function returns a reference to the XPCOM Component Manager.
130	NS_GetComponentRegistrar	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetComponentRegistrar function returns a reference to the XPCOM Component Registrar.
131	NS_GetMemoryManager	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetMemoryManager function returns a reference to the XPCOM Memory Manager.
132	NS_GetServiceManager	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetServiceManager function returns a reference to the XPCOM service manager.
133	NS_InitXPCOM2	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_InitXPCOM2 function initiates use of XPCOM in the calling process.
134	NS_InitXPCOM3	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_InitXPCOM3 function initiates use of XPCOM in the calling process with support for statically defined XPCOM modules.
135	NS_NewLocalFile	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_NewLocalFile function creates an instance of nsILocalFile that provides a platform independent representation of a file path.
136	NS_NewNativeLocalFile	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_NewNativeLocalFile function creates an instance of nsILocalFile that provides a platform independent representation of a file path.
137	NS_Realloc	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		Reallocates a block of memory using the XPCOM memory manager.
138	NS_ShutdownXPCOM	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_ShutdownXPCOM function terminates use of XPCOM in the calling process.
139	nsresult	Errors, Mozilla, Reference, Référence(2), XPCOM, XPCOM API Reference
		The nsresult data type is a strongly-typed enum used to represent a value returned by an XPCOM function; these are typically error or status codes. For a list of defined result values, see Error codes returned by Mozilla APIs.
140	Folders	thunderbird
		The folder classes all implement the nsIMsgFolder interface. There are currently three folder classes - nsLocalMailFolder, nsImapMailFolder, and nsNewsFolder. They all inherit from nsMsgDBFolder, which implements a lot of the core functionality. RSS feeds are implemented by nsLocalMailFolder.
141	NS ENSURE SUCCESS	XPCOM, XPCOM_Macros
		Macro
142	NS ENSURE TRUE	XPCOM, XPCOM_Macros
		Macro
143	NS_ABORT_IF_FALSE
		This was removed in bug 1127201
144	NS_ADDREF	XPCOM, XPCOM_Macros
		Macro
145	NS_ASSERTION	XPCOM, XPCOM_Macros
		Macro
146	NS_ENSURE_ARG_POINTER	XPCOM, XPCOM_Macros
		Macro
147	NS_ERROR	XPCOM, XPCOM_Macros
		Throws a assertion (NS_ASSERTION) with the text "Error: (error text)", so writes this text to console (stderr) and to debug logs (NSPR logging). This macro is meant for critical errors; like assertions, NS_ERRORs should not be reachable.
148	NS_IF_ADDREF	XPCOM, XPCOM_Macros
		Macro
149	NS_IF_RELEASE	XPCOM, XPCOM_Macros
		Macro
150	NS_RELEASE	XPCOM, XPCOM_Macros
		Macro
151	NS_WARNING	XPCOM, XPCOM_Macros
		Macro
152	Standard XPCOM components	Components, Landing, Mozilla, NeedsContent, XPCOM
		There are a number of components provided in the standard implementation of XPCOM; these are as follows.
153	nsCategoryManager	Components, Components:Frozen, XPCOM, XPCOM API Reference
		The XPCOM Category Manager.
154	nsDirectoryService	Components, Components:Frozen, XPCOM, XPCOM API Reference
		The XPCOM Directory Service. This service returns the locations of "well known" directories in an OS-independent manner. For instance, it can give you the path of the system's temporary directory, desktop directory, current working directory, and so on.
155	nsLocalFile	Components, Components:Frozen, XPCOM, XPCOM API Reference
		A component implementing nsILocalFile.
156	nsObserverService	Components, NeedsContent, Reference, Référence(2), XPCOM
		The XPCOM Observer Service.
157	nsScriptableInputStream	Components, Components:Frozen, XPCOM, XPCOM API Reference
		A component implementing nsIScriptableInputStream.
158	XPCOM Interface Reference	XPCOM, XPCOM Interface Reference
		This is a reference to the XPCOM interfaces provided by the Mozilla platform.
159	Component; nsIPrefBranch	Interfaces, Interfaces:Scriptable, Web Development, XPCOM, XPCOM API Reference, XPCOM Api article, XPCOM Interface Reference
		This object is created with a "root" value which describes the base point in the preferences "tree" from which this "branch" stems. Preferences are accessed off of this root by using just the final portion of the preference. For example, if this object is created with the root "browser.startup.", the preferences "browser.startup.page", "browser.startup.homepage", and "browser.startup.homepage_override" can be accessed by simply passing "page", "homepage", or "homepage_override" to the various Get/Set methods.
160	ExtensionManager (Toolkit)	Extensions
		The ExtensionManager follows the nsIExtensionManager API.
161	IAccessible2	Interfaces, NeedsContent, XPCOM, XPCOM Interface Reference
		Returns the attributes specific to this IAccessible2 object, such as a cell's formula.
162	IAccessibleAction	Interfaces, XPCOM, XPCOM Interface Reference
		Every accessible object that can be manipulated via the native GUI beyond the methods available either in the MSAA IAccessible interface or in the set of IAccessible2 interfaces (other than this IAccessibleAction interface) should support the IAccessibleAction interface in order to provide Assistive Technology access to all the actions that can be performed by the object. Each action can be performed or queried for a name, description or associated key bindings. Actions are needed more for ATs that assist the mobility impaired, such as on-screen keyboards and voice command software. By providing actions directly, the AT can present them to the user without the user having to perform the extra steps to navigate a context menu. The first action should be equivalent to the MSAA default action. If there is only one action, IAccessibleAction should also be implemented.
163	IAccessibleApplication	Interfaces, XPCOM, XPCOM Interface Reference
		This interface provides the AT with the information it needs to differentiate this application from other applications, from other versions of this application, or from other versions of this application running on different versions of an accessibility bridge or accessibility toolkit. Servers implementing IAccessible2 should provide access to the IAccessibleApplication interface via QueryService from any object so that ATs can easily determine specific information about the application such as its name or version.
164	IAccessibleComponent	Interfaces, XPCOM, XPCOM Interface Reference
		This interface provides the standard mechanism for an assistive technology to retrieve information concerning the graphical representation of an object. Coordinates used by the functions of this interface are specified in different coordinate systems. Their scale is the same and is equal to that of the screen coordinate system. In other words all coordinates are measured in pixels. They differ in their respective origin:
165	IAccessibleEditableText	Interfaces, XPCOM, XPCOM Interface Reference
		This interface is typically used in conjunction with the IAccessibleText interface and complements that interface with the additional capability of clipboard operations. Note that even a read only text object can support the copy capability so this interface is not limited to editable objects. The substrings used with this interface are specified as follows: If startOffset is less than endOffset, the substring starts with the character at startOffset and ends with the character just before endOffset. If endOffset is lower than startOffset, the result is the same as a call with the two arguments exchanged. The whole text can be defined by passing the indices zero and IAccessibleText.nCharacters(). If both indices have the same value, an empty string is defined. Refer to the @ref _specialOffsets "Special Offsets for use in the IAccessibleText and IAccessibleEditableText Methods" for information about a special offset constant that can be used in IAccessibleEditableText methods.
166	IAccessibleHyperlink	Interfaces, XPCOM, XPCOM Interface Reference
		This interface represents a hyperlink associated with a single substring of text or single non-text object. Non-text objects can have either a single link or a collection of links such as when the non-text object is an image map. Linked objects and anchors are implementation dependent. This interface is derived from IAccessibleAction. IAccessibleAction.nActions() is one greater than the maximum value for the indices used with the methods of this interface. Furthermore, the object that implements this interface has to be connected implicitly or explicitly with an object that implements IAccessibleText. startIndex() and endIndex() are indices with respect to the text exposed by IAccessibleText. This interface provides access to a single object which can have multiple actions. An example is an image map which is an image with multiple links each of which is associated with a separate non-overlapping area of the image. This interface could also be applied to other kinds of objects with multiple actions such as "smart tags" which are objects, typically strings, which have multiple actions such as "Activate URI", "Bookmark URI", end so on. An interesting use case is an image map where each area is associated with multiple actions, for example an image map of smart tags. In this case you would have to implement two levels of accessible hyperlinks. The first level hyperlinks would only implement anchor() and anchorTarget(). The anchors would all reference the image object. The anchorTargets would reference the second level accessible hyperlink objects. None of the IAccessibleAction methods would be implemented on the first level hyperlink objects. The second level hyperlink objects would implement the IAccessibleAction methods. Their anchors would also reference the image object and their anchorTargets would reference URLs or the objects that would be activated. This use case demonstrates that in some cases there is no need for IAccessibleHyperlink to derive from IAccessibleAction. As a result it may be removed in a later version of the IDL and it is suggested that implementations should not rely on the inheritance.
167	IAccessibleHypertext	Interfaces, XPCOM, XPCOM Interface Reference
		The IAccessibleHypertext interface is the main interface to expose hyperlinks in a document, typically a text document, that are used to reference other documents. A typical implementation is to implement this interface on the smallest text object such as a paragraph of text.
168	IAccessibleImage	Interfaces, XPCOM, XPCOM Interface Reference
		This interface is used for a representation of images like icons on buttons. IAccessibleImage only needs to be implemented in certain situations. Some examples are:
169	IAccessibleRelation	Interfaces, NeedsContent, XPCOM, XPCOM Interface Reference
		Returns a localized version of the relation type.
170	IAccessibleTable	Interfaces, XPCOM, XPCOM Interface Reference
		Typically all accessible objects that represent cells or cell-clusters of a table will be at the same time children of the table. In this case IAccessible2.indexInParent() will return the child index which then can be used when calling rowIndex() and columnIndex(). However, in some cases that kind of implementation will not be possible. When the table cells are not direct children of a table, the object representing the cell can define a "table-cell-index" object attribute identifying the 0 based table cell index. This object attribute is obtained by parsing the attribute string returned by IAccessible2.attributes(). The "table-cell-index" attribute can be used just like a child index of the typical case. ATs should first test for the presence of the "table-cell-index" attribute and if it is not present then IAccessible2.indexInParent() can be used as in the typical case where cells are direct children of the table. The range of valid coordinates for this interface are implementation dependent. However, that range includes at least the intervals from the from the first row or column with the index 0 up to the last (but not including) used row or column as returned by nRows() and nColumns().
171	IAccessibleTable2	Interfaces, NeedsHelp
		Please also refer to the IAccessibleTableCell interface. If you want to support older applications you should also support the IAccessibleTable interface.
172	IAccessibleTableCell	Interfaces, XPCOM, XPCOM Interface Reference
		Returns the number of columns occupied by this cell accessible. The result is greater than 1 if the specified cell spans multiple columns.
173	IAccessibleText	Interfaces, NeedsContent, XPCOM, XPCOM Interface Reference
		This enum defines values which specify a text() boundary type. IA2_TEXT_BOUNDARY_SENTENCE is optional. When a method doesn't implement this method it must return S_FALSE. Typically this feature would not be implemented by an application. However, if the application developer was not satisfied with how screen readers have handled the reading of sentences this boundary type could be implemented and screen readers could use the application's version of a sentence rather than the screen reader's. The rest of the boundary types must be supported. This enum is used in textBeforeOffset(), textAtOffset(), and textAfterOffset().
174	IAccessibleValue	Interfaces, XPCOM, XPCOM Interface Reference
		The IAccessibleValue interface represents a single numerical value and should be implemented by any class that supports numerical value like progress bars and spin boxes. This interface lets you access the value and its upper and lower bounds.
175	IDispatch	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
176	IJSDebugger	Debugger, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Implemented by: @mozilla.org/jsdebugger;1 as a service:
177	amIInstallCallback	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when an install completes or fails.
178	amIInstallTrigger	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Retained for backwards compatibility.
179	amIWebInstallInfo	Add-on Manager, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Starts all installs.
180	amIWebInstallListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when the website is not allowed to directly prompt the user to install add-ons.
181	amIWebInstallPrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Gets a confirmation that the user wants to start the installs.
182	amIWebInstaller	Extension Manager, Interfaces, Interfaces:Scriptable, Reference, XPCOM Interface Reference
		Installs an array of add-ons at the request of a webpage.
183	imgICache	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Evict images from the cache.
184	imgIContainer	Interfaces, Interfaces:Scriptable, NeedsContent, NeedsUpdate, Reference, Thebes, XPCOM Interface Reference, needsattention
		Implemented by: ?????????????????????????????????????. To create an instance, use:
185	imgIContainerObserver	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, XPCOM Interface Reference, needsattention
		If you wish to listen for activities on an imgIContainer, you should implement the frameChanged() method.
186	imgIDecoder
		This interface is the base class for decoders for specific image formats.
187	imgIDecoderObserver	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, XPCOM Interface Reference, needsattention
		We make the distinction here between "load" and "decode" notifications. Load notifications are fired as the image is loaded from the network or filesystem. Decode notifications are fired as the image is decoded. If an image is decoded on load and not visibly discarded, decode notifications are nested logically inside load notifications as one might expect. However, with decode-on-draw, the set of decode notifications can come completely after the load notifications, and can come multiple times if the image is discardable. Moreover, they can be interleaved in various ways. In general, any presumed ordering between load and decode notifications should not be relied upon.
188	imgIEncoder	Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM Interface Reference
		Possible values for input format (note that not all image formats support saving alpha channels):
189	imgILoader	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		Implemented by @mozilla.org/image/loader;1 as a service:
190	imgIRequest	Interfaces, Interfaces:Scriptable, NeedsContent
		Cancels this request as in nsIRequest.Cancel(); further, also nulls out decoderObserver so it gets no further notifications from us.
191	inIDOMUtils	Interfaces, Interfaces:Scriptable, Reference, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/inspector/dom-utils;1 as a service:
192	jsdIStackFrame	Interfaces, Interfaces:Scriptable, NeedsContent, NeedsHelp, XPCOM, XPCOM Interface Reference
		Strict mode is on. Warnings reported as errors. Makes eval() use the last object on its 'obj' param's scope chain as the ECMA 'variables object'. Private data for this object is an nsISupports object. Attempting to alter this bit will result in an NS_ERROR_ILLEGAL_VALUE. OPT_* values above, OR'd together. Last version set on this context. Scripts typically select this with the "language" attribute. See the VERSION_* consts on jsdIDebuggerService. Unique tag among all valid jsdIContext objects, useful as a hash key. Private data for this context, if it is an nsISupports, |null| otherwise. Retrieve the underlying context wrapped by this jsdIContext. Top of the scope chain for this context. |true| if this context should be allowed to run scripts, |false| otherwise. This attribute is only valid for contexts which implement nsIScriptContext. Setting or getting this attribute on any other context will throw a NS_ERROR_NO_INTERFACE exception. Stack frame objects. These are only valid inside the jsdIExecutionHook which gave it to you. After you return from that handler the bottom frame, and any frame you found attached through it, are invalidated via the jsdIEphemeral interface. Once a jsdIStackFrame has been invalidated all method and property accesses will throw a NS_ERROR_NOT_AVAILABLE exception.
193	mozIAsyncFavicons	Interfaces, Interfaces:Scriptable, Places
		nsIFaviconService handles this interface, so you do not need to directly create a new service. Simply QueryInterface() the nsIFaviconService to this interface. As an alternative, you can just use PlacesUtils.favicons from JavaScript.
194	mozIAsyncHistory	Interfaces, Interfaces:Scriptable, Places, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/history;1 as a service:
195	mozIColorAnalyzer	Interfaces, Interfaces:Scriptable, Places, Reference, XPCOM API Reference, XPCOM Interface Reference
		Given an image URI, find the most representative color for that image based on the frequency of each color. Preference is given to colors that are more interesting. It avoids the background color if it can be discerned and ignores sufficiently transparent colors.
196	mozIJSSubScriptLoader	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/moz/jssubscript-loader;1. To get this service, use:
197	mozIPersonalDictionary	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/spellchecker/personaldictionary;1. To access this service, use
198	mozIPlaceInfo
		No summary!
199	mozIPlacesAutoComplete	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM Interface Reference
		Mark a page as being currently open.
200	mozIRegistry	Outdated_articles
		Clients will rely on nsRepository to create instances of a given class. Clients requiring dynamic "binding" of CLSIDs will be required to use some higher-level services (TBD) to figure out the CLSIDs they should use. The intent is that such services themselves be built on top of the new mozIRegistry interface.
201	mozIRepresentativeColorCallback	Interfaces, Interfaces:Scriptable, Places, XPCOM API Reference, XPCOM Interface Reference
		Will be called when color analysis finishes.
202	mozISpellCheckingEngine	Interfaces, Interfaces:Scriptable, Spell check, XPCOM Interface Reference
		This interface represents a spell checking engine. The built in Hunspell engine has contract ID "@mozilla.org/spellchecker/engine;1". Extensions can use this interface to check spelling or provide its own spell checker to editors.
203	mozIStorageAggregateFunction	Interfaces, Storage, XPCOM, XPCOM API Reference
		This is an interface that must be implemented by consumers. It allows consumers to add aggregate functions that are available to SQL queries and triggers. An aggregate function is a function that returns one value from a series of values. There are a number of already defined aggregate functions provided by SQLite. Objects implementing this interface can be registered with mozIStorageConnection.createAggregateFunction().
204	mozIStorageAsyncStatement	Stub
		An asynchronous SQL statement.
205	mozIStorageBindingParams	Interfaces, Interfaces:Scriptable, Storage
		The mozIStorageBindingParams interface is used to bind values to parameters prior to calling mozIStorageStatement.executeAsync().
206	mozIStorageBindingParamsArray	Interfaces, Interfaces:Scriptable, Storage
		The mozIStorageBindingParamsArray interface is a container for mozIStorageBindingParams objects, and is used to store sets of bound parameters that will be used by the mozIStorageStatement.executeAsync().
207	mozIStorageCompletionCallback
		This interface should be implemented to handle callbacks from asynchronous Storage API routines.
208	mozIStorageConnection	Interfaces, Storage, XPCOM, XPCOM API Reference
		For a general overview on how to use this interface, see Storage.
209	mozIStorageError	Interfaces, Storage
		The mozIStorageError interface represents errors returned by the Storage API, offering attributes to obtain the error code as well as a human-readable error message corresponding to the error that occurred.
210	mozIStorageFunction	Interfaces, Storage, XPCOM, XPCOM API Reference
		This is an interface that must be implemented by consumers. It allows consumers to add functions that are available to SQL queries and triggers. There are a number of already defined functions provided by SQLite. Objects implementing this interface can be registered with mozIStorageConnection.createFunction().
211	mozIStoragePendingStatement	Interfaces, Interfaces:Scriptable, Storage
		The mozIStoragePendingStatement interface represents a pending asynchronous database statement, and offers the cancel() method which allows you to cancel the pending statement.
212	mozIStorageProgressHandler	Interfaces, Storage, XPCOM, XPCOM API Reference
		The mozIStorageProgressHandler interface lets storage consumers receive callbacks during the execution of sqlite requests.
213	mozIStorageResultSet	Interfaces, Storage
		The mozIStorageResultSet interface represents a set of results from a storage statement.
214	mozIStorageRow	Interfaces, Storage
		The mozIStorageRow interface represents a row in the result set from a storage database query.
215	mozIStorageService	Interfaces, Interfaces:Scriptable, Storage, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		See mozIStorageConnection
216	mozIStorageStatement	Interfaces, Storage, XPCOM, XPCOM API Reference
		For an introduction on how to use this interface, see the Storage overview document.
217	mozIStorageStatementCallback
		The mozIStorageStatementCallback interface represents a callback handler that the Storage API calls with result, error, and completion notifications while handling asynchronous database queries.
218	mozIStorageStatementParams	Interfaces, Storage, XPCOM, XPCOM API Reference
		This interface has no defined properties, but has properties based on the named parameters found in the SQL from the statement it was accessed off of. For example, say you create a statement like so:
219	mozIStorageStatementRow	Interfaces, Storage, XPCOM, XPCOM API Reference
		This interface has no defined properties, but has properties based on the name of the columns in the SQL result from the statement it was accessed off of. For example, say you create a statement like so:
220	mozIStorageStatementWrapper	Interfaces, Storage, XPCOM, XPCOM API Reference
		The mozIStorageStatementWrapper interface is a storage statement wrapper. When you call the mozIStorageConnection interface's createStatement() method, you get a mozIStorageStatement which has just direct bindings to SQLITE. You can then wrap that statement with a wrapper, which implements nsIXPCScriptable and provides scriptable helpers letting you execute the statement as a function, access bind variables by name as properties, etc.
221	mozIStorageVacuumParticipant
		To create an instance of this interface, use the Category Manger, with the category "vacuum-participant".
222	mozIStorageValueArray	Interfaces, Storage, XPCOM, XPCOM API Reference
		The mozIStorageValueArray interface obtains provides methods to obtain data from a given result.
223	mozITXTToHTMLConv	Interfaces
		The mozITXTToHTMLConv interface is used to convert text into HTML format. Its primary use is in converting user-entered text into properly-formatted HTML.
224	mozIThirdPartyUtil	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Determine whether the given channel and its content window hierarchy is third party. This is done as follows:
225	mozIVisitInfo
		No summary!
226	mozIVisitInfoCallback	Interfaces, Interfaces:Scriptable, Places, Reference, XPCOM Interface Reference
		Called when a mozIPlaceInfo couldn't be processed.
227	mozIVisitStatusCallback	Interfaces, Interfaces:Scriptable, Places, Reference, XPCOM Interface Reference
		Called when the mozIAsyncHistory.isURIVisited() method's check to determine whether a given URI has been visited has completed. Implement this method to determine the results of the request.
228	nsIAbCard	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, thunderbird
		The nsIAbCard interface is used to represent and manipulate cards in the addressbook. Following a huge refactoring of the address book code, most of the documentation below is out of date. Properties aren't stored anymore on the card, except for a handful of them. Complex properties are expected to be accessed through a call to getProperty. See //github.com/RealityRipple/UXP/blob/master//mailnews/addrbook/public/nsIAbCard.idl for more details.
229	nsIAboutModule	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		A method to get the flags that apply to a given about: URI. The URI passed in is guaranteed to be one of the URIs that this module registered to deal with.
230	nsIAbstractWorker	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		No summary!
231	nsIAccelerometerUpdate	Interfaces, NeedsContent, XPCOM, XPCOM Interface Reference
		This method is only used in content tabs to receive nsIAcceleration data from the chrome process.
232	nsIAccessNode	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIAccessNode implementations are instantiated lazily. The nsIAccessNode tree for a given DOM window has a one to one relationship to the DOM tree. If the DOM node for this access node is "accessible", then a QueryInterface to nsIAccessible will succeed.
233	DOMNode
		No summary!
234	GetChildNodeAt
		No summary!
235	GetComputedStyleCSSValue
		No summary!
236	GetComputedStyleValue
		No summary!
237	accessibleDocument
		No summary!
238	firstChildNode
		No summary!
239	innerHTML
		For the DOM property, see Element.innerHTML.
240	language
		No summary!
241	lastChildNode
		No summary!
242	nextSiblingNode
		No summary!
243	numChildren
		No summary!
244	parentNode
		No summary!
245	previousSiblingNode
		No summary!
246	scrollTo
		No summary!
247	scrollToPoint
		No summary!
248	nsIAccessibilityService	Accessibility, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		No summary!
249	nsIAccessible	Accessibility, Interfaces, Interfaces:Scriptable, NeedsMarkupWork, XPCOM API Reference
		The nsIAccessible interface is a cross-platform interface that supports platform-specific accessibility APIs like MSAA and ATK. Contains the sum of what's needed to support IAccessible as well as ATK's generic accessibility objects.
250	Attributes
		Attributes of accessible.
251	ChildCount
		Number of accessible children.
252	Children
		Array of all this node's children.
253	DefaultKeyBinding
		Provides localized string of global keyboard accelerator for default action, such as Ctrl+O for Open file (Ctrl + O).
254	Description
		Accessible description -- long text associated with this node.
255	DoAction
		This method performs the accessible action at the given zero-based index. Action number 0 is the default action.
256	ExtendSelection
		This method extends the current selection from its current accessible anchor node to this accessible.
257	FirstChild
		Returns first child node in accessible tree.
258	FocusedChild
		Focused accessible child of node.
259	GetAccessibleAbove
		This method returns an accessible node geometrically above this one.
260	GetAccessibleBelow
		This method returns an accessible node geometrically below this one.
261	GetAccessibleRelated
		This method returns an accessible related to this one by the given relation type.
262	GetAccessibleToLeft
		This method returns an accessible node geometrically to the left of this one.
263	GetAccessibleToRight
		This method returns an accessible node geometrically to the right of this one.
264	GetActionDescription
		This method retrieves the description (localized name) of the accessible action at the given zero-based index.
265	GetActionName
		This method retrieves the name of the accessible action at the given zero-based index.
266	GetBounds
		This method returns accessible's (x and y) coordinates relative to the screen and accessible's width and height.
267	GetChildAt
		This method returns Nth accessible child using zero-based index.
268	GetChildAtPoint
		This method returns an accessible child which contains the coordinate at (x, y) in screen pixels.
269	GetKeyBindings
		This method provides array of localized string of global keyboard accelerator for the given action index supported by accessible.
270	GetRelation
		This method returns accessible relation for this accessible object by index.
271	GetRelations
		This method returns multiple accessible relations for this accessible object.
272	GetState
		This method retrieves states of the accessible.
273	GroupPosition
		This method returns grouping information. Used for tree items, list items, tab panel labels, radio buttons, etc. Also used for collectons of non-text objects.
274	Help
		Help text associated with node.
275	IndexInParent
		The 0-based index of this accessible in its parent's list of children, or -1 if this accessible does not have a parent.
276	KeyboardShortcut
		Provides localized string of accesskey name, such as Alt+D (Alt + D). The modifier may be affected by user and platform preferences. Usually alt+letter (Alt + letter), or just the letter alone for menu items.
277	LastChild
		Returns last child node in accessible tree.
278	Name
		Accessible name -- the main text equivalent for this node.
279	NextSibling
		Returns next sibling in accessible tree.
280	NumActions
		The number of accessible actions associated with this accessible.
281	Parent
		Returns parent node in accessible tree.
282	PreviousSibling
		Returns previous node in accessible tree.
283	RelationsCount
		Returns the number of accessible relations for this object.
284	Role
		Enumerated accessible role for the associated element. The values depend on platform because of variations. See the ROLE_* constants in roles documentation.
285	SetSelected
		This method adds or remove this accessible to the current selection.
286	TakeFocus
		This method focuses this accessible node.
287	TakeSelection
		This method selects this accessible node only.
288	Value
		Accessible value -- a number or a secondary text equivalent for this node. Widgets that use role attribute can force a value using the valuenow attribute.
289	nsIAccessibleCaretMoveEvent	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
290	nsIAccessibleCoordinateType	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Prior to Gecko 1.9, these constants were implemented in nsIAccessibleText.
291	nsIAccessibleDocument	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		You can QueryInterface to nsIAccessibleDocument from the nsIAccessible or nsIAccessNode for the root node of a document. You can also get one from nsIAccessNode.GetAccessibleDocument() or nsIAccessibleEvent.GetAccessibleDocument()
292	nsIAccessibleEditableText	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Copies the text range into the clipboard.
293	DeleteText	delete
		Documentation is now located at nsIAccessibleEditableText.DeleteText().
294	nsIAccessibleEvent	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		To listen to in-process accessibility invents, make your object an nsIObserver, and listen for accessible-event by using code something like this:
295	nsIAccessibleHyperLink	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns a reference to the object at the given index.
296	nsIAccessibleHyperText	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Retrieves the nsIAccessibleHyperLink object at the given link index.
297	GetLink
		No summary!
298	GetLinkIndex
		No summary!
299	LinkCount
		No summary!
300	nsIAccessibleImage	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Returns the coordinates of the image accessible.
301	GetImagePosition
		This content is now available at nsIAccessibleImage.GetImagePosition().
302	GetImageSize
		This content is now available at nsIAccessibleImage.GetImageSize().
303	nsIAccessibleProvider	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
304	nsIAccessibleRelation	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Returns accessible relation target at the given index.
305	GetTarget
		No summary!
306	GetTargets
		No summary!
307	RelationType
		This content is now available at nsIAccessibleRelation.Attributes.
308	TargetsCount
		No summary!
309	nsIAccessibleRetrieval	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Return an nsIAccessible for a DOM node in pres shell 0. Create a new accessible of the appropriate type if necessary, or use one from the accessibility cache if it already exists.
310	nsIAccessibleRole	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
311	nsIAccessibleScrollType	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
312	nsIAccessibleSelectable	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Adds the specified accessible child of the object to the object's selection. If the specified object is already selected, then it does nothing.
313	nsIAccessibleStateChangeEvent	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
314	nsIAccessibleStates	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Prior to Gecko 1.9, these constants were implemented in nsIAccessible.
315	nsIAccessibleTable	Accessibility, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference
		Return the accessible object at the specified row and column in the table. If both row and column index are valid then the corresponding accessible object is returned that represents the requested cell regardless of whether the cell is currently visible (on the screen).
316	nsIAccessibleTableCell	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
317	nsIAccessibleTableChangeEvent
		No summary!
318	nsIAccessibleText	Accessibility, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Get the accessible and start/end offsets around the given offset. This accessible get return the DOM node and layout frame with the uniform attributes for this range of text.
319	nsIAccessibleTextChangeEvent	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
320	nsIAccessibleTreeCache	Accessibility, Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		A private interface to operate with tree accessible.
321	nsIAccessibleValue	Accessibility, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		Return a success condition of the value getting set. That is if the value is within the range of minimumValue - maximumValue.
322	nsIAccessibleWin32Object	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
323	nsIAlertsService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		By default a message is displayed in a small window that slides up from the bottom of the screen, holds there for a few seconds, then slides down. The specific appearance varies from platform to platform.
324	nsIAnnotationObserver	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		This method is called when an annotation is deleted for an item. If aName is empty, then ALL annotations for the given item have been deleted. This is not called when annotations are expired (normally happens when the application exits).
325	nsIAnnotationService	Developing Mozilla, Extensions, Interface, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference, nsIAnnotationService
		Implemented by: "@mozilla.org/browser/annotation-service;1". To use this service, use:
326	nsIAppShell	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Creates an application shell.
327	nsIAppShellService	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/appshell/appShellService;1 as a service:
328	nsIAppStartup	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/toolkit/app-startup;1. To use the service:
329	nsIAppStartup_MOZILLA_2_0	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		In Gecko 4.0 this Interface was merged into the nsIAppStartup interface.
330	nsIApplicationCache	DOM, Interfaces, Interfaces:Scriptable, Offline_resources, XPCOM, XPCOM Interface Reference
		Each application cache has a unique client ID for use with nsICacheService.openSession() method, to access the cache's entries.
331	nsIApplicationCacheChannel	DOM, Interfaces, Interfaces:Scriptable, Offline_resources, XPCOM, XPCOM Interface Reference
		A shortcut method to mark the cache item of this channel as 'foreign'. See the 'cache selection algorithm' and CACHE_SELECTION_RELOAD action handling in nsContentSink.
332	nsIApplicationCacheContainer	DOM, Interfaces, Interfaces:Scriptable, Offline_resources, XPCOM, XPCOM Interface Reference
		No summary!
333	nsIApplicationCacheNamespace	App Cache, Interfaces, Interfaces:Scriptable, Mozilla, Offline, XPCOM, XPCOM Interface Reference, nsIAplicationCacheNamespace, resources
		Application caches can store a set of namespace entries that affect loads from the application cache. If a load from the cache fails to match on an exact cache entry, the namespace entries are searched for a substring match.
334	nsIApplicationCacheService	DOM, Interfaces, Interfaces:Scriptable, Offline_resources, XPCOM, XPCOM Interface Reference
		Flags the specified key as one that should be cached opportunistically.
335	nsIApplicationUpdateService	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Adds a listener that receives progress and state information about the update that is currently being downloaded. This information is most commonly used to update a user interface that informs the user as to the status of an update.
336	nsIArray	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An indexed collection of elements. Provides basic functionality for retrieving elements at a specific position, searching for elements. Indexes are zero-based, such that the last element in the array is stored at the index length-1.
337	nsIAsyncInputStream	Interfaces, Interfaces:Scriptable, NeedsContent, Streams, XPCOM API Reference, XPCOM Interface Reference
		If an input stream is non-blocking, it may return NS_BASE_STREAM_WOULD_BLOCK when read. The caller must then wait for the stream to have some data to read. If the stream implements nsIAsyncInputStream, then the caller can use this interface to request an asynchronous notification when the stream becomes readable or closed (via the AsyncWait() method).
338	nsIAsyncOutputStream	Interfaces, Interfaces:Scriptable, NeedsContent, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		If an output stream is non-blocking, it may return NS_BASE_STREAM_WOULD_BLOCK when written to. The caller must then wait for the stream to become writable. If the stream implements nsIAsyncOutputStream, then the caller can use this interface to request an asynchronous notification when the stream becomes writable or closed (via the AsyncWait() method).
339	nsIAsyncStreamCopier	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Starts the copy operation. The specified observer is notified when the copy completes.
340	nsIAsyncVerifyRedirectCallback	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
341	nsIAuthInformation	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The caller of nsIAuthPrompt2.promptUsernameAndPassword() or nsIAuthPrompt2.promptPasswordAsync() provides an object implementing this interface; the prompt implementation can then read the values here to prefill the dialog. After the user entered the authentication information, it should set the attributes of this object to indicate to the caller what was entered by the user.
342	nsIAuthModule	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method is called to get the next token in a sequence of authentication steps.
343	nsIAuthPrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface is implemented by @mozilla.org/login-manager/prompter;1. To create an instance, use:
344	nsIAuthPrompt2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This interface is usually acquired using getInterface on notification callbacks or similar. It can be used to prompt users for authentication information, either synchronously or asynchronously.
345	nsIAuthPromptAdapterFactory	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Wrap an object implementing nsIAuthPrompt so that it's usable via nsIAuthPrompt2.
346	nsIAuthPromptCallback	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Callers must call exactly one method if nsIAuthPrompt2.asyncPromptAuth() returns successfully. They must not call any method on this interface before nsIAuthPrompt2.asyncPromptAuth() returns.
347	nsIAuthPromptProvider	Authentication, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method requests a prompt interface for the given prompt reason.
348	nsIAuthPromptWrapper	Authentication, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIAuthPromptWrapper interface is an override of nsIAuthPrompt which performs some action on the data going through nsIAuthPrompt methods. Persisting data from the prompts and using it to pre-fill subsequent prompts would be one such action.
349	nsIAutoCompleteController	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/autocomplete/controller;1. To use this service, use:
350	nsIAutoCompleteInput	Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns the name of one of the autocomplete search session objects.
351	nsIAutoCompleteItem	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
352	nsIAutoCompleteListener	Interfaces, Interfaces:Scriptable, NeedsContent
		Called by the autocomplete session when the search is done or over. As of Gecko 1.9.1, can also be called with partial results, in a similar manner to the toolkit autocomplete interface.
353	nsIAutoCompleteObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when a search is complete and the results are ready.
354	nsIAutoCompleteResult
		See nsIAutoCompleteSearch
355	nsIAutoCompleteSearch	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Users call startSearch() and pass in an nsIAutoCompleteObserver when the search starts. Results can be sent to the listener either synchronously or asynchronously, depending on the implementation.
356	nsIBadCertListener2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Replaces the obsolete nsIBadCertListener interface.
357	nsIBidiKeyboard	BiDi, Interfaces, Interfaces:Scriptable, Right-to-left, XPCOM, XPCOM Interface Reference
		Determines if the current keyboard language is right-to-left.
358	nsIBinaryInputStream	File I/O, Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Reads from the stream.
359	nsIBinaryOutputStream	File I/O, Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Sets the stream to which output is directed.
360	nsIBlocklistPrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Prompt the user about newly blocked addons. The prompt is then responsible for soft-blocking any addons that need to be afterwards.
361	nsIBlocklistService	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		No summary!
362	nsIBoxObject	Interfaces, Interfaces:Scriptable, NeedsContent
		To get an instance, use the boxObject property.
363	nsIBrowserBoxObject
		The boxObject belonging to a XUL browser element implements this interface.
364	nsIBrowserHistory	Developing Mozilla, Extensions, Interfaces, JavaScript, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/nav-history-service;1. To use this service, use:
365	nsIBrowserSearchService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/search-service;1. To access this service, use:
366	nsICRLInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
367	nsICRLManager	Interfaces, Interfaces:Scriptable, NeedsContent, Security, XPCOM Interface Reference
		No summary!
368	nsICache	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsICache is a namespace for various cache constants. It does not represent an actual object.
369	nsICacheDeviceInfo	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
370	nsICacheEntryDescriptor	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method explicitly closes the descriptor (optional).
371	nsICacheEntryInfo	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method finds out whether or not the cache entry is stream based.
372	nsICacheListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method is called when the requested access (or appropriate subset) is acquired. The status parameter equals NS_OK on success. See nsICacheService for accessGranted values.
373	nsICacheMetaDataVisitor	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method is called for each key/value pair in the meta data for a cache entry.
374	nsICacheService	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method creates a cache session.
375	nsICacheSession	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method gives an asynchronous cache access. Does not block the calling thread. Instead, the listener will be notified when the descriptor is available.
376	nsICacheVisitor	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method is called to provide information about a cache device.
377	nsICachingChannel	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface provides:
378	nsICancelable	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Call this method to request that this object abort whatever operation it may be performing.
379	nsICategoryManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/categorymanager;1. To use this service, use:
380	addCategoryEntry
		No summary!
381	deleteCategory
		No summary!
382	deleteCategoryEntry
		No summary!
383	enumerateCategories
		No summary!
384	enumerateCategory
		No summary!
385	getCategoryEntry
		No summary!
386	nsIChannel	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Once a channel is created (via nsIIOService.newChannel()), parameters for that request may be set by using the channel attributes, or by calling QueryInterface() to retrieve a subclass of nsIChannel for protocol-specific parameters. Then, the URI can be fetched by calling open() or asyncOpen(). After a request has been completed, the channel is still valid for accessing protocol-specific results. For example, QueryInterfacing to nsIHttpChannel allows response headers to be retrieved for the corresponding http transaction.
387	nsIChannelEventSink	Channels, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Channels will try to get this interface from a channel's notificationCallbacks or, if not available there, from the loadGroup's notificationCallbacks.
388	nsIChannelPolicy	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This interface exists to allow the content policy mechanism to function properly during channel redirects. Channels can be created with this interface placed in the property bag and upon redirect, the interface can be transferred from the old channel to the new channel.
389	nsICharsetResolver	Interfaces, Interfaces:Scriptable, Obsolete, XPCOM, XPCOM Interface Reference
		Some implementations may request that they be notified when the charset is actually detected.
390	nsIChromeFrameMessageManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Loads a script into the remote frame.
391	nsIChromeRegistry	Interfaces, NeedsContent, Reference, Référence(2), XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/chrome/chrome-registry;1 as a service:
392	nsIClassInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Bitflags for 'flags' attribute.
393	classDescription
		No summary!
394	classID
		No summary!
395	classIDNoAlloc
		No summary!
396	flags
		No summary!
397	getHelperForLanguage
		No summary!
398	getInterfaces
		This content is now available at nsIClassInfo.getInterfaces().
399	implementationLanguage
		No summary!
400	nsIClipboard	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Most clipboard operations in Firefox use kGlobalClipboard, which is the one also used by the typical control-C/control-V keyboard shortcuts.
401	nsIClipboardCommands	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns whether we can copy an image's contents.
402	nsIClipboardDragDropHookList	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Within Gecko, this interface is used by calling get_Interface on a docshell.
403	nsIClipboardDragDropHooks	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Embedders who want to have these hooks made available should implement nsIClipboardDragDropHooks and use the command manager to send the appropriate commands with these parameters/settings:
404	nsIClipboardHelper	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method copies string to (default) clipboard.
405	nsIClipboardOwner	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIClipboardOwner interface notifies the clipboard owner about the current status of ownership of the clipboard transferable at given situation and time.
406	nsICollection	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Appends a new item to the collection.
407	nsICommandController	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), XPCOM Interface Reference, commands, controllers
		Implemented by: @mozilla.org/embedcomp/base-command-controller;1. To create an instance, use:
408	nsICommandLine	Command Line, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Components may implement the nsICommandLineHandler interface to add custom command line handling behavior.
409	nsICommandLineHandler	Command Line, Interfaces, Interfaces:Scriptable, XPCOM API Reference, XPCOM Interface Reference
		Each command line handler is registered in the category "command-line-handler". The entries in this category are read in alphabetical order, and each category value is treated as a service contract ID implementing this interface.
410	nsICommandLineRunner	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsICommandLineRunner is an extension of nsICommandLine used to initialize command lines and run them by processing the comand line handlers.
411	nsIComponentManager	Component Manager, Components, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Loads a "bootstrapped" chrome.manifest file from the specified directory or XPI file. A "bootstrapped" chrome manifest supports some of the instructions allowed in a regular chrome manifest, see the Chrome Registration documentation for details.
412	createInstanceByContractID
		No summary!
413	getClassObject
		No summary!
414	getClassObjectByID
		No summary!
415	nsIComponentRegistrar	Component Manager, Components, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Register a component (.manifest) file or all component files in a directory. Registration lasts for this run only, and is not cached.
416	CIDToContractID
		No summary!
417	autoRegister
		No summary!
418	autoUnregister
		No summary!
419	contractIDToCID
		No summary!
420	enumerateCIDs
		No summary!
421	enumerateContractIDs
		No summary!
422	isCIDRegistered
		No summary!
423	isContractIDRegistered
		No summary!
424	registerFactory
		No summary!
425	registerFactoryLocation
		No summary!
426	unregisterFactory
		No summary!
427	unregisterFactoryLocation
		No summary!
428	nsICompositionStringSynthesizer	DOM, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		This interface is obsoleted in Gecko 38. You need to use nsITextInputProcessor instead of this.
429	nsIConsoleListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called by the nsIConsoleService when a message is posted to the console. Listeners must first be attached to the service using nsIConsoleService.registerListener()
430	nsIConsoleMessage	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implementations may provide an object that can be Query Interfaced, nsISupports.QueryInterface(), to provide more specific message information. See nsIScriptError for an example.
431	nsIConsoleService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The console service is the back-end for the Error Console, bundled with every Mozilla application, and for Firefox's Web Console and Browser Console.
432	nsIContainerBoxObject	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		The boxObject belonging to a XUL browser, editor or iframe element implements this interface.
433	nsIContentFrameMessageManager	Interface Reference, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This interface provides the environment for scripts that are loaded into content frames using the nsIFrameScriptLoader interface. It enables these scripts to receive messages from the chrome process and send messages back to the chrome process.
434	nsIContentPref	Preferences, XPCOM
		No summary!
435	nsIContentPrefCallback2	Preferences, XPCOM, XPCOM Interface Reference
		Called when the method finishes. This will be called exactly once for each method invocation, and afterward no other callback methods will be called.
436	nsIContentPrefObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when a content preference is removed.
437	nsIContentPrefService	Interfaces, Interfaces:Scriptable, Preferences, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Use the asynchronous interface nsIContentPrefService2 instead.
438	nsIContentPrefService2	Interfaces, Interfaces:Scriptable, Preferences, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Content preferences allow the application to associate arbitrary data, or "preferences", with specific domains, or web "content". Specifically, a content preference is a structure with three values: a domain with which the preference is associated, a name that identifies the preference within its domain, and a value. (See nsIContentPref below.)
439	nsIContentSecurityPolicy	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Verifies ancestry as permitted by the policy.
440	nsIContentSniffer	Interfaces, Interfaces:Scriptable, MIME, Sniffer, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Given a chunk of data, determines a MIME type. Information from the given request may be used in order to make a better decision.
441	nsIContentView	Electrolysis, Interfaces, Interfaces:Scriptable, Mobile, XPCOM Interface Reference
		See Working with content views for details on how to use this API.
442	nsIContentViewManager	Electrolysis, Interfaces, Interfaces:Scriptable, Mobile, XPCOM Interface Reference
		To obtain a reference to the view manager for a document, you can QueryInterface() the nsIFrameLoader object to nsIContentViewManager. See Getting access to content views for details. Once you have the view manager, you can call getContentViewsIn() to get a list of the content views for a given portion of the browser display, then use those nsIContentView objects to manipulate the content views.
443	nsIContentViewer	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), XPCOM Interface Reference, needsattention
		Implemented by: ?????????????????????????????????????. To create an instance, use:
444	nsIController	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, commands
		When this method is called, your implementation should execute the command with the specified name.
445	nsIControllers	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, commands, controllers
		This interface is used to manage instances of the nsIController interface. Windows and text inputs have default controllers that allow commands such as cmd_copy to act on the focused element or window. XUL elements can also have controllers, although they do not have any default controllers.
446	nsIConverterInputStream	Interfaces, Interfaces:Scriptable, Streams, Unicode, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/converter-input-stream;1. To create an instance, use:
447	nsIConverterOutputStream	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/converter-output-stream;1. To create an instance, use:
448	nsICookie	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An optional interface for accessing the HTTP or javascript cookie object.
449	nsICookie2	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsICookie2 interface provides information about a cookie, and extends the nsICookie interface.
450	nsICookieAcceptDialog	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
451	nsICookieConsent	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Inherits from: nsISupports
452	nsICookieManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An optional interface for accessing or removing the cookies that are in the cookie list.
453	nsICookieManager2	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsICookieManager2 interface contains additional methods that expand upon the nsICookieManager interface.
454	nsICookiePermission	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
		The nsICookiePermission interface is used to test for cookie permissions
455	nsICookiePromptService	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsICookiePromptService interface is to open a dialog to ask to permission to accept the cookie.
456	nsICookieService	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		See nsICookieManager and nsICookieManager2 for methods to manipulate the cookie database directly. This separation of interface is mainly historical.
457	nsICookieStorage	Cookies, Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
458	nsICrashReporter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Add some extra data to be submitted with a crash report.
459	nsICryptoHMAC	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Hashing Algorithms. These values are to be used by the init() method to indicate which hashing function to use. These values map onto the values defined in mozilla/security/nss/lib/softoken/pkcs11t.h and are switched to CKM_*_HMAC constant.
460	nsICryptoHash	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		These constants are used by the init() method to indicate which hashing function to use. The values map directly onto the values defined in mozilla/security/nss/lib/cryptohi/hasht.h.
461	nsICurrentCharsetListener	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/currentcharsetlistener;1. To create an instance, use:
462	nsICycleCollectorListener	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		The order of calls will be call to begin(); then for every node in the graph a call to noteObject() and calls to noteEdge() for every edge starting at that node; then a call to beginDescriptions(); then for every black node in the cycle collector graph a call to either describeRefcountedObject() or to describeGCedObject(); and then a call to end(). If begin() returns an error none of the other functions will be called.
463	nsIDBChangeListener	Interfaces, Interfaces:Scriptable, Message Database, Messages, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIDBChangeListener interface is used by components wanting to receive notification when the current database changes somehow.
464	nsIDBFolderInfo
		Implemented by: ?????????????????????????????????????. To create an instance, use:
465	nsIDNSListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when an asynchronous host lookup completes.
466	nsIDNSRecord	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This function copies the value of the next IP address into the given PRNetAddr struct and increments the internal address iterator.
467	nsIDNSRequest	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called to cancel a pending asynchronous DNS request. The listener will passed to asyncResolve will be notified immediately with a status code of NS_ERROR_ABORT.
468	nsIDNSService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/dns-service;1. To access the service, use:
469	nsIDOMCanvasRenderingContext2D	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		The nsIDOMCanvasRenderingContext2D interface implements the DOM CanvasRenderingContext2D interface. See that page for details.
470	nsIDOMChromeWindow	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		On some operating systems, we must allow the window manager to handle window dragging. This method tells the window manager to start dragging the window. This method will fail unless called while the left mouse button is held down, callers must check this.
471	nsIDOMClientRect	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This object was renamed a few times: initial name was TextRectangle, then ClientRect, then DOMRect.
472	nsIDOMDesktopNotification	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMDesktopNotification interface implements the DOM notification interface. See that page for details.
473	nsIDOMDesktopNotificationCenter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMDesktopNotificationCenter interface implements the DOM navigator.mozNotification interface. See that page for details.
474	nsIDOMElement	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Get an attribute value.
475	nsIDOMEvent	Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XPCOM:DOM
		No summary!
476	nsIDOMEventGroup	DOM, Interface Reference, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Reports whether or not another event group is the same as this one.
477	nsIDOMEventListener	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIDOMEventListener interface implements the DOM EventListener interface. See that page for details.
478	nsIDOMEventTarget	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		See the EventTarget documentation.
479	nsIDOMFile	DOM, File I/O, Files, Firefox 3, Gecko, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
		The nsIDOMFile interface retrieves data from a file submitted to a form using the input type "file". This allows the file reference to be saved when the form is submitted while the user is using a web application offline, so that the data can be retrieved and uploaded once the Internet connection is restored.
480	nsIDOMFileError	DOM, File I/O, Files, Firefox, Firefox 3.6, Gecko, Gecko 1.9.2, Interfaces, Interfaces:Scriptable, XPCOM
		The nsIDOMFileError interface describes errors that occur while using the DOM File API. It implements the DOM FileError object; for details, please read that article.
481	nsIDOMFileException	DOM, Firefox 3, Interfaces, XPCOM, XPCOM API Reference
		The nsIDOMFileException interface represents exceptions that can be raised by calls to the methods in the nsIDOMFile interface.
482	nsIDOMFileList	DOM, Files, Firefox 3, Interfaces, XPCOM, XPCOM API Reference, drag and drop
		The nsIDOMFileList interface contains a list of nsIDOMFile objects describing the files selected by the user for a "file" input field on a web form.
483	nsIDOMFileReader	DOM, File I/O, Files, Interfaces, Interfaces:Scriptable
		The nsIDOMFileReader interface provides a way to read data from a file specified by an nsIDOMFile.
484	nsIDOMFontFace	Interfaces, Interfaces:Scriptable, NeedsContent
		This object describes a single font. It's returned in a list you can get using inIDOMUtils.getUsedFontFaces().
485	nsIDOMFontFaceList	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		Returns the nsIDOMFontFace object at the specified index into the list.
486	nsIDOMGeoGeolocation	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMGeoGeolocation interface provides access to geolocation information. You can request a single notification of the user's current position, or you can monitor the position over time.
487	nsIDOMGeoPosition	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
488	nsIDOMGeoPositionAddress	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This object is obtained from an nsIDOMGeoPositionAddress object via its address attribute.
489	nsIDOMGeoPositionCallback	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMGeoPositionCallback interface is called when updated position information is available. You need to implement this interface to accept callbacks after using nsIDOMGeolocation.watchPosition().
490	nsIDOMGeoPositionCoords	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIDOMGeoPositionCoords interface describes a geographical location.
491	nsIDOMGeoPositionError	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMGeoPositionError interface represents an error that occurred while performing geolocation operations.
492	nsIDOMGeoPositionErrorCallback	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMGeoPositionErrorCallback interface is used to represent an object that receives callback notifications when geolocation errors occur.
493	nsIDOMGeoPositionOptions	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMGeoPositionOptions interface is used to specify options for geolocation operations.
494	nsIDOMGlobalPropertyInitializer	NeedsContent, Reference, Référence(2), XPCOM, XPCOM Interface Reference
		An XPCOM component implementing this interface can be exposed to web content as a property on the window. See Custom window properties are a snap in Firefox blog post for details.
495	nsIDOMHTMLAudioElement	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		The nsIDOMHTMLAudioElement interface is used to implement the HTML5 <audio> element.
496	nsIDOMHTMLFormElement	XPCOM, XPCOM Interface Reference
		The nsIDOMHTMLFormElement interface implements the DOM HTMLFormElement interface. See that page for details.
497	nsIDOMHTMLMediaElement	Firefox 3.5, Gecko 1.9.1, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
498	nsIDOMHTMLSourceElement	DOM, HTML, HTML5, Interfaces, Interfaces:Scriptable, Media, XPCOM, XPCOM Interface Reference
		The nsIDOMHTMLSourceElement interface is the DOM interface to the source child of the audio and video media elements in HTML.
499	nsIDOMHTMLTimeRanges	Interfaces, Media, XPCOM Interface Reference
		The nsIDOMHTMLTimeRanges interface represents a set of time ranges in media; it's primarily used by the nsIDOMHTMLMediaElement interface, and implements the DOM TimeRanges interface.
500	nsIDOMJSWindow	Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		One of the interfaces implemented by the window DOM object.
501	nsIDOMMouseScrollEvent	DOM, Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM, XPCOM Interface Reference
		Initializes the progress event object.
502	nsIDOMMozNetworkStats	Interfaces, Reference, Référence(2), XPCOM
		Implemented by: @mozilla.org/networkStats;1. To create an instance, use:
503	nsIDOMMozNetworkStatsData	Interfaces, Network, XPCOM Interface Reference
		No summary!
504	nsIDOMMozNetworkStatsManager	Interfaces, Network, Reference, Référence(2), XPCOM Interface Reference
		NOTE: Gecko is a fast evolving project. Please check dom/network/interfaces/nsIDOMNetworkStatsManager.idl to make sure this data is accurate.
505	nsIDOMMozTouchEvent	Interfaces, XPCOM Interface Reference
		The nsIDOMMozTouchEvent interface describes a raw touch event. This provides a mechanism for working with events from touch screens. This differs from tracking mouse events in that touch events can be generated independently for each finger touching the screen. This lets you process multi-finger touch gestures and actions.
506	nsIDOMNSHTMLDocument	DOM, Document, Gecko, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		Provided for compatibility with Netscape 4.x, but does not actually do anything.
507	nsIDOMNavigatorDesktopNotification	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Property that extends the navigator object.
508	nsIDOMNode	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		No summary!
509	nsIDOMOfflineResourceList	Interfaces, XPCOM, XPCOM API Reference
		The nsIDOMOfflineResourceList interface provides access to the application cache that allows web content's resources to be cached locally for use while offline. It includes methods for adding resources to and removing resources from the cache, as well as for enumerating the dynamically managed resource list.
510	nsIDOMOrientationEvent	Acceleration, DOM, Gecko 1.9.2, Interfaces, Interfaces:Scriptable, Mobile, Orientation, XPCOM Interface Reference
		The nsIDOMOrientationEvent interface describes the event that can be delivered to DOM windows, providing information from the device's accelerometer, allowing code to determine the orientation of the device.
511	nsIDOMParser
		To create a DOMParser object from a web page or a chrome script running in a window, simply use new DOMParser(). When you create a DOMParser from a privileged script, you can pass parameters to the constructor, more on that below.
512	nsIDOMProgressEvent	Interfaces, Interfaces:Scriptable, Reference, XMLHttpRequest, XPCOM Interface Reference, nsIDOMProgressEvent, progress
		The nsIDOMProgressEvent is used in the media elements (<video> and <audio>) to inform interested code of the progress of the media download. This implementation is a placeholder until the specification is complete, and is compatible with the WebKit ProgressEvent.
513	nsIDOMSerializer	DOM, Interfaces, Interfaces:Scriptable
		Implemented by: @mozilla.org/xmlextras/xmlserializer;1. To create an instance, use:
514	nsIDOMSimpleGestureEvent	DOM, Gestures, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		The nsIDOMSimpleGestureEvent interface is the datatype for all Mozilla-specific simple gesture events in the Document Object Model.
515	nsIDOMStorage	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, sessionStorage
		A DOM window's session storage object can be retrieved from the window's sessionStorage attribute.
516	nsIDOMStorage2	DOM, Interfaces, globalStorage, localStorage, sessionStorage
		The nsIDOMStorage2 interface represents the storage space used for local storage in the DOM. Items stored in local storage may only be accessed by the same origin that created the items in the first place.
517	nsIDOMStorageEventObsolete	Gecko, Interfaces, Interfaces:Scriptable, Mozilla, XPCOM, XPCOM Interface Reference, globalStorage, localStorage, sessionStorage
		When a DOM storage event is received, the recipient can check its domain attribute to determine which domain's data store has changed. If the value of the domain attribute is "#session", then the session storage has changed.
518	nsIDOMStorageItem	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, localStorage, sessionStorage
		No summary!
519	nsIDOMStorageList	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference, globalStorage
		Called when the list of available access points changes.
520	nsIDOMStorageManager	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, localStorage
		Implemented by @mozilla.org/dom/storagemanager;1 as a service:
521	nsIDOMStorageWindow	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		In Gecko 8.0 this interface has been merged into nsIDOMWindow, and this interface has been removed.
522	nsIDOMUserDataHandler	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		This method is a callback which will be called if a node with user data is being cloned, imported or adopted.
523	nsIDOMWindow	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XPCOM:DOM
		While this interface is not officially defined by any standard bodies, it originates from the de-facto DOM Level 0 standard.
524	nsIDOMWindow2	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Because nsIDOMWindow is frozen, this interface was introduced in Firefox 3 (Gecko 1.9) to allow DOM windows to take on new features. DOM windows implement nsIDOMWindow2, which is a subclass of nsIDOMWindow.
525	nsIDOMWindowInternal	Interface, Interfaces, Interfaces:Scriptable, Mozilla, Reference, XPCOM, XPCOM Interface Reference, XPCOM:DOM, nsIDOMWindowInternal
		It provides many of the common functions used in JavaScript such as alert() or open().
526	nsIDOMWindowUtils	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Implemented by: Window. To get this interface, use:
527	nsIDOMXPathEvaluator	DOM, Interfaces, Interfaces:Scriptable, XPCOM API Reference, XPCOM Interface Reference, XPath
		Implemented by: @mozilla.org/dom/xpath-evaluator;1. To create an instance, use:
528	nsIDOMXPathException	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XPath
		No summary!
529	nsIDOMXPathExpression	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XPath
		Evaluate the XPath expression.
530	nsIDOMXPathResult	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XPath
		Iterates through the available nodes of an UNORDERED_NODE_ITERATOR_TYPE or ORDERED_NODE_ITERATOR_TYPE result.
531	nsIDOMXULControlElement	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		No summary!
532	nsIDOMXULElement	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Attempts to remove focus from the element.
533	nsIDOMXULLabeledControlElement	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		No summary!
534	nsIDOMXULSelectControlElement	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		No summary!
535	nsIDOMXULSelectControlItemElement	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
536	nsIDataSignatureVerifier	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Verifies that the data matches the data that was used to generate the signature.
537	nsIDebug	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Note: C/C++ consumers who are planning to use the nsIDebug interface with the @mozilla.org/xpcom;1 contract should use NS_DebugBreak() from XPCOM glue instead, or alternatively the NS_ABORT, NS_ASSERTION, NS_BREAK, and NS_WARNING macros, which also call NS_DebugBreak() if used in a debugging build.
538	nsIDebug2	Debugging, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		No summary!
539	nsIDeviceMotion	Acceleration, Interfaces, Interfaces:Scriptable, Mobile, Orientation, XPCOM, XPCOM Interface Reference
		When called, the accelerometer support implementation must begin to notify the specified nsIDeviceMotionListener by calling its nsIDeviceMotionListener.onAccelerationChange() method as appropriate to share updated acceleration data.
540	nsIDeviceMotionData	Acceleration, DOM, Interfaces, Interfaces:Scriptable, Mobile, Orientation, XPCOM, XPCOM Interface Reference
		The values of x, y, and z can range from -1 to 1, where 0 means the device is balanced on that axis. See Accelerometer values explained for details.
541	nsIDeviceMotionListener	Acceleration, Interfaces, Interfaces:Scriptable, Mobile, Orientation, XPCOM, XPCOM Interface Reference
		Called when new orientation or acceleration data is available.
542	nsIDialogCreator	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
543	nsIDialogParamBlock	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Get a previously set integer.
544	nsIDictionary	Interface Reference, Interfaces, Interfaces:Scriptable, Obsolete, XPCOM, XPCOM API Reference
		Check if a given key is present in the dictionary.
545	nsIDirIndex	Directories, File I/O, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
		No summary!
546	nsIDirIndexListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called for each directory entry.
547	nsIDirIndexParser	Directories, File I/O, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called for each directory entry.
548	nsIDirectoryEnumerator	Directories, File I/O, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Closes the directory being enumerated, releasing the system resource. It is safe to call this function many times.
549	nsIDirectoryIterator	Directories, File I/O, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		The nsIDirectoryIterator interface provides a way to iterate over the entries in a directory.
550	nsIDirectoryService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Initializes the nsIDirectoryService instance.
551	init
		This content is now available at nsIDirectoryService.init().
552	registerProvider
		This content is now available at nsIDirectoryService.registerProvider().
553	unregisterProvider
		This content is now available at nsIDirectoryService.unregisterProvider().
554	nsIDirectoryServiceProvider	Directories, File I/O, Files, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		nsIDirectoryServiceProvider.
555	getFile	Mozilla, Reference, Référence(2), XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called by the Directory Service to obtain an nsIFile object corresponding for a given standard path location.
556	nsIDirectoryServiceProvider2	Directories, File I/O, Files, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The directory service calls this when it gets a request for a prop and the requested type is nsISimpleEnumerator.
557	getFiles	XPCOM, XPCOM API Reference
		This method is called by the Directory Service to query an enumeration of file or directory locations.
558	nsIDiskCacheStreamInternal	Interfaces, Interfaces:Scriptable, NeedsContent
		We use this method internally to close nsDiskCacheOutputStream under the cache service lock.
559	nsIDispatchSupport	Interfaces, XPCOM, XPCOM Interface Reference
		Converts a COM Variant to a jsval.
560	nsIDocShell	DocShell, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		Implemented by @mozilla.org/docshell;1. Do not create an instance directly. Instead, retrieve an nsIDocShell from a browser or other document container element. Note that out-of-process browsers do not have an nsIDocShell; instead you can access the nsIDocShell object from a frame script.
561	nsIDocumentLoader	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), XPCOM Interface Reference
		Implemented by: @mozilla.org/docloaderservice;1. To create an instance, use:
562	nsIDownload	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
563	nsIDownloadHistory	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Method overview
564	nsIDownloadManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/download-manager;1. To get the service, use:
565	nsIDownloadManagerUI	Firefox 3, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Calls attention to the Download Manager's user interface if it's already open. The UI need not be visible to call this function, nor will the UI be made visible.
566	nsIDownloadObserver	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Called to signal a download that has completed.
567	nsIDownloadProgressListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		To use simply implement this interface in your code, then call nsIDownloadManager.addListener() to start listening.
568	nsIDownloader	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Initialize this downloader.
569	nsIDragDropHandler	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, drag and drop
		nsIDragDropHandler is an interface for communicating with the built-in drag and drop implementation in the content area. Use this to register where the listeners should attach (something that implements nsPIDOMEventTarget which is what we end up using under the hood).
570	nsIDragService	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM API Reference, XPCOM Interface Reference
		Programmatically changes the drag position of the drag session. This is used on Mac and Windows to update the position of a popup being used as a drag image during the drag operation. It's not used on GTK, which handles the drag popup itself.
571	nsIDragSession	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, drag and drop
		Gets data from a drag and drop operation. Can be called while the drag is in process or after the drop has completed.
572	nsIDroppedLinkHandler	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Determines if a link being dragged can be dropped.
573	nsIDroppedLinkItem	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
574	nsIDynamicContainer	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The service can fill result nodes directly into the container when it is opened. It can use the property bag on every result node to store data associated with each item, such as a full path on disk. It can also create additional containers for each container, registered to its service.
575	nsIEditor	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), XPCOM API Reference, XPCOM Interface Reference
		No summary!
576	nsIEditorBoxObject	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The boxObject belonging to a XUL editor element implements this interface.
577	nsIEditorDocShell	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Use nsIEditingSession.makeWindowEditable() and nsIEditingSession.getEditorForWindow() from out side.
578	nsIEditorIMESupport	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Handles the start of inline input composition.
579	nsIEditorLogging	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Start logging.
580	nsIEditorMailSupport	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Get a list of IMG and OBJECT tags in the current document.
581	nsIEditorObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called after the editor completes a user action.
582	nsIEditorSpellCheck	Interfaces, Interfaces:Scriptable, Midas, NeedsMarkupWork, Reference, Référence(2), Spell check, XPCOM Interface Reference
		Implemented by: @mozilla.org/editor/editorspellchecker;1. To create an instance, use:
583	nsIEffectiveTLDService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/effective-tld-service;1. To use this service, use:
584	nsIEnumerator	Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		nsIEnumerator.idl
585	nsIEnvironment	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/process/environment;1 as a service:
586	nsIErrorService	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Implemented by: @mozilla.org/xpcom/error-service;1
587	nsIEventListenerInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Returns the debugger object if the debug service is active.
588	nsIEventListenerService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/eventlistenerservice;1. To create an instance, use:
589	nsIEventSource	Interfaces, Interfaces:Scriptable, Server-sent events
		This implements the EventSource interface used for server-sent events.
590	nsIEventTarget	Threads, XPCOM, XPCOM Interface Reference
		Dispatches an event to this event target. This function may be called from any thread, and it may be called re-entrantly.
591	nsIException	Interfaces, Interfaces:Scriptable, Reference, XPCOM, XPCOM Interface Reference
		A generic formatter - make it suitable to print, etc.
592	nsIExtensionManager	Disambiguation, NeedsContent, NeedsHelp, XPCOM, XPCOM Interface Reference
		Unfortunately, at the time of this writing there are two nsIExtensionManager Interfaces:
593	nsIExternalHelperAppService	Interfaces, MIME
		Implemented by: @mozilla.org/uriloader/external-helper-app-service;1. To access this service, use:
594	nsIExternalProtocolService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		You can ask the external protocol service if it has an external handler for a given protocol scheme. And you can ask it to load the url using the default handler.
595	nsIExternalURLHandlerService	Interfaces, Interfaces:Scriptable
		Given a URL, looks up the handler info from the operating system. This should be overridden by each operating systems implementation.
596	nsIFTPChannel	Channels, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		The nsIFTPChannel is an extension of nsISupports used to determine if a channel is an FTP channel, and offering additional information about the FTP channel.
597	nsIFTPEventSink	Channels, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		The nsIFTPEventSink is an extension of nsISupports. It can be used as a notification callback on an FTP channel.
598	nsIFactory	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM, XPCOM API Reference, XPCOM Interface Reference, needsattention
		Creates an instance of the class associated with this factory. Unlike getService, this returns a new instance each time it is called. (See also nsIComponentManager.createInstance.)
599	createInstance
		No summary!
600	lockFactory
		No summary!
601	nsIFaviconDataCallback	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when the required favicon's information is available.
602	nsIFaviconService	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/favicon-service;1. To use this service, use:
603	nsIFeed	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
604	nsIFeedContainer	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Synchronizes a container's fields with its convenience attributes.
605	nsIFeedElementBase	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki link
606	nsIFeedEntry	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki lin
607	nsIFeedGenerator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki link
608	nsIFeedPerson	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki link
609	nsIFeedProcessor	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/feed-processor;1. To create an instance, use:
610	nsIFeedProgressListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called after each entry or item is processed. If the document is a standalone item or entry, the HandleFeedAtFirstEntry() method will not already have been called, and the received nsIFeedEntry will have a null parent value.
611	nsIFeedResult	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Registers a prefix for a namespace used to access an extension in the feed or entry.
612	nsIFeedResultListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when feed processing is complete. Even if an error occurred during processing, there may be valid data available for feed-level data or entries processed before the error occurred. If you don't care about doing progress display or the like, this is all you need to implement in order to receive the parsed feed.
613	nsIFeedTextConstruct	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/feed-textconstruct;1, but users usually don't need to create instances of this directly. Various other feed-related interfaces, such as nsIFeed, nsIFeedEntry, and nsIFeedContainer have attributes that return objects implementing nsIFeedTextConstruct.
614	nsIFile	File I/O, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		nsIFile is the correct platform-agnostic way to specify a file; you should always use this instead of a string to ensure compatibility.
615	append
		No summary!
616	appendNative
		No summary!
617	clone
		No summary!
618	contains
		No summary!
619	copyTo
		No summary!
620	copyToFollowingLinks
		No summary!
621	copyToFollowingLinksNative
		This content is now available at nsIFile.copyToFollowingLinksNative().
622	copyToNative
		No summary!
623	create
		No summary!
624	createUnique
		No summary!
625	directoryEntries
		No summary!
626	equals
		No summary!
627	exists
		No summary!
628	fileSize
		No summary!
629	fileSizeOfLink
		No summary!
630	isDirectory
		No summary!
631	isExecutable
		No summary!
632	isFile
		No summary!
633	isHidden
		No summary!
634	isReadable
		No summary!
635	isSpecial
		No summary!
636	isSymlink
		No summary!
637	isWritable
		No summary!
638	lastModifiedTime
		No summary!
639	lastModifiedTimeOfLink
		No summary!
640	leafName
		No summary!
641	moveTo
		No summary!
642	moveToNative
		No summary!
643	nativeLeafName
		No summary!
644	nativePath
		No summary!
645	nativeTarget
		No summary!
646	normalize
		No summary!
647	parent
		No summary!
648	path
		No summary!
649	permissions	XPCOM, XPCOM API Reference
		No summary!
650	permissionsOfLink
		No summary!
651	remove
		No summary!
652	target
		This content is now available at nsIFile.Attributes.
653	nsIFileInputStream	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
654	nsIFileOutputStream	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
655	nsIFilePicker	File I/O, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/filepicker;1. To create an instance, use:
656	nsIFileProtocolHandler	File I/O, Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Converts the URL string into the corresponding nsIFile if possible. A local file will be created if the URL string begins with file://.
657	nsIFileSpec
		Declared in xpcom/obsolete/nsIFileSpec.idl
658	nsIFileStreams	File I/O, Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
659	nsIFileURL	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
660	nsIFileUtilities
		Long gone.
661	nsIFileView	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIFileView provides a configuration interface to @mozilla.org/filepicker/fileview;1 , which also implements nsITreeView so that it can be passed as a tree view.
662	nsIFocusManager	Interfaces, Interfaces:Scriptable, NeedsContent
		Implemented by: @mozilla.org/focus-manager;1 as a service:
663	nsIFormHistory2	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Adds a name and value pair to the form history.
664	nsIFrameLoader	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Activates event forwarding from client (remote frame) to parent.
665	nsIFrameLoaderOwner
		Returns the frame loader object owned by this object.
666	nsIFrameMessageListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This interface is used when implementing out-of-process handling of frames; the process handling a frame should implement this interface in order to receive messages.
667	nsIFrameMessageManager	Gecko, Interface, Obsolete, Reference, XPCOM, XPCOM Interface Reference
		Adds a message listener to the local frame. This listener will receive messages sent from the remote frame.
668	nsIFrameScriptLoader
		This interface is used to load frame scripts.
669	nsIGSettingsCollection	Interfaces, Interfaces:Scriptable, NeedsContent
		No summary!
670	nsIGSettingsService	Interfaces, Interfaces:Scriptable, NeedsContent
		Implemented by: @mozilla.org/gsettings-service;1 as a service:
671	nsIGeolocationProvider	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This must be called on the main thread Interface provides location information to the nsGeolocator via the nsIDOMGeolocationCallback interface. After startup() is called, any geo location change should call callback.update().
672	nsIGeolocationUpdate	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Interface provides a way for a geolocation provider to notify the system that a new location is available.
673	nsIGlobalHistory	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Add a page to the history.
674	nsIGlobalHistory2	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Add a URI to global history.
675	nsIGlobalHistory3	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface was originally created as part of nsIGlobalHistory2, but was split off during the transition to Places.
676	nsIHTMLEditor	Interfaces, Interfaces:Scriptable, NeedsContent
		Registers a default style property with the editor.
677	nsIHTTPHeaderListener	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), XPCOM Interface Reference
		No summary!
678	nsIHapticFeedback	Interfaces, Interfaces:Scriptable, Mobile, XPCOM Interface Reference
		Implemented by: @mozilla.org/widget/hapticfeedback;1 as a service:
679	nsIHttpActivityDistributor	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: mozilla.org/network/http-activity-distributor;1 as a service:
680	nsIHttpActivityObserver	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when activity occurs on the HTTP transport. You should implement this method to perform whatever tasks you wish to perform when HTTP activity occurs.
681	nsIHttpChannel	Channels, HTTP, Interface Reference, Interfaces, Interfaces:Scriptable, Network, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		To create an HTTP channel, use nsIIOService with a HTTP URI, for example:
682	nsIHttpChannelInternal	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Gets the request's major and minor version numbers.
683	nsIHttpHeaderVisitor	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called by the nsIHttpChannel implementation when visiting request and response headers. This method can throw an exception to terminate enumeration of the channel's headers.
684	nsIHttpServer
		No summary!
685	nsIHttpUpgradeListener	HTTP, Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		This is used, for example, by WebSockets in order to upgrade an HTTP channel to use the WebSocket protocol.
686	nsIIDNService	DNS, Interface Reference, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
		Implemented by: @mozilla.org/network/idn-service;1 as a service:
687	nsIIFrameBoxObject
		The boxObject belonging to a XUL iframe element implements this interface.
688	nsIINIParser	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Typically, you'll create an nsIINIParser object by calling nsIINIParserFactory.createINIParser(). Also, if you need to write to an INI file, use nsIINIParserWriter.
689	nsIINIParserFactory	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		See Example for how to use this interface.
690	nsIINIParserWriter	Files, Mozilla, Reference, Référence(2), XPCOM, XPCOM Interface Reference
		This interface provides methods that allow writing to INI-format configuration files. INI files contain zero or more sections, denoted by a name in square brackets, followed by zero or more lines of text with a property name on the left, then an equals sign ("="), then the value of the property.
691	nsIIOService	Channels, I/O, Interfaces, Interfaces:Scriptable, URIs, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface duplicates many of the nsIProtocolHandler methods in a protocol handler independent way (For example newURI() inspects the scheme in order to delegate creation of the new URI to the appropriate protocol handler).
692	nsIIdleService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		You can get the idle time directly, but in most cases you will want to register an observer for a predefined interval. The observer will get an 'idle' notification when the user is idle for that interval (or longer), and receive a 'back' (Gecko 3 to 15) or 'active' (Gecko 16+) notification when the user starts using their computer again.
693	nsIInProcessContentFrameMessageManager	Interfaces, XPCOM, XPCOM Interface Reference
		None.
694	nsIInputStream	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An input stream may be "blocking" or "non-blocking" (see the isNonBlocking() method). A blocking input stream may suspend the calling thread in order to satisfy a call to close(), available(), read(), or readSegments(). A non-blocking input stream, on the other hand, must not block the calling thread of execution.
695	available
		No summary!
696	close
		No summary!
697	isNonBlocking
		No summary!
698	read
		No summary!
699	readSegments
		No summary!
700	nsIInputStreamCallback	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		Called to indicate that the stream is either readable or closed.
701	nsIInstallLocation	Add-ons, Extensions, Interfaces, Themes, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		You can get the install location of a particular add-on using nsIExtensionManager interface:
702	nsIInterfaceRequestor	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This is similar to nsISupports.QueryInterface(). The main difference is that interfaces returned are not required to provide a way back to the object implementing nsIInterfaceRequestor. The semantics of nsISupports.QueryInterface() dictate that given an interface A that you nsISupports.QueryInterface() on to get to interface B, you must be able to nsISupports.QueryInterface() on B to get back to A. nsIInterfaceRequestor, however, allows you to obtain an interface C from A that may (or most likely) will not have the ability to get back to A.
703	getInterface
		No summary!
704	nsIJSCID	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		None.
705	nsIJSID	Interfaces, Interfaces:Scriptable, XPCOM API Reference, XPCOM Interface Reference
		The following methods return objects that implement this interface:
706	nsIJSIID	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
707	nsIJSON	Interfaces, Interfaces:Scriptable, NeedsExample, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/dom/json;1. To create an instance, use:
708	nsIJetpack	Interfaces, Interfaces:Scriptable, Jetpack, XPCOM, XPCOM Interface Reference
		This method asynchronously sends a message to the Jetpack process.
709	nsIJetpackService	Interfaces, Interfaces:Scriptable, Jetpack, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/jetpack/service;1.
710	nsIJumpListBuilder	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Jump lists are built and then applied. Modifying an applied jump list is not permitted. Callers should begin the creation of a new jump list using initListBuild(), add sub lists using addListToBuild(), then commit the jump list using commitListBuild(). Lists are built in real-time during the sequence of build calls, make sure to check for errors on each individual step.
711	nsIJumpListItem	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Compare this item to another.
712	nsILivemarkService	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/livemark-service;2. To use this service, use:
713	nsILoadGroup	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, loadgroup
		Adds a new request to the group. This will cause the default load flags to be applied to the request. If this is a foreground request then the groupObserver's onStartRequest will be called.
714	nsILocalFile	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/file/local;1. To create an instance, use:
715	nsILocalFileMac	File I/O, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		None.
716	nsILocale	Interfaces, Interfaces:Scriptable, Localization, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Retrieves a string with the current locale name.
717	nsILocaleService	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/nslocaleservice;1. To use this service, use:
718	nsILoginInfo	Firefox 3, Interfaces, Interfaces:Scriptable, Login Manager, Thunderbird 3, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		nsILoginInfo is an object containing information for a login stored by the Login Manager.
719	nsILoginManager	Firefox 3, Interfaces, Interfaces:Scriptable, Login Manager, Thunderbird 3, XPCOM, XPCOM API Reference, thunderbird
		Replaces nsIPasswordManager which was used in older versions of Gecko.
720	Using nsILoginManager	Firefox 3, Interfaces, Login Manager, Thunderbird 3, XPCOM, XPCOM API Reference, thunderbird
		Extensions often need to securely store passwords to external sites, web applications, and so on. To do so securely, they can use nsILoginManager, which provides for secure storage of sensitive password information and nsILoginInfo, which provides a way of storing login information.
721	nsILoginManagerCrypto	Cryptography, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Decrypts the specified string, returning the plain text value.
722	nsILoginManagerIEMigrationHelper	Interfaces, Interfaces:Scriptable, Login Manager, XPCOM Interface Reference
		Takes a login provided from nsIEProfileMigrator, migrates it to the current login manager format, and adds it to the list of stored logins.
723	nsILoginManagerPrompter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/login-manager/prompter;1. To call this service, use:
724	nsILoginManagerStorage	Interfaces, Interfaces:Scriptable, Login Manager, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		For example, if you wish to provide operating system integration with a native password manager system, implementing and registering a storage module for the Login Manager is how you do it. See Creating a Login Manager storage module for details.
725	nsILoginMetaInfo	Firefox 3.5, Interfaces, Interfaces:Scriptable, Login Manager, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		You can specifically modify these values by passing changes into nsILoginManager.modifyLogin() using an nsIPropertyBag2 object as the input.
726	nsIMIMEInputStream	Interfaces, Interfaces:Scriptable, MIME
		Implemented by: @mozilla.org/network/mime-input-stream;1. To create an instance, use:
727	nsIMacDockSupport	Dock, Interfaces, Interfaces:Scriptable, Mac OS X, XPCOM Interface Reference
		Implemented by: @mozilla.org/cookie-monster;1. To create an instance, use:
728	nsIMarkupDocumentViewer	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), XPCOM Interface Reference
		Scroll the make the specified node visible.
729	nsIMemory	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, memory
		nsIMemory is used to allocate and deallocate memory segments from a heap. The implementation is free to define the heap. NS_GetMemoryManager returns the global nsIMemory instance.
730	alloc
		No summary!
731	free
		No summary!
732	heapMinimize
		No summary!
733	isLowMemory
		No summary!
734	realloc
		No summary!
735	nsIMemoryMultiReporter	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		If you want to gather multiple measurements in a single operation (such as a single traversal of a large data structure), you can use a multi-reporter to do so. The callback, which must implement the nsIMemoryMultiReporterCallback interface, receives values that match the fields in the nsIMemoryReporter object.
736	nsIMemoryMultiReporterCallback	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Called to provide information from a multi-reporter. Implement this method to handle the report information.
737	nsIMemoryReporter	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Any piece of code that wishes to allow its memory use to be monitored may create an nsIMemoryReporter object and then register it by calling nsIMemoryReporterManager.registerReporter(). Once that has been done, the reporter will be found by any client accessing the enumerator returned by nsIMemoryReporterManager.enumerateReporters(). This includes the about:memory page.
738	nsIMemoryReporterManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by @mozilla.org/memory-reporter-manager;1 as a service:
739	nsIMenuBoxObject	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		To get access to the box object for a given menu, use code like this:
740	nsIMessageBroadcaster
		Message "broadcasters" don't have a single "other side" that they send messages to, but rather a set of subordinate message managers. For example, broadcasting a message through a window message manager will broadcast the message to all frame message managers within its window.
741	nsIMessageListener
		This interface is used to receive messages sent using the nsIMessageBroadcaster, nsIMessageSender, or nsISyncMessageSender interfaces. Listeners are attached using the nsIMessageListenerManager interface.
742	nsIMessageListenerManager	Interfaces, Interfaces:Scriptable, Message Manager, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/globalmessagemanager;1. To access this service, use:
743	nsIMessageSender
		Message senders enable clients to send asynchronous messages to a single "other side". For example, a child-process message manager will send messages that are only delivered to its one parent-process message manager.
744	nsIMessageWakeupService	Interfaces, XPCOM Interface Reference
		The parentprocessmessagemanager is used for this, so messages send from childprocessmessagemanagers will be heard.
745	nsIMessenger	Interfaces, Interfaces:Scriptable, Messages, NeedsContent, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMessenger interface provides functions for managing the history, undo and redo operations, and for loading, saving, or deleting messages and attachments in mailnews.
746	nsIMicrosummary	Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Add a microsummary observer to this microsummary.
747	nsIMicrosummaryGenerator	Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Calculates the interval until the microsummary should be updated for the next time, depending on the page content. If the generator doesn't specify an interval, null is returned.
748	nsIMicrosummaryObserver	Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when an observed microsummary updates its content. Since an observer might watch multiple microsummaries at the same time, the microsummary whose content has been updated gets passed to this handler.
749	nsIMicrosummaryService	Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/microsummary/service;1 as a service:
750	nsIMicrosummarySet	Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Add a microsummary observer to this microsummary set. Adding an observer to a set is the equivalent of adding it to each constituent microsummary.
751	nsIMimeConverter
		The nsIMimeConverter service allows you to convert headers into and out of MIME format.
752	nsIMimeHeaders	Interfaces, XPCOM, XPCOM Interface Reference
		Implemented by: ?????????????????????????????????????. To create an instance, use:
753	nsIModule	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method may be queried to determine whether or not the component module can be unloaded by XPCOM.
754	canUnload
		No summary!
755	getClassObject
		No summary!
756	registerSelf
		No summary!
757	unregisterSelf
		No summary!
758	nsIMsgAccount
		Adds a new identity to this account.
759	nsIMsgAccountManagerExtension	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		The nsIMsgAccountManagerExtension interface is used to add a new panel to Thunderbird's Account Manager.
760	Building an Account Manager Extension
		As first step we have to implement the nsIAccountManagerExtension. We name the Extension "devmo-account" and state that it is located in the Chrome Package "example@mozilla.org". Furthermore we show the new panel only for IMAP accounts...
761	nsIMsgCompFields	Interfaces, XPCOM, XPCOM Interface Reference, thunderbird
		The nsIMsgCompFields interface provides properties for an composition of an outgoing message.
762	nsIMsgCustomColumnHandler	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgCustomColumnHandler interface allows you to create custom handlers for columns. It can be used in the Thunderbird threadpane for extensions to overlay their own columns.
763	nsIMsgDBHdr	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, thunderbird
		The nsIMsgDBHdr interface describes headers for mail messages.
764	nsIMsgDBView	Interfaces, Interfaces:Scriptable, Message Database, Message Windows, Messages, NeedsContent, NeedsMarkupWork, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgDBView interface handles the display of mail in the threadpane and preview pane of Thunderbird and other XPCOM based mail cients.
765	nsIMsgDBViewCommandUpdater	Interfaces, Interfaces:Scriptable, Messages, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgDBViewCommandUpdater interface controls changes that occur as the selection changes.
766	nsIMsgDatabase	Interfaces, Interfaces:Scriptable, Message Database, Messages, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgDatabase interface is an abstract interface used to access the mail database backend.
767	nsIMsgFilter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		No summary!
768	nsIMsgFilterCustomAction
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterCustomAction.idl
769	nsIMsgFilterList	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterList.idl
770	nsIMsgFolder	Interfaces, Interfaces:Scriptable, Message Database, Messages, NeedsContent, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgFolder interface is used to interact with folders in Thunderbird. This page is out of date. Check http://mxr.mozilla.org/comm-central/...Folder.idl#706 for the newer methods (esp. isSpecialFolder and such).
771	nsIMsgHeaderParser	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ mime/ public/ nsIMsgHeaderParser.idl
772	nsIMsgIdentity	Interfaces, Interfaces:Scriptable, Message Database, Messages, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgIdentity interface contains all the personal outgoing mail information for a given person. Each identity is identified by a key, which is the id string in the identity preferences, such as in mail.identity.<id>.replyTo.
773	nsIMsgIncomingServer
		this is really dangerous. this destroys all pref values do not call this unless you know what you're doing!
774	nsIMsgMessageService	Interfaces, Interfaces:Scriptable, NeedsMarkupWork, XPCOM, XPCOM Interface Reference, thunderbird
		Objects that implements nsIMsgMessageService give the user top level routines related to messages like copying, displaying, attachment's manipulation, printing, streaming the message content to eml format string, etc.
775	nsIMsgProtocolInfo	Interfaces, Interfaces:Scriptable, thunderbird
		The nsIMsgProtocolInfo interface describes the capabilities of an account type.
776	nsIMsgRuleAction	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilter.idl
777	nsIMsgSearchCustomTerm	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchCustomTerm.idl
778	nsIMsgSearchNotify
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchNotify.idl
779	nsIMsgSearchScopeTerm	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		No summary!
780	nsIMsgSearchSession	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference, thunderbird
		The nsIMsgSearchSession interface allows you to create and manipulate search sessions within Thunderbird.
781	nsIMsgSearchTerm	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in mozilla/ mailnews/ base/ search/ public/ nsIMsgSearchTerm.idl
782	nsIMsgSearchValue	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		No summary!
783	nsIMsgSendLater	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		The nsIMsgSendLater interface provides functions for managing the unsent folder of a messaging account.
784	nsIMsgThread	Interfaces, Interfaces:Scriptable, Message Database, Messages, NeedsContent, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgFolder interface is used to interact with threads in Thunderbird.
785	nsIMsgWindow	Interfaces, Message Windows, NeedsContent, NeedsHelp, XPCOM API Reference, thunderbird
		Implemented by: @mozilla.org/messenger/msgwindow;1. To create an instance, use:
786	nsIMsgWindowCommands	Interfaces, Message Windows, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The JavaScript implementation of this used by Thunderbird is given here.
787	nsIMutableArray	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Consumers of nsIArray should not QueryInterface to nsIMutableArray unless they own the array.
788	nsINavBookmarkObserver	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method notifies this observer that an item is about to be removed. It is called before the actual removal takes place.
789	nsINavBookmarksService	Developing Mozilla, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/nav-bookmarks-service;1. To use this service, use:
790	nsINavHistoryBatchCallback	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
791	nsINavHistoryContainerResultNode	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		Returns a node matching specified details.
792	nsINavHistoryFullVisitResultNode	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The information returned in this interface is not commonly used, hence its separation into a separate query type for efficiency.
793	nsINavHistoryObserver	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The specified page and all its visits are about to be deleted.
794	nsINavHistoryQuery	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		The nsINavHistoryQuery is not intended to be a super-general query mechanism. This was designed so that most queries can be done in only one SQL query. This is important because, if the user has their profile on a networked drive, query latency can be non-negligible
795	nsINavHistoryQueryOptions	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM Interface Reference
		You can ask for the results to be pre-sorted. Since the DB has indices of many items, it can produce sorted results almost for free. Note: re-sorting is slower, as is sorting by title or when you have a host name.
796	nsINavHistoryQueryResultNode	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		Returns the queries that build the node's children; only valid for RESULT_TYPE_QUERY nodes.
797	nsINavHistoryResult	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		Places results use a Model-View-Controller (MVC) design pattern. Result objects represent the model in which the data is stored. External components provide the view and controller pieces of the puzzle; they define how the data looks and how the data is interacted with. More specifically, the nsINavHistoryResultViewer interface provides the View component of the pattern, and nsINavHistoryResultViewObserver is the Controller.
798	nsINavHistoryResultNode	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This is a base class; you should use one of the derived classes instead.
799	nsINavHistoryResultObserver	Interfaces, Interfaces:Scriptable, Places, XPCOM Interface Reference
		Lets the observer know when a batch operation in Places is about to start or end. The observer can then pause updates or events until the batch is completed, so that it won't handle the large number of updates that are about to be notified. This is especially useful when updating user interfaces, to avoid flicker or continuous selection changes, which may result in performance degradation (for example, if updating a view for each update).
800	nsINavHistoryResultTreeViewer	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This object removes itself from the associated result when the tree is detached; this prevents circular references. It's important to be aware of this—if you want to reuse the same viewer, you need to keep your own reference to it, then reinitialize it when the tree changes.
801	nsINavHistoryResultViewObserver	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		Implement this method to report whether or not a drop is permitted onto the specified location.
802	nsINavHistoryResultViewer	Developing Mozilla, Extensions, Interface, Interfaces, Obsolete, Places, XPCOM, XPCOM API Reference, nsINavHistoryResultViewer
		Called when a container node's state changes from closed to opened.
803	nsINavHistoryService	Developing Mozilla, Extensions, Interface, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference, nsINavHistoryService
		Implemented by: "@mozilla.org/browser/nav-history-service;1". To use this service, use:
804	nsINavHistoryVisitResultNode	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
805	nsINetworkLinkService	Interfaces, Interfaces:Scriptable, NeedsExample
		Implemented by: @mozilla.org/network/network-link-service;1 as a service:
806	nsIObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method will be called when there is a notification for the topic that the observer has been registered for.
807	nsIObserverService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The XPCOM nsObserverService implements this interface to provide global notifications for a variety of subsystems.
808	addObserver
		No summary!
809	enumerateObservers
		No summary!
810	notifyObservers
		This content is now available at nsIObserverService.notifyObservers().
811	removeObserver
		This content is now available at nsIObserverService.removeObserver().
812	nsIOutputStream	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An output stream may be "blocking" or "non-blocking" (see the IsNonBlocking() method). A blocking output stream may suspend the calling thread in order to satisfy a call to Close(), Flush(), write(), writeFrom(), or writeSegments(). A non-blocking output stream, on the other hand, must not block the calling thread of execution.
813	close
		No summary!
814	flush
		No summary!
815	isNonBlocking
		No summary!
816	write
		No summary!
817	writeFrom
		No summary!
818	writeSegments
		No summary!
819	nsIOutputStreamCallback	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		Called to indicate that the stream is either writable or closed.
820	nsIParentalControlsService	Firefox 3, Interfaces, Interfaces:Scriptable, Parental Controls, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/parental-controls-service;1. To create an instance, use:
821	nsIParserUtils
		Implemented by: @mozilla.org/parserutils;1 as a service:
822	nsIPassword	Interfaces, Login Manager, NeedsContent, XPCOM API Reference
		See Using nsIPasswordManager for examples of nsIPassword in use.
823	nsIPasswordManager	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference
		See Using nsIPasswordManager for examples.
824	nsIPermission	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIPermission interface defines a "permission" object, which is used to allow or block objects (for example cookies, images) from certain sites based on user preferences.
825	nsIPermissionManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIPermissionManager interface is used to persistently store permissions for different object types (cookies, images, and so on) on a site-by-site basis.
826	nsIPipe	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		initialize this pipe.
827	nsIPlacesImportExportService	Bookmarks, Interfaces, Interfaces:Scriptable, Places, XPCOM Interface Reference
		In the past, this interface also offered methods for importing Places data, but those methods are now part of the BookmarkHTMLUtils.jsm JavaScript code module. The interface name has been kept for compatibility reasons for code using the export service.
828	nsIPlacesView	Developing Mozilla, Interfaces, Places, XPCOM
		The nsIPlacesView interface provides a view-agnostic way to access information about a Places view.
829	nsIPluginHost	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), XPCOM, XPCOM Interface Reference
		To create temp file with Content len header in, it will use by http POST.
830	nsIPrefBranch2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Add a preference change observer. On preference changes, the following arguments will be passed to nsIObserver.observe():
831	nsIPrefLocalizedString	Interfaces, Interfaces:Scriptable, Preferences, XPCOM, XPCOM Interface Reference
		Used to set the contents of this object.
832	nsIPrefService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Call to get a Preferences "Branch" which accesses user preference data. Using a Set method on this object will always create or set a user preference value. When using a Get method a user set value will be returned if one exists, otherwise a default value will be returned.
833	nsIPrincipal
		For details on principals, how they work, and how to get the appropriate one, see Security check basics.
834	nsIPrinterEnumerator	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Returns an array of the names of all installed printers.
835	nsIPrintingPrompt	Interfaces, Interfaces:Scriptable, NeedsMarkupWork, XPCOM, XPCOM Interface Reference
		This interface is identical to nsIPintingPromptService but without the parent nsIDOMWindow parameter. See nsIPrintingPromptService for all documentation.
836	nsIPrivateBrowsingService	Interfaces, Interfaces:Scriptable, Private browsing, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIPrivateBrowsingService interface provides access to information about the state of the private browsing feature offered in Firefox 3.5 and later. When Firefox is in private browsing mode, Firefox shouldn't save any potentially private information. The browser itself stops caching, and also doesn't record history information. In addition, temporary, databases are created to be used for cookies and local storage; these databases are thrown away when private browsing mode is turned off, and the regular databases are re-activated. The temporary cookie and local storage databases start out empty.
837	nsIProcess	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/process/util;1. To create an instance, use:
838	nsIProcess2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/process/util;1. To create an instance, use:
839	nsIProcessScriptLoader
		This interface is used by parent process message managers to load scripts into a child process. The scripts run only once per process. The global object for process scripts is a ContentProcessMessageManager.
840	nsIProfile	Gecko, NeedsUpdate, Reference, Référence(2), XPCOM, XPCOM Interface Reference, profile
		Implemented by: @mozilla.org/profile/manager;1. To get access to the Profile Manager service:
841	nsIProfileLock	Interfaces, Interfaces:Scriptable, Profiles, Toolkit, XPCOM Interface Reference
		Unlocks the profile.
842	nsIProfileUnlocker	Interfaces, Interfaces:Scriptable, Profiles, XPCOM Interface Reference
		Tries to unlock the profile by attempting or forcing the process that currently holds the lock to quit.
843	nsIProgrammingLanguage	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Identifiers for programming languages.
844	nsIProgressEventSink	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This interface is used to asynchronously convey channel status and progress information that is generally not critical to the processing of the channel. The information is intended to be displayed to the user in some meaningful way.
845	nsIPrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Normally you would use the prompt service as it is more flexible, but sometimes a callback will request an nsIPrompt via nsIInterfaceRequestor.getInterface(). To get an instance, call the nsIWindowWatcher.getNewPrompter().
846	nsIPromptService	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		You can define access keys (or keyboard shortcuts) for buttons by including an ampersand ("&") in front of the character that should be the access key for that button. If you need to include an ampersand in the button's text, use two of them, like this: "&&".
847	nsIProperties	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/file/directory_service;1. To get an instance, use:
848	get
		No summary!
849	getKeys
		No summary!
850	has
		No summary!
851	set
		No summary!
852	undefine
		No summary!
853	nsIProperty	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
854	nsIPropertyBag	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Get a property value for the given name.
855	nsIPropertyBag2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method returns null if the value does not exist, or exists but is null.
856	nsIPropertyElement	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
857	nsIProtocolHandler	Interfaces, Interfaces:Scriptable, Web-Based Protocol Handlers, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Lets a protocol override blacklisted ports. This method is called when there's an attempt to connect to a port that is blacklisted. For example, for most protocols, port 25 (Simple Mail Transfer Protocol) is banned. When a URI containing this port number is encountered, this method is called to ask if the protocol handler wants to override the ban.
858	nsIProtocolProxyCallback	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This method is called when proxy info is available or when an error in the proxy resolution occurs.
859	nsIProtocolProxyFilter	Interfaces, Interfaces:Scriptable, Proxy, XPCOM, XPCOM Interface Reference
		This interface is used to apply filters to the proxies selected for a given URI. Use nsIProtocolProxyService.registerFilter() to hook up instances of this interface.
860	nsIProtocolProxyService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/protocol-proxy-service;1. To access the service use:
861	nsIProxyInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface identifies a proxy server.
862	nsIPushMessage	Interfaces, Interfaces:Scriptable, Push, XPCOM, XPCOM Interface Reference
		nsIPushMessage is the subject of a push-message observer notification.
863	nsIPushService	Interfaces, Interfaces:Scriptable, Push, XPCOM, XPCOM Interface Reference
		Push lets a remote server send payloads to a web site, add-on, or component running in the browser. nsIPushService supports the Push API implementation in Firefox, and can be used directly from privileged code to create system subscriptions.
864	nsIPushSubscription	Interfaces, Interfaces:Scriptable, Push, XPCOM, XPCOM Interface Reference
		Each subscription is associated with a unique URL generated by the Push service. Sending a POST request to this URL routes the message to the instance of Firefox that created the subscription. A subscription also has a public key and secret; these are used to encrypt message payloads.
865	nsIRadioInterfaceLayer	Interfaces, Mobile, XPCOM API Reference
		Implemented by: @mozilla.org/telephony/system-worker-manager;1. To create an instance, use:
866	nsIRandomGenerator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Generates the specified amount of random bytes.
867	nsIRequest	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		For example nsIChannel typically passes itself as the nsIRequest argument to the nsIStreamListener on each onStartRequest, onDataAvaliable, and onStopRequest invocation.
868	nsIRequestObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called to signify the beginning of an asynchronous request.
869	nsIResumableChannel	Channels, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Open this channel, and read starting at the specified offset.
870	nsIRunnable
		No summary!
871	nsISHEntry	Interfaces, Interfaces:Scriptable, NeedsContent, Session history, XPCOM Interface Reference, sessionStorage
		Implemented by: @mozilla.org/browser/session-history-entry;1. To create an instance, use:
872	nsISHistory	Interfaces, Interfaces:Scriptable, Session history, XPCOM API Reference
		In an embedded browser environment, the nsIWebBrowser object creates an instance of session history for each open window. A handle to the session history object can be obtained from nsIWebNavigation. In a non-embedded situation, the owner of the session history component must create a instance of it and set it in the nsIWebNavigation object.
873	nsISHistoryListener	Interfaces, Interfaces:Scriptable, Session history, XPCOM, XPCOM Interface Reference
		A session history listener is notified when pages are added to, removed from, and loaded from session history. The listener can prevent any action (except adding a new session history entry) from happening by returning false from the corresponding callback method.
874	nsISOCKSSocketInfo	Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
		No summary!
875	nsISSLErrorListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called in case of an SSL error.
876	nsISSLSocketControl	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Starts an SSL proxy connection.
877	nsIScreen	Interfaces, Interfaces:Scriptable, Screens, XPCOM, XPCOM Interface Reference
		Use nsIScreenManager to obtain references to screens.
878	nsIScreenManager	Interfaces, Interfaces:Scriptable, Screens, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/gfx/screenmanager;1 as a service:
879	nsIScriptError	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/scripterror;1. To create an instance, use:
880	nsIScriptError2	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		No summary!
881	nsIScriptableIO	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		File and Stream Guide: [ nsIScriptableIO | Accessing Files | Getting File Information | Reading from Files | Writing to Files | Moving, Copying and Deleting Files | Uploading and Downloading Files | Working With Directories ]
882	nsIScriptableInputStream	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Return the number of bytes currently available in the stream.
883	available
		No summary!
884	close
		No summary!
885	init
		No summary!
886	read
		No summary!
887	nsIScriptableUnescapeHTML	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/feed-unescapehtml;1 as a service:
888	nsIScriptableUnicodeConverter	Interfaces, Interfaces:Scriptable, Unicode, XPCOM, XPCOM Interface Reference
		This legacy API represents binary data using the lower haft of each 16-bit code unit in a JavaScript string. If the other APIs you are reading data from or writing data to don't require you to use this legacy representation, you should use TextDecoder and TextEncoder (available to chrome JavaScript via Components.utils.importGlobalProperties) instead of this API.
889	nsIScrollable	scrollbar
		Scroll orientations a scrollbar can be in.
890	nsISearchEngine
		Inherits from: nsISupports
891	nsISearchSubmission	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
892	nsISecurityCheckedComponent	Interfaces, Interfaces:Scriptable, Security, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		In Gecko, a "capability" is a string identifying a set of actions that code is allowed to perform. Two examples:
893	nsISeekableStream	Files, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		This method moves the stream offset of the stream implementing this interface.
894	nsISelection	Guide, NeedsContent, XPCOM
		Interface for manipulating and querying the current selected range of nodes within the document.
895	nsISelection2	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Return array of ranges intersecting with the given DOM interval.
896	nsISelection3	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Modifies the selection. Note that the parameters are case-insensitive.
897	nsISelectionController	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Will extend the selection one character cell backward in the document. This method is used internally for handling backspace key only when we're after UTF-16 surrogates.
898	nsISelectionImageService	Interfaces, NeedsContent, XPCOM Interface Reference
		Retrieve the image for alpha blending.
899	nsISelectionPrivate	Interfaces, Interfaces:Scriptable, NeedsContent
		Will resume User Interface updates after a previous call to startBatchChanges().
900	nsIServerSocket	Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
		The nsIServerSocket interface implements a server socket that can accept incoming connections.
901	nsIServerSocketListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This method is called when a client connection is accepted.
902	nsIServiceManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method returns a reference to a particular XPCOM service given the ClassID of the service. Unlike createInstance, this will always return the same object each time it is called with the same arguments.
903	getServiceByContractID
		No summary!
904	isServiceInstantiated
		No summary!
905	isServiceInstantiatedByContractID
		No summary!
906	nsISessionStartup	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, sessionStorage
		Implemented by: @mozilla.org/browser/sessionstartup;1. To use this service, use:
907	nsISessionStore	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		In versions of Firefox prior to 3.5, the user preference browser.sessionstore.enabled must be true for these calls to be successful. Starting in Firefox 3.5, this preference is no longer used.
908	nsISimpleEnumerator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called to retrieve the next element in the enumerator. The "next" element is the first element upon the first call. Must be preceded by a call to hasMoreElements() which returns PR_TRUE. This method is generally called within a loop to iterate over the elements in the enumerator.
909	getNext
		Documentation is now located at nsISimpleEnumerator.getNext().
910	hasMoreElements
		Documentation is now located at nsISimpleEnumerator.hasMoreElements().
911	nsISmsDatabaseService	Interfaces, Mobile, WebSMS
		Implemented by: @mozilla.org/sms/smsdatabaseservice;1. To create an instance, use:
912	nsISmsRequestManager	Interfaces, Mobile, WebSMS
		Implemented by: @mozilla.org/sms/smsrequestmanager;1. To create an instance, use:
913	nsISmsService	Interfaces, Mobile, WebSMS
		Implemented by: @mozilla.org/sms/smsservice;1. To create an instance, use:
914	nsISocketProvider	Interfaces, Interfaces:Scriptable, Reference, Référence(2), Sockets, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/socket;2?type=foo. To create an instance, use:
915	nsISocketProviderService	Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
		Given a string representing a socket type, this method returns an nsISocketProvider representing that socket type.
916	nsISocketTransport	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		To create an instance, call nsISocketTransportService.createTransport()
917	nsISocketTransportService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/socket-transport-service;1. To create an instance, use:
918	nsISound	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Note that nsISound instances may play the sounds using another thread; however, this is not controlled by the caller.
919	nsISpeculativeConnect	Interfaces, Interfaces:Scriptable, Necko, Network, XPCOM Interface References
		To use this service, simply call nsISupports.QueryInterface() on the nsIIOService you plan to use for the connection, to get access to the I/O service's implementation of nsISpeculativeConnect. Then call speculativeConnect() to let the networking layer know what you might be doing in the future.
920	nsIStackFrame	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		To output the stack at a particular location:
921	nsIStandardURL	Interfaces, Interfaces:Scriptable
		Implemented by: @mozilla.org/network/standard-url;1. To create an instance, use:
922	nsIStreamConverter	Interfaces, Interfaces:Scriptable, MIME, Reference, Référence(2), XPCOM Interface Reference
		Suppose you had code that converted plain text into HTML. You could implement this interface to allow everyone else to use your conversion logic using a standard api.
923	nsIStreamListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Classes which want to consume data from a nsIChannel need to implement this interface. nsIRequestObserver contains two methods. So, in all the three methods - onDataAvailable(), nsIRequestObserver.onStartRequest() and nsIRequestObserver.onStopRequest() have to be implemented.
924	nsIStringBundle	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface is used by XUL:stringbundle to retrieve strings. It is recommended that you use the methods of XUL:stringbundle to access these functions unless necessary. Alternatively, a string bundle can be created within a javascript context with nsIStringBundleService.
925	nsIStringBundleOverride	Interfaces, Interfaces:Scriptable, String bundles, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/stringbundle/text-override;1. To create an instance, use:
926	nsIStringBundleService	Interfaces, Interfaces:Scriptable, Localization, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/stringbundle;1. To access this service, use:
927	nsIStringEnumerator
		Called to retrieve the next string in the enumerator. The "next" element is the first string upon the first call. Must be preceded by a call to hasMoreElements() which returns PR_TRUE. This method is generally called within a loop to iterate over the strings in the enumerator.
928	nsIStructuredCloneContainer	Interfaces, Interfaces:Scriptable, NeedsContent
		You can copy an object into an nsIStructuredCloneContainer using initFromVariant() or initFromBase64(). it is an error to initialize an nsIStructuredCloneContainer more than once.
929	nsIStyleSheetService	Interfaces, Interfaces:Scriptable, Stylesheets, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Allows extensions or embeddors to add to the built-in list of user or agent style sheets.
930	nsISupports	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Notifies the object that an interface pointer has been duplicated.
931	AddRef
		Documentation is now located at nsISupports.AddRef().
932	Release
		Documentation is now located at nsISupports.Release().
933	nsISupports proxies	NeedsHelp, NeedsUpdate, Obsolete, XPCOM
		The main reason for nsISupports Proxies is that JavaScript and UI are on a single thread. When one is busy, the other is blocked. A good example of this is the old install.js scripts that were used in XPInstall in older Mozilla versions. They from the majority of JavaScript code, which is small and can be quickly run. XPInstall installation scripts are sometimes very complex and can require long execution time due to unzipping or native file system actions. If XPInstall ran on the UI thread, the product would appear frozen until the script was complete. This is definitely bad. Because of this, XPInstall was moved to its own thread. Now XPInstall can do its installations while the product renders, but now XPInstall can not access UI elements such as a progress meter or a confirmation dialog. How can a separate non-UI thread act as if it was on the UI thread? Herein lays the utility of nsISupports Proxies.
934	nsISupportsArray	Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM Interface Reference
		No summary!
935	nsISupportsCString	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
936	data
		No summary!
937	toString
		No summary!
938	nsISupportsChar	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
939	data
		No summary!
940	toString
		No summary!
941	nsISupportsDouble	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
942	data
		No summary!
943	toString
		No summary!
944	nsISupportsFloat	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
945	data	XPCOM API Reference
		This content is now available at nsISupportsFloat.Attributes.
946	toString
		This content is now available at nsISupportsFloat.toString().
947	nsISupportsID	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method returns a string valued representation of the object.
948	data
		No summary!
949	toString
		No summary!
950	nsISupportsInterfacePointer	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns a string valued representation of the object.
951	data
		No summary!
952	dataIID
		No summary!
953	toString
		This content is now available at nsISupportsInterfacePointer.toString().
954	nsISupportsPRBool	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
955	data
		No summary!
956	toString
		No summary!
957	nsISupportsPRInt16	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
958	data
		This content is now available at nsISupportsPRInt16.Attributes.
959	toString
		This content is now available at nsISupportsPRInt16.toString().
960	nsISupportsPRInt32	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
961	data
		No summary!
962	toString
		No summary!
963	nsISupportsPRInt64	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
964	data
		This content is now available at nsISupportsPRInt64.Attributes.
965	toString
		This content is now available at nsISupportsPRInt64.toString().
966	nsISupportsPRTime	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
967	data
		No summary!
968	toString
		No summary!
969	nsISupportsPRUint16	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
970	data
		No summary!
971	toString
		No summary!
972	nsISupportsPRUint32	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
973	data
		No summary!
974	toString
		No summary!
975	nsISupportsPRUint64	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
976	data
		No summary!
977	toString
		No summary!
978	nsISupportsPRUint8	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
979	data
		No summary!
980	toString
		No summary!
981	nsISupportsPrimitive	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface was frozen for Gecko 1.2. See bug 166426 for details. From Gecko 2.0 interfaces are no longer frozen.
982	type	XPCOM API Reference
		No summary!
983	nsISupportsPriority	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface does not strictly define what happens when the priority of an object is changed. An implementation of this interface is free to define the side-effects of changing the priority of an object. In some cases, changing the priority of an object may be disallowed (resulting in an exception being thrown) or may simply be ignored.
984	nsISupportsString	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
985	data
		No summary!
986	toString
		No summary!
987	nsISupportsVoid	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
988	data
		Documentation is now located at nsISupportsVoid.data().
989	toString
		Documentation is now located at nsISupportsVoid.toString().
990	nsISupportsWeakReference	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Produces an appropriate instance of nsIWeakReference.
991	getWeakReference
		This content is now available at nsISupportsWeakReference.getWeakReference().
992	nsISyncJPAKE	Interfaces, Interfaces:Scriptable, NeedsContent
		Perform the final step of the JPAKE exchange. This will compute the key and expand the key to two keys, an AES256 encryption key and a 256 bit HMAC key. It returns a key confirmation value (SHA256d of the key) and the encryption and HMAC keys.
993	nsISyncMessageSender
		Message "senders" have a single "other side" to which messages are sent. For example, a child-process message manager will send messages that are only delivered to its one parent-process message manager.
994	nsITXTToHTMLConv	HTML, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Prior versions of the interface named the methods using the InitialCaps style instead of the interCaps style.
995	nsITaggingService	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/tagging-service;1. To use this service, use:
996	nsITaskbarPreview	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		You can not directly instantiate this interface. Instead, you use nsITaskbarTabPreview or nsITaskbarWindowPreview as appropriate.
997	nsITaskbarPreviewButton	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		You can't directly instantiate this interface. Instead, you use the nsITaskbarWindowPreview.getButton() to get the objects representing the buttons.
998	nsITaskbarPreviewController	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		Clients should provide their own implementation of this interface. Depending on whether the controller is connected to an nsITaskbarTabPreview or nsITaskbarWindowPreview, only certain methods and attributes need to be implemented.
999	nsITaskbarProgress
		Sets the taskbar progress state and value for this window. The currentValue and maxValue parameters are optional and should be supplied when state is one of STATE_NORMAL, STATE_ERROR or STATE_PAUSED.
1000	nsITaskbarTabPreview	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		Tab preview support is disabled by default in Gecko 1.9.2
1001	nsITaskbarWindowPreview	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		You can't directly instantiate this interface; instead, call nsIWinTaskbar.getTaskbarWindowPreview() to get the taskbar preview for a specific window.
1002	nsITelemetry	Developing Mozilla, Interfaces, Interfaces:Scriptable, Performance, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/base/telemetry;1 as a service:
1003	nsITextInputProcessor	DOM, Interface, Interface:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		The motivation of this interface is to provide better API than nsIDOMWindowUtils to dispatch key events and create, modify, and commit composition in higher level. nsIDOMWindowUtils has provided the methods which dispatched keyboard events and composition events almost directly. Therefore they sometimes caused impossible scenarios in automated tests (what's tested with such events?) and JS-IME and/or JS-Keyboard on Firefox OS or add-ons may dispatch events with wrong rules. For solving that issue, methods of this interface have been designed for performing a key operation or representing a change of composition state.
1004	nsITextInputProcessorCallback	DOM, Interface, Interface:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		nsITextInputProcessorCallback is defined for receiving requests and notifications to IME from Gecko. This interface has a "function" attribute. Therefore, JS-IME can implement this as a function.
1005	nsITextInputProcessorNotification	DOM, Interface, Interface:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		This interface tells details of a request or notification to IME. When Gecko supports new notification to IME, this interface may have some new attributes. So, nsITextInputProcessorCallback won't be changed for keeping backward compatibility.
1006	nsIThread	Firefox 3, Interfaces, Interfaces:Scriptable, Threads, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface provides a high-level abstraction for an operating system thread.
1007	nsIThreadEventFilter	Firefox 3, Interfaces, Threads, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIThreadEventFilter interface may be implemented to determine whether or not an event may be accepted by a nested event queue; see nsIThreadInternal.PushEventQueue() for more information.
1008	nsIThreadInternal	Firefox 3, Interfaces, Interfaces:Scriptable, Threads, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIThreadInternal interface is implemented by the XPCOM thread object to let consumers observe dispatch activity on a thread.
1009	nsIThreadManager	Firefox 3, Interfaces, Interfaces:Scriptable, Threads, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIThreadManager interface lets applications and extensions create and manage threads, each of which is represented by an nsIThread.
1010	nsIThreadObserver	Firefox 3, Interfaces, Interfaces:Scriptable, Threads, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIThreadObserver interface may be implemented to let an observer implement a layered event queue.
1011	nsIThreadPool	Interfaces, Interfaces:Scriptable, Threads, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		A thread pool provides a convenient way to process events off the main thread. When you send events to the thread pool, the pool creates a new thread to process the event, up to the number of threads specified by the threadLimit attribute.
1012	nsIThreadPoolListener	Firefox 3.5, Interfaces, Interfaces:Scriptable, Threads, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIThreadPoolListener interface represents objects that listen to notifications generated by the nsIThreadPool.
1013	nsITimer	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsITimer interface offers a functionality to invoke a function after a specified delay.
1014	nsITimerCallback	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Initialize a timer to fire after the given millisecond interval. This version takes a function to call and a closure to pass to that function.
1015	nsIToolkit	Interfaces, XPCOM, XPCOM Interface Reference
		Initialize this toolkit with aThread.
1016	nsIToolkitProfile	Interfaces, Interfaces:Scriptable, Profiles, Toolkit, XPCOM Interface Reference
		You should not create these objects yourself; to obtain them, use the nsIToolkitProfileService interface to create and obtain them.
1017	nsIToolkitProfileService	Interfaces, Interfaces:Scriptable, Profiles, Toolkit, XPCOM Interface Reference
		Creates a new profile.
1018	nsITraceableChannel	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The typical way to use this interface is as follows:
1019	nsITransaction	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Executes the transaction.
1020	nsITransactionList	Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM Interface Reference
		Returns the list of children associated with the item at aIndex. Implementations may return null if there are no children, or an empty list. The list returned is AddRef'd so it is up to the caller to Release the transaction when it is done.
1021	nsITransactionListener	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Called after a nsITransactionManager begins a batch.
1022	nsITransactionManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Adds a listener to the transaction manager's notification list. Listeners are notified whenever a transaction is done, undone, or redone. The listener's nsITransactionListener.AddRef() method is called.
1023	nsITransferable	Gecko, Interface, Mozilla, Reference, Référence(2), XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/widget/transferable;1. To create an instance, use:
1024	nsITransport	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface provides methods to open blocking or non-blocking, buffered or unbuffered streams to the resource. The name "transport" is meant to connote the inherent data transfer implied by this interface (that is, data is being transfered in some fashion via the streams exposed by this interface).
1025	nsITransportEventSink	Interfaces, Interfaces:Scriptable, Transports, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Transport status notification.
1026	nsITransportSecurityInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
1027	nsITreeBoxObject	Interfaces, XPCOM, XPCOM Interface Reference
		The nsITreeBoxObject interface contains information about the size and layout of a tree.
1028	nsITreeColumn	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsITreeColumn interface represents a tree column.
1029	nsITreeColumns	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsITreeColumns interface represents the tree columns.
1030	nsITreeContentView	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsITreeContentView interface is implemented by tree views that are backed by DOM content. It is typically reached by calling QueryInterface on a nsITreeView.
1031	nsITreeSelection	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when the row count changes to adjust selection indices.
1032	nsITreeView	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Implementing a nsITreeView in lieu of DOM methods for tree creation can improve performance dramatically, and removes the need to make changes to the tree manually when changes to the database occur.
1033	nsIURI	Interfaces, Interfaces:Scriptable, URIs, XPCOM, XPCOM Interface Reference
		See the following RFCs for details:
1034	nsIURIFixup	Interfaces, Interfaces:Scriptable, URI, XPCOM Interface Reference
		Implemented by: @mozilla.org/docshell/urifixup;1 as a service:
1035	nsIURIFixupInfo
		No summary!
1036	nsIURL	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		You can get a nsIURL from an nsIURI, using the QueryInterface() method:
1037	nsIURLFormatter	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM Interface Reference
		Variable names can contain 'A-Z' letters and '_' characters.
1038	nsIURLParser	Interfaces, Interfaces:Scriptable, NeedsContent
		The string to parse in the methods may be given as a null terminated string, in which case the length argument should be -1.
1039	nsIUTF8ConverterService
		Ensure that aString is encoded in UTF-8. If not, convert to UTF-8 assuming it's encoded in aCharset and return the converted string in UTF-8.
1040	nsIUTF8StringEnumerator	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, strings
		Returns the next string in the enumerator. The "next" element is the first string upon the first call. Must be preceded by a call to hasMore(), which returns PR_TRUE. This method is generally called within a loop to iterate over the strings in the enumerator.
1041	nsIUUIDGenerator	Add-ons, Extensions, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by @mozilla.org/uuid-generator; as a service:
1042	nsIUpdate	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Retrieves a patch.
1043	nsIUpdateCheckListener	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when the update check is completed.
1044	nsIUpdateChecker	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Checks for available updates, notifying a listener of the results.
1045	nsIUpdateItem
		Constants representing types of update checks. Constants that callers can use to indicate the reason for an add-on update check. Internal code uses other constants in nsExtensionManager.js.in.
1046	nsIUpdateManager	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns the update at the specified index into the history list.
1047	nsIUpdatePatch	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Serializes the patch object into a DOM element.
1048	nsIUpdatePrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Presents a user interface that checks for and displays the available updates.
1049	nsIUpdateTimerManager	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Presents a user interface that checks for and displays the available updates.
1050	nsIUploadChannel	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Sets a stream to be uploaded by this channel.
1051	nsIUploadChannel2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Sets a stream to be uploaded by this channel with the specified Content-Type and Content-Length header values.
1052	nsIUrlListManagerCallback	Interfaces, Interfaces:Scriptable, NeedsContent
		No summary!
1053	nsIUserCertPicker	Cryptography, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
1054	nsIUserInfo	Interfaces, Interfaces:Scriptable, Reference, Référence(2), XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/userinfo;1. To get the service, use:
1055	nsIVariant	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference, XPConnect
		None.
1056	nsIVersionComparator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Version strings are dot-separated sequences of version-parts. A version-part consists of up to four parts, all of which are optional: <number-a><string-b><number-c><string-d (everything else)> A version-part may also consist of a single asterisk "*" which indicates * "infinity". Numbers are base-10, and are zero if left out. Strings are compared bytewise. For additional backwards compatibility, if "string-b" is "+" then "number-a" is incremented by 1 and "string-b" becomes "pre".
1057	nsIWeakReference	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An instance of nsIWeakReference is a proxy object that cooperates with its referent to give clients a non-owning, non-dangling reference. Clients own the nsIWeakReference instance.
1058	queryReferent
		No summary!
1059	nsIWebBrowser	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Registers a listener of the type specified by the iid to receive callbacks. The browser stores a weak reference to the listener to avoid any circular dependencies. Typically this method will be called to register an object to receive nsIWebProgressListener or nsISHistoryListener notifications in which case the the IID is that of the interface.
1060	nsIWebBrowserChrome	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Asks the implementer to destroy the window associated with this WebBrowser object.
1061	nsIWebBrowserChrome2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when the status text in the chrome needs to be updated. This method may be called instead of nsIWebBrowserChrome.SetStatus(). An implementor of this method, should still implement nsIWebBrowserChrome.SetStatus().
1062	nsIWebBrowserChrome3	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Determines the appropriate target for a link.
1063	nsIWebBrowserChromeFocus	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Set the focus at the next focusable element in the chrome.
1064	nsIWebBrowserFind	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Get one by doing a GetInterface on an nsIWebBrowser.
1065	nsIWebBrowserFindInFrames	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Get an instance by doing a QueryInterface from nsIWebBrowserFind.
1066	nsIWebBrowserPersist	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, needsattention
		Implemented by: @mozilla.org/embedding/browser/nsWebBrowser;1 and @mozilla.org/embedding/browser/nsWebBrowserPersist;1. To create an instance, use:
1067	nsIWebContentHandlerRegistrar	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by @mozilla.org/embeddor.implemented/web-content-handler-registrar;1 as a service:
1068	nsIWebNavigation	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface is implemented by the following components:
1069	nsIWebNavigationInfo	Interfaces, Interfaces:Scriptable, MIME, XPCOM Interface Reference
		Implemented by: @mozilla.org/webnavigation-info;1 as a service:
1070	nsIWebPageDescriptor	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Tells the object to load the page specified by the page descriptor.
1071	nsIWebProgress	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIWebProgress interface is used to add or remove nsIWebProgressListener instances to observe the loading of asynchronous requests (usually in the context of a DOM window).
1072	nsIWebProgressListener	Interfaces, Interfaces:Scriptable, NeedsMarkupWork, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		nsIWebProgress describes the parent-child relationship of nsIWebProgress instances.
1073	nsIWebProgressListener2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		An extended version of nsIWebProgressListener.
1074	nsIWebSocketChannel	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence(2), WebSockets, XPCOM Interface Reference
		Implemented by: ?????????????????????????????????????. To create an instance, use:
1075	nsIWebSocketListener	Interfaces, Interfaces:Scriptable, Reference, Référence(2), WebSockets, XPCOM Interface Reference
		Called to acknowledge a message sent via nsIWebSocketChannel.sendMsg() or nsIWebSocketChannel.sendBinaryMsg().
1076	nsIWebappsSupport	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This method installs a web application.
1077	nsIWifiAccessPoint	Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
		No summary!
1078	nsIWifiListener	Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
		Called when the list of available access points changes.
1079	nsIWifiMonitor	Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
		This is used, for example, by Geolocation to use WiFi access points for location detection.
1080	nsIWinAccessNode	Interfaces, NeedsContent, XPCOM Interface Reference
		No summary!
1081	nsIWinAppHelper	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/xre/app-info;1. To create an instance, use:
1082	nsIWinTaskbar	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		Starting with Windows 7, applications gain some control over their appearance in the taskbar. By default, there is a single taskbar preview per top level window (excluding pop-ups). This preview is represented by an nsITaskbarWindowPreview object.
1083	nsIWindowCreator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Create a new window. Gecko will/may call this method, if made available to it, to create new windows.
1084	nsIWindowMediator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The two most common uses of nsIWindowMediator are, enumerating all windows of a given type and getting the most recent / any window of a given type.
1085	nsIWindowWatcher	Embedding Mozilla, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Usage notes: This component has an activeWindow property. Clients may expect this property to be always current, so to properly integrate this component the application will need to keep it current by setting the property as the active window changes. This component should not keep a (XPCOM) reference to any windows; the implementation will claim no ownership. Windows must notify this component when they are created or destroyed, so only a weak reference is kept. Note that there is no interface for such notifications (not a public one, anyway). This is taken care of both in Mozilla and by common embedding code. Embedding clients need do nothing special about that requirement.
1086	nsIWindowsRegKey	Interfaces, Interfaces:Scriptable, NeedsContent, NeedsExample, XPCOM, XPCOM Interface Reference
		The interface represents a single key in the registry.
1087	nsIWindowsShellService	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Valid starting keys for the Windows Registry.
1088	nsIWorker	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		For usage details, see worker and the article Using DOM workers.
1089	nsIWorkerFactory	Workers, XPCOM, XPCOM Interface Reference
		Implemented by: threads/workerfactory;1. To create an instance, use:
1090	nsIWorkerGlobalScope	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, Workers, XPCOM, XPCOM Interface Reference
		No summary!
1091	nsIWorkerMessageEvent	Interfaces, Interfaces:Scriptable, Mozilla, Workers, XPCOM, XPCOM Interface Reference
		Initializes the message event.
1092	nsIWorkerMessagePort	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		Posts a message into the event queue.
1093	nsIWorkerScope	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		Allows the worker to terminate itself. If a listener has been established by setting the value of the onclose attribute, it gets called.
1094	nsIWritablePropertyBag	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Delete a property with the given name.
1095	nsIWritablePropertyBag2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
1096	nsIXFormsModelElement	Interfaces, Interfaces:Scriptable, XForms, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An nsIDOMDocument.
1097	nsIXFormsNSInstanceElement	Interfaces, Interfaces:Scriptable, NeedsExample, NeedsMarkupWork, XForms, XPCOM API Reference, XPCOM Interface Reference
		nsIXFormsNSInstanceElement is implemented by all XForms <instance/> elements, defining Mozilla extensions.
1098	nsIXFormsNSModelElement	Interfaces, Interfaces:Scriptable, NeedsContent, NeedsExample, NeedsMarkupWork, XForms, XPCOM API Reference, XPCOM Interface Reference
		nsIXFormsNSModelElement is implemented by all XForms <model/> elements. It defines Mozilla extensions to the nsIXFormsModelElement interface.
1099	nsIXMLHttpRequest	Guide, Interfaces, XMLHttpRequest, XPCOM API Reference, XPCOM Interface Reference
		nsIXMLHttpRequest along with nsIJSXMLHttpRequest and nsIXMLHttpRequestEventTarget are Mozilla's implementation details of the DOM XMLHttpRequest object.
1100	nsIXMLHttpRequestEventTarget	Interfaces, Interfaces:Scriptable, XMLHttpRequest, XPCOM, XPCOM Interface Reference
		When the handler functions for these events are called, they receive as a parameter a ProgressEvent, which implements the nsIDOMProgressEvent interface.
1101	nsIXMLHttpRequestUpload	AJAX, Interfaces, Interfaces:Scriptable, XMLHttpRequest, XPCOM, XPCOM Interface Reference
		No summary!
1102	nsIXPCException	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XPConnect
		None.
1103	nsIXPCScriptable	Interfaces, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Inherits from: nsISupports
1104	nsIXPConnect	Interfaces, NeedsContent, Reference, Référence(2), XPCOM, XPCOM Interface Reference, XPConnect
		To access the XPConnect service, use code like this:
1105	nsIXSLTException	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XSLT
		No summary!
1106	nsIXSLTProcessor	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XSLT
		Implemented by: @mozilla.org/document-transformer;1?type=xslt. To create an instance, use:
1107	nsIXSLTProcessorObsolete
		Use nsIXSLTProcessor instead.
1108	nsIXULAppInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		In XULRunner applications nsIXULAppInfo obtains app-specific information from application.ini.
1109	nsIXULBrowserWindow	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, XUL
		The XULBrowserWindow attribute exists on the nsIXULWindow interface although both Firefox and SeaMonkey also store their nsIXULBrowserWindow reference in the global XULBrowserWindow object accessible from JavaScript code.
1110	nsIXULBuilderListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called after a template builder has rebuilt its content.
1111	nsIXULRuntime	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/xre/app-info;1. To get an instance, use:
1112	nsIXULSortService	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, XUL
		Used internally for insertion sorting.
1113	nsIXULTemplateBuilder	Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XUL
		The nsITemplateBuilder interface controls the display of elements using a XUL template element and is automatically attached to an element containing a datasources attribute. A template builder, given an input source of data, a template, and a reference point, generates a list of results from the input, and copies part of the template for each result. Templates may generate content recursively, using the same template, but with the previous iteration's results as the reference point. As an example, for an XML data source the initial reference point would be a specific node in the DOM tree and a template might generate a list of all child nodes. For the next iteration, those children would be used to generate output for their child nodes and so forth.
1114	nsIXULTemplateQueryProcessor	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XUL, XUL Templates
		A query processor takes a template query and generates results for it given a datasource and a reference point. There is a one-to-one relationship between a template builder and a query processor. The template builder creates the query processor, and there is no other means to retrieve it.
1115	nsIXULTemplateResult	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XUL, XUL Templates
		Each result is identified by an id, which must be unique within the set of results produced from a query. The result may optionally be identified by an RDF resource. Generally, the result and its id will be able to uniquely identify a node in the source data, such as an RDF or XML node. In other contexts, such as a database query, a result would represent a particular record. A result is expected to only be created by a query processor. Each result also contains a set of variable bindings. The value for a particular variable may be retrieved using the getBindingFor() and getBindingObjectFor() methods.
1116	nsIXULWindow	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		An nsIXULWindow is created as part of the creation of a top-level chrome window. When the window is destroyed, it will fire a "xul-window-destroyed" notification through the global observer service. This signals the application in case it needs to quit.
1117	nsIXmlRpcClient	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
1118	nsIXmlRpcFault
		No summary!
1119	nsIZipEntry	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
1120	nsIZipReader	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/libjar/zip-reader;1. To create an instance, use:
1121	nsIZipReaderCache	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/libjar/zip-reader-cache;1. To create an instance, use:
1122	nsIZipWriter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Once all the operations you wish to perform are added to the queue, a call to processQueue() will perform the operations in the order they were added to the queue. Operations performed on the queue throw any errors that occur out to the observer.
1123	nsMsgFilterFileAttribValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterList.idl
1124	nsMsgFolderFlagType
		Defined in comm-central/ mailnews/ base/ public/ nsMsgFolderFlags.idl
1125	nsMsgJunkStatus	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1126	nsMsgKey	XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1127	nsMsgLabelValue	XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1128	nsMsgPriorityValue	XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1129	nsMsgRuleActionType	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgFilterCore.idl
1130	nsMsgSearchAttrib	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1131	nsMsgSearchOp	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1132	nsMsgSearchScope
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1133	nsMsgSearchTerm
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1134	nsMsgSearchTypeValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1135	nsMsgSearchValue	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1136	nsMsgSearchWidgetValue	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1137	nsPIPromptService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: The contract ID isn't defined.
1138	XPCOM Interface Reference by grouping
		This page lists the current (as of Dec. 01, 2010) list of Mozilla interfaces as listed on the XPCom interface Reference Page Where that page lists items by alphabetical sorting, this page attempts to group them by function. Grouping and category names were made by somewhat arbitrary decision by the author. (I'm fully aware that this will be a great point of discussion and probably will end in tears, but since I'm the first person to apparently take a swing at this, I get first dibs.)
1139	XPCOM glue classes	Classes, Landing, XPCOM
		These "glue" classes are provided to make it easier to use XPCOM from C++ code.
1140	NS ConvertASCIItoUTF16 external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1141	NS ConvertUTF16toUTF8 external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1142	NS ConvertUTF8toUTF16 external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1143	NS LossyConvertUTF16toASCII external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1144	NS_ConvertASCIItoUTF16
		Class Declaration
1145	NS_ConvertUTF16toUTF8
		Class Declaration
1146	NS_ConvertUTF8toUTF16
		Class Declaration
1147	NS_LossyConvertUTF16toASCII
		Class Declaration
1148	NS_OVERRIDE
		NS_OVERRIDE is a macro which allows C++ code in Mozilla to specify that a method is intended to override a base class method. If there is no base class method with the same signature, a compiler with static-checking enabled will fail to compile.
1149	NS_POSTCONDITION	XPCOM, XPCOM_Macros
		Macro
1150	NS_PRECONDITION	XPCOM, XPCOM_Macros
		Macro
1151	PromiseFlatCString (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1152	PromiseFlatString (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1153	nsACString	Glue_Classes, XPCOM, XPCOM API Reference
		The nsACString abstract class represents a character string composed of single-byte storage units. This class is typically used to represent ASCII or UTF-8 character arrays.
1154	Append	XPCOM, XPCOM API Reference
		The Append family of functions appends a value to the end of a string's internal buffer.
1155	Assign	XPCOM, XPCOM API Reference
		The Assign family of functions sets the value of a string's internal buffer.
1156	BeginReading	XPCOM, XPCOM API Reference
		The BeginReading function returns a const pointer to the first element of the string's internal buffer.
1157	Cut	XPCOM, XPCOM API Reference
		The Cut function removes a section of the string's internal buffer.
1158	EndReading	XPCOM, XPCOM API Reference
		The EndReading function returns a const char_type pointer to the element just beyond the last element of the string's internal buffer.
1159	Insert	XPCOM, XPCOM API Reference
		The Insert family of functions inserts a value into a string's internal buffer.
1160	Length	XPCOM, XPCOM API Reference
		The Length function returns the number of storage units in the string's internal buffer (not including the null-terminator if present).
1161	Replace	XPCOM, XPCOM API Reference
		The Replace family of functions sets the value of a string's internal buffer.
1162	operator+=	XPCOM, XPCOM API Reference
		This operator+= is a shortcut for the Append family of functions.
1163	operator=	XPCOM, XPCOM API Reference
		This operator is a shortcut for the Assign family of functions.
1164	nsACString (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1165	nsACString_internal
		Class Declaration
1166	nsAString	XPCOM, XPCOM API Reference
		The nsAString abstract class represents a character string composed of double-byte storage units. This class is typically used to represent Unicode character arrays.
1167	Append	XPCOM, XPCOM API Reference
		The Append family of functions appends a value to the end of a string's internal buffer.
1168	Assign	XPCOM, XPCOM API Reference
		The Assign family of functions sets the value of a string's internal buffer.
1169	BeginReading	XPCOM, XPCOM API Reference
		The BeginReading function returns a const pointer to the first element of the string's internal buffer.
1170	Cut	XPCOM, XPCOM API Reference
		The Cut function removes a section of the string's internal buffer.
1171	EndReading	XPCOM, XPCOM API Reference
		The EndReading function returns a const char_type pointer to the element just beyond the last element of the string's internal buffer.
1172	Insert	XPCOM, XPCOM API Reference
		The Insert family of functions inserts a value into a string's internal buffer.
1173	Length	XPCOM, XPCOM API Reference
		The Length function returns the number of storage units in the string's internal buffer (not including the null-terminator if present).
1174	Replace	XPCOM, XPCOM API Reference
		The Replace family of functions sets the value of a string's internal buffer.
1175	operator+=	XPCOM, XPCOM API Reference
		This operator+= is a shortcut for the Append family of functions.
1176	operator=	XPCOM, XPCOM API Reference
		This operator= is a shortcut for the Append family of functions.
1177	nsAString (External)
		Class Declaration
1178	nsAString_internal
		Class Declaration
1179	nsAdoptingCString
		Class Declaration
1180	nsAdoptingString
		Class Declaration
1181	nsAutoRef
		nsAutoRef<t> is a template class implementing an object that holds a handle to a resource that must be released, typically on destruction of the object.</t>
1182	nsAutoRefTraits
		nsAutoRefTraits<t> is a template class describing traits of resources held by objects of class nsAutoRef<T> and/or nsCountedRef<T>.</t>
1183	nsAutoString
		Class Declaration
1184	nsAutoString (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1185	nsCAutoString
		Class Declaration
1186	nsCAutoString (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1187	nsCOMPtr	XPCOM, XPCOM API Reference
		This utility class simplifies managing XPCOM interface references from C++ code.
1188	nsCString
		Class Declaration
1189	nsCString external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1190	nsCStringContainer (External)	Reference, Référence(2), needsattention, strings
		Class Declaration
1191	nsCStringEncoding	XPCOM, XPCOM API Reference
		The nsCStringEncoding enumeration describes the set of character encodings understood by the NS_CStringToUTF16 and NS_UTF16ToCString functions.
1192	nsCountedRef
		nsCountedRef<t> is a template class implementing an object that takes a strong reference to a reference-counted resource that must be released, typically on destruction of the object.</t>
1193	nsDependentCString
		Class Declaration
1194	nsDependentCString external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1195	nsDependentCSubstring
		Class Declaration
1196	nsDependentCSubstring external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1197	nsDependentString
		Class Declaration
1198	nsDependentString external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1199	nsDependentSubstring
		Class Declaration
1200	nsDependentSubstring external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1201	nsEmbedCString	XPCOM, XPCOM API Reference
		The nsEmbedCString concrete class provides a way to construct a nsACString object that allocates null-terminated storage.
1202	get	XPCOM, XPCOM API Reference
		The get function returns a const pointer to the string's null-terminated, internal buffer.
1203	nsEmbedCString	XPCOM, XPCOM API Reference
		Constructors for nsEmbedCString.
1204	operator=	XPCOM, XPCOM API Reference
		This operator is a shortcut for the inherited nsACString::Assign family of functions.
1205	nsEmbedString	XPCOM, XPCOM API Reference
		The nsEmbedString concrete class provides a way to construct a nsAString object that allocates null-terminated storage.
1206	get	XPCOM, XPCOM API Reference
		The get function returns a const pointer to the string's null-terminated, internal buffer.
1207	nsEmbedString	XPCOM, XPCOM API Reference
		Constructors for nsEmbedString.
1208	operator=	XPCOM, XPCOM API Reference
		This operator is a shortcut for the inherited nsAString::Assign family of functions.
1209	nsFixedCString
		Class Declaration
1210	nsFixedString
		Class Declaration
1211	nsLiteralCString (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1212	nsLiteralString (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1213	nsMemory	NeedsRelocation, Reference, Référence(2), XPCOM, XPCOM API Reference
		The nsMemory class provides static helper routines to manage memory. These routines allow easy access to XPCOM's global nsIMemory implementation without having to go through the service manager to get it.
1214	Alloc	XPCOM, XPCOM API Reference
		The Alloc function allocates a block of memory of a particular size.
1215	Clone	XPCOM, XPCOM API Reference
		The Clone function creates a copy of an existing memory block up to the size specified.
1216	Free	XPCOM, XPCOM API Reference
		The Free function frees a block of memory that was allocated by XPCOM's memory manager.
1217	GetGlobalMemoryService	XPCOM, XPCOM API Reference
		The GetGlobalMemoryService function returns a reference to XPCOM's global nsIMemory object.
1218	HeapMinimize	XPCOM, XPCOM API Reference
		The HeapMinimize function attempts to shrink the size of the heap.
1219	Realloc	XPCOM, XPCOM API Reference
		The Realloc function reallocates a block of memory to a new size.
1220	nsPromiseFlatCString
		Class Declaration
1221	nsPromiseFlatString
		Class Declaration
1222	nsRefPtr	RefPtr, nsCOMPtr, nsRefPtr
		RefPtr (formerly known as nsRefPtr, see bug 1207245) is a general class to implement reference counting pointers for objects. It is similar to nsCOMPtr, but does not require that the type be an XPCOM interface. Like with nsCOMPtr, it is the responsibility of the object itself to implement reference counting. This is done using the functions AddRef() and Release(), which respectively modify a variable of type nsAutoRefCnt, which basically is a wrapper around a count of the number of references refering to the class.
1223	nsString
		Class Declaration
1224	nsString external	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1225	nsStringContainer (External)	NeedsContent, Reference, Référence(2), strings
		Class Declaration
1226	nsSupportsWeakReference	XPCOM, XPCOM API Reference
		Inherit from this C++ class to add canonical support for nsISupportsWeakReference.
1227	nsXPIDLCString
		Class Declaration
1228	nsXPIDLString
		Class Declaration
1229	XPCOM primitive	XPCOM, XPCOM API Reference
		An XPCOM primitive is an XPCOM object that "boxes" a value of a primitive type. All XPCOM primitives are scriptable, and they all implement an XPCOM interface from the table below.
1230	XPCOM string functions	Landing, Mozilla, XPCOM, strings
		XPCOM provides these low-level string functions to let you work with strings; however, it's often better to use one of the string classes rather than directly using these functions.
1231	NS_CStringAppendData	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringAppendData function appends data to the existing value of a nsACString instance. This is a low-level API.
1232	NS_CStringCloneData	XPCOM, XPCOM API Reference
		The NS_CStringCloneData function returns a null-terminated, heap allocated copy of the string's internal buffer.
1233	NS_CStringContainerFinish	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringContainerFinish function releases any memory allocated by a nsCStringContainer instance.
1234	NS_CStringContainerInit	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringContainerInit function initializes a nsCStringContainer instance for use as a nsACString.
1235	NS_CStringContainerInit2	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringContainerInit2 function initializes a nsCStringContainer instance for use as a nsACString.
1236	NS_CStringCopy	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringCopy function copies the value from one nsACString instance to another. This is a low-level API.
1237	NS_CStringCutData	XPCOM, XPCOM API Reference
		The NS_CStringCutData function removes a section of the string's internal buffer. This is a low-level API.
1238	NS_CStringGetData	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringGetData function gives the caller read access to the string's internal buffer.
1239	NS_CStringGetMutableData	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringGetMutableData function gives the caller write access to the string's internal buffer.
1240	NS_CStringInsertData	XPCOM, XPCOM API Reference
		The NS_CStringInsertData function appends data to the existing value of a nsACString instance. This is a low-level API.
1241	NS_CStringSetData	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringSetData function copies data into the string's internal buffer. This is a low-level API.
1242	NS_CStringSetDataRange	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringSetDataRange function copies data into a section of the string's internal buffer. This is a low-level API.
1243	NS_CStringToUTF16	XPCOM, XPCOM API Reference
		The NS_CStringToUTF16 function converts the value of a nsACString instance to UTF-16 and stores the result in a nsAString instance.
1244	NS_StringAppendData	XPCOM, XPCOM API Reference
		The NS_StringAppendData function appends data to the existing value of a nsAString instance. This is a low-level API.
1245	NS_StringCloneData	XPCOM, XPCOM API Reference
		The NS_StringCloneData function returns a null-terminated, heap allocated copy of the string's internal buffer.
1246	NS_StringContainerFinish	XPCOM, XPCOM API Reference
		The NS_StringContainerFinish function releases any memory allocated by a nsStringContainer instance. This is a low-level API.
1247	NS_StringContainerInit	XPCOM, XPCOM API Reference
		The NS_StringContainerInit function initializes a nsStringContainer instance for use as a nsAString. This is a low-level API.
1248	NS_StringCopy	XPCOM, XPCOM API Reference
		The NS_StringCopy function copies the value from one nsAString instance to another. This is a low-level API.
1249	NS_StringCutData	XPCOM, XPCOM API Reference
		The NS_StringCutData function removes a section of the string's internal buffer. This is a low-level API.
1250	NS_StringGetData	XPCOM, XPCOM API Reference
		The NS_StringGetData function gives the caller access to the string's internal buffer. This is a low-level API.
1251	NS_StringInsertData	XPCOM, XPCOM API Reference
		The NS_StringInsertData function appends data to the existing value of a nsACString instance. This is a low-level API.
1252	NS_StringSetData	XPCOM, XPCOM API Reference
		The NS_StringSetData function copies data into the string's internal buffer. This is a low-level API.
1253	NS_StringSetDataRange	XPCOM, XPCOM API Reference
		The NS_StringSetDataRange function copies data into a section of the string's internal buffer. This is a low-level API.
1254	NS_UTF16ToCString	XPCOM, XPCOM API Reference
		The NS_UTF16ToCString function converts the value of a nsAString instance from UTF-16 to the specified multi-byte encoding and stores the result in a nsACString instance.
1255	nsGetModuleProc
		This function prototype provides the XPCOM entry-point into a module.
1256	nsIAbCard/Thunderbird3	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, thunderbird
		The nsIAbCard interface is used to represent and manipulate cards in the address book. In a big change from the original nsIAbCard, properties are now stored in a hash table instead of as attributes on the interface, allowing it to be more flexible.
1257	nsICookie2 MOZILLA 1 8 BRANCH	Interfaces, XPCOM, XPCOM API Reference
		No summary!
1258	nsIMsgSearchValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchValue.idl
1259	nsMsgMessageFlags
		The nsMsgMessageFlags interface describes possible flags for messages. Equivalent flags are also defined in nsMsgMessageFlags.h.
1260	nsMsgNavigationType	Interfaces, XPCOM, XPCOM API Reference, thunderbird
		The nsMsgNavigationType interface contains constants used for message navigation in Thunderbird. For example to move forward a message, you would call:
1261	nsMsgSearchOpValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1262	nsMsgViewCommandCheckState	Interfaces, XPCOM, XPCOM API Reference, thunderbird
		The nsMsgViewCommandCheckState interface contains constants used for command status in Thunderbird. It is (as far as I can tell) not currently used anywhere in Thunderbird.
1263	nsMsgViewCommandType	Interfaces, XPCOM, XPCOM API Reference, thunderbird
		The nsMsgViewCommandType interface contains constants used for commands in Thunderbird. For example to mark a message read, you would call:
1264	nsMsgViewFlagsType	Interfaces, XPCOM, XPCOM API Reference, thunderbird
		The nsMsgViewFlagsType interface contains constants used for view flags in Thunderbird. This interface isn't ever implemented. It is only used to store constants. For example, the 'unread only' view would use the flag:
1265	nsMsgViewSortOrder	Interfaces, XPCOM, XPCOM API Reference, thunderbird
		The nsMsgViewSortOrder interface contains constants used for sort direction in Thunderbird. This interface isn't ever implemented. It is only used to store constants. For example to sort by date you would pass a function the value:
1266	nsMsgViewSortType	Interfaces, XPCOM, XPCOM API Reference, thunderbird
		The nsMsgViewSortType interface contains constants used for sorting the Thunderbird threadpane. This interface isn't ever implemented. It is only used to store constants. For example to sort by date you would pass a function the value:
1267	nsMsgViewType	Interfaces, XPCOM, XPCOM API Reference, thunderbird
		The nsMsgViewType interface contains constants used for views in Thunderbird. This interface isn't ever implemented. It is only used to store constants. For example, to request the 'show all threads' view use the constant:
1268	nsStaticModuleInfo
		This data structure is used by NS_InitXPCOM3 to specify static XPCOM modules.
1269	XPCOM tasks	XPCOM
		The XPCOM module roughly parallels the C/C++ standard libraries. It overlaps them significantly, but goes beyond them in capabilities. XPCOM sits above the standard libraries. Its role is to extend them with facilities tailored to XPCOM development in general, and specifically the needs of Mozilla. Like the standard libraries, XPCOM must be a fairly self-contained library, so as not to encumber clients with any unnecessary external dependencies.
1270	Xptcall Porting Guide
		Original Author: John Bandhauer, 31 May 1999.
1271	Xptcall Porting Status
		This is a status page for the multiplatform porting of xptcall. xptcall has a FAQ and a Porting Guide.
1272	already_AddRefed	XPCOM, XPCOM API Reference, nsCOMPtr
		already_AddRefed in association with nsCOMPtr allows you to assign in a pointer without AddRefing it.
1273	nsCOMPtr versus RefPtr
		Gecko code uses both nsCOMPtr and RefPtr as smart pointers. This guide provides some explanation and advice on how to choose between them.
1274	wrappedJSObject	XPCOM:Language Bindings, XPConnect
		wrappedJSObject is a property sometimes available on XPConnect wrappers. When available, it lets you access the JavaScript object hidden by the wrapper.
1275	xptcall FAQ	XPCOM, XPCOM:Language Bindings, XPConnect
		xptcall is a small low level XPCOM method call library. It is implemented using platform specific C/C++ and assembly language code. It is used to facilitate cross language and cross thread method calls. Porting this code is required in order to make Mozilla run on any given platform.