Index

Found 1271 pages:

#	Page	Tags and summary
1	XPCOM	Add-ons, Extensions, Landing, Mozilla, XPCOM, add-ons
		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, add-ons
		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, add-ons
		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, add-ons
		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 1271 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
		Fabian Guisset <[email protected]>
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
		No summary!
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
		No summary!
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, 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, 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, add-ons
		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	Components, Language Bindings, Mozilla, XPCOM
		This function provides a safe way to expose a function from a privileged scope to a less-privileged scope. In this way privileged code, such as an add-on, can share code with less-privileged code like a normal web page script. A function exported from privileged to less-privileged code can be called from the less privileged code's context.
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	NeedsExample, 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	Storage	Guide, Interfaces, Storage, Toolkit API, storage
		Technical review completed.
73	Performance	Storage, Toolkit API, storage
		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.
74	Warnings	Storage, Warnings, storage
		Storage sometimes warns about things to stderr.  This page is designed to help explain the cause and possible solutions for these warnings.
75	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.
76	Frequently Asked Questions	XPCOM
		No summary!
77	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.
78	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.
79	Status, Recent Changes, and Plans	XPCOM
		No summary!
80	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.
81	Using nsIDirectoryService	Extensions, Guide, XPCOM
		Technical review completed.
82	Using nsIPasswordManager	Guide, Interfaces, Login Manager, Security
		Technical review completed.
83	Using nsISimpleEnumerator
		No summary!
84	Using the Gecko SDK	Add-ons, Developing Mozilla, Extensions, Gecko, NeedsContent, add-ons
		No summary!
85	Using the clipboard	Add-ons, Clipboard, Extensions, Guide, Mozilla, XPCOM
		This section provides information about cutting, copying, and pasting to and from the clipboard.
86	Weak reference	XPCOM
		In XPCOM, a weak reference is a special object that contains a pointer to an XPCOM object, but does not keep that object alive. If the referent object is destroyed before the weak reference, the pointer inside the weak reference is set to nsnull.
87	Working with Multiple Versions of Interfaces	Add-ons, Extensions, XPCOM, add-ons
		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.
88	Working with out parameters	Add-ons, Extensions, XPCOM:Language Bindings, XPConnect, add-ons
		No summary!
89	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'.
90	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.
91	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.
92	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.
93	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.
94	XPCOM guide	Add-ons, Extensions, Guide, Landing, Mozilla, XPCOM, add-ons
		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.
95	Avoiding leaks in JavaScript XPCOM components	Add-ons, Developing Mozilla, Extensions, NeedsUpdate, Obsolete, XPCOM, XPCOM:Language Bindings, XPConnect, add-ons
		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.
96	Creating XPCOM components	Deprecated, Guide, NeedsMarkupWork, XPCOM
		This guide is about Gecko, and about creating XPCOM components for Gecko-based applications.
97	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.
98	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).
99	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).
100	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.
101	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.
102	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.
103	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.
104	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.
105	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.
106	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.
107	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.
108	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.
109	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.
110	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).
111	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.
112	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).
113	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.
114	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.
115	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.
116	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.
117	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:
118	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.
119	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.
120	XPCOM reference	Add-ons, Extensions, Landing, Mozilla, Reference, XPCOM, add-ons
		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.
121	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.
122	NS_Alloc	Functions, Functions:Frozen, NeedsRelocation, Reference, Référence, XPCOM, XPCOM API Reference
		Infallibly allocates a block of memory using the XPCOM memory manager.
123	NS_Free	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		Frees a block of memory using the XPCOM memory manager.
124	NS_GetComponentManager	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetComponentManager function returns a reference to the XPCOM Component Manager.
125	NS_GetComponentRegistrar	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetComponentRegistrar function returns a reference to the XPCOM Component Registrar.
126	NS_GetMemoryManager	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetMemoryManager function returns a reference to the XPCOM Memory Manager.
127	NS_GetServiceManager	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_GetServiceManager function returns a reference to the XPCOM service manager.
128	NS_InitXPCOM2	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_InitXPCOM2 function initiates use of XPCOM in the calling process.
129	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.
130	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.
131	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.
132	NS_Realloc	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		Reallocates a block of memory using the XPCOM memory manager.
133	NS_ShutdownXPCOM	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_ShutdownXPCOM function terminates use of XPCOM in the calling process.
134	nsresult	Errors, Mozilla, Reference, Référence, 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.
135	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.
136	NS ENSURE SUCCESS	XPCOM, XPCOM_Macros
		Macro
137	NS ENSURE TRUE	XPCOM, XPCOM_Macros
		Macro
138	NS_ABORT_IF_FALSE
		This was removed in bug 1127201
139	NS_ADDREF	XPCOM, XPCOM_Macros
		Macro
140	NS_ASSERTION	XPCOM, XPCOM_Macros
		Macro
141	NS_ENSURE_ARG_POINTER	XPCOM, XPCOM_Macros
		Macro
142	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.
143	NS_IF_ADDREF	XPCOM, XPCOM_Macros
		Macro
144	NS_IF_RELEASE	XPCOM, XPCOM_Macros
		Macro
145	NS_RELEASE	XPCOM, XPCOM_Macros
		Macro
146	NS_WARNING	XPCOM, XPCOM_Macros
		Macro
147	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.
148	nsCategoryManager	Components, Components:Frozen, XPCOM, XPCOM API Reference
		The XPCOM Category Manager.
149	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.
150	nsLocalFile	Components, Components:Frozen, XPCOM, XPCOM API Reference
		A component implementing nsILocalFile.
151	nsObserverService	Components, NeedsContent, Reference, Référence, XPCOM
		The XPCOM Observer Service.
152	nsScriptableInputStream	Components, Components:Frozen, XPCOM, XPCOM API Reference
		A component implementing nsIScriptableInputStream.
153	XPCOM Interface Reference	XPCOM, XPCOM Interface Reference
		This is a reference to the XPCOM interfaces provided by the Mozilla platform.
154	ExtensionManager (Toolkit)	Extensions
		The ExtensionManager follows the nsIExtensionManager API.
155	IAccessible2	Interfaces, NeedsContent, XPCOM, XPCOM Interface Reference
		Returns the attributes specific to this IAccessible2 object, such as a cell's formula.
156	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.
157	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.
158	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:
159	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.
160	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.
161	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.
162	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:
163	IAccessibleRelation	Interfaces, NeedsContent, XPCOM, XPCOM Interface Reference
		Returns a localized version of the relation type.
164	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().
165	IAccessibleTable2	Interfaces, NeedsHelp
		Please also refer to the IAccessibleTableCell interface. If you want to support older applications you should also support the IAccessibleTable interface.
166	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.
167	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().
168	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.
169	IDispatch	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
170	IJSDebugger	Debugger, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Implemented by: @mozilla.org/jsdebugger;1 as a service:
171	amIInstallCallback	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when an install completes or fails.
172	amIInstallTrigger	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Retained for backwards compatibility.
173	amIWebInstallInfo	Add-on Manager, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Starts all installs.
174	amIWebInstallListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when the website is not allowed to directly prompt the user to install add-ons.
175	amIWebInstallPrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Gets a confirmation that the user wants to start the installs.
176	amIWebInstaller	Extension Manager, Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM Interface Reference
		Installs an array of add-ons at the request of a webpage.
177	imgICache	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Evict images from the cache.
178	imgIContainer	Interfaces, Interfaces:Scriptable, NeedsContent, NeedsUpdate, Reference, Référence, Thebes, XPCOM Interface Reference, needsattention
		Implemented by: ?????????????????????????????????????. To create an instance, use:
179	imgIContainerObserver	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference, needsattention
		If you wish to listen for activities on an imgIContainer, you should implement the frameChanged() method.
180	imgIDecoder
		This interface is the base class for decoders for specific image formats.
181	imgIDecoderObserver	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, 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.
182	imgIEncoder	Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM Interface Reference
		Possible values for input format (note that not all image formats support saving alpha channels):
183	imgILoader	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		Implemented by @mozilla.org/image/loader;1 as a service:
184	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.
185	inIDOMUtils	Interfaces, Interfaces:Scriptable, Reference, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/inspector/dom-utils;1 as a service:
186	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.
187	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.
188	mozIAsyncHistory	Interfaces, Interfaces:Scriptable, Places, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/history;1 as a service:
189	mozIColorAnalyzer	Interfaces, Interfaces:Scriptable, Places, Reference, Référence, 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.
190	mozIJSSubScriptLoader	Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/moz/jssubscript-loader;1. To get this service, use:
191	mozIPersonalDictionary	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/spellchecker/personaldictionary;1.  To access this service, use
192	mozIPlaceInfo
		No summary!
193	mozIPlacesAutoComplete	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM Interface Reference
		Mark a page as being currently open.
194	mozIRegistry
		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.
195	mozIRepresentativeColorCallback	Interfaces, Interfaces:Scriptable, Places, XPCOM API Reference, XPCOM Interface Reference
		Will be called when color analysis finishes.
196	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.
197	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().
198	mozIStorageAsyncStatement	Stub
		An asynchronous SQL statement.
199	mozIStorageBindingParams	Interfaces, Interfaces:Scriptable, Storage, storage
		The mozIStorageBindingParams interface is used to bind values to parameters prior to calling mozIStorageStatement.executeAsync().
200	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().
201	mozIStorageCompletionCallback
		This interface should be implemented to handle callbacks from asynchronous Storage API routines.
202	mozIStorageConnection	Interfaces, Storage, XPCOM, XPCOM API Reference
		For a general overview on how to use this interface, see Storage.
203	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.
204	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().
205	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.
206	mozIStorageProgressHandler	Interfaces, Storage, XPCOM, XPCOM API Reference
		The mozIStorageProgressHandler interface lets storage consumers receive callbacks during the execution of sqlite requests.
