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

GVariant�����������p�����(�������������������������������	���������Xj7���p���L�x�������<�������L�������'��y�������v����������?��������v����1$��ě�c���1$���v�H$���_��KP�����_���L��_���`���Q����`���L�`��`��Ե�����`���L�`��`����$0���`���L�`�� `��M����� `���v�(`��Ha��gU����Ha��	�v�Xa���d��]��
����d���L��d���d��misc/���
������Screencast/����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)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)screencastService.js����;������// -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
/* exported ScreencastService */

imports.gi.versions.Gst = '1.0';
imports.gi.versions.Gtk = '4.0';

const { Gio, GLib, Gst, Gtk } = imports.gi;

const { loadInterfaceXML, loadSubInterfaceXML } = imports.misc.fileUtils;
const { ServiceImplementation } = imports.dbusService;

const ScreencastIface = loadInterfaceXML('org.gnome.Shell.Screencast');

const IntrospectIface = loadInterfaceXML('org.gnome.Shell.Introspect');
const IntrospectProxy = Gio.DBusProxy.makeProxyWrapper(IntrospectIface);

const ScreenCastIface = loadSubInterfaceXML(
    'org.gnome.Mutter.ScreenCast', 'org.gnome.Mutter.ScreenCast');
const ScreenCastSessionIface = loadSubInterfaceXML(
    'org.gnome.Mutter.ScreenCast.Session', 'org.gnome.Mutter.ScreenCast');
const ScreenCastStreamIface = loadSubInterfaceXML(
    'org.gnome.Mutter.ScreenCast.Stream', 'org.gnome.Mutter.ScreenCast');
const ScreenCastProxy = Gio.DBusProxy.makeProxyWrapper(ScreenCastIface);
const ScreenCastSessionProxy = Gio.DBusProxy.makeProxyWrapper(ScreenCastSessionIface);
const ScreenCastStreamProxy = Gio.DBusProxy.makeProxyWrapper(ScreenCastStreamIface);

const DEFAULT_PIPELINE = 'videoconvert chroma-mode=GST_VIDEO_CHROMA_MODE_NONE dither=GST_VIDEO_DITHER_NONE matrix-mode=GST_VIDEO_MATRIX_MODE_OUTPUT_ONLY n-threads=%T ! queue ! vp8enc cpu-used=16 max-quantizer=17 deadline=1 keyframe-mode=disabled threads=%T static-threshold=1000 buffer-size=20000 ! queue ! webmmux';
const DEFAULT_FRAMERATE = 30;
const DEFAULT_DRAW_CURSOR = true;

const PipelineState = {
    INIT: 0,
    PLAYING: 1,
    FLUSHING: 2,
    STOPPED: 3,
};

const SessionState = {
    INIT: 0,
    ACTIVE: 1,
    STOPPED: 2,
};

var Recorder = class {
    constructor(sessionPath, x, y, width, height, filePath, options,
        invocation,
        onErrorCallback) {
        this._startInvocation = invocation;
        this._dbusConnection = invocation.get_connection();
        this._onErrorCallback = onErrorCallback;
        this._stopInvocation = null;

this._x = x;
        this._y = y;
        this._width = width;
        this._height = height;
        this._filePath = filePath;

try {
            const dir = Gio.File.new_for_path(filePath).get_parent();
            dir.make_directory_with_parents(null);
        } catch (e) {
            if (!e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.EXISTS))
                throw e;
        }

this._pipelineString = DEFAULT_PIPELINE;
        this._framerate = DEFAULT_FRAMERATE;
        this._drawCursor = DEFAULT_DRAW_CURSOR;

this._applyOptions(options);
        this._watchSender(invocation.get_sender());

this._initSession(sessionPath);
    }

_applyOptions(options) {
        for (const option in options)
            options[option] = options[option].deep_unpack();

if (options['pipeline'] !== undefined)
            this._pipelineString = options['pipeline'];
        if (options['framerate'] !== undefined)
            this._framerate = options['framerate'];
        if ('draw-cursor' in options)
            this._drawCursor = options['draw-cursor'];
    }

_addRecentItem() {
        const file = Gio.File.new_for_path(this._filePath);
        Gtk.RecentManager.get_default().add_item(file.get_uri());
    }

_watchSender(sender) {
        this._nameWatchId = this._dbusConnection.watch_name(
            sender,
            Gio.BusNameWatcherFlags.NONE,
            null,
            this._senderVanished.bind(this));
    }

_unwatchSender() {
        if (this._nameWatchId !== 0) {
            this._dbusConnection.unwatch_name(this._nameWatchId);
            this._nameWatchId = 0;
        }
    }

_senderVanished() {
        this._unwatchSender();

this.stopRecording(null);
    }

