Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
extensions	[ DIR ]	drwxr-xr-x
gir-1.0	[ DIR ]	drwxr-xr-x
modes	[ DIR ]	drwxr-xr-x
search-providers	[ DIR ]	drwxr-xr-x
theme	[ DIR ]	drwxr-xr-x
gdm-theme.gresource	3.72 MB	-rw-r--r--
gnome-shell-dbus-interfaces.gresource	55.21 KB	-rw-r--r--
gnome-shell-icons.gresource	26.05 KB	-rw-r--r--
gnome-shell-osk-layouts.gresource	755.16 KB	-rw-r--r--
gnome-shell-theme.gresource	415.44 KB	-rw-r--r--
Gvc-1.0.gir	147.29 KB	-rw-r--r--
org.gnome.Extensions	118 B	-rw-r--r--
org.gnome.Extensions.data.gresource	23.31 KB	-rw-r--r--
org.gnome.Extensions.src.gresource	24.84 KB	-rw-r--r--
org.gnome.ScreenSaver	97 B	-rw-r--r--
org.gnome.ScreenSaver.src.gresource	12.37 KB	-rw-r--r--
org.gnome.Shell.Extensions	97 B	-rw-r--r--
org.gnome.Shell.Extensions.src.gresource	36.43 KB	-rw-r--r--
org.gnome.Shell.Notifications	97 B	-rw-r--r--
org.gnome.Shell.Notifications.src.gresource	15.09 KB	-rw-r--r--
org.gnome.Shell.Screencast	97 B	-rw-r--r--
org.gnome.Shell.Screencast.src.gresource	25.15 KB	-rw-r--r--
perf-background.xml	1.1 KB	-rw-r--r--
Shell-0.1.gir	242.23 KB	-rw-r--r--
St-1.0.gir	434.11 KB	-rw-r--r--

Code Editor : org.gnome.Shell.Extensions.src.gresource

