1 // Always have this as the first line of your file. Google for an explanation.
   2 'use strict';
   3 
   4 // This is a handy import we'll use to grab our extension's object
   5 const ExtensionUtils = imports.misc.extensionUtils;
   6 const Me = ExtensionUtils.getCurrentExtension();
   7 
   8 // Like `init()` below, code *here* in the top-level of your script is executed
   9 // when your extension is loaded. You MUST NOT make any changes to GNOME Shell
  10 // here and typically you should do nothing but assign variables.
  11 const SOME_CONSTANT = 42;
  12 
  13 
  14 // This function is called once when your extension is loaded, not enabled. This
  15 // is a good time to setup translations or anything else you only do once.
  16 //
  17 // You MUST NOT make any changes to GNOME Shell, connect any signals or add any
  18 // MainLoop sources here.
  19 function init() {
  20     log(`initializing ${Me.metadata.name} version ${Me.metadata.version}`);
  21 }
  22 
  23 // This function could be called after your extension is enabled, which could
  24 // be done from GNOME Tweaks, when you log in or when the screen is unlocked.
  25 //
  26 // This is when you setup any UI for your extension, change existing widgets,
  27 // connect signals or modify GNOME Shell's behaviour.
  28 function enable() {
  29     log(`enabling ${Me.metadata.name} version ${Me.metadata.version}`);
  30 }
  31 
  32 // This function could be called after your extension is uninstalled, disabled
  33 // in GNOME Tweaks, when you log out or when the screen locks.
  34 //
  35 // Anything you created, modifed or setup in enable() MUST be undone here. Not
  36 // doing so is the most common reason extensions are rejected during review!
  37 function disable() {
  38     log(`disabling ${Me.metadata.name} version ${Me.metadata.version}`);
  39 }

   1 'use strict';
   2 
   3 const GLib = imports.gi.GLib;
   4 const Gtk = imports.gi.Gtk;
   5 
   6 // It's common practice to keep GNOME API and JS imports in separate blocks
   7 const ExtensionUtils = imports.misc.extensionUtils;
   8 const Me = ExtensionUtils.getCurrentExtension();
   9 
  10 
  11 // Like `extension.js` this is used for any one-time setup like translations.
  12 function init() {
  13     log(`initializing ${Me.metadata.name} Preferences`);
  14 }
  15 
  16 
  17 // This function is called when the preferences window is first created to build
  18 // and return a Gtk widget. As an example we'll create and return a GtkLabel.
  19 function buildPrefsWidget() {
  20     // This could be any GtkWidget subclass, although usually you would choose
  21     // something like a GtkGrid, GtkBox or GtkNotebook
  22     let prefsWidget = new Gtk.Label({
  23         label: `${Me.metadata.name} version ${Me.metadata.version}`,
  24         visible: true
  25     });
  26 
  27     // At the time buildPrefsWidget() is called, the window is not yet prepared
  28     // so if you want to access the headerbar you need to use a small trick
  29     GLib.timeout_add(0, () => {
  30         let window = prefsWidget.get_toplevel();
  31         let headerBar = window.get_titlebar();
  32         headerBar.title = `${Me.metadata.name} Preferences`;
  33     });
  34 
  35     return prefsWidget;
  36 }

   1 // A standard StLabel
   2 let label = new St.Label({
   3     text: 'LabelText',
   4     style_class: 'example-style'
   5 });
   6 
   7 // An StLabel subclass with `CssName` set to "ExampleLabel"
   8 var ExampleLabel = GObject.registerClass({
   9     GTypeName: 'ExampleLabel',
  10     CssName: 'ExampleLabel'
  11 }, class ExampleLabel extends St.Label {
  12 });
  13 
  14 let exampleLabel = new ExampleLabel({
  15     text: 'Label Text'
  16 });

   1 'use strict';
   2 
   3 // Any imports this extension needs itself must also be imported here
   4 const ExtensionUtils = imports.misc.extensionUtils;
   5 const Me = ExtensionUtils.getCurrentExtension();
   6 
   7 // Mose importantly, variables declared with `let` or `const` are not exported
   8 const LOCAL_CONSTANT = 42;
   9 let localVariable = 'a value';
  10 
  11 // This includes function expressions and classes declared with `class`
  12 let _privateFunction = function() {};
  13 
  14 // TIP: Private members are often prefixed with `_` in JavaScript, which is clue
  15 // to other developers that these should only be used internally and may change
  16 class _PrivateClass {
  17     constructor() {
  18         this._initted = true;
  19     }
  20 }
  21 
  22 
  23 // Function declarations WILL be available as properties of the module
  24 function exportedFunction(a, b) {
  25     return a + b;
  26 }
  27 
  28 // Use `var` to assign any other members you want available as part the module
  29 var EXPORTED_VARIABLE = 42;
  30 
  31 var exportedFunction2 = function(...args) {
  32     return exportedFunction(...args);
  33 }
  34 
  35 var ExportedClass = class ExportedClass extends _PrivateClass {
  36     construct(params) {
  37         super();
  38 
  39         Object.assign(this, params);
  40     }
  41 };

   1 // GJS's Built-in Modules are in the top-level
   2 // See: https://gitlab.gnome.org/GNOME/gjs/wikis/Modules
   3 const Gettext = imports.gettext;
   4 const Cairo = imports.cairo;
   5 
   6 // GNOME APIs are under the `gi` namespace (except Cairo)
   7 // See: http://devdocs.baznga.org/
   8 const GLib = imports.gi.GLib;
   9 const Gtk = imports.gi.Gtk;
  10 
  11 // GNOME Shell imports
  12 const Main = imports.ui.main;
  13 const ExtensionUtils = imports.misc.extensionUtils;
  14 const Me = ExtensionUtils.getCurrentExtension();
  15 
  16 // You can import your modules using the extension object we imported as `Me`.
  17 const ExampleLib = Me.imports.exampleLib;
  18 
  19 let myObject = new ExampleLib.ExportedClass();
  20 ExampleLib.exportedFunction(0, ExampleLib.EXPORTED_VARIABLE);

   1 const ExtensionUtils = imports.misc.extensionUtils;
   2 const ModalDialog = imports.ui.modalDialog;
   3 const PanelMenu = imports.ui.panelMenu;
   4 const PopupMenu = imports.ui.popupMenu;

   1 // Log a string, usually to `journalctl`
   2 log('a message');
   3 
   4 // Log an Error() with a stack trace and optional prefix
   5 try {
   6     throw new Error('An error occurred');
   7 } catch (e) {
   8     logError(e, 'ExtensionError');
   9 }
  10 
  11 // Print a message to stdout
  12 print('a message');
  13 
  14 // Print a message to stderr
  15 printerr('An error occured');

   1 const GObject = imports.gi.GObject;
   2 
   3 const Config = imports.misc.config;
   4 const PanelMenu = imports.ui.panelMenu;
   5 
   6 // Outputs a string like : "3.30.0"
   7 log(Config.PACKAGE_VERSION);
   8 
   9 // Getting the minor version as an integer (probably the most relevant)
  10 let shellMinorVersion = parseInt(Config.PACKAGE_VERSION.split('.')[1]);
  11 
  12 // Our PanelMenu.Button subclass
  13 var ExampleIndicator = class ExampleIndicator extends PanelMenu.Button {
  14     _init(constructor_args) {
  15         // Chaining up to the super-class
  16         super._init(...constructor_args);
  17 
  18         // do some custom setup
  19     }
  20 
  21     customMethod() {
  22         // peform some custom operation
  23     }
  24 }
  25 
  26 // In gnome-shell >= 3.32 this class and several others became GObject
  27 // subclasses. We can account for this change in a backwards-compatible way
  28 // simply by re-wrapping our subclass in `GObject.registerClass()`
  29 if (shellMinorVersion > 30) {
  30     ExampleIndicator = GObject.registerClass(
  31         {GTypeName: 'ExampleIndicator'},
  32         ExampleIndicator
  33     );
  34 }

   1 'use strict';
   2 
   3 const ExtensionUtils = imports.misc.extensionUtils;
   4 const Me = ExtensionUtils.getCurrentExtension();
   5 
   6 
   7 function init() {
   8     log(`initializing ${Me.metadata.name} version ${Me.metadata.version}`);
   9 }
  10 
  11 
  12 function enable() {
  13     log(`enabling ${Me.metadata.name} version ${Me.metadata.version}`);
  14 }
  15 
  16 
  17 function disable() {
  18     log(`disabling ${Me.metadata.name} version ${Me.metadata.version}`);
  19 }

   1 'use strict';
   2 
   3 const Gio = imports.gi.Gio;
   4 const GLib = imports.gi.GLib;
   5 const GObject = imports.gi.GObject;
   6 const St = imports.gi.St;
   7 
   8 const ExtensionUtils = imports.misc.extensionUtils;
   9 const Me = ExtensionUtils.getCurrentExtension();
  10 const Main = imports.ui.main;
  11 const PanelMenu = imports.ui.panelMenu;
  12 
  13 // For compatibility checks, as described above
  14 const Config = imports.misc.config;
  15 const SHELL_MINOR = parseInt(Config.PACKAGE_VERSION.split('.')[1]);
  16 
  17 
  18 // We'll extend the Button class from Panel Menu so we can do some setup in
  19 // the init() function.
  20 var ExampleIndicator = class ExampleIndicator extends PanelMenu.Button {
  21 
  22     _init() {
  23         super._init(0.0, `${Me.metadata.name} Indicator`, false);
  24 
  25         // Pick an icon
  26         let icon = new St.Icon({
  27             gicon: new Gio.ThemedIcon({name: 'face-laugh-symbolic'}),
  28             style_class: 'system-status-icon'
  29         });
  30         this.actor.add_child(icon);
  31 
  32         // Add a menu item
  33         this.menu.addAction('Menu Item', this.menuAction, null);
  34     }
  35 
  36     menuAction() {
  37         log('Menu item activated');
  38     }
  39 }
  40 
  41 // Compatibility with gnome-shell >= 3.32
  42 if (SHELL_MINOR > 30) {
  43     ExampleIndicator = GObject.registerClass(
  44         {GTypeName: 'ExampleIndicator'},
  45         ExampleIndicator
  46     );
  47 }
  48 
  49 // We're going to declare `indicator` in the scope of the whole script so it can
  50 // be accessed in both `enable()` and `disable()`
  51 var indicator = null;
  52 
  53 
  54 function init() {
  55     log(`initializing ${Me.metadata.name} version ${Me.metadata.version}`);
  56 }
  57 
  58 
  59 function enable() {
  60     log(`enabling ${Me.metadata.name} version ${Me.metadata.version}`);
  61 
  62     indicator = new ExampleIndicator();
  63 
  64     // The `main` import is an example of file that is mostly live instances of
  65     // objects, rather than reusable code. `Main.panel` is the actual panel you
  66     // see at the top of the screen.
  67     Main.panel.addToStatusArea(`${Me.metadata.name} Indicator`, indicator);
  68 }
  69 
  70 
  71 function disable() {
  72     log(`disabling ${Me.metadata.name} version ${Me.metadata.version}`);
  73 
  74     // REMINDER: It's required for extensions to clean up after themselves when
  75     // they are disabled. This is required for approval during review!
  76     if (indicator !== null) {
  77         indicator.destroy();
  78         indicator = null;
  79     }
  80 }

   1 // Grab the Volume Indicator from the User Menu
   2 const VolumeIndicator = Main.panel.statusArea.aggregateMenu._volume;
   3 
   4 
   5 var ExampleIndicator = class ExampleIndicator extends PanelMenu.Button {
   6 
   7     _init() {
   8         super._init(0.0, `${Me.metadata.name} Indicator`, false);
   9 
  10         let icon = new St.Icon({
  11             gicon: new Gio.ThemedIcon({name: 'face-laugh-symbolic'}),
  12             style_class: 'system-status-icon'
  13         });
  14         this.actor.add_child(icon);
  15 
  16         this.menu.addAction('Menu Item', this.menuAction, null);
  17 
  18         // Prevent the volume indicator from emitting the ::scroll-event signal
  19         VolumeIndicator.reactive = false;
  20 
  21         // Connect the callback to our button's signal
  22         //
  23         // NOTE: use `Function.bind()` to bind the scope (ie. `this`) to the
  24         // proper context. In this example, when `_onScrollEvent()` is invoked
  25         // `this` will be the `VolumeIndicator` instance the function expects.
  26         this._onScrollEventId = this.actor.connect(
  27           'scroll-event',
  28           VolumeIndicator._onScrollEvent.bind(VolumeIndicator)
  29         );
  30     }
  31 
  32     destroy() {
  33         // Disconnect from the scroll-event signal
  34         //
  35         // NOTE: When we called `GObject.connect()` above, it returned an
  36         // integer for the connection handler. We saved that so that we can use
  37         // it now to disconnect the callback.
  38         this.actor.disconnect(this._onScrollEventId);
  39 
  40         // Reset the volume indicator reactivity
  41         VolumeIndicator.reactive = true;
  42 
  43         super.destroy();
  44     }
  45 }

   1 // Grab the Volume Indicator from the User Menu
   2 const VolumeIndicator = Main.panel.statusArea.aggregateMenu._volume;
   3 
   4 // The PanelMenu.Button class is now a GObject-derived class!
   5 var ExampleIndicator = GObject.registerClass({
   6     GTypeName: 'ExampleIndicator',
   7 }, class ExampleIndicator extends PanelMenu.Button {
   8 
   9     _init() {
  10         super._init(0.0, `${Me.metadata.name} Indicator`, false);
  11 
  12         let icon = new St.Icon({
  13             gicon: new Gio.ThemedIcon({name: 'face-laugh-symbolic'}),
  14             style_class: 'system-status-icon'
  15         });
  16         this.actor.add_child(icon);
  17         this.menu.addAction('Menu Item', this.menuAction, null);
  18 
  19         VolumeIndicator.reactive = false;
  20 
  21         // In GNOME Shell 3.36+ the volume indicator now uses a vfunc (sort of
  22         // a default signal callback), so we must use that instead
  23         this._onScrollEventId = this.actor.connect(
  24           'scroll-event',
  25            VolumeIndicator.vfunc_scroll_event.bind(VolumeIndicator)
  26         );
  27     }
  28 
  29 
  30     // Because PanelMenu.Button is a ClutterActor, overriding the destroy()
  31     // method directly is bad idea. Instead PanelMenu.Button connects to
  32     // the signal, so we can override that callback and chain-up.
  33     _onDestroy() {
  34         // Disconnect from the scroll-event signal as before
  35         this.actor.disconnect(this._onScrollEventId);
  36         VolumeIndicator.reactive = true;
  37 
  38         // Chaining-up to PanelMenu.Button's callback
  39         super._onDestroy();
  40     }
  41 });

   1 var ExampleIndicator = class ExampleIndicator extends PanelMenu.Button {
   2 
   3     _init() {
   4         super._init(0.0, `${Me.metadata.name} Indicator`, false);
   5 
   6         // Pick an icon
   7         let icon = new St.Icon({
   8             gicon: new Gio.ThemedIcon({name: 'face-laugh-symbolic'}),
   9             style_class: 'system-status-icon'
  10         });
  11         this.actor.add_child(icon);
  12 
  13         // Keep a record of the original visibility of each panel item
  14         this.states = {};
  15 
  16         // Add a menu item for each item in the panel
  17         for (let name in Main.panel.statusArea) {
  18             // Remember this item's original visibility
  19             this.states[name] = Main.panel.statusArea[name].actor.visible;
  20 
  21             this.menu.addAction(
  22                 `Toggle "${name}"`,
  23                 this.togglePanelItem.bind(null, name),
  24                 null
  25             );
  26         }
  27     }
  28 
  29     /**
  30      * togglePanelItem:
  31      * @param {string} name - name of the panel item
  32      *
  33      * Don't be a jerk to your future self; document your code!
  34      */
  35     togglePanelItem(name) {
  36         log(`${name} menu item activated`);
  37 
  38         try {
  39             let statusItem = Main.panel.statusArea[name];
  40 
  41             // Many classes in GNOME Shell are actually native classes (non-GObject)
  42             // with a ClutterActor (GObject) as the property `actor`. St is an
  43             // extension of Clutter so these may also be StWidgets.
  44             statusItem.actor.visible = !statusItem.actor.visible;
  45         } catch (e) {
  46             logError(e, 'togglePanelItem');
  47         }
  48     }
  49 
  50     // We'll override the destroy() function to revert any changes we make
  51     destroy() {
  52         // Restore the visibility of the panel items
  53         for (let [name, visibility] of Object.entries(this.states)) {
  54             Main.panel.statusArea[name].actor.visible = visibility;
  55         }
  56 
  57         // Chain-up to the super-class after we've done our own cleanup
  58         super.destroy();
  59     }
  60 }

   1 var ExampleIndicator = class ExampleIndicator extends PanelMenu.Button {
   2 
   3     _init() {
   4         super._init(0.0, `${Me.metadata.name} Indicator`, false);
   5 
   6         // Get the GSchema source so we can lookup our settings
   7         let gschema = Gio.SettingsSchemaSource.new_from_directory(
   8             Me.dir.get_child('schemas').get_path(),
   9             Gio.SettingsSchemaSource.get_default(),
  10             false
  11         );
  12 
  13         this.settings = new Gio.Settings({
  14             settings_schema: gschema.lookup('org.gnome.shell.extensions.example', true)
  15         });
  16 
  17         // Bind our indicator visibility to the GSettings value
  18         //
  19         // NOTE: Binding properties only works with GProperties (properties
  20         // registered on a GObject class), not native JavaScript properties
  21         this.settings.bind(
  22             'show-indicator',
  23             this.actor,
  24             'visible',
  25             Gio.SettingsBindFlags.DEFAULT
  26         );
  27 
  28         // Watch the settings for changes
  29         this._onPanelStatesChangedId = this.settings.connect(
  30             'changed::panel-states',
  31             this._onPanelStatesChanged.bind(this)
  32         );
  33 
  34         // Keep record of the original state of each item
  35         this.states = {};
  36 
  37         // Read the saved states
  38         let variant = this.settings.get_value('panel-states');
  39 
  40         // Unpack the GSettings GVariant
  41         //
  42         // NOTE: `GSettings.get_value()` returns a GVariant, which is a
  43         // multi-type container for packed values. GJS has two helper functions:
  44         //
  45         //  * `GVariant.unpack()`
  46         //     This function will do a shallow unpacking of any variant type,
  47         //     useful for simple types like "s" (string) or "u" (uint32/Number).
  48         //
  49         //  * `GVariant.deep_unpack()`
  50         //     A deep, but non-recursive unpacking, such that our variant type
  51         //     "a{sb}" will be unpacked to a JS Object of `{ string: boolean }`.
  52         //     `GVariant.unpack()` would return `{ string: GVariant }`.
  53         this.saved = variant.deep_unpack();
  54 
  55         // Pick an icon
  56         let icon = new St.Icon({
  57             gicon: new Gio.ThemedIcon({name: 'face-laugh-symbolic'}),
  58             style_class: 'system-status-icon'
  59         });
  60         this.actor.add_child(icon);
  61 
  62         // Add a menu item for each item in the panel
  63         for (let name in Main.panel.statusArea) {
  64             // Record this item's original visibility
  65             this.states[name] = Main.panel.statusArea[name].actor.visible;
  66 
  67             // Restore our settings
  68             if (name in this.saved) {
  69                 log(`Restoring state of ${name}`);
  70                 Main.panel.statusArea[name].actor.visible = this.saved[name];
  71             }
  72 
  73             this.menu.addAction(
  74                 `Toggle "${name}"`,
  75                 this.togglePanelItem.bind(this, name),
  76                 null
  77             );
  78         }
  79     }
  80 
  81     _onPanelStatesChanged(settings, key) {
  82         // Read the new settings
  83         this.saved = this.settings.get_value('panel-states').deep_unpack();
  84 
  85         // Restore or reset the panel items
  86         for (let name in this.states) {
  87             // If we have a saved state, set that
  88             if (name in this.saved) {
  89                 Main.panel.statusArea[name].actor.visible = this.saved[name];
  90 
  91             // Otherwise restore the original state
  92             } else {
  93                 Main.panel.statusArea[name].actor.visible = this.states[name];
  94             }
  95         }
  96     }
  97 
  98     togglePanelItem(name) {
  99         log(`${name} menu item activated`);
 100 
 101         let statusItem = Main.panel.statusArea[name];
 102         statusItem.actor.visible = !statusItem.actor.visible;
 103 
 104         // Store our saved state
 105         this.saved[name] = statusItem.actor.visible;
 106     }
 107 
 108     destroy() {
 109         // Stop watching the settings for changes
 110         this.settings.disconnect(this._onSettingsChangedId);
 111 
 112         // Store the panel settings in GSettings
 113         this.settings.set_value(
 114             'panel-states',
 115             new GLib.Variant('a{sb}', this.saved)
 116         );
 117 
 118         // Restore the visibility of the panel items
 119         for (let [name, visibility] of Object.entries(this.states)) {
 120             Main.panel.statusArea[name].actor.visible = visibility;
 121         }
 122 
 123         super.destroy();
 124     }
 125 }

   1 'use strict';
   2 
   3 const Gio = imports.gi.Gio;
   4 const Gtk = imports.gi.Gtk;
   5 
   6 const ExtensionUtils = imports.misc.extensionUtils;
   7 const Me = ExtensionUtils.getCurrentExtension();
   8 
   9 
  10 function init() {
  11 }
  12 
  13 function buildPrefsWidget() {
  14 
  15     // Copy the same GSettings code from `extension.js`
  16     let gschema = Gio.SettingsSchemaSource.new_from_directory(
  17         Me.dir.get_child('schemas').get_path(),
  18         Gio.SettingsSchemaSource.get_default(),
  19         false
  20     );
  21 
  22     this.settings = new Gio.Settings({
  23         settings_schema: gschema.lookup('org.gnome.shell.extensions.example', true)
  24     });
  25 
  26     // Create a parent widget that we'll return from this function
  27     let prefsWidget = new Gtk.Grid({
  28         margin: 18,
  29         column_spacing: 12,
  30         row_spacing: 12,
  31         visible: true
  32     });
  33 
  34     // Add a simple title and add it to the prefsWidget
  35     let title = new Gtk.Label({
  36         // As described in "Extension Translations", the following template
  37         // lit
  38         // prefs.js:88: warning: RegExp literal terminated too early
  39         //label: `<b>${Me.metadata.name} Extension Preferences</b>`,
  40         label: '<b>' + Me.metadata.name + ' Extension Preferences</b>',
  41         halign: Gtk.Align.START,
  42         use_markup: true,
  43         visible: true
  44     });
  45     prefsWidget.attach(title, 0, 0, 2, 1);
  46 
  47     // Create a label to describe our button and add it to the prefsWidget
  48     let buttonLabel = new Gtk.Label({
  49         label: 'Reset Panel Items:',
  50         halign: Gtk.Align.START,
  51         visible: true
  52     });
  53     prefsWidget.attach(buttonLabel, 0, 1, 1, 1);
  54 
  55     // Create a 'Reset' button and add it to the prefsWidget
  56     let button = new Gtk.Button({
  57         label: 'Reset Panel',
  58         visible: true
  59     });
  60     prefsWidget.attach(button, 1, 1, 1, 1);
  61 
  62     // Connect the ::clicked signal to reset the stored settings
  63     button.connect('clicked', (button) => this.settings.reset('panel-states'));
  64 
  65     // Create a label & switch for `show-indicator`
  66     let toggleLabel = new Gtk.Label({
  67         label: 'Show Extension Indicator:',
  68         halign: Gtk.Align.START,
  69         visible: true
  70     });
  71     prefsWidget.attach(toggleLabel, 0, 2, 1, 1);
  72 
  73     let toggle = new Gtk.Switch({
  74         active: this.settings.get_boolean ('show-indicator'),
  75         halign: Gtk.Align.END,
  76         visible: true
  77     });
  78     prefsWidget.attach(toggle, 1, 2, 1, 1);
  79 
  80     // Bind the switch to the `show-indicator` key
  81     this.settings.bind(
  82         'show-indicator',
  83         toggle,
  84         'active',
  85         Gio.SettingsBindFlags.DEFAULT
  86     );
  87 
  88     // Return our widget which will be added to the window
  89     return prefsWidget;
  90 }

   1 const Gettext = imports.gettext;
   2 
   3 const ExtensionUtils = imports.misc.extensionUtils;
   4 const Me = ExtensionUtils.getCurrentExtension();
   5 
   6 // Bind gettext to your extension's "domain". This is generally a short, unique
   7 // string like a package name. You could use your extension UUID.
   8 Gettext.textdomain('example');
   9 
  10 // Bind the text domain to the translations in your `locale/` directory
  11 Gettext.bindtextdomain('example', Me.dir.get_child('locale').get_path());
  12 
  13 // The most common function is `gettext()`, by convention aliased to `_()`.
  14 const _ = Gettext.gettext;

   1 // This function marks a string to be translated while parsing with gettext and
   2 // returns the correct translation as a string during execution.
   3 let singular = new St.Label({
   4     text: _('Example')
   5 });
   6 
   7 // The other function you are likely to use is `ngettext()` which is used for
   8 // pluralized translations.
   9 let amount = 2;
  10 
  11 let plural = new St.Label({
  12     text: Gettext.ngettext('%d Example', '%d Examples', amount).format(amount)
  13 });

   1 // This may cause strange problems when `xgettext` is parsing the file
   2 // eg. "foo.js:5: warning: RegExp literal terminated too early"
   3 let path = `${directory}/${filename}.${extension}`;
   4 
   5 // Instead, use string concatenation...
   6 let path = directory + '/' + filename + '.' + extension;
   7 
   8 // ...or GLib.build_filenamev()
   9 const GLib = imports.gi.GLib;
  10 
  11 let path = GLib.build_filenamev([directory, `${filename}.${extension}`]);

   1 // If you're using GJS in a standalone application, you should do this yourself
   2 String.prototype.format = imports.format.format;
   3 
   4 // Two examples that both output: A string with a digit "5" and and string "test"
   5 let num = 5;
   6 let str = 'test';
   7 
   8 // With String.prototype.format()
   9 'A string with a digit "%d" and string "%s"'.format(num, str);
  10 
  11 // With native template literals
  12 'A string with a digit "${num}" and string "${str}"';

   1 'use strict';
   2 
   3 const Gettext = imports.gettext;
   4 
   5 const ExtensionUtils = imports.misc.extensionUtils;
   6 
   7 // ...code for `extension.js` or `prefs.js`...
   8 
   9 function init() {
  10     // If `gettext-domain` is defined in `metadata.json` you can simply call
  11     // this function without an argument.
  12     ExtensionUtils.initTranslations();
  13 
  14     // Otherwise, you should call it with your "domain" as described above
  15     ExtensionUtils.initTranslations('example');
  16 }