_notifyStopped() {
        this._unwatchSender();
        if (this._onStartedCallback)
            this._onStartedCallback(this, false);
        else if (this._onStoppedCallback)
            this._onStoppedCallback(this);
        else
            this._onErrorCallback(this);
    }

_onSessionClosed() {
        switch (this._pipelineState) {
        case PipelineState.STOPPED:
            break;
        default:
            this._pipeline.set_state(Gst.State.NULL);
            log(`Unexpected pipeline state: ${this._pipelineState}`);
            break;
        }
        this._notifyStopped();
    }

_initSession(sessionPath) {
        this._sessionProxy = new ScreenCastSessionProxy(Gio.DBus.session,
            'org.gnome.Mutter.ScreenCast',
            sessionPath);
        this._sessionProxy.connectSignal('Closed', this._onSessionClosed.bind(this));
    }

_startPipeline(nodeId) {
        if (!this._ensurePipeline(nodeId))
            return;

const bus = this._pipeline.get_bus();
        bus.add_watch(bus, this._onBusMessage.bind(this));

this._pipeline.set_state(Gst.State.PLAYING);
        this._pipelineState = PipelineState.PLAYING;

this._onStartedCallback(this, true);
        this._onStartedCallback = null;
    }

startRecording(onStartedCallback) {
        this._onStartedCallback = onStartedCallback;

const [streamPath] = this._sessionProxy.RecordAreaSync(
            this._x, this._y,
            this._width, this._height,
            {
                'is-recording': GLib.Variant.new('b', true),
                'cursor-mode': GLib.Variant.new('u', this._drawCursor ? 1 : 0),
            });

this._streamProxy = new ScreenCastStreamProxy(Gio.DBus.session,
            'org.gnome.Mutter.ScreenCast',
            streamPath);

this._streamProxy.connectSignal('PipeWireStreamAdded',
            (proxy, sender, params) => {
                const [nodeId] = params;
                this._startPipeline(nodeId);
            });
        this._sessionProxy.StartSync();
        this._sessionState = SessionState.ACTIVE;
    }

stopRecording(onStoppedCallback) {
        this._pipelineState = PipelineState.FLUSHING;
        this._onStoppedCallback = onStoppedCallback;
        this._pipeline.send_event(Gst.Event.new_eos());
    }

_stopSession() {
        this._sessionProxy.StopSync();
        this._sessionState = SessionState.STOPPED;
    }

_onBusMessage(bus, message, _) {
        switch (message.type) {
        case Gst.MessageType.EOS:
            this._pipeline.set_state(Gst.State.NULL);
            this._addRecentItem();

switch (this._pipelineState) {
            case PipelineState.FLUSHING:
                this._pipelineState = PipelineState.STOPPED;
                break;
            default:
                break;
            }

switch (this._sessionState) {
            case SessionState.ACTIVE:
                this._stopSession();
                break;
            case SessionState.STOPPED:
                this._notifyStopped();
                break;
            default:
                break;
            }

break;
        default:
            break;
        }
        return true;
    }

_substituteThreadCount(pipelineDescr) {
        const numProcessors = GLib.get_num_processors();
        const numThreads = Math.min(Math.max(1, numProcessors), 64);
        return pipelineDescr.replaceAll('%T', numThreads);
    }

_ensurePipeline(nodeId) {
        const framerate = this._framerate;
        const needsCopy =
            Gst.Registry.get().check_feature_version('pipewiresrc', 0, 3, 57) &&
            !Gst.Registry.get().check_feature_version('videoconvert', 1, 20, 4);

let fullPipeline = `
            pipewiresrc path=${nodeId}
                        always-copy=${needsCopy}
                        do-timestamp=true
                        keepalive-time=1000
                        resend-last=true !
            video/x-raw,max-framerate=${framerate}/1 !
            ${this._pipelineString} !
            filesink location="${this._filePath}"`;
        fullPipeline = this._substituteThreadCount(fullPipeline);

try {
            this._pipeline = Gst.parse_launch_full(fullPipeline,
                null,
                Gst.ParseFlags.FATAL_ERRORS);
        }  catch (e) {
            log(`Failed to create pipeline: ${e}`);
            this._notifyStopped();
        }
        return !!this._pipeline;
    }
};

var ScreencastService = class extends ServiceImplementation {
    constructor() {
        super(ScreencastIface, '/org/gnome/Shell/Screencast');

Gst.init(null);
        Gtk.init();

this._recorders = new Map();
        this._senders = new Map();

this._lockdownSettings = new Gio.Settings({
            schema_id: 'org.gnome.desktop.lockdown',
        });

this._proxy = new ScreenCastProxy(Gio.DBus.session,
            'org.gnome.Mutter.ScreenCast',
            '/org/gnome/Mutter/ScreenCast');

this._introspectProxy = new IntrospectProxy(Gio.DBus.session,
            'org.gnome.Shell.Introspect',
            '/org/gnome/Shell/Introspect');
    }

_removeRecorder(sender) {
        this._recorders.delete(sender);
        if (this._recorders.size === 0)
            this.release();
    }

_addRecorder(sender, recorder) {
        this._recorders.set(sender, recorder);
        if (this._recorders.size === 1)
            this.hold();
    }

_getAbsolutePath(filename) {
        if (GLib.path_is_absolute(filename))
            return filename;

const videoDir =
            GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_VIDEOS) ||
            GLib.get_home_dir();

return GLib.build_filenamev([videoDir, filename]);
    }

