ASX-TURN-IIL a67c98
BETA-TURN-IIR c79792
PHOSPHORYLATION (T) c88395
-BETA-TURN-IIL 8b5b50
-ST-MOTIF ac25a1
+BETA-TURN-IIL label
+#8b5b50
+ST-MOTIF label|||0|0
+#ac25a1
STARTGROUP uniprot
<html><a href="http://pfam.xfam.org/family/PF00111">Pfam family</a></html> FER_CAPAA -1 0 0 Pfam
import jalview.datamodel.PDBEntry;
import jalview.datamodel.SequenceI;
import jalview.io.StructureFile;
+import jalview.schemes.Colour;
import jalview.structure.AtomSpec;
import jalview.structure.StructureListener;
import jalview.structure.StructureMapping;
import jalview.structure.StructureSelectionManager;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import java.awt.Color;
for (int i = 0; i < chain.bonds.size(); i++)
{
Bond tmp = chain.bonds.elementAt(i);
- tmp.startCol = Color.lightGray;
- tmp.endCol = Color.lightGray;
+ tmp.startCol = Colour.lightGray;
+ tmp.endCol = Colour.lightGray;
if (chain != mainchain)
{
continue;
{
if (tmpBond.start[2] < (centre[2] - (maxwidth / 6)))
{
- g.setColor(tmpBond.startCol.darker().darker());
+ g.setColor(ColorUtils.getColor(tmpBond.startCol).darker()
+ .darker());
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol.darker().darker());
+ g.setColor(ColorUtils.getColor(tmpBond.endCol).darker().darker());
drawLine(g, xmid, ymid, xend, yend);
}
else if (tmpBond.start[2] < (centre[2] + (maxwidth / 6)))
{
- g.setColor(tmpBond.startCol.darker());
+ g.setColor(ColorUtils.getColor(tmpBond.startCol).darker());
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol.darker());
+ g.setColor(ColorUtils.getColor(tmpBond.endCol).darker());
drawLine(g, xmid, ymid, xend, yend);
}
else
{
- g.setColor(tmpBond.startCol);
+ g.setColor(ColorUtils.getColor(tmpBond.startCol));
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol);
+ g.setColor(ColorUtils.getColor(tmpBond.endCol));
drawLine(g, xmid, ymid, xend, yend);
}
}
else if (!depthcue && !bymolecule)
{
- g.setColor(tmpBond.startCol);
+ g.setColor(ColorUtils.getColor(tmpBond.startCol));
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol);
+ g.setColor(ColorUtils.getColor(tmpBond.endCol));
drawLine(g, xmid, ymid, xend, yend);
}
else
*/
package MCview;
+import jalview.api.ColorI;
+import jalview.schemes.Colour;
import jalview.schemes.ResidueProperties;
-import java.awt.Color;
-
public class Atom
{
public float x;
public int type;
- Color color = Color.lightGray;
+ ColorI color = Colour.lightGray;
public String chain;
*/
package MCview;
-import java.awt.Color;
+import jalview.api.ColorI;
+import jalview.schemes.Colour;
public class Bond
{
float[] end;
- Color startCol = Color.lightGray;
+ ColorI startCol = Colour.lightGray;
- Color endCol = Color.lightGray;
+ ColorI endCol = Colour.lightGray;
public Atom at1;
import jalview.gui.FeatureRenderer;
import jalview.gui.SequenceRenderer;
import jalview.io.StructureFile;
+import jalview.schemes.Colour;
import jalview.structure.AtomSpec;
import jalview.structure.StructureListener;
import jalview.structure.StructureMapping;
import jalview.structure.StructureSelectionManager;
+import jalview.util.ColorUtils;
import java.awt.Color;
import java.awt.Dimension;
for (int i = 0; i < chain.bonds.size(); i++)
{
Bond tmp = chain.bonds.elementAt(i);
- tmp.startCol = Color.lightGray;
- tmp.endCol = Color.lightGray;
+ tmp.startCol = Colour.lightGray;
+ tmp.endCol = Colour.lightGray;
if (chain != mainchain)
{
continue;
if (tmpBond.start[2] < (centre[2] - (maxwidth / 6)))
{
- g.setColor(tmpBond.startCol.darker().darker());
+ g.setColor(ColorUtils.getColor(tmpBond.startCol).darker()
+ .darker());
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol.darker().darker());
+ g.setColor(ColorUtils.getColor(tmpBond.endCol).darker().darker());
drawLine(g, xmid, ymid, xend, yend);
}
else if (tmpBond.start[2] < (centre[2] + (maxwidth / 6)))
{
- g.setColor(tmpBond.startCol.darker());
+ g.setColor(ColorUtils.getColor(tmpBond.startCol).darker());
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol.darker());
+ g.setColor(ColorUtils.getColor(tmpBond.endCol).darker());
drawLine(g, xmid, ymid, xend, yend);
}
else
{
- g.setColor(tmpBond.startCol);
+ g.setColor(ColorUtils.getColor(tmpBond.startCol));
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol);
+ g.setColor(ColorUtils.getColor(tmpBond.endCol));
drawLine(g, xmid, ymid, xend, yend);
}
}
}
else if (!depthcue && !bymolecule)
{
- g.setColor(tmpBond.startCol);
+ g.setColor(ColorUtils.getColor(tmpBond.startCol));
drawLine(g, xstart, ystart, xmid, ymid);
- g.setColor(tmpBond.endCol);
+ g.setColor(ColorUtils.getColor(tmpBond.endCol));
drawLine(g, xmid, ymid, xend, yend);
}
else
if (highlightBond1 != null && highlightBond1 == tmpBond)
{
- g.setColor(tmpBond.endCol.brighter().brighter().brighter()
+ g.setColor(ColorUtils.getColor(tmpBond.endCol).brighter()
+ .brighter().brighter()
.brighter());
drawLine(g, xmid, ymid, xend, yend);
}
if (highlightBond2 != null && highlightBond2 == tmpBond)
{
- g.setColor(tmpBond.startCol.brighter().brighter().brighter()
+ g.setColor(ColorUtils.getColor(tmpBond.startCol).brighter()
+ .brighter().brighter()
.brighter());
drawLine(g, xstart, ystart, xmid, ymid);
}
package MCview;
import jalview.analysis.AlignSeq;
+import jalview.api.ColorI;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.Annotation;
import jalview.datamodel.Mapping;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ResidueProperties;
import jalview.structure.StructureImportSettings;
}
else
{
- b.startCol = Color.gray;
- b.endCol = Color.gray;
+ b.startCol = Colour.gray;
+ b.endCol = Colour.gray;
}
}
}
- public static Color getChargeColour(String resName)
+ public static ColorI getChargeColour(String resName)
{
- Color result = Color.lightGray;
+ ColorI result = Colour.lightGray;
if ("ASP".equals(resName) || "GLU".equals(resName))
{
- result = Color.red;
+ result = Colour.red;
}
else if ("LYS".equals(resName) || "ARG".equals(resName))
{
- result = Color.blue;
+ result = Colour.blue;
}
else if ("CYS".equals(resName))
{
- result = Color.yellow;
+ result = Colour.yellow;
}
return result;
}
try
{
index = ResidueProperties.aa3Hash.get(b.at1.resName).intValue();
- b.startCol = cs.findColour(ResidueProperties.aa[index].charAt(0));
+ b.startCol = new Colour(cs.findColour(ResidueProperties.aa[index]
+ .charAt(0)));
index = ResidueProperties.aa3Hash.get(b.at2.resName).intValue();
- b.endCol = cs.findColour(ResidueProperties.aa[index].charAt(0));
+ b.endCol = new Colour(cs.findColour(ResidueProperties.aa[index]
+ .charAt(0)));
} catch (Exception e)
{
- b.startCol = Color.gray;
- b.endCol = Color.gray;
+ b.startCol = Colour.gray;
+ b.endCol = Colour.gray;
}
}
}
{
for (Bond b : bonds)
{
- b.startCol = col;
- b.endCol = col;
+ b.startCol = new Colour(col);
+ b.endCol = new Colour(col);
}
}
import jalview.datamodel.SequenceI;
import jalview.schemes.ColourSchemeI;
-import java.awt.Color;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
void updateGroupAnnotationSettings(boolean applyGlobalSettings,
boolean preserveNewGroupSettings);
- void setSequenceColour(SequenceI seq, Color col);
+ void setSequenceColour(SequenceI seq, ColorI col);
- Color getSequenceColour(SequenceI seq);
+ ColorI getSequenceColour(SequenceI seq);
void updateSequenceIdColours();
--- /dev/null
+package jalview.api;
+
+public interface ColorI
+{
+ int getGreen();
+
+ int getBlue();
+
+ int getRed();
+
+ int getRGB();
+}
import jalview.datamodel.SequenceFeature;
-import java.awt.Color;
-
public interface FeatureColourI
{
*
* @return
*/
- Color getColour();
+ ColorI getColour();
/**
* Returns the minimum colour (when isGraduatedColour answers true)
*
* @return
*/
- Color getMinColour();
+ ColorI getMinColour();
/**
* Returns the maximum colour (when isGraduatedColour answers true)
*
* @return
*/
- Color getMaxColour();
+ ColorI getMaxColour();
/**
* Answers true if the feature has a single colour, i.e. if isColourByLabel()
void setThreshold(float f);
/**
+ * Answers true if either isAboveThreshold or isBelowThreshold answers true
+ *
+ * @return
+ */
+ boolean hasThreshold();
+
+ /**
* Answers true if the colour varies between the actual minimum and maximum
* score values of the feature, or false if between absolute minimum and
* maximum values (or if not a graduated colour).
void setAutoScaled(boolean b);
/**
- * Returns the maximum score of the graduated colour range
+ * Answers true if the feature has a simple colour, or is coloured by label,
+ * or has a graduated colour and the score of this feature instance is within
+ * the range to render (if any), i.e. does not lie below or above any
+ * threshold set.
*
+ * @param feature
* @return
*/
- float getMax();
+ boolean isColored(SequenceFeature feature);
/**
- * Returns the minimum score of the graduated colour range
+ * Update the min-max range for a graduated colour scheme
*
- * @return
+ * @param min
+ * @param max
*/
- float getMin();
+ void updateBounds(float min, float max);
/**
- * Answers true if either isAboveThreshold or isBelowThreshold answers true
+ * Returns the colour in Jalview features file format
*
* @return
*/
- boolean hasThreshold();
+ String toJalviewFormat(String featureType);
/**
- * Returns the computed colour for the given sequence feature
+ * Returns the maximum score of the graduated colour range
*
- * @param feature
* @return
*/
- Color getColor(SequenceFeature feature);
+ float getMax();
/**
- * Answers true if the feature has a simple colour, or is coloured by label,
- * or has a graduated colour and the score of this feature instance is within
- * the range to render (if any), i.e. does not lie below or above any
- * threshold set.
+ * Returns the minimum score of the graduated colour range
*
- * @param feature
* @return
*/
- boolean isColored(SequenceFeature feature);
-
- /**
- * Update the min-max range for a graduated colour scheme
- *
- * @param min
- * @param max
- */
- void updateBounds(float min, float max);
+ float getMin();
/**
- * Returns the colour in Jalview features file format
+ * Returns the computed colour for the given sequence feature
*
+ * @param feature
* @return
*/
- String toJalviewFormat(String featureType);
+ ColorI getColor(SequenceFeature feature);
}
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
-import java.awt.Color;
import java.util.List;
import java.util.Map;
* - column position
* @return
*/
- Color findFeatureColour(Color col, SequenceI sequenceI, int r);
+ ColorI findFeatureColour(ColorI col, SequenceI sequenceI, int r);
/**
* trigger the feature discovery process for a newly created feature renderer.
/**
* update the feature style for a particular feature
*
- * @param ft
- * @param ggc
+ * @param featureType
+ * @param featureColour
*/
- void setColour(String ft, FeatureColourI ggc);
+ void setColour(String featureType, FeatureColourI featureColour);
AlignViewportI getViewport();
import jalview.datamodel.SequenceI;
-import java.awt.Color;
-
public interface SequenceRenderer
{
- Color getResidueBoxColour(SequenceI sequenceI, int r);
+ ColorI getResidueBoxColour(SequenceI sequenceI, int r);
- Color getResidueColour(SequenceI seq, int position, FeatureRenderer fr);
+ ColorI getResidueColour(SequenceI seq, int position, FeatureRenderer fr);
}
*/
package jalview.api;
-import java.awt.Color;
-
public interface ViewStyleI
{
*/
void setColourByReferenceSeq(boolean colourByReferenceSeq);
- Color getTextColour();
+ ColorI getTextColour();
- Color getTextColour2();
+ ColorI getTextColour2();
int getThresholdTextColour();
void setShowColourText(boolean showColourText);
- void setTextColour(Color textColour);
+ void setTextColour(ColorI textColour);
void setThresholdTextColour(int thresholdTextColour);
- void setTextColour2(Color textColour2);
+ void setTextColour2(ColorI textColour2);
boolean isSeqNameItalics();
Checkbox thresholdIsMin = new Checkbox();
+ @Override
public void actionPerformed(ActionEvent evt)
{
if (evt.getSource() == thresholdValue)
}
}
+ @Override
public void itemStateChanged(ItemEvent evt)
{
if (evt.getSource() == currentColours)
changeColour();
}
+ @Override
public void adjustmentValueChanged(AdjustmentEvent evt)
{
if (!adjusting)
}
+ @Override
public void mouseClicked(MouseEvent evt)
{
}
+ @Override
public void mousePressed(MouseEvent evt)
{
}
+ @Override
public void mouseReleased(MouseEvent evt)
{
ap.paintAlignment(true);
}
+ @Override
public void mouseEntered(MouseEvent evt)
{
}
+ @Override
public void mouseExited(MouseEvent evt)
{
}
import jalview.api.FeatureColourI;
import jalview.datamodel.GraphLine;
import jalview.schemes.AnnotationColourGradient;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import java.awt.Checkbox;
Color bl = Color.black;
if (oldcs.isSimpleColour())
{
- bl = oldcs.getColour();
+ bl = ColorUtils.getColor(oldcs.getColour());
}
// original colour becomes the maximum colour
- cs = new FeatureColour(Color.white, bl, mm[0], mm[1]);
+ cs = new FeatureColour(new Colour(Color.white), new Colour(bl),
+ mm[0], mm[1]);
}
- minColour.setBackground(cs.getMinColour());
- maxColour.setBackground(cs.getMaxColour());
- minColour.setForeground(cs.getMinColour());
- maxColour.setForeground(cs.getMaxColour());
+ minColour.setBackground(ColorUtils.getColor(cs.getMinColour()));
+ maxColour.setBackground(ColorUtils.getColor(cs.getMaxColour()));
+ minColour.setForeground(ColorUtils.getColor(cs.getMinColour()));
+ maxColour.setForeground(ColorUtils.getColor(cs.getMaxColour()));
colourFromLabel.setState(cs.isColourByLabel());
adjusting = true;
// ap.paintAlignment(false);
}
- public void minColour_actionPerformed(Color newCol)
+ public void minColour_actionPerformed(Color c)
{
- if (newCol == null)
+ if (c == null)
{
UserDefinedColours udc = new UserDefinedColours(this,
minColour.getBackground(), owner,
}
else
{
- minColour.setBackground(newCol);
- minColour.setForeground(newCol);
+ minColour.setBackground(c);
+ minColour.setForeground(c);
minColour.repaint();
changeColour();
}
slider.setEnabled(true);
thresholdValue.setEnabled(true);
- FeatureColour acg = new FeatureColour(minColour.getBackground(),
- maxColour.getBackground(), min, max);
+ FeatureColour acg = new FeatureColour(new Colour(
+ minColour.getBackground()), new Colour(
+ maxColour.getBackground()), min, max);
acg.setColourByLabel(colourFromLabel.getState());
maxColour.setEnabled(!colourFromLabel.getState());
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.io.FeaturesFile;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
import jalview.schemes.UserColourScheme;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import jalview.viewmodel.AlignmentViewport;
public class FeatureRenderer extends
jalview.renderer.seqfeatures.FeatureRenderer
{
-
// Holds web links for feature groups and feature types
// in the form label|link
Hashtable featureLinks = null;
- /**
- * Creates a new FeatureRenderer object.
- *
- * @param av
- */
- public FeatureRenderer(AlignmentViewport av)
- {
- super(av);
-
- }
-
static String lastFeatureAdded;
static String lastFeatureGroupAdded;
FeatureColourPanel colourPanel;
+ /**
+ * Creates a new FeatureRenderer object.
+ *
+ * @param av
+ */
+ public FeatureRenderer(AlignmentViewport av)
+ {
+ super(av);
+ }
+
class FeatureColourPanel extends Panel
{
String label = "";
String vlabel = "";
if (newcol.isSimpleColour())
{
- bg = newcol.getColour();
+ bg = ColorUtils.getColor(newcol.getColour());
setBackground(bg);
}
else
}
else
{
- setBackground(bg = newcol.getMinColour());
- maxCol = newcol.getMaxColour();
+ setBackground(bg = ColorUtils.getColor(newcol.getMinColour()));
+ maxCol = ColorUtils.getColor(newcol.getMaxColour());
}
}
label = vlabel;
{
Color generatedColour = UserColourScheme
.createColourFromName(name.getText());
- col = new FeatureColour(generatedColour);
+ col = new FeatureColour(new Colour(generatedColour));
}
colourPanel.updateColor(col);
if (!colourPanel.isGcol)
{
// update colour - otherwise its already done.
- setColour(sf.type, new FeatureColour(colourPanel.getBackground()));
+ setColour(
+ sf.type,
+ new FeatureColour(new Colour(colourPanel.getBackground())));
}
try
{
{
setGroupVisibility(lastFeatureGroupAdded, true);
}
- setColour(lastFeatureAdded, new FeatureColour(newColour)); // was fcol
+ setColour(lastFeatureAdded,
+ new FeatureColour(new Colour(newColour))); // was fcol
setVisible(lastFeatureAdded);
findAllFeatures(false); // different to original applet behaviour ?
// findAllFeatures();
import jalview.api.FeatureSettingsControllerI;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceFeature;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import java.awt.BorderLayout;
final FeatureColourI typeCol = fr.getFeatureStyle(type);
PopupMenu men = new PopupMenu(MessageManager.formatMessage(
"label.settings_for_type", new String[] { type }));
- java.awt.MenuItem scr = new MenuItem(
+ MenuItem scr = new MenuItem(
MessageManager.getString("label.sort_by_score"));
men.add(scr);
final FeatureSettings me = this;
FeatureColourI fcol = fr.getFeatureStyle(check.type);
if (fcol.isSimpleColour())
{
- new UserDefinedColours(this, check.type, fcol.getColour());
+ new UserDefinedColours(this, check.type, ColorUtils.getColor(fcol
+ .getColour()));
}
else
{
col = newcol;
if (col.isSimpleColour())
{
- setBackground(col.getColour());
+ setBackground(ColorUtils.getColor(col.getColour()));
}
else
{
}
else
{
- setBackground(col.getMinColour());
+ setBackground(ColorUtils.getColor(col.getMinColour()));
}
this.setLabel(vlabel);
}
* height/g.getFontMetrics().getHeight()))); g.drawString("Label",
* width/2, 0);
*/
-
}
else if (col.isGraduatedColour())
{
- Color maxCol = col.getMaxColour();
+ Color maxCol = ColorUtils.getColor(col.getMaxColour());
g.setColor(maxCol);
g.fillRect(d.width / 2, 0, d.width / 2, d.height);
-
}
}
package jalview.appletgui;
import jalview.datamodel.SequenceI;
+import jalview.util.ColorUtils;
import java.awt.Color;
import java.awt.Font;
}
else
{
- gg.setColor(av.getSequenceColour(s));
+ gg.setColor(ColorUtils.getColor(av.getSequenceColour(s)));
gg.fillRect(0, ((i - starty) * charHeight) + ypos, getSize().width,
charHeight);
gg.setColor(Color.black);
}
else
{
- currentColor = av.getSequenceColour(seq);
+ currentColor = ColorUtils.getColor(av.getSequenceColour(seq));
currentTextColor = Color.black;
}
package jalview.appletgui;
import jalview.datamodel.AlignmentI;
+import jalview.util.ColorUtils;
import java.awt.Color;
import java.awt.Dimension;
if (seq.getLength() > lastcol)
{
- color = sr.getResidueBoxColour(seq, lastcol);
+ color = ColorUtils.getColor(sr.getResidueBoxColour(seq, lastcol));
if (av.isShowSequenceFeatures())
{
- color = fr.findFeatureColour(color, seq, lastcol);
+ color = ColorUtils.getColor(fr.findFeatureColour(color, seq,
+ lastcol));
}
}
else
import jalview.datamodel.SequenceI;
import jalview.datamodel.SequencePoint;
import jalview.math.RotatableMatrix;
+import jalview.util.ColorUtils;
import jalview.util.Format;
import jalview.util.MessageManager;
import jalview.viewmodel.AlignmentViewport;
repaint();
}
+ @Override
public void setPoints(Vector points, int npoint)
{
this.points = points;
dim = height;
}
- return (float) (dim * scalefactor / (2 * maxwidth));
+ return dim * scalefactor / (2 * maxwidth);
}
public void findCentre()
// System.out.println("Centre z " + centre[2]);
}
+ @Override
public Dimension getPreferredSize()
{
if (prefsize != null)
}
}
+ @Override
public Dimension getMinimumSize()
{
return getPreferredSize();
}
+ @Override
public void update(Graphics g)
{
paint(g);
}
+ @Override
public void paint(Graphics g)
{
if (points == null)
for (int i = 0; i < npoint; i++)
{
SequencePoint sp = (SequencePoint) points.elementAt(i);
- int x = (int) ((float) (sp.coord[0] - centre[0]) * scale) + halfwidth;
- int y = (int) ((float) (sp.coord[1] - centre[1]) * scale)
+ int x = (int) ((sp.coord[0] - centre[0]) * scale) + halfwidth;
+ int y = (int) ((sp.coord[1] - centre[1]) * scale)
+ halfheight;
float z = sp.coord[1] - centre[2];
}
else
{
- g.setColor(av.getSequenceColour(sp.sequence));
+ g.setColor(ColorUtils.getColor(av.getSequenceColour(sp.sequence)));
}
if (av.getSelectionGroup() != null)
return prefsize;
}
+ @Override
public void keyTyped(KeyEvent evt)
{
}
+ @Override
public void keyReleased(KeyEvent evt)
{
}
+ @Override
public void keyPressed(KeyEvent evt)
{
if (evt.getKeyCode() == KeyEvent.VK_UP)
}
}
+ @Override
public void mouseClicked(MouseEvent evt)
{
}
+ @Override
public void mouseEntered(MouseEvent evt)
{
}
+ @Override
public void mouseExited(MouseEvent evt)
{
}
+ @Override
public void mouseReleased(MouseEvent evt)
{
}
+ @Override
public void mousePressed(MouseEvent evt)
{
int x = evt.getX();
repaint();
}
+ @Override
public void mouseMoved(MouseEvent evt)
{
SequenceI found = findPoint(evt.getX(), evt.getY());
repaint();
}
+ @Override
public void mouseDragged(MouseEvent evt)
{
mx = evt.getX();
rotmat.setIdentity();
- rotmat.rotate((float) (my - omy), 'x');
- rotmat.rotate((float) (mx - omx), 'y');
+ rotmat.rotate(my - omy, 'x');
+ rotmat.rotate(mx - omx, 'y');
for (int i = 0; i < npoint; i++)
{
for (int i = 0; i < npoint; i++)
{
SequencePoint sp = (SequencePoint) points.elementAt(i);
- int tmp1 = (int) ((sp.coord[0] - centre[0]) * scale + (float) getSize().width / 2.0);
- int tmp2 = (int) ((sp.coord[1] - centre[1]) * scale + (float) getSize().height / 2.0);
+ int tmp1 = (int) ((sp.coord[0] - centre[0]) * scale + getSize().width / 2.0);
+ int tmp2 = (int) ((sp.coord[1] - centre[1]) * scale + getSize().height / 2.0);
if (tmp1 > x1 && tmp1 < x2 && tmp2 > y1 && tmp2 < y2)
{
{
SequencePoint sp = (SequencePoint) points.elementAt(i);
- int px = (int) ((float) (sp.coord[0] - centre[0]) * scale)
+ int px = (int) ((sp.coord[0] - centre[0]) * scale)
+ halfwidth;
- int py = (int) ((float) (sp.coord[1] - centre[1]) * scale)
+ int py = (int) ((sp.coord[1] - centre[1]) * scale)
+ halfheight;
if (Math.abs(px - x) < 3 && Math.abs(py - y) < 3)
import jalview.datamodel.SequenceI;
import jalview.renderer.ScaleRenderer;
import jalview.renderer.ScaleRenderer.ScaleMark;
+import jalview.util.ColorUtils;
import jalview.viewmodel.AlignmentViewport;
import java.awt.Color;
}
else
{
- g.setColor(group.getOutlineColour());
+ g.setColor(ColorUtils.getColor(group.getOutlineColour()));
}
}
}
*/
package jalview.appletgui;
+import jalview.api.ColorI;
import jalview.api.FeatureRenderer;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import java.awt.Color;
}
@Override
- public Color getResidueBoxColour(SequenceI seq, int i)
+ public ColorI getResidueBoxColour(SequenceI seq, int i)
{
allGroups = av.getAlignment().findAllGroups(seq);
getBoxColour(av.getGlobalColourScheme(), seq, i);
}
- return resBoxColour;
+ return new Colour(resBoxColour);
}
/**
* @return
*/
@Override
- public Color getResidueColour(final SequenceI seq, int position,
+ public ColorI getResidueColour(final SequenceI seq, int position,
FeatureRenderer fr)
{
// TODO replace 8 or so code duplications with calls to this method
// (refactored as needed)
- Color col = getResidueBoxColour(seq, position);
+ ColorI col = getResidueBoxColour(seq, position);
if (fr != null)
{
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.datamodel.SequenceNode;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ColourSchemeProperty;
import jalview.schemes.ResidueProperties;
import jalview.schemes.UserColourScheme;
+import jalview.util.ColorUtils;
import jalview.util.Format;
import jalview.util.MappingUtils;
import jalview.viewmodel.AlignmentViewport;
}
else
{
- g.setColor(av.getSequenceColour(seq).darker());
+ g.setColor(ColorUtils.getColor(av.getSequenceColour(seq))
+ .darker());
}
}
if (node.element() instanceof SequenceI)
{
- av.setSequenceColour((SequenceI) node.element(), c);
+ av.setSequenceColour((SequenceI) node.element(), new Colour(c));
}
}
else
for (SequenceI seq : mappedGroup.getSequences())
{
// TODO why does gui require col.brighter() here??
- codingComplement.setSequenceColour(seq, col);
+ codingComplement.setSequenceColour(seq, new Colour(col));
}
}
}
import jalview.api.FeatureColourI;
import jalview.datamodel.SequenceGroup;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.FeatureColour;
import jalview.schemes.ResidueProperties;
import jalview.schemes.UserColourScheme;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import java.awt.Button;
public UserDefinedColours(FeatureRenderer fr, Frame alignframe)
{
caller = fr;
- originalColour = new FeatureColour(fr.colourPanel.getBackground());
+ originalColour = new FeatureColour(new Colour(
+ fr.colourPanel.getBackground()));
originalLabel = "Feature Colour";
setForDialog("Select Feature Colour", alignframe);
setTargetColour(fr.colourPanel.getBackground());
String title)
{
this.caller = caller;
- originalColour = new FeatureColour(col);
+ originalColour = new FeatureColour(new Colour(col));
originalLabel = title;
setForDialog(title, alignframe);
setTargetColour(col);
*/
public UserDefinedColours(Object caller, String label, Color colour)
{
- this(caller, label, new FeatureColour(colour), colour);
+ this(caller, label, new FeatureColour(new Colour(colour)), colour);
}
/**
public UserDefinedColours(FeatureSettings me, String type,
FeatureColourI graduatedColor)
{
- this(me, type, graduatedColor, graduatedColor.getMaxColour());
+ this(me, type, graduatedColor, ColorUtils.getColor(graduatedColor
+ .getMaxColour()));
}
private UserDefinedColours(Object caller, String label,
if (caller instanceof FeatureSettings)
{
((FeatureSettings) caller).setUserColour(originalLabel,
- new FeatureColour(getColor()));
+ new FeatureColour(new Colour(getColor())));
}
else if (caller instanceof AnnotationColourChooser)
{
else if (caller instanceof FeatureRenderer)
{
((FeatureRenderer) caller).colourPanel
- .updateColor(new FeatureColour(getColor()));
+ .updateColor(new FeatureColour(new Colour(getColor())));
}
else if (caller instanceof FeatureColourChooser)
{
if (originalLabel.equals("Min Colour"))
{
((AnnotationColourChooser) caller)
- .minColour_actionPerformed(originalColour.getColour());
+ .minColour_actionPerformed(ColorUtils
+ .getColor(originalColour.getColour()));
}
else
{
((AnnotationColourChooser) caller)
- .maxColour_actionPerformed(originalColour.getColour());
+ .maxColour_actionPerformed(ColorUtils
+ .getColor(originalColour.getColour()));
}
}
else if (caller instanceof FeatureRenderer)
if (originalLabel.indexOf("inimum") > -1)
{
((FeatureColourChooser) caller)
- .minColour_actionPerformed(originalColour.getColour());
+ .minColour_actionPerformed(ColorUtils
+ .getColor(originalColour.getColour()));
}
else
{
((FeatureColourChooser) caller)
- .maxColour_actionPerformed(originalColour.getColour());
+ .maxColour_actionPerformed(ColorUtils
+ .getColor(originalColour.getColour()));
}
}
if (dialog != null)
import jalview.api.AlignViewControllerI;
import jalview.api.AlignViewportI;
import jalview.api.AlignmentViewPanel;
+import jalview.api.ColorI;
import jalview.api.FeatureRenderer;
import jalview.commands.OrderCommand;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.io.FeaturesFile;
+import jalview.schemes.Colour;
import jalview.util.MessageManager;
import java.awt.Color;
viewport.getAlignment().addGroup(gps[g]);
Color col = new Color((int) (Math.random() * 255),
(int) (Math.random() * 255), (int) (Math.random() * 255));
- col = col.brighter();
+ ColorI newcol = new Colour(col.brighter());
for (SequenceI sq : gps[g].getSequences(null))
{
- viewport.setSequenceColour(sq, col);
+ viewport.setSequenceColour(sq, newcol);
}
}
return true;
import jalview.analysis.AAFrequency;
import jalview.analysis.Conservation;
+import jalview.api.ColorI;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ResidueProperties;
// end column (base 0)
int endRes = 0;
- public Color outlineColour = Color.black;
+ public ColorI outlineColour = Colour.black;
- public Color idColour = null;
+ public ColorI idColour = null;
public int thresholdTextColour = 0;
- public Color textColour = Color.black;
+ public ColorI textColour = Colour.black;
- public Color textColour2 = Color.white;
+ public ColorI textColour2 = Colour.white;
/**
* consensus calculation property
*/
public void setOutlineColour(Color c)
{
- outlineColour = c;
+ outlineColour = new Colour(c);
}
/**
*
* @return DOCUMENT ME!
*/
- public Color getOutlineColour()
+ public ColorI getOutlineColour()
{
return outlineColour;
}
/**
* @return the idColour
*/
- public Color getIdColour()
+ public ColorI getIdColour()
{
return idColour;
}
*/
public void setIdColour(Color idColour)
{
- this.idColour = idColour;
+ this.idColour = new Colour(idColour);
}
/**
package jalview.ext.ensembl;
+import jalview.api.ColorI;
import jalview.api.FeatureColourI;
import jalview.api.FeatureSettingsModelI;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceI;
import jalview.io.gff.SequenceOntologyFactory;
import jalview.io.gff.SequenceOntologyI;
-import jalview.schemes.FeatureColour;
+import jalview.schemes.Colour;
+import jalview.schemes.FeatureColourAdapter;
import jalview.schemes.FeatureSettingsAdapter;
import jalview.util.MapList;
-import java.awt.Color;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
{
if (so.isA(type, SequenceOntologyI.EXON))
{
- return new FeatureColour()
+ return new FeatureColourAdapter()
{
@Override
public boolean isColourByLabel()
}
if (so.isA(type, SequenceOntologyI.SEQUENCE_VARIANT))
{
- return new FeatureColour()
+ return new FeatureColourAdapter()
{
@Override
- public Color getColour()
+ public ColorI getColour()
{
- return Color.RED;
+ return Colour.red;
}
};
}
*/
package jalview.ext.jmol;
+import jalview.api.ColorI;
import jalview.api.FeatureRenderer;
import jalview.api.SequenceRenderer;
import jalview.datamodel.AlignmentI;
import jalview.structure.StructureMappingcommandSet;
import jalview.structure.StructureSelectionManager;
-import java.awt.Color;
import java.util.ArrayList;
/**
lastPos = pos;
- Color col = sr.getResidueBoxColour(sequence[pdbfnum][s], r);
+ ColorI col = sr.getResidueBoxColour(sequence[pdbfnum][s], r);
if (fr != null)
{
*/
package jalview.ext.rbvi.chimera;
+import jalview.api.ColorI;
import jalview.api.FeatureRenderer;
import jalview.api.SequenceRenderer;
import jalview.datamodel.AlignmentI;
import jalview.util.ColorUtils;
import jalview.util.Comparison;
-import java.awt.Color;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
SequenceI[][] sequence, SequenceRenderer sr, FeatureRenderer fr,
AlignmentI alignment)
{
- Map<Color, Map<Integer, Map<String, List<int[]>>>> colourMap = buildColoursMap(
+ Map<ColorI, Map<Integer, Map<String, List<int[]>>>> colourMap = buildColoursMap(
ssm, files, sequence, sr, fr, alignment);
List<String> colourCommands = buildColourCommands(colourMap);
* @return
*/
protected static List<String> buildColourCommands(
- Map<Color, Map<Integer, Map<String, List<int[]>>>> colourMap)
+ Map<ColorI, Map<Integer, Map<String, List<int[]>>>> colourMap)
{
/*
* This version concatenates all commands into a single String (semi-colon
List<String> commands = new ArrayList<String>();
StringBuilder sb = new StringBuilder(256);
boolean firstColour = true;
- for (Color colour : colourMap.keySet())
+ for (ColorI colour : colourMap.keySet())
{
String colourCode = ColorUtils.toTkCode(colour);
if (!firstColour)
* Ordering is by order of addition (for colours and positions), natural ordering (for models and chains)
* </pre>
*/
- protected static Map<Color, Map<Integer, Map<String, List<int[]>>>> buildColoursMap(
+ protected static Map<ColorI, Map<Integer, Map<String, List<int[]>>>> buildColoursMap(
StructureSelectionManager ssm, String[] files,
SequenceI[][] sequence, SequenceRenderer sr, FeatureRenderer fr,
AlignmentI alignment)
{
- Map<Color, Map<Integer, Map<String, List<int[]>>>> colourMap = new LinkedHashMap<Color, Map<Integer, Map<String, List<int[]>>>>();
- Color lastColour = null;
+ Map<ColorI, Map<Integer, Map<String, List<int[]>>>> colourMap = new LinkedHashMap<ColorI, Map<Integer, Map<String, List<int[]>>>>();
+ ColorI lastColour = null;
for (int pdbfnum = 0; pdbfnum < files.length; pdbfnum++)
{
StructureMapping[] mapping = ssm.getMapping(files[pdbfnum]);
continue;
}
- Color colour = sr.getResidueColour(seq, r, fr);
+ ColorI colour = sr.getResidueColour(seq, r, fr);
final String chain = mapping[m].getChain();
/*
* @param chain
*/
protected static void addColourRange(
- Map<Color, Map<Integer, Map<String, List<int[]>>>> colourMap,
- Color colour, int model, int startPos, int endPos, String chain)
+ Map<ColorI, Map<Integer, Map<String, List<int[]>>>> colourMap,
+ ColorI colour, int model, int startPos, int endPos, String chain)
{
/*
* Get/initialize map of data for the colour
*/
package jalview.ext.varna;
+import jalview.api.ColorI;
import jalview.api.FeatureRenderer;
import jalview.api.SequenceRenderer;
import jalview.datamodel.AlignmentI;
import jalview.structure.StructureMapping;
import jalview.structure.StructureSelectionManager;
-import java.awt.Color;
import java.util.ArrayList;
/**
StructureMapping[] mapping = ssm.getMapping(files[pdbfnum]);
if (mapping == null || mapping.length < 1)
+ {
continue;
+ }
int lastPos = -1;
for (int s = 0; s < sequence[pdbfnum].length; s++)
int pos = mapping[m].getPDBResNum(asp.findPosition(r));
if (pos < 1 || pos == lastPos)
+ {
continue;
+ }
lastPos = pos;
- Color col = sr.getResidueBoxColour(sequence[pdbfnum][s], r);
+ ColorI col = sr.getResidueBoxColour(sequence[pdbfnum][s], r);
if (fr != null)
+ {
col = fr.findFeatureColour(col, sequence[pdbfnum][s], r);
+ }
String newSelcom = (mapping[m].getChain() != " " ? ":"
+ mapping[m].getChain() : "")
+ "/"
import jalview.math.AlignmentDimension;
import jalview.schemes.ResidueProperties;
import jalview.structure.StructureSelectionManager;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import jalview.util.Platform;
}
else
{
- currentColor = av.getSequenceColour(seq);
+ currentColor = ColorUtils.getColor(av.getSequenceColour(seq));
currentTextColor = Color.black;
}
import jalview.structure.SelectionSource;
import jalview.structure.StructureSelectionManager;
import jalview.structure.VamsasSource;
+import jalview.util.ColorUtils;
import jalview.util.Comparison;
import jalview.util.MessageManager;
import jalview.util.ShiftList;
}
selectionHighlighter.highlightRegion(rna, start, end);
selectionHighlighter.getLastHighlight().setOutlineColor(
- seqsel.getOutlineColour());
+ ColorUtils.getColor(seqsel.getOutlineColour()));
// TODO - translate column markings to positions on structure if present.
vab.updateSelectedRNA(rna);
}
import jalview.api.FeatureColourI;
import jalview.datamodel.GraphLine;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import java.awt.BorderLayout;
else
{
// promote original color to a graduated color
- Color bl = oldcs.getColour();
+ Color bl = ColorUtils.getColor(oldcs.getColour());
if (bl == null)
{
bl = Color.BLACK;
}
// original colour becomes the maximum colour
- cs = new FeatureColour(Color.white, bl, mm[0], mm[1]);
+ cs = new FeatureColour(new Colour(Color.white), new Colour(bl),
+ mm[0], mm[1]);
cs.setColourByLabel(false);
}
- minColour.setBackground(oldminColour = cs.getMinColour());
- maxColour.setBackground(oldmaxColour = cs.getMaxColour());
+ minColour.setBackground(oldminColour = ColorUtils.getColor(cs
+ .getMinColour()));
+ maxColour.setBackground(oldmaxColour = ColorUtils.getColor(cs
+ .getMaxColour()));
adjusting = true;
try
FeatureColourI acg;
if (cs.isColourByLabel())
{
- acg = new FeatureColour(oldminColour, oldmaxColour, min, max);
+ acg = new FeatureColour(new Colour(oldminColour), new Colour(
+ oldmaxColour), min, max);
}
else
{
- acg = new FeatureColour(oldminColour = minColour.getBackground(),
- oldmaxColour = maxColour.getBackground(), min, max);
-
+ acg = new FeatureColour(new Colour(
+ oldminColour = minColour.getBackground()), new Colour(
+ oldmaxColour = maxColour.getBackground()), min, max);
}
if (!hasThreshold)
import jalview.datamodel.SearchResults;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
import jalview.schemes.UserColourScheme;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import java.awt.BorderLayout;
{
Color col = JColorChooser.showDialog(Desktop.desktop,
MessageManager.getString("label.select_feature_colour"),
- fcol.getColour());
+ ColorUtils.getColor(fcol.getColour()));
if (col != null)
{
- fcol = new FeatureColour(col);
- updateColourButton(bigPanel, colour, new FeatureColour(col));
+ fcol = new FeatureColour(new Colour(col));
+ updateColourButton(bigPanel, colour, fcol);
}
}
else
FeatureColourI col = getFeatureStyle(name.getText());
if (col == null)
{
- col = new FeatureColour(UserColourScheme
- .createColourFromName(name.getText()));
+ col = new FeatureColour(new Colour(UserColourScheme
+ .createColourFromName(name.getText())));
}
oldcol = fcol = col;
updateColourButton(bigPanel, colour, col);
* update the amend feature button dependent on the given style
*
* @param bigPanel
+ * @param colour
* @param col
+<<<<<<< HEAD
+=======
* @param col
+>>>>>>> refs/heads/develop
*/
protected void updateColourButton(JPanel bigPanel, JLabel colour,
FeatureColourI col)
if (col.isSimpleColour())
{
- colour.setBackground(col.getColour());
+ colour.setBackground(ColorUtils.getColor(col.getColour()));
}
else
{
import jalview.gui.Help.HelpId;
import jalview.io.JalviewFileChooser;
import jalview.schemabinding.version2.JalviewUserColours;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
+import jalview.util.ColorUtils;
import jalview.util.Format;
import jalview.util.MessageManager;
import jalview.util.Platform;
"Select new Colour", true, // modal
colorChooser, this, // OK button handler
null); // no CANCEL button handler
- colorChooser.setColor(featureColour.getMaxColour());
+ colorChooser.setColor(ColorUtils.getColor(featureColour
+ .getMaxColour()));
dialog.setVisible(true);
}
}
Cache.log.warn("Couldn't parse out graduated feature color.",
e);
}
- FeatureColourI gcol = new FeatureColour(mincol, maxcol,
+ FeatureColourI gcol = new FeatureColour(new Colour(mincol),
+ new Colour(maxcol),
newcol.getMin(), newcol.getMax());
if (newcol.hasAutoScale())
{
Color color = new Color(
Integer.parseInt(jucs.getColour(i).getRGB(), 16));
fr.setColour(name = jucs.getColour(i).getName(),
- new FeatureColour(color));
+ new FeatureColour(new Colour(color)));
}
fr.setOrder(name, (i == 0) ? 0 : i / jucs.getColourCount());
}
{
this.setText("");
this.setIcon(null);
- newColor = cellColour.getColour();
+ newColor = ColorUtils.getColor(cellColour.getColour());
setBackground(newColor);
}
if (isSelected)
}
else
{
- Color newColor = gcol.getMaxColour();
+ Color newColor = ColorUtils.getColor(gcol.getMaxColour());
comp.setBackground(newColor);
// System.err.println("Width is " + w / 2);
Icon ficon = new FeatureIcon(gcol, comp.getBackground(), w, h, thr);
g.setColor(backg);
g.fillRect(0, 0, width, height);
// need an icon here.
- g.setColor(gcol.getMaxColour());
+ g.setColor(ColorUtils.getColor(gcol.getMaxColour()));
g.setFont(new Font("Verdana", Font.PLAIN, 9));
}
else
{
- Color minCol = gcol.getMinColour();
+ Color minCol = ColorUtils.getColor(gcol.getMinColour());
g.setColor(minCol);
g.fillRect(0, 0, s1, height);
if (midspace)
g.setColor(Color.white);
g.fillRect(s1, 0, e1 - s1, height);
}
- g.setColor(gcol.getMaxColour());
+ g.setColor(ColorUtils.getColor(gcol.getMaxColour()));
g.fillRect(0, e1, width - e1, height);
}
}
if (currentColor.isSimpleColour())
{
// bring up simple color chooser
- button.setBackground(currentColor.getColour());
- colorChooser.setColor(currentColor.getColour());
+ button.setBackground(ColorUtils.getColor(currentColor.getColour()));
+ colorChooser
+ .setColor(ColorUtils.getColor(currentColor.getColour()));
dialog.setVisible(true);
}
else
{ // User pressed dialog's "OK" button.
if (currentColor.isSimpleColour())
{
- currentColor = new FeatureColour(colorChooser.getColor());
+ currentColor = new FeatureColour(
+ new Colour(colorChooser.getColor()));
}
else
{
{
button.setText("");
button.setIcon(null);
- button.setBackground(currentColor.getColour());
+ button.setBackground(ColorUtils.getColor(currentColor.getColour()));
}
return button;
}
package jalview.gui;
import jalview.datamodel.SequenceI;
+import jalview.util.ColorUtils;
import java.awt.BorderLayout;
import java.awt.Color;
}
else
{
- gg.setColor(av.getSequenceColour(s));
+ gg.setColor(ColorUtils.getColor(av.getSequenceColour(s)));
gg.fillRect(0, ((i - starty) * charHeight) + ypos, getWidth(),
charHeight);
gg.setColor(Color.black);
}
else
{
- currentColor = av.getSequenceColour(sequence);
+ currentColor = ColorUtils
+ .getColor(av.getSequenceColour(sequence));
currentTextColor = Color.black;
}
import jalview.schemabinding.version2.UserColours;
import jalview.schemabinding.version2.Viewport;
import jalview.schemes.AnnotationColourGradient;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ColourSchemeProperty;
import jalview.schemes.FeatureColour;
sg.setOutlineColour(new java.awt.Color(jGroup.getOutlineColour()));
- sg.textColour = new java.awt.Color(jGroup.getTextCol1());
- sg.textColour2 = new java.awt.Color(jGroup.getTextCol2());
+ sg.textColour = new Colour(jGroup.getTextCol1());
+ sg.textColour2 = new Colour(jGroup.getTextCol2());
sg.setShowNonconserved(jGroup.hasShowUnconserved() ? jGroup
.isShowUnconserved() : false);
sg.thresholdTextColour = jGroup.getTextColThreshold();
for (int i = 0; i < JSEQ.length; i++)
{
af.viewport.setSequenceColour(af.viewport.getAlignment()
- .getSequenceAt(i), new java.awt.Color(JSEQ[i].getColour()));
+ .getSequenceAt(i), new Colour(JSEQ[i].getColour()));
}
if (al.hasSeqrep())
af.viewport.setShowText(view.getShowText());
- af.viewport.setTextColour(new java.awt.Color(view.getTextCol1()));
- af.viewport.setTextColour2(new java.awt.Color(view.getTextCol2()));
+ af.viewport.setTextColour(new Colour(view.getTextCol1()));
+ af.viewport.setTextColour2(new Colour(view.getTextCol2()));
af.viewport.setThresholdTextColour(view.getTextColThreshold());
af.viewport.setShowUnconserved(view.hasShowUnconserved() ? view
.isShowUnconserved() : false);
if (setting.hasMincolour())
{
FeatureColourI gc = setting.hasMin() ? new FeatureColour(
- new Color(setting.getMincolour()), new Color(
- setting.getColour()), setting.getMin(),
- setting.getMax()) : new FeatureColour(new Color(
- setting.getMincolour()), new Color(setting.getColour()),
+ new Colour(new Color(setting.getMincolour())),
+ new Colour(new Color(setting.getColour())),
+ setting.getMin(), setting.getMax()) : new FeatureColour(
+ new Colour(new Color(setting.getMincolour())),
+ new Colour(new Color(setting.getColour())),
0, 1);
if (setting.hasThreshold())
{
else
{
featureColours.put(setting.getType(), new FeatureColour(
- new Color(setting.getColour())));
+ new Colour(new Color(setting.getColour()))));
}
renderOrder[fs] = setting.getType();
if (setting.hasOrder())
import jalview.binding.UserColours;
import jalview.binding.Viewport;
import jalview.datamodel.PDBEntry;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ColourSchemeProperty;
import jalview.schemes.ResidueProperties;
for (int i = 0; i < JSEQ.length; i++)
{
af.viewport.setSequenceColour(af.viewport.getAlignment()
- .getSequenceAt(i), new java.awt.Color(JSEQ[i].getColour()));
+ .getSequenceAt(i), new Colour(JSEQ[i].getColour()));
}
// af.changeColour() );
import jalview.datamodel.SequenceI;
import jalview.datamodel.SequencePoint;
import jalview.math.RotatableMatrix;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import jalview.viewmodel.AlignmentViewport;
addMouseWheelListener(new MouseWheelListener()
{
+ @Override
public void mouseWheelMoved(MouseWheelEvent e)
{
if (e.getWheelRotation() > 0)
boolean first = true;
+ @Override
public void setPoints(Vector points, int npoint)
{
this.points = points;
dim = height;
}
- return (float) ((dim * scalefactor) / (2 * maxwidth));
+ return (dim * scalefactor) / (2 * maxwidth);
}
/**
*
* @return DOCUMENT ME!
*/
+ @Override
public Dimension getPreferredSize()
{
if (prefsize != null)
*
* @return DOCUMENT ME!
*/
+ @Override
public Dimension getMinimumSize()
{
return getPreferredSize();
* @param g
* DOCUMENT ME!
*/
+ @Override
public void paintComponent(Graphics g1)
{
for (int i = 0; i < npoint; i++)
{
SequencePoint sp = (SequencePoint) points.elementAt(i);
- int x = (int) ((float) (sp.coord[0] - centre[0]) * scale) + halfwidth;
- int y = (int) ((float) (sp.coord[1] - centre[1]) * scale)
+ int x = (int) ((sp.coord[0] - centre[0]) * scale) + halfwidth;
+ int y = (int) ((sp.coord[1] - centre[1]) * scale)
+ halfheight;
float z = sp.coord[1] - centre[2];
}
else
{
- g.setColor(av.getSequenceColour(sp.sequence));
+ g.setColor(ColorUtils.getColor(av.getSequenceColour(sp.sequence)));
}
if (av.getSelectionGroup() != null)
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void keyTyped(KeyEvent evt)
{
}
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void keyReleased(KeyEvent evt)
{
}
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void keyPressed(KeyEvent evt)
{
if (evt.getKeyCode() == KeyEvent.VK_UP)
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void mouseClicked(MouseEvent evt)
{
}
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void mouseEntered(MouseEvent evt)
{
}
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void mouseExited(MouseEvent evt)
{
}
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void mouseReleased(MouseEvent evt)
{
}
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void mousePressed(MouseEvent evt)
{
int x = evt.getX();
// controller.handleSequenceSelectionEvent(new
// SequenceSelectionEvent(this,sel));
// }
+ @Override
public void mouseMoved(MouseEvent evt)
{
SequenceI found = findPoint(evt.getX(), evt.getY());
* @param evt
* DOCUMENT ME!
*/
+ @Override
public void mouseDragged(MouseEvent evt)
{
mx = evt.getX();
{
rotmat.setIdentity();
- rotmat.rotate((float) (my - omy), 'x');
- rotmat.rotate((float) (mx - omx), 'y');
+ rotmat.rotate(my - omy, 'x');
+ rotmat.rotate(mx - omx, 'y');
for (int i = 0; i < npoint; i++)
{
for (int i = 0; i < npoint; i++)
{
SequencePoint sp = (SequencePoint) points.elementAt(i);
- int tmp1 = (int) (((sp.coord[0] - centre[0]) * scale) + ((float) getWidth() / 2.0));
- int tmp2 = (int) (((sp.coord[1] - centre[1]) * scale) + ((float) getHeight() / 2.0));
+ int tmp1 = (int) (((sp.coord[0] - centre[0]) * scale) + (getWidth() / 2.0));
+ int tmp2 = (int) (((sp.coord[1] - centre[1]) * scale) + (getHeight() / 2.0));
if ((tmp1 > x1) && (tmp1 < x2) && (tmp2 > y1) && (tmp2 < y2))
{
for (int i = 0; i < npoint; i++)
{
SequencePoint sp = (SequencePoint) points.elementAt(i);
- int px = (int) ((float) (sp.coord[0] - centre[0]) * scale)
+ int px = (int) ((sp.coord[0] - centre[0]) * scale)
+ halfwidth;
- int py = (int) ((float) (sp.coord[1] - centre[1]) * scale)
+ int py = (int) ((sp.coord[1] - centre[1]) * scale)
+ halfheight;
if ((Math.abs(px - x) < 3) && (Math.abs(py - y) < 3))
import jalview.datamodel.SequenceI;
import jalview.renderer.ScaleRenderer;
import jalview.renderer.ScaleRenderer.ScaleMark;
+import jalview.util.ColorUtils;
import java.awt.BasicStroke;
import java.awt.BorderLayout;
else
{
g.setStroke(new BasicStroke());
- g.setColor(group.getOutlineColour());
+ g.setColor(ColorUtils.getColor(group.getOutlineColour()));
}
}
}
*/
package jalview.gui;
+import jalview.api.ColorI;
import jalview.api.FeatureRenderer;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
+import jalview.util.ColorUtils;
import java.awt.Color;
import java.awt.FontMetrics;
}
@Override
- public Color getResidueBoxColour(SequenceI seq, int i)
+ public ColorI getResidueBoxColour(SequenceI seq, int i)
{
// rate limiting step when rendering overview for lots of groups
allGroups = av.getAlignment().findAllGroups(seq);
getBoxColour(av.getGlobalColourScheme(), seq, i);
}
- return resBoxColour;
+ return new Colour(resBoxColour);
}
/**
* @return
*/
@Override
- public Color getResidueColour(final SequenceI seq, int position,
+ public ColorI getResidueColour(final SequenceI seq, int position,
FeatureRenderer fr)
{
// TODO replace 8 or so code duplications with calls to this method
// (refactored as needed)
- Color col = getResidueBoxColour(seq, position);
+ ColorI col = getResidueBoxColour(seq, position);
if (fr != null)
{
{
end = seq.getLength() - 1;
}
- graphics.setColor(av.getTextColour());
+ graphics.setColor(ColorUtils.getColor(av.getTextColour()));
if (monospacedFont && av.getShowText() && allGroups.length == 0
&& !av.getColourText() && av.getThresholdTextColour() == 0)
for (int i = start; i <= end; i++)
{
- graphics.setColor(av.getTextColour());
+ graphics.setColor(ColorUtils.getColor(av.getTextColour()));
getboxColour = false;
s = seq.getCharAt(i);
if (resBoxColour.getRed() + resBoxColour.getBlue()
+ resBoxColour.getGreen() < currentSequenceGroup.thresholdTextColour)
{
- graphics.setColor(currentSequenceGroup.textColour2);
+ graphics.setColor(ColorUtils.getColor(currentSequenceGroup.textColour2));
}
}
}
else
{
- graphics.setColor(currentSequenceGroup.textColour);
+ graphics.setColor(ColorUtils.getColor(currentSequenceGroup.textColour));
}
if (!isarep && !isgrep
&& currentSequenceGroup.getShowNonconserved()) // todo
if (resBoxColour.getRed() + resBoxColour.getBlue()
+ resBoxColour.getGreen() < av.getThresholdTextColour())
{
- graphics.setColor(av.getTextColour2());
+ graphics.setColor(ColorUtils.getColor(av.getTextColour2()));
}
}
if (!isarep && av.getShowUnconserved())
package jalview.gui;
import jalview.datamodel.SequenceGroup;
+import jalview.schemes.Colour;
import jalview.util.MessageManager;
import java.awt.BorderLayout;
{
if (sg == null)
{
- ap.av.setTextColour(new Color(original1));
- ap.av.setTextColour2(new Color(original2));
+ ap.av.setTextColour(new Colour(original1));
+ ap.av.setTextColour2(new Colour(original2));
ap.av.setThresholdTextColour(originalThreshold);
}
else
{
- sg.textColour = new Color(original1);
- sg.textColour2 = new Color(original2);
+ sg.textColour = new Colour(original1);
+ sg.textColour2 = new Colour(original2);
sg.thresholdTextColour = originalThreshold;
}
}
{
if (sg == null)
{
- ap.av.setTextColour(col);
+ ap.av.setTextColour(new Colour(col));
if (ap.av.getColourAppliesToAllGroups())
{
setGroupTextColour();
}
else
{
- sg.textColour = col;
+ sg.textColour = new Colour(col);
}
ap.paintAlignment(true);
{
if (sg == null)
{
- ap.av.setTextColour2(col);
+ ap.av.setTextColour2(new Colour(col));
if (ap.av.getColourAppliesToAllGroups())
{
setGroupTextColour();
}
else
{
- sg.textColour2 = col;
+ sg.textColour2 = new Colour(col);
}
ap.paintAlignment(true);
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.datamodel.SequenceNode;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ColourSchemeProperty;
import jalview.schemes.ResidueProperties;
import jalview.schemes.UserColourScheme;
import jalview.structure.SelectionSource;
+import jalview.util.ColorUtils;
import jalview.util.Format;
import jalview.util.MappingUtils;
import jalview.util.MessageManager;
}
else
{
- g.setColor(av.getSequenceColour(seq).darker());
+ g.setColor(ColorUtils.getColor(av.getSequenceColour(seq))
+ .darker());
}
}
else
for (int a = 0; a < aps.length; a++)
{
final SequenceI seq = (SequenceI) node.element();
- aps[a].av.setSequenceColour(seq, c);
+ aps[a].av.setSequenceColour(seq, new Colour(c));
}
}
}
codingComplement.getAlignment().addGroup(mappedGroup);
for (SequenceI seq : mappedGroup.getSequences())
{
- codingComplement.setSequenceColour(seq, col.brighter());
+ codingComplement.setSequenceColour(seq,
+ new Colour(col.brighter()));
}
}
}
import jalview.datamodel.HiddenSequences;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.ColourSchemeProperty;
import jalview.schemes.ResidueProperties;
}
else if (key.equalsIgnoreCase("textCol1"))
{
- sg.textColour = new UserColourScheme(value).findColour('A');
+ sg.textColour = new Colour(
+ new UserColourScheme(value).findColour('A'));
}
else if (key.equalsIgnoreCase("textCol2"))
{
- sg.textColour2 = new UserColourScheme(value).findColour('A');
+ sg.textColour2 = new Colour(
+ new UserColourScheme(value).findColour('A'));
}
else if (key.equalsIgnoreCase("textColThreshold"))
{
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.StringTokenizer;
/**
* Parses and writes features files, which may be in Jalview, GFF2 or GFF3
}
/**
+ * Process a feature type colour specification
+ *
+ * @param line
+ * the current input line (for error messages only)
+ * @param featureType
+ * the first token on the line
+ * @param gffColumns
+ * holds tokens on the line
+ * @param colours
+ * map to which to add derived colour specification
+ */
+ protected void parseFeatureColour(String line, String featureType,
+ String[] gffColumns, Map<String, FeatureColourI> colours)
+ {
+ FeatureColourI colour = null;
+ String colscheme = gffColumns[1];
+ if (colscheme.indexOf("|") > -1
+ || colscheme.trim().equalsIgnoreCase("label"))
+ {
+ colour = parseGraduatedColourScheme(line, colscheme);
+ }
+ else
+ {
+ UserColourScheme ucs = new UserColourScheme(colscheme);
+ colour = new FeatureColour(ucs.findColour('A'));
+ }
+ if (colour != null)
+ {
+ colours.put(featureType, colour);
+ }
+ }
+
+ /**
+ * Parse a Jalview graduated colour descriptor
+ *
+ * @param line
+ * @param colourDescriptor
+ * @return
+ */
+ protected FeatureColourI parseGraduatedColourScheme(String line,
+ String colourDescriptor)
+ {
+ // Parse '|' separated graduated colourscheme fields:
+ // [label|][mincolour|maxcolour|[absolute|]minvalue|maxvalue|thresholdtype|thresholdvalue]
+ // can either provide 'label' only, first is optional, next two
+ // colors are required (but may be
+ // left blank), next is optional, nxt two min/max are required.
+ // first is either 'label'
+ // first/second and third are both hexadecimal or word equivalent
+ // colour.
+ // next two are values parsed as floats.
+ // fifth is either 'above','below', or 'none'.
+ // sixth is a float value and only required when fifth is either
+ // 'above' or 'below'.
+ StringTokenizer gcol = new StringTokenizer(colourDescriptor, "|", true);
+ // set defaults
+ float min = Float.MIN_VALUE, max = Float.MAX_VALUE;
+ boolean labelCol = false;
+ // Parse spec line
+ String mincol = gcol.nextToken();
+ if (mincol == "|")
+ {
+ System.err
+ .println("Expected either 'label' or a colour specification in the line: "
+ + line);
+ return null;
+ }
+ String maxcol = null;
+ if (mincol.toLowerCase().indexOf("label") == 0)
+ {
+ labelCol = true;
+ mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null); // skip '|'
+ mincol = (gcol.hasMoreTokens() ? gcol.nextToken() : null);
+ }
+ String abso = null, minval, maxval;
+ if (mincol != null)
+ {
+ // at least four more tokens
+ if (mincol.equals("|"))
+ {
+ mincol = "";
+ }
+ else
+ {
+ gcol.nextToken(); // skip next '|'
+ }
+ // continue parsing rest of line
+ maxcol = gcol.nextToken();
+ if (maxcol.equals("|"))
+ {
+ maxcol = "";
+ }
+ else
+ {
+ gcol.nextToken(); // skip next '|'
+ }
+ abso = gcol.nextToken();
+ gcol.nextToken(); // skip next '|'
+ if (abso.toLowerCase().indexOf("abso") != 0)
+ {
+ minval = abso;
+ abso = null;
+ }
+ else
+ {
+ minval = gcol.nextToken();
+ gcol.nextToken(); // skip next '|'
+ }
+ maxval = gcol.nextToken();
+ if (gcol.hasMoreTokens())
+ {
+ gcol.nextToken(); // skip next '|'
+ }
+ try
+ {
+ if (minval.length() > 0)
+ {
+ min = Float.valueOf(minval);
+ }
+ } catch (Exception e)
+ {
+ System.err
+ .println("Couldn't parse the minimum value for graduated colour for type ("
+ + colourDescriptor
+ + ") - did you misspell 'auto' for the optional automatic colour switch ?");
+ e.printStackTrace();
+ }
+ try
+ {
+ if (maxval.length() > 0)
+ {
+ max = Float.valueOf(maxval);
+ }
+ } catch (Exception e)
+ {
+ System.err
+ .println("Couldn't parse the maximum value for graduated colour for type ("
+ + colourDescriptor + ")");
+ e.printStackTrace();
+ }
+ }
+ else
+ {
+ // add in some dummy min/max colours for the label-only
+ // colourscheme.
+ mincol = "FFFFFF";
+ maxcol = "000000";
+ }
+
+ FeatureColourI colour = null;
+ try
+ {
+ colour = new FeatureColour(
+ new UserColourScheme(mincol).findColour('A'),
+ new UserColourScheme(maxcol).findColour('A'), min, max);
+ } catch (Exception e)
+ {
+ System.err.println("Couldn't parse the graduated colour scheme ("
+ + colourDescriptor + ")");
+ e.printStackTrace();
+ }
+ if (colour != null)
+ {
+ colour.setColourByLabel(labelCol);
+ colour.setAutoScaled(abso == null);
+ // add in any additional parameters
+ String ttype = null, tval = null;
+ boolean hasThreshold = false;
+ if (gcol.hasMoreTokens())
+ {
+ // threshold type and possibly a threshold value
+ ttype = gcol.nextToken();
+ if (ttype.toLowerCase().startsWith("below"))
+ {
+ colour.setBelowThreshold(true);
+ hasThreshold = true;
+ }
+ else if (ttype.toLowerCase().startsWith("above"))
+ {
+ colour.setAboveThreshold(true);
+ hasThreshold = true;
+ }
+ else
+ {
+ if (!ttype.toLowerCase().startsWith("no"))
+ {
+ System.err.println("Ignoring unrecognised threshold type : "
+ + ttype);
+ }
+ }
+ }
+ if (hasThreshold)
+ {
+ try
+ {
+ gcol.nextToken();
+ tval = gcol.nextToken();
+ colour.setThreshold(new Float(tval).floatValue());
+ } catch (Exception e)
+ {
+ System.err.println("Couldn't parse threshold value as a float: ("
+ + tval + ")");
+ e.printStackTrace();
+ }
+ }
+ // parse the thresh-is-min token ?
+ if (gcol.hasMoreTokens())
+ {
+ System.err
+ .println("Ignoring additional tokens in parameters in graduated colour specification\n");
+ while (gcol.hasMoreTokens())
+ {
+ System.err.println("|" + gcol.nextToken());
+ }
+ System.err.println("\n");
+ }
+ }
+ return colour;
+ }
+
+ /**
* clear any temporary handles used to speed up ID matching
*/
protected void resetMatcher()
*
* @param sequences
* source of features
- * @param visible
+ * @param featureColours
* hash of Colours for each feature type
* @param visOnly
* when true only feature types in 'visible' will be output
* @return features file contents
*/
public String printJalviewFormat(SequenceI[] sequences,
- Map<String, FeatureColourI> visible, boolean visOnly,
+ Map<String, FeatureColourI> featureColours, boolean visOnly,
boolean nonpos)
{
StringBuilder out = new StringBuilder(256);
boolean featuresGen = false;
- if (visOnly && !nonpos && (visible == null || visible.size() < 1))
+ if (visOnly && !nonpos
+ && (featureColours == null || featureColours.size() < 1))
{
// no point continuing.
return "No Features Visible";
}
- if (visible != null && visOnly)
+ if (featureColours != null && visOnly)
{
// write feature colours only if we're given them and we are generating
// viewed features
// TODO: decide if feature links should also be written here ?
- Iterator<String> en = visible.keySet().iterator();
+ Iterator<String> en = featureColours.keySet().iterator();
while (en.hasNext())
{
- String featureType = en.next().toString();
- FeatureColourI colour = visible.get(featureType);
+ String featureType = en.next();
+ FeatureColourI colour = featureColours.get(featureType);
out.append(colour.toJalviewFormat(featureType)).append(newline);
}
}
{
isnonpos = features[j].begin == 0 && features[j].end == 0;
if ((!nonpos && isnonpos)
- || (!isnonpos && visOnly && !visible
+ || (!isnonpos && visOnly && !featureColours
.containsKey(features[j].type)))
{
continue;
{
isnonpos = sequenceFeature.begin == 0 && sequenceFeature.end == 0;
if ((!nonpos && isnonpos)
- || (!isnonpos && visOnly && !visible
+ || (!isnonpos && visOnly && !featureColours
.containsKey(sequenceFeature.type)))
{
// skip if feature is nonpos and we ignore them or if we only
*
* @param sequences
* the sequences whose features are to be output
- * @param visible
+ * @param featureColours
* a map whose keys are the type names of visible features
* @param outputVisibleOnly
* @param includeNonPositionalFeatures
* @return
*/
public String printGffFormat(SequenceI[] sequences,
- Map<String, FeatureColourI> visible, boolean outputVisibleOnly,
+ Map<String, FeatureColourI> featureColours,
+ boolean outputVisibleOnly,
boolean includeNonPositionalFeatures)
{
StringBuilder out = new StringBuilder(256);
// TODO why the test !isnonpos here?
// what about not visible non-positional features?
if (!isnonpos && outputVisibleOnly
- && !visible.containsKey(sf.type))
+ && !featureColours.containsKey(sf.type))
{
/*
* ignore not visible features if not wanted
*/
package jalview.io;
+import jalview.api.ColorI;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SequenceI;
import jalview.gui.AlignViewport;
import jalview.gui.AlignmentPanel;
import jalview.gui.FeatureRenderer;
import jalview.gui.SequenceRenderer;
+import jalview.schemes.Colour;
import jalview.util.MessageManager;
-import java.awt.Color;
import java.awt.Font;
import java.io.PrintWriter;
jalview.renderer.seqfeatures.FeatureRenderer fr;
- Color color;
+ ColorI color;
public HTMLOutput(AlignmentPanel ap, SequenceRenderer sr,
FeatureRenderer fr1)
}
else
{
- color = Color.white;
+ color = Colour.white;
}
if (color.getRGB() < -1)
}
else
{
- color = Color.white;
+ color = Colour.white;
}
if (color.getRGB() < -1)
import jalview.gui.IProgressIndicator;
import jalview.gui.OOMWarning;
import jalview.math.AlignmentDimension;
+import jalview.util.ColorUtils;
import jalview.util.MessageManager;
import java.awt.Color;
}
else
{
- currentColor = av.getSequenceColour(seq);
+ currentColor = ColorUtils.getColor(av.getSequenceColour(seq));
currentTextColor = Color.black;
}
pg[0].setColor(currentColor);
import jalview.json.binding.biojson.v1.SequenceFeaturesPojo;
import jalview.json.binding.biojson.v1.SequenceGrpPojo;
import jalview.json.binding.biojson.v1.SequencePojo;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeProperty;
import jalview.schemes.UserColourScheme;
import jalview.viewmodel.seqfeatures.FeaturesDisplayed;
String.valueOf(seq.hashCode()));
String featureColour = (fr == null) ? null : jalview.util.Format
- .getHexString(fr.findFeatureColour(Color.white, seq,
+ .getHexString(fr.findFeatureColour(Colour.white, seq,
seq.findIndex(sf.getBegin())));
jsonFeature.setXstart(seq.findIndex(sf.getBegin()) - 1);
jsonFeature.setXend(seq.findIndex(sf.getEnd()));
package jalview.io;
+import jalview.api.ColorI;
import jalview.api.FeatureColourI;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
import jalview.schemes.FeatureSettingsAdapter;
-import java.awt.Color;
-
public class PDBFeatureSettings extends FeatureSettingsAdapter
{
{
@Override
- public Color getColour()
+ public ColorI getColour()
{
- return Color.RED;
+ return Colour.red;
}
};
}
package jalview.renderer.seqfeatures;
import jalview.api.AlignViewportI;
+import jalview.api.ColorI;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.viewmodel.seqfeatures.FeatureRendererModel;
import java.awt.AlphaComposite;
BufferedImage offscreenImage;
@Override
- public Color findFeatureColour(Color initialCol, SequenceI seq, int res)
+ public ColorI findFeatureColour(ColorI initialCol, SequenceI seq, int res)
{
- return new Color(findFeatureColour(initialCol.getRGB(), seq, res));
+ return new Colour(findFeatureColour(initialCol.getRGB(), seq, res));
+ }
+
+ public ColorI findFeatureColour(Color initialCol, SequenceI seq, int res)
+ {
+ return findFeatureColour(new Colour(initialCol), seq, res);
}
/**
--- /dev/null
+package jalview.schemes;
+
+import jalview.api.ColorI;
+
+import java.awt.Color;
+
+public class Colour implements ColorI
+{
+ public static final ColorI lightGray = new Colour(Color.lightGray);
+
+ public static final ColorI gray = new Colour(Color.gray);
+
+ public static final ColorI blue = new Colour(Color.blue);
+
+ public static final ColorI yellow = new Colour(Color.yellow);
+
+ public static final ColorI red = new Colour(Color.red);
+
+ public static final ColorI black = new Colour(Color.black);
+
+ public static final ColorI white = new Colour(Color.white);
+
+ public static final ColorI pink = new Colour(Color.pink);
+
+ public static final ColorI green = new Colour(Color.green);
+
+ public static final ColorI magenta = new Colour(Color.magenta);
+
+ public static final ColorI orange = new Colour(Color.orange);
+
+ private int greenValue;
+
+ private int blueValue;
+
+ private int redValue;
+
+ public Colour(Color c)
+ {
+ this(c.getRed(), c.getGreen(), c.getBlue());
+ }
+
+ /**
+ * Constructor given RGB values in the range 0-255
+ *
+ * @param r
+ * @param g
+ * @param b
+ */
+ public Colour(int r, int g, int b)
+ {
+ redValue = r;
+ greenValue = g;
+ blueValue = b;
+ }
+
+ /**
+ * Constructor given an rgb value
+ *
+ * @param rgb
+ */
+ public Colour(int rgb)
+ {
+ this((rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, (rgb >> 0) & 0xFF);
+ }
+
+ /**
+ * Constructor given RGB values in the range 0-1
+ *
+ * @param r
+ * @param g
+ * @param b
+ */
+ public Colour(float r, float g, float b)
+ {
+ this((int) (r * 255 + 0.5), (int) (g * 255 + 0.5),
+ (int) (b * 255 + 0.5));
+ }
+
+ @Override
+ public int getGreen()
+ {
+ return greenValue;
+ }
+
+ @Override
+ public int getBlue()
+ {
+ return blueValue;
+ }
+
+ @Override
+ public int getRed()
+ {
+ return redValue;
+ }
+
+ /**
+ *
+ * @see java.awt.Color#Color(int, int, int, int)
+ */
+ @Override
+ public int getRGB()
+ {
+ int value = ((255 & 0xFF) << 24) |
+ ((redValue & 0xFF) << 16) |
+ ((greenValue & 0xFF) << 8) |
+ ((blueValue & 0xFF) << 0);
+ return value;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return getRGB();
+ }
+
+ @Override
+ public boolean equals(Object obj)
+ {
+ if (obj instanceof Colour)
+ {
+ return getRGB() == ((Colour) obj).getRGB();
+ }
+ return false;
+ }
+
+}
package jalview.schemes;
+import jalview.api.ColorI;
import jalview.api.FeatureColourI;
import jalview.datamodel.SequenceFeature;
import jalview.util.Format;
{
private static final String BAR = "|";
- final private Color colour;
+ final private ColorI colour;
- final private Color minColour;
+ final private ColorI minColour;
- final private Color maxColour;
+ final private ColorI maxColour;
private boolean graduatedColour;
throw new IllegalArgumentException("Invalid colour descriptor: "
+ descriptor);
}
- return new FeatureColour(colour);
+ return new FeatureColour(new Colour(colour));
}
/*
- * autoScaled == true: colours range over actual score range
+ * autoScaled == true: colours range over actual score range;
* autoScaled == false ('abso'): colours range over min/max range
*/
boolean autoScaled = true;
FeatureColour featureColour;
try
{
- featureColour = new FeatureColour(
- new UserColourScheme(mincol).findColour('A'),
- new UserColourScheme(maxcol).findColour('A'), min, max);
+ featureColour = new FeatureColour(new Colour(new UserColourScheme(
+ mincol).findColour('A')), new Colour(new UserColourScheme(
+ maxcol).findColour('A')), min, max);
featureColour.setColourByLabel(labelColour);
featureColour.setAutoScaled(autoScaled);
// add in any additional parameters
*/
public FeatureColour()
{
- this((Color) null);
+ this((ColorI) null);
}
/**
*
* @param c
*/
- public FeatureColour(Color c)
+ public FeatureColour(ColorI c)
{
- minColour = Color.WHITE;
- maxColour = Color.BLACK;
+ minColour = new Colour(Color.WHITE);
+ maxColour = new Colour(Color.BLACK);
minRed = 0f;
minGreen = 0f;
minBlue = 0f;
colour = c;
}
+ public FeatureColour(Color c)
+ {
+ this(new Colour(c));
+ }
+
/**
* Constructor given a colour range and a score range
*
* @param min
* @param max
*/
- public FeatureColour(Color low, Color high, float min, float max)
+ public FeatureColour(ColorI low, ColorI high, float min, float max)
{
graduatedColour = true;
colour = null;
}
}
+ public FeatureColour(Color low, Color high, float min, float max)
+ {
+ this(new Colour(low), new Colour(high), min, max);
+ }
/**
* Copy constructor
*
*/
public FeatureColour(FeatureColour fc)
{
- graduatedColour = fc.graduatedColour;
colour = fc.colour;
minColour = fc.minColour;
maxColour = fc.maxColour;
return graduatedColour;
}
- /**
- * Sets the 'graduated colour' flag. If true, also sets 'colour by label' to
- * false.
- */
- void setGraduatedColour(boolean b)
- {
- graduatedColour = b;
- if (b)
- {
- setColourByLabel(false);
- }
- }
-
@Override
- public Color getColour()
+ public ColorI getColour()
{
return colour;
}
@Override
- public Color getMinColour()
+ public ColorI getMinColour()
{
return minColour;
}
@Override
- public Color getMaxColour()
+ public ColorI getMaxColour()
{
return maxColour;
}
setGraduatedColour(false);
}
}
+
+ /**
+ * Sets the 'graduated colour' flag. If true, also sets 'colour by label' to
+ * false.
+ */
+ void setGraduatedColour(boolean b)
+ {
+ graduatedColour = b;
+ if (b)
+ {
+ setColourByLabel(false);
+ }
+ }
+
@Override
public boolean isBelowThreshold()
{
* @return
*/
@Override
- public Color getColor(SequenceFeature feature)
+ public ColorI getColor(SequenceFeature feature)
{
if (isColourByLabel())
{
- return UserColourScheme
- .createColourFromName(feature.getDescription());
+ return new Colour(UserColourScheme.createColourFromName(feature
+ .getDescription()));
}
if (!isGraduatedColour())
{
scl = 1f;
}
- return new Color(minRed + scl * deltaRed, minGreen + scl * deltaGreen, minBlue + scl * deltaBlue);
+ return new Colour(new Color(minRed + scl * deltaRed, minGreen + scl
+ * deltaGreen, minBlue + scl * deltaBlue));
}
/**
--- /dev/null
+package jalview.schemes;
+
+import jalview.api.ColorI;
+import jalview.api.FeatureColourI;
+import jalview.datamodel.SequenceFeature;
+
+/**
+ * A convenience class with implementations of FeatureColourI methods. Override
+ * methods as required in subclasses.
+ */
+public class FeatureColourAdapter implements FeatureColourI
+{
+ @Override
+ public boolean isGraduatedColour()
+ {
+ return isColourByLabel() || isAboveThreshold() || isBelowThreshold();
+ }
+
+ @Override
+ public ColorI getColour()
+ {
+ return Colour.black;
+ }
+
+ @Override
+ public ColorI getMinColour()
+ {
+ return Colour.white;
+ }
+
+ @Override
+ public ColorI getMaxColour()
+ {
+ return Colour.black;
+ }
+
+ @Override
+ public boolean isColourByLabel()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean isBelowThreshold()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean isAboveThreshold()
+ {
+ return false;
+ }
+
+ @Override
+ public boolean isThresholdMinMax()
+ {
+ return false;
+ }
+
+ @Override
+ public float getThreshold()
+ {
+ return 0f;
+ }
+
+ @Override
+ public float getMax()
+ {
+ return 0;
+ }
+
+ @Override
+ public float getMin()
+ {
+ return 0;
+ }
+
+ @Override
+ public boolean hasThreshold()
+ {
+ return false;
+ }
+
+ @Override
+ public ColorI getColor(SequenceFeature feature)
+ {
+ return null;
+ }
+
+ @Override
+ public boolean isColored(SequenceFeature feature)
+ {
+ return false;
+ }
+
+ @Override
+ public void updateBounds(float min, float max)
+ {
+ }
+
+ @Override
+ public String toJalviewFormat(String featureType)
+ {
+ return null;
+ }
+
+ @Override
+ public void setThreshold(float f)
+ {
+ }
+
+ @Override
+ public boolean isAutoScaled()
+ {
+ return false;
+ }
+
+ @Override
+ public void setAutoScaled(boolean b)
+ {
+ }
+
+ @Override
+ public boolean isSimpleColour()
+ {
+ return false;
+ }
+
+ @Override
+ public void setAboveThreshold(boolean b)
+ {
+ }
+
+ @Override
+ public void setThresholdMinMax(boolean b)
+ {
+ }
+
+ @Override
+ public void setBelowThreshold(boolean b)
+ {
+ }
+
+ @Override
+ public void setColourByLabel(boolean b)
+ {
+ }
+
+}
package jalview.util;
+import jalview.api.ColorI;
+
import java.awt.Color;
import java.util.Random;
public class ColorUtils
{
+ public static Color getColor(ColorI c)
+ {
+ return new Color(c.getRed(), c.getGreen(), c.getBlue());
+ }
/**
* Generates a random color, will mix with input color. Code taken from
* http://stackoverflow
* ://www.cgl.ucsf.edu/chimera/current/docs/UsersGuide/colortool.html#
* tkcode
*/
- public static final String toTkCode(Color colour)
+ public static final String toTkCode(ColorI colour)
{
String colstring = "#" + ((colour.getRed() < 16) ? "0" : "")
+ Integer.toHexString(colour.getRed())
*/
package jalview.util;
+import jalview.api.ColorI;
+
+import java.awt.Color;
+
/**
* DOCUMENT ME!
*
* if bad format
*
*/
- public static String getHexString(java.awt.Color color)
+ public static String getHexString(final Color c)
+ {
+ return getHexString(new ColorI()
+ {
+
+ @Override
+ public int getRed()
+ {
+ return c.getRed();
+ }
+
+ @Override
+ public int getGreen()
+ {
+ return c.getGreen();
+ }
+
+ @Override
+ public int getBlue()
+ {
+ return c.getBlue();
+ }
+
+ @Override
+ public int getRGB()
+ {
+ return c.getRGB();
+ }
+ });
+ }
+ public static String getHexString(ColorI color)
{
String r;
String g;
import jalview.api.AlignCalcManagerI;
import jalview.api.AlignViewportI;
import jalview.api.AlignmentViewPanel;
+import jalview.api.ColorI;
import jalview.api.FeaturesDisplayedI;
import jalview.api.ViewStyleI;
import jalview.commands.CommandI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
import jalview.schemes.Blosum62ColourScheme;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.PIDColourScheme;
import jalview.schemes.ResidueProperties;
import jalview.workers.ConsensusThread;
import jalview.workers.StrucConsensusThread;
-import java.awt.Color;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.BitSet;
protected boolean showConsensus = true;
- private Map<SequenceI, Color> sequenceColours = new HashMap<SequenceI, Color>();
+ private Map<SequenceI, ColorI> sequenceColours = new HashMap<SequenceI, ColorI>();
protected SequenceAnnotationOrder sortAnnotationsBy = null;
}
@Override
- public Color getSequenceColour(SequenceI seq)
+ public ColorI getSequenceColour(SequenceI seq)
{
- Color sqc = sequenceColours.get(seq);
- return (sqc == null ? Color.white : sqc);
+ ColorI sqc = sequenceColours.get(seq);
+ return (sqc == null ? Colour.white : sqc);
}
@Override
- public void setSequenceColour(SequenceI seq, Color col)
+ public void setSequenceColour(SequenceI seq, ColorI col)
{
if (col == null)
{
* @see jalview.api.ViewStyleI#getTextColour()
*/
@Override
- public Color getTextColour()
+ public ColorI getTextColour()
{
return viewStyle.getTextColour();
}
* @see jalview.api.ViewStyleI#getTextColour2()
*/
@Override
- public Color getTextColour2()
+ public ColorI getTextColour2()
{
return viewStyle.getTextColour2();
}
* @see jalview.api.ViewStyleI#setTextColour(java.awt.Color)
*/
@Override
- public void setTextColour(Color textColour)
+ public void setTextColour(ColorI textColour)
{
viewStyle.setTextColour(textColour);
}
* @see jalview.api.ViewStyleI#setTextColour2(java.awt.Color)
*/
@Override
- public void setTextColour2(Color textColour2)
+ public void setTextColour2(ColorI textColour2)
{
viewStyle.setTextColour2(textColour2);
}
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.renderer.seqfeatures.FeatureRenderer;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
import jalview.schemes.UserColourScheme;
+import jalview.util.ColorUtils;
import java.awt.Color;
import java.beans.PropertyChangeListener;
protected AlignViewportI av;
+ /*
+ * map holds per feature type, {{min, max}, {min, max}} feature score
+ * values for positional and non-positional features respectively
+ */
+ private Map<String, float[][]> minmax = new Hashtable<String, float[][]>();
+
@Override
public AlignViewportI getViewport()
{
renderOrder = neworder;
}
- protected Map<String, float[][]> minmax = new Hashtable<String, float[][]>();
-
public Map<String, float[][]> getMinMax()
{
return minmax;
if (fc == null)
{
Color col = UserColourScheme.createColourFromName(featureType);
- fc = new FeatureColour(col);
+ fc = new FeatureColour(new Colour(col));
featureColours.put(featureType, fc);
}
return fc;
public Color getColour(SequenceFeature feature)
{
FeatureColourI fc = getFeatureStyle(feature.getType());
- return fc.getColor(feature);
+ return ColorUtils.getColor(fc.getColor(feature));
}
protected boolean showFeature(SequenceFeature sequenceFeature)
return renderOrder != null;
}
- /**
- * Returns feature types in ordering of rendering, where last means on top
- */
public List<String> getRenderOrder()
{
if (renderOrder == null)
* @return list of groups
*/
@Override
- public List getGroups(boolean visible)
+ public List<String> getGroups(boolean visible)
{
if (featureGroups != null)
{
return av.getFeaturesDisplayed();
}
- /**
- * Returns a (possibly empty) list of visible feature types, in render order
- * (last is on top)
- */
@Override
public List<String> getDisplayedFeatureTypes()
{
{
String next = en.next();
FeatureColourI val = featureColours.get(next);
- // if (val instanceof GraduatedColor)
- if (val.isGraduatedColour() || val.isColourByLabel()) // why this test?
+ if (!val.isSimpleColour())
{
featureColours.put(next, new FeatureColour((FeatureColour) val));
}
*/
package jalview.viewmodel.styles;
+import jalview.api.ColorI;
import jalview.api.ViewStyleI;
-
-import java.awt.Color;
+import jalview.schemes.Colour;
/**
* A container for holding alignment view properties. View properties are
*/
protected boolean showUnconserved = false;
- Color textColour = Color.black;
+ ColorI textColour = Colour.black;
- Color textColour2 = Color.white;
+ ColorI textColour2 = Colour.white;
/**
* PID or consensus threshold
* @return the textColour
*/
@Override
- public Color getTextColour()
+ public ColorI getTextColour()
{
return textColour;
}
* @return the textColour2
*/
@Override
- public Color getTextColour2()
+ public ColorI getTextColour2()
{
return textColour2;
}
* the textColour to set
*/
@Override
- public void setTextColour(Color textColour)
+ public void setTextColour(ColorI textColour)
{
this.textColour = textColour;
}
* the textColour2 to set
*/
@Override
- public void setTextColour2(Color textColour2)
+ public void setTextColour2(ColorI textColour2)
{
this.textColour2 = textColour2;
}
*/
package jalview.ws.jws2;
-import jalview.api.AlignCalcWorkerI;
import jalview.api.FeatureColourI;
import jalview.bin.Cache;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.gui.AlignFrame;
+import jalview.schemes.Colour;
import jalview.schemes.FeatureColour;
import jalview.schemes.UserColourScheme;
import jalview.ws.jws2.jabaws2.Jws2Instance;
{
// set graduated color as fading to white for minimum, and
// autoscaling to values on alignment
- FeatureColourI ggc = new FeatureColour(Color.white,
+ FeatureColourI ggc = new FeatureColour(
+ new Colour(Color.white),
gc.getColour(), Float.MIN_VALUE, Float.MAX_VALUE);
ggc.setAutoScaled(true);
fr.setColour(ft, ggc);
import static org.testng.AssertJUnit.assertTrue;
import jalview.analysis.AlignSeq;
+import jalview.api.ColorI;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.TaylorColourScheme;
import jalview.structure.StructureImportSettings;
c.makeBond(a2, a3);
c.setChainColours(Color.PINK);
assertEquals(2, c.bonds.size());
- assertEquals(Color.PINK, c.bonds.get(0).startCol);
- assertEquals(Color.PINK, c.bonds.get(0).endCol);
- assertEquals(Color.PINK, c.bonds.get(1).startCol);
- assertEquals(Color.PINK, c.bonds.get(1).endCol);
+ assertEquals(Colour.pink, c.bonds.get(0).startCol);
+ assertEquals(Colour.pink, c.bonds.get(0).endCol);
+ assertEquals(Colour.pink, c.bonds.get(1).startCol);
+ assertEquals(Colour.pink, c.bonds.get(1).endCol);
}
/**
@Test(groups = { "Functional" })
public void testSetChainColours_colourScheme()
{
- Color alaColour = new Color(204, 255, 0);
- Color glyColour = new Color(255, 153, 0);
+ ColorI alaColour = new Colour(204, 255, 0);
+ ColorI glyColour = new Colour(255, 153, 0);
a1.resName = "ALA";
a2.resName = "GLY";
a3.resName = "XXX"; // no colour defined
// bond a2 to a3 - no colour found for a3
// exception handling defaults to gray
b = c.bonds.get(2);
- assertEquals(Color.gray, b.startCol);
- assertEquals(Color.gray, b.endCol);
+ assertEquals(Colour.gray, b.startCol);
+ assertEquals(Colour.gray, b.endCol);
}
@Test(groups = { "Functional" })
public void testGetChargeColour()
{
- assertEquals(Color.red, PDBChain.getChargeColour("ASP"));
- assertEquals(Color.red, PDBChain.getChargeColour("GLU"));
- assertEquals(Color.blue, PDBChain.getChargeColour("LYS"));
- assertEquals(Color.blue, PDBChain.getChargeColour("ARG"));
- assertEquals(Color.yellow, PDBChain.getChargeColour("CYS"));
- assertEquals(Color.lightGray, PDBChain.getChargeColour("ALA"));
- assertEquals(Color.lightGray, PDBChain.getChargeColour(null));
+ assertEquals(Colour.red, PDBChain.getChargeColour("ASP"));
+ assertEquals(Colour.red, PDBChain.getChargeColour("GLU"));
+ assertEquals(Colour.blue, PDBChain.getChargeColour("LYS"));
+ assertEquals(Colour.blue, PDBChain.getChargeColour("ARG"));
+ assertEquals(Colour.yellow, PDBChain.getChargeColour("CYS"));
+ assertEquals(Colour.lightGray, PDBChain.getChargeColour("ALA"));
+ assertEquals(Colour.lightGray, PDBChain.getChargeColour(null));
}
/**
assertEquals(3, c.bonds.size());
// bond a1 to a2
Bond b = c.bonds.get(0);
- assertEquals(Color.red, b.startCol);
- assertEquals(Color.blue, b.endCol);
+ assertEquals(Colour.red, b.startCol);
+ assertEquals(Colour.blue, b.endCol);
// bond a2 to a3
b = c.bonds.get(1);
- assertEquals(Color.blue, b.startCol);
- assertEquals(Color.yellow, b.endCol);
+ assertEquals(Colour.blue, b.startCol);
+ assertEquals(Colour.yellow, b.endCol);
// bond a3 to a4
b = c.bonds.get(2);
- assertEquals(Color.yellow, b.startCol);
- assertEquals(Color.lightGray, b.endCol);
+ assertEquals(Colour.yellow, b.startCol);
+ assertEquals(Colour.lightGray, b.endCol);
}
/**
import jalview.datamodel.SequenceI;
import jalview.io.gff.SequenceOntologyFactory;
import jalview.io.gff.SequenceOntologyLite;
+import jalview.schemes.Colour;
import jalview.util.MapList;
-import java.awt.Color;
import java.util.List;
import org.testng.annotations.AfterClass;
assertTrue(fc.isFeatureDisplayed("sequence_variant"));
assertTrue(fc.isFeatureDisplayed("feature_variant")); // subtype
assertFalse(fc.isFeatureDisplayed("transcript"));
- assertEquals(Color.RED, fc.getFeatureColour("sequence_variant")
+ assertEquals(Colour.red, fc.getFeatureColour("sequence_variant")
.getColour());
- assertEquals(Color.RED, fc.getFeatureColour("feature_variant")
+ assertEquals(Colour.red, fc.getFeatureColour("feature_variant")
.getColour());
assertTrue(fc.getFeatureColour("exon").isColourByLabel());
assertTrue(fc.getFeatureColour("coding_exon").isColourByLabel());
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
-import java.awt.Color;
+import jalview.api.ColorI;
+import jalview.schemes.Colour;
+
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
@Test(groups = { "Functional" })
public void testAddColourRange()
{
- Map<Color, Map<Integer, Map<String, List<int[]>>>> map = new LinkedHashMap<Color, Map<Integer, Map<String, List<int[]>>>>();
- ChimeraCommands.addColourRange(map, Color.pink, 1, 2, 4, "A");
- ChimeraCommands.addColourRange(map, Color.pink, 1, 8, 8, "A");
- ChimeraCommands.addColourRange(map, Color.pink, 1, 5, 7, "B");
- ChimeraCommands.addColourRange(map, Color.red, 1, 3, 5, "A");
- ChimeraCommands.addColourRange(map, Color.red, 0, 1, 4, "B");
- ChimeraCommands.addColourRange(map, Color.orange, 0, 5, 9, "C");
+ Map<ColorI, Map<Integer, Map<String, List<int[]>>>> map = new LinkedHashMap<ColorI, Map<Integer, Map<String, List<int[]>>>>();
+ ChimeraCommands.addColourRange(map, Colour.pink, 1, 2, 4, "A");
+ ChimeraCommands.addColourRange(map, Colour.pink, 1, 8, 8, "A");
+ ChimeraCommands.addColourRange(map, Colour.pink, 1, 5, 7, "B");
+ ChimeraCommands.addColourRange(map, Colour.red, 1, 3, 5, "A");
+ ChimeraCommands.addColourRange(map, Colour.red, 0, 1, 4, "B");
+ ChimeraCommands.addColourRange(map, Colour.orange, 0, 5, 9, "C");
// three colours mapped
assertEquals(3, map.keySet().size());
// Red has two models, Pink and Orange one each
- assertEquals(2, map.get(Color.red).keySet().size());
- assertEquals(1, map.get(Color.orange).keySet().size());
- assertEquals(1, map.get(Color.pink).keySet().size());
+ assertEquals(2, map.get(Colour.red).keySet().size());
+ assertEquals(1, map.get(Colour.orange).keySet().size());
+ assertEquals(1, map.get(Colour.pink).keySet().size());
// pink model 1 has two chains, red.0 / red.1 / orange.0 one each
- assertEquals(2, map.get(Color.pink).get(1).keySet().size());
- assertEquals(1, map.get(Color.red).get(0).keySet().size());
- assertEquals(1, map.get(Color.red).get(1).keySet().size());
- assertEquals(1, map.get(Color.orange).get(0).keySet().size());
+ assertEquals(2, map.get(Colour.pink).get(1).keySet().size());
+ assertEquals(1, map.get(Colour.red).get(0).keySet().size());
+ assertEquals(1, map.get(Colour.red).get(1).keySet().size());
+ assertEquals(1, map.get(Colour.orange).get(0).keySet().size());
// inspect positions
- List<int[]> posList = map.get(Color.pink).get(1).get("A");
+ List<int[]> posList = map.get(Colour.pink).get(1).get("A");
assertEquals(2, posList.size());
assertTrue(Arrays.equals(new int[] { 2, 4 }, posList.get(0)));
assertTrue(Arrays.equals(new int[] { 8, 8 }, posList.get(1)));
- posList = map.get(Color.pink).get(1).get("B");
+ posList = map.get(Colour.pink).get(1).get("B");
assertEquals(1, posList.size());
assertTrue(Arrays.equals(new int[] { 5, 7 }, posList.get(0)));
- posList = map.get(Color.red).get(0).get("B");
+ posList = map.get(Colour.red).get(0).get("B");
assertEquals(1, posList.size());
assertTrue(Arrays.equals(new int[] { 1, 4 }, posList.get(0)));
- posList = map.get(Color.red).get(1).get("A");
+ posList = map.get(Colour.red).get(1).get("A");
assertEquals(1, posList.size());
assertTrue(Arrays.equals(new int[] { 3, 5 }, posList.get(0)));
- posList = map.get(Color.orange).get(0).get("C");
+ posList = map.get(Colour.orange).get(0).get("C");
assertEquals(1, posList.size());
assertTrue(Arrays.equals(new int[] { 5, 9 }, posList.get(0)));
}
public void testBuildColourCommands()
{
- Map<Color, Map<Integer, Map<String, List<int[]>>>> map = new LinkedHashMap<Color, Map<Integer, Map<String, List<int[]>>>>();
- ChimeraCommands.addColourRange(map, Color.blue, 0, 2, 5, "A");
- ChimeraCommands.addColourRange(map, Color.blue, 0, 7, 7, "B");
- ChimeraCommands.addColourRange(map, Color.blue, 0, 9, 23, "A");
- ChimeraCommands.addColourRange(map, Color.blue, 1, 1, 1, "A");
- ChimeraCommands.addColourRange(map, Color.blue, 1, 4, 7, "B");
- ChimeraCommands.addColourRange(map, Color.yellow, 1, 8, 8, "A");
- ChimeraCommands.addColourRange(map, Color.yellow, 1, 3, 5, "A");
- ChimeraCommands.addColourRange(map, Color.red, 0, 3, 5, "A");
+ Map<ColorI, Map<Integer, Map<String, List<int[]>>>> map = new LinkedHashMap<ColorI, Map<Integer, Map<String, List<int[]>>>>();
+ ChimeraCommands.addColourRange(map, Colour.blue, 0, 2, 5, "A");
+ ChimeraCommands.addColourRange(map, Colour.blue, 0, 7, 7, "B");
+ ChimeraCommands.addColourRange(map, Colour.blue, 0, 9, 23, "A");
+ ChimeraCommands.addColourRange(map, Colour.blue, 1, 1, 1, "A");
+ ChimeraCommands.addColourRange(map, Colour.blue, 1, 4, 7, "B");
+ ChimeraCommands.addColourRange(map, Colour.yellow, 1, 8, 8, "A");
+ ChimeraCommands.addColourRange(map, Colour.yellow, 1, 3, 5, "A");
+ ChimeraCommands.addColourRange(map, Colour.red, 0, 3, 5, "A");
// Colours should appear in the Chimera command in the order in which
// they were added; within colour, by model, by chain, and positions as
import jalview.datamodel.AlignmentI;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceI;
+import jalview.schemes.Colour;
import jalview.schemes.ZappoColourScheme;
-import java.awt.Color;
-
import org.testng.annotations.Test;
public class SequenceRendererTest
av.setGlobalColourScheme(new ZappoColourScheme());
// @see ResidueProperties.zappo
- assertEquals(Color.pink, sr.getResidueColour(seq, 0, null)); // M
- assertEquals(Color.green, sr.getResidueColour(seq, 2, null)); // T
- assertEquals(Color.magenta, sr.getResidueColour(seq, 5, null)); // G
- assertEquals(Color.orange, sr.getResidueColour(seq, 12, null)); // F
+ assertEquals(Colour.pink, sr.getResidueColour(seq, 0, null)); // M
+ assertEquals(Colour.green, sr.getResidueColour(seq, 2, null)); // T
+ assertEquals(Colour.magenta, sr.getResidueColour(seq, 5, null)); // G
+ assertEquals(Colour.orange, sr.getResidueColour(seq, 12, null)); // F
}
// TODO more tests for getResidueBoxColour covering groups, feature rendering,
// gaps, overview...
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.gui.AlignFrame;
+import jalview.schemes.Colour;
-import java.awt.Color;
import java.io.File;
import java.io.IOException;
import java.util.Map;
*/
colours = af.getFeatureRenderer().getFeatureColours();
assertEquals("26 feature group colours not found", 26, colours.size());
- assertEquals(colours.get("Cath").getColour(), new Color(0x93b1d1));
- assertEquals(colours.get("ASX-MOTIF").getColour(), new Color(0x6addbb));
+ assertEquals(colours.get("Cath").getColour(), new Colour(0x93b1d1));
+ assertEquals(colours.get("ASX-MOTIF").getColour(), new Colour(0x6addbb));
/*
* verify (some) features on sequences
// verify colours read or synthesized
colours = af.getFeatureRenderer().getFeatureColours();
assertEquals("1 feature group colours not found", 1, colours.size());
- assertEquals(colours.get("METAL").getColour(), new Color(0xcc9900));
+ assertEquals(colours.get("METAL").getColour(), new Colour(0xcc9900));
// verify feature on FER_CAPAA
SequenceFeature[] sfs = al.getSequenceAt(0).getDatasetSequence()
}
/**
+ * Test various ways of describing a feature colour scheme
+ *
+ * @throws Exception
+ */
+ @Test(groups = { "Functional" })
+ public void testParseGraduatedColourScheme() throws Exception
+ {
+ FeaturesFile ff = new FeaturesFile();
+
+ // colour by label:
+ FeatureColourI gc = ff.parseGraduatedColourScheme(
+ "BETA-TURN-IR\t9a6a94", "label");
+ assertTrue(gc.isColourByLabel());
+ assertEquals(Colour.white, gc.getMinColour());
+ assertEquals(Colour.black, gc.getMaxColour());
+ assertTrue(gc.isAutoScaled());
+
+ // using colour name, rgb, etc:
+ String spec = "blue|255,0,255|absolute|20.0|95.0|below|66.0";
+ gc = ff.parseGraduatedColourScheme("BETA-TURN-IR\t" + spec, spec);
+ assertFalse(gc.isColourByLabel());
+ assertEquals(Colour.blue, gc.getMinColour());
+ assertEquals(new Colour(255, 0, 255), gc.getMaxColour());
+ assertFalse(gc.isAutoScaled());
+ // assertFalse(gc.getTolow());
+ assertEquals(20.0f, gc.getMin(), 0.001f);
+ assertEquals(95.0f, gc.getMax(), 0.001f);
+ assertTrue(gc.isBelowThreshold());
+ assertEquals(66.0f, gc.getThreshold(), 0.001f);
+
+ // inverse gradient high to low:
+ spec = "blue|255,0,255|95.0|20.0|below|66.0";
+ gc = ff.parseGraduatedColourScheme("BETA-TURN-IR\t" + spec, spec);
+ assertTrue(gc.isAutoScaled());
+ // assertTrue(gc..getTolow());
+ }
+
+ /**
* Test parsing a features file with GFF formatted content only
*
* @throws Exception
import static org.testng.AssertJUnit.assertTrue;
import static org.testng.AssertJUnit.fail;
+import jalview.api.ColorI;
import jalview.datamodel.SequenceFeature;
import jalview.util.Format;
public class FeatureColourTest
{
@Test(groups = { "Functional" })
- public void testCopyConstructor()
- {
- /*
- * plain colour
- */
- FeatureColour fc = new FeatureColour(Color.RED);
- FeatureColour fc1 = new FeatureColour(fc);
- assertTrue(fc1.getColour().equals(Color.RED));
- assertFalse(fc1.isGraduatedColour());
- assertFalse(fc1.isColourByLabel());
-
- /*
- * min-max colour
- */
- fc = new FeatureColour(Color.gray, Color.black, 10f, 20f);
- fc.setAboveThreshold(true);
- fc.setThreshold(12f);
- fc1 = new FeatureColour(fc);
- assertTrue(fc1.isGraduatedColour());
- assertFalse(fc1.isColourByLabel());
- assertTrue(fc1.isAboveThreshold());
- assertEquals(12f, fc1.getThreshold());
- assertEquals(Color.gray, fc1.getMinColour());
- assertEquals(Color.black, fc1.getMaxColour());
- assertEquals(10f, fc1.getMin());
- assertEquals(20f, fc1.getMax());
-
- /*
- * colour by label
- */
- fc = new FeatureColour();
- fc.setColourByLabel(true);
- fc1 = new FeatureColour(fc);
- assertTrue(fc1.isColourByLabel());
- assertFalse(fc1.isGraduatedColour());
- }
-
- @Test(groups = { "Functional" })
public void testIsColored_simpleColour()
{
FeatureColour fc = new FeatureColour(Color.RED);
public void testIsColored_aboveThreshold()
{
// graduated colour range from score 20 to 100
- FeatureColour fc = new FeatureColour(Color.WHITE, Color.BLACK, 20f,
- 100f);
+ FeatureColour fc = new FeatureColour(new Colour(Color.WHITE),
+ new Colour(Color.BLACK), 20f, 100f);
// score 0 is adjusted to bottom of range
SequenceFeature sf = new SequenceFeature("type", "desc", 0, 20, 0f,
null);
assertTrue(fc.isColored(sf));
- assertEquals(Color.WHITE, fc.getColor(sf));
+ assertEquals(fc.getColor(sf), Colour.white);
// score 120 is adjusted to top of range
sf.setScore(120f);
- assertEquals(Color.BLACK, fc.getColor(sf));
+ assertEquals(fc.getColor(sf), Colour.black);
// value below threshold is still rendered
// setting threshold has no effect yet...
fc.setThreshold(60f);
sf.setScore(36f);
assertTrue(fc.isColored(sf));
- assertEquals(new Color(204, 204, 204), fc.getColor(sf));
+ assertEquals(fc.getColor(sf), new Colour(204, 204, 204));
// now apply threshold:
fc.setAboveThreshold(true);
assertFalse(fc.isColored(sf));
// colour is still returned though ?!?
- assertEquals(new Color(204, 204, 204), fc.getColor(sf));
+ assertEquals(fc.getColor(sf), new Colour(204, 204, 204));
sf.setScore(84); // above threshold now
assertTrue(fc.isColored(sf));
- assertEquals(new Color(51, 51, 51), fc.getColor(sf));
+ assertEquals(fc.getColor(sf), new Colour(51, 51, 51));
}
@Test(groups = { "Functional" })
public void testGetColor_simpleColour()
{
- FeatureColour fc = new FeatureColour(Color.RED);
- assertEquals(Color.RED, fc.getColor(new SequenceFeature()));
+ FeatureColour fc = new FeatureColour(Colour.red);
+ assertEquals(fc.getColor(new SequenceFeature()), Colour.red);
}
@Test(groups = { "Functional" })
fc.setColourByLabel(true);
SequenceFeature sf = new SequenceFeature("type", "desc", 0, 20, 1f,
null);
- Color expected = UserColourScheme.createColourFromName("desc");
- assertEquals(expected, fc.getColor(sf));
+ ColorI expected = new Colour(
+ UserColourScheme.createColourFromName("desc"));
+ assertEquals(fc.getColor(sf), expected);
+ // assertEquals(expected, fc.getColor(sf));
}
@Test(groups = { "Functional" })
float red = 128 / 255f + 3 / 4f * (255 - 128) / 255f;
float green = 128 / 255f + 3 / 4f * (0 - 128) / 255f;
float blue = 128 / 255f + 3 / 4f * (0 - 128) / 255f;
- Color expected = new Color(red, green, blue);
- assertEquals(expected, fc.getColor(sf));
+ Colour expected = new Colour(red, green, blue);
+ assertEquals(fc.getColor(sf), expected);
+ // assertEquals(expected, fc.getColor(sf));
}
@Test(groups = { "Functional" })
null);
fc.setThreshold(100f); // ignore for now
assertTrue(fc.isColored(sf));
- assertEquals(new Color(204, 204, 204), fc.getColor(sf));
+ assertEquals(fc.getColor(sf), new Colour(204, 204, 204));
+ // assertEquals(new Color(204, 204, 204), fc.getColor(sf));
fc.setAboveThreshold(true); // feature lies below threshold
assertFalse(fc.isColored(sf));
- assertEquals(new Color(204, 204, 204), fc.getColor(sf));
+ assertEquals(fc.getColor(sf), new Colour(204, 204, 204));
+ // assertEquals(new Color(204, 204, 204), fc.getColor(sf));
}
/**
*/
FeatureColour fc = FeatureColour.parseJalviewFeatureColour("red");
assertTrue(fc.isSimpleColour());
- assertEquals(Color.RED, fc.getColour());
+ assertEquals(fc.getColour(), Colour.red);
/*
* simple colour by hex code
fc = FeatureColour.parseJalviewFeatureColour(Format
.getHexString(Color.RED));
assertTrue(fc.isSimpleColour());
- assertEquals(Color.RED, fc.getColour());
+ assertEquals(fc.getColour(), Colour.red);
+ // assertEquals(Color.RED, fc.getColour());
/*
* simple colour by rgb triplet
*/
fc = FeatureColour.parseJalviewFeatureColour("255,0,0");
assertTrue(fc.isSimpleColour());
- assertEquals(Color.RED, fc.getColour());
+ assertEquals(fc.getColour(), Colour.red);
+ // assertEquals(Color.RED, fc.getColour());
/*
* malformed colour
fc = FeatureColour.parseJalviewFeatureColour("red|green|10.0|20.0");
assertTrue(fc.isGraduatedColour());
assertFalse(fc.hasThreshold());
- assertEquals(Color.RED, fc.getMinColour());
- assertEquals(Color.GREEN, fc.getMaxColour());
+ assertEquals(fc.getMinColour(), Colour.red);
+ // assertEquals(Color.RED, fc.getMinColour());
+ assertEquals(fc.getMaxColour(), Colour.green);
+ // assertEquals(Color.GREEN, fc.getMaxColour());
assertEquals(10f, fc.getMin());
assertEquals(20f, fc.getMax());
assertTrue(fc.isAutoScaled());
assertTrue(fc.hasThreshold());
assertTrue(fc.isAboveThreshold());
assertEquals(15f, fc.getThreshold());
- assertEquals(Color.RED, fc.getMinColour());
- assertEquals(Color.GREEN, fc.getMaxColour());
+ assertEquals(fc.getMinColour(), Colour.red);
+ // assertEquals(Color.RED, fc.getMinColour());
+ assertEquals(fc.getMaxColour(), Colour.green);
+ // assertEquals(Color.GREEN, fc.getMaxColour());
assertEquals(10f, fc.getMin());
assertEquals(20f, fc.getMax());
assertTrue(fc.isAutoScaled());
assertTrue(fc.hasThreshold());
assertTrue(fc.isBelowThreshold());
assertEquals(15f, fc.getThreshold());
- assertEquals(Color.RED, fc.getMinColour());
- assertEquals(Color.GREEN, fc.getMaxColour());
+ assertEquals(fc.getMinColour(), Colour.red);
+ // assertEquals(Color.RED, fc.getMinColour());
+ assertEquals(fc.getMaxColour(), Colour.green);
+ // assertEquals(Color.GREEN, fc.getMaxColour());
assertEquals(10f, fc.getMin());
assertEquals(20f, fc.getMax());
-
- descriptor = String
- .format("blue|255,0,255|absolute|20.0|95.0|below|66.0");
- fc = FeatureColour.parseJalviewFeatureColour(descriptor);
- assertTrue(fc.isGraduatedColour());
}
}
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
+import jalview.schemes.Colour;
+
import java.awt.Color;
import org.testng.annotations.Test;
@Test(groups = { "Functional" })
public void testToTkCode()
{
- assertEquals("#fffafa", ColorUtils.toTkCode(new Color(255, 250, 250))); // snow
- assertEquals("#e6e6fa", ColorUtils.toTkCode(new Color(230, 230, 250))); // lavender
- assertEquals("#dda0dd", ColorUtils.toTkCode(new Color(221, 160, 221))); // plum
- assertEquals("#800080", ColorUtils.toTkCode(new Color(128, 0, 128))); // purple
- assertEquals("#00ff00", ColorUtils.toTkCode(new Color(0, 255, 0))); // lime
+ assertEquals("#fffafa", ColorUtils.toTkCode(new Colour(255, 250, 250))); // snow
+ assertEquals("#e6e6fa", ColorUtils.toTkCode(new Colour(230, 230, 250))); // lavender
+ assertEquals("#dda0dd", ColorUtils.toTkCode(new Colour(221, 160, 221))); // plum
+ assertEquals("#800080", ColorUtils.toTkCode(new Colour(128, 0, 128))); // purple
+ assertEquals("#00ff00", ColorUtils.toTkCode(new Colour(0, 255, 0))); // lime
}
@Test(groups = { "Functional" })
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
-import java.awt.Color;
+import jalview.api.ColorI;
+import jalview.schemes.Colour;
+
import java.lang.reflect.Field;
import java.util.Random;
{
field.set(vs, "Joe" + field.get(vs));
}
- else if (type.equals(Color.class))
+ else if (type.equals(ColorI.class))
{
- field.set(vs, Color.RED.equals(field.get(vs)) ? Color.BLACK
- : Color.RED);
+ field.set(vs, Colour.red.equals(field.get(vs)) ? Colour.black
+ : Colour.red);
}
else
{
git://source.jalview.org / jalview.git / commitdiff