|
HTML
|
Hypertext Markup Language - NGLayout implements HTML 4.0
|
|
IID
|
Interface ID {xxxxx-xxx-xxx-xxxxxx}. A unique number that identifies a given
interface.
|
|
Interface
|
Contract betwen the implementation and usage. A pure virtual abstract base
class with no data members. eg.
nsIZipReaderInterface
|
|
IDL
|
Interface Description Language. A language-independent way to describe a
module interface. IDL is compiled by an IDL compiler to generate C++ header
files which describe XPCOM interfaces. Mozilla uses both DOM IDL (compiled
by idlc), for DOM and parts of layout, and
XPIDL
(compiled by xpidl), for everything else.
In the future, DOM IDL will be replaced by XPIDL.
|
|
internationalization
|
Designing and developing a software product to function in multiple locales.
This process involves identifying the locales that must be supported,
designing features which support those locales, and writing code that
functions equally well in any of the supported locales.
|
|
i18n
|
Acronym for "internationalization" ("i" + 18 letters + "n"; lower case i
is used to distinguish it from the numeral 1 (one)).
|
|
imglib
|
Image library
|
|
js
|
JavaScript
|
|
libfont
|
Font library
|
|
localization
|
Modifying or adapting a software product to fit the requirements of a
particular locale. This process includes (but may not be limited to)
translating the user interface, documentation and packaging, changing
dialog box geometries, customizing features (if necessary), and testing
the translated product to ensure that it still works (at least as well as
the original).
|
|
localizability
|
The degree to which a software product can be localized. Localizable
products separate data from code, correctly display the target language
and function properly after being localized.
|
|
L10n
|
Acronym for "localization" ("L" + 10 letters + "n"; upper case L is used to
distinguish it from the numeral 1 (one)).
|
|
L12y
|
Acronym for "localizability" ("L" + 12 letters + "y"; upper case L is used
to distinguish it from the numeral 1 (one)).
|
|
Locale
|
A set of conventions affected or determined by human language and customs,
as defined within a particular geo-political region. These conventions
include (but are not necessarily limited to) the written language, formats
for dates, numbers and currency, sorting orders, etc.
|
|
module
|
A packaging of a set of Components (ie) a DLL.
|
|
necko
|
Mozilla's networking library. Responsible for parsing
urls, handling connections to webservers, handling transfer
protocols and delivering a data stream to the parser.
|
|
netlib
|
Networking Library. The current networking library is called
necko.
|
|
nglayout
|
Next Generation Layout Engine.
|
|
nsCOMPtr
|
nsCOMPtr is a `smart-pointer'. It is a template class that acts, syntactically, just like an ordinary pointer in C or C++, i.e., you can
apply * or -> to it to `get to' what it points at. nsCOMPtr is smart in that, unlike a raw COM interface pointer, nsCOMPtr manages
AddRef, Release, and QueryInterface for you.
|
|
nsISupports
|
The mother of all interfaces. All interfaces ultimately inherit from this.
Provides refcounting. The IID and definition has been carefully choosen so
as to be binary compatible with COM.
|
|
object
|
An instance of a Component
|
|
OCSP
|
Online Certificate Status Protocol. A PKIX protocol used for determining
the current status of a digital certificate. For details, see
OCSP.
|
|
PDT
|
The Product Delivery Team keeps track of bugs that most affect the
usability of the browser. The idea is that after the PDT bugs are fixed,
mozilla will have reached dogfood. That is, it will be usable enough for
developers and testers to use every day as their main browser and mail
client even if it isn't perfect yet. Bugs are marked [Dogfood] when
someone believes that the bug keeps mozilla from being usable as dogfood.
The PDT team marks the bug [PDT+] if they agree and [PDT-] if not.
|
|
PKIX
|
Public-Key Infrastructure (X.509). A working group of the Internet
Engineering Task Force (IETF) that is developing Internet standards
needed to support a PKI based on X.509 certificates. For more information, see
PKIX Charter.
|
|
PKCS #5
|
Public-Key Cryptography Standard #5. The standard developed by RSA
Laboratories that governs password-based cryptography, for example to
encrypt private keys for storage. For details published by RSA, see
PKCS #5.
|
|
PKCS #7
|
Public-Key Cryptography Standard #7. The standard developed by RSA
Laboratories that governs the application of cryptography to
data, for example digital signatures. For details published by RSA, see
PKCS #7.
|
|
PKCS #11
|
Public-Key Cryptography Standard #11. The standard developed by RSA
Laboratories that governs communication with cryptographic tokens (such as
smart cards). For details published by RSA, see
PKCS #11.
|
|
PKCS #12
|
Public-Key Cryptography Standard #12. The PKCS standard developed by RSA
Laboratories that governs the format used to store or transport private keys,
certificates, and other secret material. For details published by RSA, see
PKCS #12.
|
|
porkjockey
|
The porkjockeys are a group of people taking time to fix major
architectural issues that are the source of bugs and usability problems
throughout the codebase. The name was coined at an architecture meeting one
dark day, when someone asked when the beta would ship. The answer?
When pigs fly. Thus began a hopefully-not-quixotic quest to launch
pork.
|
|
presentation context
|
An object that provide a context for a presentation shell. It is a means
for the presentation shell to get at external settings and data.
|
|
presentation shell
|
Presentation shells are the controlling object
during the presentation of a document. It owns the
document, the frame hierarchy, stylesheets and the
presentation context. It also controls and initiates the
reflow of the document.
|
|
private key
|
One of a pair of keys used in public-key
cryptography. The private key is kept secret and is used to decrypt
data encrypted with the corresponding public key.
|
|
ProgID
|
A String name for a Component.
|
|
public key
|
One of a pair of keys used in public-key
cryptography. The public key is distributed freely and published as
part of a certificate. It is typically used to encrypt data sent to the
public key's owner, who then decrypts the data with the corresponding
private key.
|
|
public-key cryptography
|
A set of well-established techniques and standards that allow an entity
to verify its identity electronically or to sign and encrypt electronic
data. Two keys are involved: a public key and a private key. A public
key is published as part of a certificate, which associates that key with
a particular identity. The corresponding private key is kept secret. Data
encrypted with the public key can be decrypted only with the private key.
|
|
public-key infrastructure (PKI)
|
The standards and services that facilitate the use of public-key
cryptography and X.509 v3 certificates in a networked environment.
|
|
raptor
|
Former code-name for NGLayout. We were asked to stop using it in public
due to trademark problems.
|
|
registry
|
A hierarchical attribute-value pair storage.
|
|
RDF
|
Resource Description Framework
|
|
reflow
|
The act of laying out the content tree and creating/updating
the corresponding frame hierarchy is called reflowing.
|
|
reflow unmapped
|
Reflowing content that doesn't yet have a frame.
|
|
reflow mapped
|
Reflowing content that already has a frame.
|
|
SSL
|
Secure Sockets Layer. A protocol that allows mutual authentication between a client and server
and the establishment of an authenticated and encrypted connection. SSL
runs above TCP/IP and below HTTP, LDAP, IMAP, NNTP, and other high-level
network protocols. For complete specification, see
SSL v3.
|
|
service
|
A component that is used as a singleton. That means there
exist only one instantiation of the component, and all
request for it returns the same object.
|
|
ServiceManager
|
A singleton manager. Holds and manages singleton references to objects for
application. Going to be merged with the ComponentManager.
|
|
typelib
|
Storage for type information about interfaces. Interfaces expressed in IDL
have their type information maintained in Typelib automatically.
|
|
S/MIME
|
Secure/Multipurpose Internet Mail Extensions. A message specification (based on the popular Internet MIME standard)
that provides a consistent way to send and receive signed and encrypted
MIME data. For complete specifications, see
S/MIME version 2
and
SSL version 3.
|
|
subject name
|
A distinguished name (DN) that uniquely describes the subject of a certificate.
|
|
TLS
|
Transport Layer Security. A protocol from the IETF based on SSL.
It will eventually supersede SSL while remaining backward-compatible with SSL
implementations. For more information, see
IETF TLS page.
|
|
UI
|
User Interface
|
|
webshell
|
A container that knows how to load and render web
pages. Frameset pages has a root webshell and one webshell
per frame.
|
|
widget
|
Primitive user interface part (button, menu, radiobutton,
etc). There are two kinds of widgets: Native and
gfx. Native widgets are implemented differently for each
platform, but gfx widgets are implemented using gfx and is
thus the same for all platforms.
|
|
X.509
|
A standard defined by the International
Telecommunication Union (ITU) that governs the format of certificates
used for authentication in public-key cryptography.
|
|
XIF
|
XML Interchange Format - used internally by NGLayout for all I/O to
clipboard, etc.
|
|
XML
|
Extensible Markup Language - see the W3C's XML site for
more info
|
|
XP
|
Cross-Platform
|
|
XPCOM
|
Cross Platform Component Object Model
|
|
XPConnect
|
Ability to call C++ implementations of interfaces expressed in IDL from
javascript and vice versa.
|
|
XPFE
|
The cross-platform front end. The part of Mozilla that
implements the user interface of mozilla. Everything that
makes a browser a browser except the rendering of pages is
considered xpfe (bookmarks, toolbars, menus etc).
|
|
XPIDL
|
Cross Platform Interface Definition Language. A language for expressing
interfaces.
|
|
XUL
|
XML-based User Interface Language.
XUL (pronounced "zuul")
is the user interface description language used for creating user
interfaces with Mozilla's Cross Platform Front End.
|