Search completed in 1.38 seconds.
Manifest Files - Archive of obsolete content
« previousnext » in this section, we'll see how to put chrome and xul files into a package and create the
manifest files for them.
...
manifest files a
manifest file describes a package and maps its location on disk to a chrome url.
... the
manifest files in the chrome directory will be examined when a mozilla application starts up to see what packages are installed.
...And 20 more matches
Install Manifests - Archive of obsolete content
introduction an install
manifest is the file an add-on manager-enabled xul application (e.g.
... the format of the install
manifest is rdf/xml.
... layout the basic layout of an install
manifest is like so: <?xml version="1.0" encoding="utf-8"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <!-- properties --> </description> </rdf> some properties are required, some are optional.
...And 19 more matches
Web app manifests
web app
manifests are part of a collection of web technologies called progressive web apps (pwas), which are websites that can be installed to a device’s homescreen without an app store.
... the web app
manifest provides information about a web application in a json text file, necessary for the web app to be downloaded and be presented to the user similarly to a native app (e.g., be installed on the homescreen of a device, providing users with quicker access and a richer experience).
... pwa
manifests include its name, author, icon(s), version, description, and list of all the necessary resources (among other things).
...And 8 more matches
Inspecting web app manifests - Firefox Developer Tools
in this article we will look at inspecting app
manifests using the firefox devtools application panel.
... when you open the application panel’s
manifest view on a page that doesn't have an app
manifest successfully deployed, you'll get the following output shown: deploying a
manifest to get a
manifest deployed successfully, you need to include a <link> element in the <head> of your document that points to your .web
manifest file: <link rel="
manifest" href="/
manifest.web
manifest"> the .web
manifest extension is recommended in the spec, and should be served with an application/
manifest+json mime type, although browsers generally tend to support
manifests with other appropriate extensions like .json (mime type: application/json).
...you can test this using the web
manifest validator.
...And 3 more matches
manifest - HTML: Hypertext Markup Language
the
manifest attribute of <html> element specifies a url of a application cache
manifest that is downloaded in the early stages of page load.
... note:
manifest-based caching mechanism has been deprecated.
... the
manifest attribute has only effect during early stages of page load, thus changing it via regular dom interfaces has no effect, window.applicationcache interface instead.
...And 2 more matches
HTMLIFrameElement.getManifest()
the get
manifest() method of the htmliframeelement interface retrieves the
manifest of an app loaded in the browser <iframe> and returns it as json.
... syntax instanceofhtmliframeelement.get
manifest().then(function(json) { ...
... return value a promise that resolves to a json object representation of the loaded app's
manifest.
... examples var browser = document.queryselector('iframe'); browser.addeventlistener('mozbrowserloadend',function() { var request = browser.get
manifest().then(function(json) { console.log(json); }); }); specification not part of any specification.
mozbrowsermanifestchange
the mozbrowser
manifestchange event is fired when the
manifest location of the app loaded in the browser <iframe> changes.
... by this, we are referring to the href of the
manifest, as defined in <link rel="
manifest" href=" … ">.
... details the details property returns an anonymous javascript object with the following properties: href the url of the new app
manifest.
... example var browser = document.queryselector("iframe"); browser.addeventlistener("mozbrowser
manifestchange", function(event) { console.log("new
manifest url: " + event.details.href); }); related events mozbrowserasyncscroll mozbrowsercontextmenu mozbrowsererror mozbrowsericonchange mozbrowserloadend mozbrowserloadstart mozbrowserlocationchange mozbrowseropenwindow mozbrowsersecuritychange mozbrowsershowmodalprompt mozbrowsertitlechange mozbrowserusernameandpasswordrequired ...
scope - Web app manifests
it restricts what web pages can be viewed while the
manifest is applied.
... if the scope is a relative url, the base url will be the url of the
manifest.
... examples if the scope is relative, the
manifest url is used as a base url: "scope": "/app/" the following scope limits navigation to the current site: "scope": "https://example.com/" finally, the following example limits navigation to a subdirectory of the current site: "scope": "https://example.com/subdirectory/" specification specification status comment feedback web app
manifestthe definition of 'scope' in that specification.
... web app
manifest working group drafts ...
CSP: manifest-src - HTTP
the http content-security-policy:
manifest-src directive specifies which
manifest can be applied to the resource.
... syntax one or more sources can be allowed for the
manifest-src policy: content-security-policy:
manifest-src <source>; content-security-policy:
manifest-src <source> <source>; sources <source> can be one of the following: <host-source> internet hosts by name or ip address, as well as an optional url scheme and/or port number.
... examples violation cases given this csp header: content-security-policy:
manifest-src https://example.com/ the following <link> is blocked and won't load: <link rel="
manifest" href="https://not-example.com/
manifest"> specifications specification status comment content security policy level 3the definition of '
manifest-src' in that specification.
background_color - Web app manifests
this value is used by the user agent to draw the background color of a shortcut when the
manifest is available before the stylesheet has loaded.
... examples "background_color": "red" specification specification status comment feedback web app
manifestthe definition of 'background_color' in that specification.
... web app
manifest working group drafts ...
description - Web app manifests
description is directionality-capable, which means it can be displayed left to right or right to left based on the values of the dir and lang
manifest members.
... simple description in left-to-right language: "description": "awesome application that will help you achieve your dreams." description in arabic, which will be displayed right-to-left: "dir": "rtl", "lang": "ar", "description": ".تطبيق رائع سيساعدك على تحقيق أحلامك" specification specification status comment feedback web app
manifestthe definition of 'description' in that specification.
... web app
manifest working group drafts ...
dir - Web app manifests
type string mandatory no the base direction in which to display direction-capable members of the
manifest.
... example "dir": "rtl", "lang": "ar", "short_name": "!أنا من التطبيق" specification specification status comment feedback web app
manifestthe definition of 'dir' in that specification.
... web app
manifest working group drafts ...
icons - Web app manifests
if src is a relative url, the base url will be the url of the
manifest.
... specification specification status comment feedback web app
manifestthe definition of 'icons' in that specification.
... web app
manifest working group drafts ...
lang - Web app manifests
it specifies the primary language for the values of the
manifest's directionality-capable members, and together with dir determines their directionality.
... examples "lang": "en-us" specification specification status comment feedback web app
manifestthe definition of 'lang' in that specification.
... web app
manifest working group drafts ...
name - Web app manifests
name is directionality-capable, which means it can be displayed left-to-right or right-to-left based on the values of the dir and lang
manifest members.
... examples simple name in left-to-right language: "name": "awesome application" right-to-left name in arabic: "dir": "rtl", "lang": "ar", "name": "!أنا من التطبيق" specification specification status comment feedback web app
manifestthe definition of 'name' in that specification.
... web app
manifest working group drafts ...
related_applications - Web app manifests
such applications are intended to be alternatives to the
manifest's website that provides similar/equivalent functionality — like the native app equivalent.
... specification specification status comment feedback web app
manifestthe definition of 'related_applications' in that specification.
... web app
manifest working group drafts ...
short_name - Web app manifests
short_name is directionality-capable, which means it can be displayed left-to-right or right-to-left based on the value of the dir and lang
manifest members.
... examples simple short_name in left-to-right language: "name": "awesome application", "short_name": "awesome app" short_name in arabic, which will be displayed right-to-left: "dir": "rtl", "lang": "ar", "name": "تطبيق رائع", "short_name": "رائع" specification specification status comment feedback web app
manifestthe definition of 'short_name' in that specification.
... web app
manifest working group drafts ...
start_url - Web app manifests
examples absolute url "start_url": "https://example.com" relative url if the url is relative, the
manifest url is used as the base url to resolve it.
... "start_url": "../startpoint.html" specification specification status comment feedback web app
manifestthe definition of 'start_url' in that specification.
... web app
manifest working group drafts ...
Building a Thunderbird extension 3: install manifest
open the file called install.rdf that you created at the top of your extension's directory hierarchy and paste the following text into the file: <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>myfirstext@jen.zed</em:id> <em:name>my first extension</em:name> <em:version>1.0</em:version> <em:creator>jenzed</em:creator> <em:targetapplication> <description> <em:id>{3550f703-e582-4d05-9a08-453d09bdfdc6}</em:id> <em:minversion>1.5</em:minversion> <em:maxversion>5.0.*</em:maxversion> </description> </em:targetapplication> ...
...these are described on the install
manifests page.
categories - Web app manifests
example "categories": ["books", "education", "medical"] specification specification status comment feedback web app
manifestthe definition of 'categories' in that specification.
... web app
manifest working group drafts ...
display - Web app manifests
(none) example "display": "standalone" specification specification status comment feedback web app
manifestthe definition of 'display' in that specification.
... web app
manifest working group drafts ...
iarc_rating_id - Web app manifests
examples "iarc_rating_id": "e84b072d-71b3-4d3e-86ae-31a8ce4e53b7" specification specification status comment feedback web app
manifestthe definition of 'iarc_rating_id' in that specification.
... web app
manifest working group drafts ...
orientation - Web app manifests
values orientation can take one of the following values: any natural landscape landscape-primary landscape-secondary portrait portrait-primary portrait-secondary examples "orientation": "portrait-primary" specification specification status comment feedback web app
manifestthe definition of 'orientation' in that specification.
... web app
manifest working group drafts ...
prefer_related_applications - Web app manifests
examples "prefer_related_applications": true specification specification status comment feedback web app
manifestthe definition of 'prefer_related_applications' in that specification.
... web app
manifest working group drafts ...
screenshots - Web app manifests
examples "screenshots" : [ { "src": "screenshot1.webp", "sizes": "1280x720", "type": "image/webp" }, { "src": "screenshot2.webp", "sizes": "1280x720", "type": "image/webp" } ] specification specification status comment feedback web app
manifestthe definition of 'screenshots' in that specification.
... web app
manifest working group drafts ...
shortcuts - Web app manifests
t of shortcuts a calendar app might have: "shortcuts" : [ { "name": "today's agenda", "url": "/today", "description": "list of events planned for today" }, { "name": "new event", "url": "/create/event" }, { "name": "new reminder", "url": "/create/reminder" } ] specification specification status comment feedback web app
manifestthe definition of 'shortcuts' in that specification.
... web app
manifest working group drafts ...
theme_color - Web app manifests
examples "theme_color": "red" specification specification status comment feedback web app
manifestthe definition of 'theme_color' in that specification.
... web app
manifest working group drafts ...
chrome.manifest - Archive of obsolete content
copy the following text and paste it into a text file, then save that file as "chrome.
manifest": skin global my_theme jar:chrome/my_theme.jar!/global/ skin mozapps my_theme jar:chrome/my_theme.jar!/mozapps/ skin messenger my_theme jar:chrome/my_theme.jar!/messenger/ skin messenger-newsblog my_theme jar:chrome/my_theme.jar!/messenger-newsblog/ skin communicator my_theme jar:chrome/my_theme.jar!/communicator/ skin help my_theme jar:chrome/my_theme.jar!/help/ skin navigator my_theme jar:chrome/my_theme.jar!/navigator/ skin editor my_theme jar:chrome/my_theme.jar!/editor/ ...
JAR Manifests
documentation for jar
manifests (jar.mn files) now lives here.
Using the application cache - HTML: Hypertext Markup Language
how the application cache works enabling the application cache to enable the application cache for an application, include the
manifest attribute in the <html> element: <html
manifest="/example.appcache"> … </html> the
manifest attribute references a url for a cache
manifest file: a text file that lists urls that browsers should cache for your application.
... you should include the
manifest attribute on each page of your site that you want cached.
... the browser does not cache pages without the
manifest attribute, unless such pages are listed in the
manifest file.
...And 61 more matches
Chapter 5: Let's build a Firefox extension - Archive of obsolete content
chrome url use a file called a “chrome
manifest” to register chrome packages with firefox and start using them.
... extension/ chrome
manifest chrome/ #registered in the chrome content package #run with privileges locale package skin package figure 1: chrome packages and chrome registration (fixme: not really explicit and not a figure) cross-package overlays the “overlay” technique introduced in chapter 3 required the use of the xul-overlay instruction in the xul document that is the overlay target.
...use the chrome
manifest to invoke a cross-package overlay.
...And 26 more matches
Application cache implementation overview
nsiapplicationcache is then queried a client id (= the
manifest url + a unique time stamp).
...the association happens in nscontentsink::processoffline
manifest() called from the html parser every time <html> tag has been parsed.
... processoffline
manifest is an effective implementation of “cache selection algorithm” as described by the html5 spec.
...And 21 more matches
Enhanced Extension Installation - Archive of obsolete content
extension installation and registration is also prohibitively difficult/annoying for developers, who are forced to either dangerously hand-edit all the appropriate
manifest files, or package their code as a xpi and install it that way every time they make a change.
... <location>/extensions.ini - an ini
manifest listing the directories for all the extensions and themes at the location (used by the component manager, preferences system, chrome registry etc to locate files during the startup process).
...in situations where an item is not yet a member of one of the containers, type is inelegantly determined by checking for presence of a theme-only property on the item's install
manifest rdf file.
...And 19 more matches
Chrome registration
mozilla locates and reads the root chrome.
manifest file for extensions and themes.
... note: with gecko 1.9.2 and older, mozilla reads chrome/*.
manifest files from applications.
... starting with gecko 2.0, the root chrome.
manifest is the only
manifest used; you can add
manifest commands to that file to load secondary
manifests.
...And 15 more matches
XPCOM changes in Gecko 2.0
starting in gecko 2, however, components are registered using
manifest files, similarly to how chrome is registered.
... in fact, the same chrome
manifest file will be used to register components.
...component
manifests all component registration is now handled through
manifest files.
...And 14 more matches
Creating a Firefox sidebar extension - Archive of obsolete content
the extension needs to provide some special
manifest files that control how it is installed and where its chrome resources are stored.
... the first is install.rdf, the install
manifest.
... see install
manifests for a complete listing of the required and optional properties.
...And 13 more matches
Index - Archive of obsolete content
140 package.json commonjs, jpm, sdk, add-on, package.json the package.json file contains
manifest data for your add-on, providing not only descriptive information about the add-on for presentation in the add-ons manager, but other metadata required of add-ons.
... 246 install
manifests add-ons, archive, extensions,
manifests, toolkit api an install
manifest is the file an add-on manager-enabled xul application (e.g.
... 410 chrome.
manifest copy the following text and paste it into a text file, then save that file as "chrome.
manifest": 411 install.rdf copy the following text and paste it into a text file, then save that file as "install.rdf": 412 creating a hybrid cd developing mozilla, outdated_articles no summary!
...And 10 more matches
Component Internals
xpcom finds and processes the component
manifest (see component
manifests below).
... xpcom finds and processes the type library
manifest (see type library
manifests below).
... component
manifests and type library
manifests are described in the following section, xpcom registry
manifests.
...And 9 more matches
Bootstrapped extensions - Archive of obsolete content
notes on modifying the application user interface chrome.
manifest in bootstrapped add-ons you can use a chrome.
manifest file in bootstrapped add-ons to: make your add-on's content available via a chrome:// url (using the content, locale, and skin instructions in the
manifest).
... not all chrome.
manifest instructions are supported in bootstrapped add-ons, for example you still cannot register xul overlays from a bootstrapped add-on.
... see the chrome.
manifest documentation for details.
...And 8 more matches
Building a Theme - Archive of obsolete content
an example of the content within a typical xpi file for a theme: example.xpi: /install.rdf /chrome.
manifest /preview.png /icon.png /chrome/ browser/ communicator/ global/ mozapps/ we'll want to create a file structure similar to the one above for our tutorial, so let's begin by creating a folder for your theme somewhere on your hard disk (e.g.
...inside your new theme folder, create two new empty text files, one called chrome.
manifest and the other called install.rdf.
... browser to chrome/browser/ communicator to chrome/communicator/ you should end up with this directory structure: <ext path>/ /install.rdf /chrome.
manifest /chrome/ browser/ communicator/ global/ mozapps/ after this, it would be a good idea to read the article setting up extension development environment and follow the directions there.
...And 8 more matches
How to make PWAs installable - Progressive web apps (PWAs)
this article explains how to achieve this using the web app's
manifest.
... requirements to make the web site installable, it needs the following things in place: a web
manifest, with the correct fields filled in the web site to be served from a secure (https) domain an icon to represent the app on the device a service worker registered, to allow the app to work offline (this is required only by chrome for android currently) currently, only the chromium-based browsers such as chrome, edge, and samsung internet require the service worker.
... the
manifest file the key element is a web
manifest file, which lists all the information about the website in a json format.
...And 8 more matches
Getting started with XULRunner - Archive of obsolete content
here is the subfolder structure: + myapp/ | +-+ chrome/ | | | +-+ content/ | | | | | +-- main.xul | | | | | +-- main.js | | | +-- chrome.
manifest | +-+ defaults/ | | | +-+ preferences/ | | | +-- prefs.js | +-- application.ini | +-- chrome.
manifest notice that there are 5 files in the folder structure: application.ini, chrome.
manifest (2), prefs.js, and main.xul.
... the /chrome/chrome.
manifest file is optional, but might be useful for backward compatibility.
... note: in xulrunner 2.0, the chrome.
manifest is now used to register xpcom components in addition to its previous uses.
...And 7 more matches
nsIComponentManager
66 introduced gecko 0.7 inherits from: nsisupports last changed in gecko 8.0 (firefox 8.0 / thunderbird 8.0 / seamonkey 2.5) method overview void addbootstrapped
manifestlocation(in nsilocalfile alocation); void createinstance(in nscidref aclass, in nsisupports adelegate, in nsiidref aiid, [iid_is(aiid),retval] out nsqiresult result); void createinstancebycontractid(in string acontractid, in nsisupports adelegate, in nsiidref aiid, [iid_is(aiid),retval] out nsqiresult result); void getclassobject(in nscidref aclass, in nsiidref aiid, [iid_is(aiid),retval] out nsqiresult result); ...
... void getclassobjectbycontractid(in string acontractid, in nsiidref aiid, [iid_is(aiid),retval] out nsqiresult result); void removebootstrapped
manifestlocation(in nsilocalfile alocation); methods addbootstrapped
manifestlocation() 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.
...And 7 more matches
How to convert an overlay extension to restartless - Archive of obsolete content
the examples will also assume that you know how to properly add instructions to your add-on's chrome.
manifest to add and remove resource, chrome, locale, & etc.
... mappings, so that you can access your files with custom paths such as: resource://myaddon/filename.ext chrome://myaddon/content/filename.ext step 2: no more resource:// uris for files internal to your bundle unfortunately, resource mappings in your chrome.
manifest were not usable in restartless add-ons until mozilla finally fixed this bug in firefox 38, which looked bad, but only because mozilla is still using resource:// uris internally and in examples.
...in overlay extensions, you can place a resource mapping in the chrome.
manifest for your add-on and load your own jsm from resource:// uris.
...And 6 more matches
Plug-n-Hack Phase1 - Archive of obsolete content
security tool
manifest to support pnh-1 security tools provide a
manifest over http(s) which defines the capabilities that the browser can make use of.
... it is up to the tool authors to decide how the url of the
manifest is published.
...this can cause the browser to inspect the
manifest and register the tool by firing a customevent with the type configuresectool and a properties object which specifies the url of the tool
manifest.
...And 6 more matches
Chrome Authority - Archive of obsolete content
manifest generation the
manifest is a list, included in the generated xpi, which specifies which modules have requested require() access to which other modules.
... when the
manifest implementation is complete the runtime loader will actually prevent modules from require()ing modules that are not listed in the
manifest.
... likewise, it will prevent modules from getting chrome authority unless the
manifest indicates that they have asked for it.
...And 5 more matches
Extension Versioning, Update and Compatibility - Archive of obsolete content
this means that if your update
manifest contains an entry for the currently installed version of the add-on, and the entry's targetapplication entry specifies a larger maxversion then the application will use this value instead of that specified in the add-on's install.rdf.
...below is an example update
manifest.
... in order to do this you must add an updateinfourl entry to the update
manifest (see the example above).
...And 5 more matches
jpm - Archive of obsolete content
unless an id field is present in package.json, jpm prepends "@" to name and use the result as the id field in the add-on's install
manifest.
...the way this works is: you run jpm sign anytime you need to create a new version you host the signed add-on xpi and update it when you need to you host an "update
manifest", which, among other things, contains a url pointing to the xpi your add-on tells firefox where it can find the update
manifest to do this, include two extra keys in package.json: updateurl: this url is included in the install
manifest of the xpi file that jpm xpi builds.
... it points to your update
manifest.
...And 4 more matches
The Essentials of an Extension - Archive of obsolete content
the chrome.
manifest file chrome is the set of user interface elements of the application window that are outside of a window's content area.
...if we open the chrome.
manifest file (again, any text editor will do), we see that the same 3 sections are mentioned: content xulschoolhello content/ skin xulschoolhello classic/1.0 skin/ locale xulschoolhello en-us locale/ the chrome.
manifest file tells firefox where to look for chrome files.
... there are some additional options that can be included in the entries of a chrome.
manifest file.
...And 4 more matches
Signing an XPI - Archive of obsolete content
c:\projects\codesigning\> cd signed c:\projects\codesigning\signed> unzip fsb.xpi archive: fsb.xpi creating: chrome/ inflating: chrome.
manifest inflating: chrome/fsb.jar inflating: install.rdf c:\projects\codesigning\signed> del fsb.xpi c:\projects\codesigning\signed> cd ..
...generating signed//meta-inf/
manifest.mf file..
... --> chrome/fsb.jar --> chrome.
manifest --> install.rdf generating zigbert.sf file..
...And 4 more matches
Creating a status bar extension - Archive of obsolete content
download the sample the install
manifest the install
manifest, install.rdf, is a text file containing information that tells the host application important information about the extension.
... <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>status-bar-sample-1@example.com</em:id> <em:version>1.0</em:version> <em:type>2</em:type> <!-- front end metadata --> <em:name>status bar sample 1</em:name> <em:description>sample static status bar panel</em:description> <em:creator>my name</em:creator> <em:homepageurl>http://developer.mozilla.org/en/docs/creating_a_status_bar_extension</em:homepageurl> <!-- describe the firefox versions we support --> <em:targetapplication> <description> <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> <em:minversion>1.5</em:minversion> <em:maxversion>2.0.0.*</...
...em:maxversion> </description> </em:targetapplication> </description> </rdf> let's take a look at some key parts of the
manifest.
...And 4 more matches
Structure of an installable bundle - Archive of obsolete content
basic structure of a bundle a bundle may include any of the following files: path from the root of the bundle description version information /install.rdf extension/theme install
manifest /application.ini application launch
manifest /bootstrap.js the bootstrap script for extensions not requiring a restart (those with <em:bootstrap>true</em:bootstrap> in their install.rdf).
...chrome.
manifest, components, defaults) in bootstrapped extensions are not processed by a supporting application.
... (>=2.0) /chrome.
manifest chrome registration
manifest (>=1.8) /components/* xpcom components (*.js, *.dll), and interface files from *.xpt (>=1.7) /defaults/preferences/*.js default preferences (>=1.7) /plugins/* npapi plugins (>=1.8) /chrome/icons/default/* window icons (>=1.8) /icon.png extension icon, for display in the add-ons manager, 32px × 32px (>=1.9.2) /icon64.png extension icon, for display in the add-ons manager, 64px × 64px (>=2.0) /options.xul extension options, for display in the add-ons manager (>=7.0) ...
...And 4 more matches
Complete - Archive of obsolete content
the xpi contains: install.rdf information about the extension chrome.
manifest registration data for firefox etc.
...to tell the application that the files it needs are in a jar, there are changes to chrome.
manifest (for firefox etc.) and to install.js (for seamonkey).
... for example, chrome.
manifest originally had: content custombutton chrome/ now it has: content allcustom jar:chrome/allcustom.jar!/content/allcustom/ you can see the other changes if you unpack the xpi.
...And 4 more matches
Webapps.jsm
mporting components.utils.import("resource://gre/modules/webapps.jsm"); // exported symbol is domapplicationregistry method overview init: function() loadcurrentregistry: function() notifyappsregistrystart: function notifyappsregistrystart() notifyappsregistryready: function notifyappsregistryready() sanitizeredirects: function sanitizeredirects(asource) _savewidgetsfullpath: function(a
manifest, adestapp) appkind: function(aapp, a
manifest) updatepermissionsforapp: function(aid, aispreinstalled) updateofflinecacheforapp: function(aid) installpreinstalledapp: function installpreinstalledapp(aid) removeifhttpsduplicate: function(aid) installsystemapps: function() loadandupdateapps: function() updatedatastore: function(aid, aorigin, a
manifesturl, a
manifest) _registersystemmessagesf...
...orentrypoint: function(a
manifest, aapp, aentrypoint) _registerinterappconnectionsforentrypoint: function(a
manifest, aapp,) _registersystemmessages: function(a
manifest, aapp) _registerinterappconnections: function(a
manifest, aapp) _createactivitiestoregister: function(a
manifest, aapp, aentrypoint, arunupdate) _registeractivitiesforapps: function(aappstoregister, arunupdate) _registeractivities: function(a
manifest, aapp, arunupdate) _createactivitiestounregister: function(a
manifest, aapp, aentrypoint) _unregisteractivitiesforapps: function(aappstounregister) _unregisteractivities: function(a
manifest, aapp) _process
manifestforids: function(aids, arunupdate) observe: function(asubject, atopic, adata) addmessagelistener: function(amsgnames, aapp, amm) removemessagelistener: function(amsgna...
...mes, amm) formatmessage: function(adata) receivemessage: function(amessage) getappinfo: function getappinfo(aappid) broadcastmessage: function broadcastmessage(amsgname, acontent) registerupdatehandler: function(ahandler) unregisterupdatehandler: function(ahandler) notifyupdatehandlers: function(aapp, a
manifest, azippath) _getappdir: function(aid) _writefile: function(apath, adata) dogetlist: function() doexport: function(amsg, amm) doimport: function(amsg, amm) doextract
manifest: function(amsg, amm) dolaunch: function (adata, amm) launch: function launch(a
manifesturl, astartpoint, atimestamp, aonsuccess, aonfailure) close: function close(aapp) canceldownload: function canceldownload(a
manifesturl, aerror) startofflinecachedownload: function(a
manifest, aapp, aprofiledir, aisupdate...
...And 4 more matches
Index
there are several things to keep in mind with this file: o it must be declared in the jar archive's
manifest file.
...to declare meta-information in the
manifest file, put it in a file that is passed to signtool.
...ing; for example: install-script field #3: data corresponding to the name in field #2 for example, the -i option uses the equivalent of this line: + install-script: script.js this example associates a mime type with a file: movie.qt mime-type: video/quicktime for information about the way installer script information appears in the
manifest file for a jar archive, see the jar format on netscape devedge.
...And 4 more matches
Add to Home screen - Progressive web apps (PWAs)
to have a
manifest file with the correct fields filled in, linked from the html head.
...
manifest the web
manifest is written in standard json format and should be placed somewhere inside your app directory (in the root is probably best) with the name somefilename.web
manifest (we've chosen
manifest.web
manifest).
... note: the .web
manifest extension is specified in the media type registration section of the specification, but generally browsers will support
manifests with other appropriate extensions, e.g.
...And 4 more matches
First run - Archive of obsolete content
the first-run page is defined by the firstrunpage property of your jetpack's
manifest.
... a
manifest is simply an object set to a variable named
manifest.
... it's the same
manifest you use when defining settings for your jetpack.
...And 3 more matches
First Run - Archive of obsolete content
the first-run page is defined by the firstrunpage property of your jetpack's
manifest.
... a
manifest is simply an object set to a variable named
manifest.
...it's the same
manifest you use when defining settings for your jetpack.
...And 3 more matches
Multiple item extension packaging - Archive of obsolete content
the basic structure is shown below: /install.rdf install
manifest /extension1.xpi extension /extension2.xpi extension /theme1.jar theme /theme2.jar theme ...
... the extension manager will read the install.rdf install
manifest to determine if this is a multiple item package and then start the installation of the individual packages it contains automatically.
... no other files besides the install.rdf install
manifest and the files with a jar and xpi file extension will be extracted or utilized.
...And 2 more matches
Getting Started - Archive of obsolete content
chrome.
manifest make a copy of chrome.
manifest and place it in \my_theme and open it up in your text editor.
... this file is a small
manifest file which is used to describe the skin.
... <description about="urn:mozilla:install-
manifest"> <em:id>{themes_uuid}</em:id> <em:version>themes_version</em:version> the first section requires that you establish a uuid for your theme and that you give your theme a version number.
...And 2 more matches
XUL Structure - Archive of obsolete content
to gain the extra privileges, you will need to create a
manifest file and put that in the chrome directory.
...this newer method is the
manifest file mentioned earlier, and you will find these as files with the .
manifest extension in the chrome directory.
... for instance, browser.
manifest describes the browser package.
...And 2 more matches
Theme concepts
static themes static themes are specified using the same resources as a browser extension: a
manifest.json file to define the theme components with those components stored in the same folder as the
manifest.json file or a sub folder.
... add the theme image file to the folder: <mytheme> <your_header_image>.<type> create a file called
manifest.json in the folder and edit its content as follows: { "
manifest_version": 2, "version": "1.0", "name": "<your_theme_name>", "theme": { "images": { "theme_frame": "<your_header_image>.<type>" }, "colors": { "frame": "#ffffff", "tab_background_text": "#000" } } } where: "frame": is the heading area background color for your theme.
...first, request "theme" permission in the extension's
manifest.json file.
...And 2 more matches
NSS tools : signtool
ing; for example: install-script field #3: data corresponding to the name in field #2 for example, the -i option uses the equivalent of this line: + install-script: script.js this example associates a mime type with a file: movie.qt mime-type: video/quicktime for information about the way installer script information appears in the
manifest file for a jar archive, see the jar format on netscape devedge.
...this option makes the
manifest files (required by the jar format) considerably smaller, but they contain slightly less information.
... signtool -k mysigncert -z testjar.jar signdir using key "mysigncert" using certificate directory: /u/jsmith/.netscape generating signdir/meta-inf/
manifest.mf file..
...And 2 more matches
nsIApplicationCache
this is the uri of the cache
manifest file.
... constants constant value description item_
manifest 1 this item is the application
manifest.
... item_explicit 2 this item was explicitly listed in the application
manifest.
...And 2 more matches
Index
at a minimum, they contain an install.rdf, the chrome.
manifest and a chrome/ folder.
...when this tutorial is finished, our extension will look like this: 76 building a thunderbird extension 3: install
manifest extensions, thunderbird the install.rdf file is an xml file that provides general information about the extension.
... 77 building a thunderbird extension 4: chrome
manifest extensions, thunderbird the file called chrome.
manifest tells thunderbird what packages and overlays are provided by the extension.
...And 2 more matches
DASH Adaptive Streaming for HTML 5 Video - HTML: Hypertext Markup Language
using dash - server side first you'll need to convert your webm video to a dash
manifest with the accompanying video files in various bit rates.
...create the
manifest file: ffmpeg \ -f webm_dash_
manifest -i video_160x90_250k.webm \ -f webm_dash_
manifest -i video_320x180_500k.webm \ -f webm_dash_
manifest -i video_640x360_750k.webm \ -f webm_dash_
manifest -i video_1280x720_1500k.webm \ -f webm_dash_
manifest -i my_audio.webm \ -c copy \ -map 0 -map 1 -map 2 -map 3 -map 4 \ -f webm_dash_
manifest \ -adaptation_sets "id=0,streams=0,1,2,3 id=1,stre...
...ams=4" \ my_video_
manifest.mpd the -map arguments correspond to the input files in the sequence they are given; you should have one for each file.
...And 2 more matches
XUL Migration Guide - Archive of obsolete content
however, you can include a chrome.
manifest file in your add-on and it will be included in the generated xpi.
... my-addon/ chrome/ content/ locale/ skin/ chrome.
manifest data/ lib/ package.json there are limitations on what you can do in this
manifest file: for example, you can't register overlays, resource: uris, or components.
... you can keep the "chrome.
manifest" file in your add-on's root directory and create a directory there called "chrome".
... in that directory you can keep your "content", "locale", and "skin" subdirectories: this allows you to refer to objects in these directories from "chrome.
manifest" using a relative path, like "chrome/content".
package.json - Archive of obsolete content
the package.json file contains
manifest data for your add-on, providing not only descriptive information about the add-on for presentation in the add-ons manager, but other metadata required of add-ons.
... some of its entries, such as icon, name, and description, have direct analogues in the install
manifest format, and entries from package.json are written into the install
manifest when the add-on is built using jpm xpi.
... creating a
manifest the package.json file is initially generated in your add-on's root directory the first time you run jpm init.
... it looks like this (assuming the add-on's directory is "my-addon"): { "name": "my-addon", "title": "my-addon", "id": "jid1-1fergv45e4f4f@jetpack", "description": "a basic add-on", "author": "", "license": "mpl-2.0", "version": "0.1" } if you are using the new jpm tool, you can easily access
manifest data from package.json by requiring it like any other module: var title = require("./package.json").title; key reference package.json may contain the following keys: author the name of the package's original author; this could be the name of a person or a company.
Creating custom Firefox extensions with the Mozilla build system - Archive of obsolete content
it has thus been necessary to solve all of the issues involved in creating and registering xpcom components, building jar files and
manifests, installing the lot into the firefox extensions/ directory and so forth.
...this file should be located in the main extension directory and look something like this: <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>myextension@mycompany.com</em:id> <em:version>0.1</em:version> <em:targetapplication> <!-- firefox --> <description> <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> <em:minversion>1.0+</em:minversion> <em:maxversion>1.0+</em:maxversion> </description> </em:targetapplication> <!-- front-end metadata --> <em:name>my ...
...this is accomplished through the use of a jar
manifest.
...you also have to make one small change to the makefile in the same directory, adding the following line: use_extension_
manifest = 1 this tells make to create a single
manifest file called chrome.
manifest instead of creating separate
manifests with goofy names for each package.
Adding Toolbars and Toolbar Buttons - Archive of obsolete content
the css file with your toolbar styles needs to be included in the overlay file, as you would expect, but also in the chrome.
manifest file.
...the way to include the file in the
manifest is to add this line: style chrome://global/content/customizetoolbar.xul chrome://xulschoolhello/skin/toolbar.css if you are using xbl bindings (explained way ahead) for your toolbar items, you'll have to include the css files for those as well, each in a new line like the one above.
... you can have a different skin directory for each operating system using
manifest flags in the chrome.
manifest file: skin xulschoolhello classic/1.0 skin/unix/ skin xulschoolhello classic/1.0 skin/win/ os=winnt skin xulschoolhello classic/1.0 skin/mac/ os=darwin the osversion flag can be used in case we wanted to have different icons for mac os x lion and above, and others for older systems.
... given the way
manifest files work, we have found that the best solution is to have a separate package name for os-specific skin files.
Creating a dynamic status bar extension - Archive of obsolete content
download the sample update the install
manifest replace all occurrences of the first sample's id, "status-bar-sample-1", with the new sample's id, "stockwatcher", and update the front end metadata to describe our new extension.
... see install
manifests for details.
... update the chrome
manifest the chrome
manifest needs only a minor update from the previous sample; simply replace the id of the first sample, "status-bar-sample-1", with the name of the new sample, "stockwatcher".
... if you need to brush up, visit the chrome
manifest section.
Settings - Archive of obsolete content
because it is still under development, the api currently lives in the future and must be imported before it is used: specifying settings in a
manifest to specify its settings, a jetpack defines a variable named
manifest in its global namespace before it imports the settings api.
...here is an example
manifest definition: var
manifest = { settings: [ { name: "twitter", type: "group", label: "twitter", settings: [ { name: "username", type: "text", label: "username" }, { name: "password", type: "password", label: "password" } ] }, { name: "facebook", type: "group", label: "facebook", settings: [ { name: "username"...
..., type: "text", label: "username", default: "jdoe" }, { name: "password", type: "password", label: "secret" } ] }, { name: "music", type: "boolean", label: "music", default: true }, { name: "volume", type: "range", label: "volume", min: 0, max: 10, default: 5 } ] }; // import after defining
manifest!
...with the above
manifest the following stored properties are available in the jetpack's code: * jetpack.storage.settings.twitter.username * jetpack.storage.settings.twitter.password * jetpack.storage.settings.facebook.username * jetpack.storage.settings.facebook.password * jetpack.storage.settings.music * jetpack.storage.settings.volume see also simple storage jep 24 ...
Settings - Archive of obsolete content
because it is still under development, the api currently lives in the future and must be imported before it is used: jetpack.future.import("storage.settings"); specifying settings in a
manifest to specify its settings, a jetpack defines a variable named
manifest in its global namespace before it imports the settings api.
...here is an example
manifest definition: var
manifest = { settings: [ { name: "twitter", type: "group", label: "twitter", settings: [ { name: "username", type: "text", label: "username" }, { name: "password", type: "password", label: "password" } ] }, { name: "facebook", type: "group", label: "facebook", settings: [ { name: "username"...
..., type: "text", label: "username", default: "jdoe" }, { name: "password", type: "password", label: "secret" } ] }, { name: "music", type: "boolean", label: "music", default: true }, { name: "volume", type: "range", label: "volume", min: 0, max: 10, default: 5 } ] }; // import after defining
manifest!
...with the above
manifest the following stored properties are available in the jetpack's code: jetpack.storage.settings.twitter.username jetpack.storage.settings.twitter.password jetpack.storage.settings.facebook.username jetpack.storage.settings.facebook.password jetpack.storage.settings.music jetpack.storage.settings.volume ...
Makefile.mozextension.2 - Archive of obsolete content
uild."; exit 1; } @echo $(mkdir) $(project) $(mkdir) $(project)/content $(project)/locale $(project)/locale/en-us $(project)/components/ $(project)/defaults/ $(project)/defaults/preferences/ $(project)/locale/de-de $(project)/skin make_xpi: $(mkdir) $(project)/chrome && \ cd $(project) && \ $(zipprog) -r chrome/$(project).jar content locale skin && \ $(zipprog) -r $(project).xpi chrome.
manifest install.rdf components defaults chrome && cd ..
... make_files: chrome.
manifest install.rdf overlay.xul overlay.js overlay.dtd $(noecho) $(noop) make_clean: rm -rf $(project) # this may be a bit too old ?!
...real_install: $(cp) chrome/$(project).jar ~/.mozilla/default/32p27fdr.slt/chrome/ #################################### ###### define chrome_
manifest content $(project) content/ overlay chrome://browser/content/browser.xul chrome://$(project)/content/overlay.xul locale $(project) en-us locale/ skin $(project) classic/1.0 skin/ style chrome://global/content/customizetoolbar.xul chrome://$(project)/skin/overlay.css endef export chrome_
manifest chrome.
manifest: @echo generating $(project)/chrome.
manifest @echo "$$chrome_
manifest" > $(project)/chrome.
manifest ###### #firefox {ec8030f7-c20a-464f-9b0e-13a3a9e97384} #thunderbird {3550f703-e582-4d05-9a08-453d09bdfdc6} #nvu {136c295a-4a5a-41cf-bf24-5cee526720d5} #mozilla suite {86c18b42-e466-45a9-ae7a-9b95ba6f5640} #sea...
...monkey {92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a} #sunbird {718e30fb-e89b-41dd-9da7-e25a45638b28} #netscape browser {3db10fab-e461-4c80-8b97-957ad5f8ea47} ###### define install_rdf <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <id>$(project_id)</id> <name>$(project_name)</name> <version>$(project_version)</version> <description>$(project_desc)</description> <creator>$(project_author)</creator> <contributor>here is a place for you who helped me</contributor> <homepageurl>http://$(project).mozdev.org/</homepageurl> <optionsurl>chrome://$(project)/content/settings.xul</optionsurl> <abouturl>chrome://$(project)/content/about.xul</abouturl> <iconurl>chrome://$(project)/skin/mainicon.png</ico...
Creating toolbar buttons (Customize Toolbar Window) - Archive of obsolete content
to attach it to the overlay, put this processing instruction (pi) at the top of the overlay file: <?xml-stylesheet href="chrome://myextension/skin/toolbar-button.css" type="text/css"?> note: the css file with your toolbar styles needs to be included in the overlay file, as you would expect, but also in the chrome.
manifest file.
... to include the style on your chrome.
manifest file: style chrome://global/content/customizetoolbar.xul chrome://myextension/skin/toolbar-button.css if you are developing for firefox 1.0, attach it to the customize toolbar window (chrome://global/content/customizetoolbar.xul) using skin/contents.rdf.
...extensions for firefox/thunderbird 1.5 and above should instead use something like this in their chrome.
manifest: skin myextension classic/1.0 chrome/skin/ style chrome://global/content/customizetoolbar.xul chrome://myextension/skin/toolbar-button.css ia take note of the packaging section in this article; you may need to include .jar references if you are delivering your extension as an .xpi file.
... solution: check to be sure your stylesheet is correct, make sure your contents.rdf (or chrome.
manifest) is correct, and be sure you didn't forget to apply the stylesheet to customizetoolbar.xul.
Creating XULRunner Apps with the Mozilla Build System - Archive of obsolete content
chrome will be packaged automatically by the build system, so you also need to specify which files get put into which packages by using jar
manifests.
... in the case of mccoy, a separate
manifest is used for content/, skin/ and locale/.
...if you're lazy like me, you can also use one big jar
manifest in the chrome/ directory, which means you don't need to put makefiles in the chrome subdirectories either.
... note that the locale
manifest uses a variable to specify the name of the locale which has to be defined in the makefile (and you need to say #filter substitution in the
manifest for the variable to be expanded).
XULRunner tips - Archive of obsolete content
ns/extensions.properties"); if your application is based on gecko 2.0, you need to register a component through the new component registration because the extension manager uses fuel, namely application.restart(), to restart your xulrunner-based application after any change (installation, removal, enabling, disabling) in the extensions' list: copy files fuelapplication.js and fuelapplication.
manifest from browser/fuel/src for instance into your components/ directory tweak the line #include ../../../toolkit/components/exthelper/extapplication.js in your copy of fuelapplication.js as needed make sure to declare the fuel module and the two files in your components/makefile.in as in browser/fuel/src/makefile.in rebuild...
...when using xulrunner 1.9 or greater, you can create your own alias in your chrome
manifest add a "skin" line: skin communicator classic/1.0 skin/communicator/ add a skin folder named "communicator" and add a single css file named "communicator.css" with this content: @import url("chrome://global/skin"); dom inspector to add dom inspector 2.0.* to your xulrunner 1.9.0.* application follow these steps: download the dom inspector (instead of clicking the "add...
... save the dom_inspector-*.xpi package to a temporary directory unzip the package copy the following files: chrome/inspector.jar to the chrome directory of your xulrunner application components/inspector-cmdline.js to your components directory defaults/preferences/inspector.js to your preferences directory open your chrome.
manifest file and add these lines: content inspector jar:inspector.jar!/content/inspector/ xpcnativewrappers=no locale inspector en-us jar:inspector.jar!/locale/inspector/ skin inspector modern/1.0 jar:inspector.jar!/skin/modern/inspector/ skin inspector classic/1.0 jar:inspector.jar!/skin/classic/inspector/ overlay chrome://inspector/conte...
...in order to satisfy these dependencies, you can save firefox's brand.dtd/brand.properties to chrome/locale/branding folder, modify them appropriately, and register a locale provider for branding by adding the following line to your chrome
manifest: locale branding en-us chrome/locale/branding/ the location you put the branding files in doesn't matter, as long as you register it appropriately in the
manifest.
Shipping a plugin as a Toolkit bundle - Archive of obsolete content
plugin packages should only need to package a small set of files in the following structure in the xpi file: install.rdf plugins/ pluginlib.dll plugintypes.xpt the install.rdf file contains an install
manifest that describes the plugin to the user.
...for example: plugins/ libplugin.so libplugin.dylib install
manifest the install
manifest describes the plugin to the user.
... for a plugin the
manifest only needs to be very simple: <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>mypluginid@myplugin.com</em:id> <em:name>my plugin</em:name> <em:version>1.0</em:version> <em:targetapplication> <description> <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> <em:minversion>1.5</em:minversion> <em:maxversion>4.0.*</em:maxversion> </description> </em:targetapplication> <em:unpack>true</em:unpack> </description> </rdf> this contains 5 required pieces of information.
...this is performed by including an updateurl in the install
manifest.
Sunbird Theme Tutorial - Archive of obsolete content
copy and paste the content from here, making sure that you scroll to get all of it: <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest" em:id="just-testing@example.com" em:name="just testing" em:creator="rod whiteley" em:description="a test theme for sunbird" em:homepageurl="http://developer.mozilla.org/" em:version="0.1" em:internalname="testing" em:type="4" > <em:targetapplication><!-- sunbird --> <description em:id="{718e30fb-e89b-41dd-9da7-e25a45638b28}" em:minvers...
... registering your theme to register your theme, create a plain text file named <tt>chrome.
manifest</tt>.
...in your <tt>chrome.
manifest</tt> file, add lines like this: skin communicator testing chrome/communicator/ skin global testing chrome/global/ skin help testing chrome/help/ skin mozapps testing chrome/mozapps/ replacing <tt>testing</tt> with your theme's one-word internal name as before.
... go back to your theme directory and edit the file <tt>chrome.
manifest</tt>.
Updating an extension to support multiple Mozilla applications - Archive of obsolete content
download the sample updating the install
manifest the first step is to revise the extension's install
manifest to indicate that it can be installed in thunderbird and sunbird.
...that's where the chrome
manifest comes into play.
... update the chrome
manifest remember way back in the first article in this series when we created our chrome
manifest, which we haven't touched since?
...we need to add lines to the
manifest for thunderbird and sunbird, like this: # thunderbird overlay chrome://messenger/content/messenger.xul chrome://stockwatcher2/content/stockwatcher2.xul # sunbird overlay chrome://calendar/content/calendar.xul chrome://stockwatcher2/content/stockwatcher2.xul these lines cause the main thunderbird message list window and the main window in sunbird to be the target of the overlays we apply in the stockwatcher2.xul file.
How to implement a custom autocomplete search component
2.1) this example is your first best try because: it has no specific logic (it just returns a dummy array of choices) it doesn't care about compatibility with older gecko versions first copy the following javascript code into a file named basic_autocomplete.js into the components directory (or whatever components folder is appropriate in your case): warning: the uuid used below in chrome.
manifest and assigned to class_id must be changed before use.
...to do so put the following declaration in your chrome.
manifest file: component {x753d830-ba1e-11e0-962b-0800200c9a66} components/basic_autocomplete.js contract @mozilla.org/autocomplete/search;1?name=basic-autocomplete {x753d830-ba1e-11e0-962b-0800200c9a66} and finally use this newly available component in a xul file like this: <textbox id="text1" type="autocomplete" autocompletesearch="basic-autocomplete"/> that's it!
... a bit more complex example compatible with old gecko versions first copy the following javascript code into a file named "simple_autocomplete.js" into the "components" directory (or whatever "components" folder is appropriate in your case) warning: the uuid used below in chrome.
manifest and assigned to class_id must be changed before use.
... need to make the following changes: add an nsgetfactory() function: function nsgetfactory(cid) { if (cid.tostring().touppercase() != class_id.tostring().touppercase()) { throw components.results.ns_error_factory_not_registered; } return simpleautocompletesearchfactory; } you need to explicitly register the component by adding these lines into your chrome.
manifest file: component {6224daa1-71x2-4d1a-ad90-01ca1c08e323} components/.js contract @mozilla.org/autocomplete/search;1?name=simple-autocomplete {6224daa1-71x2-4d1a-ad90-01ca1c08e323} you need to add the following method: getlabelat: function(index) { return this._results[index]; } to simpleautocompleteresult use this newly available component in a xul fil...
L20n HTML Bindings
<head> … <script src="l20n.js"></script> </head> create
manifest use a localization
manifest to define available languages and their resource files.
... <link rel="localization" href="../locales/
manifest.json"> an example of the
manifest file (all keys are required): { "locales": [ "en-us", "pl"], "default_locale": "en-us", "resources": [ "../locales/{{locale}}/strings.l20n", "/shared/{{locale}}/date.l20n"¨ ] } make html elements localizable use the data-l10n-id attribute on an html element to mark it as localizable.
... in order to enable the monolingual mode, remove the
manifest link from your html.
... <script type="application/l20n" src="../locales/strings.l20n"></script> note that you currently cannot use the
manifest file and manually add resources via script tags at the same time (bug 923670).
Index
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.
... 411 nsicomponentmanager component manager, components, interfaces, interfaces:scriptable, xpcom, xpcom api reference, xpcom interface reference loads a "bootstrapped" chrome.
manifest file from the specified directory or xpi file.
... a "bootstrapped" chrome
manifest supports some of the instructions allowed in a regular chrome
manifest, see the chrome registration documentation for details.
... 415 nsicomponentregistrar component manager, components, interfaces, interfaces:scriptable, xpcom, xpcom api reference, xpcom interface reference register a component (.
manifest) file or all component files in a directory.
about:debugging - Firefox Developer Tools
click the button, navigate to the directory containing the add-on and select its
manifest file.
...
manifest url if you click the link, the
manifest for this extension is loaded in a new tab.
...this does what it says: reloads any persistent scripts, such as background scripts parses the
manifest.json file again, so changes to permissions, content_scripts, browser_action or any other keys take effect installed extensions the permanently installed extensions are listed in the next section, extensions.
... just as it does with temporarily loaded extensions, the link next to
manifest url opens the loaded
manifest in a new tab.
Introduction to progressive web apps - Progressive web apps (PWAs)
the relevant web standard here is the web app
manifest, which defines features of an app such as name, icon, splash screen, and theme colors in a json-formatted
manifest file.
... modern web apps can have this native app feel via properties set inside the web app
manifest, and via a feature available in modern smartphone browsers called web app installation.
... other features such as web app
manifest, push notifications, and add to home screen functionality have wide support too.
... currently, safari has limited support for web app
manifest and add to home screen and no support for web push notifications.
Progressive web apps (PWAs)
in order to call a web app a pwa, technically speaking it should have the following features: secure contexts (https), one or more service workers, and a
manifest file.
...
manifest file a json file that controls how your app appears to the user and ensures that progressive web apps are discoverable.
...this guide explains how a2hs is used, and what you need to do as a developer to allow your users to take advantage of it.how to make pwas installablein this article, we learned about how we can make pwas installable with a properly-configured web
manifest, and how the user can then install the pwa with the "add to home screen" feature of their browser.how to make pwas re-engageable using notifications and pushhaving the ability to cache the contents of an app to work offline is a great feature.
... progressive loadingin previous articles we covered apis that help us make our js13kpwa example a progressive web app: service workers, web
manifests, notifications and push.
Inline options - Archive of obsolete content
this method does not require you to create a chrome.
manifest and set it's path.
...this requires that you register a content path in the chrome.
manifest.
... you must also specify the optionstype as 2: <em:optionsurl>chrome://myaddon/content/name_of_my_file_to_use_for_inline_opts.xul</em:optionsurl> <em:optionstype>2</em:optionstype> your chrome.
manifest file should contain the following, otherwise the path chrome://myaddon/content/name_of_my_file_to_use_for_inline_opts.xul will not exist content myaddon ./ this method allows you to maintain compatibility with previous versions of firefox by adding an override to your chrome.
manifest: ...
Localizing an extension - Archive of obsolete content
the chrome registry resolves the uris based on the user's current locale setting and the data you provide in your chrome
manifest.
...update the chrome
manifest to let firefox know about the locale files, we need to make a revision to our chrome.
manifest file, adding one line for each localization: locale stockwatcher2 en-us chrome/locale/ this instructs firefox that the en-us localization is located in the chrome/locale/en-us directory.
...adding more localizations to add another localization for a new language, all you need to do is add another line to the chrome
manifest referencing the new locale.
XPInstall - Archive of obsolete content
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf
manifest.
...<?xml version="1.0" encoding="utf-8"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <!-- properties --> </description> </rdf> cross-platform install (xpinstall) is a technology used by mozilla application suite, mozilla firefox, mozilla thunderbird and other xul-based applications for installing extensions.
... an xpi (pronounced "zippy" and derived from xpinstall) installer module is a zip file that contains an install script or
manifest (entitled install.js or install.rdf) at the root of the file.
Custom toolbar button - Archive of obsolete content
paste it into the new file: <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest" em:name="custom button" em:description="my custom toolbar button" em:creator="my name" em:id="custom-toolbar-button@example.com" em:version="1.0" em:homepageurl="http://developer.mozilla.org/en/docs/custom_toolbar_button" em:iconurl="chrome://custombutton/content/icon.png" > <em:targetapplication><!-- firefox --> <description em:id="{ec8030f7-c20...
...create a plain text file named chrome.
manifest.
...do the same in button.xul and chrome.
manifest.
Creating a Skin - Archive of obsolete content
creating a custom skin package to create a skin, do the following: (if you are using firefox 1.5 or later, see
manifest files instead of below) create a directory somewhere where you want to place the skin files.
... copy a
manifest file (contents.rdf) from the classic or modern skin into this new directory.
... modify the references in the
manifest file to a custom name for your skin.
The Chrome URL - Archive of obsolete content
the mapping between chrome urls and jar files are specified in the
manifest files stored in the chrome directory.
... if you were to move the file messenger.jar somewhere else and update the
manifest file accordingly, thunderbird will still work since it doesn't rely on its specific installed location.
...in the next section, we will look at how to create .
manifest files and packages.
Theme changes in Firefox 4 - Archive of obsolete content
finally, you need to create a chrome.
manifest file with the contents: skin browser classic/1.0 chrome/browser/ skin communicator classic/1.0 chrome/communicator/ skin global classic/1.0 chrome/global/ skin mozapps classic/1.0 chrome/mozapps/ this results in the following structure : /my_theme/chrome/browser/* /my_theme/chrome/communicator/* /my_theme/chrome/global/* /my_theme/chrome/mozapps/* /my_theme/ch...
...rome.
manifest /my_theme/icon.png /my_theme/install.rdf /my_theme/preview.png note: for more information (and how to package into a jar) consult creating a skin for firefox which still mostly applies.
... most likely you must replace all occurences of classic/1.0 in chrome.
manifest and install.rdf with some other name.
omni.ja (formerly omni.jar)
omni.ja contents the omni.ja file contains assorted application resources: chrome.
manifest the chrome
manifest file.
... /chrome/ user interface files for the application /chrome/localized.
manifest manifest of localized content; referenced by the main chrome
manifest file.
... /chrome/nonlocalized.
manifest manifest of non-localized content; referenced by the main chrome
manifest file.
Receiving startup notifications
the important thing to note is that now instead of registering with the category manager programmatically as was done in the past, you add lines to your chrome.
manifest to let the application handle it for you.
...the startup process during application startup, the application's
manifest is used to get a list of the components it needs to register, and those components are loaded.
...once that process is completed, extensions can then be loaded by simply reading their
manifests, loading their components, and continuing with application startup, all without having to restart the browser.
nsIDOMMozNetworkStatsManager
ns_error_not_implmented both app
manifesturl and servicetype are specified at the same time in the networkstatsgetoptions dictionary.
...it contains the following fields: app
manifesturl a string used to filter network stats by app.
... for example, this object might be { app
manifesturl :
manifesturl }.
nsIDOMOfflineResourceList
onchecking nsidomeventlistener an event listener to be called when fetching the application cache
manifest and checking for updates.
... checking 2 the application cache
manifest is being fetched and checked for updates.
...this will check for a new cache
manifest but will not tell the browser to use the updated cache.
nsIZipReader
manifestentriescount pruint32 the number of entries in the
manifest.
...parse
manifest must be called first.
... if aentryname is an entry in the jar, getinputstream() must be called after parse
manifest.
Filelink Providers
if the provider is being merged into the comm-central code repository (and thus added to the official thunderbird build), you must also add the components to the cloudfile/cloudfilecomponents.
manifest, cloudfile/jar.mn, and installer/package-
manifest.in.
... if the nsimsgcloudfileprovider is being created as part of an add-on, the add-on must register the component in chrome.
manifest.
...see cloudfile/cloudfilecomponents.
manifest for an example, as well as this document on chrome.
manifest files.
Theme Packaging
you must have a top-level chrome.
manifest file which registers the chrome for the theme (as before) and also an install.rdf
manifest that specifies metadata that is displayed in the appearance section of the add-ons manager.
... install.rdf your install.rdf
manifest will look something like this: <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:type>4</em:type> more properties </description> </rdf> required install.rdf properties your install.rdf file must have the following properties.
... sample install.rdf file <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>{18b64b56-d42f-428d-a88c-baa413bc413f}</em:id> <em:version>1.0</em:version> <em:type>4</em:type> <!-- target application this extension can install into, with minimum and maximum supported versions.
customDBHeaders Preference
building the extension for this extension, i used a directory tree exactly like this: superfluous/ chrome.
manifest install.rdf makefile chrome/ content/ superfluous.js superfluous_overlay.xul here's the makefile: deps:= chrome/ \ chrome.
manifest \ chrome/content/ \ chrome/content/superfluous.js \ chrome/content/superfluous_overlay.xul \ install.rdf sup...
...erfluous.xpi: ${deps} zip $@ ${deps} chrome.
manifest: content superfluous chrome/content/ overlay chrome://messenger/content/messenger.xul chrome://superfluous/content/superfluous_overlay.xul install.rdf: <?xml version='1.0' encoding='utf-8'?> <rdf xmlns='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:em='http://www.mozilla.org/2004/em-rdf#'> <description about='urn:mozilla:install-
manifest'> <em:id>superfluous@yoursite.com</em:id> <em:version>0.1.1</em:version> <em:type>2</em:type> <!-- 2 is type 'extension' --> <em:targetapplication> <description> <!-- this next line identifies tbird as target --> <em:id>{3550f703-e582-4d05-9a08-453d09bdfdc6}</em:id> <em:minversion>2*</em:minversion> <em:maxversion>3.0.
...0.*</em:maxversion> </description> </em:targetapplication> <em:name>superfluous</em:name> <em:description>test superfluous extension</em:description> <em:creator>garrett comeaux</em:creator> </description> </rdf> build process: [gcomeaux@kyle tbird-ext]$ cd superfluous/ [gcomeaux@kyle superfluous]$ make zip superfluous.xpi chrome/ chrome.
manifest chrome/content/ chrome/content/superfluous.js chrome/content/superfluous_overlay.xul install.rdf adding: chrome/ (stored 0%) adding: chrome.
manifest (deflated 44%) adding: chrome/content/ (stored 0%) adding: chrome/content/superfluous.js (deflated 57%) adding: chrome/content/superfluous_overlay.xul (deflated 44%) adding: install.rdf (deflated 50%) end result ultimately, you want to be able to compose a messag...
Index - Firefox Developer Tools
11 application application, debugging, devtools, firefox, guide,
manifests, service workers the application panel provides tools for inspecting and debugging modern web apps (also known as progressive web apps).
... this includes inspection of service workers and web app
manifests.
... 13 inspecting web app
manifests application, devtools, firefox, guide,
manifest in this article we will look at inspecting app
manifests using the firefox devtools application panel.
Index - Web APIs
4947 window.onappinstalled api, event handler,
manifest, property, reference, window, onappinstalled, web
manifest the onappinstalled attribute of the window object serves as an event handler for the appinstalled event, which is dispatched once the web application is successfully installed as a progressive web app.
... 4948 window.onbeforeinstallprompt api, event handler,
manifest, property, reference, window, onbeforeinstallprompt the window.onbeforeinstallprompt property is an event handler for processing a beforeinstallprompt, which is dispatched on devices when a user is about to be prompted to "install" a web application.
... 5029 window: appinstalled event api,
manifest, reference, web, appinstalled, events, web
manifest you can use the appinstalled event in an addeventlistener method: 5030 window: beforeprint event event, reference the beforeprint event is fired when the associated document is about to be printed or previewed for printing.
display-mode - CSS: Cascading Style Sheets
this feature corresponds to the web app
manifest's display member.
...the feature query applies regardless of whether a web app
manifest is present.
... (none) examples @media all and (display-mode: fullscreen) { body { margin: 0; border: 5px solid black; } } specifications specification status comment web app
manifestthe definition of 'display-mode' in that specification.
CSP: default-src - HTTP
for each of the following directives that are absent, the user agent looks for the default-src directive and uses this value for it: child-src connect-src font-src frame-src img-src
manifest-src media-src object-src prefetch-src script-src script-src-elem script-src-attr style-src style-src-elem style-src-attr worker-src csp version 1 directive type fetch directive syntax one or more sources can be allowed for the default-src policy: content-security-policy: default-src <source>; content-security-policy: default-src <source> <source>; sources <source> can be one of the following: <host-source> internet hosts by name or i...
...the following header: content-security-policy: default-src 'self'; script-src https://example.com is the same as: content-security-policy: connect-src 'self'; font-src 'self'; frame-src 'self'; img-src 'self';
manifest-src 'self'; media-src 'self'; object-src 'self'; script-src https://example.com; style-src 'self'; worker-src 'self' specifications specification status comment content security policy level 3the definition of 'default-src' in that specificatio...
... working draft added frame-src,
manifest-src and worker-src as defaults.
Structural overview of progressive web apps - Progressive web apps (PWAs)
the file and folder hierarchy looks like this: app.js data/ games.js img/ favicon.ico fonts/ icons/ img/ bg.png js13kgames.png index.html js13kpwa.web
manifest style.css sw.js the html the html in the file index.html creates the structure of the app.
... 2017 competition, used as an example for the mdn articles about progressive web apps."> <meta name="author" content="end3r"> <meta name="theme-color" content="#b12a34"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta property="og:image" content="icons/icon-512.png"> <link rel="shortcut icon" href="favicon.ico"> <link rel="stylesheet" href="style.css"> <link rel="
manifest" href="js13kpwa.web
manifest"> <script src="data/games.js" defer></script> <script src="app.js" defer></script> </head> <body> <header> <p><a class="logo" href="http://js13kgames.com"><img src="img/js13kgames.png" alt="js13kgames"></a></p> </header> <main> <h1>js13kgames a-frame entries</h1> <p class="description">list of games submitted to the <a href="http://js13kgames.com/aframe"> a...
... // content inserted in here </section> </main> <footer> <p>© js13kgames 2012-2018, created and maintained by <a href="http://end3r.com"> andrzej mazur</a> from <a href="http://enclavegames.com">enclave games</a>.</p> </footer> </body> </html> the <head> section contains basic information about the app, including its title, description, and the needed references to its css file, web
manifest, the main application javascript file (app.js, in which the app is initialized) as well as an additional javascript code file.
/loader - Archive of obsolete content
for example, the sdk generates a
manifest file at build time representing a dependency graph of all modules used by an add-on.
... any attempt to load a module not listed in the
manifest is unauthorized and is rejected with an exception: let { loader } = require('toolkit/loader'); let
manifest = { './main': { 'requirements': { 'panel': 'sdk/panel' } }, 'sdk/panel': { 'requirements': { 'chrome': 'chrome' } } 'chrome': { 'requirements': {} } }; let loader = loader({ resolve: function(id, requirer) { let requirements =
manifest[requirer].requirements; if (id in
manifest) return requirements[id]; else throw error('module "' + requirer + '" has no authority to require ' + 'module "' + id + "') } }); thrown exceptions will propagate to the caller of require().
cfx to jpm - Archive of obsolete content
in a built xpi, it's the id field in the add-on's install
manifest (install.rdf) file.
... permanently removed options jpm has dropped support for: --extra-packages --use-config --package-path --pkgdir --no-strip-xpi --harness-option --
manifest-overload --output-file --templatedir --keydir --profiledir --overload-modules --static-args --app --no-run --addons --e10s --logfile --dependencies --force-mobile --test-runner-pkg instead of --profiledir and --overload-modules, use --profile and --overload.
Setting Up a Development Environment - Archive of obsolete content
adding: install.rdf (deflated 50%) adding: chrome.
manifest (deflated 50%) adding: content/browseroverlay.js (deflated 42%) adding: content/browseroverlay.xul (deflated 69%) adding: skin/browseroverlay.css (stored 0%) adding: locale/browseroverlay.dtd (deflated 52%) adding: locale/browseroverlay.properties (stored 0%) creating xpi file.
...signature_extra_files := $(build_dir)/meta-inf/
manifest.mf \ $(build_dir)/meta-inf/zigbert.sf # the signing key /certificate file.
Index of archived content - Archive of obsolete content
extension packaging extension samples extension theming guidelines extension versioning, update and compatibility extensions support in seamonkey 2 firefox addons developer guide hiding browser chrome hotfix extension how to convert an overlay extension to restartless inline options install
manifests installing extensions and themes from web pages interaction between privileged and non-privileged pages jetpack processes legacy add-ons legacy extensions for firefox for android api accounts.jsm browserapp a...
...e tag creating a skin for firefox/getting started creating a skin for mozilla faq getting started in-depth links contents.rdf toolbarbindings.xml creating a skin for seamonkey 2.x getting started chrome.
manifest install.rdf creating a hybrid cd creating regular expressions for a microsummary generator dtrace dehydra dehydra frequently asked questions dehydra function reference dehydra object reference installing dehydra using dehydra ...
Creating a Skin for Firefox/Getting Started - Archive of obsolete content
<description about="urn:mozilla:install-
manifest"> <em:id>{themes_uuid}</em:id> <em:version>themes_version</em:version> the first section requires that you establish a uuid for your theme and that you give your theme a version number.
... see install
manifests for the reference information about the install.rdf file.
Repackaging Firefox - Archive of obsolete content
this xpi has the following contents chrome.
manifest components/partnerbookmarks.js defaults/preferences/partner.js install.rdf locale/ar/partner.properties locale/cs/partner.properties locale/da/partner.properties locale/de/partner.properties locale/el/partner.properties locale/en-gb/partner.properties locale/partner.properties locale/es-ar/partner.properties locale/es-es/partner.properties locale/fi/partner.properties locale/fr/partner.properties...
...-no/partner.properties locale/nl/partner.properties locale/pl/partner.properties locale/pt-br/partner.properties locale/pt-pt/partner.properties locale/ru/partner.properties locale/sk/partner.properties locale/sv-se/partner.properties locale/tr/partner.properties locale/zh-cn/partner.properties locale/zh-tw/partner.properties partner-bookmarks.xml one by one, the files listed above are: chrome.
manifest contains a specialized listing of the contents of the xpi.
Table Layout Regression Tests - Archive of obsolete content
"0 1 0 0 0 0 0 0 0 0 0 0 " /> <visibility data="0 1 1.000000" /> <table data="0 0 4 -1 1 " /> <tableborder data="1 null null 0 2 " /> <content data="0 0 0 null " /> <quotes data="0 " /> <ui data="3 0 0 1 " /> <uireset data="7 0 4" /> <xul data="0 0 0 0 0 1 <svg data="0 1.000000 1.000000 0 1.000000" /> </stylecontext> the baseline log will look like: type
manifest file: e:\moz_src\mozilla\obj-i586-pc-msvc\dist\bin\components\xpti.dat +++ javascript debugging hooks installed.
...a typical part of the verify log would look like: type
manifest file: e:\moz_src\mozilla\obj-i586-pc-msvc\dist\bin\components\xpti.dat +++ javascript debugging hooks installed.
Learn XPI Installer Scripting by Example - Archive of obsolete content
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf
manifest.
...in this most common form of the registerchrome function (it can also be used to support the now-deprecated
manifest.rdf style of installation archive), the three parameters represent, in order, the chrome switch used to indicate what kind of software is being registered, the target destination of the software (e.g., the "chrome" folder in the example above), and the path within the xpi (or jar theme archive) where the contents.rdf file is located.
Cross Package Overlays - Archive of obsolete content
applying overlays to other packages note: this section talks about contents.rdf which has been replaced in gecko 1.8 by
manifest files.
... to add this overlay to the
manifest file, we need to add two resources.
Using the standard theme - Archive of obsolete content
if you are only going to use these global style sheets, you of course do not need a <tt>skin</tt> directory in your extension package, and also do not have to register a style in the <tt>chrome.
manifest</tt>.
...no matter which approach you choose, do not forget to register your custom skin in the <tt>chrome.
manifest</tt>.
Deploying XULRunner - Archive of obsolete content
copy xulrunner/ to this directory when deploying with xulrunner 2.0 and above do the following: move chrome.
manifest to the root directory, and adjust resource paths inside chrome.
manifest accordingly with xulrunner 9.0 or 10.0 you may need to copy "mozutils.dll" and/or "mozcrt19.dll" from the xulrunner directory to the root directory.
...you should copy this file from /library/frameworks/xul.framework/versions/1.8/xulrunner.) when deploying with xulrunner 2.0, move chrome.
manifest to the root directory, and adjust resource paths inside chrome.
manifest accordingly.
How to enable locale switching in a XULRunner application - Archive of obsolete content
populate the xul control with the available locales the available package locales are declared in the chrome
manifest.
... sample chrome/chrome.
manifest content localeswitchdemo content/ locale localeswitchdemo de-de locale/de-de/ locale localeswitchdemo en-gb locale/en-gb/ locale localeswitchdemo fr-fr locale/fr-fr/ how are you going to populate the xul listbox?
XUL Application Packaging - Archive of obsolete content
xulrunner application packages are standard toolkit bundles (like a firefox extension), with one additional
manifest file (application.ini) which helps describe the application.
... application.ini the application.ini
manifest is located at the root of the extension and provides metadata that allows xulrunner to launch the application properly.
xulauncher - Archive of obsolete content
-f "$1" ] then echo "\"$1\" is not a file" exit fi # define some variables ############################################################################## wd=/tmp ext=".xul" xulfile=`basename $1` xulname=${xulfile%$ext} xuldir="$wd/$xulname/chrome/$xulname/" xulprefdir="$wd/$xulname/defaults/preferences" xulappini="$wd/$xulname/application.ini" xul
manifest="$wd/$xulname/chrome/chrome.
manifest" xulprefs="$wd/$xulname/defaults/preferences/prefs.js" # make minimal directory structure ############################################################################## mkdir -p $xuldir mkdir -p $xulprefdir # create application.ini file ############################################################################## echo " [app] vendor=xulauncher.sh name=$xuln...
...ame version=0.0.1 buildid=`date +%y%m%d` [gecko] minversion=1.8 maxversion=1.9 ">$xulappini # create chrome.
manifest file ############################################################################## echo " content $xulname file:$xulname/ ">$xul
manifest # create prefs.js file ############################################################################## echo " pref(\"toolkit.defaultchromeuri\", \"chrome://$xulname/content/$xulfile\"); /* debugging prefs */ pref(\"browser.dom.window.dump.enabled\", true); pref(\"javascript.options.showinconsole\", true); pref(\"javascript.options.strict\", true); pref(\"nglayout.debug.disable_xul_cache\", true); pref(\"nglayout.debug.disable_xul_fastload\", true); ">$xulprefs # copy xul file to right location and run it ########################################...
Game distribution - Game development
it's easy to prepare a game for them as such an action involves little to no modification of the game itself — usually adding a
manifest file containing necessary information in a zipped package containing all the resources is enough.
... the chrome web store is also an attractive option — again, having a
manifest file ready, zipping your game and filling in the online submission form is about all that's required.
HTML basics - Learn web development
we chose the text "mozilla
manifesto".
... wrap the text in an <a> element, as shown below: <a>mozilla
manifesto</a> give the <a> element an href attribute, as shown below: <a href="">mozilla
manifesto</a> fill in the value of this attribute with the web address that you want the link to link to: <a href="https://www.mozilla.org/about/
manifesto/">mozilla
manifesto</a> you might get unexpected results if you omit the https:// or http:// part, called the protocol, at the beginning of the web address.
Index
689 updates firefox supports automated updates to add-ons using json update
manifests.
...other add-ons must specify the location of their update
manifests.
Creating reftest-based unit tests
include ../other.list == foo.html bar.html != aaa.html bbb.html the first line, as one might expect, includes another
manifest.
... register them in the chrome package in layout/tools/reftest/jar.mn, and reference the chrome uris in the
manifest file (see an example).
Adding APIs to the navigator object
using a
manifest to add an object to navigator you can also add an object to the window.navigator object by using the chrome
manifest of an add-on: component {ffffffff-ffff-ffff-ffff-ffffffffffff} mycomponent.js contract @mozilla.org/mycomponent;1 {ffffffff-ffff-ffff-ffff-ffffffffffff} category javascript-navigator-property mycomponent @mozilla.org/mycomponent;1 generate a guid and replace the "ffff" sections...
... real-world example you can see an example of how this is used in firefox by taking a look at how the mozapps api is implemented: dom/apps/webapps.
manifest dom/apps/webapps.js ...
Makefile - variables
extra_components nsdefaultclh.
manifest, javascript xpcomm files extra_dso_libs extra_dso_ldopts extra_js_modules extra_pp_components xpcomm files to pre-process before installation.
... python_unit_tests list of python scripts to check exit status for make check xpc_shell_tests no_xpcshell_
manifest_check inhibit validating
manifest files when running xpcshell tests.
Browser API
htmliframeelement.get
manifest() retrieves the
manifest of an app loaded in the browser <iframe> and returns it as json.
... mozbrowser
manifestchange sent when a the path to the app
manifest changes, in the case of a browser <iframe> with an open web app embedded in it.
AddonUpdateChecker
the addonupdatechecker is used to download and parse update information for an add-on's update
manifest.
... void checkforupdates( in string id, in string type, in string updatekey, string url, in updatechecklistener listener ) parameters id the id of the add-on being checked for updates type the type of add-on being checked for updates updatekey an optional update key for the add-on url the url of the add-on's update
manifest listener an observer to notify of results ...
Using JavaScript code modules
if you're writing an extension for firefox 4 and already have a chrome.
manifest with a content instruction in it, you can put the code module in your content folder and reference it like your other content files via chrome://<yourextension>/content/<yourmodule>.jsm.
... using chrome.
manifest the easiest way for extensions and xul applications to add custom aliases is by registering an alias in the chrome
manifest using a line like this: resource aliasname uri/to/files/ for example, if the xpi for your foo extension includes a top-level modules/directory containing the bar.js module (that is, the modules/directory is a sibling to chrome.
manifest and install.rdf), you could create ...
Localizing extension descriptions
the following example demonstrates this (most normal
manifest properties have been removed for brevity): <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>tabsidebar@blueprintit.co.uk</em:id> <em:localized> <description> <em:locale>de-de</em:locale> <em:name>tab sidebar</em:name> ...
... if a preference isn't set and there isn't a matching em:localized property for the current locale or en-us, then the properties specified directly on the install
manifest are used as a last resort, as they were always used before gecko 1.9.
Release phase
= hg.mozilla.org/releases/l10n-central/x-testing default-push = ssh://hg.mozilla.org/releases/l10n-central/x-testing if you haven't already cloned the remote repository, enter this command: hg clone ssh://hg.mozilla.org/releases/l10n-central/x-testing mercurial will let you know that it's cloning the repository: destination directory: x-testing requesting all changes adding changesets adding
manifests adding file changes added 4 changesets with 242 changes to 239 files updating to branch default 239 files updated, 0 files merged, 0 files removed, 0 files unresolved the default push url is the same as the default pull url (i.e., ssh://hg.mozilla.org/releases/l10n-central/x-testing).
...the output should look something like this: pushing to ssh://hg.mozilla.org/releases/l10n-central/x-testing searching for changes adding changesets adding
manifests adding file changes added 1 changesets with 2 changes to 2 files congratulations!
McCoy
specifically, it focuses on the process of digitally signing update
manifests so the applications can verify the integrity of a
manifest retrieved over normally insecure channels.
... https://fireclipse.svn.sourceforge.net/svnroot/fireclipse/trunk/fireclipseextensions/chromebug/mccoy/signontheline/ bug 396525 - patch to mccoy https://bugzilla.mozilla.org/show_bug.cgi?id=396525 signing update
manifests before you release your add-on in order to verify the update
manifests applications need to already have information from you for how to verify it.
NSS tools : modutil
there are several things to keep in mind with this file: o it must be declared in the jar archive's
manifest file.
...to declare meta-information in the
manifest file, put it in a file that is passed to signtool.
NSS Tools modutil
this information file contains special scripting and must be declared in the jar archive's
manifest file.
...to declare meta-information in the
manifest file, put it in a file that is passed to the netscape signing tool.
NSS tools : modutil
there are several things to keep in mind with this file: o it must be declared in the jar archive's
manifest file.
...to declare meta-information in the
manifest file, put it in a file that is passed to signtool.
nsIMessageWakeupService
the easiest way to do this is to add the appropriate entry to the chrome
manifest that registers your component (see category in "chrome registration").
... to indicate a wakeup request in a
manifest file, add a line that looks something like this: category wakeup-request nscomponent @mozilla.org/myservice;1,nsimyinterface,getservice,mymessage1,mymessage2[,..] the category entry value consists of a comma separate string that contains: the contract id for your component (e.g.
nsIUpdateItem
note: add-ons can specify a targetapplication id of toolkit@mozilla.org in their install
manifest for compatibility with all apps using a specific release of the toolkit.
...this must be the public part of the key that was used to sign update
manifests for this add-on.
Troubleshooting XPCOM components registration
if using firefox 4 / xulrunner 2.0, make sure that your extension is unpacked and you declared the binary component in your chrome.
manifest.
... if you compiled the component with msvc 8.0 (2005) and are attempting to use it on a windows xp machine or later, it will need a
manifest embedded to find the runtime.
XPCOM ABI
if an extension provides binary xpcom components, it should declare their xpcom abi in the install
manifest.
... if the application doesn't have an xpcom abi string (due to the fact that either its cpu architecture or c++ compiler are unknown, as described in the abi naming section), you should use the operating system's name (without appending the xpcom abi) as the platform name in the install
manifest etc.
Building a Thunderbird extension 2: extension file layout
at a minimum, they contain an install.rdf, the chrome.
manifest and a chrome/ folder.
...when this tutorial is finished, our extension will look like this: myfirstext.xpi: //created in step 8 /install.rdf //created in step 3 /chrome.
manifest //created in step 4 /chrome/ /content/ /content/myhelloworld.xul //created in step 5 /content/overlay.js //created in step 6 /chrome/locale/* //building an extension# localization /chrome/skin/ /defaults/preferences/ //building an extension# defaults files the following ...
Add Option to Context Menu
assuming this on chrome.
manifest: overlay chrome://messenger/content/mailwindowoverlay.xul chrome://myext/content/thunderbird-overlay.xul add the next in thunderbird-overlay.xul.
...this can be reached by adding these lines to the chrome.
manifest file: overlay chrome://messenger/content/mailwindowoverlay.xul chrome://myaddon/content/tboverlay-tb2.xul appversion<3.0 overlay chrome://messenger/content/mailwindowoverlay.xul chrome://myaddon/content/tboverlay-tb3.xul appversion=>3.0 than we need two overlay xul files with content from examples above.
Toolkit version format
versions in at least the following places must conform to this format: addon's and target application's version in install and update
manifests.
... application.ini in xulrunner applications appversion flag in chrome
manifests.
DOM Inspector internals - Firefox Developer Tools
these overlays are: browseroverlay.xul tasksoverlay-cz.xul tasksoverlay-ff.xul tasksoverlay-mobile.xul tasksoverlay-sb.xul tasksoverlay-tb.xul tasksoverlay.xul venkmanoverlay.xul prefs/prefsoverlay.xul further examination of the chrome
manifest will reveal that dom inspector also uses conditional overlays on its primary window: overlay chrome://inspector/content/inspector.xul chrome://communicator/content/utilityoverlay.xul application={92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a} overlay chrome://inspector/content/inspector.xul chrome://communicator/content/tasksoverlay.xul application={92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a} overlay chrome:...
...l chrome://inspector/content/keysetoverlay.xul chrome://inspector/content/viewers/d...setoverlay.xul chrome://inspector/content/statusbaroverlay.xul chrome://global/content/globaloverlay.xul (note that the overlays from the viewer subdirectories—viewers/dom and viewers/stylerules—are loaded as a result of overlay directives in dom inspector's chrome
manifest, rather than being explicitly imported using a xul-overlay processing instruction in the overlaid file.) inspectoroverlay.xul this imports the scripts the top-level inspector needs, including dependencies.
Application - Firefox Developer Tools
this includes inspection of service workers and web app
manifests.
... finding an example if you want to test this functionality and you don't have a handy pwa available, you can grab one of our simple examples to use: add to homescreen demo: shows pictures of foxes (source code | live version) js13kpwa demo: show information on entries to the js13k annual competition (source code | live version) how to debug service workers inspect web app
manifests ...
about:debugging (before Firefox 68) - Firefox Developer Tools
if you change files that are only parsed at install time, like the
manifest.json file, you'll need to restart firefox, then load the add-on again.
...this does what it says: reloading any persistent scripts, such as background scripts parsing the
manifest.json file again, so changes to permissions, content_scripts, browser_action or any other keys will take effect.
Event reference
appinstalled event web app
manifest a web application is successfully installed as a progressive web app.
... mozbrowser
manifestchange firefox os browser api-specific sent when the path to the app
manifest changes, in the case of a browser <iframe> with an open web app embedded in it.
HTML attribute: crossorigin - HTML: Hypertext Markup Language
<script src="https://example.com/example-framework.js" crossorigin="anonymous"></script> example: web
manifest with credentials the use-credentials value must be used when fetching a
manifest that requires credentials, even if the file is from the same origin.
... <link rel="
manifest" href="/app.web
manifest" crossorigin="use-credentials"> specifications specification status comment html living standardthe definition of 'cors settings attributes' in that specification.
HTML attribute: rel - HTML: Hypertext Markup Language
link link link
manifest web app
manifest link not allowed not allowed modulepreload tells to browser to preemptively fetch the script and store it in the document's module map for later evaluation.
...
manifest web app
manifest.
HTML documentation index - HTML: Hypertext Markup Language
113
manifest cache, application cache the
manifest attribute of <html> element specifies a url of a application cache
manifest that is downloaded in the early stages of page load.
... 225 link types:
manifest app, attribute, html, link, link types,
manifest, reference the
manifest keyword for the rel attribute of the <link> element indicates that the target resource is a web app
manifest.
Content-Security-Policy - HTTP
manifest-src specifies valid sources of application
manifest files.
... specifications specification status comment content security policy level 3 working draft adds
manifest-src, navigate-to, report-to, strict-dynamic, worker-src.
Sec-Fetch-Dest - HTTP
header type fetch metadata request header forbidden header name yes, since it has prefix sec- cors-safelisted request header syntax sec-fetch-dest: audio sec-fetch-dest: audioworklet sec-fetch-dest: document sec-fetch-dest: embed sec-fetch-dest: empty sec-fetch-dest: font sec-fetch-dest: image sec-fetch-dest:
manifest sec-fetch-dest: nested-document sec-fetch-dest: object sec-fetch-dest: paintworklet sec-fetch-dest: report sec-fetch-dest: script sec-fetch-dest: serviceworker sec-fetch-dest: sharedworker sec-fetch-dest: style sec-fetch-dest: track sec-fetch-dest: video sec-fetch-dest: worker sec-fetch-dest: xslt sec-fetch-dest: audioworklet sec-fetch-dest: audioworklet values audio audioworklet docu...
...ment embed empty font image
manifest object paintworklet report script serviceworker sharedworker style track video worker xslt nested-document examples todo specifications specification title fetch metadata request headers the sec-fetch-dest http request header ...
Progressive web app structure - Progressive web apps (PWAs)
2017 competition, used as an example for the mdn articles about progressive web apps."> <meta name="author" content="end3r"> <meta name="theme-color" content="#b12a34"> <meta name="viewport" content="width=device-width, initial-scale=1"> <meta property="og:image" content="icons/icon-512.png"> <link rel="shortcut icon" href="favicon.ico"> <link rel="stylesheet" href="style.css"> <link rel="
manifest" href="js13kpwa.web
manifest"> <script src="data/games.js" defer></script> <script src="app.js" defer></script> </head> <body> <header> <p><a class="logo" href="http://js13kgames.com"><img src="img/js13kgames.png" alt="js13kgames"></a></p> </header> <main> <h1>js13kgames a-frame entries</h1> <p class="description">list of games submitted to the <a href="http://js13kgames.com/aframe">a-frame c...
...>request dummy notifications</button> <section id="content"> // content inserted in here </section> </main> <footer> <p>© js13kgames 2012-2018, created and maintained by <a href="http://end3r.com">andrzej mazur</a> from <a href="http://enclavegames.com">enclave games</a>.</p> </footer> </body> </html> the <head> section contains some basic info like title, description and links to css, web
manifest, games content js file, and app.js — that's where our javascript application is initialized.
Navigator.mozNotification - Archive of obsolete content
permissions when using notifications in an open web app, be sure to add the desktop-notification permission in your
manifest file: "permissions": { "desktop-notification": {} } usage notes in firefox 22+, the instantiation of a new notification should be done with the notification object by calling new notification(title, options).
Tools - Archive of obsolete content
package.json the package.json file contains
manifest data for your add-on, providing not only descriptive information about the add-on for presentation in the add-ons manager, but other metadata required of add-ons.
Developing for Firefox Mobile - Archive of obsolete content
with some extra options: jpm-mobile run --adb /path/to/adb in the command shell, you should see something like: launching mobile application with intent name org.mozilla.fennec pushing the addon to your device starting: intent { act=android.activity.main cmp=org.mozilla.fennec/.app (has extras) } --------- beginning of /dev/log/main --------- beginning of /dev/log/system could not read chrome
manifest 'file:///data/data/org.mozilla.fennec/chrome.
manifest'.
Scrollbar - Archive of obsolete content
example assumes a structure like this: app/chrome/chrome.
manifest app/chrome/skin/global/ copy the scrollbars.css from xulrunner/chrome/classic.jar/skin/classic/global to app/chrome/skin/global/scrollbars.css open the app/chrome/chrome.
manifest and add: skin app-global standard/1.0 skin/global/ override chrome://global/skin/xulscrollbars.css chrome://app-global/skin/scrollbars.css xulscrollbars.css are used for windows xp, and nativescrollbars.css on osx.
Default Preferences - Archive of obsolete content
setting default preferences while most of an extension's directories can be named arbitrarily and mapped using a chrome
manifest, default preferences must be in very particular spot: | extension root +--|content +--|skin +--|defaults +--|preferences to add preferences simply drop a .js file into that directory and mozilla will read it and set the appropriate preferences.
Deploying a Plugin as an Extension - Archive of obsolete content
here's what a basic install.rdf file looks like: <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>rhapsodyplayerengine@rhapsody.com</em:id> <em:name>rhapsody player engine</em:name> <em:version>1.0.0.487</em:version> <em:targetapplication> <description> <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id> <em:minversion>1.5</em:minversion> <em:maxversion>1.5.0.*</em:maxversion> </description> </em:targetapplication> </descr...
Signing an extension - Archive of obsolete content
sign the basic usage of the signing tool is as follows: nss-signtool \ -d (path to the directory that contains your certificate database files) \ -k (your certificate nickname) \ -p (your certificate password) \ -x -z (output path/name of signed file) \ (path to your extension working directory that contains chrome directory, chrome.
manifest file, install.rdf file, etc.) writing your password directly in the script is dangerous.
downloading - Archive of obsolete content
the downloading event is fired after checking for an application cache update, if the user agent has found an update and is fetching it, or is downloading the resources listed by the cache
manifest for the first time.
updateready - Archive of obsolete content
the updateready event is fired when the resources listed in the application cache
manifest have been newly redownloaded, and the script can use swapcache() to switch to the new cache.
MCD, Mission Control Desktop, AKA AutoConfig - Archive of obsolete content
build install mercurial tools [root@b008-02 ~]# yum install mercurial installed: mercurial.i586 0:1.2.1-1.fc11 check merge tools in [root@b008-02 ~]# vim /etc/mercurial/hgrc.d/mergetools.rc get the source comm-central [root@b008-02 moz]# time hg clone http://hg.mozilla.org/comm-central/ commsrc requesting all changes adding changesets adding
manifests adding file changes added 2975 changesets with 16793 changes to 7117 files (+3 heads) updating working directory 5644 files updated, 0 files merged, 0 files removed, 0 files unresolved real 0m40.771s user 0m9.284s sys 0m1.304s [root@b008-02 commsrc]# python client.py checkout executing command: ['hg', 'pull', '-r', './.', '-r', 'tip'] pulling from http://hg.mozilla.org/comm-central...
Automated testing tips and tricks - Archive of obsolete content
todo: check example code in to the tree somewhere how to quit the browser on all platforms window.close() of the last open window does not quit the application on mac http://people.mozilla.com/~davel/scripts/ - look at quit.js and quit.xul install
manifest file in appdir/chrome to map chrome://tests/content to directory containing quit.js and quit.xul example: content tests file:///users/davel/work/tests/ start app with command line flag -chrome chrome://tests/content/quit.xul how to create a new profile from the command line first, use the -createprofile command line flag to add a profile entry to profiles.ini and populate the new profile directory with a prefs.js file firefox-bin -createprofile "testprofile ${profile_d...
install.rdf - Archive of obsolete content
copy the following text and paste it into a text file, then save that file as "install.rdf": <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>author@oftheme.com</em:id> <em:version>2.0b1</em:version> <!-- seamonkey --> <em:targetapplication> <description> <em:id>{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}</em:id> <em:minversion>2.0b1pre</em:minversion> <em:maxversion>2.0b2pre</em:maxversion> </description> </em:targetapplication> <!-- front end metadata --> <em:name>my_theme</em:name> <em:description>my first theme</em:description> <!-- front end integration hooks (used by theme...
Extenders - Archive of obsolete content
manifest chief mechanism for allowing advanced api use within your jetpack superpowers similar to libraries, superpowers are for adding deeper platform coupling for your jetpack sandboxes safely abstracts library interoperability issues so you don't have to worry about them future api interface method for including not yet finalized functionality in your jetpack ...
Extensions - Archive of obsolete content
the code snippet will look something like this: <em:targetapplication> <!– prism –> <description> <em:id>prism@developer.mozilla.org</em:id> <em:minversion>0.8</em:minversion> <em:maxversion>1.0.0.*</em:maxversion> </description> </em:targetapplication> in addition to the install
manifest changes, you may want to expose your extension into the prism ui.
Creating XPI Installer Modules - Archive of obsolete content
where before a single
manifest.rdf file described the resources in an entire package directory or archive, now contents.rdf files can be used for as large or as small a part of your package description as you want; you can use several contents.rdf files in your package to describe the various parts (e.g., one for the skin of your package, another for the content, and so on), or you can use a single one, as was common before.
Index - Archive of obsolete content
1040
manifest files needsupdate, tutorials, xul, xul_tutorial in this section, we'll see how to put chrome and xul files into a package and create the
manifest files for them.
Providing Command-Line Options - Archive of obsolete content
using the example to use this sample code, save the commandline.js file into the components directory and add the following lines to your chrome.
manifest file: component {2991c315-b871-42cd-b33f-bfee4fcbf682} components/commandline.js contract @mozilla.org/commandlinehandler/general-startup;1?type=myapp {2991c315-b871-42cd-b33f-bfee4fcbf682} category command-line-handler m-myapp @mozilla.org/commandlinehandler/general-startup;1?type=myapp the javascript code const cc = components.classes; const ci = components.interfaces; components.utils.imp...
Localization - Archive of obsolete content
you also need to add the locale to the chrome.
manifest file, for example: locale findfile en-us locale/ declaring entities the entities are declared using a simple syntax as shown below: <!entity findlabel "find"> this example creates an entity with the name findlabel and the value "find".
XUL Tutorial - Archive of obsolete content
introduction introduction xul structure the chrome url
manifest files simple elements creating a window adding buttons adding labels and images input controls numeric controls list controls progress meters adding html elements using spacers more button features the box model the box model element positioning box model details groupboxes adding more elements more layout elements stacks and decks stack positioning tabboxes grids content panels splitters toolbars and menus toolbars simple menu bars more menu features popup menus scrolling menus events and scripts adding event handle...
Custom app bundles for Mac OS X - Archive of obsolete content
(this is where you place your xul application code and support files) application.ini (xulrunner-related application settings) example.icns (this is the icon which will be used by your application bundle) chrome/ content/ example.xul (this directory contains your application's chrome) example.
manifest defaults/ preferences/ app-prefs.js (this provides some default values for preferences) application bundle contents in addition to the standard directory hierarchy that's required of all mac os x applications, as shown above in application bundle layout, there are ...
Debugging a XULRunner Application - Archive of obsolete content
note the "new in firefox 3" attribute "contentaccessible" on https://developer.mozilla.org/en/chrome_registration so as per http://markmail.org/message/ezbomhkw3bgqjllv#query:x-jsd+page:1+mid:xvlr7odilbyhn6v7+state:results change the
manifest to have this line: content venkman jar:venkman.jar!/content/venkman/ contentaccessible=yes i get errors about not being able to open contentareautils.js, contentareadd.js, findutils.js, or contentareautils.js...
install.rdf - Archive of obsolete content
copy the following text and paste it into a text file, then save that file as "install.rdf": <?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>{themes_uuid}</em:id> <em:version>themes_version</em:version> <!-- target application this extension can install into, with minimum and maximum supported versions.
Getting started with React - Learn web development
its initial file structure looks like this: moz-todo-react ├── readme.md ├── node_modules ├── package.json ├── package-lock.json ├── .gitignore ├── public │ ├── favicon.ico │ ├── index.html │ └──
manifest.json └── src ├── app.css ├── app.js ├── app.test.js ├── index.css ├── index.js ├── logo.svg └── serviceworker.js the src directory is where we'll spend most of our time, as it's where the source code for our application lives.
Chrome Worker Modules
ave been exported // assuming that mymodule.js is installed to resource://gre/modules/mymodule.js let module = require("resource://gre/modules/mymodule.js") foo(module.key); // module.key == "this is public"; // however, secretkey is not exported and cannot be used for the installation of resources, please see the documentation on moz.build (if your code is part of the platform) or on chrome
manifests (if your code is part of an add-on).
Themes
tools & resources browser theme
manifest.json keys browser extensions theme api discourse forum theme related blog posts archived resources ...
Browser chrome tests
if you are adding the first tests in a directory, make sure to also include any head.js you added to support-files, and additionally, ensure that your browser.ini is referenced by a moz.build file somewhere, such as: browser_chrome_
manifests += [ 'test/functional/mochitest/browser.ini' ] support-files once added to support-file section of browser.ini support files may be referenced as https://example.com/browser/[path_to_file] or chrome://mochitests/content/browser/[path_to_file].
Creating a spell check dictionary add-on
<?xml version="1.0"?> <rdf xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:em="http://www.mozilla.org/2004/em-rdf#"> <description about="urn:mozilla:install-
manifest"> <em:id>locale-code@dictionaries.addons.mozilla.org</em:id> <em:version>version number</em:version> <em:type>64</em:type> <em:unpack>true</em:unpack> <em:name>name</em:name> <!-- other install.rdf metadata such as em:localized, em:description, em:creator, em:developer, em:translator, em:contributor or em:homepageurl --> <!-- firefox --> ...
Old Thunderbird build
on linux, this can
manifest as problems setting up the virtualenv for running tests (failure to install pip or virtualenv because of os access denied errors, where access is denied not because of permission problems, but because the paths being accessed have been truncated, and so do not exist).
Simple Instantbird build
on linux, this can
manifest as problems setting up the virtualenv for running tests (failure to install pip or virtualenv because of os access denied errors, where access is denied not because of permission problems, but because the paths being accessed have been truncated, and so do not exist).
Simple Thunderbird build
on linux, this can
manifest as problems setting up the virtualenv for running tests (failure to install pip or virtualenv because of os access denied errors, where access is denied not because of permission problems, but because the paths being accessed have been truncated, and so do not exist).
Interface Compatibility
if necessary, it is possible for an extension to support multiple versions by shipping multiple shared libraries (dlls) in the same extension package, and selecting the correct version using versioning flags in its chrome.
manifest file.
Limitations of chrome scripts
you'll get the shims for your add-on by default, unless you set the multiprocesscompatible flag in your add-on's install
manifest.
Frame script loading and lifetime
to define the mapping between a chrome:// url and a frame script packaged with an extension, use a "chrome.
manifest" file to register a chrome url: // chrome.
manifest content my-e10s-extension chrome/content/ // chrome script mm.loadframescript("chrome://my-e10s-extension/content/content.js", true); allowdelayedload if the message manager is a global frame message manager or a window message manager then: if allowdelayedload is true, the frame script will be loaded into any new frame, which has opene...
mozbrowseractivitydone
note: for activities where the receiving app's activity definition in its
manifest does not include returnvalue or returnvalue is false, no mozbrowseractivitydone event will be generated as of the landing of bug 1194525 in firefox os 2.5.
HTML parser threading
there are two such pieces of information: the
manifest url for an app cache
manifest and the character encoding for the document.
Geckoview-Junit Tests
for example: <class1>#<test1> <class2> <class3>#<test2> <class3>#<test3> to run the tests specified in the file: mozilla-central$ mach geckoview-junit --test-filters-file <path-to-filter-file> disabling one failing test there is no
manifest listing the geckoview junit tests.
How test harnesses work
python runner the python runner: sets up the testing environment sets up environment variables (mozrunner, currently) creates a profile (mozprofile via mozrunner) sets appropriate test preferences inserts a shim extension in the profile (for non-marionette tests) gathers the tests (
manifestdestiny) potentially sets up an http server for test data (mozhttpd) invokes the binary (mozrunner) it is the job of the shim extension to shut down the browser logging (mozlog, in theory) (run tests, accrue results) cleanup: shutdown the browser check for crashes (mozcrash) reporting (moztest) marionette tests list of testing extensions pageloader (talos) m...
CustomizableUI.jsm
to avoid that, update your chrome
manifest file with links to two different versions of xul overlay, using
manifest flags.
L10n Checks
if you want to test the localization for de, run: check-l10n-completeness browser/locales/l10n.ini ../l10n/ de add-ons (xpi) mode l10n checks gathers the locales to compare from the chrome.
manifest file inside the xpi file.
Localizing with Koala
the easy way involves opening the console and issuing the following commands: c:\users\stas> cd c:\mozilla\l10n\application\firefox c:\mozilla\l10n\application\firefox> rmdir 3.6 c:\mozilla\l10n\application\firefox> hg clone http://hg.mozilla.org/releases/mozilla-1.9.2 3.6 requesting all changes adding changesets adding
manifests adding file changes added 33099 changesets with 158636 changes to 50664 files (+9 heads) updating working directory 40357 files updated, 0 files merged, 0 files removed, 0 files unresolved configure the locale locale id: x-testing (put your locale's code) version: 3.6 location: choose the folder where you want to keep the localized files or leave empty for now check "mercurial" if you wish ...
QA phase
adding changesets adding
manifests adding file changes added 1 changesets with 2 changes to 2 files bb/acl: your_id is allowed.
Uplifting a localization from Central to Aurora
this looks something like searching for changes adding changesets adding
manifests adding file changes added 22 changesets with 23 changes to 46 files (+1 heads) (run 'hg heads' to see heads, 'hg merge' to merge) ok, let's make sure we're not talking relbranches: hg heads --template '{node} {branches}\n' this is printing something like 5131e147fa50c28ec858c7d9fd1ba201ea2a433b 4da525ed77699794c56081791bd46cc85983f6f8 9bc7e6c58fc091c8cd0e8d9e1dbc7e6...
MathML In Action
your feedback can be
manifested by putting mathml content on the web, reporting bugs in bugzilla, and, if you can help with code, inspecting/improving the current code, and/or picking up an item in the todo list.
Mozilla DOM Hacking Guide
for us, it is: 1225 dom_classinfo_map_entry(nsidomhtmldomimplementation) add the new interface to the makefiles,
manifests, etc.
Gecko Profiler FAQ
you can make your own talos pageload test which has just the one page that you’re interested in in its
manifest.
Power profiling overview
if the problem
manifests on a particular website, try saving a local copy of the site and then manually removing html elements to see if a particular page feature is causing the problem many power problems are caused by either high cpu usage or high wakeup frequency.
NSS_3.12_release_notes.html
oalgid() in mozilla/security/nss/lib/pk11wrap/pk11mech.c bug 339907: oaep_xor_with_h1 allocates and leaks sha1cx bug 341122: coverity 633 sftk_destroyslotdata uses slot->slotlock then checks it for null bug 351140: coverity 995, potential crash in ecgroup_fromnameandhex bug 362278: lib/util includes header files from other nss directories bug 228190: remove unnecessary nss_enable_ecc defines from
manifest.mn bug 412906: remove sha.c and sha.h from lib/freebl bug 353543: valgrind uninitialized memory read in nsspkiobjectcollection_addinstances bug 377548: nss qa test program certutil's default dsa prime is only 512 bits bug 333405: item cleanup is unused deadcode in secitem_allocitem loser bug 288730: compiler warnings in certutil bug 337251: warning: /* within comment bug 362967: export secmod_del...
NSS Developer Tutorial
symbol export lists the
manifest.mn file, in a directory in the nss source tree, specifies which headers are public, and which headers are private.
Mozilla Projects
specifically, it focuses on the process of digitally signing update
manifests so the applications can verify the integrity of a
manifest retrieved over normally insecure channels.
How to build an XPCOM component in JavaScript
elloworld]), hello: function() { return "hello world!"; } }; var components = [helloworld]; if ("generatensgetfactory" in xpcomutils) var nsgetfactory = xpcomutils.generatensgetfactory(components); // firefox 4.0 and higher else var nsgetmodule = xpcomutils.generatensgetmodule(components); // firefox 3.x note: starting with firefox 4.0 you will need to declare your component in chrome.
manifest; classdescription and contractid properties on the other hand are no longer required.
Packaging WebLock
the archive, its subdirectory structure, and its contents should look like this: weblock.xpi archive viewed in winzip note that the top level of the archive holds the install.js installation file, an rdf
manifest for the package as a whole, and the component files (weblock.xpt and weblock4.dll).
Creating XPCOM components
ngs common xpcom error codes using xpcom components component examples cookie manager the webbrowserfind component the weblock component component use in mozilla finding mozilla components using xpcom components in your cpp xpconnect: using xpcom components from script component internals creating components in cpp xpcom initialization xpcom registry
manifests registration methods in xpcom autoregistration the shutdown process three parts of a xpcom component library xpcom glue the glue library xpcom string classes creating the component code what we'll be working on component registration the regxpcom program registration alternatives overview of the weblock module source digging in: required includes and cons...
nsIComponentRegistrar
sname, in string acontractid, in nsifactory afactory); void registerfactorylocation(in nscidref aclass, in string aclassname, in string acontractid, in nsifile afile, in string aloaderstr, in string atype); void unregisterfactory(in nscidref aclass, in nsifactory afactory); void unregisterfactorylocation(in nscidref aclass, in nsifile afile); methods autoregister() register a component (.
manifest) file or all component files in a directory.
Building a Thunderbird extension 1: introduction
the tutorial has the following pages: introduction (this page) the extension filesystem (setting up your local system) install
manifest (the install.rdf file that contains meta-information about the extension) chrome
manifest (list of packages and overlays) xul (the xml user interface language that is used to modify the thunderbird user interface) adding javascript (explains how to add some simple javascript to your thunderbird extension) installing locally (enabling the extension on your local thunderbird instance) packagin...
Creating a Custom Column
for this we overlay messenger.xul, by placing the following line in our chrome.
manifest file: overlay chrome://messenger/content/messenger.xul chrome://replyto_col/content/replyto_col_overlay.xul now that our overlay is set up we need to connect a column to the current columns that exist.
WebIDL bindings
nerateqi([components.interfaces.nsisupports]), donothing: function() {}, get othervalue() { return this.invisiblevalue - 4; }, __init: function(firstnumber) { if (arguments.length > 0) { this.value = firstnumber; } } } var components = [mynumberinner]; var nsgetfactory = xpcomutils.generatensgetfactory(components); finally, add a component and a contract and whatever other
manifest stuff you need to implement an xpcom component.
Index - HTTP
39 csp:
manifest-src csp, directive, http, reference, security the http content-security-policy:
manifest-src directive specifies which
manifest can be applied to the resource.
HTTP headers - HTTP
it is a structured header whose value is a token with possible values audio, audioworklet, document, embed, empty, font, image,
manifest, object, paintworklet, report, script, serviceworker, sharedworker, style, track, video, worker, xslt, and nested-document.
HTTP Index - HTTP
87 csp:
manifest-src csp, content-security-policy, directive, http,
manifest, reference, security,
manifest-src, source the http content-security-policy:
manifest-src directive specifies which
manifest can be applied to the resource.
Equality comparisons and sameness - JavaScript
here's a non-exhaustive list of built-in methods and operators that might cause a distinction between -0 and +0 to
manifest itself in your code: - (unary negation) let stoppingforce = obj.mass * -obj.velocity; if obj.velocity is 0 (or computes to 0), a -0 is introduced at that place and propogates out into stoppingforce.
Web technology for developers
accessibilitycss houdinicss: cascading style sheetsdemos of open web technologiesdeveloper guidesexsltevent referencehtml: hypertext markup languagehttpjavascriptmathmlopensearch description formatprivacy, permissions, and information securityprogressive web apps (pwas)svg: scalable vector graphicstutorialsweb apisweb componentsweb performanceweb app
manifestsweb media technologiesweb securityweb technology referencexml: extensible markup languagexpathxslt: extensible stylesheet language transformations ...