Merge branch 'JAL-1347' into develop
[jalview.git] / src / jalview / renderer / AnnotationRenderer.java
index 8f25e77..e360ba4 100644 (file)
@@ -82,6 +82,7 @@ public class AnnotationRenderer
     // If a closing base pair half of the stem, display a backward arrow
     if (column > 0 && closeparen.search(dc))
     {
+       
       if (diffupstream)
       // if (validRes && column>1 && row_annotations[column-2]!=null &&
       // dc.equals(row_annotations[column-2].displayCharacter))
@@ -98,6 +99,7 @@ public class AnnotationRenderer
     }
     else
     {
+       
       // display a forward arrow
       if (diffdownstream)
       {
@@ -170,7 +172,66 @@ public class AnnotationRenderer
    * master flag indicating if renderer should ever try to clip. not enabled for jalview 2.8.1 
    */
   private boolean canClip=false;
+
   
+  public void drawNotCanonicalAnnot(Graphics g, Color nonCanColor, Annotation[] row_annotations,
+          int lastSSX, int x, int y, int iconOffset, int startRes,
+          int column, boolean validRes, boolean validEnd)
+  {
+       //System.out.println(nonCanColor);
+       
+    g.setColor(nonCanColor);
+    int sCol = (lastSSX / charWidth) + startRes;
+    int x1 = lastSSX;
+    int x2 = (x * charWidth);
+    Regex closeparen = new Regex("}|]|<|a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z");
+    
+    String dc = (column == 0 || row_annotations[column - 1] == null) ? ""
+            : row_annotations[column - 1].displayCharacter;
+
+    boolean diffupstream = sCol == 0 || row_annotations[sCol - 1] == null
+            || !dc.equals(row_annotations[sCol - 1].displayCharacter);
+    boolean diffdownstream = !validRes || !validEnd
+            || row_annotations[column] == null
+            || !dc.equals(row_annotations[column].displayCharacter);
+    // System.out.println("Column "+column+" diff up: "+diffupstream+" down:"+diffdownstream);
+    // If a closing base pair half of the stem, display a backward arrow
+    if (column > 0 && closeparen.search(dc))//  closeletter_b.search(dc)||closeletter_c.search(dc)||closeletter_d.search(dc)||closecrochet.search(dc)) )
+    {
+       
+      if (diffupstream)
+      // if (validRes && column>1 && row_annotations[column-2]!=null &&
+      // dc.equals(row_annotations[column-2].displayCharacter))
+      {
+        g.fillPolygon(new int[]
+        { lastSSX + 5, lastSSX + 5, lastSSX }, new int[]
+        { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
+        x1 += 5;
+      }
+      if (diffdownstream)
+      {
+        x2 -= 1;
+      }
+    }
+    else
+    {
+       
+      // display a forward arrow
+      if (diffdownstream)
+      {
+        g.fillPolygon(new int[]
+        { x2 - 5, x2 - 5, x2 }, new int[]
+        { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset }, 3);
+        x2 -= 5;
+      }
+      if (diffupstream)
+      {
+        x1 += 1;
+      }
+    }
+    // draw arrow body
+    g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+  }
   // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI
   // av)
   public void updateFromAwtRenderPanel(AwtRenderPanelI annotPanel,
@@ -536,7 +597,8 @@ public class AnnotationRenderer
                                     .equals(row_annotations[column - 1].displayCharacter) || (row_annotations[column].displayCharacter
                             .length() < 2 && row_annotations[column].secondaryStructure == ' ')))
             {
-              g.drawString(row_annotations[column].displayCharacter, x
+               g.drawString(row_annotations[column].displayCharacter
+                         , x
                       * charWidth + charOffset, y + iconOffset);
             }
             g.setFont(ofont);
@@ -545,15 +607,284 @@ public class AnnotationRenderer
         if (row.hasIcons)
         {
           char ss = validRes ? row_annotations[column].secondaryStructure
-                  : ' ';
-          if (ss == 'S')
+                  : '-';
+          
+          if (ss == '(')
           {
             // distinguish between forward/backward base-pairing
             if (row_annotations[column].displayCharacter.indexOf(')') > -1)
             {
-              ss = 's';
+            
+              ss = ')';
+              
+            }
+          }
+           if (ss == '[')
+          {
+            if ((row_annotations[column].displayCharacter.indexOf(']') > -1))
+            {
+                ss = ']';
+                
+                
             }
           }
+           if (ss == '{')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('}') > -1)
+             {
+               ss = '}';
+               
+               
+             }
+           }
+           if (ss == '<')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('<') > -1)
+             {
+               ss = '>';
+               
+               
+             }
+           }
+           if (ss == 'A')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('a') > -1)
+             {
+               ss = 'a';
+              
+               
+             }
+           }
+           
+           if (ss == 'B')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('b') > -1)
+             {
+               ss = 'b';
+               
+             }
+           }
+           
+           if (ss == 'C')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('c') > -1)
+             {
+               ss = 'c';
+               
+             }
+           }
+           if (ss == 'D')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('d') > -1)
+             {
+               ss = 'd';
+               
+             }
+           }
+           if (ss == '1')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('e') > -1)
+             {
+               ss = 'e';
+               
+             }
+           }
+           if (ss == 'F')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('f') > -1)
+             {
+               ss = 'f';
+               
+             }
+           }
+           if (ss == 'G')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('g') > -1)
+             {
+               ss = 'g';
+               
+             }
+           }
+           if (ss == '2')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('h') > -1)
+             {
+               ss = 'h';
+               
+             }
+           }
+           if (ss == 'I')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('i') > -1)
+             {
+               ss = 'i';
+               
+             }
+           }
+           if (ss == 'J')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('j') > -1)
+             {
+               ss = 'j';
+               
+             }
+           }
+           if (ss == 'K')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('k') > -1)
+             {
+               ss = 'k';
+               
+             }
+           }
+           if (ss == 'L')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('l') > -1)
+             {
+               ss = 'l';
+               
+             }
+           }
+           if (ss == 'M')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('m') > -1)
+             {
+               ss = 'm';
+               
+             }
+           }
+           if (ss == 'N')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('n') > -1)
+             {
+               ss = 'n';
+               
+             }
+           }
+           if (ss == 'O')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('o') > -1)
+             {
+               ss = 'o';
+               
+             }
+           }
+           if (ss == 'P')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('p') > -1)
+             {
+               ss = 'p';
+               
+             }
+           }
+           if (ss == 'Q')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('q') > -1)
+             {
+               ss = 'q';
+               
+             }
+           }
+           if (ss == 'R')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('r') > -1)
+             {
+               ss = 'r';
+               
+             }
+           }
+           if (ss == 'S')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('s') > -1)
+             {
+               ss = 's';
+               
+             }
+           }
+           if (ss == 'T')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('t') > -1)
+             {
+               ss = 't';
+               
+             }
+           }
+           if (ss == 'U')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('u') > -1)
+             {
+               ss = 'u';
+               
+             }
+           }
+           if (ss == 'V')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('v') > -1)
+             {
+               ss = 'v';
+               
+             }
+           }
+           if (ss == 'W')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('w') > -1)
+             {
+               ss = 'w';
+               
+             }
+           }
+           if (ss == 'X')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('x') > -1)
+             {
+               ss = 'x';
+               
+             }
+           }
+           if (ss == 'Y')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('y') > -1)
+             {
+               ss = 'y';
+               
+             }
+           }
+           if (ss == 'Z')
+           {
+             // distinguish between forward/backward base-pairing
+             if (row_annotations[column].displayCharacter.indexOf('z') > -1)
+             {
+               ss = 'z';
+               
+             }
+           }
           if (!validRes || (ss != lastSS))
           {
             if (x > -1)
@@ -570,12 +901,78 @@ public class AnnotationRenderer
                         iconOffset, startRes, column, validRes, validEnd);
                 break;
 
