Review "Gtk4 Desktop Icons NG (DING)" version 100.30 (147)

                    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.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 setting encryption status: ${e.message}`)
                console.error(
                    e, `Error opening file ${this.file.get_uri()}: ${e.message}`
                )
console.error(e)
                console.error(
                    e,
                    'Exception while updating icon on Metadata Changed: ' +
                    `${e.message}`
                )
                console.error(
                    e,
                    `Exception while updating ${
                        this._getVisibleName?.() ?? 'an icon'
                    }: ${e.message}`
                )
console.error(e)
console.error(e)
console.log('Not enough space to add icons')
            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('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(`Could not get activation token: ${e.message}`)
                    console.log(
                        `Exception while updating desktop after pressing "F5":
                        ${e.message}\n${e.stack}`)
console.error(e)
console.error(e, 'Paste action failed')
console.error(e, 'Paste as Link failed')
console.error(e)
console.error(error, 'Error navigating preview')
            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.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)
                    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)
this._webView.run_dispose()
                console.warn(
                    'HtmlWidgetHostWithBackend: failed to move backend to systemd scope:',
                    e
                )
                        console.warn(
                            'BACKEND stderr:',
                            inst?.instanceId ?? '<unknown>',
                            line.trim()
                        )
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(`Failed to move ${description} to systemd scope:`, e)
            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.warn(`Failed to move ${this._processID} to systemd scope:`, 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.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 ' +
                        `icon size changed: ${e.message}\n${e.stack}`)
                console.warn(
                    'Folder Symlink in monitored templates/scripts folder...\n',
                    'This can lead to unlimited recursion.'
                )
                            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(
                `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(
                    `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 folder: ${error.message}`)
                    console.log(
                        `Error showing file on desktop: ${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.warn(
                `createInstanceForWidget: no descriptor for ${widgetId},` +
                ' using fallback html kind'
            )
            console.warn(
                `WidgetManager loadState: state version ${schemaVersion} ` +
                `(current ${WIDGETS_STATE_SCHEMA_VERSION}); migrating`
            )
console.warn('No widget selected or widget has no preferences UI.')
        console.warn(
            `WidgetManager: GTK widget kind requested for ${inst.widgetId}, ` +
            'but GTK widget support is not implemented yet'
        )
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.warn('WidgetRegistry: failed to resolve user root:', e)
console.warn('WidgetRegistry: failed to build system roots:', e)
                        console.warn(
                            `WidgetRegistry:
                            rejecting widget with invalid id in ${mf}`
                        )
        console.warn(
            `WidgetRegistry: duplicate widget id "${id}": ` +
            `${existingPath} (${existingScope}) vs ` +
            `${newPath} (${newScope}) — ${action}`
        )
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.warn(
                'WebWidgetContext.openPreferencesForInstance: no instance',
                instanceId
            )
            console.warn(
                'WebWidgetContext: failed to configure ding-widget scheme security:',
                e
            )
console.warn('Unknown CSP profile, enforcing STRICT')
            console.warn(
                'WebWidgetContext: unexpected widget message payload',
                json,
                typeof json,
                'raw jsValue:',
                jsValue,
                'ctor:',
                jsValue?.constructor?.name
            )
console.warn('Widget openExternalLink rejected invalid URL:', rawUrl, error)
console.warn('Widget openExternalLink rejected scheme:', scheme || '<none>')
            console.warn(
                'WebWidgetContext: suppressing config update burst for widget instance',
                instanceId,
                `(${guard.count} updates in ${CONFIG_UPDATE_WINDOW_MS}ms)`
            )
            console.warn(
                `WebWidgetContext: suppressing ${label} for widget instance`,
                instanceId,
                `type=${kind}`,
                `(${guard.count} events in ${windowMs}ms)`
            )
            console.warn(
                'WebWidgetContext: failed to inspect request origin for widget response:',
                e
            )
        console.warn(
            'WebWidgetContext: served missing widget resource as 404',
            resourcePath
        )
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._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._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()
                .catch(e => logError(e))
        )
        createDesktopShortcut.connect('activate', (action, parameter) => {
            this._createDesktopShortcut(parameter.recursiveUnpack());
        })
        displayShellBackgroundMenu.connect('activate', () => {
            this._DBusUtils.RemoteExtensionControl.showShellBackgroundMenu();
        })
        this.doPasteSimpleAction.connect(
            'activate',
            async () => {
                try {
                    await this._clipboardManager.paste();
                } catch (e) {
                    console.error(e, 'Paste action failed');
                }
            }
     
        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)
        )
        pasteAsLink.connect(
            'activate',
            async () => {
                try {
                    await this._clipboardManager.paste(true);
                } catch (e) {
                    console.error(e, 'Paste as Link failed');
                }
            }
        )
        previewAction.connect('activate', () => {
            if (this._desktopManager.popupmenu ||
                this._desktopManager.fileItemMenu.popupmenu ||
                !this.activeFileItem)
                return;

            this._setKeyboardSelected(this.activeFileItem);

            c
        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());
            }
        )
        openInNewWindow.connect('activate', () => {
            this._doOpenInNewWindow(this.activeFileItem)
                .catch(e => console.error(e));
        })
        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._fileManagerMonitor.connect('changed', () => {
            this._updateFileManager();
        })
        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
        GnomeNautilusPreview.connect('changed-status', (_manager, available) => {
            if (!available)
                this._releasePreviewHandle();
        })
        mainApp.connect('shutdown', () => {
            this._previewRequest++;
            this._releasePreviewHandle();
        })
        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))
            downloadButton.connect('clicked', async () => {
                try {
                    const didInstall = await this.downloadLatestWidgets(
                        parentWindow,
                        cancellable
                    );

                    if (didInstall) {
         
            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', () => {
                cancellable.cancel();

                if (reopeningAfterDownload)
                    return false;

                if (!creationInProgress)
                    resolve(null);

                GLib.idle_add(GLib.PRIORITY_DEFAULT_I
        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();
        })
        this._Prefs.desktopSettings.connect(
            'changed::show-desktop-widgets',
            syncPinnedWidgetsAction
        )
        action.connect('activate', () => {
            this.toggleWidgetLayers();
        })
        lowerAction.connect('activate', () => {
            this.lowerWidgetLayers();
        })
        raiseAction.connect('activate', () => {
            this.raiseWidgetLayers();
        })
        togglePinnedWidgetsBelowApps.connect('activate', () => {
            const settings = this._Prefs.desktopSettings;
            settings.set_boolean(
                'keep-pinned-widgets-below-apps',
                !settings.get_boolean('keep-pinned-widgets-below-apps')
            );
      
        updateGridWindows.connect('activate', (action, parameter) => {
            this.updateGridWindows(parameter)
            .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_after('raised', () => {
                    if (this._desktopWindow && !this.windowInstanceId &&
                        !this._raiseDesktopAsDock)
                        this._syncToBottomOfStack();
                })
                GLib.timeout_add(
                    GLib.PRIORITY_DEFAULT,
                    500,
                    () => {
                        this.onMountRemoved();
                        return GLib.SOURCE_REMOVE;
                    }
                )
        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()) {
                    if (this.windowInstanceId) {
                        this._moveFrameWithoutTrackingFeedback(
                            
    disable() {
        this.dingManager?.disable();
        this.dingManager = null;
        this.DesktopIconsUsableArea = null;
    }

Version	Status
100.30 (147)	Active
100.30 (146)	Rejected
100.29 (145)	Active
100.29 (144)	Rejected
100.29 (143)	Active
100.28 (142)	Active
100.27 (141)	Active
100.26 (140)	Active
100.25 (139)	Inactive
100.24 (138)	Inactive
100.24 (137)	Rejected
100.23 (136)	Inactive
100.22 (135)	Active
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.30 (147)

Details Page Preview

Gtk4 Desktop Icons NG (DING)

Diff Against

Files

Shexli (experimental) error 3 warning 20

All Versions

Previous Reviews on this Version