207	mozIStorageResultSet	Interfaces, Storage
		The mozIStorageResultSet interface represents a set of results from a storage statement.
208	mozIStorageRow	Interfaces, Storage
		The mozIStorageRow interface represents a row in the result set from a storage database query.
209	mozIStorageService	Interfaces, Interfaces:Scriptable, Storage, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		See mozIStorageConnection
210	mozIStorageStatement	Interfaces, Storage, XPCOM, XPCOM API Reference, storage
		For an introduction on how to use this interface, see the Storage overview document.
211	mozIStorageStatementCallback
		The mozIStorageStatementCallback interface represents a callback handler that the Storage API calls with result, error, and completion notifications while handling asynchronous database queries.
212	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:
213	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:
214	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.
215	mozIStorageVacuumParticipant
		To create an instance of this interface, use the Category Manger, with the category "vacuum-participant".
216	mozIStorageValueArray	Interfaces, Storage, XPCOM, XPCOM API Reference, storage
		The mozIStorageValueArray interface obtains provides methods to obtain data from a given result.
217	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.
218	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:
219	mozIVisitInfo
		No summary!
220	mozIVisitInfoCallback	Interfaces, Interfaces:Scriptable, Places, Reference, Référence, XPCOM Interface Reference
		Called when a mozIPlaceInfo couldn't be processed.
221	mozIVisitStatusCallback	Interfaces, Interfaces:Scriptable, Places, Reference, Référence, 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.
222	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 https://mxr.mozilla.org/comm-central/source//mailnews/addrbook/public/nsIAbCard.idl for more details.
223	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.
224	nsIAbstractWorker	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		No summary!
225	nsIAccelerometerUpdate	Interfaces, NeedsContent, XPCOM, XPCOM Interface Reference
		This method is only used in content tabs to receive nsIAcceleration data from the chrome process.
226	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.
227	DOMNode
		No summary!
228	GetChildNodeAt
		No summary!
229	GetComputedStyleCSSValue
		No summary!
230	GetComputedStyleValue
		No summary!
231	accessibleDocument
		No summary!
232	firstChildNode
		No summary!
233	innerHTML
		For the DOM property, see Element.innerHTML.
234	language
		No summary!
235	lastChildNode
		No summary!
236	nextSiblingNode
		No summary!
237	numChildren
		No summary!
238	parentNode
		No summary!
239	previousSiblingNode
		No summary!
240	scrollTo
		No summary!
241	scrollToPoint
		No summary!
242	nsIAccessibilityService	Accessibility, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		No summary!
243	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.
244	Attributes
		Attributes of accessible.
245	ChildCount
		Number of accessible children.
246	Children
		Array of all this node's children.
247	DefaultKeyBinding
		Provides localized string of global keyboard accelerator for default action, such as Ctrl+O for Open file (Ctrl + O).
248	Description
		Accessible description -- long text associated with this node.
249	DoAction
		This method performs the accessible action at the given zero-based index. Action number 0 is the default action.
250	ExtendSelection
		This method extends the current selection from its current accessible anchor node to this accessible.
251	FirstChild
		Returns first child node in accessible tree.
252	FocusedChild
		Focused accessible child of node.
253	GetAccessibleAbove
		This method returns an accessible node geometrically above this one.
254	GetAccessibleBelow
		This method returns an accessible node geometrically below this one.
255	GetAccessibleRelated
		This method returns an accessible related to this one by the given relation type.
256	GetAccessibleToLeft
		This method returns an accessible node geometrically to the left of this one.
257	GetAccessibleToRight
		This method returns an accessible node geometrically to the right of this one.
258	GetActionDescription
		This method retrieves the description (localized name) of the accessible action at the given zero-based index.
259	GetActionName
		This method retrieves the name of the accessible action at the given zero-based index.
260	GetBounds
		This method returns accessible's (x and y) coordinates relative to the screen and accessible's width and height.
261	GetChildAt
		This method returns Nth accessible child using zero-based index.
262	GetChildAtPoint
		This method returns an accessible child which contains the coordinate at (x, y) in screen pixels.
263	GetKeyBindings
		This method provides array of localized string of global keyboard accelerator for the given action index supported by accessible.
264	GetRelation
		This method returns accessible relation for this accessible object by index.
265	GetRelations
		This method returns multiple accessible relations for this accessible object.
266	GetState
		This method retrieves states of the accessible.
267	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.
268	Help
		Help text associated with node.
269	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.
270	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.
271	LastChild
		Returns last child node in accessible tree.
272	Name
		Accessible name -- the main text equivalent for this node.
273	NextSibling
		Returns next sibling in accessible tree.
274	NumActions
		The number of accessible actions associated with this accessible.
275	Parent
		Returns parent node in accessible tree.
276	PreviousSibling
		Returns previous node in accessible tree.
277	RelationsCount
		Returns the number of accessible relations for this object.
278	Role
		Enumerated accessible role for the associated element. The values depend on platform because of variations. See the ROLE_* constants in roles documentation.
279	SetSelected
		This method adds or remove this accessible to the current selection.
280	TakeFocus
		This method focuses this accessible node.
281	TakeSelection
		This method selects this accessible node only.
282	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.
283	nsIAccessibleCaretMoveEvent	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
284	nsIAccessibleCoordinateType	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Prior to Gecko 1.9, these constants were implemented in nsIAccessibleText.
285	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()
286	nsIAccessibleEditableText	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Copies the text range into the clipboard.
287	DeleteText	delete
		Documentation is now located at nsIAccessibleEditableText.DeleteText().
288	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:
289	nsIAccessibleHyperLink	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns a reference to the object at the given index.
290	nsIAccessibleHyperText	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Retrieves the nsIAccessibleHyperLink object at the given link index.
291	GetLink
		No summary!
292	GetLinkIndex
		No summary!
293	LinkCount
		No summary!
294	nsIAccessibleImage	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Returns the coordinates of the image accessible.
295	GetImagePosition
		This content is now available at nsIAccessibleImage.GetImagePosition().
296	GetImageSize
		This content is now available at nsIAccessibleImage.GetImageSize().
297	nsIAccessibleProvider	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
298	nsIAccessibleRelation	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Returns accessible relation target at the given index.
299	GetTarget
		No summary!
300	GetTargets
		No summary!
301	RelationType
		This content is now available at nsIAccessibleRelation.Attributes.
302	TargetsCount
		No summary!
303	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.
304	nsIAccessibleRole	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
305	nsIAccessibleScrollType	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
306	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.
307	nsIAccessibleStateChangeEvent	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
308	nsIAccessibleStates	Accessibility, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Prior to Gecko 1.9, these constants were implemented in nsIAccessible.
309	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).
310	nsIAccessibleTableCell	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
311	nsIAccessibleTableChangeEvent
		No summary!
312	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.
313	nsIAccessibleTextChangeEvent	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
314	nsIAccessibleTreeCache	Accessibility, Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		A private interface to operate with tree accessible.
315	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.
316	nsIAccessibleWin32Object	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
317	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.
318	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).
319	nsIAnnotationService	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: "@mozilla.org/browser/annotation-service;1". To use this service, use:
320	nsIAppShell	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Creates an application shell.
321	nsIAppShellService	Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/appshell/appShellService;1 as a service:
322	nsIAppStartup	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/toolkit/app-startup;1. To use the service:
323	nsIAppStartup_MOZILLA_2_0	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
324	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.
325	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.
326	nsIApplicationCacheContainer	DOM, Interfaces, Interfaces:Scriptable, Offline_resources, XPCOM, XPCOM Interface Reference
		No summary!
327	nsIApplicationCacheNamespace	DOM, Interfaces, Interfaces:Scriptable, Offline_resources, XPCOM, XPCOM Interface Reference
		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.
328	nsIApplicationCacheService	DOM, Interfaces, Interfaces:Scriptable, Offline_resources, XPCOM, XPCOM Interface Reference
		Flags the specified key as one that should be cached opportunistically.
329	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.
330	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.
331	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).
332	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).
333	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.
334	nsIAsyncVerifyRedirectCallback	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
335	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.
336	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.
337	nsIAuthPrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method puts up a text input dialog with OK and Cancel buttons.
338	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.
339	nsIAuthPromptAdapterFactory	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Wrap an object implementing nsIAuthPrompt so that it's usable via nsIAuthPrompt2.
340	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.
341	nsIAuthPromptProvider	Authentication, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method requests a prompt interface for the given prompt reason.
342	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.
343	nsIAutoCompleteController	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/autocomplete/controller;1. To use this service, use:
344	nsIAutoCompleteInput	Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns the name of one of the autocomplete search session objects.
345	nsIAutoCompleteItem	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
346	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.
347	nsIAutoCompleteObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when a search is complete and the results are ready.
348	nsIAutoCompleteResult
		See nsIAutoCompleteSearch
349	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.
350	nsIBadCertListener2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Replaces the obsolete nsIBadCertListener interface.
351	nsIBidiKeyboard	BiDi, Interfaces, Interfaces:Scriptable, Right-to-left, XPCOM, XPCOM Interface Reference
		Determines if the current keyboard language is right-to-left.
352	nsIBinaryInputStream	File I/O, Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Reads from the stream.
353	nsIBinaryOutputStream	File I/O, Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Sets the stream to which output is directed.
354	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.
355	nsIBlocklistService	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Firefox 29
356	nsIBoxObject	Interfaces, Interfaces:Scriptable, NeedsContent
		To get an instance, use the boxObject property.
357	nsIBrowserBoxObject
		The boxObject belonging to a XUL browser element implements this interface.
358	nsIBrowserHistory	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/nav-history-service;1. To use this service, use:
359	nsIBrowserSearchService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/search-service;1. To access this service, use:
360	nsICRLInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
361	nsICRLManager	Interfaces, Interfaces:Scriptable, NeedsContent, Security, XPCOM Interface Reference
		No summary!