-              case 'S': // Stem case for RNA secondary structure
-              case 's': // and opposite direction
-                drawStemAnnot(g, row_annotations, lastSSX, x, y,
-                        iconOffset, startRes, column, validRes, validEnd);
+              case '(': // Stem case for RNA secondary structure
+              case ')': // and opposite direction
+                drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset, startRes,
+                        column, validRes, validEnd);
+//              case 'S': // Stem case for RNA secondary structure
+//              case 's': // and opposite direction
+//                drawStemAnnot(g, row_annotations, lastSSX, x, y,
+//                        iconOffset, startRes, column, validRes, validEnd);
                 break;
-
+              case '{':
+              case '}':
+              case '[':
+              case ']':
+              case '>':
+              case '<':
+              case 'A':
+              case 'a':
+              case 'B':
+              case 'b':
+              case 'C':
+              case 'c':
+              case 'D':
+              case 'd':
+              case '1':
+              case 'e':
+              case 'F':
+              case 'f':
+              case 'G':
+              case 'g':
+              case '2':
+              case 'h':
+              case 'I':
+              case 'i':
+              case 'J':
+              case 'j':
+              case 'K':
+              case 'k':
+              case 'L':
+              case 'l':
+              case 'M':
+              case 'm':
+              case 'N':
+              case 'n':
+              case 'O':
+              case 'o':
+              case 'P':
+              case 'p':
+              case 'Q':
+              case 'q':
+              case 'R':
+              case 'r':
+              case 'S':
+              case 's':
+              case 'T':
+              case 't':
+              case 'U':
+              case 'u':
+              case 'V':
+              case 'v':
+              case 'W':
+              case 'w':
+              case 'X':
+              case 'x':
+              case 'Y':
+              case 'y':
+              case 'Z':
+              case 'z':
+                 //System.out.println(lastSS);
+                 Color nonCanColor= getNotCanonicalColor(lastSS);
+                 drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX, x, y, iconOffset, startRes,
+                          column, validRes, validEnd);
+                 break;
               default:
                 g.setColor(Color.gray);
                 g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth)