GVariant�����������4�����(������������������������������������	�����������������������������$0���4���L�<��@���P�����@���v�X��
��y3c����
���v���i'���%�y
���i'���v�x'��z(���*!����z(��	�v��(���+��������+���v��+���A��ε������A���v��A���V��Ե������V���L��V���V��6�|����V���v��V���w���ag�����w��	�v��w���{�����
����{���L��{���{��B�;�
����{���L��{��|����;�
���|���L�|��|���H����|���L�|��(|��]Lp	���(|���L�0|��@|���m�����@|���v�P|��������\��������v���������KP���������L����������Q���������L���������gnome/�����extension-error-page.ui��������<?xml version="1.0" encoding="UTF-8"?>
<interface>
  <template class="ExtensionPrefsErrorPage" parent="AdwPreferencesPage">
    <style>
      <class name="error-page"/>
    </style>
    <child>
      <object class="AdwPreferencesGroup">
        <child>
          <object class="GtkBox">
            <property name="orientation">vertical</property>
            <property name="spacing">12</property>
            <child>
              <object class="GtkLabel">
                <property name="label" translatable="yes">Something’s gone wrong</property>
                <style>
                  <class name="title-1"/>
                </style>
              </object>
            </child>
            <child>
              <object class="GtkLabel">
                <property name="label" translatable="yes">We’re very sorry, but there’s been a problem: the settings for this extension can’t be displayed. We recommend that you report the issue to the extension authors.</property>
                <property name="justify">center</property>
                <property name="wrap">True</property>
              </object>
            </child>
            <child>
              <object class="GtkFrame">
                <property name="margin-top">12</property>
                <child>
                  <object class="GtkBox">
                    <property name="hexpand">True</property>
                    <property name="orientation">vertical</property>
                    <child>
                      <object class="GtkBox" id="expander">
                        <property name="spacing">6</property>
                        <style>
                          <class name="expander"/>
                        </style>
                        <child>
                          <object class="GtkImage" id="expanderArrow">
                            <property name="icon-name">pan-end-symbolic</property>
                          </object>
                        </child>
                        <child>
                          <object class="GtkLabel">
                            <property name="label" translatable="yes">Technical Details</property>
                          </object>
                        </child>
                      </object>
                    </child>
                    <child>
                      <object class="GtkRevealer" id="revealer">
                        <child>
                          <object class="GtkBox">
                            <property name="orientation">vertical</property>
                            <child>
                              <object class="GtkTextView" id="errorView">
                                <property name="monospace">True</property>
                                <property name="editable">False</property>
                                <property name="wrap-mode">word</property>
                                <property name="left-margin">12</property>
                                <property name="right-margin">12</property>
                                <property name="top-margin">12</property>
                                <property name="bottom-margin">12</property>
                              </object>
                            </child>
                            <child>
                              <object class="GtkBox">
                                <style>
                                  <class name="expander-toolbar"/>
                                </style>
                                <child>
                                  <object class="GtkButton">
                                    <property name="receives-default">True</property>
                                    <property name="action-name">page.copy-error</property>
                                    <property name="has-frame">False</property>
                                    <property name="icon-name">edit-copy-symbolic</property>
                                  </object>
                                </child>
                                <child>
                                  <object class="GtkButton" id="homeButton">
                                    <property name="visible"
                                              bind-source="homeButton"
                                              bind-property="sensitive"
                                              bind-flags="sync-create"/>
                                    <property name="hexpand">True</property>
                                    <property name="halign">end</property>
                                    <property name="label" translatable="yes">Homepage</property>
                                    <property name="tooltip-text" translatable="yes">Visit extension homepage</property>
                                    <property name="receives-default">True</property>
                                    <property name="has-frame">False</property>
                                    <property name="action-name">page.show-url</property>
                                  </object>
                                </child>
                              </object>
                            </child>
                          </object>
                        </child>
                      </object>
                    </child>
                  </object>
                </child>
              </object>
            </child>
          </object>
        </child>
      </object>
    </child>
  </template>
</interface>
��(uuay)fileUtils.js��A������// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported collectFromDatadirs, recursivelyDeleteDir,
            recursivelyMoveDir, loadInterfaceXML, loadSubInterfaceXML */

const { Gio, GLib } = imports.gi;
const Config = imports.misc.config;

function collectFromDatadirs(subdir, includeUserDir, processFile) {
    let dataDirs = GLib.get_system_data_dirs();
    if (includeUserDir)
        dataDirs.unshift(GLib.get_user_data_dir());

for (let i = 0; i < dataDirs.length; i++) {
        let path = GLib.build_filenamev([dataDirs[i], 'gnome-shell', subdir]);
        let dir = Gio.File.new_for_path(path);

let fileEnum;
        try {
            fileEnum = dir.enumerate_children('standard::name,standard::type',
                                              Gio.FileQueryInfoFlags.NONE, null);
        } catch (e) {
            fileEnum = null;
        }
        if (fileEnum != null) {
            let info;
            while ((info = fileEnum.next_file(null)))
                processFile(fileEnum.get_child(info), info);
        }
    }
}

function recursivelyDeleteDir(dir, deleteParent) {
    let children = dir.enumerate_children('standard::name,standard::type',
        Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);

let info;
    while ((info = children.next_file(null)) != null) {
        let type = info.get_file_type();
        let child = dir.get_child(info.get_name());
        if (type == Gio.FileType.REGULAR)
            child.delete(null);
        else if (type == Gio.FileType.DIRECTORY)
            recursivelyDeleteDir(child, true);
    }

if (deleteParent)
        dir.delete(null);
}

function recursivelyMoveDir(srcDir, destDir) {
    let children = srcDir.enumerate_children('standard::name,standard::type',
        Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);

if (!destDir.query_exists(null))
        destDir.make_directory_with_parents(null);

let info;
    while ((info = children.next_file(null)) != null) {
        let type = info.get_file_type();
        let srcChild = srcDir.get_child(info.get_name());
        let destChild = destDir.get_child(info.get_name());
        if (type == Gio.FileType.REGULAR)
            srcChild.move(destChild, Gio.FileCopyFlags.NONE, null, null);
        else if (type == Gio.FileType.DIRECTORY)
            recursivelyMoveDir(srcChild, destChild);
    }
}

let _ifaceResource = null;
function ensureIfaceResource() {
    if (_ifaceResource)
        return;

// don't use global.datadir so the method is usable from tests/tools
    let dir = GLib.getenv('GNOME_SHELL_DATADIR') || Config.PKGDATADIR;
    let path = `${dir}/gnome-shell-dbus-interfaces.gresource`;
    _ifaceResource = Gio.Resource.load(path);
    _ifaceResource._register();
}

function loadInterfaceXML(iface) {
    ensureIfaceResource();

let uri = `resource:///org/gnome/shell/dbus-interfaces/${iface}.xml`;
    let f = Gio.File.new_for_uri(uri);

try {
        let [ok_, bytes] = f.load_contents(null);
        return new TextDecoder().decode(bytes);
    } catch (e) {
        log(`Failed to load D-Bus interface ${iface}`);
    }

return null;
}

function loadSubInterfaceXML(iface, ifaceFile) {
    let xml = loadInterfaceXML(ifaceFile);
    if (!xml)
        return null;

let ifaceStartTag = `<interface name="${iface}">`;
    let ifaceStopTag = '</interface>';
    let ifaceStartIndex = xml.indexOf(ifaceStartTag);
    let ifaceEndIndex = xml.indexOf(ifaceStopTag, ifaceStartIndex + 1) + ifaceStopTag.length;

let xmlHeader = '<!DOCTYPE node PUBLIC\n' +
        '\'-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\'\n' +
        '\'http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\'>\n' +
        '<node>\n';
    let xmlFooter = '</node>';

return (
        xmlHeader +
        xml.substr(ifaceStartIndex, ifaceEndIndex - ifaceStartIndex) +
        xmlFooter);
}
��(uuay)application.css��������.error-page preferencespage { margin: 30px; }

.expander { padding: 12px; }
.expander.expanded { border: 0 solid @borders; border-bottom-width: 1px; }
.expander-toolbar {
  border: 0 solid @borders;
  border-top-width: 1px;
  padding: 3px;
}
��(uuay)config.js�����������// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-

/* The name of this package (not localized) */
var PACKAGE_NAME = 'gnome-shell';
/* The version of this package */
var PACKAGE_VERSION = '42.9';
/* 1 if gnome-bluetooth is available, 0 otherwise */
var HAVE_BLUETOOTH = 1;
/* 1 if networkmanager is available, 0 otherwise */
var HAVE_NETWORKMANAGER = 1;
/* 1 if soup2 should be used instead of soup3, 0 otherwise */
var HAVE_SOUP2 = 1;
/* 1 if recorder is enabled, 0 otherwise */
var HAVE_RECORDER = 1;
/* gettext package */
var GETTEXT_PACKAGE = 'gnome-shell';
/* locale dir */
var LOCALEDIR = '/usr/share/locale';
/* other standard directories */
var LIBEXECDIR = '/usr/libexec';
var PKGDATADIR = '/usr/share/gnome-shell';
/* g-i package versions */
var LIBMUTTER_API_VERSION = '10'
��(uuay)extensionPrefsDialog.js����������// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported ExtensionPrefsDialog */

const { Adw, Gdk, Gio, GLib, GObject, Gtk } = imports.gi;

const ExtensionUtils = imports.misc.extensionUtils;

var ExtensionPrefsDialog = GObject.registerClass({
    GTypeName: 'ExtensionPrefsDialog',
}, class ExtensionPrefsDialog extends Adw.PreferencesWindow {
    _init(extension) {
        super._init({
            title: extension.metadata.name,
            search_enabled: false,
        });

try {
            ExtensionUtils.installImporter(extension);

// give extension prefs access to their own extension object
            ExtensionUtils.getCurrentExtension = () => extension;

const prefsModule = extension.imports.prefs;
            prefsModule.init(extension.metadata);

if (prefsModule.fillPreferencesWindow) {
                prefsModule.fillPreferencesWindow(this);

if (!this.visible_page)
                    throw new Error('Extension did not provide any UI');
            } else {
                const widget = prefsModule.buildPrefsWidget();
                const page = this._wrapWidget(widget);
                this.add(page);
            }
        } catch (e) {
            this._showErrorPage(e);
            logError(e, 'Failed to open preferences');
        }
    }

set titlebar(w) {
        this.set_titlebar(w);
    }

// eslint-disable-next-line camelcase
    set_titlebar() {
        // intercept fatal libadwaita error, show error page instead
        GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
            this._showErrorPage(
                new Error('set_titlebar() is not supported for Adw.Window'));
            return GLib.SOURCE_REMOVE;
        });
    }

_showErrorPage(e) {
        while (this.visible_page)
            this.remove(this.visible_page);

const extension = ExtensionUtils.getCurrentExtension();
        this.add(new ExtensionPrefsErrorPage(extension, e));
    }

_wrapWidget(widget) {
        if (widget instanceof Adw.PreferencesPage)
            return widget;

const page = new Adw.PreferencesPage();
        if (widget instanceof Adw.PreferencesGroup) {
            page.add(widget);
            return page;
        }

const group = new Adw.PreferencesGroup();
        group.add(widget);
        page.add(group);

return page;
    }
});

const ExtensionPrefsErrorPage = GObject.registerClass({
    GTypeName: 'ExtensionPrefsErrorPage',
    Template: 'resource:///org/gnome/Shell/Extensions/ui/extension-error-page.ui',
    InternalChildren: [
        'expander',
        'expanderArrow',
        'revealer',
        'errorView',
    ],
}, class ExtensionPrefsErrorPage extends Adw.PreferencesPage {
    static _classInit(klass) {
        super._classInit(klass);

klass.install_action('page.copy-error',
            null,
            self => {
                const clipboard = self.get_display().get_clipboard();
                clipboard.set(self._errorMarkdown);
            });
        klass.install_action('page.show-url',
            null,
            self => Gtk.show_uri(self.get_root(), self._url, Gdk.CURRENT_TIME));

return klass;
    }

_init(extension, error) {
        super._init();

this._addCustomStylesheet();

this._uuid = extension.uuid;
        this._url = extension.metadata.url || '';

this.action_set_enabled('page.show-url', this._url !== '');

this._gesture = new Gtk.GestureClick({
            button: 0,
            exclusive: true,
        });
        this._expander.add_controller(this._gesture);

this._gesture.connect('released', (gesture, nPress) => {
            if (nPress === 1)
                this._revealer.reveal_child = !this._revealer.reveal_child;
        });

this._revealer.connect('notify::reveal-child', () => {
            this._expanderArrow.icon_name = this._revealer.reveal_child
                ? 'pan-down-symbolic'
                : 'pan-end-symbolic';
            this._syncExpandedStyle();
        });
        this._revealer.connect('notify::child-revealed',
            () => this._syncExpandedStyle());

this._errorView.buffer.text = `${error}\n\nStack trace:\n`;
        // Indent stack trace.
        this._errorView.buffer.text +=
            error.stack.split('\n').map(line => `  ${line}`).join('\n');

// markdown for pasting in gitlab issues
        let lines = [
            `The settings of extension ${this._uuid} had an error:`,
            '```',
            `${error}`,
            '```',
            '',
            'Stack trace:',
            '```',
            error.stack.replace(/\n$/, ''), // stack without trailing newline
            '```',
            '',
        ];
        this._errorMarkdown = lines.join('\n');
    }

_syncExpandedStyle() {
        if (this._revealer.reveal_child)
            this._expander.add_css_class('expanded');
        else if (!this._revealer.child_revealed)
            this._expander.remove_css_class('expanded');
    }

_addCustomStylesheet() {
        let provider = new Gtk.CssProvider();
        let uri = 'resource:///org/gnome/Shell/Extensions/css/application.css';
        try {
            provider.load_from_file(Gio.File.new_for_uri(uri));
        } catch (e) {
            logError(e, 'Failed to add application style');
        }
        Gtk.StyleContext.add_provider_for_display(Gdk.Display.get_default(),
            provider,
            Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION);
    }
});
��(uuay)extensionsService.js����������// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported ExtensionsService */

const { Gio, GLib, Shew } = imports.gi;

const ExtensionUtils = imports.misc.extensionUtils;

const { loadInterfaceXML } = imports.misc.fileUtils;
const { ExtensionPrefsDialog } = imports.extensionPrefsDialog;
const { ServiceImplementation } = imports.dbusService;

const ExtensionsIface = loadInterfaceXML('org.gnome.Shell.Extensions');
const ExtensionsProxy = Gio.DBusProxy.makeProxyWrapper(ExtensionsIface);

var ExtensionsService = class extends ServiceImplementation {
    constructor() {
        super(ExtensionsIface, '/org/gnome/Shell/Extensions');

this._proxy = new ExtensionsProxy(Gio.DBus.session,
            'org.gnome.Shell', '/org/gnome/Shell');

this._proxy.connectSignal('ExtensionStateChanged',
            (proxy, sender, params) => {
                this._dbusImpl.emit_signal('ExtensionStateChanged',
                    new GLib.Variant('(sa{sv})', params));
            });

this._proxy.connect('g-properties-changed', () => {
            this._dbusImpl.emit_property_changed('UserExtensionsEnabled',
                new GLib.Variant('b', this._proxy.UserExtensionsEnabled));
        });
    }

get ShellVersion() {
        return this._proxy.ShellVersion;
    }

get UserExtensionsEnabled() {
        return this._proxy.UserExtensionsEnabled;
    }

set UserExtensionsEnabled(enable) {
        this._proxy.UserExtensionsEnabled = enable;
    }

ListExtensionsAsync(params, invocation) {
        this._proxy.ListExtensionsRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(new GLib.Variant('(a{sa{sv}})', res));
        });
    }

GetExtensionInfoAsync(params, invocation) {
        this._proxy.GetExtensionInfoRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(new GLib.Variant('(a{sv})', res));
        });
    }

GetExtensionErrorsAsync(params, invocation) {
        this._proxy.GetExtensionErrorsRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(new GLib.Variant('(as)', res));
        });
    }

InstallRemoteExtensionAsync(params, invocation) {
        this._proxy.InstallRemoteExtensionRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(new GLib.Variant('(s)', res));
        });
    }

UninstallExtensionAsync(params, invocation) {
        this._proxy.UninstallExtensionRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(new GLib.Variant('(b)', res));
        });
    }

