Merge pull request #1661 from JetBrains/feature/pausepoints

Add pausepoints

rider/src/main/kotlin/com/jetbrains/rider/plugins/unity/debugger/breakpoints/UnityPausepointBreakpointType.kt

@@ -0,0 +1,43 @@
+package com.jetbrains.rider.plugins.unity.debugger.breakpoints
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.xdebugger.breakpoints.SuspendPolicy
+import com.intellij.xdebugger.breakpoints.XLineBreakpoint
+import com.jetbrains.rider.debugger.breakpoint.DotNetLineBreakpointProperties
+import com.jetbrains.rider.debugger.breakpoint.DotNetLineBreakpointType
+import icons.UnityIcons
+import java.util.*
+import javax.swing.Icon
+
+class UnityPausepointBreakpointType : DotNetLineBreakpointType(Id, Title) {
+    companion object {
+        const val Id = "UnityPausepointType"
+        const val Title = "Unity Pausepoints"
+    }
+
+    override fun getDisplayText(breakpoint: XLineBreakpoint<DotNetLineBreakpointProperties>?): String {
+        return "Pause Unity editor when debugger reaches " + super.getDisplayText(breakpoint)
+    }
+
+    override fun getDisabledIcon(): Icon = UnityIcons.Debugger.Db_disabled_pausepoint
+    override fun getEnabledIcon(): Icon = UnityIcons.Debugger.Db_set_pausepoint
+    override fun getInactiveDependentIcon(): Icon = UnityIcons.Debugger.Db_dep_line_pausepoint
+    override fun getInvalidIcon(): Icon = UnityIcons.Debugger.Db_invalid_pausepoint
+    override fun getMutedDisabledIcon(): Icon = UnityIcons.Debugger.Db_muted_disabled_pausepoint
+    override fun getMutedEnabledIcon(): Icon = UnityIcons.Debugger.Db_muted_pausepoint
+    override fun getSuspendNoneIcon(): Icon = UnityIcons.Debugger.Db_no_suspend_pausepoint
+    // Temporary is remove-once-hit
+    override fun getTemporaryIcon(): Icon = UnityIcons.Debugger.Db_set_pausepoint
+    override fun getVerifiedIcon() = UnityIcons.Debugger.Db_verified_pausepoint
+    override fun getVerifiedIconWithNoSuspend() = UnityIcons.Debugger.Db_verified_no_suspend_pausepoint
+    // getPendingIcon is not overridden. Base will return null, which then uses set icon
+
+    // Don't allow adding the breakpoint manually
+    override fun canPutAt(file: VirtualFile, line: Int, project: Project): Boolean = false
+
+    override fun getPriority(): Int = super.getPriority() - 1
+    override fun getDefaultSuspendPolicy() = SuspendPolicy.NONE
+
+    override fun getVisibleStandardPanels(): EnumSet<StandardPanels> = EnumSet.of(StandardPanels.DEPENDENCY)
+}

rider/src/main/kotlin/com/jetbrains/rider/plugins/unity/debugger/breakpoints/UnityPausepointConstants.kt

@@ -0,0 +1,7 @@
+package com.jetbrains.rider.plugins.unity.debugger.breakpoints
+
+object UnityPausepointConstants {
+    const val pauseEditorCommand = "(UnityEditor.EditorApplication.isPaused = true) ? \"Unity pausepoint hit. Pausing Unity editor at the end of frame\" : \"Unable to pause Unity editor\""
+    const val convertToPausepointText = "Convert to Unity Pausepoint"
+    const val convertToLineBreakpointText = "Convert to Line Breakpoint"
+}

rider/src/main/kotlin/com/jetbrains/rider/plugins/unity/debugger/breakpoints/UnityPausepointHandlerFactory.kt

