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.Extensions.src.gresource

GVariant����������������(	�����������������������	���	���	���KP�������L� ��$���	�����$��	�v�0��u����$0����u���L�|������0I�������L��������H�.�������v�����A��VCb�����A���L��A��B��Oq�e���B���v�B��Ec���s����Ec���L�Pc��Tc��Ե�����Tc���L�Xc��\c��org/���config.js���5�������/* Fake module to satify import in ExtensionUtils */
��(uuay)gnome/����js/�������main.js�����N@������/* exported main */
imports.gi.versions.Adw = '1';
imports.gi.versions.Gtk = '4.0';

const Gettext = imports.gettext;
const Package = imports.package;
const { Adw, GLib, Gio, GObject, Gtk, Shew } = imports.gi;

Package.initFormat();

const ExtensionUtils = imports.misc.extensionUtils;

const { ExtensionState, ExtensionType } = ExtensionUtils;

const GnomeShellIface = loadInterfaceXML('org.gnome.Shell.Extensions');
const GnomeShellProxy = Gio.DBusProxy.makeProxyWrapper(GnomeShellIface);

Gio._promisify(Gio.DBusConnection.prototype, 'call');
Gio._promisify(Shew.WindowExporter.prototype, 'export');

function loadInterfaceXML(iface) {
    const uri = `resource:///org/gnome/Extensions/dbus-interfaces/${iface}.xml`;
    const 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 toggleState(action) {
    let state = action.get_state();
    action.change_state(new GLib.Variant('b', !state.get_boolean()));
}

var Application = GObject.registerClass(
class Application extends Adw.Application {
    _init() {
        GLib.set_prgname('gnome-extensions-app');
        super._init({ application_id: Package.name });

this.connect('window-removed', (a, window) => window.run_dispose());
    }

get shellProxy() {
        return this._shellProxy;
    }

vfunc_activate() {
        this._shellProxy.CheckForUpdatesRemote();
        this._window.present();
    }

vfunc_startup() {
        super.vfunc_startup();

const action = new Gio.SimpleAction({ name: 'quit' });
        action.connect('activate', () => this._window.close());
        this.add_action(action);

this.set_accels_for_action('app.quit', ['<Primary>q']);

this._shellProxy = new GnomeShellProxy(Gio.DBus.session,
            'org.gnome.Shell.Extensions', '/org/gnome/Shell/Extensions');

this._window = new ExtensionsWindow({ application: this });
    }
});

var ExtensionsWindow = GObject.registerClass({
    GTypeName: 'ExtensionsWindow',
    Template: 'resource:///org/gnome/Extensions/ui/extensions-window.ui',
    InternalChildren: [
        'userGroup',
        'userList',
        'systemGroup',
        'systemList',
        'mainStack',
        'searchBar',
        'searchButton',
        'searchEntry',
        'updatesBar',
        'updatesLabel',
    ],
}, class ExtensionsWindow extends Gtk.ApplicationWindow {
    _init(params) {
        super._init(params);

this._updatesCheckId = 0;

this._exporter = new Shew.WindowExporter({ window: this });
        this._exportedHandle = '';

let action;
        action = new Gio.SimpleAction({ name: 'show-about' });
        action.connect('activate', this._showAbout.bind(this));
        this.add_action(action);

action = new Gio.SimpleAction({ name: 'logout' });
        action.connect('activate', this._logout.bind(this));
        this.add_action(action);

action = new Gio.SimpleAction({
            name: 'user-extensions-enabled',
            state: new GLib.Variant('b', false),
        });
        action.connect('activate', toggleState);
        action.connect('change-state', (a, state) => {
            this._shellProxy.UserExtensionsEnabled = state.get_boolean();
        });
        this.add_action(action);

this._searchTerms = [];
        this._searchEntry.connect('search-changed', () => {
            const { text } = this._searchEntry;
            if (text === '')
                this._searchTerms = [];
            else
                [this._searchTerms] = GLib.str_tokenize_and_fold(text, null);

this._userList.invalidate_filter();
            this._systemList.invalidate_filter();
        });

this._userList.set_sort_func(this._sortList.bind(this));
        this._userList.set_filter_func(this._filterList.bind(this));
        this._userList.set_placeholder(new Gtk.Label({
            label: _('No Matches'),
            margin_start: 12,
            margin_end: 12,
            margin_top: 12,
            margin_bottom: 12,
        }));
        this._userList.connect('row-activated', (_list, row) => row.activate());

this._systemList.set_sort_func(this._sortList.bind(this));
        this._systemList.set_filter_func(this._filterList.bind(this));
        this._systemList.set_placeholder(new Gtk.Label({
            label: _('No Matches'),
            margin_start: 12,
            margin_end: 12,
            margin_top: 12,
            margin_bottom: 12,
        }));
        this._systemList.connect('row-activated', (_list, row) => row.activate());

this._shellProxy.connectSignal('ExtensionStateChanged',
            this._onExtensionStateChanged.bind(this));

this._shellProxy.connect('g-properties-changed',
            this._onUserExtensionsEnabledChanged.bind(this));
        this._onUserExtensionsEnabledChanged();

this._scanExtensions();
    }

get _shellProxy() {
        return this.application.shellProxy;
    }

uninstall(uuid) {
        let row = this._findExtensionRow(uuid);

let dialog = new Gtk.MessageDialog({
            transient_for: this,
            modal: true,
            text: _('Remove “%s”?').format(row.name),
            secondary_text: _('If you remove the extension, you need to return to download it if you want to enable it again'),
        });

dialog.add_button(_('Cancel'), Gtk.ResponseType.CANCEL);
        dialog.add_button(_('Remove'), Gtk.ResponseType.ACCEPT)
            .get_style_context().add_class('destructive-action');

dialog.connect('response', (dlg, response) => {
            if (response === Gtk.ResponseType.ACCEPT)
                this._shellProxy.UninstallExtensionRemote(uuid);
            dialog.destroy();
        });
        dialog.present();
    }

async openPrefs(uuid) {
        if (!this._exportedHandle) {
            try {
                this._exportedHandle = await this._exporter.export();
            } catch (e) {
                log(`Failed to export window: ${e.message}`);
            }
        }

this._shellProxy.OpenExtensionPrefsRemote(uuid,
            this._exportedHandle,
            { modal: new GLib.Variant('b', true) });
    }

_showAbout() {
        let aboutDialog = new Gtk.AboutDialog({
            authors: [
                'Florian Müllner <fmuellner@gnome.org>',
                'Jasper St. Pierre <jstpierre@mecheye.net>',
                'Didier Roche <didrocks@ubuntu.com>',
                'Romain Vigier <contact@romainvigier.fr>',
            ],
            translator_credits: _('translator-credits'),
            program_name: _('Extensions'),
            comments: _('Manage your GNOME Extensions'),
            license_type: Gtk.License.GPL_2_0,
            logo_icon_name: Package.name,
            version: Package.version,

transient_for: this,
            modal: true,
        });
        aboutDialog.present();
    }

_logout() {
        this.application.get_dbus_connection().call(
            'org.gnome.SessionManager',
            '/org/gnome/SessionManager',
            'org.gnome.SessionManager',
            'Logout',
            new GLib.Variant('(u)', [0]),
            null,
            Gio.DBusCallFlags.NONE,
            -1,
            null);
    }

_sortList(row1, row2) {
        return row1.name.localeCompare(row2.name);
    }

_filterList(row) {
        return this._searchTerms.every(
            t => row.keywords.some(k => k.startsWith(t)));
    }

_findExtensionRow(uuid) {
        return [
            ...this._userList,
            ...this._systemList,
        ].find(c => c.uuid === uuid);
    }

_onUserExtensionsEnabledChanged() {
        let action = this.lookup_action('user-extensions-enabled');
        action.set_state(
            new GLib.Variant('b', this._shellProxy.UserExtensionsEnabled));
    }

_onExtensionStateChanged(proxy, senderName, [uuid, newState]) {
        let extension = ExtensionUtils.deserializeExtension(newState);
        let row = this._findExtensionRow(uuid);

this._queueUpdatesCheck();

// the extension's type changed; remove the corresponding row
        // and reset the variable to null so that we create a new row
        // below and add it to the appropriate list
        if (row && row.type !== extension.type) {
            row.get_parent().remove(row);
            row = null;
        }

if (row) {
            if (extension.state === ExtensionState.UNINSTALLED)
                row.get_parent().remove(row);
        } else {
            this._addExtensionRow(extension);
        }

this._syncListVisibility();
    }

_scanExtensions() {
        this._shellProxy.ListExtensionsRemote(([extensionsMap], e) => {
            if (e) {
                if (e instanceof Gio.DBusError) {
                    log(`Failed to connect to shell proxy: ${e}`);
                    this._mainStack.visible_child_name = 'noshell';
                } else {
                    throw e;
                }
                return;
            }

for (let uuid in extensionsMap) {
                let extension = ExtensionUtils.deserializeExtension(extensionsMap[uuid]);
                this._addExtensionRow(extension);
            }
            this._extensionsLoaded();
        });
    }

_addExtensionRow(extension) {
        let row = new ExtensionRow(extension);

if (row.type === ExtensionType.PER_USER)
            this._userList.append(row);
        else
            this._systemList.append(row);
    }

_queueUpdatesCheck() {
        if (this._updatesCheckId)
            return;

this._updatesCheckId = GLib.timeout_add_seconds(
            GLib.PRIORITY_DEFAULT, 1, () => {
                this._checkUpdates();

this._updatesCheckId = 0;
                return GLib.SOURCE_REMOVE;
            });
    }

_syncListVisibility() {
        this._userGroup.visible = [...this._userList].length > 1;
        this._systemGroup.visible = [...this._systemList].length > 1;

if (this._userGroup.visible || this._systemGroup.visible)
            this._mainStack.visible_child_name = 'main';
        else
            this._mainStack.visible_child_name = 'placeholder';
    }

_checkUpdates() {
        let nUpdates = [...this._userList].filter(c => c.hasUpdate).length;

this._updatesLabel.label = Gettext.ngettext(
            '%d extension will be updated on next login.',
            '%d extensions will be updated on next login.',
            nUpdates).format(nUpdates);
        this._updatesBar.revealed = nUpdates > 0;
    }

_extensionsLoaded() {
        this._syncListVisibility();
        this._checkUpdates();
    }
});

var ExtensionRow = GObject.registerClass({
    GTypeName: 'ExtensionRow',
    Template: 'resource:///org/gnome/Extensions/ui/extension-row.ui',
    InternalChildren: [
        'nameLabel',
        'descriptionLabel',
        'versionLabel',
        'errorLabel',
        'errorIcon',
        'updatesIcon',
        'switch',
        'actionsBox',
    ],
}, class ExtensionRow extends Gtk.ListBoxRow {
    _init(extension) {
        super._init();

this._app = Gio.Application.get_default();
        this._extension = extension;
        this._prefsModule = null;

[this._keywords] = GLib.str_tokenize_and_fold(this.name, null);

this._actionGroup = new Gio.SimpleActionGroup();
        this.insert_action_group('row', this._actionGroup);

let action;
        action = new Gio.SimpleAction({
            name: 'show-prefs',
            enabled: this.hasPrefs,
        });
        action.connect('activate', () => this.get_root().openPrefs(this.uuid));
        this._actionGroup.add_action(action);

action = new Gio.SimpleAction({
            name: 'show-url',
            enabled: this.url !== '',
        });
        action.connect('activate', () => {
            Gio.AppInfo.launch_default_for_uri(
                this.url, this.get_display().get_app_launch_context());
        });
        this._actionGroup.add_action(action);

action = new Gio.SimpleAction({
            name: 'uninstall',
            enabled: this.type === ExtensionType.PER_USER,
        });
        action.connect('activate', () => this.get_root().uninstall(this.uuid));
        this._actionGroup.add_action(action);

action = new Gio.SimpleAction({
            name: 'enabled',
            state: new GLib.Variant('b', false),
        });
        action.connect('activate', toggleState);
        action.connect('change-state', (a, state) => {
            if (state.get_boolean())
                this._app.shellProxy.EnableExtensionRemote(this.uuid);
            else
                this._app.shellProxy.DisableExtensionRemote(this.uuid);
        });
        this._actionGroup.add_action(action);

this._nameLabel.label = this.name;

const desc = this._extension.metadata.description.split('\n')[0];
        this._descriptionLabel.label = desc;
        this._descriptionLabel.tooltip_text = desc;

this.connect('destroy', this._onDestroy.bind(this));

this._extensionStateChangedId = this._app.shellProxy.connectSignal(
            'ExtensionStateChanged', (p, sender, [uuid, newState]) => {
                if (this.uuid !== uuid)
                    return;

this._extension = ExtensionUtils.deserializeExtension(newState);
                this._updateState();
            });
        this._updateState();
    }

vfunc_activate() {
        this._switch.mnemonic_activate(false);
    }

get uuid() {
        return this._extension.uuid;
    }

get name() {
        return this._extension.metadata.name;
    }

get hasPrefs() {
        return this._extension.hasPrefs;
    }

get hasUpdate() {
        return this._extension.hasUpdate || false;
    }

get hasError() {
        const { state } = this._extension;
        return state === ExtensionState.OUT_OF_DATE ||
               state === ExtensionState.ERROR;
    }

get type() {
        return this._extension.type;
    }

get creator() {
        return this._extension.metadata.creator || '';
    }

get url() {
        return this._extension.metadata.url || '';
    }

get version() {
        return this._extension.metadata.version || '';
    }

get error() {
        if (!this.hasError)
            return '';

if (this._extension.state === ExtensionState.OUT_OF_DATE)
            return _('The extension is incompatible with the current GNOME version');

return this._extension.error
            ? this._extension.error : _('The extension had an error');
    }

get keywords() {
        return this._keywords;
    }

_updateState() {
        let state = this._extension.state === ExtensionState.ENABLED;

let action = this._actionGroup.lookup('enabled');
        action.set_state(new GLib.Variant('b', state));
        action.enabled = this._canToggle();

if (!action.enabled)
            this._switch.active = state;

this._updatesIcon.visible = this.hasUpdate;
        this._errorIcon.visible = this.hasError;

this._descriptionLabel.visible = !this.hasError;

this._errorLabel.label = this.error;
        this._errorLabel.visible = this.error !== '';

this._versionLabel.label = this.version.toString();
        this._versionLabel.visible = this.version !== '';
    }

_onDestroy() {
        if (!this._app.shellProxy)
            return;

if (this._extensionStateChangedId)
            this._app.shellProxy.disconnectSignal(this._extensionStateChangedId);
        this._extensionStateChangedId = 0;
    }

_canToggle() {
        return this._extension.canChange;
    }
});

function initEnvironment() {
    // Monkey-patch in a "global" object that fakes some Shell utilities
    // that ExtensionUtils depends on.
    globalThis.global = {
        log(...args) {
            print(args.join(', '));
        },

logError(s) {
            log(`ERROR: ${s}`);
        },

userdatadir: GLib.build_filenamev([GLib.get_user_data_dir(), 'gnome-shell']),
    };
}

function main(argv) {
    initEnvironment();
    Package.initGettext();

new Application().run(argv);
}
��(uuay)misc/�������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)Extensions/���/�������

${this.title}

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