EnableExtensionAsync(params, invocation) {
        this._proxy.EnableExtensionRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(new GLib.Variant('(b)', res));
        });
    }

DisableExtensionAsync(params, invocation) {
        this._proxy.DisableExtensionRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(new GLib.Variant('(b)', res));
        });
    }

LaunchExtensionPrefsAsync([uuid], invocation) {
        this.OpenExtensionPrefsAsync([uuid, '', {}], invocation);
    }

OpenExtensionPrefsAsync(params, invocation) {
        const [uuid, parentWindow, options] = params;

this._proxy.GetExtensionInfoRemote(uuid, (res, error) => {
            if (this._handleError(invocation, error))
                return;

if (this._prefsDialog) {
                this._handleError(invocation,
                    new Error('Already showing a prefs dialog'));
                return;
            }

const [serialized] = res;
            const extension = ExtensionUtils.deserializeExtension(serialized);

this._prefsDialog = new ExtensionPrefsDialog(extension);
            this._prefsDialog.connect('realize', () => {
                let externalWindow = null;

if (parentWindow)
                    externalWindow = Shew.ExternalWindow.new_from_handle(parentWindow);

if (externalWindow)
                    externalWindow.set_parent_of(this._prefsDialog.get_surface());
            });

if (options.modal)
                this._prefsDialog.modal = options.modal.get_boolean();

this._prefsDialog.connect('close-request', () => {
                delete this._prefsDialog;
                this.release();
                return false;
            });
            this.hold();

this._prefsDialog.show();

invocation.return_value(null);
        });
    }

