Adding upstream version 43.9.upstream/43.9upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 617 insertions, 0 deletions

diff --git a/js/misc/util.js b/js/misc/util.js
new file mode 100644
index 0000000..e6065c4
--- /dev/null
+++ b/js/misc/util.js
@@ -0,0 +1,617 @@
+// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
+/* exported findUrls, spawn, spawnCommandLine, spawnApp, trySpawnCommandLine,
+            formatTime, formatTimeSpan, createTimeLabel, insertSorted,
+            ensureActorVisibleInScrollView, wiggle, lerp, GNOMEversionCompare,
+            DBusSenderChecker, Highlighter */
+
+const { Clutter, Gio, GLib, Shell, St, GnomeDesktop } = imports.gi;
+const Gettext = imports.gettext;
+
+const Main = imports.ui.main;
+const Params = imports.misc.params;
+
+var SCROLL_TIME = 100;
+
+const WIGGLE_OFFSET = 6;
+const WIGGLE_DURATION = 65;
+const N_WIGGLES = 3;
+
+// http://daringfireball.net/2010/07/improved_regex_for_matching_urls
+const _balancedParens = '\\([^\\s()<>]+\\)';
+const _leadingJunk = '[\\s`(\\[{\'\\"<\u00AB\u201C\u2018]';
+const _notTrailingJunk = '[^\\s`!()\\[\\]{};:\'\\".,<>?\u00AB\u00BB\u200E\u200F\u201C\u201D\u2018\u2019\u202A\u202C]';
+
+const _urlRegexp = new RegExp(
+    `(^|${_leadingJunk})` +
+    '(' +
+        '(?:' +
+            '(?:http|https|ftp)://' +             // scheme://
+            '|' +
+            'www\\d{0,3}[.]' +                    // www.
+            '|' +
+            '[a-z0-9.\\-]+[.][a-z]{2,4}/' +       // foo.xx/
+        ')' +
+        '(?:' +                                   // one or more:
+            '[^\\s()<>]+' +                       // run of non-space non-()
+            '|' +                                 // or
+            `${_balancedParens}` +                // balanced parens
+        ')+' +
+        '(?:' +                                   // end with:
+            `${_balancedParens}` +                // balanced parens
+            '|' +                                 // or
+            `${_notTrailingJunk}` +               // last non-junk char
+        ')' +
+    ')', 'gi');
+
+let _desktopSettings = null;
+
+// findUrls:
+// @str: string to find URLs in
+//
+// Searches @str for URLs and returns an array of objects with %url
+// properties showing the matched URL string, and %pos properties indicating
+// the position within @str where the URL was found.
+//
+// Return value: the list of match objects, as described above
+function findUrls(str) {
+    let res = [], match;
+    while ((match = _urlRegexp.exec(str)))
+        res.push({ url: match[2], pos: match.index + match[1].length });
+    return res;
+}
+
+// spawn:
+// @argv: an argv array
+//
+// Runs @argv in the background, handling any errors that occur
+// when trying to start the program.
+function spawn(argv) {
+    try {
+        trySpawn(argv);
+    } catch (err) {
+        _handleSpawnError(argv[0], err);
+    }
+}
+
+// spawnCommandLine:
+// @commandLine: a command line
+//
+// Runs @commandLine in the background, handling any errors that
+// occur when trying to parse or start the program.
+function spawnCommandLine(commandLine) {
+    try {
+        let [success_, argv] = GLib.shell_parse_argv(commandLine);
+        trySpawn(argv);
+    } catch (err) {
+        _handleSpawnError(commandLine, err);
+    }
+}
+
+// spawnApp:
+// @argv: an argv array
+//
+// Runs @argv as if it was an application, handling startup notification
+function spawnApp(argv) {
+    try {
+        let app = Gio.AppInfo.create_from_commandline(argv.join(' '), null,
+                                                      Gio.AppInfoCreateFlags.SUPPORTS_STARTUP_NOTIFICATION);
+
+        let context = global.create_app_launch_context(0, -1);
+        app.launch([], context);
+    } catch (err) {
+        _handleSpawnError(argv[0], err);
+    }
+}
+
+// trySpawn:
+// @argv: an argv array
+//
+// Runs @argv in the background. If launching @argv fails,
+// this will throw an error.
+function trySpawn(argv) {
+    var success_, pid;
+    try {
+        [success_, pid] = GLib.spawn_async(
+            null, argv, null,
+            GLib.SpawnFlags.SEARCH_PATH | GLib.SpawnFlags.DO_NOT_REAP_CHILD,
+            () => {
+                try {
+                    global.context.restore_rlimit_nofile();
+                } catch (err) {
+                }
+            }
+        );
+    } catch (err) {
+        /* Rewrite the error in case of ENOENT */
+        if (err.matches(GLib.SpawnError, GLib.SpawnError.NOENT)) {
+            throw new GLib.SpawnError({
+                code: GLib.SpawnError.NOENT,
+                message: _('Command not found'),
+            });
+        } else if (err instanceof GLib.Error) {
+            // The exception from gjs contains an error string like:
+            //   Error invoking GLib.spawn_command_line_async: Failed to
+            //   execute child process "foo" (No such file or directory)
+            // We are only interested in the part in the parentheses. (And
+            // we can't pattern match the text, since it gets localized.)
+            let message = err.message.replace(/.*\((.+)\)/, '$1');
+            throw new err.constructor({ code: err.code, message });
+        } else {
+            throw err;
+        }
+    }
+
+    // Async call, we don't need the reply though
+    GnomeDesktop.start_systemd_scope(argv[0], pid, null, null, null, () => {});
+
+    // Dummy child watch; we don't want to double-fork internally
+    // because then we lose the parent-child relationship, which
+    // can break polkit.  See https://bugzilla.redhat.com//show_bug.cgi?id=819275
+    GLib.child_watch_add(GLib.PRIORITY_DEFAULT, pid, () => {});
+}
+
+// trySpawnCommandLine:
+// @commandLine: a command line
+//
+// Runs @commandLine in the background. If launching @commandLine
+// fails, this will throw an error.
+function trySpawnCommandLine(commandLine) {
+    let success_, argv;
+
+    try {
+        [success_, argv] = GLib.shell_parse_argv(commandLine);
+    } catch (err) {
+        // Replace "Error invoking GLib.shell_parse_argv: " with
+        // something nicer
+        err.message = err.message.replace(/[^:]*: /, `${_('Could not parse command:')}\n`);
+        throw err;
+    }
+
+    trySpawn(argv);
+}
+
+function _handleSpawnError(command, err) {
+    let title = _("Execution of “%s” failed:").format(command);
+    Main.notifyError(title, err.message);
+}
+
+function formatTimeSpan(date) {
+    let now = GLib.DateTime.new_now_local();
+
+    let timespan = now.difference(date);
+
+    let minutesAgo = timespan / GLib.TIME_SPAN_MINUTE;
+    let hoursAgo = timespan / GLib.TIME_SPAN_HOUR;
+    let daysAgo = timespan / GLib.TIME_SPAN_DAY;
+    let weeksAgo = daysAgo / 7;
+    let monthsAgo = daysAgo / 30;
+    let yearsAgo = weeksAgo / 52;
+
+    if (minutesAgo < 5)
+        return _("Just now");
+    if (hoursAgo < 1) {
+        return Gettext.ngettext("%d minute ago",
+                                "%d minutes ago", minutesAgo).format(minutesAgo);
+    }
+    if (daysAgo < 1) {
+        return Gettext.ngettext("%d hour ago",
+                                "%d hours ago", hoursAgo).format(hoursAgo);
+    }
+    if (daysAgo < 2)
+        return _("Yesterday");
+    if (daysAgo < 15) {
+        return Gettext.ngettext("%d day ago",
+                                "%d days ago", daysAgo).format(daysAgo);
+    }
+    if (weeksAgo < 8) {
+        return Gettext.ngettext("%d week ago",
+                                "%d weeks ago", weeksAgo).format(weeksAgo);
+    }
+    if (yearsAgo < 1) {
+        return Gettext.ngettext("%d month ago",
+                                "%d months ago", monthsAgo).format(monthsAgo);
+    }
+    return Gettext.ngettext("%d year ago",
+                            "%d years ago", yearsAgo).format(yearsAgo);
+}
+
+function formatTime(time, params) {
+    let date;
+    // HACK: The built-in Date type sucks at timezones, which we need for the
+    //       world clock; it's often more convenient though, so allow either
+    //       Date or GLib.DateTime as parameter
+    if (time instanceof Date)
+        date = GLib.DateTime.new_from_unix_local(time.getTime() / 1000);
+    else
+        date = time;
+
+    let now = GLib.DateTime.new_now_local();
+
+    let daysAgo = now.difference(date) / (24 * 60 * 60 * 1000 * 1000);
+
+    let format;
+
+    if (_desktopSettings == null)
+        _desktopSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.interface' });
+    let clockFormat = _desktopSettings.get_string('clock-format');
+
+    params = Params.parse(params, {
+        timeOnly: false,
+        ampm: true,
+    });
+
+    if (clockFormat == '24h') {
+        // Show only the time if date is on today
+        if (daysAgo < 1 || params.timeOnly)
+            /* Translators: Time in 24h format */
+            format = N_("%H\u2236%M");
+        // Show the word "Yesterday" and time if date is on yesterday
+        else if (daysAgo < 2)
+            /* Translators: this is the word "Yesterday" followed by a
+             time string in 24h format. i.e. "Yesterday, 14:30" */
+            // xgettext:no-c-format
+            format = N_("Yesterday, %H\u2236%M");
+        // Show a week day and time if date is in the last week
+        else if (daysAgo < 7)
+            /* Translators: this is the week day name followed by a time
+             string in 24h format. i.e. "Monday, 14:30" */
+            // xgettext:no-c-format
+            format = N_("%A, %H\u2236%M");
+        else if (date.get_year() == now.get_year())
+            /* Translators: this is the month name and day number
+             followed by a time string in 24h format.
+             i.e. "May 25, 14:30" */
+            // xgettext:no-c-format
+            format = N_("%B %-d, %H\u2236%M");
+        else
+            /* Translators: this is the month name, day number, year
+             number followed by a time string in 24h format.
+             i.e. "May 25 2012, 14:30" */
+            // xgettext:no-c-format
+            format = N_("%B %-d %Y, %H\u2236%M");
+    } else {
+        // Show only the time if date is on today
+        if (daysAgo < 1 || params.timeOnly) // eslint-disable-line no-lonely-if
+            /* Translators: Time in 12h format */
+            format = N_("%l\u2236%M %p");
+        // Show the word "Yesterday" and time if date is on yesterday
+        else if (daysAgo < 2)
+            /* Translators: this is the word "Yesterday" followed by a
+             time string in 12h format. i.e. "Yesterday, 2:30 pm" */
+            // xgettext:no-c-format
+            format = N_("Yesterday, %l\u2236%M %p");
+        // Show a week day and time if date is in the last week
+        else if (daysAgo < 7)
+            /* Translators: this is the week day name followed by a time
+             string in 12h format. i.e. "Monday, 2:30 pm" */
+            // xgettext:no-c-format
+            format = N_("%A, %l\u2236%M %p");
+        else if (date.get_year() == now.get_year())
+            /* Translators: this is the month name and day number
+             followed by a time string in 12h format.
+             i.e. "May 25, 2:30 pm" */
+            // xgettext:no-c-format
+            format = N_("%B %-d, %l\u2236%M %p");
+        else
+            /* Translators: this is the month name, day number, year
+             number followed by a time string in 12h format.
+             i.e. "May 25 2012, 2:30 pm"*/
+            // xgettext:no-c-format
+            format = N_("%B %-d %Y, %l\u2236%M %p");
+    }
+
+    // Time in short 12h format, without the equivalent of "AM" or "PM"; used
+    // when it is clear from the context
+    if (!params.ampm)
+        format = format.replace(/\s*%p/g, '');
+
+    let formattedTime = date.format(Shell.util_translate_time_string(format));
+    // prepend LTR-mark to colon/ratio to force a text direction on times
+    return formattedTime.replace(/([:\u2236])/g, '\u200e$1');
+}
+
+function createTimeLabel(date, params) {
+    if (_desktopSettings == null)
+        _desktopSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.interface' });
+
+    let label = new St.Label({ text: formatTime(date, params) });
+    _desktopSettings.connectObject(
+        'changed::clock-format', () => (label.text = formatTime(date, params)),
+        label);
+    return label;
+}
+
+// lowerBound:
+// @array: an array or array-like object, already sorted
+//         according to @cmp
+// @val: the value to add
+// @cmp: a comparator (or undefined to compare as numbers)
+//
+// Returns the position of the first element that is not
+// lower than @val, according to @cmp.
+// That is, returns the first position at which it
+// is possible to insert @val without violating the
+// order.
+// This is quite like an ordinary binary search, except
+// that it doesn't stop at first element comparing equal.
+
+function lowerBound(array, val, cmp) {
+    let min, max, mid, v;
+    cmp ||= (a, b) => a - b;
+
+    if (array.length == 0)
+        return 0;
+
+    min = 0;
+    max = array.length;
+    while (min < (max - 1)) {
+        mid = Math.floor((min + max) / 2);
+        v = cmp(array[mid], val);
+
+        if (v < 0)
+            min = mid + 1;
+        else
+            max = mid;
+    }
+
+    return min == max || cmp(array[min], val) < 0 ? max : min;
+}
+
+// insertSorted:
+// @array: an array sorted according to @cmp
+// @val: a value to insert
+// @cmp: the sorting function
+//
+// Inserts @val into @array, preserving the
+// sorting invariants.
+// Returns the position at which it was inserted
+function insertSorted(array, val, cmp) {
+    let pos = lowerBound(array, val, cmp);
+    array.splice(pos, 0, val);
+
+    return pos;
+}
+
+function ensureActorVisibleInScrollView(scrollView, actor) {
+    let adjustment = scrollView.vscroll.adjustment;
+    let [value, lower_, upper, stepIncrement_, pageIncrement_, pageSize] = adjustment.get_values();
+
+    let offset = 0;
+    let vfade = scrollView.get_effect("fade");
+    if (vfade)
+        offset = vfade.fade_margins.top;
+
+    let box = actor.get_allocation_box();
+    let y1 = box.y1, y2 = box.y2;
+
+    let parent = actor.get_parent();
+    while (parent != scrollView) {
+        if (!parent)
+            throw new Error("actor not in scroll view");
+
+        box = parent.get_allocation_box();
+        y1 += box.y1;
+        y2 += box.y1;
+        parent = parent.get_parent();
+    }
+
+    if (y1 < value + offset)
+        value = Math.max(0, y1 - offset);
+    else if (y2 > value + pageSize - offset)
+        value = Math.min(upper, y2 + offset - pageSize);
+    else
+        return;
+
+    adjustment.ease(value, {
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        duration: SCROLL_TIME,
+    });
+}
+
+function wiggle(actor, params) {
+    if (!St.Settings.get().enable_animations)
+        return;
+
+    params = Params.parse(params, {
+        offset: WIGGLE_OFFSET,
+        duration: WIGGLE_DURATION,
+        wiggleCount: N_WIGGLES,
+    });
+    actor.translation_x = 0;
+
+    // Accelerate before wiggling
+    actor.ease({
+        translation_x: -params.offset,
+        duration: params.duration,
+        mode: Clutter.AnimationMode.EASE_OUT_QUAD,
+        onComplete: () => {
+            // Wiggle
+            actor.ease({
+                translation_x: params.offset,
+                duration: params.duration,
+                mode: Clutter.AnimationMode.LINEAR,
+                repeatCount: params.wiggleCount,
+                autoReverse: true,
+                onComplete: () => {
+                    // Decelerate and return to the original position
+                    actor.ease({
+                        translation_x: 0,
+                        duration: params.duration,
+                        mode: Clutter.AnimationMode.EASE_IN_QUAD,
+                    });
+                },
+            });
+        },
+    });
+}
+
+function lerp(start, end, progress) {
+    return start + progress * (end - start);
+}
+
+// _GNOMEversionToNumber:
+// @version: a GNOME version element
+//
+// Like Number() but returns sortable values for special-cases
+// 'alpha' and 'beta'. Returns NaN for unhandled 'versions'.
+function _GNOMEversionToNumber(version) {
+    let ret = Number(version);
+    if (!isNaN(ret))
+        return ret;
+    if (version === 'alpha')
+        return -2;
+    if (version === 'beta')
+        return -1;
+    return ret;
+}
+
+// GNOMEversionCompare:
+// @version1: a string containing a GNOME version
+// @version2: a string containing another GNOME version
+//
+// Returns an integer less than, equal to, or greater than
+// zero, if version1 is older, equal or newer than version2
+function GNOMEversionCompare(version1, version2) {
+    const v1Array = version1.split('.');
+    const v2Array = version2.split('.');
+
+    for (let i = 0; i < Math.max(v1Array.length, v2Array.length); i++) {
+        let elemV1 = _GNOMEversionToNumber(v1Array[i] || '0');
+        let elemV2 = _GNOMEversionToNumber(v2Array[i] || '0');
+        if (elemV1 < elemV2)
+            return -1;
+        if (elemV1 > elemV2)
+            return 1;
+    }
+
+    return 0;
+}
+
+var DBusSenderChecker = class {
+    /**
+     * @param {string[]} allowList - list of allowed well-known names
+     */
+    constructor(allowList) {
+        this._allowlistMap = new Map();
+
+        this._uninitializedNames = new Set(allowList);
+        this._initializedPromise = new Promise(resolve => {
+            this._resolveInitialized = resolve;
+        });
+
+        this._watchList = allowList.map(name => {
+            return Gio.DBus.watch_name(Gio.BusType.SESSION,
+                name,
+                Gio.BusNameWatcherFlags.NONE,
+                (conn_, name_, owner) => {
+                    this._allowlistMap.set(name, owner);
+                    this._checkAndResolveInitialized(name);
+                },
+                () => {
+                    this._allowlistMap.delete(name);
+                    this._checkAndResolveInitialized(name);
+                });
+        });
+    }
+
+    /**
+     * @param {string} name - bus name for which the watcher got initialized
+     */
+    _checkAndResolveInitialized(name) {
+        if (this._uninitializedNames.delete(name) &&
+            this._uninitializedNames.size === 0)
+            this._resolveInitialized();
+    }
+
+    /**
+     * @async
+     * @param {string} sender - the bus name that invoked the checked method
+     * @returns {bool}
+     */
+    async _isSenderAllowed(sender) {
+        await this._initializedPromise;
+        return [...this._allowlistMap.values()].includes(sender);
+    }
+
+    /**
+     * Check whether the bus name that invoked @invocation maps
+     * to an entry in the allow list.
+     *
+     * @async
+     * @throws
+     * @param {Gio.DBusMethodInvocation} invocation - the invocation
+     * @returns {void}
+     */
+    async checkInvocation(invocation) {
+        if (global.context.unsafe_mode)
+            return;
+
+        if (await this._isSenderAllowed(invocation.get_sender()))
+            return;
+
+        throw new GLib.Error(Gio.DBusError,
+            Gio.DBusError.ACCESS_DENIED,
+            `${invocation.get_method_name()} is not allowed`);
+    }
+
+    /**
+     * @returns {void}
+     */
+    destroy() {
+        for (const id in this._watchList)
+            Gio.DBus.unwatch_name(id);
+        this._watchList = [];
+    }
+};
+
+/* @class Highlighter Highlight given terms in text using markup. */
+var Highlighter = class {
+    /**
+     * @param {?string[]} terms - list of terms to highlight
+     */
+    constructor(terms) {
+        if (!terms)
+            return;
+
+        const escapedTerms = terms
+            .map(term => Shell.util_regex_escape(term))
+            .filter(term => term.length > 0);
+
+        if (escapedTerms.length === 0)
+            return;
+
+        this._highlightRegex = new RegExp(
+            `(${escapedTerms.join('|')})`, 'gi');
+    }
+
+    /**
+     * Highlight all occurences of the terms defined for this
+     * highlighter in the provided text using markup.
+     *
+     * @param {string} text - text to highlight the defined terms in
+     * @returns {string}
+     */
+    highlight(text) {
+        if (!this._highlightRegex)
+            return GLib.markup_escape_text(text, -1);
+
+        let escaped = [];
+        let lastMatchEnd = 0;
+        let match;
+        while ((match = this._highlightRegex.exec(text))) {
+            if (match.index > lastMatchEnd) {
+                let unmatched = GLib.markup_escape_text(
+                    text.slice(lastMatchEnd, match.index), -1);
+                escaped.push(unmatched);
+            }
+            let matched = GLib.markup_escape_text(match[0], -1);
+            escaped.push(`<b>${matched}</b>`);
+            lastMatchEnd = match.index + match[0].length;
+        }
+        let unmatched = GLib.markup_escape_text(
+            text.slice(lastMatchEnd), -1);
+        escaped.push(unmatched);
+
+        return escaped.join('');
+    }
+};