Review "Gtk4 Desktop Icons NG (DING)" version 100.22 (135)

                    console.log('desktop-icons: The desktop is writable by' +
                        ' others. Not allowing launching any desktop files.'
                    )
            console.log(
                'Exception while updating Desktop after a' +
                ` mount was added: ${e.message}\n${e.stack}`
            )
            console.log(
                'Exception while updating Desktop after a ' +
                `mount was removed: ${e.message}\n${e.stack}`
            )
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
                        console.error(
                            e,
                            'Exception while updating desktop from' +
                            ` Directory Monitor attribute change: ${e.message}`
                        )
            console.error(
                e,
                'Exception while updating desktop from Directory Monitor: ' +
                `${e.message}`
            )
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
                        console.error(e, `Error opening ${fileItem.uri}` +
                            ` in GNOME Files: ${e.message}`)
            console.error(
                `Unable to create Folder ${defaultDesktop}: ${e.message}`
            )
console.error(e, `XDG Desktop not set, ${e}`)
console.error('No system xdg user-dirs.default file')
console.error(e, `XDG Desktop not set in user-dirs.default, ${e}`)
console.error(e, `Error selecting folder: ${e.message}`)
console.error(e, `Failed to write XDG Desktop file with ${e}`)
console.error(e, `Failed to write XDG Desktop file with ${e}`)
console.log('Not enough space to add icons')
            console.log('Exception while updating desktop after the hidden ' +
                `settings changed: ${e.message}\n${e.stack}`)
            console.log('Exception while reloading desktop after icon ' +
                `size change: ${e.message}\n${e.stack}`)
console.error(e, 'Error loading stackMarker icon')
                    console.error(
                        e, `Failed to set attributes to ${dir.get_path()}`)
console.error(e, `Failed to create folder ${e.message}`)
            console.error(
                `Error while redrawing desktop: ${e.message}\n${e.stack}`
            )
console.error(`Error while refreshing desktop: ${e.message}`)
console.error(`Error while reframing desktop: ${e.message}`)
                    console.log(
                        'Could not parse desktopFile as a desktop file,' +
                        ' cannot set shell cursor'
                    )
console.log('Could not parse desktopFile as desktop file')
console.error(e)
console.error(e)
console.error(e)
                console.error(
                    e, `Error opening ${uri} in GNOME Files: ${e.message}`
                )
            console.error(e,
                'Error reading desktop file. Cannot set shell Cursor'
            )
                console.error(e,
                    'Error reading desktop file. Cannot launch application.'
                )
console.error(e)
                console.log(
                    `Timeout while generating thumbnail for ${file.displayName}`
                )
            console.log(
                `Error when asking for a thumbnail for ${file.displayName}:` +
                ` ${error.message}\n${error.stack}`)
console.error(`Error saving thumbnail ${e}`)
                console.error(e,
                    'Error creating thumbnail with thumbnailFactory: ' +
                    `${e.message}`
                )
console.error(`Error saving thumbnail ${e}`)
                console.error(e,
                    `Error while creating failed thumbnail: ${e.message}`
                )
                console.error(e,
                    `Error while generating icon image: ${e.message}`
                )
                console.error(e,
                    `Error creating pdf thumbnail pixbuf ${file.uri}`
                )
            console.error(e,
                `Error creating image thumbnail pixbuf ${file.uri}`
            )
console.log(`Failed to get the list of mounts with ${e}`)
console.log(`Failed with ${e} while getting volume`)
                                        console.log(
                                            'Failed to make executable ' +
                                            `.desktop File: ${error.message}`
                                        )
console.error(e, `${commandLine} failed with ${e}`)
console.error(`Error determining encryption Zip file ${e}`)
console.error(`Error determining encryption 7z file ${e}`)
console.error(e)
console.error(`readJsonFile(${file.get_path?.() ?? '??'}):`, e)
console.error('writeJsonFile: JSON.stringify failed:', e)
                    console.log(
                        `Exception while updating desktop after pressing "F5":
                        ${e.message}\n${e.stack}`)
                                    console.log(
                                        'Exception while reading clipboard:' +
                                        `${e.message}\n${e.stack}`
                                    )
                        console.log(
                            `Exception while reading clipboard mimetype
                            x-special/gnome-copied-files:
                            ${e.message}\n${e.stack}`
                        )
                        console.log(
                            'Exception while reading clipboard media-type ' +
                            `"text/plain": ${e.message}\n${e.stack}`
                        )
console.error(e)
console.error(e, 'Paste action failed')
            console.error(
                e, `Error opening desktop in GNOME Files: ${e.message}`
            )
                console.error(
                    e, `Failed to set template metadata ${e.message}`)
console.error(e, `Failed to create template ${e.message}`)
console.error(e, 'Error updating Clipboard')
                console.log(
                    'Exception while doing move with drag and drop and' +
                    `"Keep arranged…": ${e.message}\n${e.stack}`)
console.error(e, 'Error making file-system links')
console.error(e)
console.error(`Cannot Copy/Move, ${uri} does not exist`)
console.error('Error moving files')
console.error('Error copying files')
console.error('Error making links')
                        console.error(
                            e,
                            'Error asking choosing what to do with Files ' +
                            `${e.message}`
                        )