@@ -0,0 +1,23 @@
+package com.jetbrains.rider.plugins.unity.debugger.breakpoints
+
+import com.intellij.xdebugger.breakpoints.XBreakpointHandler
+import com.intellij.xdebugger.breakpoints.XLineBreakpoint
+import com.jetbrains.rider.debugger.DotNetDebugProcess
+import com.jetbrains.rider.debugger.breakpoint.DotNetLineBreakpointProperties
+import com.jetbrains.rider.debugger.breakpoint.IDotNetSupportedBreakpointHandlerFactory
+
+class UnityPausepointHandler(private val debugProcess: DotNetDebugProcess) : XBreakpointHandler<XLineBreakpoint<DotNetLineBreakpointProperties>>(UnityPausepointBreakpointType::class.java) {
+    override fun registerBreakpoint(breakpoint: XLineBreakpoint<DotNetLineBreakpointProperties>) {
+        debugProcess.breakpointsManager.registerLineBreakpoint(breakpoint)
+    }
+
+    override fun unregisterBreakpoint(breakpoint: XLineBreakpoint<DotNetLineBreakpointProperties>, p1: Boolean) {
+        debugProcess.breakpointsManager.unregisterLineBreakpoint(breakpoint)
+    }
+}
+
+class UnityPausepointHandlerFactory : IDotNetSupportedBreakpointHandlerFactory {
+    override fun createHandler(debugProcess: DotNetDebugProcess): XBreakpointHandler<*> {
+        return UnityPausepointHandler(debugProcess)
+    }
+}

rider/src/main/kotlin/com/jetbrains/rider/plugins/unity/debugger/breakpoints/UnityPausepointPanelProvider.kt

@@ -0,0 +1,88 @@
+package com.jetbrains.rider.plugins.unity.debugger.breakpoints
+
+import com.intellij.openapi.project.Project
+import com.intellij.ui.HyperlinkLabel
+import com.intellij.util.ui.UIUtil
+import com.intellij.xdebugger.XDebuggerManager
+import com.intellij.xdebugger.XDebuggerUtil
+import com.intellij.xdebugger.breakpoints.SuspendPolicy
+import com.intellij.xdebugger.breakpoints.XLineBreakpoint
+import com.intellij.xdebugger.breakpoints.ui.XBreakpointCustomPropertiesPanel
+import com.jetbrains.rd.platform.util.application
+import com.jetbrains.rider.UnityProjectDiscoverer
+import com.jetbrains.rider.debugger.breakpoint.DotNetLineBreakpointProperties
+import com.jetbrains.rider.debugger.breakpoint.DotNetLineBreakpointType
+import com.jetbrains.rider.debugger.breakpoint.IDotNetLineBreakpointCustomPanelsProvider
+import javax.swing.JComponent
+import javax.swing.event.HyperlinkListener
+
+class UnityPausepointPanelProvider : IDotNetLineBreakpointCustomPanelsProvider {
+    override fun getCustomBreakpointPanel(project: Project): XBreakpointCustomPropertiesPanel<XLineBreakpoint<DotNetLineBreakpointProperties>>? {
+        if (!UnityProjectDiscoverer.getInstance(project).isUnityProject)
+            return null
+        return UnityPausepointPanel(project)
+    }
+}
+
+class UnityPausepointPanel(private val project: Project) : XBreakpointCustomPropertiesPanel<XLineBreakpoint<DotNetLineBreakpointProperties>>() {
+
+    private val activatePausepointHyperlink = HyperlinkLabel(UnityPausepointConstants.convertToPausepointText)
+    private var currentListener: HyperlinkListener? = null
+
+    override fun loadFrom(breakpoint: XLineBreakpoint<DotNetLineBreakpointProperties>) {
+        val isPausepoint = breakpoint.type is UnityPausepointBreakpointType
+        activatePausepointHyperlink.setHyperlinkText(
+            if (isPausepoint)
+                UnityPausepointConstants.convertToLineBreakpointText
+            else
+                UnityPausepointConstants.convertToPausepointText
+        )
+
+        val listener = HyperlinkListener {
+            if (!isPausepoint) {
+                convertToPausepoint(breakpoint)
+            } else {
+                convertToLineBreakpoint(breakpoint)
+            }
+        }
+
+        if (currentListener != null) {
+            activatePausepointHyperlink.removeHyperlinkListener(currentListener)
+        }
+        currentListener = listener
+
+        activatePausepointHyperlink.addHyperlinkListener(listener)
+    }
+
+    override fun saveTo(breakpoint: XLineBreakpoint<DotNetLineBreakpointProperties>) {
+    }
+
+    override fun getComponent(): JComponent = activatePausepointHyperlink
+
+    private fun convertToPausepoint(breakpoint: XLineBreakpoint<DotNetLineBreakpointProperties>) {
+        UIUtil.invokeLaterIfNeeded {
+            application.runWriteAction {
+                val breakpointManager = XDebuggerManager.getInstance(project).breakpointManager
+                val unityPausepointType = XDebuggerUtil.getInstance().findBreakpointType(UnityPausepointBreakpointType::class.java)
+                breakpointManager.removeBreakpoint(breakpoint)
+
+                breakpointManager.addLineBreakpoint(unityPausepointType, breakpoint.fileUrl, breakpoint.line, breakpoint.properties).apply {
+                    this.suspendPolicy = SuspendPolicy.NONE
+                    this.logExpression = UnityPausepointConstants.pauseEditorCommand
+                }
+            }
+        }
+    }
+
+    private fun convertToLineBreakpoint(breakpoint: XLineBreakpoint<DotNetLineBreakpointProperties>) {
+        UIUtil.invokeLaterIfNeeded {
+            application.runWriteAction {
+                val breakpointManager = XDebuggerManager.getInstance(project).breakpointManager
+                val dotnetLineBreakpointType = XDebuggerUtil.getInstance().findBreakpointType(DotNetLineBreakpointType::class.java)
+                breakpointManager.removeBreakpoint(breakpoint)
+
+                breakpointManager.addLineBreakpoint(dotnetLineBreakpointType, breakpoint.fileUrl, breakpoint.line, breakpoint.properties)
+            }
+        }
+    }
+}

