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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.