362	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.
363	nsICacheDeviceInfo	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
364	nsICacheEntryDescriptor	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method explicitly closes the descriptor (optional).
365	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.
366	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.
367	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.
368	nsICacheService	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method creates a cache session.
369	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.
370	nsICacheVisitor	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method is called to provide information about a cache device.
371	nsICachingChannel	Cache, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface provides:
372	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.
373	nsICategoryManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/categorymanager;1. To use this service, use:
374	addCategoryEntry
		No summary!
375	deleteCategory
		No summary!
376	deleteCategoryEntry
		No summary!
377	enumerateCategories
		No summary!
378	enumerateCategory
		No summary!
379	getCategoryEntry
		No summary!
380	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.
381	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.
382	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.
383	nsICharsetResolver	Interfaces, Interfaces:Scriptable, Obsolete, XPCOM, XPCOM Interface Reference
		Some implementations may request that they be notified when the charset is actually detected.
384	nsIChromeFrameMessageManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Loads a script into the remote frame.
385	nsIChromeRegistry	Interfaces, NeedsContent, Reference, Référence, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/chrome/chrome-registry;1 as a service:
386	nsIClassInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Bitflags for 'flags' attribute.
387	classDescription
		No summary!
388	classID
		No summary!
389	classIDNoAlloc
		No summary!
390	flags
		No summary!
391	getHelperForLanguage
		No summary!
392	getInterfaces
		This content is now available at nsIClassInfo.getInterfaces().
393	implementationLanguage
		No summary!
394	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.
395	nsIClipboardCommands	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns whether we can copy an image's contents.
396	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.
397	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:
398	nsIClipboardHelper	Clipboard, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method copies string to (default) clipboard.
399	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.
400	nsICollection	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Appends a new item to the collection.
401	nsICommandController	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference, commands, controllers
		Implemented by: @mozilla.org/embedcomp/base-command-controller;1. To create an instance, use:
402	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.
403	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.
404	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.
405	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.
406	createInstanceByContractID
		No summary!
407	getClassObject
		No summary!
408	getClassObjectByID
		No summary!
409	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.
410	CIDToContractID
		No summary!
411	autoRegister
		No summary!
412	autoUnregister
		No summary!
413	contractIDToCID
		No summary!
414	enumerateCIDs
		No summary!
415	enumerateContractIDs
		No summary!
416	isCIDRegistered
		No summary!
417	isContractIDRegistered
		No summary!
418	registerFactory
		No summary!
419	registerFactoryLocation
		No summary!
420	unregisterFactory
		No summary!
421	unregisterFactoryLocation
		No summary!
422	nsICompositionStringSynthesizer	DOM, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		This interface is obsoleted in Gecko 38. You need to use nsITextInputProcessor instead of this.
423	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()
424	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.
425	nsIConsoleService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/consoleservice;1 as a service:
426	nsIContainerBoxObject	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		The boxObject belonging to a XUL browser, editor or iframe element implements this interface.
427	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.
428	nsIContentPolicy	Interfaces, Interfaces:Scriptable, NeedsMarkupWork, Reference, Référence, XPCOM, XPCOM Interface Reference
		You can observe content that is being loaded into your browser by implementing nsIContentPolicy. This interface can be very useful if you are developing a content-aware plugin (blocking ads or altering the look of content, for example), or if you want to stop or allow user-browsed URLs.
429	nsIContentPref	Preferences, XPCOM
		No summary!
430	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.
431	nsIContentPrefObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when a content preference is removed.
432	nsIContentPrefService	Interfaces, Interfaces:Scriptable, Preferences, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Use the asynchronous interface nsIContentPrefService2 instead.
433	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.)
434	nsIContentSecurityPolicy	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Verifies ancestry as permitted by the policy.
435	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.
436	nsIContentView	Electrolysis, Interfaces, Interfaces:Scriptable, Mobile, XPCOM Interface Reference
		See Working with content views for details on how to use this API.
437	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.
438	nsIContentViewer	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference, needsattention
		Implemented by: ?????????????????????????????????????. To create an instance, use:
439	nsIController	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, commands
		When this method is called, your implementation should execute the command with the specified name.
440	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.
441	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:
442	nsIConverterOutputStream	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/converter-output-stream;1. To create an instance, use:
443	nsICookie	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An optional interface for accessing the HTTP or javascript cookie object.
444	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.
445	nsICookieAcceptDialog	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
446	nsICookieConsent	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Inherits from: nsISupports
447	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.
448	nsICookieManager2	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, cookies
		The nsICookieManager2 interface contains additional methods that expand upon the nsICookieManager interface.
449	nsICookiePermission	Cookies, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
		The nsICookiePermission interface is used to test for cookie permissions
450	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.
451	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.
452	nsICookieStorage	Cookies, Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
453	nsICrashReporter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Add some extra data to be submitted with a crash report.
454	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.
455	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.
456	nsICurrentCharsetListener	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/currentcharsetlistener;1. To create an instance, use:
457	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.
458	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.
459	nsIDBFolderInfo
		Implemented by: ?????????????????????????????????????. To create an instance, use:
460	nsIDNSListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when an asynchronous host lookup completes.
461	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.
462	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.
463	nsIDNSService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/dns-service;1. To access the service, use:
464	nsIDOMCanvasRenderingContext2D	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		The nsIDOMCanvasRenderingContext2D interface implements the DOM CanvasRenderingContext2D interface. See that page for details.
465	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.
466	nsIDOMClientRect	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This object was renamed a few times: initial name was TextRectangle, then ClientRect, then DOMRect.
467	nsIDOMDesktopNotification	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMDesktopNotification interface implements the DOM notification interface. See that page for details.
468	nsIDOMDesktopNotificationCenter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMDesktopNotificationCenter interface implements the DOM navigator.mozNotification interface. See that page for details.
469	nsIDOMElement	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Get an attribute value.
470	nsIDOMEvent	DOM, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
471	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.
472	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.
473	nsIDOMEventTarget	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		See the EventTarget documentation.
474	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.
475	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.
476	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.
477	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.
478	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.
479	nsIDOMFontFace	Interfaces, Interfaces:Scriptable, NeedsContent
		This object describes a single font. It's returned in a list you can get using inIDOMUtils.getUsedFontFaces().
480	nsIDOMFontFaceList	Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM Interface Reference
		Returns the nsIDOMFontFace object at the specified index into the list.
481	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.
482	nsIDOMGeoPosition	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
483	nsIDOMGeoPositionAddress	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This object is obtained from an nsIDOMGeoPositionAddress object via its address attribute.
484	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().
485	nsIDOMGeoPositionCoords	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsIDOMGeoPositionCoords interface describes a geographical location.
486	nsIDOMGeoPositionError	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMGeoPositionError interface represents an error that occurred while performing geolocation operations.
487	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.
488	nsIDOMGeoPositionOptions	DOM, Geolocation, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMGeoPositionOptions interface is used to specify options for geolocation operations.
489	nsIDOMGlobalPropertyInitializer	NeedsContent, Reference, Référence, 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.
490	nsIDOMHTMLAudioElement	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		The nsIDOMHTMLAudioElement interface is used to implement the HTML5 <audio> element.
491	nsIDOMHTMLFormElement	XPCOM, XPCOM Interface Reference
		The nsIDOMHTMLFormElement interface implements the DOM HTMLFormElement interface. See that page for details.
492	nsIDOMHTMLMediaElement	Firefox 3.5, Gecko 1.9.1, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsIDOMHTMLMediaElement interface implements the DOM HTMLMediaElement interface. See that page for details.
493	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.
494	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.
495	nsIDOMJSWindow	Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		One of the interfaces implemented by the window DOM object.
496	nsIDOMMouseScrollEvent	DOM, Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM, XPCOM Interface Reference
		Initializes the progress event object.
497	nsIDOMMozNetworkStats	Interfaces, Reference, Référence, XPCOM
		Implemented by: @mozilla.org/networkStats;1. To create an instance, use:
498	nsIDOMMozNetworkStatsData	Interfaces, Network, XPCOM Interface Reference
		No summary!
499	nsIDOMMozNetworkStatsManager	Interfaces, Network, Reference, Référence, XPCOM Interface Reference
		NOTE: Gecko is a fast evolving project. Please check dom/network/interfaces/nsIDOMNetworkStatsManager.idl to make sure this data is accurate.
500	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.
501	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.
502	nsIDOMNavigatorDesktopNotification	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Property that extends the navigator object.
503	nsIDOMNode	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		No summary!
504	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.
505	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.
506	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.
507	nsIDOMProgressEvent	DOM, Interfaces, Interfaces:Scriptable, Reference, Référence, XMLHttpRequest, XPCOM Interface Reference
		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.
508	nsIDOMSerializer	DOM, Interfaces, Interfaces:Scriptable
		Implemented by: @mozilla.org/xmlextras/xmlserializer;1. To create an instance, use:
509	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.
510	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.
511	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.
512	nsIDOMStorageEvent
		The nsIDOMStorageEvent interface implements the DOM StorageEvent interface. See that page for details.
513	nsIDOMStorageEventObsolete	DOM, Interfaces, Interfaces:Scriptable, 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.
514	nsIDOMStorageItem	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, localStorage, sessionStorage
		No summary!
515	nsIDOMStorageList	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference, globalStorage
		Called when the list of available access points changes.
516	nsIDOMStorageManager	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, localStorage
		Implemented by @mozilla.org/dom/storagemanager;1 as a service:
517	nsIDOMStorageWindow	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
518	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.
519	nsIDOMWindow	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		While this interface is not officially defined by any standard bodies, it originates from the de-facto DOM Level 0 standard.
520	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.
521	nsIDOMWindowInternal	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		It provides many of the common functions used in JavaScript such as alert() or open().
522	nsIDOMWindowUtils	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Implemented by: nsIDOMWindow. To get this interface, use:
523	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:
524	nsIDOMXPathException	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XPath
		No summary!
