Review "Gtk4 Desktop Icons NG (DING)" version 100.27 (141)

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,
                                `Failed with ${e.message} while adding` +
                                ` extra folder ${newFolder.get_uri()}`
                            )
                            console.error(e,
                                `Failed with ${e.message} while ` +
                                `adding volume ${newFolder}`
                            )
                console.error(e,
                    'Failed to read contents of' +
                    `${this._desktopDir.get_path()}`
                )
console.error(e)
console.error(e, 'Paste action failed')
console.error(e)
            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.error(e, 'Error updating clipboard')
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, `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.error(
                    e,
                    'Failed to store the desktop coordinates for ' +
                    `${this.uri}: ${e.message}`
                )
                console.error(e,
                    'Failed to store the desktop coordinates for ' +
                    `${this.uri}: ${e.message}`
                )
                console.error(
                    e,
                    `Exception while checking encryption status for ${
                        this._getVisibleName()
                            ? this._getVisibleName()
                            : 'file'
                    }: ${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.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('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)
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(
                        'Could not parse desktopFile as a desktop file,' +
                        ' cannot set shell cursor'
                    )
console.log('Could not parse desktopFile as desktop file')
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(
                    `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(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(`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, '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(
                    'Exception while doing move with drag and drop and' +
                    `"Keep arranged…": ${e.message}\n${e.stack}`)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.log('Reverting to old method of selecting')
                console.warn(
                    'HtmlWidgetHostWithBackend: failed to move backend to systemd scope:',
                    e
                )
                        console.warn(
                            'BACKEND stderr:',
                            inst?.instanceId ?? '<unknown>',
                            line.trim()
                        )
            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.error(
                'HtmlWidgetHostWithBackend: write backend failed:', e
            )
console.warn(`Failed to move ${this._processID} to systemd scope:`, e)
console.error('Gtk4 DING extension requires a Wayland session')
console.error(e)
console.error(e)
console.error(e)
                console.error(
                    e, `Error while trying to launch DING process: ${e.message}`
                )
console.error(e)
console.error(e, `${this._processID}_Error`)
console.error(`Failed to move ${appID} to its own slice & scope:`, e)
console.log('Adw-DING enabled.')
this._webView.run_dispose()
console.error(`Failed to load CSS override: ${e}`)
console.error(e)
console.error(e)
console.error(e)
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.warn(
                    'Folder Symlink in monitored templates/scripts folder...\n',
                    'This can lead to unlimited recursion.'
                )
console.error(e)
console.error(e)
                            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(`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('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(e,
                            'Impossible to determine the parent window'
                        )
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
console.error(e)
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);
        })
        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))
            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();
        })
        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()) {
                    if (this.windowInstanceId) {
                        this._moveFrameWithoutTrackingFeedback(
                            
    disable() {
        this.dingManager?.disable();
        this.dingManager = null;
        this.DesktopIconsUsableArea = null;
    }

Version	Status
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.27 (141)

Details Page Preview

Gtk4 Desktop Icons NG (DING)

Diff Against

Files

Shexli (experimental) error 3 warning 19

All Versions

Previous Reviews on this Version