private void setColumnPreferredSize() {
for (int i = 0; i < getColumnCount(); i++) {
TableColumn column = getColumnModel().getColumn(i);
if (i == AbstractVcsLogTableModel.ROOT_COLUMN) { // thin stripe or nothing
int rootWidth = myUI.getColorManager().isMultipleRoots() ? ROOT_INDICATOR_WIDTH : 0;
// NB: all further instructions and their order are important, otherwise the minimum size
// which is less than 15 won't be applied
column.setMinWidth(rootWidth);
column.setMaxWidth(rootWidth);
column.setPreferredWidth(rootWidth);
} else if (i
== AbstractVcsLogTableModel
.COMMIT_COLUMN) { // let commit message occupy as much as possible
column.setPreferredWidth(Short.MAX_VALUE);
} else if (i
== AbstractVcsLogTableModel.AUTHOR_COLUMN) { // detect author with the longest name
// to avoid querying the last row (it would lead to full graph loading)
int maxRowsToCheck =
Math.min(MAX_ROWS_TO_CALC_WIDTH, getRowCount() - MAX_ROWS_TO_CALC_OFFSET);
if (maxRowsToCheck < 0) { // but if the log is small, check all of them
maxRowsToCheck = getRowCount();
}
int contentWidth = calcMaxContentColumnWidth(i, maxRowsToCheck);
column.setMinWidth(Math.min(contentWidth, MAX_DEFAULT_AUTHOR_COLUMN_WIDTH));
column.setWidth(column.getMinWidth());
} else if (i == AbstractVcsLogTableModel.DATE_COLUMN) { // all dates have nearly equal sizes
Font tableFont = UIManager.getFont("Table.font");
column.setMinWidth(
getFontMetrics(tableFont)
.stringWidth("mm" + DateFormatUtil.formatDateTime(new Date())));
column.setWidth(column.getMinWidth());
}
}
}
private boolean setColumnPreferredSize() {
boolean sizeCalculated = false;
Font tableFont = UIManager.getFont("Table.font");
for (int i = 0; i < getColumnCount(); i++) {
TableColumn column = getColumnModel().getColumn(i);
if (i == GraphTableModel.ROOT_COLUMN) { // thin stripe, or root name, or nothing
setRootColumnSize(column);
} else if (i
== GraphTableModel.COMMIT_COLUMN) { // let commit message occupy as much as possible
column.setPreferredWidth(Short.MAX_VALUE);
} else if (i == GraphTableModel.AUTHOR_COLUMN) { // detect author with the longest name
// to avoid querying the last row (it would lead to full graph loading)
int maxRowsToCheck =
Math.min(MAX_ROWS_TO_CALC_WIDTH, getRowCount() - MAX_ROWS_TO_CALC_OFFSET);
if (maxRowsToCheck < 0) { // but if the log is small, check all of them
maxRowsToCheck = getRowCount();
}
int maxWidth = 0;
for (int row = 0; row < maxRowsToCheck; row++) {
String value = getModel().getValueAt(row, i).toString();
maxWidth = Math.max(getFontMetrics(tableFont).stringWidth(value), maxWidth);
if (!value.isEmpty()) sizeCalculated = true;
}
column.setMinWidth(
Math.min(maxWidth + UIUtil.DEFAULT_HGAP, MAX_DEFAULT_AUTHOR_COLUMN_WIDTH));
column.setWidth(column.getMinWidth());
} else if (i == GraphTableModel.DATE_COLUMN) { // all dates have nearly equal sizes
column.setMinWidth(
getFontMetrics(tableFont)
.stringWidth("mm" + DateFormatUtil.formatDateTime(new Date())));
column.setWidth(column.getMinWidth());
}
}
return sizeCalculated;
}
@Override
public void mouseDragged(MouseEvent e) {
if (!myDragging) return;
MouseEvent event = SwingUtilities.convertMouseEvent(e.getComponent(), e, MyDivider.this);
final ToolWindowAnchor anchor = myInfo.getAnchor();
final Point point = event.getPoint();
final Container windowPane = InternalDecorator.this.getParent();
myLastPoint = SwingUtilities.convertPoint(MyDivider.this, point, windowPane);
myLastPoint.x = Math.min(Math.max(myLastPoint.x, 0), windowPane.getWidth());
myLastPoint.y = Math.min(Math.max(myLastPoint.y, 0), windowPane.getHeight());
final Rectangle bounds = InternalDecorator.this.getBounds();
if (anchor == ToolWindowAnchor.TOP) {
InternalDecorator.this.setBounds(0, 0, bounds.width, myLastPoint.y);
} else if (anchor == ToolWindowAnchor.LEFT) {
InternalDecorator.this.setBounds(0, 0, myLastPoint.x, bounds.height);
} else if (anchor == ToolWindowAnchor.BOTTOM) {
InternalDecorator.this.setBounds(
0, myLastPoint.y, bounds.width, windowPane.getHeight() - myLastPoint.y);
} else if (anchor == ToolWindowAnchor.RIGHT) {
InternalDecorator.this.setBounds(
myLastPoint.x, 0, windowPane.getWidth() - myLastPoint.x, bounds.height);
}
InternalDecorator.this.validate();
e.consume();
}
private static void duplicateHighlighters(
MarkupModel to, MarkupModel from, int offset, TextRange textRange) {
for (RangeHighlighter rangeHighlighter : from.getAllHighlighters()) {
if (!rangeHighlighter.isValid()) continue;
Object tooltip = rangeHighlighter.getErrorStripeTooltip();
HighlightInfo highlightInfo =
tooltip instanceof HighlightInfo ? (HighlightInfo) tooltip : null;
if (highlightInfo != null) {
if (highlightInfo.getSeverity() != HighlightSeverity.INFORMATION) continue;
if (highlightInfo.type.getAttributesKey() == EditorColors.IDENTIFIER_UNDER_CARET_ATTRIBUTES)
continue;
}
final int localOffset = textRange.getStartOffset();
final int start = Math.max(rangeHighlighter.getStartOffset(), localOffset) - localOffset;
final int end =
Math.min(rangeHighlighter.getEndOffset(), textRange.getEndOffset()) - localOffset;
if (start > end) continue;
final RangeHighlighter h =
to.addRangeHighlighter(
start + offset,
end + offset,
rangeHighlighter.getLayer(),
rangeHighlighter.getTextAttributes(),
rangeHighlighter.getTargetArea());
((RangeHighlighterEx) h)
.setAfterEndOfLine(((RangeHighlighterEx) rangeHighlighter).isAfterEndOfLine());
}
}
@Override
public void removeWatches(final List<? extends XDebuggerTreeNode> nodes) {
List<? extends WatchNode> children = myRootNode.getAllChildren();
int minIndex = Integer.MAX_VALUE;
List<XDebuggerTreeNode> toRemove = new ArrayList<XDebuggerTreeNode>();
if (children != null) {
for (XDebuggerTreeNode node : nodes) {
@SuppressWarnings("SuspiciousMethodCalls")
int index = children.indexOf(node);
if (index != -1) {
toRemove.add(node);
minIndex = Math.min(minIndex, index);
}
}
}
myRootNode.removeChildren(toRemove);
List<? extends WatchNode> newChildren = myRootNode.getAllChildren();
if (newChildren != null && !newChildren.isEmpty()) {
WatchNode node =
minIndex < newChildren.size()
? newChildren.get(minIndex)
: newChildren.get(newChildren.size() - 1);
TreeUtil.selectNode(myTreePanel.getTree(), node);
}
updateSessionData();
}
private void setSizeAndDimensions(
@NotNull JTable table,
@NotNull JBPopup popup,
@NotNull RelativePoint popupPosition,
@NotNull List<UsageNode> data) {
JComponent content = popup.getContent();
Window window = SwingUtilities.windowForComponent(content);
Dimension d = window.getSize();
int width = calcMaxWidth(table);
width = (int) Math.max(d.getWidth(), width);
Dimension headerSize = ((AbstractPopup) popup).getHeaderPreferredSize();
width = Math.max((int) headerSize.getWidth(), width);
width = Math.max(myWidth, width);
if (myWidth == -1) myWidth = width;
int newWidth = Math.max(width, d.width + width - myWidth);
myWidth = newWidth;
int rowsToShow = Math.min(30, data.size());
Dimension dimension = new Dimension(newWidth, table.getRowHeight() * rowsToShow);
Rectangle rectangle = fitToScreen(dimension, popupPosition, table);
dimension = rectangle.getSize();
Point location = window.getLocation();
if (!location.equals(rectangle.getLocation())) {
window.setLocation(rectangle.getLocation());
}
if (!data.isEmpty()) {
TableScrollingUtil.ensureSelectionExists(table);
}
table.setSize(dimension);
// table.setPreferredSize(dimension);
// table.setMaximumSize(dimension);
// table.setPreferredScrollableViewportSize(dimension);
Dimension footerSize = ((AbstractPopup) popup).getFooterPreferredSize();
int newHeight =
(int) (dimension.height + headerSize.getHeight() + footerSize.getHeight())
+ 4 /* invisible borders, margins etc*/;
Dimension newDim = new Dimension(dimension.width, newHeight);
window.setSize(newDim);
window.setMinimumSize(newDim);
window.setMaximumSize(newDim);
window.validate();
window.repaint();
table.revalidate();
table.repaint();
}
public static Image createImage(final JTable table, int column) {
final int height =
Math.max(20, Math.min(100, table.getSelectedRowCount() * table.getRowHeight()));
final int width = table.getColumnModel().getColumn(column).getWidth();
final BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = (Graphics2D) image.getGraphics();
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.7f));
drawSelection(table, column, g2, width);
return image;
}
public Dimension getPreferredSize() {
Dimension basicSize = super.getPreferredSize();
Icon icon = getIcon();
FontMetrics fm = getFontMetrics(getFont());
Rectangle viewRect = new Rectangle(0, 0, Short.MAX_VALUE, Short.MAX_VALUE);
Insets insets = getInsets();
int dx = insets.left + insets.right;
int dy = insets.top + insets.bottom;
Rectangle iconR = new Rectangle();
Rectangle textR = new Rectangle();
SwingUtilities.layoutCompoundLabel(
this,
fm,
getText(),
icon,
SwingConstants.CENTER,
horizontalTextAlignment(),
SwingConstants.CENTER,
horizontalTextPosition(),
viewRect,
iconR,
textR,
iconTextSpace());
int x1 = Math.min(iconR.x, textR.x);
int x2 = Math.max(iconR.x + iconR.width, textR.x + textR.width);
int y1 = Math.min(iconR.y, textR.y);
int y2 = Math.max(iconR.y + iconR.height, textR.y + textR.height);
Dimension rv = new Dimension(x2 - x1 + dx, y2 - y1 + dy);
rv.width += Math.max(basicSize.height - rv.height, 0);
rv.width = Math.max(rv.width, basicSize.width);
rv.height = Math.max(rv.height, basicSize.height);
return rv;
}
private void performRemove() {
final int selectedRow = myInjectionsTable.getSelectedRow();
if (selectedRow < 0) return;
final List<InjInfo> selected = getSelectedInjections();
for (InjInfo info : selected) {
if (info.bundled) continue;
info.cfgInfo.injectionInfos.remove(info);
}
myInjectionsTable.getListTableModel().setItems(getInjInfoList(myInfos));
final int index =
Math.min(myInjectionsTable.getListTableModel().getRowCount() - 1, selectedRow);
myInjectionsTable.getSelectionModel().setSelectionInterval(index, index);
TableUtil.scrollSelectionToVisible(myInjectionsTable);
updateCountLabel();
}
private void setRootColumnSize(TableColumn column) {
int rootWidth;
if (!myUI.isMultipleRoots()) {
rootWidth = 0;
} else if (!myUI.isShowRootNames()) {
rootWidth = ROOT_INDICATOR_WIDTH;
} else {
rootWidth = Math.min(calculateMaxRootWidth(), ROOT_NAME_MAX_WIDTH);
}
// NB: all further instructions and their order are important, otherwise the minimum size which
// is less than 15 won't be applied
column.setMinWidth(rootWidth);
column.setMaxWidth(rootWidth);
column.setPreferredWidth(rootWidth);
}
private void updateButtons() {
final int[] selectedRows = myEntryTable.getSelectedRows();
boolean removeButtonEnabled = true;
int minRow = myEntryTable.getRowCount() + 1;
int maxRow = -1;
for (final int selectedRow : selectedRows) {
minRow = Math.min(minRow, selectedRow);
maxRow = Math.max(maxRow, selectedRow);
final ClasspathTableItem<?> item = myModel.getItemAt(selectedRow);
if (!item.isRemovable()) {
removeButtonEnabled = false;
}
}
if (myRemoveButton != null) {
myRemoveButton.setEnabled(removeButtonEnabled && selectedRows.length > 0);
}
ClasspathTableItem<?> selectedItem =
selectedRows.length == 1 ? myModel.getItemAt(selectedRows[0]) : null;
myEditButton.setEnabled(selectedItem != null && selectedItem.isEditable());
}
private static void adjustRows(JTextArea area) {
area.setRows(Math.max(2, Math.min(3, StringUtil.countChars(area.getText(), '\n') + 1)));
}
@NotNull
@Override
public RelativePoint guessBestPopupLocation(@NotNull final JComponent component) {
Point popupMenuPoint = null;
final Rectangle visibleRect = component.getVisibleRect();
if (component instanceof JList) { // JList
JList list = (JList) component;
int firstVisibleIndex = list.getFirstVisibleIndex();
int lastVisibleIndex = list.getLastVisibleIndex();
int[] selectedIndices = list.getSelectedIndices();
for (int index : selectedIndices) {
if (firstVisibleIndex <= index && index <= lastVisibleIndex) {
Rectangle cellBounds = list.getCellBounds(index, index);
popupMenuPoint =
new Point(visibleRect.x + visibleRect.width / 4, cellBounds.y + cellBounds.height);
break;
}
}
} else if (component instanceof JTree) { // JTree
JTree tree = (JTree) component;
int[] selectionRows = tree.getSelectionRows();
if (selectionRows != null) {
Arrays.sort(selectionRows);
for (int i = 0; i < selectionRows.length; i++) {
int row = selectionRows[i];
Rectangle rowBounds = tree.getRowBounds(row);
if (visibleRect.contains(rowBounds)) {
popupMenuPoint = new Point(rowBounds.x + 2, rowBounds.y + rowBounds.height - 1);
break;
}
}
if (popupMenuPoint == null) { // All selected rows are out of visible rect
Point visibleCenter =
new Point(
visibleRect.x + visibleRect.width / 2, visibleRect.y + visibleRect.height / 2);
double minDistance = Double.POSITIVE_INFINITY;
int bestRow = -1;
Point rowCenter;
double distance;
for (int i = 0; i < selectionRows.length; i++) {
int row = selectionRows[i];
Rectangle rowBounds = tree.getRowBounds(row);
rowCenter =
new Point(rowBounds.x + rowBounds.width / 2, rowBounds.y + rowBounds.height / 2);
distance = visibleCenter.distance(rowCenter);
if (minDistance > distance) {
minDistance = distance;
bestRow = row;
}
}
if (bestRow != -1) {
Rectangle rowBounds = tree.getRowBounds(bestRow);
tree.scrollRectToVisible(
new Rectangle(
rowBounds.x,
rowBounds.y,
Math.min(visibleRect.width, rowBounds.width),
rowBounds.height));
popupMenuPoint = new Point(rowBounds.x + 2, rowBounds.y + rowBounds.height - 1);
}
}
}
} else if (component instanceof JTable) {
JTable table = (JTable) component;
int column = table.getColumnModel().getSelectionModel().getLeadSelectionIndex();
int row =
Math.max(
table.getSelectionModel().getLeadSelectionIndex(),
table.getSelectionModel().getAnchorSelectionIndex());
Rectangle rect = table.getCellRect(row, column, false);
if (!visibleRect.intersects(rect)) {
table.scrollRectToVisible(rect);
}
popupMenuPoint = new Point(rect.x, rect.y + rect.height);
} else if (component instanceof PopupOwner) {
popupMenuPoint = ((PopupOwner) component).getBestPopupPosition();
}
if (popupMenuPoint == null) {
popupMenuPoint =
new Point(visibleRect.x + visibleRect.width / 2, visibleRect.y + visibleRect.height / 2);
}
return new RelativePoint(component, popupMenuPoint);
}
protected String addTextRangeToHistory(
TextRange textRange, final EditorEx consoleEditor, boolean preserveMarkup) {
final Document history = myHistoryViewer.getDocument();
final MarkupModel markupModel = DocumentMarkupModel.forDocument(history, myProject, true);
if (myPrompt != null) {
appendToHistoryDocument(history, myPrompt);
}
markupModel.addRangeHighlighter(
history.getTextLength() - StringUtil.length(myPrompt),
history.getTextLength(),
HighlighterLayer.SYNTAX,
ConsoleViewContentType.USER_INPUT.getAttributes(),
HighlighterTargetArea.EXACT_RANGE);
final int localStartOffset = textRange.getStartOffset();
String text;
EditorHighlighter highlighter;
if (consoleEditor instanceof EditorWindow) {
EditorWindow editorWindow = (EditorWindow) consoleEditor;
EditorColorsScheme scheme = EditorColorsManager.getInstance().getGlobalScheme();
PsiFile file = editorWindow.getInjectedFile();
final VirtualFile virtualFile = file.getVirtualFile();
assert virtualFile != null;
highlighter = HighlighterFactory.createHighlighter(virtualFile, scheme, getProject());
String fullText = InjectedLanguageUtil.getUnescapedText(file, null, null);
highlighter.setText(fullText);
text = textRange.substring(fullText);
} else {
text = consoleEditor.getDocument().getText(textRange);
highlighter = consoleEditor.getHighlighter();
}
// offset can be changed after text trimming after insert due to buffer constraints
appendToHistoryDocument(history, text);
int offset = history.getTextLength() - text.length();
final HighlighterIterator iterator = highlighter.createIterator(localStartOffset);
final int localEndOffset = textRange.getEndOffset();
while (!iterator.atEnd()) {
final int itStart = iterator.getStart();
if (itStart > localEndOffset) break;
final int itEnd = iterator.getEnd();
if (itEnd >= localStartOffset) {
final int start = Math.max(itStart, localStartOffset) - localStartOffset + offset;
final int end = Math.min(itEnd, localEndOffset) - localStartOffset + offset;
markupModel.addRangeHighlighter(
start,
end,
HighlighterLayer.SYNTAX,
iterator.getTextAttributes(),
HighlighterTargetArea.EXACT_RANGE);
}
iterator.advance();
}
if (preserveMarkup) {
duplicateHighlighters(
markupModel,
DocumentMarkupModel.forDocument(consoleEditor.getDocument(), myProject, true),
offset,
textRange);
duplicateHighlighters(markupModel, consoleEditor.getMarkupModel(), offset, textRange);
}
if (!text.endsWith("\n")) {
appendToHistoryDocument(history, "\n");
}
return text;
}
/**
* Generates a comment if possible.
*
* <p>It's assumed that this method {@link PsiDocumentManager#commitDocument(Document) syncs} all
* PSI-document changes during the processing.
*
* @param anchor target element for which a comment should be generated
* @param editor target editor
* @param commenter commenter to use
* @param project current project
*/
private static void generateComment(
@NotNull PsiElement anchor,
@NotNull Editor editor,
@NotNull CodeDocumentationProvider documentationProvider,
@NotNull CodeDocumentationAwareCommenter commenter,
@NotNull Project project) {
Document document = editor.getDocument();
int commentStartOffset = anchor.getTextRange().getStartOffset();
int lineStartOffset = document.getLineStartOffset(document.getLineNumber(commentStartOffset));
if (lineStartOffset > 0 && lineStartOffset < commentStartOffset) {
// Example:
// void test1() {
// }
// void test2() {
// <offset>
// }
// We want to insert the comment at the start of the line where 'test2()' is declared.
int nonWhiteSpaceOffset =
CharArrayUtil.shiftBackward(document.getCharsSequence(), commentStartOffset - 1, " \t");
commentStartOffset = Math.max(nonWhiteSpaceOffset, lineStartOffset);
}
int commentBodyRelativeOffset = 0;
int caretOffsetToSet = -1;
StringBuilder buffer = new StringBuilder();
String commentPrefix = commenter.getDocumentationCommentPrefix();
if (commentPrefix != null) {
buffer.append(commentPrefix).append("\n");
commentBodyRelativeOffset += commentPrefix.length() + 1;
}
String linePrefix = commenter.getDocumentationCommentLinePrefix();
if (linePrefix != null) {
buffer.append(linePrefix);
commentBodyRelativeOffset += linePrefix.length();
caretOffsetToSet = commentStartOffset + commentBodyRelativeOffset;
}
buffer.append("\n");
commentBodyRelativeOffset++;
String commentSuffix = commenter.getDocumentationCommentSuffix();
if (commentSuffix != null) {
buffer.append(commentSuffix).append("\n");
}
if (buffer.length() <= 0) {
return;
}
document.insertString(commentStartOffset, buffer);
PsiDocumentManager docManager = PsiDocumentManager.getInstance(project);
docManager.commitDocument(document);
Pair<PsiElement, PsiComment> pair = documentationProvider.parseContext(anchor);
if (pair == null || pair.second == null) {
return;
}
String stub = documentationProvider.generateDocumentationContentStub(pair.second);
CaretModel caretModel = editor.getCaretModel();
if (stub != null) {
int insertionOffset = commentStartOffset + commentBodyRelativeOffset;
// if (CodeStyleSettingsManager.getSettings(project).JD_ADD_BLANK_AFTER_DESCRIPTION) {
// buffer.setLength(0);
// if (linePrefix != null) {
// buffer.append(linePrefix);
// }
// buffer.append("\n");
// buffer.append(stub);
// stub = buffer.toString();
// }
document.insertString(insertionOffset, stub);
docManager.commitDocument(document);
pair = documentationProvider.parseContext(anchor);
}
if (caretOffsetToSet >= 0) {
caretModel.moveToOffset(caretOffsetToSet);
}
if (pair == null || pair.second == null) {
return;
}
int start = Math.min(calcStartReformatOffset(pair.first), calcStartReformatOffset(pair.second));
int end = pair.second.getTextRange().getEndOffset();
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(project);
codeStyleManager.reformatText(anchor.getContainingFile(), start, end);
int caretOffset = caretModel.getOffset();
if (caretOffset > 0 && caretOffset <= document.getTextLength()) {
char c = document.getCharsSequence().charAt(caretOffset - 1);
if (!StringUtil.isWhiteSpace(c)) {
document.insertString(caretOffset, " ");
caretModel.moveToOffset(caretOffset + 1);
}
}
}
private void paintBackgroundAndFoldingLine(Graphics g, Rectangle clipBounds) {
Graphics2D g2d = (Graphics2D) g;
g.setColor(getBackground());
g.fillRect(
clipBounds.x,
clipBounds.y,
Math.min(clipBounds.width, myFoldingLineX - clipBounds.x),
clipBounds.height);
g.setColor(getEditorComponent().getBackground());
g.fillRect(
Math.max(clipBounds.x, myFoldingLineX),
clipBounds.y,
clipBounds.width - Math.max(0, myFoldingLineX - clipBounds.x),
clipBounds.height);
// same as in EditorComponent.paint() method
EditorCell deepestCell = myEditorComponent.getDeepestSelectedCell();
if (deepestCell instanceof EditorCell_Label) {
int selectedCellY = deepestCell.getY();
int selectedCellHeight =
deepestCell.getHeight() - deepestCell.getTopInset() - deepestCell.getBottomInset();
if (g.hitClip(clipBounds.x, selectedCellY, clipBounds.width, selectedCellHeight)) {
g.setColor(EditorComponent.CARET_ROW_COLOR);
g.fillRect(clipBounds.x, selectedCellY, clipBounds.width, selectedCellHeight);
// Drawing folding line
UIUtil.drawVDottedLine(
g2d,
myFoldingLineX,
clipBounds.y,
selectedCellY,
getBackground(),
EditorColorsManager.getInstance()
.getGlobalScheme()
.getColor(EditorColors.TEARLINE_COLOR));
UIUtil.drawVDottedLine(
g2d,
myFoldingLineX,
selectedCellY,
selectedCellY + selectedCellHeight,
EditorComponent.CARET_ROW_COLOR,
EditorColorsManager.getInstance()
.getGlobalScheme()
.getColor(EditorColors.TEARLINE_COLOR));
UIUtil.drawVDottedLine(
g2d,
myFoldingLineX,
selectedCellY + selectedCellHeight,
clipBounds.y + clipBounds.height,
getBackground(),
EditorColorsManager.getInstance()
.getGlobalScheme()
.getColor(EditorColors.TEARLINE_COLOR));
return;
}
}
// Drawing folding line
// COLORS: Remove hardcoded color
UIUtil.drawVDottedLine(
g2d,
myFoldingLineX,
clipBounds.y,
clipBounds.y + clipBounds.height,
getBackground(),
Color.gray);
}
public SizedIcon(int maxWidth, int maxHeight, Image image) {
myWidth = Math.min(maxWidth, image.getWidth(null));
myHeight = Math.min(maxHeight, image.getHeight(null));
myImage = image;
}