525	nsIDOMXPathExpression	DOM, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XPath
		Evaluate the XPath expression.
526	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.
527	nsIDOMXULControlElement	Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM Interface Reference
		No summary!
528	nsIDOMXULElement	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Attempts to remove focus from the element.
529	nsIDOMXULLabeledControlElement	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		No summary!
530	nsIDOMXULSelectControlElement	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		No summary!
531	nsIDOMXULSelectControlItemElement	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
532	nsIDataSignatureVerifier	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Verifies that the data matches the data that was used to generate the signature.
533	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.
534	nsIDebug2	Debugging, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		No summary!
535	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.
536	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.
537	nsIDeviceMotionListener	Acceleration, Interfaces, Interfaces:Scriptable, Mobile, Orientation, XPCOM, XPCOM Interface Reference
		Called when new orientation or acceleration data is available.
538	nsIDialogCreator	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
539	nsIDialogParamBlock	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Get a previously set integer.
540	nsIDictionary	Interface Reference, Interfaces, Interfaces:Scriptable, Obsolete, XPCOM, XPCOM API Reference
		Check if a given key is present in the dictionary.
541	nsIDirIndex	Directories, File I/O, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
		No summary!
542	nsIDirIndexListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called for each directory entry.
543	nsIDirIndexParser	Directories, File I/O, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called for each directory entry.
544	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.
545	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.
546	nsIDirectoryService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Initializes the nsIDirectoryService instance.
547	init
		This content is now available at nsIDirectoryService.init().
548	registerProvider
		This content is now available at nsIDirectoryService.registerProvider().
549	unregisterProvider
		This content is now available at nsIDirectoryService.unregisterProvider().
550	nsIDirectoryServiceProvider	Directories, File I/O, Files, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		nsIDirectoryServiceProvider.
551	getFile	Mozilla, Reference, Référence, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called by the Directory Service to obtain an nsIFile object corresponding for a given standard path location.
552	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.
553	getFiles	XPCOM, XPCOM API Reference
		This method is called by the Directory Service to query an enumeration of file or directory locations.
554	nsIDiskCacheStreamInternal	Interfaces, Interfaces:Scriptable, NeedsContent
		We use this method internally to close nsDiskCacheOutputStream under the cache service lock.
555	nsIDispatchSupport	Interfaces, XPCOM, XPCOM Interface Reference
		Converts a COM Variant to a jsval.
556	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.
557	nsIDocumentLoader	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference
		Implemented by: @mozilla.org/docloaderservice;1. To create an instance, use:
558	nsIDownload	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
559	nsIDownloadHistory	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Method overview
560	nsIDownloadManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/download-manager;1. To get the service, use:
561	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.
562	nsIDownloadObserver	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Called to signal a download that has completed.
563	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.
564	nsIDownloader	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Initialize this downloader.
565	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).
566	nsIDragService	Interfaces, Interfaces:Scriptable, Reference, Référence, 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.
567	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.
568	nsIDroppedLinkHandler	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Determines if a link being dragged can be dropped.
569	nsIDroppedLinkItem	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
570	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.
571	nsIEditor	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM API Reference, XPCOM Interface Reference
		No summary!
572	nsIEditorBoxObject	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The boxObject belonging to a XUL editor element implements this interface.
573	nsIEditorDocShell	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Use nsIEditingSession.makeWindowEditable() and nsIEditingSession.getEditorForWindow() from out side.
574	nsIEditorIMESupport	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Handles the start of inline input composition.
575	nsIEditorLogging	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Start logging.
576	nsIEditorMailSupport	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Get a list of IMG and OBJECT tags in the current document.
577	nsIEditorObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called after the editor completes a user action.
578	nsIEditorSpellCheck	Interfaces, Interfaces:Scriptable, Midas, NeedsMarkupWork, Reference, Référence, Spell check, XPCOM Interface Reference
		Implemented by: @mozilla.org/editor/editorspellchecker;1. To create an instance, use:
579	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:
580	nsIEnumerator	Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		nsIEnumerator.idl
581	nsIEnvironment	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/process/environment;1 as a service:
582	nsIErrorService	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Implemented by: @mozilla.org/xpcom/error-service;1
583	nsIEventListenerInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Returns the debugger object if the debug service is active.
584	nsIEventListenerService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/eventlistenerservice;1. To create an instance, use:
585	nsIEventSource	Interfaces, Interfaces:Scriptable, Server-sent events
		This implements the EventSource interface used for server-sent events.
586	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.
587	nsIException	Interfaces, Interfaces:Scriptable, Reference, XPCOM, XPCOM Interface Reference
		A generic formatter - make it suitable to print, etc.
588	nsIExtensionManager	Disambiguation, NeedsContent, NeedsHelp, XPCOM, XPCOM Interface Reference
		Unfortunately, at the time of this writing there are two nsIExtensionManager Interfaces:
589	nsIExternalHelperAppService	Interfaces, MIME
		Implemented by: @mozilla.org/uriloader/external-helper-app-service;1. To access this service, use:
590	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.
591	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.
592	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.
593	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.
594	nsIFactory	Interfaces, Interfaces:Scriptable, NeedsAttention, Reference, Référence, 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.)
595	createInstance
		No summary!
596	lockFactory
		No summary!
597	nsIFaviconDataCallback	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when the required favicon's information is available.
598	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:
599	nsIFeed	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
600	nsIFeedContainer	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Synchronizes a container's fields with its convenience attributes.
601	nsIFeedElementBase	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki link
602	nsIFeedEntry	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki link
603	nsIFeedGenerator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki link
604	nsIFeedPerson	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Interwiki link
605	nsIFeedProcessor	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/feed-processor;1. To create an instance, use:
606	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.
607	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.
608	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.
609	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.
610	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.
611	append
		No summary!
612	appendNative
		No summary!
613	clone
		No summary!
614	contains
		No summary!
615	copyTo
		No summary!
616	copyToFollowingLinks
		No summary!
617	copyToFollowingLinksNative
		This content is now available at nsIFile.copyToFollowingLinksNative().
618	copyToNative
		No summary!
619	create
		No summary!
620	createUnique
		No summary!
621	directoryEntries
		No summary!
622	equals
		No summary!
623	exists
		No summary!
624	fileSize
		No summary!
625	fileSizeOfLink
		No summary!
626	isDirectory
		No summary!
627	isExecutable
		No summary!
628	isFile
		No summary!
629	isHidden
		No summary!
630	isReadable
		No summary!
631	isSpecial
		No summary!
632	isSymlink
		No summary!
633	isWritable
		No summary!
634	lastModifiedTime
		No summary!
635	lastModifiedTimeOfLink
		No summary!
636	leafName
		No summary!
637	moveTo
		No summary!
638	moveToNative
		No summary!
639	nativeLeafName
		No summary!
640	nativePath
		No summary!
641	nativeTarget
		No summary!
642	normalize
		No summary!
643	parent
		No summary!
644	path
		No summary!
645	permissions	XPCOM, XPCOM API Reference
		No summary!
646	permissionsOfLink
		No summary!
647	remove
		No summary!
648	target
		This content is now available at nsIFile.Attributes.
649	nsIFileInputStream	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
650	nsIFileOutputStream	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
651	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:
652	nsIFileProtocolHandler	File I/O, Interfaces, Interfaces:Scriptable, Reference, Référence, 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://.
653	nsIFileSpec
		Declared in xpcom/obsolete/nsIFileSpec.idl
654	nsIFileStreams	File I/O, Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
655	nsIFileURL	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
656	nsIFileUtilities
		Long gone.
657	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.
658	nsIFocusManager	Interfaces, Interfaces:Scriptable, NeedsContent
		Implemented by: @mozilla.org/focus-manager;1 as a service:
659	nsIFormHistory2	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Adds a name and value pair to the form history.
660	nsIFrameLoader	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Activates event forwarding from client (remote frame) to parent.
661	nsIFrameLoaderOwner
		Returns the frame loader object owned by this object.
662	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.
663	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.
664	nsIFrameScriptLoader
		This interface is used to load frame scripts.
665	nsIGSettingsCollection	Interfaces, Interfaces:Scriptable, NeedsContent
		No summary!
666	nsIGSettingsService	Interfaces, Interfaces:Scriptable, NeedsContent
		Implemented by: @mozilla.org/gsettings-service;1 as a service:
667	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().
668	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.
669	nsIGlobalHistory	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Add a page to the history.
670	nsIGlobalHistory2	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Add a URI to global history.
671	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.
672	nsIHTMLEditor	Interfaces, Interfaces:Scriptable, NeedsContent
		Registers a default style property with the editor.
673	nsIHTTPHeaderListener	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference
		No summary!
674	nsIHapticFeedback	Interfaces, Interfaces:Scriptable, Mobile, XPCOM Interface Reference
		Implemented by: @mozilla.org/widget/hapticfeedback;1 as a service:
675	nsIHttpActivityDistributor	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: mozilla.org/network/http-activity-distributor;1 as a service:
676	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.
677	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:
678	nsIHttpChannelInternal	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Gets the request's major and minor version numbers.
679	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.
680	nsIHttpServer
		No summary!
681	nsIHttpUpgradeListener	HTTP, Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM Interface Reference
		This is used, for example, by WebSockets in order to upgrade an HTTP channel to use the WebSocket protocol.
682	nsIIDNService	DNS, Interface Reference, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
		Implemented by: @mozilla.org/network/idn-service;1 as a service:
683	nsIIFrameBoxObject
		The boxObject belonging to a XUL iframe element implements this interface.
684	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.
685	nsIINIParserFactory	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		See Example for how to use this interface.
686	nsIINIParserWriter	Files, Mozilla, Reference, Référence, 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.
687	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).
688	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.
689	nsIInProcessContentFrameMessageManager	Interfaces, XPCOM, XPCOM Interface Reference
		None.
690	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.
691	available
		No summary!
692	close
		No summary!
693	isNonBlocking
		No summary!
694	read
		No summary!
695	readSegments
		No summary!
696	nsIInputStreamCallback	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		Called to indicate that the stream is either readable or closed.
697	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:
698	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.
699	getInterface
		No summary!
700	nsIJSCID	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		None.
701	nsIJSID	Interfaces, Interfaces:Scriptable, XPCOM API Reference, XPCOM Interface Reference
		The following methods return objects that implement this interface:
702	nsIJSIID	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
703	nsIJSON	Interfaces, Interfaces:Scriptable, NeedsExample, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/dom/json;1. To create an instance, use:
704	nsIJSXMLHttpRequest	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		You must call open() on the XMLHttpRequest before setting any event listeners on it.
705	nsIJetpack	Interfaces, Interfaces:Scriptable, Jetpack, XPCOM, XPCOM Interface Reference
		This method asynchronously sends a message to the Jetpack process.
706	nsIJetpackService	Interfaces, Interfaces:Scriptable, Jetpack, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/jetpack/service;1.
707	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.
708	nsIJumpListItem	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Compare this item to another.
709	nsILivemarkService	Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/browser/livemark-service;2. To use this service, use:
710	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.
711	nsILocalFile	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/file/local;1. To create an instance, use:
712	nsILocalFileMac	File I/O, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		None.
713	nsILocale	Interfaces, Interfaces:Scriptable, Localization, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Retrieves a string with the current locale name.
714	nsILocaleService	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/nslocaleservice;1. To use this service, use:
715	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.
716	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.
717	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.
718	nsILoginManagerCrypto	Cryptography, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Decrypts the specified string, returning the plain text value.
719	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.
720	nsILoginManagerPrompter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Initialize the prompter. Must be called before using other interfaces.
721	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.
722	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.
723	nsIMIMEInputStream	Interfaces, Interfaces:Scriptable, MIME
		Implemented by: @mozilla.org/network/mime-input-stream;1. To create an instance, use:
724	nsIMacDockSupport	Dock, Interfaces, Interfaces:Scriptable, Mac OS X, XPCOM Interface Reference
		Implemented by: @mozilla.org/cookie-monster;1. To create an instance, use:
725	nsIMarkupDocumentViewer	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference
		Scroll the make the specified node visible.
726	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.
727	alloc
		No summary!
728	free
		No summary!
729	heapMinimize
		No summary!
730	isLowMemory
		No summary!
731	realloc
		No summary!
732	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.
733	nsIMemoryMultiReporterCallback	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Called to provide information from a multi-reporter. Implement this method to handle the report information.
734	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.
735	nsIMemoryReporterManager	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by @mozilla.org/memory-reporter-manager;1 as a service:
736	nsIMenuBoxObject	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		To get access to the box object for a given menu, use code like this:
737	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.
738	nsIMessageListener
		This interface is used to receive messages sent using the nsIMessageBroadcaster, nsIMessageSender, or nsISyncMessageSender interfaces. Listeners are attached using the nsIMessageListenerManager interface.
739	nsIMessageListenerManager	Interfaces, Interfaces:Scriptable, Message Manager, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/globalmessagemanager;1. To access this service, use:
740	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.
741	nsIMessageWakeupService	Interfaces, XPCOM Interface Reference
		The parentprocessmessagemanager is used for this, so messages send from childprocessmessagemanagers will be heard.
742	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.
743	nsIMicrosummary	Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Add a microsummary observer to this microsummary.
744	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.
745	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.
746	nsIMicrosummaryService	Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/microsummary/service;1 as a service:
747	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.
748	nsIMimeConverter
		The nsIMimeConverter service allows you to convert headers into and out of MIME format.
749	nsIMimeHeaders	Interfaces, XPCOM, XPCOM Interface Reference
		Implemented by: ?????????????????????????????????????. To create an instance, use:
750	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.
751	canUnload
		No summary!
752	getClassObject
		No summary!
753	registerSelf
		No summary!
754	unregisterSelf
		No summary!
755	nsIMsgAccount
		Adds a new identity to this account.
756	nsIMsgAccountManagerExtension	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		The nsIMsgAccountManagerExtension interface is used to add a new panel to Thunderbird's Account Manager.
757	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 "[email protected]". Furthermore we show the new panel only for IMAP accounts...
758	nsIMsgCompFields	Interfaces, XPCOM, XPCOM Interface Reference, thunderbird
		The nsIMsgCompFields interface provides properties for an composition of an outgoing message.
759	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.
760	nsIMsgDBHdr	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, thunderbird
		The nsIMsgDBHdr interface describes headers for mail messages.
761	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.
762	nsIMsgDBViewCommandUpdater	Interfaces, Interfaces:Scriptable, Messages, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The nsIMsgDBViewCommandUpdater interface controls changes that occur as the selection changes.
763	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.
764	nsIMsgFilter	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		No summary!
765	nsIMsgFilterCustomAction
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterCustomAction.idl
766	nsIMsgFilterList	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterList.idl
767	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 https://mxr.mozilla.org/comm-central/...Folder.idl#706 for the newer methods (esp. isSpecialFolder and such).
768	nsIMsgHeaderParser	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ mime/ public/ nsIMsgHeaderParser.idl
769	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.
770	nsIMsgIncomingServer
		this is really dangerous. this destroys all pref values do not call this unless you know what you're doing!
771	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.
772	nsIMsgProtocolInfo	Interfaces, Interfaces:Scriptable, thunderbird
		The nsIMsgProtocolInfo interface describes the capabilities of an account type.
773	nsIMsgRuleAction	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilter.idl
774	nsIMsgSearchCustomTerm	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchCustomTerm.idl
775	nsIMsgSearchNotify
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchNotify.idl
776	nsIMsgSearchScopeTerm	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		No summary!
777	nsIMsgSearchSession	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference, thunderbird
		The nsIMsgSearchSession interface allows you to create and manipulate search sessions within Thunderbird.
778	nsIMsgSearchTerm	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in mozilla/ mailnews/ base/ search/ public/ nsIMsgSearchTerm.idl
779	nsIMsgSearchValue	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		No summary!
780	nsIMsgSendLater	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		The nsIMsgSendLater interface provides functions for managing the unsent folder of a messaging account.
781	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.
782	nsIMsgWindow	Interfaces, Message Windows, NeedsContent, NeedsHelp, XPCOM API Reference, thunderbird
		Implemented by: @mozilla.org/messenger/msgwindow;1. To create an instance, use:
783	nsIMsgWindowCommands	Interfaces, Message Windows, XPCOM API Reference, XPCOM Interface Reference, thunderbird
		The JavaScript implementation of this used by Thunderbird is given here.
784	nsIMutableArray	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Consumers of nsIArray should not QueryInterface to nsIMutableArray unless they own the array.
785	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.
786	nsINavBookmarksService	Developing Mozilla, Extensions, 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:
787	nsINavHistoryBatchCallback	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
788	nsINavHistoryContainerResultNode	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		Returns a node matching specified details.
789	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.
790	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.
791	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
792	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.
793	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.
794	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.
795	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.
796	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).
797	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.
798	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.
799	nsINavHistoryResultViewer	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
		Called when a container node's state changes from closed to opened.
800	nsINavHistoryService	Developing Mozilla, Extensions, Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: "@mozilla.org/browser/nav-history-service;1". To use this service, use:
801	nsINavHistoryVisitResultNode	Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
802	nsINetworkLinkService	Interfaces, Interfaces:Scriptable, NeedsExample
		Implemented by: @mozilla.org/network/network-link-service;1 as a service:
803	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.
804	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.
805	addObserver
		No summary!
806	enumerateObservers
		No summary!
807	notifyObservers
		This content is now available at nsIObserverService.notifyObservers().
808	removeObserver
		This content is now available at nsIObserverService.removeObserver().
809	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.
810	close
		No summary!
811	flush
		No summary!
812	isNonBlocking
		No summary!
813	write
		No summary!
814	writeFrom
		No summary!
815	writeSegments
		No summary!
816	nsIOutputStreamCallback	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		Called to indicate that the stream is either writable or closed.
817	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:
818	nsIParserUtils
		Implemented by: @mozilla.org/parserutils;1 as a service:
819	nsIPassword	Interfaces, Login Manager, NeedsContent, XPCOM API Reference
		See Using nsIPasswordManager for examples of nsIPassword in use.
820	nsIPasswordManager	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference
		See Using nsIPasswordManager for examples.
821	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.
822	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.
823	nsIPipe	Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
		initialize this pipe.
824	nsIPlacesImportExportService	Bookmarks, Interfaces, Interfaces:Scriptable, Places, XPCOM Interface Reference, bookmarks
		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.
825	nsIPlacesView	Developing Mozilla, Extensions, Interfaces, Places
		The nsIPlacesView interface provides a view-agnostic way to access information about a Places view.
826	nsIPluginHost	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM, XPCOM Interface Reference
		To create temp file with Content len header in, it will use by http POST.
827	nsIPrefBranch	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, 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.
828	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():
829	nsIPrefLocalizedString	Interfaces, Interfaces:Scriptable, Preferences, XPCOM, XPCOM Interface Reference
		Used to set the contents of this object.
830	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.
831	nsIPrincipal
		For details on principals, how they work, and how to get the appropriate one, see Security check basics.
832	nsIPrinterEnumerator	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Returns an array of the names of all installed printers.
833	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.
834	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.
835	nsIProcess	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/process/util;1. To create an instance, use:
836	nsIProcess2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/process/util;1. To create an instance, use:
837	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.
838	nsIProfile	Gecko, NeedsUpdate, Reference, Référence, XPCOM, XPCOM Interface Reference, profile
		Implemented by: @mozilla.org/profile/manager;1. To get access to the Profile Manager service:
839	nsIProfileLock	Interfaces, Interfaces:Scriptable, Profiles, Toolkit, XPCOM Interface Reference
		Unlocks the profile.
840	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.
841	nsIProgrammingLanguage	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Identifiers for programming languages.
842	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.
843	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().
844	nsIPromptService	Interfaces, Interfaces:Scriptable, Reference, Référence, 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: "&&".
845	nsIProperties	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/file/directory_service;1. To get an instance, use:
846	get
		No summary!
847	getKeys
		No summary!
848	has
		No summary!
849	set
		No summary!
850	undefine
		No summary!
851	nsIProperty	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
852	nsIPropertyBag	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Get a property value for the given name.
853	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.
854	nsIPropertyElement	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
855	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.
856	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.
857	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.
858	nsIProtocolProxyService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/protocol-proxy-service;1. To access the service use:
859	nsIProxyInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface identifies a proxy server.
860	nsIPushMessage	Interfaces, Interfaces:Scriptable, Push, XPCOM, XPCOM Interface Reference
		nsIPushMessage is the subject of a push-message observer notification.
861	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.
862	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.
863	nsIRadioInterfaceLayer	Interfaces, Mobile, XPCOM API Reference
		Implemented by: @mozilla.org/telephony/system-worker-manager;1. To create an instance, use:
864	nsIRandomGenerator	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Generates the specified amount of random bytes.
865	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.
866	nsIRequestObserver	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called to signify the beginning of an asynchronous request.
867	nsIResumableChannel	Channels, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Open this channel, and read starting at the specified offset.
868	nsIRunnable
		No summary!
869	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:
870	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.
871	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.
872	nsISOCKSSocketInfo	Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
		No summary!
873	nsISSLErrorListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called in case of an SSL error.
874	nsISSLSocketControl	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Starts an SSL proxy connection.
875	nsIScreen	Interfaces, Interfaces:Scriptable, Screens, XPCOM, XPCOM Interface Reference
		Use nsIScreenManager to obtain references to screens.
876	nsIScreenManager	Interfaces, Interfaces:Scriptable, Screens, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/gfx/screenmanager;1 as a service:
877	nsIScriptError	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/scripterror;1. To create an instance, use:
878	nsIScriptError2	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		No summary!
879	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 ]
880	nsIScriptableInputStream	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Return the number of bytes currently available in the stream.
881	available
		No summary!
882	close
		No summary!
883	init
		No summary!
884	read
		No summary!
885	nsIScriptableUnescapeHTML	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/feed-unescapehtml;1 as a service:
886	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.
887	nsIScrollable	scrollbar
		Scroll orientations a scrollbar can be in.
888	nsISearchEngine
		Inherits from: nsISupports
889	nsISearchSubmission	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
890	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:
891	nsISeekableStream	Files, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		This method moves the stream offset of the stream implementing this interface.
892	nsISelection	Guide, NeedsContent, XPCOM
		Interface for manipulating and querying the current selected range of nodes within the document.
893	nsISelection2	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Return array of ranges intersecting with the given DOM interval.
894	nsISelection3	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Modifies the selection. Note that the parameters are case-insensitive.
895	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.
896	nsISelectionImageService	Interfaces, NeedsContent, XPCOM Interface Reference
		Retrieve the image for alpha blending.
897	nsISelectionPrivate	Interfaces, Interfaces:Scriptable, NeedsContent
		Will resume User Interface updates after a previous call to startBatchChanges().
898	nsIServerSocket	Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
		The nsIServerSocket interface implements a server socket that can accept incoming connections.
899	nsIServerSocketListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This method is called when a client connection is accepted.
900	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.
901	getServiceByContractID
		No summary!
902	isServiceInstantiated
		No summary!
903	isServiceInstantiatedByContractID
		No summary!
904	nsISessionStartup	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, sessionStorage
		Implemented by: @mozilla.org/browser/sessionstartup;1. To use this service, use:
905	nsISessionStore	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Deletes a value from a specified tab.
906	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.
907	getNext
		Documentation is now located at nsISimpleEnumerator.getNext().
908	hasMoreElements
		Documentation is now located at nsISimpleEnumerator.hasMoreElements().
909	nsISmsDatabaseService	Interfaces, Mobile, WebSMS
		Implemented by: @mozilla.org/sms/smsdatabaseservice;1. To create an instance, use:
910	nsISmsRequestManager	Interfaces, Mobile, WebSMS
		Implemented by: @mozilla.org/sms/smsrequestmanager;1. To create an instance, use:
911	nsISmsService	Interfaces, Mobile, WebSMS
		Implemented by: @mozilla.org/sms/smsservice;1. To create an instance, use:
912	nsISocketProvider	Interfaces, Interfaces:Scriptable, Reference, Référence, Sockets, XPCOM Interface Reference
		Implemented by: @mozilla.org/network/socket;2?type=foo. To create an instance, use:
913	nsISocketProviderService	Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
		Given a string representing a socket type, this method returns an nsISocketProvider representing that socket type.
914	nsISocketTransport	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		To create an instance, call nsISocketTransportService.createTransport()
915	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:
916	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.
917	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.
918	nsIStackFrame	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		To output the stack at a particular location:
919	nsIStandardURL	Interfaces, Interfaces:Scriptable
		Implemented by: @mozilla.org/network/standard-url;1. To create an instance, use:
920	nsIStreamConverter	Interfaces, Interfaces:Scriptable, MIME, Reference, Référence, 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.
921	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.
922	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.
923	nsIStringBundleOverride	Interfaces, Interfaces:Scriptable, String bundles, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/stringbundle/text-override;1. To create an instance, use:
924	nsIStringBundleService	Interfaces, Interfaces:Scriptable, Localization, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/intl/stringbundle;1. To access this service, use:
925	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.
926	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.
927	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.
928	nsISupports	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Notifies the object that an interface pointer has been duplicated.
929	AddRef
		Documentation is now located at nsISupports.AddRef().
930	Release
		Documentation is now located at nsISupports.Release().
931	nsISupports proxies	NeedsHelp, NeedsUpdate, Obsolete, XPCOM
		XPCOM proxies were a technology which allowed code to make asynchronous or synchronous XPCOM calls to a different thread on arbitrary XPCOM interfaces. This technology has been removed in Firefox 12 because it was very complex and often lead to strange deadlock conditions. It is no longer needed because JavaScript code can no longer run on arbitrary threads, and compiled code can use compiled runnable to achieve the same effect in a much simpler manner. For more information about alternatives, see Making cross-thread calls using runnables.
932	nsISupportsArray	Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM Interface Reference
		No summary!
933	nsISupportsCString	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
934	data
		No summary!
935	toString
		No summary!
936	nsISupportsChar	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
937	data
		No summary!
938	toString
		No summary!
939	nsISupportsDouble	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
940	data
		No summary!
941	toString
		No summary!
942	nsISupportsFloat	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
943	data	XPCOM API Reference
		This content is now available at nsISupportsFloat.Attributes.
944	toString
		This content is now available at nsISupportsFloat.toString().
945	nsISupportsID	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This method returns a string valued representation of the object.
946	data
		No summary!
947	toString
		No summary!
948	nsISupportsInterfacePointer	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns a string valued representation of the object.
949	data
		No summary!
950	dataIID
		No summary!
951	toString
		This content is now available at nsISupportsInterfacePointer.toString().
952	nsISupportsPRBool	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
953	data
		No summary!
954	toString
		No summary!
955	nsISupportsPRInt16	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
956	data
		This content is now available at nsISupportsPRInt16.Attributes.
957	toString
		This content is now available at nsISupportsPRInt16.toString().
958	nsISupportsPRInt32	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
959	data
		No summary!
960	toString
		No summary!
961	nsISupportsPRInt64	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
962	data
		This content is now available at nsISupportsPRInt64.Attributes.
963	toString
		This content is now available at nsISupportsPRInt64.toString().
964	nsISupportsPRTime	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
965	data
		No summary!
966	toString
		No summary!
967	nsISupportsPRUint16	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
968	data
		No summary!
969	toString
		No summary!
970	nsISupportsPRUint32	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
971	data
		No summary!
972	toString
		No summary!
973	nsISupportsPRUint64	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
974	data
		No summary!
975	toString
		No summary!
976	nsISupportsPRUint8	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
977	data
		No summary!
978	toString
		No summary!
979	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.
980	type	XPCOM API Reference
		No summary!
981	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.
982	nsISupportsString	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This methods returns a string valued representation of the object.
983	data
		No summary!
984	toString
		No summary!
985	nsISupportsVoid	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		None.
986	data
		Documentation is now located at nsISupportsVoid.data().
987	toString
		Documentation is now located at nsISupportsVoid.toString().
988	nsISupportsWeakReference	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Produces an appropriate instance of nsIWeakReference.
989	getWeakReference
		This content is now available at nsISupportsWeakReference.getWeakReference().
990	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.
991	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.
992	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.
993	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:
994	nsITaskbarPreview	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		You can not directly instantiate this interface. Instead, you use nsITaskbarTabPreview or nsITaskbarWindowPreview as appropriate.
995	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.
996	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.
997	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.
998	nsITaskbarTabPreview	Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
		Creating an nsITaskbarTabPreview for a window will automatically hide that window's nsITaskbarWindowPreview; this is done by Windows and cannot be prevented. When there are no more tab previews left for a window, the window preview is automatically made visible again.
999	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.
1000	nsITelemetry	Developing Mozilla, Interfaces, Interfaces:Scriptable, Performance, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/base/telemetry;1 as a service:
1001	nsITextInputProcessor	DOM, Interface, Interface:Scriptable, Reference, Référence, 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.
1002	nsITextInputProcessorCallback	DOM, Interface, Interface:Scriptable, Reference, Référence, 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.
1003	nsITextInputProcessorNotification	DOM, Interface, Interface:Scriptable, Reference, Référence, 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.
1004	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.
1005	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.
1006	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.
1007	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.
1008	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.
1009	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.
1010	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.
1011	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.
1012	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.
1013	nsIToolkit	Interfaces, XPCOM, XPCOM Interface Reference
		Initialize this toolkit with aThread.