console.error(e, 'Error setting link FileInfo')
console.error('Error making desktop links')
            console.log(
                'Could not apply discrete GPU environment, switcheroo-control' +
                ' not available'
            )
            console.log(
                'Could not apply discrete GPU environment. No GPUs in list.'
            )
console.log('Could not find discrete GPU data in switcheroo-control')
console.error(e, `Error getting file info: ${e.message}`)
console.error(`Error updating after setting encryption status ${e}`)
                console.error(
                    e, `Error opening file ${this.file.get_uri()}: ${e.message}`
                )
console.error(e)
                console.error(
                    e,
                    `Exception while updating ${
                        this._getVisibleName()
                            ? this._getVisibleName()
                            : 'updating icon'
                    }: ${e.message}`)
                console.error(
                    e,
                    'Exception while updating icon on Attribute Changed: ' +
                    `${e.message}`
                )
                console.error(
                    e,
                    'Exception while updating icon on Metadata Changed: ' +
                    `${e.message}`
                )
console.log('Reverting to old method of selecting')
console.log('zip command not installed, cannot send email')
console.log(`Error Zipping Files, ${e}`)
console.log('xdg-email command not installed, cannot send email')
console.log(`Error emailing Files, ${e}`)
console.log('Executed xdg-terminal-exec')
console.log(`Error opening xdg-terminal-exec ${e}`)
console.log(`{Error opening ${t.get_string('Name')}, ${e}`)
console.error(e)
console.error(e)
this._webView.run_dispose()
console.log(`HtmlWidget backend ${level}:`, inst.instanceId, text)
            console.error(
                'HtmlWidgetHostWithBackend: failed to fetch descriptor:',
                e
            )
            console.error(
                'HtmlWidgetHostWithBackend: no descriptor for widget',
                inst?.widgetId ?? '<unknown>'
            )
            console.error(
                'HtmlWidgetHostWithBackend: no backend configured for widget',
                inst?.widgetId ?? '<unknown>'
            )
console.error('BACKEND stdout loop error:', e?.message ?? e)
console.error('BACKEND stderr loop error:', e?.message ?? e)
            console.error(
                'HtmlWidgetHostWithBackend: failed to start backend:', e
            )
            console.error(
                'HtmlWidgetHostWithBackend: write backend failed:', e
            )
console.error('BACKEND stream read error:', label, e?.message ?? e)
console.error('BACKEND stdout JSON parse error:', e?.message ?? e)
console.log('Adw-DING enabled.')
console.log('Adw-DING disabled.')
console.log(`${name} DBus Name Acquired`)
console.log(`${name} DBus and Name Lost`)
console.log(`${this.dbusConnectionName} DBus Name Relinquished`)
console.log(`Killing old DING process ${filename}`)
console.log('Launching Adw-DING process')
                console.log(
                    `${this._processID}: ${textDecoder.decode(output)}`
                )
console.error('Gtk4 DING extension requires a Wayland session')
console.error(e)
console.log('System supports accent colors')
console.log('System does not support accent colors')
console.log('schemaObj does not exist!')
console.log('Current extension path:', this._extensionPath)
console.log('Current schemaFile:', schemaFile.get_path())
console.log('Schema File exists:', schemaFile.query_exists(null))
            console.log(
                'Error loading widget state from widgets.json:',
                e.message ?? e
            )
                    console.log(
                        'Exception while updating desktop after "Dark Text"' +
                        ` changed: ${e.message}\n${e.stack}`
                    )
                    console.log(
                        'Exception while updating desktop after ' +
                        `"Show Emblems" changed: ${e.message}\n${e.stack}`
                    )
                console.log('Exception while updating Desktop after the' +
                    ` settings changed: ${e.message}\n${e.stack}`
                )
                            console.log(
                                'Exception while updating entries in ' +
                                `monitor: ${e.message}\n${e.stack}`
                            )
                console.log(
                    'Exception while updating entries: ' +
                    `${e.message}\n${e.stack}`
                )
                console.log(
                    'Limiting the number of folders monitored in ' +
                    'templates/scripts...'
                )
                console.log(
                    'Limiting submenu depth of folders monitored' +
                    ' in templates/scripts...'
                )
console.log('Truncating menu entries templates/scripts submenu')
console.error(e)
console.error(e)
                console.warn(
                    'Folder Symlink in monitored templates/scripts folder...\n',
                    'This can lead to unlimited recursion.'
                )
console.log('GLibUnix not found.')
console.log('GioUnix not found, falling back to Gio...')
console.log(`WebKit GI not found; desktop widgets disabled\n${e}`)
console.log(`Soup GI not found; desktop widgets disabled\n${e}`)
console.error(e)
console.error(`Install Poppler for proper fallback pdf thumbnailing \n ${e}`)
console.error(`Install Cairo for proper fallback pdf thumbnailing \n ${e}`)
console.error('DesktopAppInfo is not available on this system!')
                console.log(
                    `Error creating proxy, ${this._programNeeded[0]}:` +
                    ` ${e.message}\n${e.stack}`
                )
                    console.log(
                        `Error creating proxy, ${this._programNeeded[0]}:` +
                        ` ${e.message}\n${e.stack}`
                    )
console.log(this._programNeeded[0])
console.log(this._programNeeded[1])
                console.log(
                    'Error getting introspection data over Dbus: ' +
                    `${e.message}\n${e.stack}`
                )
                        console.log(
                            'Can not get the extractable types:' +
                            ` ${error.message}.` +
                            `\nEnsure that File-Roller is installed.\n${error}.`
                        )
console.log(e.message, e.stack)
console.log(`Error showing properties: ${error.message}`)
                    console.log(
                        `Error showing file on desktop: ${error.message}`
                    )
console.log(`Error previewing file: ${error.message}`)
GLib.file_get_contents(userDirsGioFile.get_path())
GLib.file_get_contents(systemDirsGioFile.get_path())
GLib.file_get_contents(userDirsGioFile.get_path())
GLib.spawn_command_line_sync(command)
GLib.spawn_command_line_sync(command)
console.error('WidgetManager: failed to clone widget config:', e)
console.error('createInstanceForWidget: missing widgetId')
console.error('createInstanceForWidget: widgetRegistry missing')
console.error(`Descriptor load failed for ${widgetId}:`, e)
            console.error(
                `createInstanceForWidget: invalid monitorIndex ${monitorIndex}`
            )
console.error('WidgetManager: listAvailableWidgets failed:', e)
                    console.error(
                        'WidgetManager loadState failed for instance:',
                        {
                            instanceId: instData.instanceId,
                            widgetId: instData.widgetId,
                            monitorIndex: instDat
console.error('WidgetManager loadState failed:', e)
            console.error(
                `WidgetManager.createInstance:
                    unknown monitorIndex ${monitorIndex}`
            )
                console.error(
                    `WidgetManager: grid for monitorIndex ${monitorIndex
                    } is missing widgetContainer`
                )
console.error('WidgetRegistry: failed to clone JSON object:', e)
console.error('WidgetRegistry.preload():', e)
            console.error(
                'WidgetRegistry: getHtmlEntryFile failed for',
                id,
                e
            )
            console.error(
                'WidgetRegistry: application-id not available; ' +
                'widget paths will not be resolved.'
            )
            console.error(
                'WidgetRegistry: enumerate_children failed for',
                root.get_path?.(),
                e
            )
            console.error(
                'WidgetRegistry: error scanning root',
                root.get_path?.(),
                e
            )
                console.error(
                    'WidgetRegistry: error closing enumerator',
                    e
                )
            console.error(
                'WidgetRegistry: backend argv missing/invalid for widget',
                desc?.id ?? '<unknown>'
            )
console.warn('WidgetRegistry: failed to resolve user root:', e)
console.warn('WidgetRegistry: failed to build system roots:', e)
console.log('>>> WebWidgetContext[HOST]', op, 'id=', id, 'patch=', patch)
        console.log(
            `${arrow} WebWidgetContext[WIDGET]`,
            'type=',
            type,
            'id=',
            id,
            'mode=',
            mode,
            payload
        )
            console.log(
                'HtmlWidget log:',
                '(instanceId=',
                instanceId,
                ')',
                message
            )
            console.error(
                'WebWidgetContext: failed to register dingWidget handler:',
                e
            )
            console.error(
                'WebWidgetContext: failed to install WIDGET_API user script:',
                e
            )
console.error('WebWidgetContext: failed to read widget message:', e)
            console.error(
                'WebWidgetContext: failed to convert widget message to string:',
                e
            )
console.error('WebWidgetContext: invalid widget JSON payload:', e)
console.error('Failed to open external link:', rawUrl, error)
console.error(`No description for ${widgetId}`, e)
import Adw from 'gi://Adw';
import Gdk from 'gi://Gdk?version=4.0';
import Gtk from 'gi://Gtk';
this.gtkSettings = new Gio.Settings({settings_schema: schemaGtk})
            this.mutterSettings =
                new Gio.Settings({settings_schema: schemaMutter})
            this.nautilusCompression =
                new Gio.Settings({settings_schema: compressionSchema})
            this.nautilusSettings =
                new Gio.Settings({settings_schema: schemaObj})
            this.schemaGnomeThemeSettings =
                new Gio.Settings({settings_schema: schemaGnomeSettings})
            this.schemaTerminalSettings =
                new Gio.Settings({settings_schema: schemaTerminalSettings})
        this._dbusGeometryIface =
                Gio.DBusExportedObject.wrapJSObject(signalXml, this)
        button.connect('clicked', () => {
            this.reloadCSS();
        })
this.cssOverrideButton.connect('activated', this.openUserCssOverrideFile.bind(this))
this.shortcutButton.connect('activated', this.showShortcuts.bind(this))
        this.appChooserDialog.connect('close', () => {
            this.appChooserDialog.response(Gtk.ResponseType.CANCEL);
        })
        this.appChooserDialog.connect('response', (actor, retval) => {
            if (retval === Gtk.ResponseType.OK) {
                this._checkUpdateDefaultAppForMimeType();
                this.applicationSelectionComplete(this.selectedAppInfo);
            } else {
                this.applic
        this.appChooserWidget.connect(
            'application-activated',
            this._onApplicationActivated.bind(this)
        )
        this.appChooserWidget.connect(
            'application-selected',
            this._onApplicationSelected.bind(this)
        )
        this._buttonId =
            this._button.connect(
                'clicked',
                this._do_rename.bind(this)
            )
        this._focusTrackerID =
            this._focusTracker.connect('leave', this.close.bind(this))
        this._popoverId =
            this._popover.connect('closed', this.close.bind(this))
        this._textAreaActivateId =
            this._textArea.connect('activate', this._do_rename.bind(this))
        this._textAreaChangedId =
            this._textArea.connect(
                'changed',
                () => {
                    this._validate()
                    .catch(e => console.error(e));
                }
            )
        this._progressWindow.connect('close-request', () => {
            return true;
        })
        this._cancelButton.connect('clicked', () => {
            if (this._buttonPromiseAccept) {
                this._buttonPromiseAccept(false);
                return;
            }
            this._cancellable.cancel();
        })
this._passEntry.connect('activate', passOKfunc)
        this._passEntry.connect('icon-release', () => {
            this._passEntry.visibility = !this._passEntry.visibility;
        })
this._passOkButton.connect('clicked', passOKfunc)
        this._dialog.connect('response', (dialog, id) => {
            if (id === Gtk.ResponseType.ACCEPT) {
                const data =
                    this._desktopManager
                    .autoAr.getFormatAndFilterForExtension(
                        this._compressOptions[this._selectedT
        this._extensionDropdown.connect('clicked', () => {
            this._extensionPopoverContainer.show();
            this._extensionPopover.popup();
            for (let index in this._compressOptions) {
                const data = this._compressOptions[index];
                data.selected_i
this._nameEntry.connect('activate', () => this._entryActivated())
this._nameEntry.connect('changed', () => this._updateStatus())
this._passEntry.connect('activate', () => this._entryActivated())
this._passEntry.connect('changed', () => this._updateStatus())
        this._volumeMonitor.connect(
            'mount-added',
            () => {
                this.onMountAdded();
            }
        )
        this._volumeMonitor.connect(
            'mount-removed',
            () => {
                GLib.timeout_add(
                    GLib.PRIORITY_DEFAULT,
                    500,
                    () => {
                        this.onMountRemoved();
                        return GLib.S
        changeDesktop.connect('activate', () => {
            this.changeDesktop();
        })
        this.restoreDefaultDesktopAction.connect('activate', () => {
            this.restoreDefaultDesktop();
        })
        cancellable.connect(
            () => {
                this._monitorDesktopDir.disconnect(monitorID);
                this._monitorDesktopDir.cancel();
                this._monitorDesktopDir = null;
                this.monitorDesktopCancellable = null;
            }
        )
        this._window.connect(
            'close-request',
            () => {
                if (this._destroying)
                    return false;

                if (this._asDesktop) {
                    // Do not destroy window when closing if the instance
                    // is working a
            this._window.connect('map', () => {
                if (!this._resolveMapped)
                    return;
                this._resolveMapped(true);
                this._resolveMapped = null;
                // Maximize however creates an error where the window can
                // be
        this._window.connect('notify::css_classes', () => {
            this._window.set_css_classes(['background']);
        })
        this._buttonClick.connect('pressed', (actor, nPress, x, y) => {
            this._doGesturePress(actor, nPress, x, y);
        })
        this._buttonClick.connect('released', (actor, nPress, x, y) => {
            if (this._longHandled)
                this._longHandled = false;

            this._doGestureRelease(actor, nPress, x, y, this);
        })
        this._buttonLongClick.connect('cancelled', _actor => {
            this._longHandled = false;
        })
        this._buttonLongClick.connect('pressed', (actor, x, y) => {
            this._longHandled = true;
            this._doGestureLongPress(actor, x, y);
        })
        this._eventKey.connect(
            'key-pressed',
            this._onKeyPress.bind(this)
        )
        this._eventKeyState.connect(
            'key-pressed',
            this._onModifierUpdate.bind(this)
        )
        this._eventKeyState.connect(
            'key-released',
            this._onModifierClear.bind(this)
        )
        this._eventMotion.connect(
            'motion',
            (actor, x, y) => {
                if (!this._dragManager.rubberBand)
                    return false;

                const [X, Y] = this.coordinatesLocalToGlobal(x, y);
                this._dragManager.onMotion(X, Y);
        
        this.gridDropController.connect(
            'accept',
            (actor, drop) => {
                if (drop.get_formats().match(desktopAcceptFormats))
                    return true;
                else
                    return false;
            }
        )
        this.gridDropController.connect(
            'drag-enter',
            (actor, drop) => {
                this.localDrag = true;
                drop.status(
                    Gdk.DragAction.COPY |
                        Gdk.DragAction.MOVE |
                        Gdk.DragAction.LINK,
 
        this.gridDropController.connect('drag-leave', () => {
            this.localDrag = false;
            this._receiveLeave();
        })
        this.gridDropController.connect(
            'drag-motion',
            (actor, drop, x, y) => {
                let desktopDropZone = false;
                let fileItemDropZone = false;
                const fileItem = this._fileAt(x, y);
                const [X, Y] = this.coordinatesLoca
        this.gridDropController.connect('drop', (actor, drop, x, y) => {
            const event = {
                'parentWindow': this._window,
                'timestamp': Gdk.CURRENT_TIME,
            };

            let desktopDropZone = false;
            let fileItemDropZone = false;
       
        this.gridDropControllerMotion.connect(
            'motion',
            (actor, x, y) => {
                if (!this.gridDropControllerMotion.is_pointer) {
                    const fileItem = this._fileAt(x, y);
                    const [X, Y] = this.coordinatesLocalToGlobal(x, y);
      
        widgetDragController.connect('drag-begin', () => {
            this._dragManager.onReleaseButton(this);
            this._dragManager.onDragBegin(clickItem);
        })
        widgetDragController.connect(
            'drag-cancel',
            async (actor, drag, reason) => {
                if (reason === Gdk.DragCancelReason.NO_TARGET ||
                    reason === Gdk.DragCancelReason.ERROR) {
                    const gnomedropDetected =
                  
        widgetDragController.connect('drag-end', () => {
            this._dragManager.onDragEnd();
            this._dragManager.selected(clickItem, this.Enums.Selection.RELEASE);
        })
        widgetDragController.connect(
            'prepare',
            // eslint-disable-next-line consistent-return
            (actor, x, y) => {
                const draggedItem = this._fileAt(x, y);

                if (draggedItem && !this._dragManager.rubberBand) {
                    click
        this._offsetAnim.connect('done', () => {
            this._setLiveOffset(-this._tweenDelta.dx, -this._tweenDelta.dy);
            // Ensure we end exactly at identity scale
            if (this._moveAway) {
                this._setLiveTransform(
                    1.0, this._tweenDelta.piv
        fileOperationsManager.connect('changed-status',
            (actor, available) => {
                if (available)
                    this._syncUndoRedo();
                else
                    this._syncUndoRedo(true);
            }
        )
        arrangeByDescendingName.connect(
            'activate',
            () => this._mainApp.activate_action(
                'arrangeaction',
                new GLib.Variant('s', 'DESCENDINGNAME')
            )
        )
        arrangeByKind.connect(
            'activate',
            () => this._mainApp.activate_action(
                'arrangeaction',
                new GLib.Variant('s', 'KIND')
            )
        )
        arrangeByModifiedTime.connect(
            'activate',
            () => this._mainApp.activate_action(
                'arrangeaction',
                new GLib.Variant('s', 'MODIFIEDTIME')
            )
        )
        arrangeByName.connect(
            'activate',
            () => this._mainApp.activate_action(
                'arrangeaction',
                new GLib.Variant('s', 'NAME')
            )
        )
        arrangeBySize.connect(
            'activate',
            () => this._mainApp.activate_action(
                'arrangeaction',
                new GLib.Variant('s', 'SIZE')
            )
        )
        changeBackGround.connect(
            'activate',
            () => {
                const desktopFile =
                    DesktopAppInfo.new('gnome-background-panel.desktop');
                const context =
                    Gdk.Display.get_default().get_app_launch_context();
        
        changeDesktopIconSettings.connect(
            'activate',
            this._showPreferences.bind(this)
        )
        changeDisplaySettings.connect(
            'activate',
            () => {
                const desktopFile =
                    DesktopAppInfo.new('gnome-display-panel.desktop');
                const context =
                    Gdk.Display.get_default().get_app_launch_context();
      
        chooseIconDown.connect('activate', () => {
            this._selectFileItemInDirection(Gdk.KEY_Down);
        })
        chooseIconLeft.connect('activate', () => {
            this._selectFileItemInDirection(Gdk.KEY_Left);
        })
        chooseIconRight.connect('activate', () => {
            this._selectFileItemInDirection(Gdk.KEY_Right);
        })
        chooseIconUp.connect('activate', () => {
            this._selectFileItemInDirection(Gdk.KEY_Up);
        })
        cleanUpIconsAction.connect(
            'activate',
            () => this._desktopManager.sortAllFilesFromGridsByPosition()
        )
        createDesktopShortcut.connect('activate', (action, parameter) => {
            this._createDesktopShortcut(parameter.recursiveUnpack());
        })
        displayShellBackgroundMenu.connect('activate', () => {
            this._DBusUtils.RemoteExtensionControl.showShellBackgroundMenu();
        })
        this.doPasteSimpleAction.connect(
            'activate',
            async () => {
                try {
                    if (!(this._desktopManager.popupmenu ||
                        this._desktopManager.fileItemMenu.popupmenu))
                        await this._updateClipboard().ca
        this.doRedoSimpleAction.connect(
            'activate',
            () => this._doRedo()
        )
        this.doUndoSimpleAction.connect(
            'activate',
            () => this._doUndo()
        )
        findFilesAction.connect(
            'activate',
            () => this._desktopManager.findFiles(null)
        )
        menuKeyPressed.connect('activate', () => {
            this._menuKeyPressed();
        })
        newDocument.connect('activate', (action, parameter) => {
            this._newDocument(parameter.deep_unpack());
        })
        newFolder.connect('activate', () => {
            this._desktopManager.doNewFolder().catch(e => console.error(e));
        })
        openDesktopInTerminal.connect(
            'activate',
            this._onOpenTerminalClicked.bind(this)
        )
        previewAction.connect('activate', () => {
            if (this._desktopManager.popupmenu ||
                this._desktopManager.fileItemMenu.popupmenu ||
                !this.activeFileItem)
                return;
            const RemoteOperation =
                this._DBusUtils.RemoteF
        radioArrangeAction.connect('change-state',
            this._syncArrangeOrder.bind(this))
        selectAll.connect(
            'activate',
            () => this._selectAll()
        )
        showDesktopInFiles.connect(
            'activate',
            () => this._onOpenDesktopInFilesClicked().catch(e => logError(e))
        )
        showHideHiddenFiles.connect(
            'activate',
            () => {
                this._Prefs.gtkSettings.set_boolean('show-hidden',
                    !this._Prefs.showHidden);
            }
        )
        toggleKeyboardSelection.connect('activate', () => {
            this._toggleKeyboardSelection();
        })
        toggleVisibility.connect('activate', () => {
            this._windowManager.toggleVisibility();
        })
        unselectAll.connect(
            'activate',
            () => {
                this._desktopManager.unselectAll();
                if (this.searchString)
                    this.searchString = null;
            }
        )
        updateDesktop.connect(
            'activate',
            async () => {
                await this._desktopManager.reLoadDesktop().catch(e => {
                    console.log(
                        `Exception while updating desktop after pressing "F5":
                        ${e.message
        this._docopy.connect(
            'activate',
            this._doCopy.bind(this)
        )
        this._docut.connect(
            'activate',
            this._doCut.bind(this)
        )
        allowdisallowlaunching.connect('activate', () => {
            if (!this.activeFileItem)
                return;

            this.activeFileItem
                .onAllowDisallowLaunchingClicked()
                .catch(e => console.error(e));
        })
        bulkCopy.connect(
            'activate',
            this._bulkCopy.bind(this)
        )
        bulkMove.connect(
            'activate',
            this._bulkMove.bind(this)
        )
        compressfiles.connect(
            'activate',
            this._doCompressFilesFromSelection.bind(this, null)
        )
        this.deletePermanantly.connect(
            'activate',
            () => this.doDeletePermanently()
        )
        desktopAction.connect(
            'activate',
            (_action, parameter) => {
                const [path, actionName, action] = parameter.deepUnpack();
                this._desktopFileAction(path, actionName, action);
            }
        )
        doopenwith.connect('activate', () => {
            this._doOpenWith().catch(e => logError(e));
        })
        dorename.connect('activate', () => {
            this._desktopManager
                .doRename(this.activeFileItem, false)
                .catch(e => logError(e));
        })
        eject.connect('activate', () => {
            this.activeFileItem.eject().catch(e => console.error(e));
        })
        emptytrash.connect(
            'activate',
            () => this.doEmptyTrash()
        )
        extractautoar.connect(
            'activate',
            () => {
                this._desktopManager.getCurrentSelection()
                ?.forEach(
                    f => this._desktopManager.autoAr.extractFile(f.fileName));
            }
        )
        extracthere.connect(
            'activate',
            this._extractFileFromSelection.bind(this, true)
        )
        extractto.connect(
            'activate',
            this._extractFileFromSelection.bind(this, false)
        )
        graphicslaunch.connect('activate', () => {
            if (!this.activeFileItem)
                return;
            this.activeFileItem._doDiscreteGpu();
        })
        makeLinks.connect(
            'activate',
            this._makeLinks.bind(this)
        )
        this.moveToTrash.connect(
            'activate',
            () => this.doTrash()
        )
        newfolderfromselection.connect(
            'activate',
            this._newFolderFromSelection.bind(this)
        )
        onScriptClicked.connect(
            'activate',
            (_action, parameter) => {
                this._onScriptClicked(parameter.unpack());
            }
        )
        openMultipleFileAction.connect(
            'activate',
            this._doMultiOpen.bind(this)
        )
        openOneFileAction.connect(
            'activate',
            () => {
                if (this.activeFileItem) {
                    if (this.activeFileItem.isStackMarker) {
                        this._onToggleStackUnstackThisTypeClicked(
                            this.activeFileItem.at
        openinterminal.connect(
            'activate',
            this._openInTerminal.bind(this)
        )
        properties.connect(
            'activate',
            this._onPropertiesClicked.bind(this)
        )
        runasaprogram.connect(
            'activate',
            this._runExecutableScript.bind(this)
        )
        sendto.connect(
            'activate',
            this._mailFilesFromSelection.bind(this, null)
        )
        showinfiles.connect(
            'activate',
            this._onShowInFilesClicked.bind(this)
        )
        stackunstack.connect(
            'activate',
            (_action, paramenter) => {
                this._onToggleStackUnstackThisTypeClicked(paramenter.unpack());
            })
        unmount.connect('activate', () => {
            this.activeFileItem.unmount().catch(e => console.error(e));
        })
        this._userShortcutMonitor = this._desktopSettings.connect(
            'changed',
            (obj, key) => {
                if (key === 'shortcutoverrides')
                    this._refreshUserShortcuts();
            }
        )
        this._mainApp.connect(
            'action-added',
            (_app, name) => this._setAccel(name)
        )
        this._mainApp.connect(
            'action-enabled-changed',
            (_app, name, _enabled) => this._setAccel(name)
        )
        showShortcutViewer.connect('activate', () => {
            this._showShortcutViewer();
        })
        textEntryAccelsTurnOff.connect('activate', () => {
            this._textEntryAccelsTurnOff();
        })
        textEntryAccelsTurnOn.connect('activate', () => {
            this._textEntryAccelsTurnOn();
        })
this._dialog.connect('response', this._callback.bind(this))
                this._symlinkFileMonitorId = this._symlinkFileMonitor.connect(
                    'changed',
                    this._updateSymlinkIcon.bind(this)
                )
            this._monitorDir.connect(
                'changed',
                () => {
                    this.updateEntries()
                    .catch(
                        e => {
                            console.log(
                                'Exception while updating entries in '
        dbusManager.connect(
            inSystemBus
                ? 'changed-availability-system'
                : 'changed-availability-local',
            () => {
                this._makeProxy(makeAsync);
            }
        )
        this.archiveConnectionId =
            this.gnomeArchiveManager.connect(
                'changed-status',
                (_actor, available) => {
                    if (available) {
                        // wait a second to ensure that everything has settled
                        GLib
        this.SwitcherooControl.connect('changed-status', (obj, newStatus) => {
            this.discreteGpuAvailable = newStatus;
        })
        this.GsConnectManager.connect('changed-status', () => {
            GLib.timeout_add(GLib.PRIORITY_DEFAULT, 1000, () => {
                this._startGsConnectService();
                return false;
            });
        })
        sendfiles.connect('activate', (action, parameter) => {
            let device = parameter.recursiveUnpack();
            this._send_files(device);
        })
            this.signalID =
                this.gsConnectProxy.connect(
                    'g-signal',
                    this._on_g_signal.bind(this)
                )
        this._dbusScreenSaverActiveChangedId =
            this._desktopManager.DBusUtils.connect(
                'screen-saver-active-changed',
                (_dbusUtils, active) => {
                    if (active)
                        return;

                    this.schedulePinnedWindowWa
            addButton.connect('clicked', async () => {
                if (creationInProgress)
                    return;

                const row = list.get_selected_row();
                if (!row || !row._widgetId) {
                    window.close();
                    resolve(null);
      
        addWidgetAction.connect('activate', () => {
            const parentWindow =
                this._desktopManager.getDialogParentWindow();
            if (!parentWindow)
                return;

            this.clearSelectedInstance();

            const monitorIndex = this.getMonitorIndexF
            cancelButton.connect('clicked', () => {
                window.close();
            })
closeWidget.connect('activate', this.deleteSelectedInstance.bind(this))
            list.connect('row-activated', () => {
                addButton.activate();
            })
        showGridAction.connect('activate', () => {
            const parentWindow = this._desktopManager.getDialogParentWindow();
            if (!parentWindow)
                return;

            const parentSurfaceWindow = parentWindow;
            const monitorIndex = this.getMonitorIndexForWind
        updatePinnedWindowPosition.connect('activate', (_action, parameter) => {
            if (!parameter)
                return;

            const [instanceId, x, y] = parameter.deepUnpack();
            this.updatePinnedWindowPosition(instanceId, x, y);
        })
            window.connect('close-request', () => {
                if (!creationInProgress)
                    resolve(null);

                GLib.idle_add(GLib.PRIORITY_DEFAULT_IDLE, () => {
                    this.restoreWidgetLayerFocus(monitorIndex);
                    return GLib.SOURCE_RE
        this._dragGesture.connect(
            'drag-begin',
            this._onOverlayDragBegin.bind(this)
        )
        this._hoverController.connect('enter', () => {
            this._overlay.add_css_class('pointer-inside');
            this._showControlsStrip();
        })
        this._hoverController.connect('leave', () => {
            this._overlay.remove_css_class('pointer-inside');
            this._hideControlsStrip();
        })
        action.connect('activate', () => {
            this.toggleWidgetLayers();
        })
        lowerAction.connect('activate', () => {
            this.lowerWidgetLayers();
        })
        raiseAction.connect('activate', () => {
            this.raiseWidgetLayers();
        })
        updateGridWindows.connect('activate', (action, parameter) => {
            this.updateGridWindows(parameter.recursiveUnpack())
            .catch(e => logError(e));
        })
        this._restackedBottomID = global.display.connect('restacked',
            this._syncToBottomOfStack.bind(this)
        )
        this._restackedTopID = global.display.connect('restacked',
            this._syncToTopOfStack.bind(this)
        )
        this._titleID = this._window.connect('notify::title', () => {
            this.refreshProperties();
        })
            this._window.connect('position-changed', () => {
                this._emitWindowPositionUpdate();
            })
                GLib.timeout_add(
                    GLib.PRIORITY_DEFAULT,
                    500,
                    () => {
                        this.onMountRemoved();
                        return GLib.SOURCE_REMOVE;
                    }
                )
        this.directoryOpenTimer =
            GLib.timeout_add(
                GLib.PRIORITY_DEFAULT,
                this.Enums.DND_HOVER_TIMEOUT,
                () => {
                    const context =
                        Gdk.Display.get_default()
                        .get_app_launch_c
        this._signalTimerID =
            GLib.timeout_add(
                GLib.PRIORITY_DEFAULT,
                1000,
                () => {
                    this._signalTimerID = 0;
                    this._updateAllAvailabilities();

                    if (this._pendingLocalSignal)
      
                        GLib.timeout_add(GLib.PRIORITY_DEFAULT, 1000, () => {
                            try {
                                this._getExtractionSupportedTypes();
                            } catch (e) {}
                            return false;
                        })
            GLib.timeout_add(GLib.PRIORITY_DEFAULT, 1000, () => {
                this._startGsConnectService();
                return false;
            })
        this._pendingPinnedWindowReloadId = GLib.idle_add(
            GLib.PRIORITY_DEFAULT_IDLE,
            () => {
                this._pendingPinnedWindowReloadId = 0;
                this._reloadPinnedHtmlWidgetsInWindows(reason)
                    .catch(e => logError(e));
                r
                GLib.idle_add(GLib.PRIORITY_DEFAULT_IDLE, () => {
                    this.restoreWidgetLayerFocus(monitorIndex);
                    return GLib.SOURCE_REMOVE;
                })
        this._moveIntoPlaceID =
            GLib.timeout_add(GLib.PRIORITY_LOW, 250, () => {
                if (force || this._needsMoveToParsedPosition())
                    this._window.move_frame(true, this._x, this._y);


                this._moveIntoPlaceID = 0;
                return GLib.S
    disable() {
        this.dingManager?.disable();
        this.dingManager = null;
        this.DesktopIconsUsableArea = null;
    }

Version	Status
100.22 (135)	Unreviewed
100.21 (134)	Rejected
100.20 (133)	Rejected
100.19 (132)	Active
100.18 (131)	Rejected
100.17 (130)	Rejected
100.17 (129)	Active
100.16 (128)	Active
100.15 (127)	Inactive
100.14 (126)	Active
100.14 (125)	Rejected
100.14 (124)	Rejected
100.14 (123)	Rejected
100.13 (122)	Active
100.12 (121)	Inactive
100.12 (120)	Rejected
100.11 (119)	Active
100.9 (118)	Active
100.8 (117)	Active
100.8 (116)	Inactive
100.7 (115)	Active
100.6 (114)	Inactive
100.5 (113)	Active
100.4 (112)	Active
100.3 (111)	Active
100.2 (110)	Active
100.1 (109)	Active
100 (108)	Active
100 (107)	Active
99 (106)	Active
98 (105)	Active
98 (104)	Rejected
97 (103)	Active
96 (102)	Active
95 (101)	Inactive
94 (100)	Inactive
93 (99)	Inactive
92 (98)	Active
91 (97)	Inactive
91 (96)	Rejected
91 (95)	Inactive
90 (94)	Active
90 (93)	Rejected
89 (92)	Active
88 (91)	Active
87 (90)	Active
86 (89)	Active
85 (88)	Active
84 (87)	Active
83 (86)	Active
82 (85)	Active
81 (84)	Inactive
80 (83)	Active
79 (82)	Active
78 (81)	Active
77 (80)	Active
76 (79)	Active
75 (78)	Inactive
74 (77)	Inactive
74 (76)	Inactive
74 (75)	Rejected
74 (74)	Rejected
73 (73)	Active
72 (72)	Active
71 (71)	Active
70 (70)	Active
69 (69)	Active
68	Active
67	Active
66	Active
65	Rejected
64	Rejected
63	Active
62	Active
61	Active
60	Active
59	Active
58	Inactive
57	Active
56	Active
55	Active
54	Active
53	Rejected
52	Rejected
51	Rejected
50	Rejected
49	Active
48	Rejected
47	Active
46	Active
45	Active
44	Rejected
43	Active
42	Active
41	Active
40	Active
39	Active
38	Active
37	Active
36	Active
35	Active
34	Active
33	Active
32	Active
31	Active
30	Active
29	Rejected
28	Active
27	Active
26	Active
25	Active
24	Active
23	Active
22	Active
21	Active
20	Active
19	Rejected
18	Active
17	Active
16	Active
15	Active
14	Active
13	Active
12	Active
11	Active
10	Active
9	Active
8	Active
7	Active
6	Active
5	Active
4	Rejected
3	Active
2	Active
1	Rejected

Review of "Gtk4 Desktop Icons NG (DING)" version 100.22 (135)

Details Page Preview

Gtk4 Desktop Icons NG (DING)

Diff Against

Files

Shexli (experimental) error 3 warning 22

All Versions