protected void toggleWatchpoint( IResource resource, int lineNumber, String fcn, String var, boolean access, boolean modification) throws CoreException { // look for existing watchpoint to delete IBreakpoint[] breakpoints = DebugPlugin.getDefault() .getBreakpointManager() .getBreakpoints(DebugCorePlugin.ID_PDA_DEBUG_MODEL); for (int i = 0; i < breakpoints.length; i++) { IBreakpoint breakpoint = breakpoints[i]; if (breakpoint instanceof PDAWatchpoint && resource.equals(breakpoint.getMarker().getResource())) { PDAWatchpoint watchpoint = (PDAWatchpoint) breakpoint; String otherVar = watchpoint.getVariableName(); String otherFcn = watchpoint.getFunctionName(); if (otherVar.equals(var) && otherFcn.equals(fcn)) { breakpoint.delete(); return; } } } // create watchpoint PDAWatchpoint watchpoint = new PDAWatchpoint(resource, lineNumber + 1, fcn, var, access, modification); DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(watchpoint); }
@Override public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection) throws CoreException { AbstractTextEditor editor = getEditor(part); if (editor != null) { IResource resource = (IResource) editor.getEditorInput().getAdapter(IResource.class); ITextSelection textSelection = (ITextSelection) selection; int lineNumber = textSelection.getStartLine() + 1; IBreakpoint[] breakpoints = DebugPlugin.getDefault() .getBreakpointManager() .getBreakpoints(DartDebugCorePlugin.DEBUG_MODEL_ID); for (int i = 0; i < breakpoints.length; i++) { IBreakpoint breakpoint = breakpoints[i]; if (resource.equals(breakpoint.getMarker().getResource())) { if (((ILineBreakpoint) breakpoint).getLineNumber() == lineNumber) { breakpoint.delete(); return; } } } DartBreakpoint breakpoint = new DartBreakpoint(resource, lineNumber); DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(breakpoint); } }
private static void terminate(final ILaunch previousLaunch) throws DebugException { final Object signal = new Object(); final boolean[] terminated = {false}; DebugPlugin debugPlugin = DebugPlugin.getDefault(); debugPlugin.addDebugEventListener( new IDebugEventSetListener() { public void handleDebugEvents(final DebugEvent[] events) { for (int i = 0; i < events.length; i++) { DebugEvent event = events[i]; if (isTerminateEventFor(event, previousLaunch)) { DebugPlugin.getDefault().removeDebugEventListener(this); synchronized (signal) { terminated[0] = true; signal.notifyAll(); } } } } }); previousLaunch.terminate(); try { synchronized (signal) { if (!terminated[0]) { signal.wait(); } } } catch (InterruptedException e) { // ignore } }
protected void terminated() { DebugPlugin manager = DebugPlugin.getDefault(); if (manager != null) { DebugEvent event = new DebugEvent(this, DebugEvent.TERMINATE); manager.fireDebugEventSet(new DebugEvent[] {event}); } }
private static void execute(String commandLine, String[] expectedArgs, String expectedRendered) throws Exception { String[] arguments = DebugPlugin.parseArguments(commandLine); assertEquals( "unexpected parseArguments result;", //$NON-NLS-1$ Arrays.asList(expectedArgs).toString(), Arrays.asList(arguments).toString()); runCommandLine(commandLine, arguments); String rendered = DebugPlugin.renderArguments(arguments, null); assertEquals("unexpected renderArguments result;", expectedRendered, rendered); // $NON-NLS-1$ if (!commandLine.equals(rendered)) { String[] arguments2 = DebugPlugin.parseArguments(rendered); assertEquals( "parsing rendered command line doesn't yield original arguments;", //$NON-NLS-1$ Arrays.asList(expectedArgs).toString(), Arrays.asList(arguments2).toString()); } String[] splitArguments = DebugPlugin.splitArguments(commandLine); assertEquals(expectedArgs.length, splitArguments.length); StringBuilder sb = new StringBuilder(); for (int i = 0; i < splitArguments.length; i++) { if (i > 0) { sb.append(" "); // $NON-NLS-1$ } sb.append(splitArguments[i]); } assertEquals(commandLine, sb.toString()); }
/* (non-Javadoc) * @see org.eclipse.debug.ui.actions.IToggleBreakpointsTarget#toggleLineBreakpoints(org.eclipse.ui.IWorkbenchPart, org.eclipse.jface.viewers.ISelection) */ @Override public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection) throws CoreException { ITextEditor textEditor = getEditor(part); if (textEditor != null) { IResource resource = textEditor.getEditorInput().getAdapter(IResource.class); ITextSelection textSelection = (ITextSelection) selection; int lineNumber = textSelection.getStartLine(); IBreakpoint[] breakpoints = DebugPlugin.getDefault() .getBreakpointManager() .getBreakpoints(DebugCorePlugin.ID_PDA_DEBUG_MODEL); for (int i = 0; i < breakpoints.length; i++) { IBreakpoint breakpoint = breakpoints[i]; if (breakpoint instanceof ILineBreakpoint && resource.equals(breakpoint.getMarker().getResource())) { if (((ILineBreakpoint) breakpoint).getLineNumber() == (lineNumber + 1)) { // remove breakpoint.delete(); return; } } } // create line breakpoint (doc line numbers start at 0) PDALineBreakpoint lineBreakpoint = new PDALineBreakpoint(resource, lineNumber + 1); DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(lineBreakpoint); } }
public void toggleLineBreakpoints(IWorkbenchPart part, ISelection selection) throws CoreException { if (part instanceof IEditorPart) { IEditorPart editor = (IEditorPart) part; IResource resource = (IResource) editor.getEditorInput().getAdapter(IResource.class); ITextSelection textSelection = (ITextSelection) selection; int lineNumber = textSelection.getStartLine(); IBreakpoint[] breakpoints = DebugPlugin.getDefault() .getBreakpointManager() .getBreakpoints(IDroolsDebugConstants.ID_DROOLS_DEBUG_MODEL); for (int i = 0; i < breakpoints.length; i++) { IBreakpoint breakpoint = breakpoints[i]; if (resource.equals(breakpoint.getMarker().getResource())) { if (breakpoint.getMarker().getType().equals(IDroolsDebugConstants.DROOLS_MARKER_TYPE)) { if (((DroolsLineBreakpoint) breakpoint).getDRLLineNumber() == (lineNumber + 1)) { breakpoint.delete(); return; } } } } // TODO: drools breakpoints can only be created in functions and consequences DroolsLineBreakpoint lineBreakpoint = new DroolsLineBreakpoint(resource, lineNumber + 1); DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(lineBreakpoint); } }
/** Cleans up the process so that it will display as terminated. */ protected void finish() { DebugPlugin manager = DebugPlugin.getDefault(); if (manager != null) { manager.fireDebugEventSet(new DebugEvent[] {new DebugEvent(this, DebugEvent.TERMINATE)}); } paused = false; }
/** * Provide the initialization of the listeners additions. The Window, Part, and Document Listener * are added. Note that sensor shell should be instantiated before this method is called because * <code>processActivity()</code> method uses sensor shell instance. */ private void registerListeners() { IWorkbench workbench = EclipseSensorPlugin.getInstance().getWorkbench(); // :RESOLVED: JULY 1, 2003 // Supports the multiple window for sensor collection. IWorkbenchWindow[] activeWindows = workbench.getWorkbenchWindows(); // Check if window listener is not added yet. Otherwise multi instances are notified. if (this.windowListener == null) { this.windowListener = new WindowListenerAdapter(); workbench.addWindowListener(new WindowListenerAdapter()); } for (int i = 0; i < activeWindows.length; i++) { IWorkbenchPage activePage = activeWindows[i].getActivePage(); activePage.addPartListener(new PartListenerAdapter()); IEditorPart activeEditorPart = activePage.getActiveEditor(); // Adds this EclipseSensorPlugin instance to IDocumentListener // only when activeEditorPart is the instance of ITextEditor // so that null case is also ignored. if (activeEditorPart instanceof ITextEditor) { // Sets activeTextEditor. Otherwise a first activated file would not be recorded. this.activeTextEditor = (ITextEditor) activeEditorPart; // Gets opened file since the initial opened file is not notified from IPartListener. URI fileResource = EclipseSensor.this.getFileResource(this.activeTextEditor); Map<String, String> keyValueMap = new HashMap<String, String>(); keyValueMap.put(EclipseSensorConstants.SUBTYPE, "Open"); keyValueMap.put(EclipseSensorConstants.UNIT_TYPE, EclipseSensorConstants.FILE); keyValueMap.put( EclipseSensorConstants.UNIT_NAME, EclipseSensor.this.extractFileName(fileResource)); this.addDevEvent( EclipseSensorConstants.DEVEVENT_EDIT, fileResource, keyValueMap, "Opened " + fileResource.toString()); IDocumentProvider provider = this.activeTextEditor.getDocumentProvider(); IDocument document = provider.getDocument(activeEditorPart.getEditorInput()); // Initially sets active buffer and threshold buffer. // Otherwise a first activated buffer would not be recorded. this.activeBufferSize = document.getLength(); this.thresholdBufferSize = document.getLength(); document.addDocumentListener(new DocumentListenerAdapter()); } } // Handles breakpoint set/unset event. IBreakpointManager bpManager = DebugPlugin.getDefault().getBreakpointManager(); bpManager.addBreakpointListener(new BreakPointerSensor(this)); // Listens to debug event. DebugPlugin.getDefault().addDebugEventListener(new DebugSensor(this)); // Creates instance to handle build error. this.buildErrorSensor = new BuildErrorSensor(this); }
@Override protected void dispose() { super.dispose(); if (DebugPlugin.getDefault() != null) { DebugPlugin.getDefault().removeDebugEventListener(this); } }
/** * Cleans up the internal state of this debug target as a result of a session ending with a VM (as * a result of a disconnect or termination of the VM). * * <p>All threads are removed from this target. This target is removed as a breakpoint listener, * and all breakpoints are removed from this target. */ protected void cleanup() { removeAllThreads(); DebugPlugin plugin = DebugPlugin.getDefault(); plugin.getBreakpointManager().removeBreakpointListener(this); // plugin.getLaunchManager().removeLaunchListener(this); // plugin.getBreakpointManager().removeBreakpointManagerListener(this); // plugin.removeDebugEventListener(this); removeAllBreakpoints(); }
public void disconnected() { if (!disconnectAspect.isDisconnected()) { setDisconnected(true); DebugPlugin.getDefault() .getBreakpointManager() .removeBreakpointManagerListener(workspaceRelations.getBreakpointHandler()); DebugPlugin.getDefault().getBreakpointManager().removeBreakpointListener(debugTargetImpl); fireTerminateEvent(); } }
@Override public boolean finalLaunchCheck( ILaunchConfiguration configuration, String mode, IProgressMonitor monitor) throws CoreException { // Check for existing launches of same resource BndPreferences prefs = new BndPreferences(); if (prefs.getWarnExistingLaunches()) { IResource launchResource = LaunchUtils.getTargetResource(configuration); if (launchResource == null) throw new CoreException( new Status( IStatus.ERROR, Plugin.PLUGIN_ID, 0, "Bnd launch target was not specified or does not exist.", null)); int processCount = 0; for (ILaunch l : DebugPlugin.getDefault().getLaunchManager().getLaunches()) { // ... is it the same launch resource? ILaunchConfiguration launchConfig = l.getLaunchConfiguration(); if (launchConfig == null) { continue; } if (launchResource.equals(LaunchUtils.getTargetResource(launchConfig))) { // Iterate existing processes for (IProcess process : l.getProcesses()) { if (!process.isTerminated()) processCount++; } } } // Warn if existing processes running if (processCount > 0) { Status status = new Status( IStatus.WARNING, Plugin.PLUGIN_ID, 0, "One or more OSGi Frameworks have already been launched for this configuration. Additional framework instances may interfere with each other due to the shared storage directory.", null); IStatusHandler prompter = DebugPlugin.getDefault().getStatusHandler(status); if (prompter != null) { boolean okay = (Boolean) prompter.handleStatus(status, launchResource); if (!okay) return okay; } } } IStatus launchStatus = getLauncherStatus(); IStatusHandler prompter = DebugPlugin.getDefault().getStatusHandler(launchStatus); if (prompter != null) return (Boolean) prompter.handleStatus(launchStatus, model); return true; }
private void cleanup() { ILaunch[] allLaunches = DebugPlugin.getDefault().getLaunchManager().getLaunches(); if (allLaunches != null) { for (int i = 0; i < allLaunches.length; i++) { if (launch != allLaunches[i]) { DebugPlugin.getDefault().getLaunchManager().removeLaunch(allLaunches[i]); } } } }
/* (non-Javadoc) * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object) */ @Override public int compare(Object arg0, Object arg1) { IBreakpoint bp0 = (IBreakpoint) DebugPlugin.getAdapter(arg0, IBreakpoint.class); IBreakpoint bp1 = (IBreakpoint) DebugPlugin.getAdapter(arg1, IBreakpoint.class); if (bp0 != null && bp1 != null) { return doCompare(bp0, bp1); } else if (arg0 instanceof IBreakpointContainer && arg1 instanceof IBreakpointContainer) { return doCompare((IBreakpointContainer) arg0, (IBreakpointContainer) arg1); } else { return -1; // just return -1 if the two objects are not IBreakpoint type } }
private static ILaunchConfiguration createLaunchConfigurationForProject(IJavaProject javaProject) throws CoreException { DebugPlugin plugin = DebugPlugin.getDefault(); ILaunchManager manager = plugin.getLaunchManager(); ILaunchConfigurationType javaAppType = manager.getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION); ILaunchConfigurationWorkingCopy wc = javaAppType.newInstance(null, "temp-config"); wc.setAttribute( IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, javaProject.getElementName()); return wc; }
/** * Returns any logical value for the raw value. This method will recurse over the returned value * until the same structure is encountered again (to avoid infinite recursion). * * @param value raw value to possibly be replaced by a logical value * @param previousStructureIds the list of logical structures that have already been applied to * the returned value during the recursion of this method. Callers should always pass in a * new, empty list. * @return logical value if one is calculated, otherwise the raw value is returned */ protected IValue getLogicalValue( IValue value, List previousStructureIds, IPresentationContext context) throws CoreException { if (isShowLogicalStructure(context)) { ILogicalStructureType[] types = DebugPlugin.getLogicalStructureTypes(value); if (types.length > 0) { ILogicalStructureType type = DebugPlugin.getDefaultStructureType(types); if (type != null && !previousStructureIds.contains(type.getId())) { IValue logicalValue = getLogicalStructureCache().getLogicalStructure(type, value); previousStructureIds.add(type.getId()); return getLogicalValue(logicalValue, previousStructureIds, context); } } } return value; }
protected ILaunch doLaunch(ILaunchConfiguration config, String testName) throws URISyntaxException, IOException, CoreException { ILaunch launch; IPath pathToFiles = getPathToFiles(testName); if (!ValgrindTestsPlugin.RUN_VALGRIND) { bindLocation(pathToFiles); } ILaunchConfigurationWorkingCopy wc = config.getWorkingCopy(); wc.setAttribute( LaunchConfigurationConstants.ATTR_INTERNAL_OUTPUT_DIR, pathToFiles.toOSString()); wc.doSave(); ValgrindTestLaunchDelegate delegate = new ValgrindTestLaunchDelegate(); launch = new Launch(config, ILaunchManager.PROFILE_MODE, null); DebugPlugin.getDefault().getLaunchManager().addLaunch(launch); launches.add(launch); delegate.launch(config, ILaunchManager.PROFILE_MODE, launch, null); if (ValgrindTestsPlugin.RUN_VALGRIND) { unbindLocation(pathToFiles); } return launch; }
/** * Returns the logical structure cache to use to store calculated structures. If the cache does * not exist yet, one is created and a debug event listener is added to clear the cache on RESUME * and TERMINATE events. * * @return the logical structure cache to use */ protected synchronized LogicalStructureCache getLogicalStructureCache() { if (fgLogicalCache == null) { fgLogicalCache = new LogicalStructureCache(); // Add a listener to clear the cache when resuming, terminating, or suspending DebugPlugin.getDefault() .addDebugEventListener( new IDebugEventSetListener() { public void handleDebugEvents(DebugEvent[] events) { for (int i = 0; i < events.length; i++) { if (events[i].getKind() == DebugEvent.TERMINATE) { fgLogicalCache.clear(); break; } else if (events[i].getKind() == DebugEvent.RESUME && events[i].getDetail() != DebugEvent.EVALUATION_IMPLICIT) { fgLogicalCache.clear(); break; } else if (events[i].getKind() == DebugEvent.SUSPEND && events[i].getDetail() != DebugEvent.EVALUATION_IMPLICIT) { fgLogicalCache.clear(); break; } else if (events[i].getKind() == DebugEvent.CHANGE && events[i].getDetail() == DebugEvent.CONTENT) { fgLogicalCache.clear(); break; } } } }); } return fgLogicalCache; }
public static ILaunchConfiguration[] getVerifierLaunchConfigs() throws CoreException { ILaunchManager manager = DebugPlugin.getDefault().getLaunchManager(); ILaunchConfigurationType veriferLaunchType = manager.getLaunchConfigurationType(VerifierLaunchConfiguration.LAUNCH_ID); ILaunchConfiguration[] cfgs = manager.getLaunchConfigurations(veriferLaunchType); return cfgs; }
/** * Validates if the drop is valid by validating the local selection transfer to ensure that a * watch expression can be created for each contained IVariable. * * @param target target of the drop * @return whether the drop is valid */ private boolean validateVariableDrop(Object target) { // Target must be null or an IExpression, you cannot add a new watch expression inside another if (target != null && getTargetExpression(target) == null) { return false; } IStructuredSelection selection = (IStructuredSelection) LocalSelectionTransfer.getTransfer().getSelection(); int enabled = 0; int size = -1; if (selection != null) { size = selection.size(); IExpressionManager manager = DebugPlugin.getDefault().getExpressionManager(); Iterator iterator = selection.iterator(); while (iterator.hasNext()) { Object element = iterator.next(); if (element instanceof IVariable) { IVariable variable = (IVariable) element; if (variable instanceof IndexedVariablePartition) { break; } else if (manager.hasWatchExpressionDelegate(variable.getModelIdentifier()) && isFactoryEnabled(variable)) { enabled++; } else { break; } } } } return enabled == size; }
protected ILaunch buildAndLaunch( ILaunchConfiguration configuration, String mode, IProgressMonitor monitor) throws CoreException { monitor.beginTask("", 1); // $NON-NLS-1$ try { MavenLaunchDelegate mvld = new TalendMavenLaunchDelegate(); ILaunch launch = new Launch(configuration, mode, null); ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager(); launch.setAttribute( DebugPlugin.ATTR_LAUNCH_TIMESTAMP, Long.toString(System.currentTimeMillis())); launch.setAttribute( DebugPlugin.ATTR_CONSOLE_ENCODING, launchManager.getEncoding(configuration)); if (isCaptureOutputInConsoleView()) { launchManager.addLaunch(launch); } String type = "org.eclipse.m2e.launching.MavenSourceLocator"; // $NON-NLS-1$ IPersistableSourceLocator locator = launchManager.newSourceLocator(type); locator.initializeDefaults(configuration); launch.setSourceLocator(locator); mvld.launch(configuration, mode, launch, monitor); return launch; } finally { monitor.done(); } }
public SimulationView() { DebugUITools.getDebugContextManager().addDebugContextListener(this); DebugPlugin.getDefault().addDebugEventListener(this); kit = new FormToolkit(Display.getDefault()); font = new Font(Display.getDefault(), new FontData("Courier", 10, SWT.BOLD)); clockUpdater = new ClockUpdater(); }
public void handleDebugEvents(DebugEvent[] events) { if (events != null && project != null) { int size = events.length; for (int i = 0; i < size; i++) { for (IProcess process : processes) { if (process != null && process.equals(events[i].getSource()) && events[i].getKind() == DebugEvent.TERMINATE) { DebugPlugin.getDefault().removeDebugEventListener(this); terminateForked(); Job job = new Job("refresh project") { @Override protected IStatus run(IProgressMonitor monitor) { try { project.refreshLocal(IResource.DEPTH_INFINITE, monitor); } catch (CoreException e) { } GrailsCoreActivator.getDefault().notifyCommandFinish(project); return Status.OK_STATUS; } }; job.setSystem(true); job.setRule(ResourcesPlugin.getWorkspace().getRuleFactory().buildRule()); job.setPriority(Job.INTERACTIVE); job.schedule(); } } } } }
/** * Resolves the {@link IBreakpoint} from the given editor and ruler information. Returns <code> * null</code> if no breakpoint exists or the operation fails. * * @param editor the editor * @param info the current ruler information * @return the {@link IBreakpoint} from the current editor position or <code>null</code> */ protected IBreakpoint getBreakpointFromEditor(ITextEditor editor, IVerticalRulerInfo info) { IAnnotationModel annotationModel = editor.getDocumentProvider().getAnnotationModel(editor.getEditorInput()); IDocument document = editor.getDocumentProvider().getDocument(editor.getEditorInput()); if (annotationModel != null) { @SuppressWarnings("unchecked") Iterator<Annotation> iterator = annotationModel.getAnnotationIterator(); while (iterator.hasNext()) { Object object = iterator.next(); if (object instanceof SimpleMarkerAnnotation) { SimpleMarkerAnnotation markerAnnotation = (SimpleMarkerAnnotation) object; IMarker marker = markerAnnotation.getMarker(); try { if (marker.isSubtypeOf(IBreakpoint.BREAKPOINT_MARKER)) { Position position = annotationModel.getPosition(markerAnnotation); int line = document.getLineOfOffset(position.getOffset()); if (line == info.getLineOfLastMouseButtonActivity()) { IBreakpoint breakpoint = DebugPlugin.getDefault().getBreakpointManager().getBreakpoint(marker); if (breakpoint != null) { return breakpoint; } } } } catch (CoreException e) { } catch (BadLocationException e) { } } } } return null; }
@Override public void setupLaunchConfiguration( ILaunchConfigurationWorkingCopy workingCopy, IProgressMonitor monitor) throws CoreException { super.setupLaunchConfiguration(workingCopy, monitor); workingCopy.setAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING, "UTF-8"); // $NON-NLS-1$ String existingVMArgs = workingCopy.getAttribute( IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, (String) null); if (null != existingVMArgs) { String[] parsedVMArgs = DebugPlugin.parseArguments(existingVMArgs); List<String> memoryArgs = new ArrayList<String>(); if (!CoreUtil.isNullOrEmpty(parsedVMArgs)) { for (String pArg : parsedVMArgs) { if (pArg.startsWith("-Xm") || pArg.startsWith("-XX:")) // $NON-NLS-1$ //$NON-NLS-2$ { memoryArgs.add(pArg); } } } String argsWithoutMem = mergeArguments( existingVMArgs, getRuntimeVMArguments(), memoryArgs.toArray(new String[0]), false); String fixedArgs = mergeArguments(argsWithoutMem, getRuntimeVMArguments(), null, false); workingCopy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, fixedArgs); } }
@Override protected GocodeServerInstance doCreateServerInstance(IOperationMonitor om) throws CommonException, OperationCancellation { Path gocodePath = getServerPath(); ArrayList2<String> commandLine = new ArrayList2<String>(); commandLine.add(gocodePath.toString()); commandLine.add("-s"); if (GocodeCompletionOperation.USE_TCP) { commandLine.add("-sock=tcp"); } LangCore.logInfo( "Starting gocode server: " + DebugPlugin.renderArguments(commandLine.toArray(String.class), null)); ProcessBuilder pb = new ProcessBuilder(commandLine); IToolOperationMonitor opMonitor = toolMgr.startNewOperation(ProcessStartKind.ENGINE_SERVER, true, false); String prefixText = "==== Starting gocode server ====\n"; gocodeSetEnableBuiltins(gocodePath, om, opMonitor, prefixText); ExternalProcessNotifyingHelper process = toolMgr.new RunToolTask(opMonitor, prefixText, null, pb, om).startProcess(); return new GocodeServerInstance(gocodePath, process); }
@Override public void stepInto() throws DebugException { target.sendRequest(GHCiSyntax.STEP_COMMAND, true); DebugPlugin.getDefault() .fireDebugEventSet( new DebugEvent[] {new DebugEvent(frame, DebugEvent.CHANGE, DebugEvent.CONTENT)}); }
public IBreakpoint findIBreakpoint(String filename, int lineNumber) { IBreakpoint[] breakpoints = DebugPlugin.getDefault() .getBreakpointManager() .getBreakpoints(this.debugServiceFactory.getLIConstants().getDebugModel()); for (int i = 0; i < breakpoints.length; i++) { IBreakpoint breakpoint = breakpoints[i]; if (supportsBreakpoint(breakpoint)) { try { if (breakpoint.isEnabled()) { // only add the breakpoint to the debugger when the // breakpoint is enabled int l = breakpoint.getMarker().getAttribute(IMarker.LINE_NUMBER, -1); // TODO: get marker language type or get language from // the resource IResource r = breakpoint.getMarker().getResource(); String location = r.getProjectRelativePath().toOSString(); if (l > 0) { // only linenumbers greater than 0 are valid as // linenumber is 1-based if (location.equals(filename) && lineNumber == l) { return breakpoint; } } } } catch (CoreException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } return null; }
@Override protected Control createDialogArea(Composite parent) { Composite contents = (Composite) super.createDialogArea(parent); setTitle(Messages.ManageLaunchesDialog_manageLaunches); setTitleImage(DartDebugUIPlugin.getImage("wiz/run_wiz.png")); // $NON-NLS-1$ Composite composite = new Composite(contents, SWT.NONE); GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(composite); createDialogUI(composite); DebugPlugin.getDefault().getLaunchManager().addLaunchConfigurationListener(this); parent.addDisposeListener( new DisposeListener() { @Override public void widgetDisposed(DisposeEvent e) { DebugPlugin.getDefault() .getLaunchManager() .removeLaunchConfigurationListener(ManageLaunchesDialog.this); } }); return contents; }