1014	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.
1015	nsIToolkitProfileService	Interfaces, Interfaces:Scriptable, Profiles, Toolkit, XPCOM Interface Reference
		Creates a new profile.
1016	nsITraceableChannel	HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The typical way to use this interface is as follows:
1017	nsITransaction	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Executes the transaction.
1018	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.
1019	nsITransactionListener	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Called after a nsITransactionManager begins a batch.
1020	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.
1021	nsITransferable	Gecko, Interface, Mozilla, Reference, Référence, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/widget/transferable;1. To create an instance, use:
1022	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).
1023	nsITransportEventSink	Interfaces, Interfaces:Scriptable, Transports, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Transport status notification.
1024	nsITransportSecurityInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
1025	nsITreeBoxObject	Interfaces, XPCOM, XPCOM Interface Reference
		The nsITreeBoxObject interface contains information about the size and layout of a tree.
1026	nsITreeColumn	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		The nsITreeColumn interface represents a tree column.
1027	nsITreeColumns	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		The nsITreeColumns interface represents the tree columns.
1028	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.
1029	nsITreeSelection	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called when the row count changes to adjust selection indices.
1030	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.
1031	nsIURI	Interfaces, Interfaces:Scriptable, URIs, XPCOM, XPCOM Interface Reference
		See the following RFCs for details:
1032	nsIURIFixup	Interfaces, Interfaces:Scriptable, URI, XPCOM Interface Reference
		Implemented by: @mozilla.org/docshell/urifixup;1 as a service:
1033	nsIURIFixupInfo
		No summary!
1034	nsIURL	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		You can get a nsIURL from an nsIURI, using the QueryInterface() method:
1035	nsIURLFormatter	Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM Interface Reference
		Variable names can contain 'A-Z' letters and '_' characters.
1036	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.
1037	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.
1038	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.
1039	nsIUUIDGenerator	Add-ons, Extensions, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by @mozilla.org/uuid-generator; as a service:
1040	nsIUpdate	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Retrieves a patch.
1041	nsIUpdateCheckListener	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Called when the update check is completed.
1042	nsIUpdateChecker	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Checks for available updates, notifying a listener of the results.
1043	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.
1044	nsIUpdateManager	Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Returns the update at the specified index into the history list.
1045	nsIUpdatePatch	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Serializes the patch object into a DOM element.
1046	nsIUpdatePrompt	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Presents a user interface that checks for and displays the available updates.
1047	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.
1048	nsIUploadChannel	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Sets a stream to be uploaded by this channel.
1049	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.
1050	nsIUrlListManagerCallback	Interfaces, Interfaces:Scriptable, NeedsContent
		No summary!
1051	nsIUserCertPicker	Cryptography, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		No summary!
1052	nsIUserInfo	Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/userinfo;1. To get the service, use:
1053	nsIVariant	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference, XPConnect
		None.
1054	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".
1055	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.
1056	queryReferent
		No summary!
1057	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.
1058	nsIWebBrowserChrome	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Asks the implementer to destroy the window associated with this WebBrowser object.
1059	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().
1060	nsIWebBrowserChrome3	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Determines the appropriate target for a link.
1061	nsIWebBrowserChromeFocus	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Set the focus at the next focusable element in the chrome.
1062	nsIWebBrowserFind	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Get one by doing a GetInterface on an nsIWebBrowser.
1063	nsIWebBrowserFindInFrames	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Get an instance by doing a QueryInterface from nsIWebBrowserFind.
1064	nsIWebBrowserPersist	Interfaces, Interfaces:Scriptable, NeedsAttention, 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:
1065	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:
1066	nsIWebNavigation	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		This interface is implemented by the following components:
1067	nsIWebNavigationInfo	Interfaces, Interfaces:Scriptable, MIME, XPCOM Interface Reference
		Implemented by: @mozilla.org/webnavigation-info;1 as a service:
1068	nsIWebPageDescriptor	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Tells the object to load the page specified by the page descriptor.
1069	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).
1070	nsIWebProgressListener	Interfaces, Interfaces:Scriptable, NeedsMarkupWork, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		nsIWebProgress describes the parent-child relationship of nsIWebProgress instances.
1071	nsIWebProgressListener2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		An extended version of nsIWebProgressListener.
1072	nsIWebSocketChannel	Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, WebSockets, XPCOM Interface Reference
		Technical review completed.
1073	nsIWebSocketListener	Interfaces, Interfaces:Scriptable, Reference, Référence, WebSockets, XPCOM Interface Reference
		Called to acknowledge a message sent via nsIWebSocketChannel.sendMsg() or nsIWebSocketChannel.sendBinaryMsg().
1074	nsIWebappsSupport	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		This method installs a web application.
1075	nsIWifiAccessPoint	Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
		No summary!
1076	nsIWifiListener	Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
		Called when the list of available access points changes.
1077	nsIWifiMonitor	Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
		This is used, for example, by Geolocation to use WiFi access points for location detection.
1078	nsIWinAccessNode	Interfaces, NeedsContent, XPCOM Interface Reference
		No summary!
1079	nsIWinAppHelper	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/xre/app-info;1. To create an instance, use:
1080	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.
1081	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.
1082	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.
1083	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.
1084	nsIWindowsRegKey	Interfaces, Interfaces:Scriptable, NeedsContent, NeedsExample, XPCOM, XPCOM Interface Reference
		The interface represents a single key in the registry.
1085	nsIWindowsShellService	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
		Valid starting keys for the Windows Registry.
1086	nsIWorker	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		For usage details, see worker and the article Using DOM workers.
1087	nsIWorkerFactory	Workers, XPCOM, XPCOM Interface Reference
		Implemented by: threads/workerfactory;1. To create an instance, use:
1088	nsIWorkerGlobalScope	DOM, Interfaces, Interfaces:Scriptable, NeedsContent, Workers, XPCOM, XPCOM Interface Reference
		No summary!
1089	nsIWorkerMessageEvent	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		Initializes the message event.
1090	nsIWorkerMessagePort	DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
		Posts a message into the event queue.
1091	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.
1092	nsIWritablePropertyBag	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
		Delete a property with the given name.
1093	nsIWritablePropertyBag2	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		No summary!
1094	nsIXFormsModelElement	Interfaces, Interfaces:Scriptable, XForms, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		An nsIDOMDocument.
1095	nsIXFormsNSInstanceElement	Interfaces, Interfaces:Scriptable, NeedsExample, NeedsMarkupWork, XForms, XPCOM API Reference, XPCOM Interface Reference
		nsIXFormsNSInstanceElement is implemented by all XForms <instance/> elements, defining Mozilla extensions.
1096	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.
1097	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.
1098	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.
1099	nsIXMLHttpRequestUpload	AJAX, Interfaces, Interfaces:Scriptable, XMLHttpRequest, XPCOM, XPCOM Interface Reference
		No summary!
1100	nsIXPCException	Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XPConnect
		None.
1101	nsIXPCScriptable	Interfaces, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Inherits from: nsISupports
1102	nsIXPConnect	Interfaces, NeedsContent, Reference, Référence, XPCOM, XPCOM Interface Reference, XPConnect
		To access the XPConnect service, use code like this:
1103	nsIXSLTException	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XSLT
		No summary!
1104	nsIXSLTProcessor	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XSLT
		Implemented by: @mozilla.org/document-transformer;1?type=xslt. To create an instance, use:
1105	nsIXSLTProcessorObsolete
		Use nsIXSLTProcessor instead.
1106	nsIXULAppInfo	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		In XULRunner applications nsIXULAppInfo obtains app-specific information from application.ini.
1107	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.
1108	nsIXULBuilderListener	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Called after a template builder has rebuilt its content.
1109	nsIXULRuntime	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/xre/app-info;1. To get an instance, use:
1110	nsIXULSortService	Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, XUL
		Used internally for insertion sorting.
1111	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.
1112	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.
1113	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.
1114	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.
1115	nsIXmlRpcClient	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
1116	nsIXmlRpcFault
		No summary!
1117	nsIZipEntry	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		No summary!
1118	nsIZipReader	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
		Implemented by: @mozilla.org/libjar/zip-reader;1. To create an instance, use:
1119	nsIZipReaderCache	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: @mozilla.org/libjar/zip-reader-cache;1. To create an instance, use:
1120	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.
1121	nsMsgFilterFileAttribValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterList.idl
1122	nsMsgFolderFlagType
		Defined in comm-central/ mailnews/ base/ public/ nsMsgFolderFlags.idl
1123	nsMsgJunkStatus	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1124	nsMsgKey	XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1125	nsMsgLabelValue	XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1126	nsMsgPriorityValue	XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1127	nsMsgRuleActionType	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgFilterCore.idl
1128	nsMsgSearchAttrib	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1129	nsMsgSearchOp	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1130	nsMsgSearchScope
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1131	nsMsgSearchTerm
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1132	nsMsgSearchTypeValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1133	nsMsgSearchValue	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1134	nsMsgSearchWidgetValue	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1135	nsPIPromptService	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
		Implemented by: The contract ID isn't defined.
1136	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.)
1137	XPCOM glue classes	Classes, Landing, XPCOM
		These "glue" classes are provided to make it easier to use XPCOM from C++ code.
1138	NS ConvertASCIItoUTF16 external	NeedsContent, Reference, Référence, strings
		Class Declaration
1139	NS ConvertUTF16toUTF8 external	NeedsContent, Reference, Référence, strings
		Class Declaration
1140	NS ConvertUTF8toUTF16 external	NeedsContent, Reference, Référence, strings
		Class Declaration
