Index

Found 1269 pages:

# Page Tags and summary
1 XPCOM Landing, Mozilla, XPCOM
XPCOM is a cross platform component object model, similar to Microsoft COM. It has multiple language bindings, allowing XPCOM components to be used and implemented in JavaScript, Java, and Python in addition to C++.
2 Accessing the Windows Registry Using XPCOM Add-ons, Code snippets, Extensions, NeedsClassification, Windows Registry, 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 1269 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 <fguisset@softhome.net>
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
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 Landing, Mozilla, XPCOM
These articles provide tutorials and usage documentation for XPCOM, including how to use it in your own projects and how to build XPCOM components for your Firefox add-ons and the like.
95 Avoiding leaks in JavaScript XPCOM components Add-ons, Developing Mozilla, Extensions, NeedsUpdate, XPCOM, XPCOM:Language Bindings, XPConnect
Programmers writing and reviewing JavaScript code in Mozilla should understand how code using XPCOM in JavaScript can leak so that they can avoid leaks. This document attempts to help them do so, first by explaining the underlying concepts, and second by describing a number of common JavaScript patterns that cause leaks.
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 Landing, Mozilla, Reference, Référence, XPCOM
This reference describes the interfaces and functions provided by the XPCOM library. In addition, it details the various helper classes and functions, as well as the components, provided by the XPCOM glue library. The contents herein are oriented primarily toward extension developers and people embedding XPCOM in other projects.
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 http://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
A notification displayed by the alerts serviceBy 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 users will expect clipboard operations to use the global clipboard. In fact, the kSelectionClipboard is peculiar to the X Windows System, and not used much even under X.
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 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.
570 nsIEditor Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM API Reference, XPCOM Interface Reference
No summary!
571 nsIEditorBoxObject Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
The boxObject belonging to a XUL editor element implements this interface.
572 nsIEditorDocShell Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
Use nsIEditingSession.makeWindowEditable() and nsIEditingSession.getEditorForWindow() from out side.
573 nsIEditorIMESupport Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
Handles the start of inline input composition.
574 nsIEditorLogging Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
Start logging.
575 nsIEditorMailSupport Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Get a list of IMG and OBJECT tags in the current document.
576 nsIEditorObserver Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Called after the editor completes a user action.
577 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:
578 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:
579 nsIEnumerator Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
nsIEnumerator.idl
580 nsIEnvironment Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/process/environment;1 as a service:
581 nsIErrorService Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
Implemented by: @mozilla.org/xpcom/error-service;1
582 nsIEventListenerInfo Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Returns the debugger object if the debug service is active.
583 nsIEventListenerService Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/eventlistenerservice;1. To create an instance, use:
584 nsIEventSource Interfaces, Interfaces:Scriptable, Server-sent events
This implements the EventSource interface used for server-sent events.
585 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.
586 nsIException Interfaces, Interfaces:Scriptable, Reference, XPCOM, XPCOM Interface Reference
A generic formatter - make it suitable to print, etc.
587 nsIExtensionManager Disambiguation, NeedsContent, NeedsHelp, XPCOM, XPCOM Interface Reference
Unfortunately, at the time of this writing there are two nsIExtensionManager Interfaces:
588 nsIExternalHelperAppService Interfaces, MIME
Implemented by: @mozilla.org/uriloader/external-helper-app-service;1. To access this service, use:
589 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.
590 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.
591 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.
592 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.
593 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.)
594 createInstance
No summary!
595 lockFactory
No summary!
596 nsIFaviconDataCallback Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Called when the required favicon's information is available.
597 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:
598 nsIFeed Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
599 nsIFeedContainer Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Synchronizes a container's fields with its convenience attributes.
600 nsIFeedElementBase Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Interwiki link
601 nsIFeedEntry Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Interwiki link
602 nsIFeedGenerator Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Interwiki link
603 nsIFeedPerson Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Interwiki link
604 nsIFeedProcessor Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/feed-processor;1. To create an instance, use:
605 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.
606 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.
607 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.
608 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.
609 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.
610 append
No summary!
611 appendNative
No summary!
612 clone
No summary!
613 contains
No summary!
614 copyTo
No summary!
615 copyToFollowingLinks
No summary!
616 copyToFollowingLinksNative
This content is now available at nsIFile.copyToFollowingLinksNative().
617 copyToNative
No summary!
618 create
No summary!
619 createUnique
No summary!
620 directoryEntries
No summary!
621 equals
No summary!
622 exists
No summary!
623 fileSize
No summary!
624 fileSizeOfLink
No summary!
625 isDirectory
No summary!
626 isExecutable
No summary!
627 isFile
No summary!
628 isHidden
No summary!
629 isReadable
No summary!
630 isSpecial
No summary!
631 isSymlink
No summary!
632 isWritable
No summary!
633 lastModifiedTime
No summary!
634 lastModifiedTimeOfLink
No summary!
635 leafName
No summary!
636 moveTo
No summary!
637 moveToNative
No summary!
638 nativeLeafName
No summary!
639 nativePath
No summary!
640 nativeTarget
No summary!
641 normalize
No summary!
642 parent
No summary!
643 path
No summary!
644 permissions XPCOM, XPCOM API Reference
No summary!
645 permissionsOfLink
No summary!
646 remove
No summary!
647 target
This content is now available at nsIFile.Attributes.
648 nsIFileInputStream Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
649 nsIFileOutputStream Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
650 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:
651 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://.
652 nsIFileSpec
Declared in xpcom/obsolete/nsIFileSpec.idl
653 nsIFileStreams File I/O, Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
654 nsIFileURL Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
No summary!
655 nsIFileUtilities Interfaces, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
656 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.
657 nsIFocusManager Interfaces, Interfaces:Scriptable, NeedsContent
Implemented by: @mozilla.org/focus-manager;1 as a service:
658 nsIFormHistory2 Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
Adds a name and value pair to the form history.
659 nsIFrameLoader Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Activates event forwarding from client (remote frame) to parent.
660 nsIFrameLoaderOwner
Returns the frame loader object owned by this object.
661 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.
662 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.
663 nsIFrameScriptLoader
This interface is used to load frame scripts.
664 nsIGSettingsCollection Interfaces, Interfaces:Scriptable, NeedsContent
No summary!
665 nsIGSettingsService Interfaces, Interfaces:Scriptable, NeedsContent
Implemented by: @mozilla.org/gsettings-service;1 as a service:
666 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().
667 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.
668 nsIGlobalHistory Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Add a page to the history.
669 nsIGlobalHistory2 Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Add a URI to global history.
670 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.
671 nsIHTMLEditor Interfaces, Interfaces:Scriptable, NeedsContent
Registers a default style property with the editor.
672 nsIHTTPHeaderListener Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference
No summary!
673 nsIHapticFeedback Interfaces, Interfaces:Scriptable, Mobile, XPCOM Interface Reference
Implemented by: @mozilla.org/widget/hapticfeedback;1 as a service:
674 nsIHttpActivityDistributor HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: mozilla.org/network/http-activity-distributor;1 as a service:
675 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.
676 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:
677 nsIHttpChannelInternal HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Gets the request's major and minor version numbers.
678 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.
679 nsIHttpServer
No summary!
680 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.
681 nsIIDNService DNS, Interface Reference, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference
Implemented by: @mozilla.org/network/idn-service;1 as a service:
682 nsIIFrameBoxObject
The boxObject belonging to a XUL iframe element implements this interface.
683 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.
684 nsIINIParserFactory Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
See Example for how to use this interface.
685 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.
686 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).
687 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.
688 nsIInProcessContentFrameMessageManager Interfaces, XPCOM, XPCOM Interface Reference
None.
689 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.
690 available
No summary!
691 close
No summary!
692 isNonBlocking
No summary!
693 read
No summary!
694 readSegments
No summary!
695 nsIInputStreamCallback Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
Called to indicate that the stream is either readable or closed.
696 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:
697 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.
698 getInterface
No summary!
699 nsIJSCID Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
None.
700 nsIJSID Interfaces, Interfaces:Scriptable, XPCOM API Reference, XPCOM Interface Reference
The following methods return objects that implement this interface:
701 nsIJSIID Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
702 nsIJSON Interfaces, Interfaces:Scriptable, NeedsExample, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/dom/json;1. To create an instance, use:
703 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.
704 nsIJetpack Interfaces, Interfaces:Scriptable, Jetpack, XPCOM, XPCOM Interface Reference
This method asynchronously sends a message to the Jetpack process.
705 nsIJetpackService Interfaces, Interfaces:Scriptable, Jetpack, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/jetpack/service;1.
706 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.
707 nsIJumpListItem Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Compare this item to another.
708 nsILivemarkService Interfaces, Interfaces:Scriptable, Places, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/browser/livemark-service;2. To use this service, use:
709 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.
710 nsILocalFile Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/file/local;1. To create an instance, use:
711 nsILocalFileMac File I/O, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
None.
712 nsILocale Interfaces, Interfaces:Scriptable, Localization, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Retrieves a string with the current locale name.
713 nsILocaleService Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
Implemented by: @mozilla.org/intl/nslocaleservice;1. To use this service, use:
714 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.
715 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.
716 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.
717 nsILoginManagerCrypto Cryptography, Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
Decrypts the specified string, returning the plain text value.
718 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.
719 nsILoginManagerPrompter Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Initialize the prompter. Must be called before using other interfaces.
720 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.
721 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.
722 nsIMIMEInputStream Interfaces, Interfaces:Scriptable, MIME
Implemented by: @mozilla.org/network/mime-input-stream;1. To create an instance, use:
723 nsIMacDockSupport Dock, Interfaces, Interfaces:Scriptable, Mac OS X, XPCOM Interface Reference
Implemented by: @mozilla.org/cookie-monster;1. To create an instance, use:
724 nsIMarkupDocumentViewer Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, XPCOM Interface Reference
Scroll the make the specified node visible.
725 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.
726 alloc
No summary!
727 free
No summary!
728 heapMinimize
No summary!
729 isLowMemory
No summary!
730 realloc
No summary!
731 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.
732 nsIMemoryMultiReporterCallback Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
Called to provide information from a multi-reporter. Implement this method to handle the report information.
733 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.
734 nsIMemoryReporterManager Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by @mozilla.org/memory-reporter-manager;1 as a service:
735 nsIMenuBoxObject Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
To get access to the box object for a given menu, use code like this:
736 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.
737 nsIMessageListener
This interface is used to receive messages sent using the nsIMessageBroadcaster, nsIMessageSender, or nsISyncMessageSender interfaces. Listeners are attached using the nsIMessageListenerManager interface.
738 nsIMessageListenerManager Interfaces, Interfaces:Scriptable, Message Manager, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/globalmessagemanager;1. To access this service, use:
739 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.
740 nsIMessageWakeupService Interfaces, XPCOM Interface Reference
The parentprocessmessagemanager is used for this, so messages send from childprocessmessagemanagers will be heard.
741 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.
742 nsIMicrosummary Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Add a microsummary observer to this microsummary.
743 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.
744 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.
745 nsIMicrosummaryService Interfaces, Interfaces:Scriptable, Microsummaries, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/microsummary/service;1 as a service:
746 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.
747 nsIMimeConverter
The nsIMimeConverter service allows you to convert headers into and out of MIME format.
748 nsIMimeHeaders Interfaces, XPCOM, XPCOM Interface Reference
Implemented by: ?????????????????????????????????????. To create an instance, use:
749 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.
750 canUnload
No summary!
751 getClassObject
No summary!
752 registerSelf
No summary!
753 unregisterSelf
No summary!
754 nsIMsgAccount
Adds a new identity to this account.
755 nsIMsgAccountManagerExtension Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
The nsIMsgAccountManagerExtension interface is used to add a new panel to Thunderbird's Account Manager.
756 Building an Account Manager Extension
As first step we have to implement the nsIAccountManagerExtension. We name the Extension "devmo-account" and state that it is located in the Chrome Package "example@mozilla.org". Furthermore we show the new panel only for IMAP accounts...
757 nsIMsgCompFields Interfaces, XPCOM, XPCOM Interface Reference, thunderbird
The nsIMsgCompFields interface provides properties for an composition of an outgoing message.
758 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.
759 nsIMsgDBHdr Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference, thunderbird
The nsIMsgDBHdr interface describes headers for mail messages.
760 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.
761 nsIMsgDBViewCommandUpdater Interfaces, Interfaces:Scriptable, Messages, XPCOM, XPCOM API Reference, XPCOM Interface Reference, thunderbird
The nsIMsgDBViewCommandUpdater interface controls changes that occur as the selection changes.
762 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.
763 nsIMsgFilter Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
No summary!
764 nsIMsgFilterCustomAction
Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterCustomAction.idl
765 nsIMsgFilterList Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterList.idl
766 nsIMsgFolder Interfaces, Interfaces:Scriptable, Message Database, Messages, NeedsContent, XPCOM API Reference, XPCOM Interface Reference, thunderbird
The nsIMsgFolder interface is used to interact with folders in Thunderbird. This page is out of date. Check http://mxr.mozilla.org/comm-central/...Folder.idl#706 for the newer methods (esp. isSpecialFolder and such).
767 nsIMsgHeaderParser Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ mime/ public/ nsIMsgHeaderParser.idl
768 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.
769 nsIMsgIncomingServer
this is really dangerous. this destroys all pref values do not call this unless you know what you're doing!
770 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.
771 nsIMsgProtocolInfo Interfaces, Interfaces:Scriptable, thunderbird
The nsIMsgProtocolInfo interface describes the capabilities of an account type.
772 nsIMsgRuleAction Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilter.idl
773 nsIMsgSearchCustomTerm Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchCustomTerm.idl
774 nsIMsgSearchNotify
Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchNotify.idl
775 nsIMsgSearchScopeTerm Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
No summary!
776 nsIMsgSearchSession Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference, thunderbird
The nsIMsgSearchSession interface allows you to create and manipulate search sessions within Thunderbird.
777 nsIMsgSearchTerm Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in mozilla/ mailnews/ base/ search/ public/ nsIMsgSearchTerm.idl
778 nsIMsgSearchValue Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
No summary!
779 nsIMsgSendLater Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
The nsIMsgSendLater interface provides functions for managing the unsent folder of a messaging account.
780 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.
781 nsIMsgWindow Interfaces, Message Windows, NeedsContent, NeedsHelp, XPCOM API Reference, thunderbird
Implemented by: @mozilla.org/messenger/msgwindow;1. To create an instance, use:
782 nsIMsgWindowCommands Interfaces, Message Windows, XPCOM API Reference, XPCOM Interface Reference, thunderbird
The JavaScript implementation of this used by Thunderbird is given here.
783 nsIMutableArray Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Consumers of nsIArray should not QueryInterface to nsIMutableArray unless they own the array.
784 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.
785 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:
786 nsINavHistoryBatchCallback Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
No summary!
787 nsINavHistoryContainerResultNode Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
Returns a node matching specified details.
788 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.
789 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.
790 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
791 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.
792 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.
793 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.
794 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.
795 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).
796 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.
797 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.
798 nsINavHistoryResultViewer Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference
Called when a container node's state changes from closed to opened.
799 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:
800 nsINavHistoryVisitResultNode Developing Mozilla, Extensions, Interfaces, Places, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
801 nsINetworkLinkService Interfaces, Interfaces:Scriptable, NeedsExample
Implemented by: @mozilla.org/network/network-link-service;1 as a service:
802 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.
803 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.
804 addObserver
No summary!
805 enumerateObservers
No summary!
806 notifyObservers
This content is now available at nsIObserverService.notifyObservers().
807 removeObserver
This content is now available at nsIObserverService.removeObserver().
808 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.
809 close
No summary!
810 flush
No summary!
811 isNonBlocking
No summary!
812 write
No summary!
813 writeFrom
No summary!
814 writeSegments
No summary!
815 nsIOutputStreamCallback Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
Called to indicate that the stream is either writable or closed.
816 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:
817 nsIParserUtils
Implemented by: @mozilla.org/parserutils;1 as a service:
818 nsIPassword Interfaces, Login Manager, NeedsContent, XPCOM API Reference
See Using nsIPasswordManager for examples of nsIPassword in use.
819 nsIPasswordManager Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM API Reference
See Using nsIPasswordManager for examples.
820 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.
821 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.
822 nsIPipe Interfaces, Interfaces:Scriptable, Streams, XPCOM, XPCOM Interface Reference
initialize this pipe.
823 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.
824 nsIPlacesView Developing Mozilla, Extensions, Interfaces, Places
The nsIPlacesView interface provides a view-agnostic way to access information about a Places view.
825 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.
826 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.
827 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():
828 nsIPrefLocalizedString Interfaces, Interfaces:Scriptable, Preferences, XPCOM, XPCOM Interface Reference
Used to set the contents of this object.
829 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.
830 nsIPrincipal
For details on principals, how they work, and how to get the appropriate one, see Security check basics.
831 nsIPrinterEnumerator Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
Returns an array of the names of all installed printers.
832 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.
833 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.
834 nsIProcess Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/process/util;1. To create an instance, use:
835 nsIProcess2 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/process/util;1. To create an instance, use:
836 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.
837 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:
838 nsIProfileLock Interfaces, Interfaces:Scriptable, Profiles, Toolkit, XPCOM Interface Reference
Unlocks the profile.
839 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.
840 nsIProgrammingLanguage Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Identifiers for programming languages.
841 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.
842 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().
843 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: "&&".
844 nsIProperties Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/file/directory_service;1. To get an instance, use:
845 get
No summary!
846 getKeys
No summary!
847 has
No summary!
848 set
No summary!
849 undefine
No summary!
850 nsIProperty Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
851 nsIPropertyBag Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Get a property value for the given name.
852 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.
853 nsIPropertyElement Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
854 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.
855 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.
856 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.
857 nsIProtocolProxyService Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/network/protocol-proxy-service;1. To access the service use:
858 nsIProxyInfo Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This interface identifies a proxy server.
859 nsIPushMessage Interfaces, Interfaces:Scriptable, Push, XPCOM, XPCOM Interface Reference
nsIPushMessage is the subject of a push-message observer notification.
860 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.
861 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.
862 nsIRadioInterfaceLayer Interfaces, Mobile, XPCOM API Reference
Implemented by: @mozilla.org/telephony/system-worker-manager;1. To create an instance, use:
863 nsIRandomGenerator Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Generates the specified amount of random bytes.
864 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.
865 nsIRequestObserver Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Called to signify the beginning of an asynchronous request.
866 nsIResumableChannel Channels, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Open this channel, and read starting at the specified offset.
867 nsIRunnable
No summary!
868 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:
869 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.
870 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.
871 nsISOCKSSocketInfo Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
No summary!
872 nsISSLErrorListener Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Called in case of an SSL error.
873 nsISSLSocketControl Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Starts an SSL proxy connection.
874 nsIScreen Interfaces, Interfaces:Scriptable, Screens, XPCOM, XPCOM Interface Reference
Use nsIScreenManager to obtain references to screens.
875 nsIScreenManager Interfaces, Interfaces:Scriptable, Screens, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/gfx/screenmanager;1 as a service:
876 nsIScriptError Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/scripterror;1. To create an instance, use:
877 nsIScriptError2 Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
No summary!
878 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 ]
879 nsIScriptableInputStream Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Return the number of bytes currently available in the stream.
880 available
No summary!
881 close
No summary!
882 init
No summary!
883 read
No summary!
884 nsIScriptableUnescapeHTML Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/feed-unescapehtml;1 as a service:
885 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.
886 nsIScrollable scrollbar
Scroll orientations a scrollbar can be in.
887 nsISearchEngine
Inherits from: nsISupports
888 nsISearchSubmission Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
No summary!
889 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:
890 nsISeekableStream Files, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
This method moves the stream offset of the stream implementing this interface.
891 nsISelection Guide, NeedsContent, XPCOM
Interface for manipulating and querying the current selected range of nodes within the document.
892 nsISelection2 Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
Return array of ranges intersecting with the given DOM interval.
893 nsISelection3 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Modifies the selection. Note that the parameters are case-insensitive.
894 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.
895 nsISelectionImageService Interfaces, NeedsContent, XPCOM Interface Reference
Retrieve the image for alpha blending.
896 nsISelectionPrivate Interfaces, Interfaces:Scriptable, NeedsContent
Will resume User Interface updates after a previous call to startBatchChanges().
897 nsIServerSocket Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
The nsIServerSocket interface implements a server socket that can accept incoming connections.
898 nsIServerSocketListener Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
This method is called when a client connection is accepted.
899 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.
900 getServiceByContractID
No summary!
901 isServiceInstantiated
No summary!
902 isServiceInstantiatedByContractID
No summary!
903 nsISessionStartup Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, sessionStorage
Implemented by: @mozilla.org/browser/sessionstartup;1. To use this service, use:
904 nsISessionStore Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Deletes a value from a specified tab.
905 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.
906 getNext
Documentation is now located at nsISimpleEnumerator.getNext().
907 hasMoreElements
Documentation is now located at nsISimpleEnumerator.hasMoreElements().
908 nsISmsDatabaseService Interfaces, Mobile, WebSMS
Implemented by: @mozilla.org/sms/smsdatabaseservice;1. To create an instance, use:
909 nsISmsRequestManager Interfaces, Mobile, WebSMS
Implemented by: @mozilla.org/sms/smsrequestmanager;1. To create an instance, use:
910 nsISmsService Interfaces, Mobile, WebSMS
Implemented by: @mozilla.org/sms/smsservice;1. To create an instance, use:
911 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:
912 nsISocketProviderService Interfaces, Interfaces:Scriptable, Sockets, XPCOM Interface Reference
Given a string representing a socket type, this method returns an nsISocketProvider representing that socket type.
913 nsISocketTransport Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
To create an instance, call nsISocketTransportService.createTransport()
914 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:
915 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.
916 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.
917 nsIStackFrame Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
To output the stack at a particular location:
918 nsIStandardURL Interfaces, Interfaces:Scriptable
Implemented by: @mozilla.org/network/standard-url;1. To create an instance, use:
919 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.
920 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.
921 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.
922 nsIStringBundleOverride Interfaces, Interfaces:Scriptable, String bundles, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/intl/stringbundle/text-override;1. To create an instance, use:
923 nsIStringBundleService Interfaces, Interfaces:Scriptable, Localization, NeedsContent, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/intl/stringbundle;1. To access this service, use:
924 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.
925 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.
926 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.
927 nsISupports Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Notifies the object that an interface pointer has been duplicated.
928 AddRef
Documentation is now located at nsISupports.AddRef().
929 Release
Documentation is now located at nsISupports.Release().
930 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.
931 nsISupportsArray Interfaces, Interfaces:Scriptable, NeedsHelp, XPCOM, XPCOM Interface Reference
No summary!
932 nsISupportsCString Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
This methods returns a string valued representation of the object.
933 data
No summary!
934 toString
No summary!
935 nsISupportsChar Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
936 data
No summary!
937 toString
No summary!
938 nsISupportsDouble Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
939 data
No summary!
940 toString
No summary!
941 nsISupportsFloat Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
942 data XPCOM API Reference
This content is now available at nsISupportsFloat.Attributes.
943 toString
This content is now available at nsISupportsFloat.toString().
944 nsISupportsID Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This method returns a string valued representation of the object.
945 data
No summary!
946 toString
No summary!
947 nsISupportsInterfacePointer Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Returns a string valued representation of the object.
948 data
No summary!
949 dataIID
No summary!
950 toString
This content is now available at nsISupportsInterfacePointer.toString().
951 nsISupportsPRBool Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
952 data
No summary!
953 toString
No summary!
954 nsISupportsPRInt16 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
955 data
This content is now available at nsISupportsPRInt16.Attributes.
956 toString
This content is now available at nsISupportsPRInt16.toString().
957 nsISupportsPRInt32 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
958 data
No summary!
959 toString
No summary!
960 nsISupportsPRInt64 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
961 data
This content is now available at nsISupportsPRInt64.Attributes.
962 toString
This content is now available at nsISupportsPRInt64.toString().
963 nsISupportsPRTime Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
964 data
No summary!
965 toString
No summary!
966 nsISupportsPRUint16 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
967 data
No summary!
968 toString
No summary!
969 nsISupportsPRUint32 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
970 data
No summary!
971 toString
No summary!
972 nsISupportsPRUint64 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
973 data
No summary!
974 toString
No summary!
975 nsISupportsPRUint8 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
976 data
No summary!
977 toString
No summary!
978 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.
979 type XPCOM API Reference
No summary!
980 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.
981 nsISupportsString Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This methods returns a string valued representation of the object.
982 data
No summary!
983 toString
No summary!
984 nsISupportsVoid Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
None.
985 data
Documentation is now located at nsISupportsVoid.data().
986 toString
Documentation is now located at nsISupportsVoid.toString().
987 nsISupportsWeakReference Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Produces an appropriate instance of nsIWeakReference.
988 getWeakReference
This content is now available at nsISupportsWeakReference.getWeakReference().
989 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.
990 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.
991 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.
992 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:
993 nsITaskbarPreview Interfaces, Interfaces:Scriptable, Taskbar, XPCOM, XPCOM Interface Reference
You can not directly instantiate this interface. Instead, you use nsITaskbarTabPreview or nsITaskbarWindowPreview as appropriate.
994 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.
995 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.
996 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.
997 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.
998 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.
999 nsITelemetry Developing Mozilla, Interfaces, Interfaces:Scriptable, Performance, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/base/telemetry;1 as a service:
1000 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.
1001 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.
1002 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.
1003 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.
1004 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.
1005 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.
1006 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.
1007 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.
1008 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.
1009 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.
1010 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.
1011 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.
1012 nsIToolkit Interfaces, XPCOM, XPCOM Interface Reference
Initialize this toolkit with aThread.
1013 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.
1014 nsIToolkitProfileService Interfaces, Interfaces:Scriptable, Profiles, Toolkit, XPCOM Interface Reference
Creates a new profile.
1015 nsITraceableChannel HTTP, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
The typical way to use this interface is as follows:
1016 nsITransaction Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Executes the transaction.
1017 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.
1018 nsITransactionListener Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
Called after a nsITransactionManager begins a batch.
1019 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.
1020 nsITransferable Gecko, Interface, Mozilla, Reference, Référence, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/widget/transferable;1. To create an instance, use:
1021 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).
1022 nsITransportEventSink Interfaces, Interfaces:Scriptable, Transports, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Transport status notification.
1023 nsITransportSecurityInfo Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
No summary!
1024 nsITreeBoxObject Interfaces, XPCOM, XPCOM Interface Reference
The nsITreeBoxObject interface contains information about the size and layout of a tree.
1025 nsITreeColumn Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
The nsITreeColumn interface represents a tree column.
1026 nsITreeColumns Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
The nsITreeColumns interface represents the tree columns.
1027 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.
1028 nsITreeSelection Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Called when the row count changes to adjust selection indices.
1029 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.
1030 nsIURI Interfaces, Interfaces:Scriptable, URIs, XPCOM, XPCOM Interface Reference
See the following RFCs for details:
1031 nsIURIFixup Interfaces, Interfaces:Scriptable, URI, XPCOM Interface Reference
Implemented by: @mozilla.org/docshell/urifixup;1 as a service:
1032 nsIURL Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
You can get a nsIURL from an nsIURI, using the QueryInterface() method:
1033 nsIURLFormatter Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM Interface Reference
Variable names can contain 'A-Z' letters and '_' characters.
1034 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.
1035 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.
1036 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.
1037 nsIUUIDGenerator Add-ons, Extensions, Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by @mozilla.org/uuid-generator; as a service:
1038 nsIUpdate Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Retrieves a patch.
1039 nsIUpdateCheckListener Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Called when the update check is completed.
1040 nsIUpdateChecker Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Checks for available updates, notifying a listener of the results.
1041 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.
1042 nsIUpdateManager Interfaces, Interfaces:Scriptable, Update Service, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Returns the update at the specified index into the history list.
1043 nsIUpdatePatch Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Serializes the patch object into a DOM element.
1044 nsIUpdatePrompt Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Presents a user interface that checks for and displays the available updates.
1045 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.
1046 nsIUploadChannel Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Sets a stream to be uploaded by this channel.
1047 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.
1048 nsIUrlListManagerCallback Interfaces, Interfaces:Scriptable, NeedsContent
No summary!
1049 nsIUserCertPicker Cryptography, Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
No summary!
1050 nsIUserInfo Interfaces, Interfaces:Scriptable, Reference, Référence, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/userinfo;1. To get the service, use:
1051 nsIVariant Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference, XPConnect
None.
1052 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".
1053 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.
1054 queryReferent
No summary!
1055 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.
1056 nsIWebBrowserChrome Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Asks the implementer to destroy the window associated with this WebBrowser object.
1057 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().
1058 nsIWebBrowserChrome3 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Determines the appropriate target for a link.
1059 nsIWebBrowserChromeFocus Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Set the focus at the next focusable element in the chrome.
1060 nsIWebBrowserFind Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Get one by doing a GetInterface on an nsIWebBrowser.
1061 nsIWebBrowserFindInFrames Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Get an instance by doing a QueryInterface from nsIWebBrowserFind.
1062 nsIWebBrowserPersist Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference, needsattention
Implemented by: @mozilla.org/embedding/browser/nsWebBrowser;1 and @mozilla.org/embedding/browser/nsWebBrowserPersist;1. To create an instance, use:
1063 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:
1064 nsIWebNavigation Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
This interface is implemented by the following components:
1065 nsIWebNavigationInfo Interfaces, Interfaces:Scriptable, MIME, XPCOM Interface Reference
Implemented by: @mozilla.org/webnavigation-info;1 as a service:
1066 nsIWebPageDescriptor Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
Tells the object to load the page specified by the page descriptor.
1067 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).
1068 nsIWebProgressListener Interfaces, Interfaces:Scriptable, NeedsMarkupWork, XPCOM, XPCOM API Reference, XPCOM Interface Reference
nsIWebProgress describes the parent-child relationship of nsIWebProgress instances.
1069 nsIWebProgressListener2 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
An extended version of nsIWebProgressListener.
1070 nsIWebSocketChannel Interfaces, Interfaces:Scriptable, NeedsContent, Reference, Référence, WebSockets, XPCOM Interface Reference
Technical review completed.
1071 nsIWebSocketListener Interfaces, Interfaces:Scriptable, Reference, Référence, WebSockets, XPCOM Interface Reference
Called to acknowledge a message sent via nsIWebSocketChannel.sendMsg() or nsIWebSocketChannel.sendBinaryMsg().
1072 nsIWebappsSupport Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
This method installs a web application.
1073 nsIWifiAccessPoint Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
No summary!
1074 nsIWifiListener Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
Called when the list of available access points changes.
1075 nsIWifiMonitor Interfaces, Interfaces:Scriptable, WiFi, XPCOM, XPCOM Interface Reference
This is used, for example, by Geolocation to use WiFi access points for location detection.
1076 nsIWinAccessNode Interfaces, NeedsContent, XPCOM Interface Reference
No summary!
1077 nsIWinAppHelper Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/xre/app-info;1. To create an instance, use:
1078 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.
1079 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.
1080 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.
1081 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.
1082 nsIWindowsRegKey Interfaces, Interfaces:Scriptable, NeedsContent, NeedsExample, XPCOM, XPCOM Interface Reference
The interface represents a single key in the registry.
1083 nsIWindowsShellService Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM Interface Reference
Valid starting keys for the Windows Registry.
1084 nsIWorker DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
For usage details, see worker and the article Using DOM workers.
1085 nsIWorkerFactory Workers, XPCOM, XPCOM Interface Reference
Implemented by: threads/workerfactory;1. To create an instance, use:
1086 nsIWorkerGlobalScope DOM, Interfaces, Interfaces:Scriptable, NeedsContent, Workers, XPCOM, XPCOM Interface Reference
No summary!
1087 nsIWorkerMessageEvent DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
Initializes the message event.
1088 nsIWorkerMessagePort DOM, Interfaces, Interfaces:Scriptable, Workers, XPCOM, XPCOM Interface Reference
Posts a message into the event queue.
1089 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.
1090 nsIWritablePropertyBag Interfaces, Interfaces:Scriptable, XPCOM Interface Reference
Delete a property with the given name.
1091 nsIWritablePropertyBag2 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
No summary!
1092 nsIXFormsModelElement Interfaces, Interfaces:Scriptable, XForms, XPCOM, XPCOM API Reference, XPCOM Interface Reference
An nsIDOMDocument.
1093 nsIXFormsNSInstanceElement Interfaces, Interfaces:Scriptable, NeedsExample, NeedsMarkupWork, XForms, XPCOM API Reference, XPCOM Interface Reference
nsIXFormsNSInstanceElement is implemented by all XForms <instance/> elements, defining Mozilla extensions.
1094 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.
1095 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.
1096 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.
1097 nsIXMLHttpRequestUpload AJAX, Interfaces, Interfaces:Scriptable, XMLHttpRequest, XPCOM, XPCOM Interface Reference
No summary!
1098 nsIXPCException Interfaces, Interfaces:Scriptable, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference, XPConnect
None.
1099 nsIXPCScriptable Interfaces, NeedsContent, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Inherits from: nsISupports
1100 nsIXPConnect Interfaces, NeedsContent, Reference, Référence, XPCOM, XPCOM Interface Reference, XPConnect
To access the XPConnect service, use code like this:
1101 nsIXSLTException Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XSLT
No summary!
1102 nsIXSLTProcessor Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, XSLT
Implemented by: @mozilla.org/document-transformer;1?type=xslt. To create an instance, use:
1103 nsIXSLTProcessorObsolete
Use nsIXSLTProcessor instead.
1104 nsIXULAppInfo Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
In XULRunner applications nsIXULAppInfo obtains app-specific information from application.ini.
1105 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.
1106 nsIXULBuilderListener Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Called after a template builder has rebuilt its content.
1107 nsIXULRuntime Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/xre/app-info;1. To get an instance, use:
1108 nsIXULSortService Interfaces, Interfaces:Scriptable, XPCOM Interface Reference, XUL
Used internally for insertion sorting.
1109 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.
1110 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.
1111 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.
1112 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.
1113 nsIXmlRpcClient Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
1114 nsIXmlRpcFault
No summary!
1115 nsIZipEntry Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
No summary!
1116 nsIZipReader Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, XPCOM Interface Reference
Implemented by: @mozilla.org/libjar/zip-reader;1. To create an instance, use:
1117 nsIZipReaderCache Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: @mozilla.org/libjar/zip-reader-cache;1. To create an instance, use:
1118 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.
1119 nsMsgFilterFileAttribValue
Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgFilterList.idl
1120 nsMsgFolderFlagType
Defined in comm-central/ mailnews/ base/ public/ nsMsgFolderFlags.idl
1121 nsMsgJunkStatus Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1122 nsMsgKey XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1123 nsMsgLabelValue XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1124 nsMsgPriorityValue XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ public/ MailNewsTypes2.idl
1125 nsMsgRuleActionType Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgFilterCore.idl
1126 nsMsgSearchAttrib Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1127 nsMsgSearchOp Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1128 nsMsgSearchScope
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1129 nsMsgSearchTerm
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1130 nsMsgSearchTypeValue
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1131 nsMsgSearchValue Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1132 nsMsgSearchWidgetValue Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference, thunderbird
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1133 nsPIPromptService Interfaces, Interfaces:Scriptable, XPCOM, XPCOM Interface Reference
Implemented by: The contract ID isn't defined.
1134 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.)
1135 XPCOM glue classes Classes, Landing, XPCOM
These "glue" classes are provided to make it easier to use XPCOM from C++ code.
1136 NS ConvertASCIItoUTF16 external NeedsContent, Reference, Référence, strings
Class Declaration
1137 NS ConvertUTF16toUTF8 external NeedsContent, Reference, Référence, strings
Class Declaration
1138 NS ConvertUTF8toUTF16 external NeedsContent, Reference, Référence, strings
Class Declaration
1139 NS LossyConvertUTF16toASCII external NeedsContent, Reference, Référence, strings
Class Declaration
1140 NS_ConvertASCIItoUTF16
Class Declaration
1141 NS_ConvertUTF16toUTF8
Class Declaration
1142 NS_ConvertUTF8toUTF16
Class Declaration
1143 NS_LossyConvertUTF16toASCII
Class Declaration
1144 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.
1145 NS_POSTCONDITION XPCOM, XPCOM_Macros
Macro
1146 NS_PRECONDITION XPCOM, XPCOM_Macros
Macro
1147 PromiseFlatCString (External) NeedsContent, Reference, Référence, strings
Class Declaration
1148 PromiseFlatString (External) NeedsContent, Reference, Référence, strings
Class Declaration
1149 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.
1150 Append XPCOM, XPCOM API Reference
The Append family of functions appends a value to the end of a string's internal buffer.
1151 Assign XPCOM, XPCOM API Reference
The Assign family of functions sets the value of a string's internal buffer.
1152 BeginReading XPCOM, XPCOM API Reference
The BeginReading function returns a const pointer to the first element of the string's internal buffer.
1153 Cut XPCOM, XPCOM API Reference
The Cut function removes a section of the string's internal buffer.
1154 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.
1155 Insert XPCOM, XPCOM API Reference
The Insert family of functions inserts a value into a string's internal buffer.
1156 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).
1157 Replace XPCOM, XPCOM API Reference
The Replace family of functions sets the value of a string's internal buffer.
1158 operator+= XPCOM, XPCOM API Reference
This operator+= is a shortcut for the Append family of functions.
1159 operator= XPCOM, XPCOM API Reference
This operator is a shortcut for the Assign family of functions.
1160 nsACString (External) NeedsContent, Reference, Référence, strings
Class Declaration
1161 nsACString_internal
Class Declaration
1162 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.
1163 Append XPCOM, XPCOM API Reference
The Append family of functions appends a value to the end of a string's internal buffer.
1164 Assign XPCOM, XPCOM API Reference
The Assign family of functions sets the value of a string's internal buffer.
1165 BeginReading XPCOM, XPCOM API Reference
The BeginReading function returns a const pointer to the first element of the string's internal buffer.
1166 Cut XPCOM, XPCOM API Reference
The Cut function removes a section of the string's internal buffer.
1167 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.
1168 Insert XPCOM, XPCOM API Reference
The Insert family of functions inserts a value into a string's internal buffer.
1169 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).
1170 Replace XPCOM, XPCOM API Reference
The Replace family of functions sets the value of a string's internal buffer.
1171 operator+= XPCOM, XPCOM API Reference
This operator+= is a shortcut for the Append family of functions.
1172 operator= XPCOM, XPCOM API Reference
This operator= is a shortcut for the Append family of functions.
1173 nsAString (External)
Class Declaration
1174 nsAString_internal
Class Declaration
1175 nsAdoptingCString
Class Declaration
1176 nsAdoptingString
Class Declaration
1177 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>
1178 nsAutoRefTraits
nsAutoRefTraits<t> is a template class describing traits of resources held by objects of class nsAutoRef<T> and/or nsCountedRef<T>.</t>
1179 nsAutoString
Class Declaration
1180 nsAutoString (External) NeedsContent, Reference, Référence, strings
Class Declaration
1181 nsCAutoString
Class Declaration
1182 nsCAutoString (External) NeedsContent, Reference, Référence, strings
Class Declaration
1183 nsCOMPtr XPCOM, XPCOM API Reference
This utility class simplifies managing XPCOM interface references from C++ code.
1184 nsCString
Class Declaration
1185 nsCString external NeedsContent, Reference, Référence, strings
Class Declaration
1186 nsCStringContainer (External) NeedsAttention, Reference, Référence, needsattention, strings
Class Declaration
1187 nsCStringEncoding XPCOM, XPCOM API Reference
The nsCStringEncoding enumeration describes the set of character encodings understood by the NS_CStringToUTF16 and NS_UTF16ToCString functions.
1188 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>
1189 nsDependentCString
Class Declaration
1190 nsDependentCString external NeedsContent, Reference, Référence, strings
Class Declaration
1191 nsDependentCSubstring
Class Declaration
1192 nsDependentCSubstring external NeedsContent, Reference, Référence, strings
Class Declaration
1193 nsDependentString
Class Declaration
1194 nsDependentString external NeedsContent, Reference, Référence, strings
Class Declaration
1195 nsDependentSubstring
Class Declaration
1196 nsDependentSubstring external NeedsContent, Reference, Référence, strings
Class Declaration
1197 nsEmbedCString XPCOM, XPCOM API Reference
The nsEmbedCString concrete class provides a way to construct a nsACString object that allocates null-terminated storage.
1198 get XPCOM, XPCOM API Reference
The get function returns a const pointer to the string's null-terminated, internal buffer.
1199 nsEmbedCString XPCOM, XPCOM API Reference
Constructors for nsEmbedCString.
1200 operator= XPCOM, XPCOM API Reference
This operator is a shortcut for the inherited nsACString::Assign family of functions.
1201 nsEmbedString XPCOM, XPCOM API Reference
The nsEmbedString concrete class provides a way to construct a nsAString object that allocates null-terminated storage.
1202 get XPCOM, XPCOM API Reference
The get function returns a const pointer to the string's null-terminated, internal buffer.
1203 nsEmbedString XPCOM, XPCOM API Reference
Constructors for nsEmbedString.
1204 operator= XPCOM, XPCOM API Reference
This operator is a shortcut for the inherited nsAString::Assign family of functions.
1205 nsFixedCString
Class Declaration
1206 nsFixedString
Class Declaration
1207 nsLiteralCString (External) NeedsContent, Reference, Référence, strings
Class Declaration
1208 nsLiteralString (External) NeedsContent, Reference, Référence, strings
Class Declaration
1209 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.
1210 Alloc XPCOM, XPCOM API Reference
The Alloc function allocates a block of memory of a particular size.
1211 Clone XPCOM, XPCOM API Reference
The Clone function creates a copy of an existing memory block up to the size specified.
1212 Free XPCOM, XPCOM API Reference
The Free function frees a block of memory that was allocated by XPCOM's memory manager.
1213 GetGlobalMemoryService XPCOM, XPCOM API Reference
The GetGlobalMemoryService function returns a reference to XPCOM's global nsIMemory object.
1214 HeapMinimize XPCOM, XPCOM API Reference
The HeapMinimize function attempts to shrink the size of the heap.
1215 Realloc XPCOM, XPCOM API Reference
The Realloc function reallocates a block of memory to a new size.
1216 nsPromiseFlatCString
Class Declaration
1217 nsPromiseFlatString
Class Declaration
1218 nsRefPtr nsCOMPtr nsRefPtr
nsRefPtr 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.
1219 nsString
Class Declaration
1220 nsString external NeedsContent, Reference, Référence, strings
Class Declaration
1221 nsStringContainer (External) NeedsContent, Reference, Référence, strings
Class Declaration
1222 nsSupportsWeakReference XPCOM, XPCOM API Reference
Inherit from this C++ class to add canonical support for nsISupportsWeakReference.
1223 nsXPIDLCString
Class Declaration
1224 nsXPIDLString
Class Declaration
1225 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.
1226 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.
1227 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.
1228 NS_CStringCloneData XPCOM, XPCOM API Reference
The NS_CStringCloneData function returns a null-terminated, heap allocated copy of the string's internal buffer.
1229 NS_CStringContainerFinish Functions, Functions:Frozen, XPCOM, XPCOM API Reference
The NS_CStringContainerFinish function releases any memory allocated by a nsCStringContainer instance.
1230 NS_CStringContainerInit Functions, Functions:Frozen, XPCOM, XPCOM API Reference
The NS_CStringContainerInit function initializes a nsCStringContainer instance for use as a nsACString.
1231 NS_CStringContainerInit2 Functions, Functions:Frozen, XPCOM, XPCOM API Reference
The NS_CStringContainerInit2 function initializes a nsCStringContainer instance for use as a nsACString.
1232 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.
1233 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.
1234 NS_CStringGetData Functions, Functions:Frozen, XPCOM, XPCOM API Reference
The NS_CStringGetData function gives the caller read access to the string's internal buffer.
1235 NS_CStringGetMutableData Functions, Functions:Frozen, XPCOM, XPCOM API Reference
The NS_CStringGetMutableData function gives the caller write access to the string's internal buffer.
1236 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.
1237 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.
1238 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.
1239 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.
1240 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.
1241 NS_StringCloneData XPCOM, XPCOM API Reference
The NS_StringCloneData function returns a null-terminated, heap allocated copy of the string's internal buffer.
1242 NS_StringContainerFinish XPCOM, XPCOM API Reference
The NS_StringContainerFinish function releases any memory allocated by a nsStringContainer instance. This is a low-level API.
1243 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.
1244 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.
1245 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.
1246 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.
1247 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.
1248 NS_StringSetData XPCOM, XPCOM API Reference
The NS_StringSetData function copies data into the string's internal buffer. This is a low-level API.
1249 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.
1250 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.
1251 nsGetModuleProc
This function prototype provides the XPCOM entry-point into a module.
1252 nsIAbCard/Thunderbird3 Interfaces, Interfaces:Scriptable, XPCOM, XPCOM API Reference, thunderbird
No summary!
1253 nsICookie2 MOZILLA 1 8 BRANCH Interfaces, XPCOM, XPCOM API Reference
No summary!
1254 nsIMsgSearchValue
Defined in comm-central/ mailnews/ base/ search/ public/ nsIMsgSearchValue.idl
1255 nsMsgMessageFlags
The nsMsgMessageFlags interface describes possible flags for messages. Equivalent flags are also defined in nsMsgMessageFlags.h.
1256 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:
1257 nsMsgSearchOpValue
Defined in comm-central/ mailnews/ base/ search/ public/ nsMsgSearchCore.idl
1258 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.
1259 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:
1260 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:
1261 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:
1262 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:
1263 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:
1264 nsStaticModuleInfo
This data structure is used by NS_InitXPCOM3 to specify static XPCOM modules.
1265 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.
1266 Xptcall Porting Guide
Original Author: John Bandhauer, 31 May 1999.
1267 Xptcall Porting Status
This is a status page for the multiplatform porting of xptcall. xptcall has a FAQ and a Porting Guide.
1268 already_AddRefed XPCOM, XPCOM API Reference, nsCOMPtr
already_AddRefed in association with nsCOMPtr allows you to assign in a pointer without AddRefing it.
1269 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.

Document Tags and Contributors

 Contributors to this page: fscholz
 Last updated by: fscholz,