CheckForUpdatesAsync(params, invocation) {
        this._proxy.CheckForUpdatesRemote(...params, (res, error) => {
            if (this._handleError(invocation, error))
                return;

invocation.return_value(null);
        });
    }
};
��(uuay)/����extensionUtils.js���!������// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported ExtensionState, ExtensionType, getCurrentExtension,
   getSettings, initTranslations, gettext, ngettext, pgettext,
   openPrefs, isOutOfDate, installImporter, serializeExtension,
   deserializeExtension */

// Common utils for the extension system and the extension
// preferences tool

const { Gio, GLib } = imports.gi;

const Gettext = imports.gettext;

const Config = imports.misc.config;

var ExtensionType = {
    SYSTEM: 1,
    PER_USER: 2,
};

var ExtensionState = {
    ENABLED: 1,
    DISABLED: 2,
    ERROR: 3,
    OUT_OF_DATE: 4,
    DOWNLOADING: 5,
    INITIALIZED: 6,

// Used as an error state for operations on unknown extensions,
    // should never be in a real extensionMeta object.
    UNINSTALLED: 99,
};

const SERIALIZED_PROPERTIES = [
    'type',
    'state',
    'path',
    'error',
    'hasPrefs',
    'hasUpdate',
    'canChange',
];

/**
 * getCurrentExtension:
 *
 * @returns {?object} - The current extension, or null if not called from
 * an extension.
 */