rider/src/main/kotlin/com/jetbrains/rider/plugins/unity/run/UnityDebuggerOutputListener.kt

@@ -67,4 +67,4 @@ class UnityDebuggerOutputListener(val project: Project, private val host: String
         }
         super.onOutputMessageAvailable(message)
     }
-}
+}

rider/src/main/kotlin/icons/UnityIcons.kt

@@ -2,7 +2,6 @@ package icons
 
 import com.intellij.openapi.util.IconLoader
 import com.intellij.ui.AnimatedIcon
-import com.jetbrains.rider.icons.*
 import javax.swing.Icon
 
 // FYI: Icons are defined in C# files in the backend. When being shown in the frontend, only the icon ID is passed to
@@ -96,6 +95,23 @@ class UnityIcons {
         }
     }
 
+    class Debugger {
+        // Field and file names deliberately match the AllIcons.Debugger icons.
+        // Pausepoints are by definition "no suspend". Where the default breakpoint icon set includes a "no_suspend"
+        // variant, the same file name is used. Otherwise, the default name is drawn as "no_suspend".
+        companion object {
+            val Db_dep_line_pausepoint = IconLoader.getIcon("/Icons/debugger/db_dep_line_pausepoint.svg")
+            val Db_disabled_pausepoint = IconLoader.getIcon("/Icons/debugger/db_disabled_pausepoint.svg")
+            val Db_invalid_pausepoint = IconLoader.getIcon("/Icons/debugger/db_invalid_pausepoint.svg")
+            val Db_muted_pausepoint = IconLoader.getIcon("/Icons/debugger/db_muted_pausepoint.svg")
+            val Db_muted_disabled_pausepoint = IconLoader.getIcon("/Icons/debugger/db_muted_disabled_pausepoint.svg")
+            val Db_no_suspend_pausepoint = IconLoader.getIcon("/Icons/debugger/db_no_suspend_pausepoint.svg")
+            val Db_set_pausepoint = Db_no_suspend_pausepoint
+            val Db_verified_no_suspend_pausepoint = IconLoader.getIcon("/Icons/debugger/db_verified_no_suspend_pausepoint.svg")
+            val Db_verified_pausepoint = Db_verified_no_suspend_pausepoint
+        }
+    }
+
     class Explorer {
         companion object {
 

rider/src/main/resources/META-INF/plugin.xml

@@ -92,6 +92,9 @@
     <projectModelViewUpdater implementation="com.jetbrains.rider.plugins.unity.explorer.UnityExplorerProjectModelViewUpdater"/>
 
     <xdebugger.attachDebuggerProvider implementation="com.jetbrains.rider.plugins.unity.run.attach.UnityLocalAttachProcessDebuggerProvider" />
+    <xdebugger.breakpointType implementation="com.jetbrains.rider.plugins.unity.debugger.breakpoints.UnityPausepointBreakpointType" />
+    <rider.breakpoint.customPanelProvider implementation="com.jetbrains.rider.plugins.unity.debugger.breakpoints.UnityPausepointPanelProvider" />
+    <rider.debug.breakpoint.handler.factory implementation="com.jetbrains.rider.plugins.unity.debugger.breakpoints.UnityPausepointHandlerFactory" />
 
     <rider.android.project.validator implementation="com.jetbrains.rider.plugins.unity.android.UnityCustomAndroidProjectValidator"/>
     <rdclient.traceScenarioHolder implementation="com.jetbrains.rider.plugins.unity.logs.UnityLogTraceScenarios"/>