Adding a setting to switch inline values on/off.

Author: lahodaj

ide/editor.actions/src/org/netbeans/modules/editor/actions/ShowInlineHintsAction.java

@@ -24,7 +24,7 @@
 
 @EditorActionRegistration(name="toggle-inline-hints",
                           menuPath="View",
-                          menuPosition=899,
+                          menuPosition=897,
                           preferencesKey=ShowInlineHintsAction.KEY_LINES,
                           preferencesDefault=ShowInlineHintsAction.DEF_LINES)
 public class ShowInlineHintsAction extends AbstractAction {

ide/editor.actions/src/org/netbeans/modules/editor/actions/ShowLinesAction.java

@@ -24,7 +24,7 @@
 
 @EditorActionRegistration(name="toggle-lines-view",
                           menuPath="View",
-                          menuPosition=898,
+                          menuPosition=895,
                           preferencesKey=ShowLinesAction.KEY_LINES,
                           preferencesDefault=ShowLinesAction.DEF_LINES)
 public class ShowLinesAction extends AbstractAction {

ide/spi.debugger.ui/apichanges.xml

@@ -51,6 +51,25 @@
 <!-- ACTUAL CHANGES BEGIN HERE: -->
 
 <changes>
+    <change id="inline-values-setting-keys">
+        <api name="DebuggerCoreSPI"/>
+        <summary><code>Constants</code> class enhanced with constants for inline values.</summary>
+        <version major="2" minor="87"/>
+        <date day="8" month="4" year="2025"/>
+        <author login="jlahoda"/>
+        <compatibility binary="compatible" source="compatible" modification="yes" semantic="compatible"/>
+        <description>
+            <p>
+                Two new contants are added to <code>Constants</code>:
+                <ul>
+                    <li><b>KEY_INLINE_VALUES</b>: the <code>Preferences</code> key for the inline value setting.</li>
+                    <li><b>DEF_INLINE_VALUES</b>: the default value of the inline value setting.</li>
+                </ul>
+            </p>
+        </description>
+        <class package="org.netbeans.spi.debugger.ui" name="Constants"/>
+    </change>
+
     <change id="annotation-to-breakpoint">
         <api name="DebuggerCoreSPI"/>
         <summary><code>BreakpointAnnotation</code> class added.</summary>

ide/spi.debugger.ui/manifest.mf

@@ -2,6 +2,6 @@ Manifest-Version: 1.0
 OpenIDE-Module: org.netbeans.spi.debugger.ui/1
 OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/debugger/ui/Bundle.properties
 OpenIDE-Module-Layer: org/netbeans/modules/debugger/resources/mf-layer.xml
-OpenIDE-Module-Specification-Version: 2.86
+OpenIDE-Module-Specification-Version: 2.87
 OpenIDE-Module-Provides: org.netbeans.spi.debugger.ui
 OpenIDE-Module-Install: org/netbeans/modules/debugger/ui/DebuggerModule.class

ide/spi.debugger.ui/src/org/netbeans/modules/debugger/ui/actions/ShowInlineValuesAction.java

@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.netbeans.modules.debugger.ui.actions;
+
+import java.awt.event.ActionEvent;
+import javax.swing.AbstractAction;
+import org.netbeans.api.editor.EditorActionRegistration;
+import org.netbeans.spi.debugger.ui.Constants;
+import org.openide.util.NbBundle.Messages;
+
+@EditorActionRegistration(name="toggle-inline-values",
+                          menuPath="View",
+                          menuPosition=899,
+                          preferencesKey=Constants.KEY_INLINE_VALUES,
+                          preferencesDefault=Constants.DEF_INLINE_VALUES)
+@Messages({
+    "toggle-inline-values=Show Inline Values",
+    "toggle-inline-values_menu_text=Show Inline V&alues"
+})
+public class ShowInlineValuesAction extends AbstractAction {
+    @Override
+    public void actionPerformed(ActionEvent e) {
+    }
+
+}

ide/spi.debugger.ui/src/org/netbeans/spi/debugger/ui/Constants.java

@@ -149,4 +149,16 @@ public interface Constants {
      * @see org.netbeans.spi.viewmodel.ColumnModel#getNextColumnID
      */
     public static final String SESSION_LANGUAGE_COLUMN_ID = "SessionLanguage";
+
+    /**Should the inline values be visible - preferences key.
+     *
+     * @since 2.87
+     */
+    public static final String KEY_INLINE_VALUES = "enable.inline.values";
+
+    /**Should the inline values be visible - default value.
+     *
+     * @since 2.87
+     */
+    public static final boolean DEF_INLINE_VALUES = true;
 }

java/debugger.jpda.ui/src/org/netbeans/modules/debugger/jpda/ui/models/InlineValueComputerImpl.java

@@ -36,6 +36,9 @@
 import java.util.function.Consumer;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.prefs.PreferenceChangeEvent;
+import java.util.prefs.PreferenceChangeListener;
+import java.util.prefs.Preferences;
 import java.util.stream.Collectors;
 import javax.swing.text.AttributeSet;
 import javax.swing.text.Document;
@@ -48,6 +51,7 @@
 import org.netbeans.api.debugger.jpda.JPDADebugger;
 import org.netbeans.api.debugger.jpda.ObjectVariable;
 import org.netbeans.api.debugger.jpda.Variable;
+import org.netbeans.api.editor.mimelookup.MimeLookup;
 import org.netbeans.api.editor.mimelookup.MimeRegistration;
 import org.netbeans.api.editor.settings.AttributesUtilities;
 import org.netbeans.api.java.source.CancellableTask;
@@ -68,6 +72,7 @@
 import org.netbeans.modules.parsing.spi.TaskIndexingMode;
 import org.netbeans.spi.debugger.ContextProvider;
 import org.netbeans.spi.debugger.DebuggerServiceRegistration;
+import org.netbeans.spi.debugger.ui.Constants;
 import org.netbeans.spi.editor.highlighting.HighlightsLayer;
 import org.netbeans.spi.editor.highlighting.HighlightsLayerFactory;
 import org.netbeans.spi.editor.highlighting.HighlightsSequence;
@@ -79,22 +84,26 @@
 import org.openide.util.Exceptions;
 import org.openide.util.Lookup;
 import org.openide.util.RequestProcessor;
+import org.openide.util.WeakListeners;
 import org.openide.util.lookup.ServiceProvider;
 import org.openide.util.lookup.ServiceProviders;
 
 
 @DebuggerServiceRegistration(path="netbeans-JPDASession/inlineValue", types=InlineValueComputer.class)
-public class InlineValueComputerImpl implements InlineValueComputer, PropertyChangeListener {
+public class InlineValueComputerImpl implements InlineValueComputer, PreferenceChangeListener, PropertyChangeListener {
 
     private static final Logger LOG = Logger.getLogger(InlineValueComputerImpl.class.getName());
     private static final RequestProcessor EVALUATOR = new RequestProcessor(InlineValueComputerImpl.class.getName(), 1, false, false);
     private static final String JAVA_STRATUM = "Java"; //XXX: this is probably already defined somewhere
     private final JPDADebuggerImpl debugger;
+    private final Preferences prefs;
     private TaskDescription currentTask;
 
     public InlineValueComputerImpl(ContextProvider contextProvider) {
         debugger = (JPDADebuggerImpl) contextProvider.lookupFirst(null, JPDADebugger.class);
         debugger.addPropertyChangeListener(this);
+        prefs = MimeLookup.getLookup("text/x-java").lookup(Preferences.class);
+        prefs.addPreferenceChangeListener(WeakListeners.create(PreferenceChangeListener.class, this, prefs));
     }
 
     @Override
@@ -105,108 +114,118 @@ public void propertyChange(PropertyChangeEvent evt) {
         }
 
         if (JPDADebugger.PROP_CURRENT_CALL_STACK_FRAME.equals(evt.getPropertyName())) {
-            CallStackFrame frame = debugger.getCurrentCallStackFrame();
+            refreshVariables();
+        }
+    }
 
-            FileObject frameFile = null;
-            int frameLineNumber = -1;
-            Document frameDocument = null;
+    @Override
+    public void preferenceChange(PreferenceChangeEvent evt) {
+        refreshVariables();
+    }
 
-            if (frame != null && !frame.isObsolete() &&
-                frame.getThread().isSuspended() &&
-                JAVA_STRATUM.equals(frame.getDefaultStratum())) {
-                try {
-                    String url = debugger.getEngineContext().getURL(frame, JAVA_STRATUM);
-                    frameFile = url != null ? URLMapper.findFileObject(URI.create(url).toURL()) : null;
-                    if (frameFile != null) {
-                        frameLineNumber = frame.getLineNumber(JAVA_STRATUM);
-                        EditorCookie ec = frameFile.getLookup().lookup(EditorCookie.class);
-                        frameDocument = ec != null ? ec.getDocument() : null;
-                    }
-                } catch (InternalExceptionWrapper | InvalidStackFrameExceptionWrapper | ObjectCollectedExceptionWrapper | VMDisconnectedExceptionWrapper | MalformedURLException ex) {
-                    Exceptions.printStackTrace(ex);
+    private void refreshVariables() {
+        CallStackFrame frame = debugger.getCurrentCallStackFrame();
+
+        FileObject frameFile = null;
+        int frameLineNumber = -1;
+        Document frameDocument = null;
+
+        if (prefs.getBoolean(Constants.KEY_INLINE_VALUES, Constants.DEF_INLINE_VALUES) &&
+            frame != null && !frame.isObsolete() &&
+            frame.getThread().isSuspended() &&
+            JAVA_STRATUM.equals(frame.getDefaultStratum())) {
+            try {
+                String url = debugger.getEngineContext().getURL(frame, JAVA_STRATUM);
+                frameFile = url != null ? URLMapper.findFileObject(URI.create(url).toURL()) : null;
+                if (frameFile != null) {
+                    frameLineNumber = frame.getLineNumber(JAVA_STRATUM);
+                    EditorCookie ec = frameFile.getLookup().lookup(EditorCookie.class);
+                    frameDocument = ec != null ? ec.getDocument() : null;
                 }
+            } catch (InternalExceptionWrapper | InvalidStackFrameExceptionWrapper | ObjectCollectedExceptionWrapper | VMDisconnectedExceptionWrapper | MalformedURLException ex) {
+                Exceptions.printStackTrace(ex);
             }
+        }
 
-            TaskDescription newTask;
+        TaskDescription newTask;
 
-            if (frameFile != null && frameDocument != null) {
-                newTask = new TaskDescription(frameFile, frameLineNumber, frameDocument);
-            } else {
-                newTask = null;
-            }
+        if (frameFile != null && frameDocument != null) {
+            newTask = new TaskDescription(frameFile, frameLineNumber, frameDocument);
+        } else {
+            newTask = null;
+        }
 
-            if (setNewTask(newTask)) {
-                return;
-            }
+        if (setNewTask(newTask)) {
+            return;
+        }
 
-            if (newTask != null) {
-                //TODO: cancel any already running computation if the configuration is different:
-                CountDownLatch computationDone = new CountDownLatch(1);
+        if (newTask != null) {
+            //TODO: cancel any already running computation if the configuration is different:
+            CountDownLatch computationDone = new CountDownLatch(1);
 
-                newTask.addCancelCallback(computationDone::countDown);
+            newTask.addCancelCallback(computationDone::countDown);
 
-                AtomicReference<Collection<InlineVariable>> values = new AtomicReference<>();
+            AtomicReference<Collection<InlineVariable>> values = new AtomicReference<>();
 
-                EVALUATOR.post(() -> {
-                    OffsetsBag runningBag = new OffsetsBag(newTask.frameDocument);
+            EVALUATOR.post(() -> {
+                OffsetsBag runningBag = new OffsetsBag(newTask.frameDocument);
 
-                    Lookup.getDefault().lookup(ComputeInlineVariablesFactory.class).set(newTask.frameFile, newTask.frameLineNumber, variables -> {
-                        values.set(variables);
-                        computationDone.countDown();
-                    });
+                Lookup.getDefault().lookup(ComputeInlineVariablesFactory.class).set(newTask.frameFile, newTask.frameLineNumber, variables -> {
+                    values.set(variables);
+                    computationDone.countDown();
+                });
 
-                    try {
-                        computationDone.await();
-                    } catch (InterruptedException ex) {
-                        Exceptions.printStackTrace(ex);
-                    }
+                try {
+                    computationDone.await();
+                } catch (InterruptedException ex) {
+                    Exceptions.printStackTrace(ex);
+                }
 
-                    if (newTask.isCancelled()) {
-                        return ;
-                    }
+                if (newTask.isCancelled()) {
+                    return ;
+                }
+
+                Collection<InlineVariable> variables = values.get();
 
-                    Collection<InlineVariable> variables = values.get();
+                if (values == null) {
+                    return ;
+                }
 
-                    if (values == null) {
+                Map<String, Variable> expression2Value = new HashMap<>();
+                Map<Integer, Map<String, String>> line2Values = new HashMap<>();
+
+                for (InlineVariable v : variables) {
+                    if (newTask.isCancelled()) {
                         return ;
                     }
 
-                    Map<String, Variable> expression2Value = new HashMap<>();
-                    Map<Integer, Map<String, String>> line2Values = new HashMap<>();
-
-                    for (InlineVariable v : variables) {
-                        if (newTask.isCancelled()) {
-                            return ;
+                    Variable value = expression2Value.computeIfAbsent(v.expression, expr -> {
+                        try {
+                            return debugger.evaluate(expr);
+                        } catch (InvalidExpressionException ex) {
+                            //the variable may not exist
+                            LOG.log(Level.FINE, null, ex);
+                            return null;
                         }
-
-                        Variable value = expression2Value.computeIfAbsent(v.expression, expr -> {
-                            try {
-                                return debugger.evaluate(expr);
-                            } catch (InvalidExpressionException ex) {
-                                //the variable may not exist
-                                LOG.log(Level.FINE, null, ex);
-                                return null;
-                            }
-                        });
-                        if (value != null) {
-                            String valueText;
-                            if (value instanceof ObjectVariable ov) {
-                                valueText = toValue(ov).replace("\n", "\\n");
-                            } else {
-                                valueText = value.getValue();
-                            }
-                            line2Values.computeIfAbsent(v.lineEnd, __ -> new LinkedHashMap<>())
-                                       .putIfAbsent(v.expression, v.expression + " = " + valueText);
-                            String mergedValues = line2Values.get(v.lineEnd).values().stream().collect(Collectors.joining(", ", "  ", ""));
-                            AttributeSet attrs = AttributesUtilities.createImmutable("virtual-text-prepend", mergedValues);
-
-                            runningBag.addHighlight(v.lineEnd, v.lineEnd + 1, attrs);
-
-                            setHighlights(newTask, runningBag);
+                    });
+                    if (value != null) {
+                        String valueText;
+                        if (value instanceof ObjectVariable ov) {
+                            valueText = toValue(ov).replace("\n", "\\n");
+                        } else {
+                            valueText = value.getValue();
                         }
+                        line2Values.computeIfAbsent(v.lineEnd, __ -> new LinkedHashMap<>())
+                                   .putIfAbsent(v.expression, v.expression + " = " + valueText);
+                        String mergedValues = line2Values.get(v.lineEnd).values().stream().collect(Collectors.joining(", ", "  ", ""));
+                        AttributeSet attrs = AttributesUtilities.createImmutable("virtual-text-prepend", mergedValues);
+
+                        runningBag.addHighlight(v.lineEnd, v.lineEnd + 1, attrs);
+
+                        setHighlights(newTask, runningBag);
                     }
-                });
-            }
+                }
+            });
         }
     }