Search completed in 1.19 seconds.
454 results for "Manifest":
Your results are loading. Please wait...
Native manifests
Mozilla › Add-ons › WebExtensions › Native manifests
native manifests are specially formatted json files that are provisioned on the user's computer by some means outside the extension installation process.
... for example, a native manifest might be provisioned by a device administrator or by a native application installer.
... there are three different types of native manifest: native messaging manifests enable a feature called native messaging, in which an extension can communicate with a native app installed on the device.
...And 24 more matches
Manifest Files - Archive of obsolete content
Archive › Mozilla › XUL › Tutorial › Manifest Files
« 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
Archive › Add-ons › Install Manifests
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 › Manifest
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
manifest.json
Mozilla › Add-ons › WebExtensions › manifest.json
this article describes manifest.json for web extensions.
... if you are looking for information about the manifest.json in pwas, check out the web app manifest article.
... the manifest.json file is the only file that every extension using webextension apis must contain.
...And 4 more matches
Inspecting web app manifests - Firefox Developer Tools
Tools › Application › Manifests
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 .webmanifest file: <link rel="manifest" href="/manifest.webmanifest"> the .webmanifest 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
Web › HTML › Element › html › manifest
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
management.getPermissionWarningsByManifest()
Mozilla › Add-ons › WebExtensions › API › management › getPermissionWarningsByManifest
given the text of a manifest.json file, this function returns the permission warnings that would be given for the resulting add-on, as an array of strings.
... syntax var gettingwarnings = browser.management.getpermissionwarningsbymanifest( manifeststring // string ) parameters manifeststring string.
... string containing the manifest file.
... this must be a valid manifest: for example, it must contain all the mandatory manifest keys.
HTMLIFrameElement.getManifest()
Mozilla › Gecko › Chrome › API › Browser API › getManifest
the getmanifest() method of the htmliframeelement interface retrieves the manifest of an app loaded in the browser <iframe> and returns it as json.
... syntax instanceofhtmliframeelement.getmanifest().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.getmanifest().then(function(json) { console.log(json); }); }); specification not part of any specification.
mozbrowsermanifestchange
Mozilla › Gecko › Chrome › API › Browser API › mozbrowsermanifestchange
the mozbrowsermanifestchange 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("mozbrowsermanifestchange", 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
Web › Manifest › scope
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 ...
runtime.getManifest()
Mozilla › Add-ons › WebExtensions › API › runtime › getManifest
get the complete manifest.json file, deserialized from json to an object.
... syntax browser.runtime.getmanifest() parameters none.
... return value an object representing the manifest.
Browser compatibility for manifest.json
Mozilla › Add-ons › WebExtensions › Browser compatibility for manifest.json
nonotes no support nonotes notes see bug 1380812.opera full support yessafari no support nofirefox android no support nonotes no support nonotes notes see bug 1380812.manifest_versionchrome full support 4edge full support 14firefox full support 48opera full support 15safari full support 14firefox android full support ...
... 48manifest_version: version 1 deprecatednon-standardchrome no support 4 — 21edge no support nofirefox no support noopera no support nosafari no support nofirefox android no support nomanifest_version: version 2chrome full support yesedge full support 14firefox full support 48opera full support yessafari full support ...
... 14firefox android full support 48manifest_version: version 3 experimentalchrome no support noedge no support nofirefox no support noopera no support nosafari no support nofirefox android no support nonamechrome full support yesedge full support 14firefox full support 48opera full support yessafari ...
CSP: manifest-src - HTTP
Web › HTTP › Headers › Content-Security-Policy › manifest-src
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
Web › Manifest › background color
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
Web › Manifest › description
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
Web › Manifest › dir
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
Web › Manifest › icons
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
Web › Manifest › lang
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
Web › Manifest › name
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
Web › Manifest › related applications
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
Web › Manifest › short name
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
Web › Manifest › start url
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 ...
manifest_version
Mozilla › Add-ons › WebExtensions › manifest.json › manifest version
type number mandatory yes example "manifest_version": 2 this key specifies the version of manifest.json used by this extension.
... example "manifest_version": 2 ...
Building a Thunderbird extension 3: install manifest
Mozilla › Thunderbird › Thunderbird extensions › 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.
Link types: manifest - HTML: Hypertext Markup Language
Web › HTML › Link types › manifest
the manifest keyword for the rel attribute of the <link> element indicates that the target resource is a web app manifest.
... specifications specification status comment web app manifest working draft ...
categories - Web app manifests
Web › Manifest › categories
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
Web › Manifest › display
(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
Web › Manifest › iarc rating id
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
Web › Manifest › orientation
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
Web › Manifest › prefer related applications
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
Web › Manifest › screenshots
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
Web › Manifest › shortcuts
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
Web › Manifest › theme color
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
Archive › Mozilla › Creating a Skin for SeaMonkey 2.x › chrome.manifest
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/ ...
Match patterns in extension manifests
Mozilla › Add-ons › WebExtensions › Match patterns
see, for example, the content_scripts key in manifest.json.
JAR Manifests
Mozilla › Developer guide › Build Instructions › JAR Manifests
documentation for jar manifests (jar.mn files) now lives here.
XPCshell Test Manifest Expressions
Mozilla › Tech › XPCOM › Language Bindings › XPConnect › xpcshell › Test manifest expressions
xpcshell unit tests are run by specifying them in a manifest file.
Using the application cache - HTML: Hypertext Markup Language
Web › HTML › Using the application cache
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
Index
Mozilla › Add-ons › Index
18 browser compatibility for manifest.json add-ons, webextensions, manifest.json no summary!
...tabs without a specific popup will inherit the global popup, which defaults to the default_popup specified in the manifest.
...tabs or windows without a specific title will inherit the global title text, which defaults to the default_title or name specified in the manifest.
...And 33 more matches
Native messaging
Mozilla › Add-ons › WebExtensions › Native messaging
create a json file called the "host manifest" or "app manifest".
... the extension must request the "nativemessaging" permission in the manifest.json file.
... also, the native application must grant permission for the extension by including the id in the "allowed_extensions" field of the app manifest.
...And 32 more matches
Index
Mozilla › Add-ons › WebExtensions › Index
8 browser compatibility for manifest.json add-ons, webextensions, manifest.json no summary!
...tabs without a specific popup will inherit the global popup, which defaults to the default_popup specified in the manifest.
...tabs or windows without a specific title will inherit the global title text, which defaults to the default_title or name specified in the manifest.
...And 31 more matches
Chapter 5: Let's build a Firefox extension - Archive of obsolete content
Archive › Add-ons › Overlay Extensions › Firefox addons developer guide › Let's build a Firefox extension
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
Mozilla › Application cache implementation overview
nsiapplicationcache is then queried a client id (= the manifest url + a unique time stamp).
...the association happens in nscontentsink::processofflinemanifest() called from the html parser every time <html> tag has been parsed.
... processofflinemanifest 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
Archive › Add-ons › Enhanced Extension Installation
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 › 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
Mozilla › Tech › XPCOM › Guide › 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
Archive › Mozilla › Creating a Firefox sidebar extension
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
Archive › Index
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
Mozilla › Tech › XPCOM › Guide › Creating components › 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
Archive › Add-ons › Bootstrapped extensions
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
Archive › Themes › Building a Theme
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)
Web › Progressive web apps › Installable 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
Archive › Mozilla › XULRunner › Getting started with XULRunner
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
Mozilla › Tech › XPCOM › Reference › Interface › 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 addbootstrappedmanifestlocation(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 removebootstrappedmanifestlocation(in nsilocalfile alocation); methods addbootstrappedmanifestlocation() 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
Archive › Add-ons › How to convert an overlay extension to restartless
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
Archive › Mozilla › Plug-n-Hack › Plug-n-Hack Phase1
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
Anatomy of an extension
Mozilla › Add-ons › WebExtensions › Anatomy of a WebExtension
manifest.json this is the only file that must be present in every extension.
... this manifest can also contain pointers to several other types of files: background scripts: implement long-running logic.
... see the manifest.json reference page for all the details.
...And 6 more matches
Building a cross-browser extension
Mozilla › Add-ons › WebExtensions › Build a cross browser extension
cross-platform extension coding hurdles there are six areas you need to address when tackling a cross-platform extension: api namespace api asynchronous event handling api function coverage manifest keys extension packaging extension publishing api namespace there are two api namespaces in use among the four main browsers: browser.*, the proposed standard for the extensions api, used by firefox and edge.
... then, reference browser-polyfill.js in: manifest.json, to make it available to background and content scripts.
... the executescript call in dynamically-injected content scripts loaded by tabs.executescript, where it hasn’t been loaded using a content_scripts declaration in manifest.json.
...And 6 more matches
Internationalization
Mozilla › Add-ons › WebExtensions › Internationalization
manifest.json locale-dependent metadata myjavascript.js javascript for retrieving browser locale, locale-specific messages, etc.
... internationalizing manifest.json there are a couple of different tasks to carry out to internationalize your manifest.json.
... retrieving localized strings in manifests your manifest.json includes strings that are displayed to the user, such as the extension's name and description.
...And 6 more matches
Chrome Authority - Archive of obsolete content
Archive › Add-ons › Add-on SDK › Tutorials › Chrome Authority
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
Archive › Add-ons › Extension Versioning, Update and Compatibility
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
Chrome incompatibilities
Mozilla › Add-ons › WebExtensions › Chrome incompatibilities
support for manifest.json keys differs across browsers.
... see the "browser compatibility" section in the manifest.json page for more details.
... if an extension wants to redirect a public (e.g., https) url to an extension page, the extension's manifest.json file must contain a web_accessible_resources key with the url of the extension page.
...And 5 more matches
jpm - Archive of obsolete content
Archive › Add-ons › Add-on SDK › Tools › jpm
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
Archive › Add-ons › Overlay Extensions › XUL School › The Essentials of an Extension
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
Archive › Add-ons › Signing an XPI
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
Archive › Creating a status bar extention
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
Archive › Mozilla › Bundles
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
Archive › Mozilla › XUL › Toolbars › Custom toolbar button › Complete
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
ExtensionInfo
Mozilla › Add-ons › WebExtensions › API › management › ExtensionInfo
the add-on's description, taken from the manifest.json description key.
...the add-on's homepage url, taken from the manifest.json homepage_url key.
...the add-on's name, taken from the manifest.json name key.
...And 4 more matches
Add a button to the toolbar
Mozilla › Add-ons › WebExtensions › Add a button to the toolbar
with webextension apis, these kinds of buttons are called "browser actions", and are set up like so: the manifest.json key browser_action is used to define the button.
... first, create a new directory, "button", and create a file called "manifest.json" inside it with the following contents: { "description": "demonstrating toolbar buttons", "manifest_version": 2, "name": "button-demo", "version": "1.0", "background": { "scripts": ["background.js"] }, "browser_action": { "default_icon": { "16": "icons/page-16.png", "32": "icons/page-32.png" } } } this specifies that we'll have a background script named "background.js", and...
... at this point the complete extension should look like this: button/ icons/ page-16.png page-32.png background.js manifest.json now install the extension and click the button: adding a popup let's try adding a popup to the button.
...And 4 more matches
Working with the Tabs API
Mozilla › Add-ons › WebExtensions › Working with the Tabs API
the following is how you might request "tabs" permission in your extension’s manifest.json file: "permissions": [ "<all_urls>", "tabs" ], this request gives you use of all tabs api feature on all website your user visits.
... manifest.json here is the manifest.json: { "browser_action": { "browser_style": true, "default_title": "tabs, tabs, tabs", "default_popup": "tabs.html" }, "description": "a list of methods you can perform on a tab.", "homepage_url": "https://github.com/mdn/webextensions-examples/tree/master/tabs-tabs-tabs", "manifest_version": 2, "name": "tabs, tabs, tabs", "permissions": [ ...
... but first, here is a demonstration of the feature in action: manifest.json none of the functions require a permission to operate, so there are no features in the manifest.json file that need to be highlighted.
...And 4 more matches
Your first extension
Mozilla › Add-ons › WebExtensions › Your first WebExtension
for example, in your command line/terminal you do it like this: mkdir borderify cd borderify manifest.json now create a new file called "manifest.json" directly under the "borderify" directory.
... give it the following contents: { "manifest_version": 2, "name": "borderify", "version": "1.0", "description": "adds a red border to all webpages matching mozilla.org.", "icons": { "48": "icons/border-48.png" }, "content_scripts": [ { "matches": ["*://*.mozilla.org/*"], "js": ["borderify.js"] } ] } the first three keys: manifest_version, name, and version, are mandatory and contain basic metadata for the extension.
...if you do need to specify an add-on id, include the browser_specific_settings key in manifest.json and set its gecko.id property: "browser_specific_settings": { "gecko": { "id": "borderify@example.com" } } icons/border-48.png the extension should have an icon.
...And 4 more matches
Your second extension
Mozilla › Add-ons › WebExtensions › Your second WebExtension
writing the extension create a new directory and navigate to it: mkdir beastify cd beastify manifest.json now create a new file called "manifest.json", and give it the following contents: { "manifest_version": 2, "name": "beastify", "version": "1.0", "description": "adds a browser action icon to the toolbar.
...ee/master/beastify", "icons": { "48": "icons/beasts-48.png" }, "permissions": [ "activetab" ], "browser_action": { "default_icon": "icons/beasts-32.png", "default_title": "beastify", "default_popup": "popup/choose_beast.html" }, "web_accessible_resources": [ "beasts/frog.jpg", "beasts/turtle.jpg", "beasts/snake.jpg" ] } the first three keys: manifest_version, name, and version, are mandatory and contain basic metadata for the extension.
... note that all paths given are relative to manifest.json itself.
...And 4 more matches
Webapps.jsm
Mozilla › JavaScript code modules › 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(amanifest, adestapp) appkind: function(aapp, amanifest) updatepermissionsforapp: function(aid, aispreinstalled) updateofflinecacheforapp: function(aid) installpreinstalledapp: function installpreinstalledapp(aid) removeifhttpsduplicate: function(aid) installsystemapps: function() loadandupdateapps: function() updatedatastore: function(aid, aorigin, amanifesturl, amanifest) _registersystemmessagesf...
...orentrypoint: function(amanifest, aapp, aentrypoint) _registerinterappconnectionsforentrypoint: function(amanifest, aapp,) _registersystemmessages: function(amanifest, aapp) _registerinterappconnections: function(amanifest, aapp) _createactivitiestoregister: function(amanifest, aapp, aentrypoint, arunupdate) _registeractivitiesforapps: function(aappstoregister, arunupdate) _registeractivities: function(amanifest, aapp, arunupdate) _createactivitiestounregister: function(amanifest, aapp, aentrypoint) _unregisteractivitiesforapps: function(aappstounregister) _unregisteractivities: function(amanifest, aapp) _processmanifestforids: 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, amanifest, azippath) _getappdir: function(aid) _writefile: function(apath, adata) dogetlist: function() doexport: function(amsg, amm) doimport: function(amsg, amm) doextractmanifest: function(amsg, amm) dolaunch: function (adata, amm) launch: function launch(amanifesturl, astartpoint, atimestamp, aonsuccess, aonfailure) close: function close(aapp) canceldownload: function canceldownload(amanifesturl, aerror) startofflinecachedownload: function(amanifest, aapp, aprofiledir, aisupdate...
...And 4 more matches
Index
Mozilla › Projects › NSS › 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)
Web › Progressive web apps › Add to home screen
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.webmanifest (we've chosen manifest.webmanifest).
... note: the .webmanifest 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
Archive › Mozilla › Jetpack › Meta › First Run
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
Archive › Mozilla › Jetpack › Meta › firstrun
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
Implement a settings page
Mozilla › Add-ons › WebExtensions › Implement a settings page
set the path to the html file as the options_ui key in manifest.json.
... create a new directory called settings, then create a file called manifest.json inside it with the following contents: { "manifest_version": 2, "name": "settings example", "version": "1.0", "content_scripts": [ { "matches": ["<all_urls>"], "js": ["borderify.js"] } ] } this extension instructs the browser to load a content script called "borderify.js" into all web pages the user visits.
... first, update manifest.json so it has these contents: { "manifest_version": 2, "name": "settings example", "version": "1.0", "content_scripts": [ { "matches": ["<all_urls>"], "js": ["borderify.js"] } ], "options_ui": { "page": "options.html" }, "permissions": ["storage"], "browser_specific_settings": { "gecko": { "id": "addon@example.com" } } } we've added three new m...
...And 3 more matches
Multiple item extension packaging - Archive of obsolete content
Archive › Add-ons › Multiple Item Packaging
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
Archive › Mozilla › Creating a Skin for SeaMonkey 2.x › Getting Started
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
Archive › Mozilla › XUL › Tutorial › XUL Structure
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
Mozilla › Add-ons › Themes › 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
Browser support for JavaScript APIs
Mozilla › Add-ons › WebExtensions › Browser support for JavaScript APIs
support yesedge full support 79firefox no support noopera full support yessafari no support nofirefox android no support nogetpermissionwarningsbymanifestchrome full support yesedge full support 79firefox no support noopera full support yessafari no support nofirefox android no support ...
...to request permissions from an options page, set the open_in_tab property in the options_ui manifest key, so the options page opens in its own tab.opera full support yessafari full support 14notes full support 14notes notes requesting <all_urls> or *://*/* origins will grant permission to request specific origin patterns and automatically prompt the user for acc...
...to request permissions from an options page, set the open_in_tab property in the options_ui manifest key, so the options page opens in its own tab.legend full support full support no support no supportsee implementation notes.see implementation notes.pkcs11desktopmobilechromeedgefirefoxoperasafarifirefox for androidgetmoduleslots non-standardchrome ...
...And 2 more matches
Message Styles
Mozilla › Chat Core › Message Styles
the typical content of an xpi of a theme will be: chrome/ subdirectory (contains the theme files, see below) chrome.manifest install.rdf note: an xpi file is just a zip file with the .xpi extension.
... registration the files used for the registration of your theme with the theme system are install.rdf, chrome.manifest and info.plist.
... install.rdf typical content of 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>messagestyle-shortthemename@hostname.domain.tld</em:id> <em:name>theme name (human readable)</em:name> <em:version>theme version</em:version> <em:description>theme description</em:description> <em:creator>author name</em:creator> <!-- instantbird --> <em:targetapplication> <description> <em:id>{33cb9019-c295-46dd-be21-8c4936574bee}</em:id> <em:minversion>1.5</em:minversion> <em:maxversion>1.6.*</em:maxversion> </description> </em:targetapplication> </description> </rdf> chrome.manifest ty...
...And 2 more matches
NSS tools : signtool
Mozilla › Projects › 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
Mozilla › Tech › XPCOM › Reference › Interface › 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
Mozilla › Thunderbird › 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
Web › HTML › DASH Adaptive Streaming for HTML 5 Video
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
Archive › Add-ons › Add-on SDK › Guides › XUL Migration Guide
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
Archive › Add-ons › Add-on SDK › Tools › 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.
... 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
Archive › Add-ons › Creating Custom Firefox Extensions with the Mozilla Build System
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>m...
...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
Archive › Add-ons › Overlay Extensions › XUL School › Adding Toolbars and Toolbar Buttons
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.
Using the message manager from Firefox extensions - Archive of obsolete content
Archive › Add-ons › Working with multiprocess Firefox › Using the message manager from Firefox extensions
ng the message manager, we can put all the meat of the add-on in a frame script: // frame-script.js // will run in the content process addeventlistener("domcontentloaded", function(event) { var doc = event.originaltarget; if (doc.nodename != "#document") return; // only documents doc.body.style.border = "5px solid red"; }); we'll register a chrome:// url for the frame script: // chrome.manifest content modify-all-pages chrome/content/ the main script, that we attach to the xul overlay, is just a stub that uses the global message manager to load the frame script into each tab: // chrome script // will run in the chrome process var globalmm = cc["@mozilla.org/globalmessagemanager;1"] .getservice(ci.nsimessagelistenermanager); globalmm.loadframescript("chrome://modify-all-pag...
... getservice(ci.nsiioservice); // the 'style' directive isn't supported in chrome.manifest for bootstrapped // extensions, so this is the manual way of doing the same.
... getservice(ci.nsiioservice); // the 'style' directive isn't supported in chrome.manifest for bootstrapped // extensions, so this is the manual way of doing the same.
...gelistener("request-gifs", gifinate.getgifs); }, getgifs : function(message) { var gifstoreturn = new array(message.data); for (var i = 0; i < gifstoreturn.length; i++) { let gif = this.gifs[math.floor(math.random() * this.gifs.length)]; gifstoreturn[i] = gif; } return gifstoreturn; }, again, we need to register a chrome:// url for the frame script: // chrome.manifest content gifinate frame-script.js in the frame script, we get all the <img> elements and send the "request-gifs" message to the main add-on code.
Creating a dynamic status bar extension - Archive of obsolete content
Archive › Creating a dynamic status bar extension
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.
Index of archived content - Archive of obsolete content
Archive › Index of archived 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 ...
...localization code best practices developing bidi apps getting started with app localization internationalization helpers: intlhelper and mozintl l10n.js reference localizing open web apps app permissions building apps for firefox os app manifest apps csp firefox os app beginners tutorial firefox accounts on firefox os firefox os building blocks action menu action menu 2.0 implementation banners ...
... installing b2g os on a mobile device introduction to firefox os mulet open web apps quickstart app development for web developers app development for mobile developers app tools developing app functionality intro to firefox os intro to open web apps intro to manifests your first app pandaboard passcodehelper internals porting b2g os porting b2g onto nexus player (lollipop) porting basics porting on cyanogenmod preparing for your first b2g build resources running tests on firefox os: a...
Settings - Archive of obsolete content
Archive › Mozilla › Jetpack › Meta › settings
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
Archive › Mozilla › Jetpack › Storage › Settings
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
Archive › Mozilla › Makefile.mozextension.2
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
Archive › Mozilla › XUL › Toolbars › Creating toolbar buttons
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
Archive › Mozilla › XULRunner › Creating XULRunner Apps with the Mozilla Build System
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
Archive › Mozilla › XULRunner › Tips
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
Archive › Plugins › Shipping a plugin as a Toolkit bundle
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
Archive › Sunbird theme tutorial
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
Archive › Updating an extension to support multiple Mozilla applications
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.
contentScripts.register()
Mozilla › Add-ons › WebExtensions › API › contentScripts › register
it accepts one parameter, which is an object with similar properties to the objects given in the content_scripts manifest key (but note that content_scripts is an array of objects, while the argument to register() is a single object).
...it has similar syntax to the objects in the content_scripts manifest key array.
...each object has either a property named file, which is a url starting at the extension's manifest.json and pointing to a css file to register, or a property named code, which is some css code to register.
...each object has either a property named file, which is a url starting at the extension's manifest.json and pointing to a javascript file to register, or a property named code, which is some javascript code to register.
pkcs11
Mozilla › Add-ons › WebExtensions › API › pkcs11
there are two environmental prerequisites for using this api: one or more pkcs #11 modules must be installed on the user's computer for each installed pkcs #11 module, there must be a native manifest file that enables the browser to locate the module.
... most probably, the user or device administrator would install the pkcs #11 module, and its installer would install the native manifest file at the same time.
... however, the module and manifest can't be installed as part of the extension's own installation process.
... for details about the manifest file's contents and location, see native manifests.
sidebarAction.setIcon()
Mozilla › Add-ons › WebExtensions › API › sidebarAction › setIcon
types of icon your extension should specify an icon for the sidebar in the sidebar_action manifest key.
... this is called the "manifest icon".
... if path is null, and tabid was specified, and the specified tab had a tab-specific icon set: then the tab-specific icon is reset to the global icon (if a global icon is set) or the manifest icon.
... if path is null, and tabid was omitted, and there was a global icon set, it will be reset to the manifest icon.
sidebarAction.setTitle()
Mozilla › Add-ons › WebExtensions › API › sidebarAction › setTitle
types of title your extension should specify an title for the sidebar in the sidebar_action manifest key.
... this is called the "manifest title".
... if you don't specify the manifest title, it will default to the extension name.
... otherwise, the global title will be reset to the manifest title.
storage.managed
Mozilla › Add-ons › WebExtensions › API › storage › managed
for chrome instructions, see the "manifest for storage areas" article.
... for firefox, you need to create a json manifest file in a specific format, in a specific location.
... for the details of manifest syntax and location, see native manifests.
... here's an example manifest: { "name": "favourite-color-examples@mozilla.org", "description": "ignored", "type": "storage", "data": { "color": "management thinks it should be blue!" } } given this manifest, the "favourite-color-examples@mozilla.org" extension could access the data using code like this: var storageitem = browser.storage.managed.get('color'); storageitem.then((res) => { console.log(`managed color is: ${res.color}`); }); ...
Modify a web page
Mozilla › Add-ons › WebExtensions › Modify a web page
in that directory, create a file called "manifest.json", with the following contents: { "manifest_version": 2, "name": "modify-page", "version": "1.0", "content_scripts": [ { "matches": ["https://developer.mozilla.org/*"], "js": ["page-eater.js"] } ] } the content_scripts key is how you load scripts into pages that match url patterns.
... first, update "manifest.json" so it has the following contents: { "manifest_version": 2, "name": "modify-page", "version": "1.0", "permissions": [ "activetab", "contextmenus" ], "background": { "scripts": ["background.js"] } } here, we've removed the content_scripts key, and added two new keys: permissions: to inject scripts into pages we need permissions for the page we're modifying.
... at this point the extension should look like this: modify-page/ background.js manifest.json page-eater.js now reload the extension, open a page (any page, this time) activate the context menu, and select "eat this page": note that although this video shows the content script working in addons.mozilla.org, content scripts are currently blocked for this site.
... learn more content scripts guide content_scripts manifest key permissions manifest key tabs.executescript() tabs.insertcss() tabs.sendmessage() runtime.sendmessage() runtime.onmessage examples using content_scripts: borderify emoji-substitution notify-link-clicks-i18n page-to-extension-messaging examples using tabs.executescript(): beastify context-menu-copy-link-with-types ...
How to implement a custom autocomplete search component
Mozilla › How to implement 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
Mozilla › Projects › 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
Mozilla › Tech › XPCOM › 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
Tools › about:debugging
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)
Web › Progressive web apps › Introduction
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)
Web › Progressive web apps
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.
Embedded WebExtensions - Archive of obsolete content
Archive › Add-ons › Embedded WebExtensions
for example: my-boostrapped-addon/ chrome/ webextension/ manifest.json background.js ...
... bootstrap.js chrome.manifest install.rdf my-sdk-addon/ index.js package.json webextension/ manifest.json background.js ...
... the promise is rejected if the embedded webextension is missing a manifest or if the manifest is invalid.
Inline options - Archive of obsolete content
Archive › Add-ons › Inline Options
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
Archive › Localizing an extension
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
Archive › Mozilla › XPInstall
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
Archive › Mozilla › XUL › Toolbars › Custom toolbar button
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
Archive › Mozilla › XUL › Tutorial › Creating a Skin
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
Archive › Mozilla › XUL › Tutorial › The Chrome URL
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
Archive › Themes › Theme changes in Firefox 4
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)
Mozilla › About 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.
commands
Mozilla › Add-ons › WebExtensions › API › commands
listen for the user executing commands that you have registered using the commands manifest.json key.
...this contains the information specified for the command in the commands manifest.json key.
... commands.reset reset the given command's description and shortcut to the values given in the manifest key.
permissions
Mozilla › Add-ons › WebExtensions › API › permissions
they can ask for permissions at install time, by including the permissions they need in the permissions manifest.json key.
... users must use about:debugging, go to the add-ons section, then use the "manifest url" link for this add-on.
...these permissions need to be listed in the optional_permissions manifest.json key.
Working with userScripts
Mozilla › Add-ons › WebExtensions › API › userScripts › Working with userScripts
implement userscripts in your extension using the following steps: define the script in the extension's manifest using the "user_scripts" key.
... userscripts manifest a user script is identified by the contents of the user_scripts key of the extensions's manifest.
...and double-click on the extensions's manifest.
JavaScript APIs
Mozilla › Add-ons › WebExtensions › API
(see the list in the content script guide.) to use the more powerful apis, you need to request permission in your extension's manifest.json.
...currently the api only supports copying images, but it's intended to support copying text and html in the future.commandslisten for the user executing commands that you have registered using the commands manifest.json key.contentscriptswith the contentscripts api, an extension can register and unregister scripts at runtime.contextualidentitieswork with contextual identities: list, create, remove, and update contextual identities.cookiesenables extensions to get and set cookies, and be notified when they change.devtoolsenables extensions to interact with the browser's developer tools.
...they can ask for permissions at install time, by including the permissions they need in the permissions manifest.json key.
Content scripts
Mozilla › Add-ons › WebExtensions › Content scripts
using the content_scripts key in your manifest.json, you can ask the browser to load a content script whenever the browser loads a page whose url matches a given pattern.
... webextension apis in addition to the standard dom apis, content scripts can use the following webextension apis: from extension: geturl() inincognitocontext from runtime: connect() getmanifest() geturl() onconnect onmessage sendmessage() from i18n: getmessage() getacceptlanguages() getuilanguage() detectlanguage() from menus: gettargetelement everything from: storage xhr and fetch content scripts can make requests using the normal window.xmlhttprequest and window.fetch() apis.
... content scripts get the same cross-domain privileges as the rest of the extension: so if the extension has requested cross-domain access for a domain using the permissions key in manifest.json, then its content scripts get access that domain as well.
Differences between API implementations
Mozilla › Add-ons › WebExtensions › Differences between API implementations
the differences between browsers’ extensions api implementations fall into four areas: namespace, asynchronous event handling, api coverage, and manifest keys.
... manifest keys the differences in the supported manifest.json keys among the browsers fall broadly into two categories: extension information attributes.
... more information you can find more detailed information about the differences in the supported browser extensions api features in: chrome incompatibilities browser support for javascript apis browser compatibility for manifest.json ...
Example extensions
Mozilla › Add-ons › WebExtensions › Examples
these examples work in firefox nightly: most work in earlier versions of firefox, but check the strict_min_version key in the extension's manifest.json to make sure.
... browseraction.onclickednotifications.createruntime.getmanifestruntime.oninstalledruntime.reload selection-to-clipboard demonstrates how to write to the clipboard from a content script session-state demonstrates how to retrieve extension-defined state state from restored tabs.
... management.getallmanagement.setenabled themes a collection of themes illustrating:weta_fade: a basic theme employing a single image specified in theme_frame:.weta_fade_chrome: the weta_fade theme implemented with chrome compatible manifest keys.weta_tiled: a theme using a tiled image.weta_mirror: a theme using multiple images and aligning those images in the header.animated: use of an animated png.
Intercept HTTP requests
Mozilla › Add-ons › WebExtensions › Intercept HTTP requests
in that directory, create a file called "manifest.json" which has the following contents: { "description": "demonstrating webrequests", "manifest_version": 2, "name": "webrequest-demo", "version": "1.0", "permissions": [ "webrequest", "<all_urls>" ], "background": { "scripts": ["background.js"] } } next, create a file called "background.js" with the following contents: function logurl(requestdetails) { console.
...first, replace manifest.json with this: { "description": "demonstrating webrequests", "manifest_version": 2, "name": "webrequest-demo", "version": "1.0", "permissions": [ "webrequest", "webrequestblocking", "https://developer.mozilla.org/", "https://mdn.mozillademos.org/" ], "background": { "scripts": ["background.js"] } } the only change here is to add the "webrequestblocking" ...
... the "manifest.json" can stay the same as in the previous example.
Working with files
Mozilla › Add-ons › WebExtensions › Working with files
to use this api you need to have the "downloads" api permission specified in your manifest.json file.
... to use this method the extension must request the "nativemessaging" permission in its manifest.json file.
... reciprocally, the native application must grant permission for the extension by including its id in the "allowed_extensions" field of the app manifest.
background
Mozilla › Add-ons › WebExtensions › manifest.json › background
the path is relative to the manifest.json file itself.
...<script src = "https://code.jquery.com/jquery-1.7.1.min.js">), you will also have to change the content_security_policy key in the manifest.json file of your extension.
... page if you need some particular content in the page, you can define your own page using the page property, which is a string representing a path, relative your manifest.json file, to an html document included in your extension bundle.
browser_specific_settings
Mozilla › Add-ons › WebExtensions › manifest.json › browser specific settings
update_url is a link to an extension update manifest.
... for example: "id": "extensionname@example.org" "id": "{daf44bf7-a45e-4450-979c-91cf07434c3d}" microsoft edge properties warning: adding edge-specific properties to the manifest caused an error prior to firefox 69 which can prevent the extension from installing.
... safari properties warning: adding safari-specific properties to the manifest caused an error prior to firefox 69 which can prevent the extension from installing.
web_accessible_resources
Mozilla › Add-ons › WebExtensions › manifest.json › web accessible resources
you specify them as paths relative to the manifest.json file.
... using web_accessible_resources for example, suppose your extension includes an image file at images/my-image.png, like this: my-extension-files/ manifest.json my-background-script.js images/ my-image.png to enable a web page to use an <img> element whose src attribute points to this image, you would specify web_accessible_resources like this: "web_accessible_resources": ["images/my-image.png"] the file is then available using a url like: moz-extension://<extension-uuid>/images/my-image.png" <extension-uuid> is not your extensi...
... the recommended approach to obtaining the url of the resource is to use runtime.geturl passing the path relative to manifest.json, for example: browser.runtime.geturl("images/my-image.png"); // something like: // moz-extension://944cfddf-7a95-3c47-bd9a-663b3ce8d699/images/my-image.png this approach gives you the correct url regardless of the browser your extension is running on.
Browser styles
Mozilla › Add-ons › WebExtensions › user interface › Browser styles
certain user interface components - browser and page action popups, sidebars, and options pages - are specified by your extension in essentially the same way: create an html file defining the structure of the ui element add a manifest.json key (browser_action, page_action, sidebar_action, or options_ui) pointing to that html file.
...to help with this, the manifest.json keys include an extra optional property: browser_style.
... when browser_style: true is included in your web extension's manifest, text selection in your extension's ui is disabled except in input controls.
Browser Extensions
Mozilla › Add-ons › WebExtensions
references get comprehensive details about the methods, properties, types, and events of the webextensions apis and full details about the manifest keys.
... concepts get detailed information on the concept that underpin extensions from an overview of the javascript api, through content scripts, match patterns, working with files, internationalization, and content security policy, to more advanced subjects such as native messaging, using the devtools apis, and native manifests.
... manifest keys get full details about the manifest keys, including all their properties and settings.
Smiley Themes
Mozilla › Chat Core › Smiley Themes
the typical content of an xpi of a smiley theme will be: chrome/ chrome/skin.jar chrome.manifest install.rdf typical content of 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>emoticons-shortthemename@hostname.domain.tld</em:id> <em:name>theme name (human readable)</em:name> <em:version>theme version</em:version> <em...
...escription</em:description> <em:creator>author name</em:creator> <!-- instantbird --> <em:targetapplication> <description> <em:id>{33cb9019-c295-46dd-be21-8c4936574bee}</em:id> <em:minversion>0.2a1pre</em:minversion> <em:maxversion>0.2.*</em:maxversion> </description> </em:targetapplication> </description> </rdf> typical content of chrome.manifest: skin shortthemename classic/1.0 jar:chrome/skin.jar!/ all the values in italic in the 2 previous listings should be replaced with appropriate values for your theme.
... important: please note that for your theme to work, shortthemename in the chrome.manifest and install.rdf files should be identical.
Mochitest
Mozilla › Projects › Mochitest
adding a new mochitest.ini or chrome.ini file if a manifest.ini or chrome.ini file does not exist in the test directory where you want to add a test, add them and update the moz.build file in the directory for your test.
... for example, in gfx/layers/moz.build, we add these two manifest files: mochitest_manifests += ['apz/test/mochitest.ini'] mochitest_chrome_manifests += ['apz/test/chrome.ini'] building and running new tests before committing a new test you should check that the makefile.in changes are correct and that your tests pass as you expect them to.
...for instance, you can xhr to it or you could use a html element: var xhr = new xmlhttprequest(); xhr.open("get", "http://test/tests/dom/manifest/test/test_file.sjs"); xhr.onload = function(e){ console.log("loaded!", this.responsetext)} xhr.send(); the exact properties of the request and response parameters are defined in the nsihttprequestmetadata and nsihttpresponse interfaces in nsihttpserver.idl.
Receiving startup notifications
Mozilla › Tech › XPCOM › Guide › 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
Mozilla › Tech › XPCOM › Reference › Interface › nsIDOMMozNetworkStatsManager
ns_error_not_implmented both appmanifesturl and servicetype are specified at the same time in the networkstatsgetoptions dictionary.
...it contains the following fields: appmanifesturl a string used to filter network stats by app.
... for example, this object might be { appmanifesturl : manifesturl }.
nsIDOMOfflineResourceList
Mozilla › Tech › XPCOM › Reference › Interface › 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
Mozilla › Tech › XPCOM › Reference › Interface › nsIZipReader
manifestentriescount pruint32 the number of entries in the manifest.
...parsemanifest must be called first.
... if aentryname is an entry in the jar, getinputstream() must be called after parsemanifest.
Filelink Providers
Mozilla › Thunderbird › 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
Mozilla › Thunderbird › Thunderbird extensions › 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
Mozilla › Thunderbird › Thunderbird extensions › 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
Tools › Index
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
Web › API › Index
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
Web › CSS › @media › display-mode
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
Web › HTTP › Headers › Content-Security-Policy › default-src
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)
Web › Progressive web apps › Structural overview
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.webmanifest 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.webmanifest"> <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.
Navigator.mozNotification - Archive of obsolete content
Archive › API › Navigator › mozNotification
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+ (firefox os 1.1+), the instantiation of a new notification should be done with the notification object by calling new notification(title, options).
...the manifest origin field fixes this, but it is only available in firefox os 1.1+.
/loader - Archive of obsolete content
Archive › Add-ons › Add-on SDK › Low-Level APIs › loader
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
Archive › Add-ons › Add-on SDK › Tools › cfx to jpm
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.
Extension Etiquette - Archive of obsolete content
Archive › Add-ons › Extension etiquette
chrome: or resource: packages, which are often defined in chrome.manifest files.
... xpcom contract ids, which are often registered in chrome.manifest files.
Setting Up a Development Environment - Archive of obsolete content
Archive › Add-ons › Overlay Extensions › XUL School › Setting Up a Development Environment
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.
Setting up an extension development environment - Archive of obsolete content
Archive › Add-ons › Setting up extension development environment
also note that the use of proxy files requires that the extension's chrome.manifest defines its chrome urls using traditional directories, rather than a jared structure.
...if you choose a jared structure for releasing, you can still develop with a directory structure by editing your chrome.manifest.
Creating a Skin for Firefox/Getting Started - Archive of obsolete content
Archive › Mozilla › Creating a sking for Firefox Getting Started
<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
Archive › Mozilla › Firefox › Repackaging Firefox
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
Archive › Mozilla › Table Layout Regression Tests
"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
Archive › Mozilla › XPInstall › Scripting by example
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-deprecatedmanifest.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
Archive › Mozilla › XUL › Tutorial › Cross Package Overlays
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
Archive › Mozilla › XUL › Using the standard theme
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
Archive › Mozilla › XULRunner › Deploying XULRunner
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
Archive › Mozilla › XULRunner › How to enable locale switching in a XULRunner application
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
Archive › Mozilla › XULRunner › XUL Application Packaging
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
Archive › Mozilla › XULRunner › xulauncher
-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" xulmanifest="$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/ ">$xulmanifest # 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
Games › Publishing games › Game distribution
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
Learn › Getting started with the web › HTML basics
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.
browserAction.setIcon()
Mozilla › Add-ons › WebExtensions › API › browserAction › setIcon
tabs without a specific icon will inherit the global icon, which defaults to the default_icon specified in the manifest.
... otherwise, the global icon will be reset to the manifest icon.
browserAction.setTitle()
Mozilla › Add-ons › WebExtensions › API › browserAction › setTitle
tabs or windows without a specific title will inherit the global title text, which defaults to the default_title or name specified in the manifest.
... otherwise, the global title will be reset to the manifest title.
onCommand
Mozilla › Add-ons › WebExtensions › API › commands › onCommand
this matches the name given to the command in its manifest.json entry.
...this matches the name given to the command in its manifest.json entry.
cookies.set()
Mozilla › Add-ons › WebExtensions › API › cookies › set
the call succeeds only if you include the "cookies" api permission in your manifest.json file, as well as host permissions for the given url specified in its manifest.
...if host permissions for this url are not specified in the manifest file, the method call will fail.
cookies
Mozilla › Add-ons › WebExtensions › API › cookies
to use this api, you need to include the "cookies" api permission in your manifest.json file, as well as host permissions for the sites whose cookies you need to access.
... permissions in order to use this api, an add-on must specify the "cookies" api permission in its manifest, along with host permissions for any sites for which it wishes to access cookies.
management
Mozilla › Add-ons › WebExtensions › API › management
with the management api you can: get information about installed add-ons enable/disable add-ons uninstall add-ons find out which permission warnings are given for particular add-ons or manifests get notifications of add-ons being installed, uninstalled, enabled, or disabled.
... management.getpermissionwarningsbymanifest() get the set of permission warnings that would be displayed for the given manifest string.
menus.update()
Mozilla › Add-ons › WebExtensions › API › menus › update
the top-level icon matches the extension's primary icon as declared in the extension's manifest file.
...to avoid any scaling, you can specify icons like this: "icons": { "16": "path/to/geo-16.png", "32": "path/to/geo-32.png" } alternatively, you can specify a single svg icon, and it will be scaled appropriately: "icons": { "16": "path/to/geo.svg" } note: the top-level menu item uses the icons specified in the manifest rather than what is specified with this key.
pageAction.setIcon()
Mozilla › Add-ons › WebExtensions › API › pageAction › setIcon
if path is null, this will reset the page action's icon to the icon that was given in the page_action manifest key.
... if path is "", this will reset the icon to the browser's global default icon (that is, the icon used if no icon is given in the page_action manifest key).
runtime.getURL()
Mozilla › Add-ons › WebExtensions › API › runtime › getURL
given a relative path from the manifest.json to a resource packaged with the extension, return a fully-qualified url.
...a relative path from the manifest.json to a resource packaged with the extension.
runtime
Mozilla › Add-ons › WebExtensions › API › runtime
runtime.getmanifest() gets the complete manifest.json file, serialized as an object.
... runtime.geturl() given a relative path from the manifest.json to a resource packaged with the extension, returns a fully-qualified url.
sidebarAction.setPanel()
Mozilla › Add-ons › WebExtensions › API › sidebarAction › setPanel
types of panel sidebars always have a "manifest panel", which is the panel defined in the sidebar_action manifest key.
... otherwise, the global panel will be reset to the manifest panel.
theme
Mozilla › Add-ons › WebExtensions › API › theme
to use this api, an extension must request the "theme" permission in its manifest.json file.
... note: when we set up a theme in a background file, we must declare the 'theme' permission and therefore we cannot use the theme function of the manifest, since it's not compatible.
userScripts.register()
Mozilla › Add-ons › WebExtensions › API › userScripts › register
each object has either a property named file, which is a url starting at the extension's manifest.json and pointing to a javascript file to register, or a property named code, which contains javascript code to register.
... the url patterns provided in matches must be enabled by the host permissions defined in the manifest permission property or enabled by the user from the optional_permissions list.
userScripts
Mozilla › Add-ons › WebExtensions › API › userScripts
an api script is declared in the extension's manifest file using the "user_scripts" manifest key.
... this api requires the presence of the user_scripts key in the manifest.json, even if no api script is specified.
webRequest.onBeforeRequest
Mozilla › Add-ons › WebExtensions › API › webRequest › onBeforeRequest
https) url to an extension page, the extension's manifest.json file must contain a web_accessible_resources key that lists the url for the extension page.
... if you use "blocking", you must have the "webrequestblocking" api permission in your manifest.json.
Content Security Policy
Mozilla › Add-ons › WebExtensions › Content Security Policy
the extension's author can change the default policy using the content_security_policy manifest.json key, but there are restrictions on the policies that are allowed.
... default content security policy the default content security policy for extensions is: "script-src 'self'; object-src 'self';" this will be applied to any extension that has not explicitly set its own content security policy using the content_security_policy manifest.json key.
Extending the developer tools
Mozilla › Add-ons › WebExtensions › Extending the developer tools
to create a devtools extension, include the "devtools_page" key in manifest.json: "devtools_page": "devtools/devtools-page.html" the value of this key is a url pointing to an html file that's been bundled with your extension.
... the url should be relative to the manifest.json file itself.
Firefox differentiators
Mozilla › Add-ons › WebExtensions › Firefox differentiators
define, in the manifest.json file, the urls where a page action is shown or hidden, and choose where to place the browser action icon.
... take advantage of external services to handle protocols or content types by registering protocol handlers in the manifest.json.
Work with contextual identities
Mozilla › Add-ons › WebExtensions › Work with contextual identities
permissions to use the contextualidentities api you need to include the "contextualidentities" permission in your manifest.json file.
... here is a short video of the extension in action: manifest.json the main features of the manifest.json file are: the permissions request: "permissions": [ "contextualidentities", "cookies" ], specification of the toolbar button (browseaction) that provides access to the extension’s features: "browser_action": { "browser_style": true, "default_title": "contextual identities", "default_popup": "context.html", ...
Work with the Bookmarks API
Mozilla › Add-ons › WebExtensions › Work with the Bookmarks API
permissions to make use of the bookmarks api, you need to ask for the "bookmarks" permission in your extension’s manifest.json file: "permissions": [ "bookmarks" ], features the bookmarks api lets your extension do the things users can do with bookmarks and includes functions for: basic bookmark item manipulation, offering: add (bookmarks.create).
... this video shows the extension in action: manifest.json the manifest.json describes the extension: { "manifest_version": 2, "name": "bookmark it!", "version": "1.1", "description": "a simple bookmark button", "homepage_url": "https://github.com/mdn/webextensions-examples/tree/master/bookmark-it", defines the icons that’ll be used to represent the extension, in places such as the add-on manager.
browser_action
Mozilla › Add-ons › WebExtensions › manifest.json › browser action
icons are specified as urls relative to the manifest.json file itself.
... icons are specified as urls relative to the manifest.json file.
chrome_settings_overrides
Mozilla › Add-ons › WebExtensions › manifest.json › chrome settings overrides
"chrome_settings_overrides" : { "homepage": "https://developer.mozilla.org/" } "chrome_settings_overrides": { "search_provider": { "name": "discogs", "search_url": "https://www.discogs.com/search/?q={searchterms}", "keyword": "disc", "favicon_url": "https://www.discogs.com/favicon.ico" } } manifest key: chrome_settings_overrides type object mandatory no syntax the chrome_settings_overrides key is an object that may have the following properties: name type description homepage string defines the page to be used as the browser's homepage.
...the url may: point to a file bundled with the extension, in which case it is given as a url relative to the manifest.json file be a remote url, such as "https://developer.mozilla.org/".
content_scripts
Mozilla › Add-ons › WebExtensions › manifest.json › content scripts
css array an array of paths, relative to manifest.json, referencing css files that will be injected into matching pages.
... js array an array of paths, relative to the manifest.json file, referencing javascript files that will be injected into matching pages.
dictionaries
Mozilla › Add-ons › WebExtensions › manifest.json › dictionaries
although the dictionary consists of two files, one with a .dic and one with an .aff file extension, only the one with the .dic extension is referenced in the manifest.json.
... if you use the dictionaries key, you must also set an id for your extension using the browser_specific_settings manifest.json key.
Extension pages
Mozilla › Add-ons › WebExtensions › user interface › Extension pages
/my-extension /manifest.json /my-page.html /my-page.js displaying extension pages there are two options for displaying extension pages: windows.create() and tabs.create().
...if you don't want to have this behavior, use history.deleteurl() to remove the browser's record: function onvisited(historyitem) { if (historyitem.url == browser.extension.geturl(mypage)) { browser.history.deleteurl({url: historyitem.url}); } } browser.history.onvisited.addlistener(onvisited); to use the history api, you must request the "history" permission in your manifest.json file.
Address bar button
Mozilla › Add-ons › WebExtensions › user interface › Page actions
the button’s visibility: the page action is hidden by default (although this default can be changed via the show_matches and hide_matches manifest key properties), and you call pageaction.show() and pageaction.hide() to show or hide it in specific tabs.
...for example: type bookmarks action content action tabs operation page action bookmark this page reddit enhancement send tab browser action show all bookmarks enable ad-blocking sync all open tabs specifying the page action you define the page action's properties using the page_action key in manifest.json: "page_action": { "browser_style": true, "default_icon": { "19": "button/geo-19.png", "38": "button/geo-38.png" }, "default_title": "whereami?" } the only mandatory key is default_icon.
Popups
Mozilla › Add-ons › WebExtensions › user interface › Popups
see the documentation for the manifest.json key commands .
... the html file is included in the extension and specified as part of the browser_action or page_action key by "default_popup" in the manifest.json: "browser_action": { "default_icon": "icons/beasts-32.png", "default_title": "beastify", "default_popup": "popup/choose_beast.html" } you can ask the browser to include a stylesheet in your popup that will make it look consistent with the browser's ui.
Sidebars
Mozilla › Add-ons › WebExtensions › user interface › Sidebars
for example, firefox includes a sidebar for interacting with bookmarks: using the sidebar_action manifest.json key, an extension can add its own sidebar to the browser.
... specifying sidebars to specify a sidebar, define the default document with the sidebar_action manifest.json key, alongside a default title and icon: "sidebar_action": { "default_title": "my sidebar", "default_panel": "sidebar.html", "default_icon": "sidebar_icon.png" } the title, panel, and icon can be changed programmatically using the sidebaraction api.
Creating reftest-based unit tests
Mozilla › 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
Mozilla › Developer guide › 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
Mozilla › Developer guide › Build Instructions › How Mozilla s build system works › 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
Mozilla › Gecko › Chrome › API › Browser API
htmliframeelement.getmanifest() retrieves the manifest of an app loaded in the browser <iframe> and returns it as json.
... mozbrowsermanifestchange 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
Mozilla › JavaScript code modules › Add-on Manager › 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
Mozilla › JavaScript code modules › Using
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
Mozilla › Localization › 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
Mozilla › Localization › Quick start guide › 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
Mozilla › Projects › 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
Mozilla › Projects › NSS › Reference › 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
Mozilla › Projects › NSS › tools › 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
Mozilla › Projects › 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
Mozilla › Tech › XPCOM › Reference › Interface › 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
Mozilla › Tech › XPCOM › Reference › Interface › 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
Mozilla › Tech › XPCOM › 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
Mozilla › Tech › XPCOM › 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
Mozilla › Thunderbird › Thunderbird extensions › Building a Thunderbird extension 2 extension filesystem
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
Mozilla › Thunderbird › Thunderbird extensions › HowTos › Common Thunderbird Extension Techniques › 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
Mozilla › 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
Tools › Add-ons › DOM Inspector › Internals
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
Tools › Application
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
Tools › about:debugging › about:debugging before Firefox 68
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
Web › Events
appinstalled event web app manifest a web application is successfully installed as a progressive web app.
... mozbrowsermanifestchange 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
Web › HTML › Attributes › crossorigin
<script src="https://example.com/example-framework.js" crossorigin="anonymous"></script> example: webmanifest 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.webmanifest" 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
Web › HTML › Attributes › rel
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 attribute reference - HTML: Hypertext Markup Language
Web › HTML › Attributes
manifest <html> specifies the url of the document's cache manifest.
... note: this attribute is obsolete, use <link rel="manifest"> instead.
<html>: The HTML Document / Root element - HTML: Hypertext Markup Language
Web › HTML › Element › html
manifest specifies the uri of a resource manifest indicating resources that should be cached locally.
... recommendation added support for the manifest attribute (deprecated later).
HTML documentation index - HTML: Hypertext Markup Language
Web › HTML › Index
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
Web › HTTP › Headers › Content-Security-Policy
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
Web › HTTP › Headers › Sec-Fetch-Dest
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)
Web › Progressive web apps › App structure
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.webmanifest"> <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.
Program ID - Archive of obsolete content
Archive › Add-ons › Add-on SDK › Guides › Program ID
when you package your add-on for distribution using jpm xpi, it will become the id field in the add-on's install manifest.
platform/xpcom - Archive of obsolete content
Archive › Add-ons › Add-on SDK › Low-Level APIs › platform xpcom
autoregister(path) register a component (.manifest) file or all component files in a directory.
cfx - Archive of obsolete content
Archive › Add-ons › Add-on SDK › Tools › cfx
--manifest-overload add fields to, or override selected fields in, package.json.
Tools - Archive of obsolete content
Archive › Add-ons › Add-on SDK › Tools
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
Archive › Add-ons › Add-on SDK › Tutorials › Mobile development
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
Archive › Add-ons › Code snippets › Scrollbar
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
Archive › Add-ons › Default Preferences
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
Archive › Add-ons › Deploying a Plugin as an Extension
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...
Migrating raw components to add-ons - Archive of obsolete content
Archive › Add-ons › Migrating raw components to add-ons
as you'll see, add-ons give you much more flexibility than simply loading a component, but in order to get started, all you'll need is your directory structure and install manifest.
Custom XUL Elements with XBL - Archive of obsolete content
Archive › Add-ons › Overlay Extensions › XUL School › Custom XUL Elements with XBL
if you use bindings on toolbar elements, remember to include the css file in the customize dialog, using the style directive in the chrome.manifest file.
Getting Started with Firefox Extensions - Archive of obsolete content
Archive › Add-ons › Overlay Extensions › XUL School › Getting Started with Firefox Extensions
you should see the following directory structure: xulschoolhello1 chrome.manifest install.rdf content browseroverlay.xul browseroverlay.js skin browseroverlay.css locale en-us browseroverlay.dtd browseroverlay.properties that's lots of files for something so simple!
JavaScript Object Management - Archive of obsolete content
Archive › Add-ons › Overlay Extensions › XUL School › JavaScript Object Management
the first thing you need to do is add an entry in the chrome.manifest file: resource xulschoolhello modules/ javascript code modules are accessed with the resource protocol, which is very similar to the chrome protocol.
Extensions support in SeaMonkey 2 - Archive of obsolete content
Archive › Add-ons › SeaMonkey 2
in manifest file seamonkey uses different overlays than other applications.
Signing an extension - Archive of obsolete content
Archive › Add-ons › Signing an extension
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.
Add-ons - Archive of obsolete content
Archive › Add-ons
install manifests an install manifest is the file an add-on manager-enabled xul application (e.g.
Adding preferences to an extension - Archive of obsolete content
Archive › Adding preferences to an extension
get the code here: download the sample update the manifests the install manifest and chrome manifest need to be updated.
cached - Archive of obsolete content
Archive › Events › cached
the cached event is fired when the resources listed in the application cache manifest have been downloaded, and the application is now cached.
checking - Archive of obsolete content
Archive › Events › checking
the checking event is fired when the user agent is checking for an update, or attempting to download the cache manifest for the first time.
downloading - Archive of obsolete content
Archive › Events › downloading
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.
error - Archive of obsolete content
Archive › Events › error (appcache event)
the error event is fired when an error occurred while downloading the cache manifest or updating the content of the application.
noupdate - Archive of obsolete content
Archive › Events › noupdate
the noupdate event is fired after checking for an application cache update, if the manifest hasn't changed.
obsolete - Archive of obsolete content
Archive › Events › obsolete
the obsolete event is fired when the manifest was found to have become a 404 or 410 page, so the application cache is being deleted.
progress - Archive of obsolete content
Archive › Events › progress
the progress event is fired when the user agent is downloading resources listed by the manifest.
updateready - Archive of obsolete content
Archive › Events › updateready
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.
Install.js - Archive of obsolete content
Archive › Install.js
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
MCD, Mission Control Desktop, AKA AutoConfig - Archive of obsolete content
Archive › Misc top level › MCD, Mission Control Desktop AKA AutoConfig
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
Archive › Mozilla › Automated testing tips and tricks
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...
Making a Mozilla installation modifiable - Archive of obsolete content
Archive › Mozilla › Creating a Mozilla extension › Making a Mozilla installation modifiable
the files are then collected into a series of jar archives, which are just zip files that contain a specially formatted "manifest" file which describes the contents of the archive so mozilla knows what to do with them.
install.rdf - Archive of obsolete content
Archive › Mozilla › Creating a Skin for SeaMonkey 2.x › install.rdf
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
Archive › Mozilla › Jetpack › Extenders
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 ...
Migrate apps from Internet Explorer to Mozilla - Archive of obsolete content
Archive › Mozilla › Migrate apps from Internet Explorer to Mozilla
it usually manifests itself by changing text style when hovered over in mozilla, but not in internet explorer.
Mozilla Application Framework in Detail - Archive of obsolete content
Archive › Mozilla › Mozilla Application Framework › Mozilla Application Framework in Detail
related: xulrunner:what xulrunner provides, xulrunner hall of fame ui in mozilla mozilla's philosophy of using "the right tool for the right job" is manifested most prominently in the design of the user interface.
Extensions - Archive of obsolete content
Archive › Mozilla › Prism › Extensions
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
Archive › Mozilla › XPInstall › Creating XPI installer modules
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.
Mac stub installer - Archive of obsolete content
Archive › Mozilla › XPInstall › Install wizards › Mac stub installer
adding a package involves a few steps: add a section named for your <component> to the packages-mac manifest that describes which files from dist belong to which module.
Unix stub installer - Archive of obsolete content
Archive › Mozilla › XPInstall › Install wizards › Unix stub installer
adding a package involves a few steps: add a section named for your <component> to the packages-unix manifest that describes which files from dist belong to which module.
Windows stub installer - Archive of obsolete content
Archive › Mozilla › XPInstall › Install wizards › Windows stub installer
adding a package involves a few steps: add a section named for your <component> to the packages-win manifest that describes which files from dist belong to which module.
Using XPInstall to Install Plugins - Archive of obsolete content
Archive › Mozilla › XPInstall › Installing plugins
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
Methods - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › File Object › Methods
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
File Object - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › File Object
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
InstallVersion Object - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › InstallVersion Object
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
registerChrome - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › Install Object › Methods › registerChrome
in this case, registerchrome is supporting the old format of installation archives, in which the manifest.rdf file was always located at the highest level of the installation archive.
Methods - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › Install Object › Methods
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
Properties - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › Install Object › Properties
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
Install Object - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › Install Object
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
Methods - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › WinProfile Object › Methods
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
WinProfile Object - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › WinProfile Object
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
Methods - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › WinReg Object › Methods
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
WinReg Object - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference › WinReg Object
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
XPInstall API reference - Archive of obsolete content
Archive › Mozilla › XPInstall › Reference
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
Index - Archive of obsolete content
Archive › Mozilla › XUL › Index
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
Archive › Mozilla › XUL › Providing Command-Line Options
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...
Adding Style Sheets - Archive of obsolete content
Archive › Mozilla › XUL › Tutorial › Adding Style Sheets
for installed files, you'll have to create or modify a manifest file and install the skin.
Creating a Window - Archive of obsolete content
Archive › Mozilla › XUL › Tutorial › Creating a Window
create a file called findfile.xul and put it in the content directory specified in the findfile.manifest file (we've created in the previous section).
Creating an Installer - Archive of obsolete content
Archive › Mozilla › XUL › Tutorial › Creating an Installer
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
Localization - Archive of obsolete content
Archive › Mozilla › XUL › Tutorial › Localization
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".
Templates - Archive of obsolete content
Archive › Mozilla › XUL › Tutorial › Templates
to view this example, you will need to create a chrome package and load the file from there (you can do this easily, see manifest files).
XUL Tutorial - Archive of obsolete content
Archive › Mozilla › XUL › Tutorial
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...
Using Visual Studio as your XUL IDE - Archive of obsolete content
Archive › Mozilla › XUL › Using Visual Studio as your XUL IDE
there is also project that provides xml schema for install manifest files (install.rdf) - installrdfschema.codeplex.com - from the same author as a xul schema.
CommandLine - Archive of obsolete content
Archive › Mozilla › XULRunner › CommandLine
example notice the changes since gecko 2.0 (component registration has moved into the manifest file).
Custom app bundles for Mac OS X - Archive of obsolete content
Archive › Mozilla › XULRunner › Creating custom app bundles for Mac OS X
(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
Archive › Mozilla › XULRunner › Debugging XULRunner applications
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...
Mozprofile - Archive of obsolete content
Archive › Mozilla › mozprofile
installing addons addons may be installed individually or from a manifest.
nsIContentPolicy - Archive of obsolete content
Archive › Mozilla › nsIContentPolicy
type_web_manifest 22 indicates a request to load a web manifest.
2006-10-20 - Archive of obsolete content
Archive › Newsgroup summaries › mozilla-dev-builds › 2006-10-20
benjamin smedberg mentioned in his post that jan vávra needs to add the extension files to the packaging manifest, which is used to create the installer.
install.rdf - Archive of obsolete content
Archive › Themes › Creating a Skin for Firefox › install.rdf
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.
Index - MDN Web Docs Glossary: Definitions of Web-related terms
Glossary › Index
20 application context codingscripting, glossary an application context is a top-level browsing context that has a manifest applied to it.
Application Context - MDN Web Docs Glossary: Definitions of Web-related terms
Glossary › application context
an application context is a top-level browsing context that has a manifest applied to it.
General asynchronous programming concepts - Learn web development
Learn › JavaScript › Asynchronous › Concepts
objective: to understand the basic concepts behind asynchronous programming, and how they manifest in web browsers and javascript.
Getting started with React - Learn web development
Learn › Tools and testing › Client-side JavaScript frameworks › React getting started
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
Mozilla › API › ChromeWorkers › 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
Mozilla › Add-ons › Themes
tools & resources browser theme manifest.json keys browser extensions theme api discourse forum theme related blog posts archived resources ...
bookmarks
Mozilla › Add-ons › WebExtensions › API › bookmarks
to use this api, an extension must request the "bookmarks" permission in its manifest.json file.
browserAction.setPopup()
Mozilla › Add-ons › WebExtensions › API › browserAction › setPopup
tabs without a specific popup will inherit the global popup, which defaults to the default_popup specified in the manifest.
browserAction
Mozilla › Add-ons › WebExtensions › API › browserAction
you can define most of a browser action's properties declaratively using the browser_action key in the manifest.json.
Command
Mozilla › Add-ons › WebExtensions › API › commands › Command
this contains the information specified for the command in the commands manifest.json key.
getAll()
Mozilla › Add-ons › WebExtensions › API › commands › getAll
gets all commands for the extension that you have registered using the commands manifest.json key.
commands.reset()
Mozilla › Add-ons › WebExtensions › API › commands › reset
resets the given command's description and keyboard shortcut to the values given in the extension's commands manifest.json key.
commands.update()
Mozilla › Add-ons › WebExtensions › API › commands › update
a string matching the format of the commands manifest.json key to set a new shortcut key.
contentScripts
Mozilla › Add-ons › WebExtensions › API › contentScripts
this api is very similar to the "content_scripts" manifest.json key, except that with "content_scripts" , the set of content scripts and associated patterns is fixed at install time.
contextualIdentities
Mozilla › Add-ons › WebExtensions › API › contextualIdentities
to use this api you need to include the "contextualidentities" and "cookies" permissions in your manifest.json file.
cookies.get()
Mozilla › Add-ons › WebExtensions › API › cookies › get
if host permissions for this url are not specified in the extension's manifest file, the api call will fail.
cookies.remove()
Mozilla › Add-ons › WebExtensions › API › cookies › remove
the call succeeds only if you include the "cookies" api permission in your manifest.json file, as well as host permissions for the given url specified in its manifest.
devtools.inspectedWindow
Mozilla › Add-ons › WebExtensions › API › devtools.inspectedWindow
like all the devtools apis, this api is only available to code running in the document defined in the devtools_page manifest.json key, or in other devtools documents created by the extension (such as the document hosted by a panel the extension created).
devtools.network
Mozilla › Add-ons › WebExtensions › API › devtools.network
like all the devtools apis, this api is only available to code running in the document defined in the devtools_page manifest.json key, or in other devtools documents created by the extension (such as the panel's own document).
devtools.panels
Mozilla › Add-ons › WebExtensions › API › devtools.panels
like all the devtools apis, this api is only available to code running in the document defined in the devtools_page manifest.json key, or in other devtools documents created by the extension (such as the panel's own document).
devtools
Mozilla › Add-ons › WebExtensions › API › devtools
to use this api you need to have the "devtools" api permission specified in your manifest.json file.
dns
Mozilla › Add-ons › WebExtensions › API › dns
to use this api, an extension must request the "dns" permission in its manifest.json file.
downloads.open()
Mozilla › Add-ons › WebExtensions › API › downloads › open
to use this function in your extension you must ask for the "downloads.open" manifest permission, as well as the "downloads" permission.
downloads.setShelfEnabled()
Mozilla › Add-ons › WebExtensions › API › downloads › setShelfEnabled
note: to use this function in your extension you must ask for the "downloads.shelf" manifest permission, as well as the "downloads" permission.
downloads
Mozilla › Add-ons › WebExtensions › API › downloads
to use this api you need to have the "downloads" api permission specified in your manifest.json file.
history
Mozilla › Add-ons › WebExtensions › API › history
to use this api, an extension must request the "history" permission in its manifest.json file.
management.install()
Mozilla › Add-ons › WebExtensions › API › management › install
return value a promise that will be fulfilled with an object, containing the extensionid defined for the theme in manifest.json.
menus.ContextType
Mozilla › Add-ons › WebExtensions › API › menus › ContextType
requires the "bookmarks" api permission in the manifest.
menus.create()
Mozilla › Add-ons › WebExtensions › API › menus › create
to avoid any scaling, you can specify icons like this: "icons": { "16": "path/to/geo-16.png", "32": "path/to/geo-32.png" } alternatively, you can specify a single svg icon, and it will be scaled appropriately: "icons": { "16": "path/to/geo.svg" } note: the top-level menu item uses the icons specified in the manifest rather than what is specified with this key.
createProperties
Mozilla › Add-ons › WebExtensions › API › menus › createProperties
to avoid any scaling, you can specify icons like this: "icons": { "16": "path/to/geo-16.png", "32": "path/to/geo-32.png" } alternatively, you can specify a single svg icon, and it will be scaled appropriately: "icons": { "16": "path/to/geo.svg" } note: the top-level menu item uses the icons specified in the manifest rather than what is specified with this key.
menus
Mozilla › Add-ons › WebExtensions › API › menus
for example, here's an extension called "menu demo" that's added two context menu items: icons if you've specified icons for your extension using the "icons" manifest key, your menu item will display the specified icon next to its label.
omnibox
Mozilla › Add-ons › WebExtensions › API › omnibox
it works as follows: first, the extension must include an "omnibox" key in its manifest.json file, which defines a keyword.
pageAction.setPopup()
Mozilla › Add-ons › WebExtensions › API › pageAction › setPopup
if null is passed here, the popup is reset to the popup that was specified in the page_action manifest key.
pageAction.setTitle()
Mozilla › Add-ons › WebExtensions › API › pageAction › setTitle
if null is passed here, the title is reset to the title that was specified in the page_action manifest key.
pageAction
Mozilla › Add-ons › WebExtensions › API › pageAction
you can define most of a page action's properties declaratively using the page_action key in your manifest.json, but can also redefine them programmatically using this api.
permissions.remove()
Mozilla › Add-ons › WebExtensions › API › permissions › remove
permissions must come from the set of permissions defined in the optional_permissions manifest.json key.
permissions.request()
Mozilla › Add-ons › WebExtensions › API › permissions › request
permissions must come from the set of permissions defined in the optional_permissions manifest.json key.
pkcs11.getModuleSlots()
Mozilla › Add-ons › WebExtensions › API › pkcs11 › getModuleSlots
this must match the name property in the pkcs #11 manifest for the module.
pkcs11.installModule()
Mozilla › Add-ons › WebExtensions › API › pkcs11 › installModule
this must match the name property in the pkcs #11 manifest for the module.
pkcs11.uninstallModule()
Mozilla › Add-ons › WebExtensions › API › pkcs11 › uninstallModule
this must match the name property in the pkcs #11 manifest for the module.
proxy.register()
Mozilla › Add-ons › WebExtensions › API › proxy › register
pac files must be bundled with the extension, and url must be relative to the extension's manifest.json file.
runtime.MessageSender
Mozilla › Add-ons › WebExtensions › API › runtime › MessageSender
if the sender set an id explicitly using the applications key in manifest.json, then id will have this value.
runtime.connect()
Mozilla › Add-ons › WebExtensions › API › runtime › connect
if the target has set an id explicitly using the applications key in manifest.json, then extensionid should have that value.
runtime.connectNative()
Mozilla › Add-ons › WebExtensions › API › runtime › connectNative
this must match the "name" property in the native application's manifest file.
runtime.getBackgroundPage()
Mozilla › Add-ons › WebExtensions › API › runtime › getBackgroundPage
in chrome, this method is available only with persistent background pages, which are not available in manifest v3, so consider using manifest v2.
runtime.id
Mozilla › Add-ons › WebExtensions › API › runtime › id
if the extension specifies an id in its browser_specific_settings manifest.json key, runtime.id contains that value.
runtime.sendMessage()
Mozilla › Add-ons › WebExtensions › API › runtime › sendMessage
if the intended recipient has set an id explicitly using the applications key in manifest.json, then extensionid should have that value.
runtime.sendNativeMessage()
Mozilla › Add-ons › WebExtensions › API › runtime › sendNativeMessage
this must match the "name" property in the native application's manifest file.
search.search()
Mozilla › Add-ons › WebExtensions › API › search › search
to use this function in your extension you must ask for the "search" manifest permission.
sidebarAction
Mozilla › Add-ons › WebExtensions › API › sidebarAction
using the sidebar_action manifest.json key, an extension can define its own sidebar.
storage.sync
Mozilla › Add-ons › WebExtensions › API › storage › sync
if you use storage.sync, you must set an id for your extension using the browser_specific_settings manifest.json key.
storage
Mozilla › Add-ons › WebExtensions › API › storage
to use this api you need to include the "storage" permission in your manifest.json file.
tabs.create()
Mozilla › Add-ons › WebExtensions › API › tabs › create
to load a page that's packaged with your extension, specify an absolute url starting at the extension's manifest.json file.
tabs.sendMessage()
Mozilla › Add-ons › WebExtensions › API › tabs › sendMessage
whether the content script is executed in all frames depends on the all_frames setting in the content_scripts section of manifest.json.
tabs.update()
Mozilla › Add-ons › WebExtensions › API › tabs › update
to load a page that's packaged with your extension, specify an absolute url starting at the extension's manifest.json file.
Theme
Mozilla › Add-ons › WebExtensions › API › theme › Theme
type a json object that takes the same properties as the "theme" manifest key.
UserScripts.UserScriptOptions
Mozilla › Add-ons › WebExtensions › API › userScripts › UserScriptOptions
each object has either a property named file, which is a url starting at the extension's manifest.json and pointing to a javascript file to register, or a property named code, which is some javascript code to register.
webRequest.BlockingResponse
Mozilla › Add-ons › WebExtensions › API › webRequest › BlockingResponse
https) url to an extension page, the extension's manifest.json file must contain a web_accessible_resources key that lists the url for the extension page..
webRequest.ResourceType
Mozilla › Add-ons › WebExtensions › API › webRequest › ResourceType
web_manifest web app manifests loaded for websites that can be installed to the homescreen.
webRequest.onAuthRequired
Mozilla › Add-ons › WebExtensions › API › webRequest › onAuthRequired
if you use "blocking" you must have the "webrequestblocking" api permission in your manifest.json.
webRequest.onBeforeSendHeaders
Mozilla › Add-ons › WebExtensions › API › webRequest › onBeforeSendHeaders
if you use "blocking", you must have the "webrequestblocking" api permission in your manifest.json.
webRequest.onHeadersReceived
Mozilla › Add-ons › WebExtensions › API › webRequest › onHeadersReceived
if you use "blocking", you must have the "webrequestblocking" api permission in your manifest.json.
windows.get()
Mozilla › Add-ons › WebExtensions › API › windows › get
the tab objects only contain the url, title and faviconurl properties if the extension's manifest file includes the "tabs" permission.
windows.getAll()
Mozilla › Add-ons › WebExtensions › API › windows › getAll
the tab objects will contain the url, title and faviconurl properties only if the extension's manifest file includes the "tabs" permission.
windows.getCurrent()
Mozilla › Add-ons › WebExtensions › API › windows › getCurrent
the tab objects only contain the url, title and faviconurl properties if the extension's manifest file includes the "tabs" permission.
windows.getLastFocused()
Mozilla › Add-ons › WebExtensions › API › windows › getLastFocused
the tab objects only contain the url, title and faviconurl properties if the extension's manifest file includes the "tabs" permission.
Browser actions
Mozilla › Add-ons › WebExtensions › Browser actions
specifying the browser action you define the browser action's properties - icon, title, popup - using the browser_action key in manifest.json: "browser_action": { "default_icon": { "19": "button/geo-19.png", "38": "button/geo-38.png" }, "default_title": "whereami?", "default_popup": "popup/geo.html" } the only mandatory key is default_icon.
Developing WebExtensions for Thunderbird
Mozilla › Add-ons › WebExtensions › Developing WebExtensions for Thunderbird
being both gecko based, thunderbird supports many of the apis firefox supports, with some differences, see browser compatibility for manifest.json and browser support for javascript apis for details.
Interact with the clipboard
Mozilla › Add-ons › WebExtensions › Interact with the clipboard
using the api requires that you have the permission "clipboardread" or "clipboardwrite" in your manifest.json file.
What next?
Mozilla › Add-ons › WebExtensions › What next
a full reference guide to the manifest keys.
Work with the Cookies API
Mozilla › Add-ons › WebExtensions › Work with the Cookies API
manifest.json the key feature of the manifest.json file relating to the use of the cookies api is the permissions request: "permissions": [ "tabs", "cookies", "<all_urls>" ], here, the extension requests permission to use the cookies api ("cookies") with all websites ("<all_urls>").
commands
Mozilla › Add-ons › WebExtensions › manifest.json › commands
once you've defined commands in your extension's manifest.json, you can listen for their associated key combinations with the commands javascript api.
content_security_policy
Mozilla › Add-ons › WebExtensions › manifest.json › content security policy
you can use the "content_security_policy" manifest key to loosen or tighten the default policy.
icons
Mozilla › Add-ons › WebExtensions › manifest.json › icons
e.g.: <svg xmlns="http://www.w3.org/2000/svg" viewbox="0 0 48 48" width="48" height="48"> <!-- your svg content --> </svg> even though you can use one file, you still need to specify various size of the icon in your manifest.
options_page
Mozilla › Add-ons › WebExtensions › manifest.json › options page
type string mandatory no example "options_page": "options/options.html" this manifest key has been deprecated.
options_ui
Mozilla › Add-ons › WebExtensions › manifest.json › options ui
the path is relative to the location of manifest.json itself.
short_name
Mozilla › Add-ons › WebExtensions › manifest.json › short name
if the short name field is not included in manifest.json, then name will be used instead and may be truncated.
sidebar_action
Mozilla › Add-ons › WebExtensions › manifest.json › sidebar action
icons are specified as urls relative to the manifest.json file itself.
theme
Mozilla › Add-ons › WebExtensions › manifest.json › theme
optional images all urls are relative to the manifest.json file and cannot reference an external url.
theme_experiment
Mozilla › Add-ons › WebExtensions › manifest.json › theme experiment
in the manifest.json file, --reload-button-color is then mapped to the name to be used in the theme colors property: "theme_experiment": { "stylesheet": "style.css", "colors": { "reload_button": "--reload-button-color" } } the argument reload_button is used in the same way as any other theme property: "theme": { "colors": { "reload_button": "orange" } } this has the effect of maki...
user_scripts
Mozilla › Add-ons › WebExtensions › manifest.json › user scripts
the api script path, relative to the manifest.json file, is defined as a string in "api_script".
version
Mozilla › Add-ons › WebExtensions › manifest.json › version
note that the syntax defined for chrome's version is more restrictive than that used by firefox: values for version that are valid for chrome will always be valid for firefox values for version that are valid for firefox may not be valid for chrome to obtain your extension version in your javascript code, use: console.log(browser.runtime.getmanifest().version); example if the manifest contains: "version": "0.1" to obtain your extension version in your javascript code, use: console.log(browser.runtime.getmanifest().version); // expected output: "0.1" ...
Toolbar button
Mozilla › Add-ons › WebExtensions › user interface › Browser action
specifying the browser action you define the browser action's properties using the browser_action key in manifest.json: "browser_action": { "default_icon": { "19": "button/geo-19.png", "38": "button/geo-38.png" }, "default_title": "whereami?" } the only mandatory key is default_icon.
Context menu items
Mozilla › Add-ons › WebExtensions › user interface › Context menu items
however, you need to request the contextmenus permission in your manifest.json to be able to take advantage of the api.
Notifications
Mozilla › Add-ons › WebExtensions › user interface › Notifications
to use this api you must request the notifications permission in your manifest.json: "permissions": ["notifications"] you then use notifications.create to create your notifications, as in this example from notify-link-clicks-i18n: var title = browser.i18n.getmessage("notificationtitle"); var content = browser.i18n.getmessage("notificationcontent", message.url); browser.notifications.create({ "type": "basic", "iconurl": browser.extension.geturl("icons/link-48.png"), ...
Address bar suggestions
Mozilla › Add-ons › WebExtensions › user interface › Omnibox
specifying the omnibox customization you tell your extension that it is going to customize the address bar suggestions by including the omnibox key and definition of the trigger keyword in its manifest.json file: "omnibox": { "keyword" : "cs" } in the extension's background javascript file, using omnibox.setdefaultsuggestion(), you can optionally define the first suggestion to be displayed in the address bar drop-down.
Options page
Mozilla › Add-ons › WebExtensions › user interface › Options pages
you also need to include the options_ui key in your manifest.json file, giving it the url to the page.
devtools panels
Mozilla › Add-ons › WebExtensions › user interface › devtools panels
add the devtools page by including the devtools_page key in extension's manifest.json and provide the location of the page's html file in the extension: "devtools_page": "devtools-page.html" from the devtools page, call a script that will add the devtools panel: <body> <script src="devtools.js"></script> </body> in the script, create the devtools panel by specifying the panel's title, icon, and html file that provides the panel's content: function handleshown() { con...
Android-specific test suites
Mozilla › Android-specific test suites
disabling one failing test there is no manifest listing the android local unit tests.
Browser chrome tests
Mozilla › 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 Firefox sidebar
Mozilla › Creating a Firefox sidebar
since firefox 57, the only way to create a firefox sidebar is to create a webextension with the sidebar_action manifest.json key.
Creating a spell check dictionary add-on
Mozilla › 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
Mozilla › Developer guide › Build Instructions › 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
Mozilla › Developer guide › Build Instructions › 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
Mozilla › Developer guide › Build Instructions › 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
Mozilla › Developer guide › 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.
Index
Mozilla › Firefox › Index
you may add references to both these files in chrome.manifest for compatibility.
Limitations of chrome scripts
Mozilla › Firefox › Multiprocess Firefox › 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
Mozilla › Firefox › Multiprocess Firefox › Message Manager › 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...
Pitfalls for add-on developers
Mozilla › Firefox › Multiprocess Firefox › Pitfalls for add-on developers
you'll get the shims for your add-on by default, unless you set the multiprocesscompatible flag in your add-on's install manifest.
Which URIs load where
Mozilla › Firefox › Multiprocess Firefox › Which URIs load where
two new flags are defined in the chrome.manifest file: remoteenabled: the page will be loaded in the same process as the browser that has loaded it.
mozbrowseractivitydone
Mozilla › Gecko › Chrome › API › Browser API › 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
Mozilla › Gecko › 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
Mozilla › 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
Mozilla › 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
Mozilla › JavaScript code modules › CustomizableUI.jsm
to avoid that, update your chrome manifest file with links to two different versions of xul overlay, using manifest flags.
L10n Checks
Mozilla › Localization › 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
Mozilla › Localization › 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
Mozilla › Localization › Quick start guide › 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
Mozilla › Localization › Uplifting
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...
Writing localizable code
Mozilla › Localization › Writing localizable code
jar manifests can make this easy.
MathML In Action
Mozilla › MathML Project › Start
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
Mozilla › Mozilla DOM Hacking
for us, it is: 1225 dom_classinfo_map_entry(nsidomhtmldomimplementation) add the new interface to the makefiles, manifests, etc.
Gecko Profiler FAQ
Mozilla › Performance › 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
Mozilla › Performance › 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.
Profiling with the Firefox Profiler
Mozilla › Performance › Profiling with the Built-in Profiler
factors such as sampling or stack-walking variance and system load can lead to sampling delays which manifest as gaps in the timeline.
Reporting a Performance Problem
Mozilla › Performance › Reporting a Performance Problem
if possible let the problem manifest itself for 5-10 seconds.
NSS_3.12_release_notes.html
Mozilla › Projects › NSS › 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
Mozilla › Projects › NSS › 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
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
Mozilla › Tech › XPCOM › Guide › Building components 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
Mozilla › Tech › XPCOM › Guide › Creating components › 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
Mozilla › Tech › XPCOM › Guide › Creating 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...
Introduction to XPCOM for the DOM
Mozilla › Tech › XPCOM › Introduction to XPCOM for the DOM
this includes, if needed, "manifest", "makefile.win", "makefile.in", etc...
nsIComponentRegistrar
Mozilla › Tech › XPCOM › Reference › Interface › 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.
nsIMsgAccountManagerExtension
Mozilla › Tech › XPCOM › Reference › Interface › nsIMsgAccountManagerExtension
the interface is basically a manifest and defines the properties of the new panel.
Building a Thunderbird extension 1: introduction
Mozilla › Thunderbird › Thunderbird extensions › Building a Thunderbird extension
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
Mozilla › Thunderbird › Thunderbird extensions › 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
Mozilla › 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.
Firefox Developer Tools
Tools
this includes inspection of service workers and web app manifests.
Managing screen orientation - Web APIs
Web › API › CSS Object Model › Managing screen orientation
firefox os and android: orientation lock using the manifest for a firefox os and firefox android (soon to work on firefox desktop too) specific way to lock orientation, you can set the orientation field in app's your manifest file, for example: "orientation": "portrait" ...
Geolocation API - Web APIs
Web › API › Geolocation API
webextensions that wish to use the geolocation object must add the "geolocation" permission to their manifest.
compareVersion - Web APIs
Web › API › InstallTrigger › compareVersion
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
getVersion - Web APIs
Web › API › InstallTrigger › getVersion
extension, theme, and plug-in developers must switch away from install.js based packages to the new packaging scheme with an install.rdf manifest.
installChrome - Web APIs
Web › API › InstallTrigger › installChrome
url url is a string containing a full or relative url to download name name is displayed in the dialog, but is also used to *select* the theme somust match exactly the name in the internal manifest.rdf file.
Transcoding assets for Media Source Extensions - Web APIs
Web › API › Media Source Extensions API › Transcoding assets for MSE
most dash clients expect a corresponding media presentation description (mpd) manifest file, which is typically generated while generating the multiple resolution asset files.
Navigator.getUserMedia() - Web APIs
Web › API › Navigator › getUserMedia
.onloadedmetadata = function(e) { video.play(); }; }, function(err) { console.log("the following error occurred: " + err.name); } ); } else { console.log("getusermedia not supported"); } permissions to use getusermedia() in an installable app (for example, a firefox os app), you need to specify one or both of the following fields inside your manifest file: "permissions": { "audio-capture": { "description": "required to capture audio using getusermedia()" }, "video-capture": { "description": "required to capture video using getusermedia()" } } see permission: audio-capture and permission: video-capture for more information.
Push API - Web APIs
Web › API › Push API
it also requires an app manifest, with some special parameters to use this service.
Request.destination - Web APIs
Web › API › Request › destination
this type is much broader than the usual document type values (such as "document" or "manifest"), and may include contextual cues such as "image" or "worker" or "audioworklet".
RequestDestination - Web APIs
Web › API › RequestDestination
"manifest" the target is a manifest.
Window: appinstalled event - Web APIs
Web › API › Window › appinstalled event
the appinstalled event of the web manifest api is fired when the browser has successfully installed a page as an application.
Window - Web APIs
Web › API › Window
manifest events appinstalled fired when the browser has successfully installed a page as an application.
Synchronous and asynchronous requests - Web APIs
Web › API › XMLHttpRequest › Synchronous and Asynchronous Requests
but developers typically don't notice the problem because the hang only manifests with poor network conditions or when the remote server is slow to respond.
@media - CSS: Cascading Style Sheets
Web › CSS › @media
display-mode the display mode of the application, as specified in the web app manifest's display member defined in the web app manifest spec.
Using media queries - CSS: Cascading Style Sheets
Web › CSS › Media Queries › Using media queries
display-mode the display mode of the application, as specified in the web app manifest's display member defined in the web app manifest spec.
content - CSS: Cascading Style Sheets
Web › CSS › content
</p> <h1>6</h1> <p>according to the mozilla manifesto, <q cite="http://www.mozilla.org/about/manifesto/">individuals must have the ability to shape the internet and their own experiences on the internet.</q> therefore, we can infer that contributing to the open web can protect our own individual experiences on it.
Link types - HTML: Hypertext Markup Language
Web › HTML › Link types
manifest indicates that the linked file is a web app manifest.
Index - HTTP
Web › HTTP › Headers › Index
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
Web › HTTP › Headers
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
Web › HTTP › Index
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
Web › JavaScript › Equality comparisons and sameness
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.
Using Promises - JavaScript
Web › JavaScript › Guide › Using promises
several of these mistakes manifest in the following example: // bad example!
Installing and uninstalling web apps - Progressive web apps (PWAs)
Web › Progressive web apps › Developer guide › Installing
the application itself may then manifest as in a chromeless view (without the full browser chrome) but it nevertheless is executing effectively as a tab within the browser.
Progressive loading - Progressive web apps (PWAs)
Web › Progressive web apps › Loading
previous overview: progressive web apps in previous articles we covered apis that help us make our js13kpwa example a progressive web app: service workers, web manifests, notifications and push.
The building blocks of responsive design - Progressive web apps (PWAs)
Web › Progressive web apps › Responsive › responsive design building blocks
if you are working on an installed app, you can easily do this with the orientation manifest field.
Web technology for developers
Web
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 referencewebdriverxml: extensible markup languagexpathxslt: extensible stylesheet language transformations ...