function getCurrentExtension() {
    let stack = new Error().stack.split('\n');
    let extensionStackLine;

// Search for an occurrence of an extension stack frame
    // Start at 1 because 0 is the stack frame of this function
    for (let i = 1; i < stack.length; i++) {
        if (stack[i].includes('/gnome-shell/extensions/')) {
            extensionStackLine = stack[i];
            break;
        }
    }
    if (!extensionStackLine)
        return null;

// The stack line is like:
    //   init([object Object])@/home/user/data/gnome-shell/extensions/u@u.id/prefs.js:8
    //
    // In the case that we're importing from
    // module scope, the first field is blank:
    //   @/home/user/data/gnome-shell/extensions/u@u.id/prefs.js:8
    let match = new RegExp('@(.+):\\d+').exec(extensionStackLine);
    if (!match)
        return null;

// local import, as the module is used from outside the gnome-shell process
    // as well (not this function though)
    let extensionManager = imports.ui.main.extensionManager;

let path = match[1];
    let file = Gio.File.new_for_path(path);

// Walk up the directory tree, looking for an extension with
    // the same UUID as a directory name.
    while (file != null) {
        let extension = extensionManager.lookup(file.get_basename());
        if (extension !== undefined)
            return extension;
        file = file.get_parent();
    }

return null;
}