_generateFilePath(template) {
        let filename = '';
        let escape = false;

[...template].forEach(c => {
            if (escape) {
                switch (c) {
                case '%':
                    filename += '%';
                    break;
                case 'd': {
                    const datetime = GLib.DateTime.new_now_local();
                    const datestr = datetime.format('%0x');
                    const datestrEscaped = datestr.replace(/\//g, '-');

filename += datestrEscaped;
                    break;
                }

case 't': {
                    const datetime = GLib.DateTime.new_now_local();
                    const datestr = datetime.format('%0X');
                    const datestrEscaped = datestr.replace(/\//g, ':');

filename += datestrEscaped;
                    break;
                }

default:
                    log(`Warning: Unknown escape ${c}`);
                }

escape = false;
            } else if (c === '%') {
                escape = true;
            } else {
                filename += c;
            }
        });

if (escape)
            filename += '%';

return this._getAbsolutePath(filename);
    }

ScreencastAsync(params, invocation) {
        let returnValue = [false, ''];

if (this._lockdownSettings.get_boolean('disable-save-to-disk')) {
            invocation.return_value(GLib.Variant.new('(bs)', returnValue));
            return;
        }

const sender = invocation.get_sender();

if (this._recorders.get(sender)) {
            invocation.return_value(GLib.Variant.new('(bs)', returnValue));
            return;
        }

const [sessionPath] = this._proxy.CreateSessionSync({});

const [fileTemplate, options] = params;
        const [screenWidth, screenHeight] = this._introspectProxy.ScreenSize;
        const filePath = this._generateFilePath(fileTemplate);

let recorder;

try {
            recorder = new Recorder(
                sessionPath,
                0, 0,
                screenWidth, screenHeight,
                filePath,
                options,
                invocation,
                _recorder => this._removeRecorder(sender));
        } catch (error) {
            log(`Failed to create recorder: ${error.message}`);
            invocation.return_value(GLib.Variant.new('(bs)', returnValue));
            return;
        }

this._addRecorder(sender, recorder);

try {
            recorder.startRecording(
                (_, result) => {
                    if (result) {
                        returnValue = [true, filePath];
                        invocation.return_value(GLib.Variant.new('(bs)', returnValue));
                    } else {
                        this._removeRecorder(sender);
                        invocation.return_value(GLib.Variant.new('(bs)', returnValue));
                    }
                });
        } catch (error) {
            log(`Failed to start recorder: ${error.message}`);
            this._removeRecorder(sender);
            invocation.return_value(GLib.Variant.new('(bs)', returnValue));
        }
    }

ScreencastAreaAsync(params, invocation) {
        let returnValue = [false, ''];

if (this._lockdownSettings.get_boolean('disable-save-to-disk')) {
            invocation.return_value(GLib.Variant.new('(bs)', returnValue));
            return;
        }

const sender = invocation.get_sender();

if (this._recorders.get(sender)) {
            invocation.return_value(GLib.Variant.new('(bs)', returnValue));
            return;
        }

const [sessionPath] = this._proxy.CreateSessionSync({});

const [x, y, width, height, fileTemplate, options] = params;
        const filePath = this._generateFilePath(fileTemplate);

let recorder;

try {
            recorder = new Recorder(
                sessionPath,
                x, y,
                width, height,
                filePath,
                options,
                invocation,
                _recorder => this._removeRecorder(sender));
        } catch (error) {
            log(`Failed to create recorder: ${error.message}`);
            invocation.return_value(GLib.Variant.new('(bs)', returnValue));
            return;
        }

this._addRecorder(sender, recorder);

StopScreencastAsync(params, invocation) {
        const sender = invocation.get_sender();

const recorder = this._recorders.get(sender);
        if (!recorder) {
            invocation.return_value(GLib.Variant.new('(b)', [false]));
            return;
        }

recorder.stopRecording(() => {
            this._removeRecorder(sender);
            invocation.return_value(GLib.Variant.new('(b)', [true]));
        });
    }
};
��(uuay)org/������Shell/�����/������gnome/�����main.js�������/* exported main */

const { DBusService } = imports.dbusService;
const { ScreencastService } = imports.screencastService;

function main() {
    const service = new DBusService(
        'org.gnome.Shell.Screencast',
        new ScreencastService());
    service.run();
}
��(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)js/������	����������

${this.title}

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