Datasets:
Mlxa
/
java_methods

Dataset card Data Studio Files
xet
 Community
1
Unnamed: 0
int64
0
305k
body
stringlengths
7
52.9k
name
stringlengths
1
185
295,400
Project () { return myProject; }
getProject
295,401
void (Collection<? extends XBreakpointBase<?, ?, ?>> breakpoints) { for (XBreakpointBase<?, ?, ?> breakpoint : breakpoints) { fireBreakpointChanged(breakpoint); } }
fireBreakpointsChanged
295,402
boolean (XBreakpoint<?> breakpoint) { return withLockMaybeCancellable(myLock, () -> myAllBreakpoints.contains(breakpoint)); }
isRegistered
295,403
void (XBreakpointBase<?, ?, ?> breakpoint) { if (isRegistered(breakpoint)) { if (breakpoint instanceof XLineBreakpointImpl) { myLineBreakpointManager.breakpointChanged((XLineBreakpointImpl)breakpoint); } sendBreakpointEvent(breakpoint.getType(), listener -> listener.breakpointChanged(breakpoint)); } }
fireBreakpointChanged
295,404
void (XBreakpoint<?> breakpoint, @Nullable XDebugSession session) { if (isRegistered(breakpoint)) { sendBreakpointEvent(breakpoint.getType(), listener -> listener.breakpointPresentationUpdated(breakpoint, session)); } }
fireBreakpointPresentationUpdated
295,405
void (@NotNull final XBreakpoint<?> breakpoint) { removeBreakpoints(List.of(breakpoint)); }
removeBreakpoint
295,406
void () { withLockMaybeCancellable(myLock, () -> List.copyOf(myAllBreakpoints).forEach(this::doRemoveBreakpoint)); }
removeAllBreakpoints
295,407
void (@NotNull final XBreakpoint<?> breakpoint) { withLockMaybeCancellable(myLock, () -> { if (!isDefaultBreakpoint(breakpoint)) { throw new IllegalStateException("Trying to remove not default breakpoint " + breakpoint); } doRemoveBreakpointImpl(breakpoint, true); }); }
removeDefaultBreakpoint
295,408
void (XBreakpoint<?> breakpoint) { if (isDefaultBreakpoint(breakpoint)) { // removing default breakpoint should just disable it breakpoint.setEnabled(false); } else { doRemoveBreakpointImpl(breakpoint, false); } }
doRemoveBreakpoint
295,409
void (XBreakpoint<?> breakpoint, boolean isDefaultBreakpoint) { XBreakpointType type = breakpoint.getType(); XBreakpointBase<?, ?, ?> breakpointBase = (XBreakpointBase<?, ?, ?>)breakpoint; withLockMaybeCancellable(myLock, () -> { if (isDefaultBreakpoint) { Set<XBreakpointBase<?, ?, ?>> typeDefaultBreakpoints = myDefaultBreakpoints.get(breakpoint.getType()); if (typeDefaultBreakpoints != null) { typeDefaultBreakpoints.remove(breakpoint); } } else { myBreakpoints.remove(type, breakpointBase); } myAllBreakpoints.remove(breakpointBase); if (breakpointBase instanceof XLineBreakpointImpl) { myLineBreakpointManager.unregisterBreakpoint((XLineBreakpointImpl)breakpointBase); } }); UIUtil.invokeLaterIfNeeded(() -> breakpointBase.dispose()); sendBreakpointEvent(type, listener -> listener.breakpointRemoved(breakpoint)); }
doRemoveBreakpointImpl
295,410
void (XBreakpointType type, Consumer<? super XBreakpointListener<XBreakpoint<?>>> event) { if (myFirstLoadDone) { EventDispatcher<XBreakpointListener> dispatcher = myDispatchers.get(type); if (dispatcher != null) { //noinspection unchecked XBreakpointListener<XBreakpoint<?>> multicaster = dispatcher.getMulticaster(); event.accept(multicaster); } event.accept(getBreakpointDispatcherMulticaster()); } }
sendBreakpointEvent
295,411
boolean (@NotNull XBreakpoint<?> breakpoint) { return withLockMaybeCancellable(myLock, () -> ContainerUtil.exists(myDefaultBreakpoints.values(), s -> s.contains(breakpoint))); }
isDefaultBreakpoint
295,412
void (@NotNull XLineBreakpoint<?> breakpoint, @Nullable Icon icon, @Nullable String errorMessage) { XLineBreakpointImpl lineBreakpoint = (XLineBreakpointImpl)breakpoint; CustomizedBreakpointPresentation presentation = lineBreakpoint.getCustomizedPresentation(); if (presentation == null) { if (icon == null && errorMessage == null) { return; } presentation = new CustomizedBreakpointPresentation(); } else if (Comparing.equal(presentation.getIcon(), icon) && Comparing.strEqual(presentation.getErrorMessage(), errorMessage)) { return; } presentation.setErrorMessage(errorMessage); presentation.setIcon(icon); lineBreakpoint.setCustomizedPresentation(presentation); myLineBreakpointManager.queueBreakpointUpdate(breakpoint, () -> fireBreakpointPresentationUpdated(breakpoint, null)); }
updateBreakpointPresentation
295,413
BreakpointManagerState (@NotNull BreakpointManagerState state) { // create default breakpoints map without locking var defaultBreakpointsMap = StreamEx.of(createDefaultBreakpoints()).toMap(XBreakpointBase::getType, Function.identity()); return withLockMaybeCancellable(myLock, () -> { myDependentBreakpointManager.saveState(); List<BreakpointState<?, ?, ?>> defaultBreakpoints = new SmartList<>(); for (Set<XBreakpointBase<?, ?, ?>> typeDefaultBreakpoints : myDefaultBreakpoints.values()) { if (!ContainerUtil.exists(typeDefaultBreakpoints, breakpoint -> differsFromDefault(defaultBreakpointsMap, breakpoint.getType(), breakpoint.getState()))) { continue; } for (XBreakpointBase<?, ?, ?> breakpoint : typeDefaultBreakpoints) { final BreakpointState breakpointState = breakpoint.getState(); defaultBreakpoints.add(breakpointState); } } List<BreakpointState<?, ?, ?>> breakpoints = new SmartList<>(); for (XBreakpointBase<?, ?, ?> breakpoint : myBreakpoints.values()) { breakpoints.add(breakpoint.getState()); } List<BreakpointState<?, ?, ?>> breakpointsDefaults = new SmartList<>(); for (Map.Entry<XBreakpointType, BreakpointState<?, ?, ?>> entry : myBreakpointsDefaults.entrySet()) { if (statesAreDifferent(entry.getValue(), createBreakpointDefaults(entry.getKey()), false)) { breakpointsDefaults.add(entry.getValue()); } } state.getDefaultBreakpoints().clear(); state.getDefaultBreakpoints().addAll(defaultBreakpoints); state.getBreakpoints().clear(); state.getBreakpoints().addAll(breakpoints); state.getBreakpointsDefaults().clear(); state.getBreakpointsDefaults().addAll(breakpointsDefaults); state.setBreakpointsDialogProperties(myBreakpointsDialogSettings); state.setDefaultGroup(myDefaultGroup); return state; }); }
saveState
295,414
boolean (BreakpointState state1, BreakpointState state2, boolean ignoreTimestamp) { long timeStamp1 = state1.getTimeStamp(); long timeStamp2 = state2.getTimeStamp(); if (ignoreTimestamp) { state1.setTimeStamp(timeStamp2); } Element elem1 = XmlSerializer.serialize(state1); Element elem2 = XmlSerializer.serialize(state2); boolean res = !JDOMUtil.areElementsEqual(elem1, elem2); if (ignoreTimestamp) { state1.setTimeStamp(timeStamp1); } return res; }
statesAreDifferent
295,415
void (@NotNull BreakpointManagerState state) { // create default breakpoint without locking var defaultBreakpoints = createDefaultBreakpoints(); // make sure that no RW lock is taken under myLock ApplicationManager.getApplication().runReadAction(() -> { withLockMaybeCancellable(myLock, () -> { myBreakpointsDialogSettings = state.getBreakpointsDialogProperties(); myAllBreakpoints.clear(); myDefaultBreakpoints.clear(); myBreakpointsDefaults.clear(); state.getDefaultBreakpoints().forEach(breakpointState -> loadBreakpoint(breakpointState, true)); //noinspection unchecked StreamEx.of(defaultBreakpoints) .remove(b -> myDefaultBreakpoints.containsKey(b.getType())) .forEach(b -> addBreakpoint(b, true, false)); List.copyOf(myBreakpoints.values()).forEach(this::doRemoveBreakpoint); ContainerUtil.notNullize(state.getBreakpoints()).forEach(breakpointState -> loadBreakpoint(breakpointState, false)); for (BreakpointState defaults : state.getBreakpointsDefaults()) { XBreakpointType<?, ?> type = XBreakpointUtil.findType(defaults.getTypeId()); if (type != null) { myBreakpointsDefaults.put(type, defaults); } else { LOG.warn("Unknown breakpoint type " + defaults.getTypeId()); } } myDependentBreakpointManager.loadState(); myLineBreakpointManager.updateBreakpointsUI(); myDefaultGroup = state.getDefaultGroup(); myFirstLoadDone = true; }); }); }
loadState
295,416
void () { // create default breakpoint without locking var defaultBreakpoints = createDefaultBreakpoints(); withLockMaybeCancellable(myLock, () -> { myDefaultBreakpoints.clear(); //noinspection unchecked defaultBreakpoints.forEach(b -> addBreakpoint(b, true, false)); myFirstLoadDone = true; }); }
noStateLoaded
295,417
List<XBreakpointBase> () { //noinspection unchecked return XBreakpointUtil.breakpointTypes().map(this::createDefaultBreakpoint).nonNull().toList(); }
createDefaultBreakpoints
295,418
void (BreakpointState breakpointState, final boolean defaultBreakpoint) { XBreakpointBase<?,?,?> breakpoint = createBreakpoint(breakpointState); if (breakpoint != null) { addBreakpoint(breakpoint, defaultBreakpoint, false); } myTime = Math.max(myTime, breakpointState.getTimeStamp()); }
loadBreakpoint
295,419
XBreakpointsDialogState () { return myBreakpointsDialogSettings; }
getBreakpointsDialogSettings
295,420
void (XBreakpointsDialogState breakpointsDialogSettings) { myBreakpointsDialogSettings = breakpointsDialogSettings; }
setBreakpointsDialogSettings
295,421
Set<String> () { return withLockMaybeCancellable(myLock, () -> StreamEx.of(myAllBreakpoints).map(XBreakpointBase::getGroup).nonNull().toSet()); }
getAllGroups
295,422
String () { return myDefaultGroup; }
getDefaultGroup
295,423
void (String defaultGroup) { myDefaultGroup = defaultGroup; }
setDefaultGroup
295,424
BreakpointState (@NotNull XBreakpointType type) { return withLockMaybeCancellable(myLock, () -> myBreakpointsDefaults.computeIfAbsent(type, k -> createBreakpointDefaults(type))); }
getBreakpointDefaults
295,425
BreakpointState (@NotNull XBreakpointType type) { BreakpointState state = new BreakpointState(); state.setTypeId(type.getId()); state.setSuspendPolicy(type.getDefaultSuspendPolicy()); return state; }
createBreakpointDefaults
295,426
void (@NotNull XBreakpointBase breakpoint) { myLastRemovedBreakpoint = new RemovedBreakpointData(breakpoint); }
rememberRemovedBreakpoint
295,427
XBreakpointBase () { return myLastRemovedBreakpoint != null ? myLastRemovedBreakpoint.myBreakpoint : null; }
getLastRemovedBreakpoint
295,428
XBreakpoint () { // FIXME[inline-bp]: support multiple breakpoints here if (myLastRemovedBreakpoint != null) { XBreakpoint breakpoint = myLastRemovedBreakpoint.restore(); myLastRemovedBreakpoint = null; return breakpoint; } return null; }
restoreLastRemovedBreakpoint
295,429
boolean () { return myLastRemovedBreakpoint != null && myLastRemovedBreakpoint.isRestorable(); }
canRestoreLastRemovedBreakpoint
295,430
void (Collection<XBreakpointGroupingRule> rules) { }
createBreakpointsGroupingRules
295,431
void (final BreakpointsListener listener, Project project, Disposable disposable) { project.getMessageBus().connect(disposable).subscribe(XBreakpointListener.TOPIC, new MyXBreakpointListener(listener, XDebuggerManager.getInstance(project).getBreakpointManager())); }
addListener
295,432
int () { return 0; }
getPriority
295,433
GutterIconRenderer (Object breakpoint) { if (breakpoint instanceof XLineBreakpointImpl) { RangeHighlighter highlighter = ((XLineBreakpointImpl<?>)breakpoint).getHighlighter(); if (highlighter != null) { return highlighter.getGutterIconRenderer(); } } return null; }
getBreakpointGutterIconRenderer
295,434
void (final Project project) { }
onDialogClosed
295,435
void (Project project, Collection<? super BreakpointItem> items) { Arrays.stream(XDebuggerManager.getInstance(project).getBreakpointManager().getAllBreakpoints()) .map(XBreakpointItem::new) .forEach(items::add); }
provideBreakpointItems
295,436
void (@NotNull XBreakpoint<?> breakpoint) { myListener.breakpointsChanged(); }
breakpointAdded
295,437
void (@NotNull XBreakpoint<?> breakpoint) { myListener.breakpointsChanged(); }
breakpointRemoved
295,438
void (@NotNull XBreakpoint<?> breakpoint) { myListener.breakpointsChanged(); }
breakpointChanged
295,439
String () { return myFileUrl; }
getFileUrl
295,440
void (final String fileUrl) { myFileUrl = fileUrl; }
setFileUrl
295,441
int () { return myLine; }
getLine
295,442
void (final int line) { myLine = line; }
setLine
295,443
boolean () { return myTemporary; }
isTemporary
295,444
void (boolean temporary) { myTemporary = temporary; }
setTemporary
295,445
XExpression () { checkConverted(); // old versions may have empty expressions serialized if (StringUtil.isEmptyOrSpaces(myExpression)) { return null; } return new XExpressionImpl(XmlStringUtil.unescapeIllegalXmlChars(myExpression), Language.findLanguageByID(myLanguage), myCustomInfo, myMode); }
toXExpression
295,446
void (String oldUrl, String newUrl) { myBreakpoints.values().forEach(breakpoint -> { String url = breakpoint.getFileUrl(); if (FileUtil.startsWith(url, oldUrl)) { breakpoint.setFileUrl(newUrl + url.substring(oldUrl.length())); } }); }
fileUrlChanged
295,447
void (@NotNull VirtualFileEvent event) { removeBreakpoints(myBreakpoints.get(event.getFile().getUrl())); }
fileDeleted
295,448
void (@NotNull EditorFactoryEvent event) { getInlineBreakpointInlayManager().initializeInNewEditor(event.getEditor()); }
editorCreated
295,449
void (@NotNull RegistryValue value) { if (!XDebuggerUtil.areInlineBreakpointsEnabled()) { // Multiple breakpoints on the single line should be joined in this case. for (String fileUrl : myBreakpoints.keySet()) { var file = VirtualFileManager.getInstance().findFileByUrl(fileUrl); if (file == null) continue; var document = FileDocumentManager.getInstance().getDocument(file); if (document == null) continue; updateBreakpoints(document); } } getInlineBreakpointInlayManager().reinitializeAll(); }
afterValueChanged
295,450
void (@NotNull VirtualFile file, @NotNull Document document) { myBreakpoints.get(file.getUrl()).stream().filter(b -> b.getHighlighter() == null) .forEach(XLineBreakpointManager.this::queueBreakpointUpdate); }
fileContentLoaded
295,451
InlineBreakpointInlayManager () { return InlineBreakpointInlayManager.getInstance(myProject); }
getInlineBreakpointInlayManager
295,452
void (XLineBreakpointImpl breakpoint, final boolean initUI) { if (initUI) { updateBreakpointNow(breakpoint); } myBreakpoints.putValue(breakpoint.getFileUrl(), breakpoint); }
registerBreakpoint
295,453
void (final XLineBreakpointImpl breakpoint) { myBreakpoints.remove(breakpoint.getFileUrl(), breakpoint); }
unregisterBreakpoint
295,454
Collection<XLineBreakpointImpl> (Document document) { VirtualFile file = FileDocumentManager.getInstance().getFile(document); if (file != null) { return myBreakpoints.get(file.getUrl()); } return Collections.emptyList(); }
getDocumentBreakpoints
295,455
void (@NotNull Document document) { Collection<XLineBreakpointImpl> breakpoints = getDocumentBreakpoints(document); if (breakpoints.isEmpty() || ApplicationManager.getApplication().isUnitTestMode()) { return; } IntSet positions = new IntOpenHashSet(); List<XLineBreakpoint> toRemove = new SmartList<>(); for (XLineBreakpointImpl breakpoint : breakpoints) { breakpoint.updatePosition(); if (!breakpoint.isValid() || !positions.add(XDebuggerUtil.areInlineBreakpointsEnabled() ? breakpoint.getOffset() : breakpoint.getLine())) { toRemove.add(breakpoint); } } removeBreakpoints(toRemove); }
updateBreakpoints
295,456
void (@Nullable final Collection<? extends XLineBreakpoint> toRemove) { if (ContainerUtil.isEmpty(toRemove)) { return; } ((XBreakpointManagerImpl)XDebuggerManager.getInstance(myProject).getBreakpointManager()).removeBreakpoints(toRemove); }
removeBreakpoints
295,457
void (XLineBreakpointImpl breakpoint) { if (ApplicationManager.getApplication().isDispatchThread()) { updateBreakpointNow(breakpoint); } else { queueBreakpointUpdate(breakpoint); } }
breakpointChanged
295,458
void (final XBreakpoint<?> slave) { queueBreakpointUpdate(slave, null); }
queueBreakpointUpdate
295,459
void (final XBreakpoint<?> slave, @Nullable Runnable callOnUpdate) { if (slave instanceof XLineBreakpointImpl<?>) { queueBreakpointUpdate((XLineBreakpointImpl<?>)slave, callOnUpdate); } }
queueBreakpointUpdate
295,460
void (@NotNull final XLineBreakpointImpl<?> breakpoint) { queueBreakpointUpdate(breakpoint, null); myBreakpointsUpdateQueue.sendFlush(); }
updateBreakpointNow
295,461
void () { breakpoint.doUpdateUI(ObjectUtils.notNull(callOnUpdate, EmptyRunnable.INSTANCE)); }
run
295,462
void () { myBreakpointsUpdateQueue.queue(new Update("all breakpoints") { @Override public void run() { myBreakpoints.values().forEach(b -> b.doUpdateUI(EmptyRunnable.INSTANCE)); } }); // skip waiting myBreakpointsUpdateQueue.sendFlush(); }
queueAllBreakpointsUpdate
295,463
void () { myBreakpoints.values().forEach(b -> b.doUpdateUI(EmptyRunnable.INSTANCE)); }
run
295,464
void (@NotNull final DocumentEvent e) { final Document document = e.getDocument(); Collection<XLineBreakpointImpl> breakpoints = getDocumentBreakpoints(document); if (!breakpoints.isEmpty()) { myBreakpointsUpdateQueue.queue(new Update(document) { @Override public void run() { ApplicationManager.getApplication().invokeLater(() -> { updateBreakpoints(document); }); } }); if (XDebuggerUtil.areInlineBreakpointsEnabled()) { var file = FileDocumentManager.getInstance().getFile(document); if (file != null) { var inlineInlaysManager = getInlineBreakpointInlayManager(); var firstLine = document.getLineNumber(e.getOffset()); var lastLine = document.getLineNumber(e.getOffset() + e.getNewLength()); inlineInlaysManager.redrawLineQueued(document, firstLine); if (lastLine != firstLine) { inlineInlaysManager.redrawLineQueued(document, lastLine); } } } } }
documentChanged
295,465
void () { ApplicationManager.getApplication().invokeLater(() -> { updateBreakpoints(document); }); }
run
295,466
void (@NotNull EditorMouseEvent e) { myDragDetected = true; }
mouseDragged
295,467
void (@NotNull EditorMouseEvent e) { myDragDetected = false; }
mousePressed
295,468
void (@NotNull final EditorMouseEvent e) { final Editor editor = e.getEditor(); final MouseEvent mouseEvent = e.getMouseEvent(); if (mouseEvent.isPopupTrigger() || mouseEvent.isMetaDown() || mouseEvent.isControlDown() || mouseEvent.getButton() != MouseEvent.BUTTON1 || DiffUtil.isDiffEditor(editor) || !isInsideClickableGutterArea(e, editor) || ConsoleViewUtil.isConsoleViewEditor(editor) || !isFromMyProject(editor) || (editor.getSelectionModel().hasSelection() && myDragDetected) ) { return; } final Document document = editor.getDocument(); PsiDocumentManager.getInstance(myProject).commitDocument(document); final int line = EditorUtil.yToLogicalLineNoCustomRenderers(editor, mouseEvent.getY()); final VirtualFile file = FileDocumentManager.getInstance().getFile(document); if (line >= 0 && line < document.getLineCount() && file != null) { AnAction action = ActionManager.getInstance().getAction(IdeActions.ACTION_TOGGLE_LINE_BREAKPOINT); if (action == null) throw new AssertionError("'" + IdeActions.ACTION_TOGGLE_LINE_BREAKPOINT + "' action not found"); DataContext dataContext = SimpleDataContext.getSimpleContext(BREAKPOINT_LINE_KEY, line, DataManager.getInstance().getDataContext(mouseEvent.getComponent())); AnActionEvent event = AnActionEvent.createFromAnAction(action, mouseEvent, ActionPlaces.EDITOR_GUTTER, dataContext); ActionUtil.performActionDumbAwareWithCallbacks(action, event); } }
mouseClicked
295,469
boolean (EditorMouseEvent e, Editor editor) { if (ExperimentalUI.isNewUI() && e.getArea() == EditorMouseEventArea.LINE_NUMBERS_AREA) { return UISettings.getInstance().getShowBreakpointsOverLineNumbers(); } if (e.getArea() != EditorMouseEventArea.LINE_MARKERS_AREA && e.getArea() != EditorMouseEventArea.FOLDING_OUTLINE_AREA) { return false; } return e.getMouseEvent().getX() <= ((EditorEx)editor).getGutterComponentEx().getWhitespaceSeparatorOffset(); }
isInsideClickableGutterArea
295,470
boolean (@NotNull Editor editor) { if (myProject == editor.getProject()) { return true; } for (FileEditor fileEditor : FileEditorManager.getInstance(myProject).getAllEditors()) { if (fileEditor instanceof TextEditor && ((TextEditor)fileEditor).getEditor().equals(editor)) { return true; } } return false; }
isFromMyProject
295,471
void (@NotNull final XBreakpoint<?> slave, @NotNull final XBreakpoint<?> master) { queueBreakpointUpdate(slave); }
dependencySet
295,472
void (final XBreakpoint<?> breakpoint) { queueBreakpointUpdate(breakpoint); }
dependencyCleared
295,473
void (EditorColorsScheme scheme) { updateBreakpointsUI(); }
globalSchemeChange
295,474
String () { return myId; }
getId
295,475
String () { return myMasterBreakpointId; }
getMasterBreakpointId
295,476
boolean () { return myLeaveEnabled; }
isLeaveEnabled
295,477
void (final String id) { myId = id; }
setId
295,478
void (final String masterBreakpointId) { myMasterBreakpointId = masterBreakpointId; }
setMasterBreakpointId
295,479
void (final boolean leaveEnabled) { myLeaveEnabled = leaveEnabled; }
setLeaveEnabled
295,480
void (ColoredListCellRenderer renderer, Project project, boolean selected) { setupGenericRenderer(renderer, true); }
setupRenderer
295,481
void (ColoredTreeCellRenderer renderer, Project project, boolean selected) { setupGenericRenderer(renderer, false); }
setupRenderer
295,482
void (SimpleColoredComponent renderer, boolean plainView) { renderer.setIcon(getIcon()); final SimpleTextAttributes attributes = myBreakpoint.isEnabled() ? SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES : SimpleTextAttributes.GRAYED_ATTRIBUTES; renderer.append(StringUtil.notNullize(getDisplayText()), attributes); String description = getUserDescription(); if (!StringUtil.isEmpty(description)) { renderer.append(" (" + description + ")", SimpleTextAttributes.REGULAR_ITALIC_ATTRIBUTES); } }
setupGenericRenderer
295,483
String () { return XBreakpointUtil.getShortText(myBreakpoint); }
getDisplayText
295,484
String () { return ((XBreakpointBase<?, ?, ?>)myBreakpoint).getUserDescription(); }
getUserDescription
295,485
Icon () { return ((XBreakpointBase<?, ?, ?>)myBreakpoint).getIcon(); }
getIcon
295,486
String () { return getDisplayText() + " " + StringUtil.notNullize(getUserDescription()); }
speedSearchText
295,487
String () { return XBreakpointUtil.getDisplayText(myBreakpoint); }
footerText
295,488
void () { if (myPropertiesPanel != null) { myPropertiesPanel.saveProperties(); } }
saveState
295,489
void (DetailView panel, boolean editorOnly) { XBreakpointBase breakpoint = (XBreakpointBase)myBreakpoint; Project project = breakpoint.getProject(); //saveState(); if (myPropertiesPanel != null) { myPropertiesPanel.dispose(); myPropertiesPanel = null; } if (!editorOnly) { myPropertiesPanel = new XLightBreakpointPropertiesPanel(project, getManager(), breakpoint, true); panel.setPropertiesPanel(myPropertiesPanel.getMainPanel()); } panel.clearEditor(); ReadAction.nonBlocking(() -> myBreakpoint.getSourcePosition()) .finishOnUiThread(ModalityState.defaultModalityState(), sourcePosition -> { if (sourcePosition != null && sourcePosition.getFile().isValid()) { showInEditor(panel, sourcePosition.getFile(), sourcePosition.getLine()); } else { panel.clearEditor(); } }) .coalesceBy(panel) .submit(AppExecutorUtil.getAppExecutorService()); if (myPropertiesPanel != null) { myPropertiesPanel.setDetailView(panel); myPropertiesPanel.loadProperties(); myPropertiesPanel.getMainPanel().revalidate(); } }
doUpdateDetailView
295,490
void (DetailView panel, VirtualFile virtualFile, int line) { TextAttributes attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(DebuggerColors.BREAKPOINT_ATTRIBUTES); // null attributes to avoid the new highlighter for a line breakpoints DetailView.PreviewEditorState state = DetailView.PreviewEditorState.create(virtualFile, line, myBreakpoint instanceof XLineBreakpoint ? null : attributes); if (state.equals(panel.getEditorState())) { return; } panel.navigateInPreviewEditor(state); TextAttributes softerAttributes = attributes.clone(); Color backgroundColor = softerAttributes.getBackgroundColor(); if (backgroundColor != null) { softerAttributes.setBackgroundColor(ColorUtil.desaturate(backgroundColor, 10)); } Editor editor = panel.getEditor(); if (editor != null) { MarkupModel editorModel = editor.getMarkupModel(); MarkupModel documentModel = DocumentMarkupModel.forDocument(editor.getDocument(), editor.getProject(), false); for (RangeHighlighter highlighter : documentModel.getAllHighlighters()) { if (highlighter.getUserData(DebuggerColors.BREAKPOINT_HIGHLIGHTER_KEY) == Boolean.TRUE) { int line1 = editor.offsetToLogicalPosition(highlighter.getStartOffset()).line; if (line1 != line) { if (highlighter.getTargetArea() == HighlighterTargetArea.LINES_IN_RANGE) { editorModel.addLineHighlighter(line1, DebuggerColors.BREAKPOINT_HIGHLIGHTER_LAYER + 1, softerAttributes); } else { editorModel.addRangeHighlighter(highlighter.getStartOffset(), highlighter.getEndOffset(), DebuggerColors.BREAKPOINT_HIGHLIGHTER_LAYER + 1, softerAttributes, HighlighterTargetArea.EXACT_RANGE); } } } } } }
showInEditor
295,491
void (boolean requestFocus) { Navigatable navigatable = myBreakpoint.getNavigatable(); if (navigatable != null && navigatable.canNavigate()) { navigatable.navigate(requestFocus); } }
navigate
295,492
boolean () { Navigatable navigatable = myBreakpoint.getNavigatable(); return navigatable != null && navigatable.canNavigate(); }
canNavigate
295,493
boolean () { Navigatable navigatable = myBreakpoint.getNavigatable(); return navigatable != null && navigatable.canNavigateToSource(); }
canNavigateToSource
295,494
XBreakpointManagerImpl () { return ((XBreakpointBase<?, ?, ?>)myBreakpoint).getBreakpointManager(); }
getManager
295,495
boolean () { return !getManager().isDefaultBreakpoint(myBreakpoint); }
allowedToRemove
295,496
void (Project project) { XDebuggerUtil.getInstance().removeBreakpoint(project, myBreakpoint); }
removed
295,497
Object () { return myBreakpoint; }
getBreakpoint
295,498
boolean () { return myBreakpoint.isEnabled(); }
isEnabled
295,499
void (boolean state) { myBreakpoint.setEnabled(state); }
setEnabled