/**
 * initTranslations:
 * @param {string=} domain - the gettext domain to use
 *
 * Initialize Gettext to load translations from extensionsdir/locale.
 * If @domain is not provided, it will be taken from metadata['gettext-domain']
 */
function initTranslations(domain) {
    let extension = getCurrentExtension();

if (!extension)
        throw new Error('initTranslations() can only be called from extensions');

domain ||= extension.metadata['gettext-domain'];

// Expect USER extensions to have a locale/ subfolder, otherwise assume a
    // SYSTEM extension that has been installed in the same prefix as the shell
    let localeDir = extension.dir.get_child('locale');
    if (localeDir.query_exists(null))
        Gettext.bindtextdomain(domain, localeDir.get_path());
    else
        Gettext.bindtextdomain(domain, Config.LOCALEDIR);

Object.assign(extension, Gettext.domain(domain));
}

/**
 * gettext:
 * @param {string} str - the string to translate
 *
 * Translate @str using the extension's gettext domain
 *
 * @returns {string} - the translated string
 *
 */
function gettext(str) {
    return callExtensionGettextFunc('gettext', str);
}

/**
 * ngettext:
 * @param {string} str - the string to translate
 * @param {string} strPlural - the plural form of the string
 * @param {number} n - the quantity for which translation is needed
 *
 * Translate @str and choose plural form using the extension's
 * gettext domain
 *
 * @returns {string} - the translated string
 *
 */
function ngettext(str, strPlural, n) {
    return callExtensionGettextFunc('ngettext', str, strPlural, n);
}

/**
 * pgettext:
 * @param {string} context - context to disambiguate @str
 * @param {string} str - the string to translate
 *
 * Translate @str in the context of @context using the extension's
 * gettext domain
 *
 * @returns {string} - the translated string
 *
 */
function pgettext(context, str) {
    return callExtensionGettextFunc('pgettext', context, str);
}

function callExtensionGettextFunc(func, ...args) {
    const extension = getCurrentExtension();

if (!extension)
        throw new Error(`${func}() can only be called from extensions`);

if (!extension[func])
        throw new Error(`${func}() is used without calling initTranslations() first`);

return extension[func](...args);
}

/**
 * getSettings:
 * @param {string=} schema - the GSettings schema id
 * @returns {Gio.Settings} - a new settings object for @schema
 *
 * Builds and returns a GSettings schema for @schema, using schema files
 * in extensionsdir/schemas. If @schema is omitted, it is taken from
 * metadata['settings-schema'].
 */
