org.netbeans.modules.java.graph.EdgeWidget Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.modules.java.graph;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Stroke;
import javax.swing.UIManager;
import org.netbeans.api.visual.anchor.AnchorShape;
import org.netbeans.api.visual.layout.LayoutFactory;
import org.netbeans.api.visual.widget.ConnectionWidget;
import org.netbeans.api.visual.widget.LabelWidget;
import org.netbeans.api.visual.widget.LevelOfDetailsWidget;
import org.netbeans.api.visual.widget.Widget;
import static org.netbeans.modules.java.graph.Bundle.TIP_Primary;
import static org.netbeans.modules.java.graph.Bundle.TIP_Secondary;
import static org.netbeans.modules.java.graph.Bundle.TIP_VersionConflict;
import static org.netbeans.modules.java.graph.Bundle.TIP_VersionWarning;
import static org.netbeans.modules.java.graph.DependencyGraphScene.VersionProvider.VERSION_CONFLICT;
import static org.netbeans.modules.java.graph.DependencyGraphScene.VersionProvider.VERSION_NO_CONFLICT;
import static org.netbeans.modules.java.graph.DependencyGraphScene.VersionProvider.VERSION_POTENTIAL_CONFLICT;
import org.openide.util.NbBundle.Messages;
/**
*
* @author mkleint
*/
class EdgeWidget extends ConnectionWidget {
public static final int DISABLED = 0;
public static final int GRAYED = 1;
public static final int REGULAR = 2;
public static final int HIGHLIGHTED = 3;
public static final int HIGHLIGHTED_PRIMARY = 4;
private static float[] hsbVals = new float[3];
private GraphEdge edge;
private int state = REGULAR;
private boolean isConflict;
private int edgeConflictType;
private LabelWidget conflictVersion;
private Widget versionW;
private Stroke origStroke;
EdgeWidget(DependencyGraphScene scene, GraphEdge edge) {
super(scene);
this.edge = edge;
origStroke = getStroke();
setTargetAnchorShape(AnchorShape.TRIANGLE_FILLED);
if(scene.supportsVersions()) {
isConflict = scene.isConflict(edge.getTarget());
edgeConflictType = getConflictType();
updateVersionW(isConflict);
}
}
private void updateVersionW (boolean isConflict) {
DependencyGraphScene scene = getDependencyGraphScene();
assert scene.supportsVersions();
GraphNode targetNode = scene.getGraphNodeRepresentant(edge.getTarget());
if (targetNode == null) {
return;
}
int includedConflictType = targetNode.getConflictType(scene::isConflict, scene::compareVersions);
if (versionW == null) {
if (isConflict || includedConflictType != VERSION_NO_CONFLICT) {
versionW = new LevelOfDetailsWidget(scene, 0.5, 0.7, Double.MAX_VALUE, Double.MAX_VALUE);
conflictVersion = new LabelWidget(scene, scene.getVersion(edge.getTarget()));
if (isConflict) {
Color c = getConflictColor(edgeConflictType);
if (c != null) {
conflictVersion.setForeground(c);
}
}
versionW.addChild(conflictVersion);
addChild(versionW);
setConstraint(versionW, LayoutFactory.ConnectionWidgetLayoutAlignment.CENTER_RIGHT, 0.5f);
}
} else {
if (!isConflict && includedConflictType == VERSION_NO_CONFLICT) {
if (versionW.getParentWidget() == this) {
removeChild(versionW);
} // else already removed??
}
}
}
public void setState (int state) {
this.state = state;
updateAppearance(((DependencyGraphScene)getScene()).isAnimated());
}
/**
* readable widgets are calculated based on scene zoom factor when zoom factor changes, the readable scope should too
*/
public void updateReadableZoom() {
if (state == HIGHLIGHTED || state == HIGHLIGHTED_PRIMARY) {
updateAppearance(false);
}
}
private DependencyGraphScene getDependencyGraphScene() {
return (DependencyGraphScene)getScene();
}
public void modelChanged () {
DependencyGraphScene scene = getDependencyGraphScene();
if(scene.supportsVersions()) {
edgeConflictType = getConflictType();
isConflict = scene.isConflict(edge.getTarget());
// correction if some graph editing(fixing) was done
if (isConflict && edgeConflictType == VERSION_NO_CONFLICT) {
isConflict = false;
}
updateVersionW(isConflict);
}
updateAppearance(((DependencyGraphScene)getScene()).isAnimated());
}
@Messages({
"TIP_VersionConflict=Conflict with {0} version required by {1}",
"TIP_VersionWarning=Warning, overridden by {0} version required by {1}",
"TIP_Primary=Primary dependency path",
"TIP_Secondary=Secondary dependency path"
})
@SuppressWarnings("fallthrough")
@org.netbeans.api.annotations.common.SuppressWarnings(value = "SF_SWITCH_FALLTHROUGH")
void updateAppearance (boolean animated) {
Color inactiveC = UIManager.getColor("textInactiveText");
if (inactiveC == null) {
inactiveC = Color.LIGHT_GRAY;
}
Color activeC = UIManager.getColor("textText");
if (activeC == null) {
activeC = Color.BLACK;
}
Color conflictC = getConflictColor(edgeConflictType);
if (conflictC == null) {
conflictC = activeC;
}
Stroke s = getDependencyGraphScene().getStroke(edge);
Stroke stroke = s != null ? s : origStroke;
Color c = activeC;
switch (state) {
case REGULAR:
c = edge.isPrimary() ? middleColor(activeC, inactiveC) : isConflict ? conflictC : inactiveC;
break;
case GRAYED:
c = isConflict ? deriveColor(conflictC, 0.7f) : inactiveC;
break;
case HIGHLIGHTED_PRIMARY:
stroke = new BasicStroke(3);
// without break!
case HIGHLIGHTED:
c = isConflict ? conflictC : activeC;
break;
}
if (state != DISABLED) {
StringBuilder sb = new StringBuilder("");
if (isConflict) {
DependencyGraphScene grScene = getDependencyGraphScene();
assert grScene.supportsVersions();
GraphNodeImplementation included = grScene.getGraphNodeRepresentant(
edge.getTarget()).getImpl();
if (included == null) {
return;
}
String version = grScene.getVersion(included);
GraphNodeImplementation parent = included.getParent();
String requester = parent != null ? parent.getName() : "???";
String confText = edgeConflictType == VERSION_CONFLICT ? TIP_VersionConflict(version, requester) : TIP_VersionWarning(version, requester);
conflictVersion.setToolTipText(confText);
sb.append(confText);
sb.append("
");
}
sb.append("");
if (edge.isPrimary()) {
sb.append(TIP_Primary());
} else {
sb.append(TIP_Secondary());
}
sb.append("");
sb.append("");
setToolTipText(sb.toString());
} else {
setToolTipText(null);
}
if (conflictVersion != null) {
conflictVersion.setForeground(c);
Font origF = getScene().getDefaultFont();
conflictVersion.setFont(state == HIGHLIGHTED || state == HIGHLIGHTED_PRIMARY
? NodeWidget.getReadable(getScene(), origF) : origF);
}
setVisible(state != DISABLED && ((DependencyGraphScene)getScene()).isVisible(edge));
setStroke(stroke);
DependencyGraphScene grScene = (DependencyGraphScene)getScene();
if (animated) {
grScene.getSceneAnimator().animateForegroundColor(this, c);
} else {
setForeground(c);
}
}
private int getConflictType () {
GraphNode included = ((DependencyGraphScene)getScene()).getGraphNodeRepresentant(edge.getTarget());
if (included == null) {
return VERSION_NO_CONFLICT;
}
DependencyGraphScene scene = getDependencyGraphScene();
int ret = scene.compareVersions(edge.getTarget(), included.getImpl());
return ret > 0 ?
VERSION_CONFLICT :
ret < 0 ?
VERSION_POTENTIAL_CONFLICT :
VERSION_NO_CONFLICT;
}
private static Color getConflictColor (int conflictType) {
return conflictType == VERSION_CONFLICT ? NodeWidget.CONFLICT
: conflictType == VERSION_POTENTIAL_CONFLICT
? NodeWidget.WARNING : null;
}
/** Derives color from specified with saturation multiplied by given ratio.
*/
static Color deriveColor (Color c, float saturationR) {
Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(), hsbVals);
hsbVals[1] = Math.min(1.0f, hsbVals[1] * saturationR);
return Color.getHSBColor(hsbVals[0], hsbVals[1], hsbVals[2]);
}
private static Color middleColor (Color c1, Color c2) {
return new Color(
(c1.getRed() + c2.getRed()) / 2,
(c1.getGreen() + c2.getGreen()) / 2,
(c1.getBlue() + c2.getBlue()) / 2);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy