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());
}
}
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 static int adjust(int expectedOnMyMachine, long thisTiming, long ethanolTiming) {
// most of our algorithms are quadratic. sad but true.
double speed = 1.0 * thisTiming / ethanolTiming;
double delta = speed < 1 ? 0.9 + Math.pow(speed - 0.7, 2) : 0.45 + Math.pow(speed - 0.25, 2);
expectedOnMyMachine *= delta;
return expectedOnMyMachine;
}
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();
}
@Override
public void layoutContainer(final Container parent) {
final int componentCount = parent.getComponentCount();
if (componentCount == 0) return;
final EditorEx history = myHistoryViewer;
final EditorEx editor = componentCount == 2 ? myConsoleEditor : null;
if (editor == null) {
parent.getComponent(0).setBounds(parent.getBounds());
return;
}
final Dimension panelSize = parent.getSize();
if (panelSize.getHeight() <= 0) return;
final Dimension historySize = history.getContentSize();
final Dimension editorSize = editor.getContentSize();
final Dimension newEditorSize = new Dimension();
// deal with width
final int width = Math.max(editorSize.width, historySize.width);
newEditorSize.width = width + editor.getScrollPane().getHorizontalScrollBar().getHeight();
history.getSoftWrapModel().forceAdditionalColumnsUsage();
editor
.getSettings()
.setAdditionalColumnsCount(
2 + (width - editorSize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, editor));
history
.getSettings()
.setAdditionalColumnsCount(
2 + (width - historySize.width) / EditorUtil.getSpaceWidth(Font.PLAIN, history));
// deal with height
if (historySize.width == 0) historySize.height = 0;
final int minHistorySize =
historySize.height > 0
? 2 * history.getLineHeight() + (myShowSeparatorLine ? SEPARATOR_THICKNESS : 0)
: 0;
final int minEditorSize = editor.isViewer() ? 0 : editor.getLineHeight();
final int editorPreferred =
editor.isViewer() ? 0 : Math.max(minEditorSize, editorSize.height);
final int historyPreferred = Math.max(minHistorySize, historySize.height);
if (panelSize.height < minEditorSize) {
newEditorSize.height = panelSize.height;
} else if (panelSize.height < editorPreferred) {
newEditorSize.height = panelSize.height - minHistorySize;
} else if (panelSize.height < editorPreferred + historyPreferred) {
newEditorSize.height = editorPreferred;
} else {
newEditorSize.height = editorPreferred == 0 ? 0 : panelSize.height - historyPreferred;
}
final Dimension newHistorySize =
new Dimension(width, panelSize.height - newEditorSize.height);
// apply
editor
.getComponent()
.setBounds(0, newHistorySize.height, panelSize.width, newEditorSize.height);
myForceScrollToEnd.compareAndSet(false, shouldScrollHistoryToEnd());
history.getComponent().setBounds(0, 0, panelSize.width, newHistorySize.height);
}
private static int getScrollAmount(Component c, MouseWheelEvent me, JScrollBar scrollBar) {
final int scrollBarWidth = scrollBar.getWidth();
final int ratio =
Registry.is("ide.smart.horizontal.scrolling") && scrollBarWidth > 0
? Math.max((int) Math.pow(c.getWidth() / scrollBarWidth, 2), 10)
: 10; // do annoying scrolling faster if smart scrolling is on
return me.getUnitsToScroll() * scrollBar.getUnitIncrement() * ratio;
}
private void recalculateFoldingAreaWidth() {
myLeftFoldingAreaWidth =
myRightToLeft ? MIN_RIGHT_FOLDING_AREA_WIDTH : MIN_LEFT_FOLDING_AREA_WIDTH;
myRightFoldingAreaWidth =
myRightToLeft ? MIN_LEFT_FOLDING_AREA_WIDTH : MIN_RIGHT_FOLDING_AREA_WIDTH;
// Layouting painters
for (AbstractFoldingAreaPainter painter : myFoldingAreaPainters) {
myLeftFoldingAreaWidth = Math.max(myLeftFoldingAreaWidth, painter.getLeftAreaWidth());
myRightFoldingAreaWidth = Math.max(myRightFoldingAreaWidth, painter.getRightAreaWidth());
}
}
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 void setImage(BufferedImage image, String format) {
ImageDocument document = imageComponent.getDocument();
BufferedImage previousImage = document.getValue();
document.setValue(image);
if (image == null) return;
document.setFormat(format);
ImageZoomModel zoomModel = getZoomModel();
if (previousImage == null || !zoomModel.isZoomLevelChanged()) {
// Set smart zooming behaviour on open
Options options = OptionsManager.getInstance().getOptions();
ZoomOptions zoomOptions = options.getEditorOptions().getZoomOptions();
// Open as actual size
zoomModel.setZoomFactor(1.0d);
if (zoomOptions.isSmartZooming()) {
Dimension prefferedSize = zoomOptions.getPrefferedSize();
if (prefferedSize.width > image.getWidth() && prefferedSize.height > image.getHeight()) {
// Resize to preffered size
// Calculate zoom factor
double factor =
(prefferedSize.getWidth() / (double) image.getWidth()
+ prefferedSize.getHeight() / (double) image.getHeight())
/ 2.0d;
zoomModel.setZoomFactor(Math.ceil(factor));
}
}
}
}
@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();
}
public boolean canZoomOut() {
double factor = getZoomFactor();
double minFactor = getMinimumZoomFactor();
double stepSize = (1.0 - minFactor) / MICRO_ZOOM_LIMIT;
double step = Math.ceil((1.0 - factor) / stepSize);
return step < MICRO_ZOOM_LIMIT;
}
private int calculateMaxRootWidth() {
int width = 0;
for (VirtualFile file : myLogDataHolder.getRoots()) {
Font tableFont = UIManager.getFont("Table.font");
width = Math.max(getFontMetrics(tableFont).stringWidth(file.getName() + " "), width);
}
return width;
}
private int calcMaxContentColumnWidth(int columnIndex, int maxRowsToCheck) {
int maxWidth = 0;
for (int row = 0; row < maxRowsToCheck; row++) {
TableCellRenderer renderer = getCellRenderer(row, columnIndex);
Component comp = prepareRenderer(renderer, row, columnIndex);
maxWidth = Math.max(comp.getPreferredSize().width, maxWidth);
}
return maxWidth + UIUtil.DEFAULT_HGAP;
}
private void scrollToRow(Integer row, Integer delta) {
Rectangle startRect = myTable.getCellRect(row, 0, true);
myTable.scrollRectToVisible(
new Rectangle(
startRect.x,
Math.max(startRect.y - delta, 0),
startRect.width,
myTable.getVisibleRect().height));
}
private void recalculateTextColumnWidth() {
int initialOffset = getTextColumnOffset();
int offset = initialOffset;
for (AbstractLeftColumn column : myLeftColumns) {
column.setX(offset);
column.relayout();
offset += column.getWidth();
}
myTextColumnWidth = Math.max(MIN_LEFT_TEXT_WIDTH, offset - initialOffset);
}
private void recalculateIconRenderersWidth() {
myLineToRenderersMap.clear();
for (EditorMessageIconRenderer renderer : myIconRenderers) {
int yCoordinate = getIconCoordinate(renderer);
if (yCoordinate < 0) {
continue;
}
List<IconRendererLayoutConstraint> renderersForLine = myLineToRenderersMap.get(yCoordinate);
if (renderersForLine == null) {
renderersForLine = new SortedList(myIconRenderersComparator);
myLineToRenderersMap.put(yCoordinate, renderersForLine);
}
renderersForLine.add(new IconRendererLayoutConstraint(renderer));
}
myIconRenderersWidth = MIN_ICON_RENDERERS_WIDTH;
myMaxIconHeight = 0;
int[] sortedYCoordinates = myLineToRenderersMap.keys();
Arrays.sort(sortedYCoordinates);
int initialOffset = getIconRenderersOffset();
for (int y : sortedYCoordinates) {
List<IconRendererLayoutConstraint> row = myLineToRenderersMap.get(y);
assert row.size() != 0;
int maxIconHeight = 0;
for (IconRendererLayoutConstraint rendererConstraint : row) {
maxIconHeight =
Math.max(maxIconHeight, rendererConstraint.getIconRenderer().getIcon().getIconHeight());
}
myMaxIconHeight = Math.max(myMaxIconHeight, maxIconHeight);
int offset = initialOffset + LEFT_GAP;
for (Iterator<IconRendererLayoutConstraint> it = row.iterator(); it.hasNext(); ) {
IconRendererLayoutConstraint rendererConstraint = it.next();
rendererConstraint.setX(offset);
offset += rendererConstraint.getIconRenderer().getIcon().getIconWidth();
if (it.hasNext()) {
offset += GAP_BETWEEN_ICONS;
}
}
myIconRenderersWidth = Math.max(myIconRenderersWidth, offset - initialOffset);
}
}
private static Rectangle fitToScreen(
@NotNull Dimension newDim, @NotNull RelativePoint popupPosition, JTable table) {
Rectangle rectangle = new Rectangle(popupPosition.getScreenPoint(), newDim);
ScreenUtil.fitToScreen(rectangle);
if (rectangle.getHeight() != newDim.getHeight()) {
int newHeight = (int) rectangle.getHeight();
int roundedHeight = newHeight - newHeight % table.getRowHeight();
rectangle.setSize((int) rectangle.getWidth(), Math.max(roundedHeight, table.getRowHeight()));
}
return rectangle;
}
private static int columnMaxWidth(@NotNull JTable table, int col) {
TableColumn column = table.getColumnModel().getColumn(col);
int width = 0;
for (int row = 0; row < table.getRowCount(); row++) {
Component component = table.prepareRenderer(column.getCellRenderer(), row, col);
int rendererWidth = component.getPreferredSize().width;
width = Math.max(width, rendererWidth + table.getIntercellSpacing().width);
}
return width;
}
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 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();
}
public void zoomOut() {
double factor = getZoomFactor();
if (factor > 1.0d) {
// Macro
setZoomFactor(factor / 2.0d);
} else {
// Micro
double minFactor = getMinimumZoomFactor();
double stepSize = (1.0d - minFactor) / MICRO_ZOOM_LIMIT;
int step = (int) Math.ceil((1.0d - factor) / stepSize);
setZoomFactor(1.0d - stepSize * (step + 1));
}
myZoomLevelChanged = true;
}
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);
}
public static void assertTiming(final String message, final long expectedMs, final long actual) {
if (COVERAGE_ENABLED_BUILD) return;
final long expectedOnMyMachine =
Math.max(1, expectedMs * Timings.MACHINE_TIMING / Timings.ETALON_TIMING);
// Allow 10% more in case of test machine is busy.
String logMessage = message;
if (actual > expectedOnMyMachine) {
int percentage = (int) (100.0 * (actual - expectedOnMyMachine) / expectedOnMyMachine);
logMessage += ". Operation took " + percentage + "% longer than expected";
}
logMessage +=
". Expected on my machine: "
+ expectedOnMyMachine
+ "."
+ " Actual: "
+ actual
+ "."
+ " Expected on Standard machine: "
+ expectedMs
+ ";"
+ " Actual on Standard: "
+ actual * Timings.ETALON_TIMING / Timings.MACHINE_TIMING
+ ";"
+ " Timings: CPU="
+ Timings.CPU_TIMING
+ ", I/O="
+ Timings.IO_TIMING
+ "."
+ " ("
+ (int) (Timings.MACHINE_TIMING * 1.0 / Timings.ETALON_TIMING * 100)
+ "% of the Standard)"
+ ".";
final double acceptableChangeFactor = 1.1;
if (actual < expectedOnMyMachine) {
System.out.println(logMessage);
TeamCityLogger.info(logMessage);
} else if (actual < expectedOnMyMachine * acceptableChangeFactor) {
TeamCityLogger.warning(logMessage, null);
} else {
// throw AssertionFailedError to try one more time
throw new AssertionFailedError(logMessage);
}
}
@Override
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
String text;
Color color;
if (value instanceof VirtualFile) {
VirtualFile root = (VirtualFile) value;
int readableRow =
ScrollingUtil.getReadableRow(table, Math.round(myUi.getTable().getRowHeight() * 0.5f));
if (row < readableRow) {
text = "";
} else if (row == 0
|| !value.equals(table.getModel().getValueAt(row - 1, column))
|| readableRow == row) {
text = root.getName();
} else {
text = "";
}
color = getRootBackgroundColor(root, myUi.getColorManager());
} else {
text = null;
color = UIUtil.getTableBackground(isSelected);
}
myColor = color;
Color background =
((VcsLogGraphTable) table)
.getStyle(row, column, text, hasFocus, isSelected)
.getBackground();
assert background != null;
myBorderColor = background;
setForeground(UIUtil.getTableForeground(false));
if (myUi.isShowRootNames()) {
setText(text);
isNarrow = false;
} else {
setText("");
isNarrow = true;
}
return this;
}
private static int calcMaxWidth(JTable table) {
int colsNum = table.getColumnModel().getColumnCount();
int totalWidth = 0;
for (int col = 0; col < colsNum - 1; col++) {
TableColumn column = table.getColumnModel().getColumn(col);
int preferred = column.getPreferredWidth();
int width = Math.max(preferred, columnMaxWidth(table, col));
totalWidth += width;
column.setMinWidth(width);
column.setMaxWidth(width);
column.setWidth(width);
column.setPreferredWidth(width);
}
totalWidth += columnMaxWidth(table, colsNum - 1);
return totalWidth;
}
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 int moveRow(final int row, final int increment) {
int newIndex = Math.abs(row + increment) % myModel.getRowCount();
myModel.exchangeRows(row, newIndex);
return newIndex;
}
private int moveRow(final int row, final int increment) {
int newIndex = Math.abs(row + increment) % myModel.getRowCount();
final ClasspathTableItem<?> item = myModel.removeDataRow(row);
myModel.addItemAt(item, newIndex);
return newIndex;
}