function getSettings(schema) {
    let extension = getCurrentExtension();

if (!extension)
        throw new Error('getSettings() can only be called from extensions');

schema ||= extension.metadata['settings-schema'];

const GioSSS = Gio.SettingsSchemaSource;

// Expect USER extensions to have a schemas/ subfolder, otherwise assume a
    // SYSTEM extension that has been installed in the same prefix as the shell
    let schemaDir = extension.dir.get_child('schemas');
    let schemaSource;
    if (schemaDir.query_exists(null)) {
        schemaSource = GioSSS.new_from_directory(schemaDir.get_path(),
                                                 GioSSS.get_default(),
                                                 false);
    } else {
        schemaSource = GioSSS.get_default();
    }

let schemaObj = schemaSource.lookup(schema, true);
    if (!schemaObj)
        throw new Error(`Schema ${schema} could not be found for extension ${extension.metadata.uuid}. Please check your installation`);

return new Gio.Settings({ settings_schema: schemaObj });
}

/**
 * openPrefs:
 *
 * Open the preference dialog of the current extension
 */
function openPrefs() {
    const extension = getCurrentExtension();

if (!extension)
        throw new Error('openPrefs() can only be called from extensions');

try {
        const extensionManager = imports.ui.main.extensionManager;
        extensionManager.openExtensionPrefs(extension.uuid, '', {});
    } catch (e) {
        if (e.name === 'ImportError')
            throw new Error('openPrefs() cannot be called from preferences');
        logError(e, 'Failed to open extension preferences');
    }
}

function isOutOfDate(extension) {
    const [major] = Config.PACKAGE_VERSION.split('.');
    return !extension.metadata['shell-version'].some(v => v.startsWith(major));
}

function serializeExtension(extension) {
    let obj = { ...extension.metadata };

SERIALIZED_PROPERTIES.forEach(prop => {
        obj[prop] = extension[prop];
    });

return res;
}

function installImporter(extension) {
    let oldSearchPath = imports.searchPath.slice();  // make a copy
    imports.searchPath = [extension.dir.get_parent().get_path()];
    // importing a "subdir" creates a new importer object that doesn't affect
    // the global one
    extension.imports = imports[extension.uuid];
    imports.searchPath = oldSearchPath;
}
��(uuay)params.js���������// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported parse */

// parse:
// @params: caller-provided parameter object, or %null
// @defaults-provided defaults object
// @allowExtras: whether or not to allow properties not in @default
//
// Examines @params and fills in default values from @defaults for
// any properties in @defaults that don't appear in @params. If
// @allowExtras is not %true, it will throw an error if @params
// contains any properties that aren't in @defaults.
//
// If @params is %null, this returns the values from @defaults.
//
// Return value: a new object, containing the merged parameters from
// @params and @defaults
function parse(params = {}, defaults, allowExtras) {
    if (!allowExtras) {
        for (let prop in params) {
            if (!(prop in defaults))
                throw new Error(`Unrecognized parameter "${prop}"`);
        }
    }

let defaultsCopy = Object.assign({}, defaults);
    return Object.assign(defaultsCopy, params);
}
��(uuay)css/���js/����������������ui/����Extensions/�
���������misc/������������	���dbusService.js��#������/* exported DBusService, ServiceImplementation */

const { Gio, GLib } = imports.gi;

const Signals = imports.signals;

const IDLE_SHUTDOWN_TIME = 2; // s

const { programArgs } = imports.system;

var ServiceImplementation = class {
    constructor(info, objectPath) {
        this._objectPath = objectPath;
        this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(info, this);

this._injectTracking('return_dbus_error');
        this._injectTracking('return_error_literal');
        this._injectTracking('return_gerror');
        this._injectTracking('return_value');
        this._injectTracking('return_value_with_unix_fd_list');

this._senders = new Map();
        this._holdCount = 0;

this._hasSignals = this._dbusImpl.get_info().signals.length > 0;
        this._shutdownTimeoutId = 0;

// subclasses may override this to disable automatic shutdown
        this._autoShutdown = true;

this._queueShutdownCheck();
    }

// subclasses may override this to own additional names
    register() {
    }

export() {
        this._dbusImpl.export(Gio.DBus.session, this._objectPath);
    }

unexport() {
        this._dbusImpl.unexport();
    }

hold() {
        this._holdCount++;
    }

release() {
        if (this._holdCount === 0) {
            logError(new Error('Unmatched call to release()'));
            return;
        }

this._holdCount--;

if (this._holdCount === 0)
            this._queueShutdownCheck();
    }

/**
     * _handleError:
     * @param {Gio.DBusMethodInvocation}
     * @param {Error}
     *
     * Complete @invocation with an appropriate error if @error is set;
     * useful for implementing early returns from method implementations.
     *
     * @returns {bool} - true if @invocation was completed
     */

_handleError(invocation, error) {
        if (error === null)
            return false;

if (error instanceof GLib.Error) {
            invocation.return_gerror(error);
        } else {
            let name = error.name;
            if (!name.includes('.')) // likely a normal JS error
                name = `org.gnome.gjs.JSError.${name}`;
            invocation.return_dbus_error(name, error.message);
        }

return true;
    }

_maybeShutdown() {
        if (!this._autoShutdown)
            return;

if (GLib.getenv('SHELL_DBUS_PERSIST'))
            return;

if (this._holdCount > 0)
            return;

this.emit('shutdown');
    }

_queueShutdownCheck() {
        if (this._shutdownTimeoutId)
            GLib.source_remove(this._shutdownTimeoutId);

this._shutdownTimeoutId = GLib.timeout_add_seconds(
            GLib.PRIORITY_DEFAULT, IDLE_SHUTDOWN_TIME,
            () => {
                this._shutdownTimeoutId = 0;
                this._maybeShutdown();

return GLib.SOURCE_REMOVE;
            });
    }

_trackSender(sender) {
        if (this._senders.has(sender))
            return;

this.hold();
        this._senders.set(sender,
            this._dbusImpl.get_connection().watch_name(
                sender,
                Gio.BusNameWatcherFlags.NONE,
                null,
                () => this._untrackSender(sender)));
    }

_untrackSender(sender) {
        const id = this._senders.get(sender);

if (id)
            this._dbusImpl.get_connection().unwatch_name(id);

if (this._senders.delete(sender))
            this.release();
    }

_injectTracking(methodName) {
        const { prototype } = Gio.DBusMethodInvocation;
        const origMethod = prototype[methodName];
        const that = this;

prototype[methodName] = function (...args) {
            origMethod.apply(this, args);

if (that._hasSignals)
                that._trackSender(this.get_sender());

that._queueShutdownCheck();
        };
    }
};
Signals.addSignalMethods(ServiceImplementation.prototype);

var DBusService = class {
    constructor(name, service) {
        this._name = name;
        this._service = service;
        this._loop = new GLib.MainLoop(null, false);

this._service.connect('shutdown', () => this._loop.quit());
    }

run() {
        // Bail out when not running under gnome-shell
        Gio.DBus.watch_name(Gio.BusType.SESSION,
            'org.gnome.Shell',
            Gio.BusNameWatcherFlags.NONE,
            null,
            () => this._loop.quit());

this._service.register();

let flags = Gio.BusNameOwnerFlags.ALLOW_REPLACEMENT;
        if (programArgs.includes('--replace'))
            flags |= Gio.BusNameOwnerFlags.REPLACE;

Gio.DBus.own_name(Gio.BusType.SESSION,
            this._name,
            flags,
            () => this._service.export(),
            null,
            () => this._loop.quit());

this._loop.run();
    }
};
��(uuay)main.js������������/* exported main */

imports.gi.versions.Adw = '1';
imports.gi.versions.Gdk = '4.0';
imports.gi.versions.Gtk = '4.0';

const { Adw, GObject } = imports.gi;
const pkg = imports.package;

const { DBusService } = imports.dbusService;
const { ExtensionsService } = imports.extensionsService;

function main() {
    Adw.init();
    pkg.initFormat();

GObject.gtypeNameBasedOnJSPath = true;

const service = new DBusService(
        'org.gnome.Shell.Extensions',
        new ExtensionsService());
    service.run();
}
��(uuay)org/����Shell/��
���

${this.title}

Code Editor : org.gnome.Shell.Extensions.src.gresource