public Component getTreeCellRendererComponent(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
installMouseHandler();
TreePath path = getPathForRow(row);
state = UNCHECKABLE;
if (path != null) {
if (isChecked(path)) {
state = FULLCHECKED;
} else if (isPartiallyChecked(path)) {
state = PARTIALCHECKED;
} else if (isSelectable(path)) {
state = UNCHECKED;
}
}
checkBox.setSelected(state == FULLCHECKED);
checkBox.getModel().setArmed(mouseRow == row && pressedRow == row && mouseInCheck);
checkBox.getModel().setPressed(pressedRow == row && mouseInCheck);
checkBox.getModel().setRollover(mouseRow == row && mouseInCheck);
Component c =
renderer.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
checkBox.setForeground(c.getForeground());
if (c instanceof JLabel) {
JLabel label = (JLabel) c;
// Augment the icon to include the checkbox
setAppropriateLabelAndIcon(value, label, selected, expanded);
}
return c;
}
/**
* base interaction with list: renderer uses list's unselected colors
*
* <p>currently, this test fails because the assumptions are wrong! Core renderer behaves slightly
* unexpected.
*/
public void testTreeRendererExtColors() {
// prepare standard
Component coreComponent =
coreTreeRenderer.getTreeCellRendererComponent(tree, null, false, false, false, 0, false);
// sanity: known standard behaviour
assertNull(coreComponent.getBackground());
// assertNull(coreComponent.getForeground());
assertNull(tree.getForeground());
Color uiForeground = UIManager.getColor("Tree.textForeground");
assertEquals(uiForeground, coreComponent.getForeground());
// prepare extended
Component xComponent =
xTreeRenderer.getTreeCellRendererComponent(tree, null, false, false, false, 0, false);
// assert behaviour same as standard
// assertEquals(coreComponent.getBackground(), xComponent.getBackground());
assertEquals(coreComponent.getForeground(), xComponent.getForeground());
}
/**
* base interaction with list: renderer uses list's unselected custom colors.
*
* <p>currently, this test fails because the assumptions are wrong! Core renderer behaves slightly
* unexpected.
*/
public void testTreeRendererExtTreeColors() {
Color background = Color.MAGENTA;
Color foreground = Color.YELLOW;
tree.setBackground(background);
tree.setForeground(foreground);
coreTreeRenderer.setBackgroundNonSelectionColor(background);
coreTreeRenderer.setTextNonSelectionColor(foreground);
// prepare standard
Component coreComponent =
coreTreeRenderer.getTreeCellRendererComponent(tree, null, false, false, false, 0, false);
// sanity: known standard behaviour
// background is manually painted
assertEquals(background, coreComponent.getBackground());
assertEquals(tree.getForeground(), coreComponent.getForeground());
// prepare extended
Component xComponent =
xTreeRenderer.getTreeCellRendererComponent(tree, null, false, false, false, 0, false);
// assert behaviour same as standard
assertEquals(background, xComponent.getBackground());
assertEquals(foreground, xComponent.getForeground());
}
private VcsLogHighlighter.VcsCommitStyle getStyle(
int row, int column, String text, boolean hasFocus, final boolean selected) {
Component dummyRendererComponent =
myDummyRenderer.getTableCellRendererComponent(this, text, selected, hasFocus, row, column);
VisibleGraph<Integer> visibleGraph = getVisibleGraph();
if (row < 0 || row >= visibleGraph.getVisibleCommitCount()) {
LOG.error(
"Visible graph has "
+ visibleGraph.getVisibleCommitCount()
+ " commits, yet we want row "
+ row);
return VcsCommitStyleFactory.createStyle(
dummyRendererComponent.getForeground(),
dummyRendererComponent.getBackground(),
VcsLogHighlighter.TextStyle.NORMAL);
}
final RowInfo<Integer> rowInfo = visibleGraph.getRowInfo(row);
VcsLogHighlighter.VcsCommitStyle defaultStyle =
VcsCommitStyleFactory.createStyle(
rowInfo.getRowType() == RowType.UNMATCHED
? JBColor.GRAY
: dummyRendererComponent.getForeground(),
dummyRendererComponent.getBackground(),
VcsLogHighlighter.TextStyle.NORMAL);
List<VcsLogHighlighter.VcsCommitStyle> styles =
ContainerUtil.map(
myHighlighters,
new Function<VcsLogHighlighter, VcsLogHighlighter.VcsCommitStyle>() {
@Override
public VcsLogHighlighter.VcsCommitStyle fun(VcsLogHighlighter highlighter) {
return highlighter.getStyle(rowInfo.getCommit(), selected);
}
});
return VcsCommitStyleFactory.combine(ContainerUtil.append(styles, defaultStyle));
}
public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
float size = this.stroke.getLineWidth();
if (size > 0.0f) {
g = g.create();
if (g instanceof Graphics2D) {
Graphics2D g2d = (Graphics2D) g;
g2d.setStroke(this.stroke);
g2d.setPaint(color != null ? color : c == null ? null : c.getForeground());
g2d.draw(new Rectangle2D.Float(x + size / 2, y + size / 2, width - size, height - size));
}
g.dispose();
}
}
public void paintIcon(Component c, Graphics g, int x, int y) {
Color color = c.getForeground();
Color saveColor = g.getColor();
CRectangle bg = new CRectangle(x, y, width, height);
bg.setFilled(false);
bg.paint(g);
polyline
.setReferencePoint(0, 0)
.translateTo(x + sideStartingPoint / 2 + 1, y + sideStartingPoint / 2 + 1);
polyline.setOutlinePaint(color).setAntialiased(true);
polyline.paint(g);
startPoint.paint(g);
g.setColor(saveColor);
}
@Override
protected void applyForeground(Component renderer, ComponentAdapter adapter) {
if (!adapter.isSelected()) {
Object colorMemory =
((JComponent) renderer).getClientProperty("rendererColorMemory.foreground");
if (colorMemory instanceof ColorMemory) {
renderer.setForeground(((ColorMemory) colorMemory).color);
} else {
((JComponent) renderer)
.putClientProperty(
"rendererColorMemory.foreground", new ColorMemory(renderer.getForeground()));
}
}
}
public static BufferedImage componentToImage(Component component, Rectangle region) {
BufferedImage img =
new BufferedImage(
component.getWidth(), component.getHeight(), BufferedImage.TYPE_INT_ARGB_PRE);
Graphics g = img.getGraphics();
g.setColor(component.getForeground());
g.setFont(component.getFont());
component.paintAll(g);
g.dispose();
if (region == null) {
return img;
}
return img.getSubimage(region.x, region.y, region.width, region.height);
}
/**
* Draw the icon at the specified location. Icon implementations may use the Component argument to
* get properties useful for painting, e.g. the foreground or background color.
*/
public void paintIcon(Component c, Graphics g, int x, int y) {
Graphics2D g2 = (Graphics2D) g;
Toolkit tk = Toolkit.getDefaultToolkit();
Map<?, ?> map = (Map<?, ?>) (tk.getDesktopProperty("awt.font.desktophints"));
if (map != null) {
g2.addRenderingHints(map);
}
// We don't insist that it be on the same Component
g2.setColor(c.getForeground());
g2.setFont(c.getFont());
if (fRotation == ROTATE_NONE) {
int yPos = y + fCharHeight;
for (int i = 0; i < fCharStrings.length; i++) {
// Special rules for Japanese - "half-height" characters (like ya, yu, yo in combinations)
// should draw in the top-right quadrant when drawn vertically
// - they draw in the bottom-left normally
int tweak;
switch (fPosition[i]) {
case POSITION_NORMAL:
// Roman fonts should be centered. Japanese fonts are always monospaced.
g2.drawString(fCharStrings[i], x + ((fWidth - fCharWidths[i]) / 2), yPos);
break;
case POSITION_TOP_RIGHT:
tweak = fCharHeight / 3; // Should be 2, but they aren't actually half-height
g2.drawString(fCharStrings[i], x + (tweak / 2), yPos - tweak);
break;
case POSITION_FAR_TOP_RIGHT:
tweak = fCharHeight - fCharHeight / 3;
g2.drawString(fCharStrings[i], x + (tweak / 2), yPos - tweak);
break;
default:
throw new Error();
}
yPos += fCharHeight;
}
} else if (fRotation == ROTATE_LEFT) {
g2.translate(x + fWidth, y + fHeight);
g2.rotate(-NINETY_DEGREES);
g2.drawString(fLabel, K_BUFFER_SPACE, -fDescent);
g2.rotate(NINETY_DEGREES);
g2.translate(-(x + fWidth), -(y + fHeight));
} else if (fRotation == ROTATE_RIGHT) {
g2.translate(x, y);
g2.rotate(NINETY_DEGREES);
g2.drawString(fLabel, K_BUFFER_SPACE, -fDescent);
g2.rotate(-NINETY_DEGREES);
g2.translate(-x, -y);
}
}
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
Component comp =
super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
if (value != null && highlight(table, value, isSelected, hasFocus, row, column)) {
if (isSelected) {
comp.setBackground(new Color((HIGHLIGHT_COLOR.getRGB() ^ comp.getBackground().getRGB())));
comp.setForeground(new Color(Color.BLACK.getRGB() ^ comp.getForeground().getRGB()));
} else {
comp.setBackground(HIGHLIGHT_COLOR);
comp.setForeground(Color.BLACK);
}
} else {
if (!isSelected) {
comp.setBackground(Color.WHITE);
comp.setForeground(Color.BLACK);
}
}
return comp;
}
@Override
public void paintIcon(Component c, Graphics g, int x, int y) {
Color color = c.getForeground();
g.setColor(color);
// draw horizontal lines
g.drawLine(x, y, x + 8, y);
g.drawLine(x, y + 2, x + 8, y + 2);
g.drawLine(x, y + 8, x + 2, y + 8);
// draw vertical lines
g.drawLine(x, y + 1, x, y + 7);
g.drawLine(x + 4, y + 1, x + 4, y + 4);
g.drawLine(x + 8, y + 1, x + 8, y + 4);
// draw arrow
g.drawLine(x + 3, y + 6, x + 9, y + 6);
g.drawLine(x + 4, y + 7, x + 8, y + 7);
g.drawLine(x + 5, y + 8, x + 7, y + 8);
g.drawLine(x + 6, y + 9, x + 6, y + 9);
}
/**
* Constructs a Graphics context with the following graphics state:
*
* <UL>
* <LI>Paint: The color of the component.
* <LI>Font: The font of the component.
* <LI>Stroke: Linewidth 1.0; No Dashing; Miter Join Style; Miter Limit 10; Square Endcaps;
* <LI>Transform: The getDefaultTransform for the GraphicsConfiguration of the component.
* <LI>Composite: AlphaComposite.SRC_OVER
* <LI>Clip: The size of the component, Rectangle(0, 0, size.width, size.height)
* </UL>
*
* @param component to be used to initialize the values of the graphics state
* @param doRestoreOnDispose true if writeGraphicsRestore() should be called when this graphics
* context is disposed of.
*/
protected AbstractVectorGraphicsIO(Component component, boolean doRestoreOnDispose) {
super();
this.size = component.getSize();
this.component = component;
this.doRestoreOnDispose = doRestoreOnDispose;
deviceClip = (size != null ? new Rectangle(0, 0, size.width, size.height) : null);
userClip = null;
GraphicsConfiguration gc = component.getGraphicsConfiguration();
currentTransform = (gc != null) ? gc.getDefaultTransform() : new AffineTransform();
currentComposite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER);
currentStroke =
new BasicStroke(1.0f, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_MITER, 10.0f, null, 0.0f);
super.setFont(component.getFont());
super.setBackground(component.getBackground());
super.setColor(component.getForeground());
// Initialize the rendering hints.
hints = new RenderingHints(null);
}
@Override
public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
int titleHeight = getTitleHeight(c);
// create image with vertical gradient and then use alpha composite to
// render the image with a horizontal fade
BufferedImage titleImage = Utilities.createTranslucentImage(width, titleHeight);
GradientPaint gradient =
new GradientPaint(
0, 0, titleGradientColors[0], 0, titleHeight, titleGradientColors[1], false);
Graphics2D g2 = (Graphics2D) titleImage.getGraphics();
g2.setPaint(gradient);
g2.fillRoundRect(x, y, width, height, 10, 10);
g2.setColor(Utilities.deriveColorHSB(titleGradientColors[1], 0, 0, -.2f));
g2.drawLine(x + 1, titleHeight - 1, width - 2, titleHeight - 1);
g2.setColor(Utilities.deriveColorHSB(titleGradientColors[1], 0, -.5f, .5f));
g2.drawLine(x + 1, titleHeight, width - 2, titleHeight);
g2.setPaint(
new GradientPaint(
0, 0, new Color(0.0f, 0.0f, 0.0f, 1.0f), width, 0, new Color(0.0f, 0.0f, 0.0f, 0.0f)));
g2.setComposite(AlphaComposite.DstIn);
g2.fillRect(x, y, width, titleHeight);
g2.dispose();
g.drawImage(titleImage, x, y, c);
// draw rounded border
super.paintBorder(c, g, x, y, width, height);
// draw title string
g2 = (Graphics2D) g;
g2.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2.setColor(c.getForeground());
g2.setFont(c.getFont());
FontMetrics metrics = c.getFontMetrics(c.getFont());
g2.drawString(title, x + 8, y + (titleHeight - metrics.getHeight()) / 2 + metrics.getAscent());
}
@Override
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
final Component orig =
super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
if (myPluginDescriptor != null) {
myNameLabel.setText(myPluginDescriptor.getName());
final PluginId pluginId = myPluginDescriptor.getPluginId();
final String idString = pluginId.getIdString();
if (myPluginDescriptor.isBundled()) {
myBundledLabel.setText("Bundled");
} else {
final String host = myPlugin2host.get(idString);
if (host != null) {
String presentableUrl = VfsUtil.urlToPath(host);
final int idx = presentableUrl.indexOf('/');
if (idx > -1) {
presentableUrl = presentableUrl.substring(0, idx);
}
myBundledLabel.setText("From " + presentableUrl);
} else {
if (PluginManagerUISettings.getInstance().getInstalledPlugins().contains(idString)) {
myBundledLabel.setText("From repository");
} else {
myBundledLabel.setText("Custom");
}
}
}
if (myPluginDescriptor instanceof IdeaPluginDescriptorImpl
&& ((IdeaPluginDescriptorImpl) myPluginDescriptor).isDeleted()) {
myNameLabel.setIcon(AllIcons.Actions.Clean);
} else if (hasNewerVersion(pluginId)) {
myNameLabel.setIcon(AllIcons.Nodes.Pluginobsolete);
myPanel.setToolTipText("Newer version of the plugin is available");
} else {
myNameLabel.setIcon(AllIcons.Nodes.Plugin);
}
final Color fg = orig.getForeground();
final Color bg = orig.getBackground();
final Color grayedFg = isSelected ? fg : Color.GRAY;
myPanel.setBackground(bg);
myNameLabel.setBackground(bg);
myBundledLabel.setBackground(bg);
myNameLabel.setForeground(fg);
final boolean wasUpdated = wasUpdated(pluginId);
if (wasUpdated || PluginManager.getPlugin(pluginId) == null) {
if (!isSelected) {
myNameLabel.setForeground(FileStatus.COLOR_ADDED);
}
if (wasUpdated) {
myPanel.setToolTipText(
"Plugin was updated to the newest version. Changes will be available after restart");
} else {
myPanel.setToolTipText("Plugin will be activated after restart.");
}
}
myBundledLabel.setForeground(grayedFg);
final Set<PluginId> required = myDependentToRequiredListMap.get(pluginId);
if (required != null && required.size() > 0) {
myNameLabel.setForeground(Color.RED);
final StringBuilder s = new StringBuilder();
if (myEnabled.get(pluginId) == null) {
s.append("Plugin was not loaded.\n");
}
if (required.contains(PluginId.getId("com.intellij.modules.ultimate"))) {
s.append("The plugin requires IntelliJ IDEA Ultimate");
} else {
s.append("Required plugin").append(required.size() == 1 ? " \"" : "s \"");
s.append(
StringUtil.join(
required,
new Function<PluginId, String>() {
@Override
public String fun(final PluginId id) {
final IdeaPluginDescriptor plugin = PluginManager.getPlugin(id);
return plugin == null ? id.getIdString() : plugin.getName();
}
},
","));
s.append(required.size() == 1 ? "\" is not enabled!" : "\" are not enabled!");
}
myPanel.setToolTipText(s.toString());
}
if (PluginManager.isIncompatible(myPluginDescriptor)) {
myPanel.setToolTipText(
IdeBundle.message(
"plugin.manager.incompatible.tooltip.warning",
ApplicationNamesInfo.getInstance().getFullProductName()));
myNameLabel.setForeground(Color.red);
}
}
return myPanel;
}
/**
* Returns the foreground color of the cell renderer for the given table cell.
*
* <p><b>Note:</b> This method is <b>not</b> executed in the event dispatch thread (EDT.) Clients
* are responsible for invoking this method in the EDT.
*
* @param table the given <code>JTable</code>.
* @param row the row index of the cell.
* @param column the column index of the cell.
* @return the foreground color of the cell renderer for the given table cell.
*/
@RunsInCurrentThread
public Color foregroundAt(JTable table, int row, int column) {
Component c = cellRendererIn(table, row, column);
return c != null ? c.getForeground() : null;
}