1141	NS LossyConvertUTF16toASCII external	NeedsContent, Reference, Référence, strings
		Class Declaration
1142	NS_ConvertASCIItoUTF16
		Class Declaration
1143	NS_ConvertUTF16toUTF8
		Class Declaration
1144	NS_ConvertUTF8toUTF16
		Class Declaration
1145	NS_LossyConvertUTF16toASCII
		Class Declaration
1146	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.
1147	NS_POSTCONDITION	XPCOM, XPCOM_Macros
		Macro
1148	NS_PRECONDITION	XPCOM, XPCOM_Macros
		Macro
1149	PromiseFlatCString (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1150	PromiseFlatString (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1151	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.
1152	Append	XPCOM, XPCOM API Reference
		The Append family of functions appends a value to the end of a string's internal buffer.
1153	Assign	XPCOM, XPCOM API Reference
		The Assign family of functions sets the value of a string's internal buffer.
1154	BeginReading	XPCOM, XPCOM API Reference
		The BeginReading function returns a const pointer to the first element of the string's internal buffer.
1155	Cut	XPCOM, XPCOM API Reference
		The Cut function removes a section of the string's internal buffer.
1156	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.
1157	Insert	XPCOM, XPCOM API Reference
		The Insert family of functions inserts a value into a string's internal buffer.
1158	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).
1159	Replace	XPCOM, XPCOM API Reference
		The Replace family of functions sets the value of a string's internal buffer.
1160	operator+=	XPCOM, XPCOM API Reference
		This operator+= is a shortcut for the Append family of functions.
1161	operator=	XPCOM, XPCOM API Reference
		This operator is a shortcut for the Assign family of functions.
1162	nsACString (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1163	nsACString_internal
		Class Declaration
1164	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.
1165	Append	XPCOM, XPCOM API Reference
		The Append family of functions appends a value to the end of a string's internal buffer.
1166	Assign	XPCOM, XPCOM API Reference
		The Assign family of functions sets the value of a string's internal buffer.
1167	BeginReading	XPCOM, XPCOM API Reference
		The BeginReading function returns a const pointer to the first element of the string's internal buffer.
1168	Cut	XPCOM, XPCOM API Reference
		The Cut function removes a section of the string's internal buffer.
1169	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.
1170	Insert	XPCOM, XPCOM API Reference
		The Insert family of functions inserts a value into a string's internal buffer.
1171	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).
1172	Replace	XPCOM, XPCOM API Reference
		The Replace family of functions sets the value of a string's internal buffer.
1173	operator+=	XPCOM, XPCOM API Reference
		This operator+= is a shortcut for the Append family of functions.
1174	operator=	XPCOM, XPCOM API Reference
		This operator= is a shortcut for the Append family of functions.
1175	nsAString (External)
		Class Declaration
1176	nsAString_internal
		Class Declaration
1177	nsAdoptingCString
		Class Declaration
1178	nsAdoptingString
		Class Declaration
1179	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>
1180	nsAutoRefTraits
		nsAutoRefTraits<t> is a template class describing traits of resources held by objects of class nsAutoRef<T> and/or nsCountedRef<T>.</t>
1181	nsAutoString
		Class Declaration
1182	nsAutoString (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1183	nsCAutoString
		Class Declaration
1184	nsCAutoString (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1185	nsCOMPtr	XPCOM, XPCOM API Reference
		This utility class simplifies managing XPCOM interface references from C++ code.
1186	nsCString
		Class Declaration
1187	nsCString external	NeedsContent, Reference, Référence, strings
		Class Declaration
1188	nsCStringContainer (External)	NeedsAttention, Reference, Référence, needsattention, strings
		Class Declaration
1189	nsCStringEncoding	XPCOM, XPCOM API Reference
		The nsCStringEncoding enumeration describes the set of character encodings understood by the NS_CStringToUTF16 and NS_UTF16ToCString functions.
1190	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>
1191	nsDependentCString
		Class Declaration
1192	nsDependentCString external	NeedsContent, Reference, Référence, strings
		Class Declaration
1193	nsDependentCSubstring
		Class Declaration
1194	nsDependentCSubstring external	NeedsContent, Reference, Référence, strings
		Class Declaration
1195	nsDependentString
		Class Declaration
1196	nsDependentString external	NeedsContent, Reference, Référence, strings
		Class Declaration
1197	nsDependentSubstring
		Class Declaration
1198	nsDependentSubstring external	NeedsContent, Reference, Référence, strings
		Class Declaration
1199	nsEmbedCString	XPCOM, XPCOM API Reference
		The nsEmbedCString concrete class provides a way to construct a nsACString object that allocates null-terminated storage.
1200	get	XPCOM, XPCOM API Reference
		The get function returns a const pointer to the string's null-terminated, internal buffer.
1201	nsEmbedCString	XPCOM, XPCOM API Reference
		Constructors for nsEmbedCString.
1202	operator=	XPCOM, XPCOM API Reference
		This operator is a shortcut for the inherited nsACString::Assign family of functions.
1203	nsEmbedString	XPCOM, XPCOM API Reference
		The nsEmbedString concrete class provides a way to construct a nsAString object that allocates null-terminated storage.
1204	get	XPCOM, XPCOM API Reference
		The get function returns a const pointer to the string's null-terminated, internal buffer.
1205	nsEmbedString	XPCOM, XPCOM API Reference
		Constructors for nsEmbedString.
1206	operator=	XPCOM, XPCOM API Reference
		This operator is a shortcut for the inherited nsAString::Assign family of functions.
1207	nsFixedCString
		Class Declaration
1208	nsFixedString
		Class Declaration
1209	nsLiteralCString (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1210	nsLiteralString (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1211	nsMemory	NeedsRelocation, Reference, Référence, 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.
1212	Alloc	XPCOM, XPCOM API Reference
		The Alloc function allocates a block of memory of a particular size.
1213	Clone	XPCOM, XPCOM API Reference
		The Clone function creates a copy of an existing memory block up to the size specified.
1214	Free	XPCOM, XPCOM API Reference
		The Free function frees a block of memory that was allocated by XPCOM's memory manager.
1215	GetGlobalMemoryService	XPCOM, XPCOM API Reference
		The GetGlobalMemoryService function returns a reference to XPCOM's global nsIMemory object.
1216	HeapMinimize	XPCOM, XPCOM API Reference
		The HeapMinimize function attempts to shrink the size of the heap.
1217	Realloc	XPCOM, XPCOM API Reference
		The Realloc function reallocates a block of memory to a new size.
1218	nsPromiseFlatCString
		Class Declaration
1219	nsPromiseFlatString
		Class Declaration
1220	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.
1221	nsString
		Class Declaration
1222	nsString external	NeedsContent, Reference, Référence, strings
		Class Declaration
1223	nsStringContainer (External)	NeedsContent, Reference, Référence, strings
		Class Declaration
1224	nsSupportsWeakReference	XPCOM, XPCOM API Reference
		Inherit from this C++ class to add canonical support for nsISupportsWeakReference.
1225	nsXPIDLCString
		Class Declaration
1226	nsXPIDLString
		Class Declaration
1227	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.
1228	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.
1229	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.
1230	NS_CStringCloneData	XPCOM, XPCOM API Reference
		The NS_CStringCloneData function returns a null-terminated, heap allocated copy of the string's internal buffer.
1231	NS_CStringContainerFinish	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringContainerFinish function releases any memory allocated by a nsCStringContainer instance.
1232	NS_CStringContainerInit	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringContainerInit function initializes a nsCStringContainer instance for use as a nsACString.
1233	NS_CStringContainerInit2	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringContainerInit2 function initializes a nsCStringContainer instance for use as a nsACString.
1234	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.
1235	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.
1236	NS_CStringGetData	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringGetData function gives the caller read access to the string's internal buffer.
1237	NS_CStringGetMutableData	Functions, Functions:Frozen, XPCOM, XPCOM API Reference
		The NS_CStringGetMutableData function gives the caller write access to the string's internal buffer.
1238	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.
1239	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.
1240	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.
1241	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.
1242	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.
1243	NS_StringCloneData	XPCOM, XPCOM API Reference
		The NS_StringCloneData function returns a null-terminated, heap allocated copy of the string's internal buffer.
1244	NS_StringContainerFinish	XPCOM, XPCOM API Reference
		The NS_StringContainerFinish function releases any memory allocated by a nsStringContainer instance. This is a low-level API.
1245	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.
1246	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.
1247	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.
1248	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.
1249	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.
1250	NS_StringSetData	XPCOM, XPCOM API Reference
		The NS_StringSetData function copies data into the string's internal buffer. This is a low-level API.
1251	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.
1252	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.
1253	nsGetModuleProc
		This function prototype provides the XPCOM entry-point into a module.
1254	nsIAbCard/Thunderbird3	Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, thunderbird
		No summary!
1255	nsICookie2 MOZILLA 1 8 BRANCH	Interfaces, XPCOM, XPCOM API Reference
		No summary!
1256	nsIMsgSearchValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchValue.idl
1257	nsMsgMessageFlags
		The nsMsgMessageFlags interface describes possible flags for messages. Equivalent flags are also defined in nsMsgMessageFlags.h.
1258	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:
1259	nsMsgSearchOpValue
		Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1260	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.
1261	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:
1262	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:
1263	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:
1264	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:
1265	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:
1266	nsStaticModuleInfo
		This data structure is used by NS_InitXPCOM3 to specify static XPCOM modules.
1267	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.
1268	Xptcall Porting Guide
		Original Author: John Bandhauer, 31 May 1999.
1269	Xptcall Porting Status
		This is a status page for the multiplatform porting of xptcall. xptcall has a FAQ and a Porting Guide.
1270	already_AddRefed	XPCOM, XPCOM API Reference, nsCOMPtr
		already_AddRefed in association with nsCOMPtr allows you to assign in a pointer without AddRefing it.
1271	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.