@@ -640,6 +1037,67 @@ public class AnnotationRenderer
           drawStemAnnot(g, row_annotations, lastSSX, x, y, iconOffset,
                   startRes, column, validRes, validEnd);
           break;
+        case '{':
+        case '}':
+        case '[':
+        case ']':
+        case '>':
+        case '<':
+        case 'A':
+        case 'a':
+        case 'B':
+        case 'b':
+        case 'C':
+        case 'c':
+        case 'D':
+        case 'd':
+        case '1':
+        case 'e':
+        case 'F':
+        case 'f':
+        case 'G':
+        case 'g':
+        case '2':
+        case 'h':
+        case 'I':
+        case 'i':
+        case 'J':
+        case 'j':
+        case 'K':
+        case 'k':
+        case 'L':
+        case 'l':
+        case 'M':
+        case 'm':
+        case 'N':
+        case 'n':
+        case 'O':
+        case 'o':
+        case 'P':
+        case 'p':
+        case 'Q':
+        case 'q':
+        case 'R':
+        case 'r':
+        case 'T':
+        case 't':
+        case 'U':
+        case 'u':
+        case 'V':
+        case 'v':
+        case 'W':
+        case 'w':
+        case 'X':
+        case 'x':
+        case 'Y':
+        case 'y':
+        case 'Z':
+        case 'z':
+               //System.out.println(lastSS);
+          Color nonCanColor = getNotCanonicalColor(lastSS);
+         drawNotCanonicalAnnot(g,nonCanColor, row_annotations, lastSSX, x, y, iconOffset, startRes,
+                    column, validRes, validEnd);
+         break;
         default:
           drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset,
                   startRes, column, validRes, validEnd);
@@ -746,6 +1204,8 @@ public class AnnotationRenderer
   private final Color HELIX_COLOUR = Color.red;
 
   private final Color STEM_COLOUR = Color.blue;
+  
+  private  Color sdNOTCANONICAL_COLOUR;
 
   public void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX,
           int x, int y, int iconOffset, int startRes, int column,
@@ -1110,4 +1570,135 @@ public class AnnotationRenderer
       x += charWidth;
     }
   }
+
+  
+  Color getNotCanonicalColor(char lastss)
+       {
+         switch (lastss)
+      {
+         case '{':  
+             case '}':
+                 return Color.cyan;
+                
+             case '[':
+             case ']':
+                 return Color.green;
+                
+             case '>':
+             case '<':
+                 return Color.magenta;
+                 
+             case 'A':
+             case 'a':
+                 return Color.orange;
+               
+             case 'B':
+             case 'b':
+                 return Color.pink;
+                 
+             case 'C':
+             case 'c':
+                 return Color.red;
+                
+             case 'D':
+             case 'd':
+                 return Color.yellow;
+                 
+             case '1':
+             case 'e':
+                 return Color.black;
+                
+             case 'F':
+             case 'f':
+                 return Color.darkGray;
+                
+             case 'G':
+             case 'g':
+                 return Color.gray;
+               
+             case '2':
+             case 'h':
+                 return Color.lightGray;
+                 
+             case 'I':
+             case 'i':
+                 return Color.white;
+                
+             case 'J':
+             case 'j':
+                 return Color.cyan;
+                 
+             case 'K':
+             case 'k':
+                 return Color.magenta;
+               
+             case 'L':
+             case 'l':
+                 return Color.orange;
+       
+             case 'M':
+             case 'm':
+                 return Color.red;
+               
+             case 'N':
+             case 'n':
+                 return Color.yellow;
+                 
+             case 'O':
+             case 'o':
+                 return Color.pink;
+               
+             case 'P':
+             case 'p':
+                 return Color.black;
+               
+             case 'Q':
+             case 'q':
+                 return Color.blue;
+       
+             case 'R':
+             case 'r':
+                 return Color.cyan;
+       
+             case 'S':
+             case 's':
+                 return Color.magenta;
+               
+             case 'T':
+             case 't':
+                 return Color.darkGray;
+                
+             case 'U':
+             case 'u':
+                 return Color.yellow;
+                 
+             case 'V':
+             case 'v':
+                 return Color.blue;
+                
+             case 'W':
+             case 'w':
+                 return Color.orange;
+                 
+             case 'X':
+             case 'x':
+                 return Color.magenta;
+                
+             case 'Y':
+             case 'y':
+                 return Color.blue;
+                 
+             case 'Z':
+             case 'z':
+                 return Color.blue;
+                
+       default :
+               System.out.println("This is not a interaction");
+               return null;
+               
+      }
+       }
 }
+
+       
+