From ec955aa655d8320258b91eb079bc57f688cd0a07 Mon Sep 17 00:00:00 2001 From: amwaterhouse Date: Wed, 4 May 2005 15:10:21 +0000 Subject: [PATCH] Applet files --- src/jalview/appletgui/APopupMenu.java | 530 ++++++++++ src/jalview/appletgui/AlignFrame.java | 978 ++++++++++++++++++ src/jalview/appletgui/AlignViewport.java | 505 ++++++++++ src/jalview/appletgui/AlignmentPanel.java | 430 ++++++++ src/jalview/appletgui/AnnotationLabels.java | 99 ++ src/jalview/appletgui/AnnotationPanel.java | 364 +++++++ src/jalview/appletgui/ColumnSelection.java | 74 ++ src/jalview/appletgui/CutAndPasteTransfer.java | 72 ++ src/jalview/appletgui/FeatureRenderer.java | 79 ++ src/jalview/appletgui/Finder.java | 230 +++++ src/jalview/appletgui/FontChooser.java | 87 ++ src/jalview/appletgui/IdCanvas.java | 204 ++++ src/jalview/appletgui/IdPanel.java | 242 +++++ src/jalview/appletgui/IdwidthAdjuster.java | 61 ++ src/jalview/appletgui/OverviewPanel.java | 264 +++++ src/jalview/appletgui/PCAPanel.java | 122 +++ src/jalview/appletgui/PaintRefresher.java | 35 + src/jalview/appletgui/PairwiseAlignPanel.java | 71 ++ src/jalview/appletgui/RedundancyPanel.java | 102 ++ src/jalview/appletgui/RotatableCanvas.java | 514 ++++++++++ src/jalview/appletgui/ScalePanel.java | 175 ++++ src/jalview/appletgui/SeqCanvas.java | 486 +++++++++ src/jalview/appletgui/SeqPanel.java | 631 ++++++++++++ src/jalview/appletgui/SequenceRenderer.java | 188 ++++ src/jalview/appletgui/SliderPanel.java | 222 ++++ src/jalview/appletgui/TreeCanvas.java | 430 ++++++++ src/jalview/appletgui/TreePanel.java | 101 ++ src/jalview/appletgui/UserDefinedColours.java | 226 +++++ src/jalview/bin/JalviewLite.java | 122 +++ src/jalview/jbappletgui/GAlignFrame.java | 1113 +++++++++++++++++++++ src/jalview/jbappletgui/GAlignmentPanel.java | 87 ++ src/jalview/jbappletgui/GCutAndPasteTransfer.java | 85 ++ src/jalview/jbappletgui/GFinder.java | 119 +++ src/jalview/jbappletgui/GFontChooser.java | 142 +++ src/jalview/jbappletgui/GPCAPanel.java | 95 ++ src/jalview/jbappletgui/GPairwiseAlignPanel.java | 51 + src/jalview/jbappletgui/GSliderPanel.java | 117 +++ src/jalview/jbappletgui/GTreePanel.java | 108 ++ src/jalview/jbappletgui/GUserDefinedColours.java | 201 ++++ 39 files changed, 9762 insertions(+) create mode 100755 src/jalview/appletgui/APopupMenu.java create mode 100755 src/jalview/appletgui/AlignFrame.java create mode 100755 src/jalview/appletgui/AlignViewport.java create mode 100755 src/jalview/appletgui/AlignmentPanel.java create mode 100755 src/jalview/appletgui/AnnotationLabels.java create mode 100755 src/jalview/appletgui/AnnotationPanel.java create mode 100755 src/jalview/appletgui/ColumnSelection.java create mode 100755 src/jalview/appletgui/CutAndPasteTransfer.java create mode 100755 src/jalview/appletgui/FeatureRenderer.java create mode 100755 src/jalview/appletgui/Finder.java create mode 100755 src/jalview/appletgui/FontChooser.java create mode 100755 src/jalview/appletgui/IdCanvas.java create mode 100755 src/jalview/appletgui/IdPanel.java create mode 100755 src/jalview/appletgui/IdwidthAdjuster.java create mode 100755 src/jalview/appletgui/OverviewPanel.java create mode 100755 src/jalview/appletgui/PCAPanel.java create mode 100755 src/jalview/appletgui/PaintRefresher.java create mode 100755 src/jalview/appletgui/PairwiseAlignPanel.java create mode 100755 src/jalview/appletgui/RedundancyPanel.java create mode 100755 src/jalview/appletgui/RotatableCanvas.java create mode 100755 src/jalview/appletgui/ScalePanel.java create mode 100755 src/jalview/appletgui/SeqCanvas.java create mode 100755 src/jalview/appletgui/SeqPanel.java create mode 100755 src/jalview/appletgui/SequenceRenderer.java create mode 100755 src/jalview/appletgui/SliderPanel.java create mode 100755 src/jalview/appletgui/TreeCanvas.java create mode 100755 src/jalview/appletgui/TreePanel.java create mode 100755 src/jalview/appletgui/UserDefinedColours.java create mode 100755 src/jalview/bin/JalviewLite.java create mode 100755 src/jalview/jbappletgui/GAlignFrame.java create mode 100755 src/jalview/jbappletgui/GAlignmentPanel.java create mode 100755 src/jalview/jbappletgui/GCutAndPasteTransfer.java create mode 100755 src/jalview/jbappletgui/GFinder.java create mode 100755 src/jalview/jbappletgui/GFontChooser.java create mode 100755 src/jalview/jbappletgui/GPCAPanel.java create mode 100755 src/jalview/jbappletgui/GPairwiseAlignPanel.java create mode 100755 src/jalview/jbappletgui/GSliderPanel.java create mode 100755 src/jalview/jbappletgui/GTreePanel.java create mode 100755 src/jalview/jbappletgui/GUserDefinedColours.java diff --git a/src/jalview/appletgui/APopupMenu.java b/src/jalview/appletgui/APopupMenu.java new file mode 100755 index 0000000..b6d43ea --- /dev/null +++ b/src/jalview/appletgui/APopupMenu.java @@ -0,0 +1,530 @@ +package jalview.appletgui; + +import jalview.datamodel.*; +import jalview.analysis.*; +import jalview.schemes.*; +import java.awt.*; +import java.awt.event.*; + +public class APopupMenu extends java.awt.PopupMenu +{ + Menu groupMenu = new Menu(); + Menu analyze = new Menu(); + Menu defineMenu = new Menu(); + Menu groupName = new Menu(); + Menu groupAnnotation = new Menu(); + protected MenuItem clustalColour = new MenuItem(); + protected MenuItem zappoColour = new MenuItem(); + protected MenuItem taylorColour = new MenuItem(); + protected MenuItem hydrophobicityColour = new MenuItem(); + protected MenuItem helixColour = new MenuItem(); + protected MenuItem strandColour = new MenuItem(); + protected MenuItem turnColour = new MenuItem(); + protected MenuItem buriedColour = new MenuItem(); + protected CheckboxMenuItem abovePIDColour = new CheckboxMenuItem(); + protected MenuItem userDefinedColour = new MenuItem(); + protected MenuItem PIDColour = new MenuItem(); + protected MenuItem BLOSUM62Colour = new MenuItem(); + MenuItem noColourmenuItem = new MenuItem(); + protected CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem(); + + + AlignmentPanel ap; + Menu sequenceMenu = new Menu(); + MenuItem sequenceName = new MenuItem(); + Menu residueMenu = new Menu(); + MenuItem annotateResidue = new MenuItem(); + + Sequence sequence; + MenuItem unGroupMenuItem = new MenuItem(); + MenuItem outline = new MenuItem(); + MenuItem nucleotideMenuItem = new MenuItem(); + + public APopupMenu(AlignmentPanel ap, Sequence seq) + { + /////////////////////////////////////////////////////////// + // If this is activated from the sequence panel, the user may want to + // edit or annotate a particular residue. Therefore display the residue menu + // + // If from the IDPanel, we must display the sequence menu + ////////////////////////////////////////////////////////// + + this.ap = ap; + sequence = seq; + + try + { jbInit(); } + catch(Exception e) + { e.printStackTrace(); } + + + if(seq!=null) + residueMenu.setEnabled(false); + else + sequenceMenu.setEnabled(false); + + } + private void jbInit() throws Exception + { + groupMenu.setLabel("Group"); + analyze.setLabel("Analyze"); + analyze.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + analyze_actionPerformed(e); + } + }); + defineMenu.setLabel("Define"); + groupName.setLabel("Name"); + groupName.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + groupName_actionPerformed(e); + } + }); + groupAnnotation.setEnabled(false); + groupAnnotation.setLabel("Annotation"); + groupAnnotation.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + groupAnnotation_actionPerformed(e); + } + }); + sequenceMenu.setLabel("Sequence"); + sequenceName.setLabel("Edit name"); + sequenceName.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + sequenceName_actionPerformed(e); + } + }); + residueMenu.setLabel("Residue"); + annotateResidue.setEnabled(false); + annotateResidue.setActionCommand("annotate residue"); + annotateResidue.setLabel("annotate residue???"); + unGroupMenuItem.setLabel("Remove Group"); + unGroupMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + unGroupMenuItem_actionPerformed(e); + } + }); + + outline.setLabel("Border colour"); + outline.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + outline_actionPerformed(e); + } + }); + nucleotideMenuItem.setLabel("Nucleotide"); + nucleotideMenuItem.addActionListener(new ActionListener() + { + public void actionPerformed(ActionEvent e) + { + nucleotideMenuItem_actionPerformed(e); + } + }); + + add(groupMenu); + this.add(sequenceMenu); + this.add(residueMenu); + groupMenu.add(defineMenu); + groupMenu.add(unGroupMenuItem); + groupMenu.addSeparator(); + groupMenu.add(analyze); + defineMenu.add(groupName); + defineMenu.add(groupAnnotation); + defineMenu.addSeparator(); + defineMenu.add(outline); + defineMenu.addSeparator(); + defineMenu.add(noColourmenuItem); + defineMenu.add(clustalColour); + defineMenu.add(BLOSUM62Colour); + defineMenu.add(PIDColour); + + defineMenu.add(zappoColour); + defineMenu.add(taylorColour); + defineMenu.add(hydrophobicityColour); + defineMenu.add(helixColour); + defineMenu.add(strandColour); + defineMenu.add(turnColour); + defineMenu.add(buriedColour); + defineMenu.add(nucleotideMenuItem); + + defineMenu.add(userDefinedColour); + + defineMenu.addSeparator(); + defineMenu.add(abovePIDColour); + defineMenu.add(conservationMenuItem); + + sequenceMenu.add(sequenceName); + residueMenu.add(annotateResidue); + + noColourmenuItem.setLabel("None"); + noColourmenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + noColourmenuItem_actionPerformed(e); + } + }); + + clustalColour.setLabel("Clustalx colours"); + clustalColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + clustalColour_actionPerformed(e); + } + }); + zappoColour.setLabel("Zappo"); + zappoColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + zappoColour_actionPerformed(e); + } + }); + taylorColour.setLabel("Taylor"); + taylorColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + taylorColour_actionPerformed(e); + } + }); + hydrophobicityColour.setLabel("Hydrophobicity"); + hydrophobicityColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + hydrophobicityColour_actionPerformed(e); + } + }); + helixColour.setLabel("Helix propensity"); + helixColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + helixColour_actionPerformed(e); + } + }); + strandColour.setLabel("Strand propensity"); + strandColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + strandColour_actionPerformed(e); + } + }); + turnColour.setLabel("Turn propensity"); + turnColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + turnColour_actionPerformed(e); + } + }); + buriedColour.setLabel("Buried Index"); + buriedColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + buriedColour_actionPerformed(e); + } + }); + abovePIDColour.setLabel("Above % Identity"); + abovePIDColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + abovePIDColour_actionPerformed(e); + } + }); + userDefinedColour.setLabel("User Defined"); + userDefinedColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + userDefinedColour_actionPerformed(e); + } + }); + PIDColour.setLabel("Percentage Identity"); + PIDColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + PIDColour_actionPerformed(e); + } + }); + BLOSUM62Colour.setLabel("BLOSUM62"); + BLOSUM62Colour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + BLOSUM62Colour_actionPerformed(e); + } + }); + conservationMenuItem.setLabel("Conservation"); + conservationMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + conservationMenuItem_actionPerformed(e); + } + }); + + + + } + + void refresh() + { + SequenceGroup sg = getGroup(); + SuperGroup superG = ap.av.alignment.getSuperGroup( sg ); + if( superG !=null) + superG.setSuperGroupProperties( sg ); + + ap.seqPanel.repaint(); + } + + protected void clustalColour_actionPerformed(ActionEvent e) + { + SequenceGroup sg = getGroup(); + sg.cs = new ClustalxColourScheme(sg.sequences, ap.av.alignment.getWidth()); + refresh(); + } + + protected void zappoColour_actionPerformed(ActionEvent e) + { + getGroup().cs = new ZappoColourScheme(); + refresh(); + } + + protected void taylorColour_actionPerformed(ActionEvent e) + { + getGroup().cs = new TaylorColourScheme(); + refresh(); + } + + + protected void hydrophobicityColour_actionPerformed(ActionEvent e) + { + getGroup().cs = new HydrophobicColourScheme(); + refresh(); + } + + protected void helixColour_actionPerformed(ActionEvent e) + { + getGroup().cs = new HelixColourScheme(); + refresh(); + } + + protected void strandColour_actionPerformed(ActionEvent e) + { + getGroup().cs = new StrandColourScheme(); + refresh(); + } + + protected void turnColour_actionPerformed(ActionEvent e) + { + getGroup().cs = new TurnColourScheme(); + refresh(); + } + + protected void buriedColour_actionPerformed(ActionEvent e) + { + getGroup().cs = new BuriedColourScheme(); + refresh(); + } + + public void nucleotideMenuItem_actionPerformed(ActionEvent e) + { + getGroup().cs = new NucleotideColourScheme(); + refresh(); + } + + + + protected void abovePIDColour_actionPerformed(ActionEvent e) + { + SequenceGroup sg = getGroup(); + if (abovePIDColour.getState()) + { + sg.cs.setConsensus(AAFrequency.calculate(sg.sequences, 0, + ap.av.alignment.getWidth())); + int threshold = SliderPanel.setPIDSliderSource(ap, sg.cs, getGroup().getName()); + if (sg.cs instanceof ResidueColourScheme) + ( (ResidueColourScheme)sg. cs).setThreshold(threshold); + else if (sg.cs instanceof ScoreColourScheme) + ( (ScoreColourScheme) sg.cs).setThreshold(threshold); + + SliderPanel.showPIDSlider(); + + + } + else // remove PIDColouring + { + ResidueColourScheme rcs = (ResidueColourScheme) sg.cs; + rcs.setThreshold(0); + sg.cs = rcs; + } + + refresh(); + + } + + + protected void userDefinedColour_actionPerformed(ActionEvent e) + { + UserDefinedColours chooser = new UserDefinedColours( ap, getGroup()); + } + + protected void PIDColour_actionPerformed(ActionEvent e) + { + + } + + protected void BLOSUM62Colour_actionPerformed(ActionEvent e) + { + SequenceGroup sg = getGroup(); + + sg.cs = new Blosum62ColourScheme(); + + sg.cs.setConsensus(AAFrequency.calculate(sg.sequences, 0, + ap.av.alignment.getWidth())); + + refresh(); + } + + + protected void noColourmenuItem_actionPerformed(ActionEvent e) + { + getGroup().cs = null; + refresh(); + } + + protected void conservationMenuItem_actionPerformed(ActionEvent e) + { + SequenceGroup sg = getGroup(); + + if(conservationMenuItem.getState()) + { + + Conservation c = new Conservation("Group", + ResidueProperties.propHash, 3, + sg.sequences, 0, + ap.av.alignment.getWidth()); + + c.calculate(); + c.verdict(false, ap.av.ConsPercGaps); + ConservationColourScheme ccs = new ConservationColourScheme(c, sg.cs); + + + sg.cs = ccs; + + SliderPanel.setConservationSlider(ap, ccs, sg.getName()); + SliderPanel.showConservationSlider(); + } + else // remove ConservationColouring + { + ConservationColourScheme ccs = (ConservationColourScheme)sg.cs; + sg.cs = ccs.cs; + } + + refresh(); + } + + protected void groupAnnotation_actionPerformed(ActionEvent e) + { + + } + + protected void groupName_actionPerformed(ActionEvent e) + { + /* SequenceGroup sg = getGroup(); + String reply = JOptionPane.showInternalInputDialog(Desktop.desktop, "Enter new group name", "Edit group name", JOptionPane.QUESTION_MESSAGE); + if(reply==null) + return; + + sg.setName(reply); + groupName.setLabel(reply);*/ + } + + + protected void analyze_actionPerformed(ActionEvent e) + { + CutAndPasteTransfer cap = new CutAndPasteTransfer(false); + Frame frame = new Frame(); + frame.add(cap); + jalview.bin.JalviewLite.addFrame(frame, "Analyze this - ", 400, 300); + SequenceGroup sg = getGroup(); + StringBuffer sb = new StringBuffer(); + + for(int i=0; i0) + { + undoMenuItem.setEnabled(true); + Object [] history = (Object[])historyList.elementAt(0); + undoMenuItem.setLabel("Undo "+history[0]); + } + else + { + undoMenuItem.setEnabled(false); + undoMenuItem.setLabel("Undo"); + } + + if(redoList.size()>0) + { + redoMenuItem.setEnabled(true); + Object [] history = (Object[])redoList.elementAt(0); + redoMenuItem.setLabel("Redo "+history[0]); + } + else + { + redoMenuItem.setEnabled(false); + redoMenuItem.setLabel("Redo"); + } + } + + public void addHistoryItem(String type) + { + // must make sure we add new sequence objects her, not refs to the existing sequences + redoList.removeAllElements(); + SequenceI[] seq = new SequenceI[viewport.getAlignment().getHeight()]; + for(int i=0; i -1; i--) + { + SequenceI seq = viewport.alignment.getSequenceAt(i); + if (!sg.sequences.contains(seq)) + continue; + + SequenceI temp = viewport.alignment.getSequenceAt(i + 1); + if (sg.sequences.contains(temp)) + continue; + + viewport.alignment.getSequences().setElementAt(temp, i); + viewport.alignment.getSequences().setElementAt(seq, i + 1); + } + } + + alignPanel.repaint(); + } + + + StringBuffer copiedSequences; + protected void copy_actionPerformed(ActionEvent e) + { + if(viewport.getSelectionGroup()==null) + return; + + SequenceGroup sg = viewport.getSelectionGroup(); + copiedSequences = new StringBuffer(); + + for(int i=0; i 0) + { + int min = colSel.getMin(); + viewport.getAlignment().trimLeft(min); + colSel.compensateForEdit(0,min); + + if(viewport.getSelectionGroup()!=null) + viewport.getSelectionGroup().adjustForRemoveLeft(min); + + Vector groups = viewport.alignment.getGroups(); + for(int i=0; i 0) + { + int max = colSel.getMax(); + viewport.getAlignment().trimRight(max); + if(viewport.getSelectionGroup()!=null) + viewport.getSelectionGroup().adjustForRemoveRight(max); + + Vector groups = viewport.alignment.getGroups(); + for(int i=0; i1) + { + Frame frame = new Frame(); + frame.add(new PairwiseAlignPanel(viewport)); + jalview.bin.JalviewLite.addFrame(frame, "Pairwise Alignment", 600, 500); + } + } + + public void PCAMenuItem_actionPerformed(ActionEvent e) + { + + if( (viewport.getSelectionGroup()!=null && viewport.getSelectionGroup().getSize()<4 && viewport.getSelectionGroup().getSize()>0) + || viewport.getAlignment().getHeight()<4) + { + return; + } + + try{ + PCAPanel pcaPanel = new PCAPanel(viewport, null); + Frame frame = new Frame(); + frame.add(pcaPanel); + jalview.bin.JalviewLite.addFrame(frame, "Principal component analysis", 400, 400); + }catch(java.lang.OutOfMemoryError ex) + { + } + + + } + + public void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e) + { + NewTreePanel("AV", "PID", "Average distance tree using PID"); + } + + public void neighbourTreeMenuItem_actionPerformed(ActionEvent e) + { + NewTreePanel("NJ", "PID", "Neighbour joining tree using PID"); + } + + + protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e) + { + NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62"); + } + + protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e) + { + NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62PID"); + } + + void NewTreePanel(String type, String pwType, String title) + { + //are the sequences aligned? + if(!viewport.alignment.isAligned()) + { + return; + } + + final TreePanel tp; + if (viewport.getSelectionGroup() != null && + viewport.getSelectionGroup().getSize() > 3) + { + tp = new TreePanel(viewport, viewport.getSelectionGroup().sequences, type, + pwType, + 0, viewport.alignment.getWidth()); + } + else + { + tp = new TreePanel(viewport, viewport.getAlignment().getSequences(), + type, pwType, 0, viewport.alignment.getWidth()); + } + + addTreeMenuItem(tp, title); + + jalview.bin.JalviewLite.addFrame(tp, title, 600, 500); + } + + void addTreeMenuItem(final TreePanel treePanel, String title) + { + final MenuItem item = new MenuItem(title); + sortByTreeMenu.add(item); + item.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + addHistoryItem("sort"); + AlignmentSorter.sortByTree(viewport.getAlignment(), treePanel.getTree()); + alignPanel.repaint(); + } + }); + + treePanel.addWindowListener(new WindowAdapter() + { + public void windowClosing(WindowEvent e) + { + sortByTreeMenu.remove(item); + }; + }); + } + + protected void documentation_actionPerformed(ActionEvent e) { + + jalview.bin.JalviewLite.showURL("http://www.jalview.org"); + + } + + protected void about_actionPerformed(ActionEvent e) + { + class AboutPanel extends Canvas + { + public void paint(Graphics g) + { + g.setColor(Color.white); + g.fillRect(0,0,getSize().width, getSize().height); + g.setFont(new Font("Helvetica", Font.PLAIN, 12)); + FontMetrics fm = g.getFontMetrics(); + int fh = fm.getHeight(); + int y=20, x=7; + g.setColor(Color.black); + g.setFont(new Font("Helvetica", Font.BOLD, 14)); + g.drawString("JalView 2005", 200,y+=fh); + g.setFont(new Font("Helvetica", Font.PLAIN, 12)); + g.drawString("Authors: Michele Clamp, James Cuff, Steve Searle, Andrew Waterhouse, Jim Procter & Geoff Barton.",x,y+=fh*2); + g.drawString("Current development managed by Andrew Waterhouse; Barton Group, University of Dundee.",x,y+=fh); + g.drawString("If you use JalView, please cite:",x,y+=fh+8); + g.drawString("\"Clamp, M., Cuff, J., Searle, S. M. and Barton, G. J. (2004), The Jalview Java Alignment Editor\"",x,y+=fh); + g.drawString("Bioinformatics, 2004 12;426-7.",x,y+=fh); + } + } + Frame frame = new Frame(); + frame.add(new AboutPanel()); + jalview.bin.JalviewLite.addFrame(frame, "Jalview 2005", 580,200); + + + + } +} diff --git a/src/jalview/appletgui/AlignViewport.java b/src/jalview/appletgui/AlignViewport.java new file mode 100755 index 0000000..0b6ec1a --- /dev/null +++ b/src/jalview/appletgui/AlignViewport.java @@ -0,0 +1,505 @@ +package jalview.appletgui; + +import java.awt.*; +import jalview.bin.*; +import jalview.analysis.*; +import jalview.datamodel.*; +import jalview.schemes.*; +import java.util.*; + +public class AlignViewport +{ + int startRes; + int endRes; + + int startSeq; + int endSeq; + + boolean showFullId = true; + boolean showText=true; + boolean showColourText=false; + boolean showBoxes=true; + boolean wrapAlignment=false; + boolean renderGaps = true; + boolean showSequenceFeatures = false; + boolean showAnnotation = true; + boolean showConservation = true; + boolean showQuality = true; + boolean showConsensus = true; + + boolean colourAppliesToAllGroups = true; + ColourSchemeI globalColourScheme = null; + boolean conservationColourSelected = false; + boolean abovePIDThreshold = false; + + SequenceGroup selectionGroup = new SequenceGroup(); + + int charHeight; + int charWidth; + int chunkWidth; + int chunkHeight; + + Font font = new Font("SansSerif",Font.PLAIN,10); + AlignmentI alignment; + + ColumnSelection colSel = new ColumnSelection(); + + int threshold; + int increment; + + NJTree currentTree = null; + + boolean scaleAboveWrapped = true; + boolean scaleLeftWrapped = true; + boolean scaleRightWrapped = true; + + public AlignViewport(AlignmentI al, JalviewLite applet) + { + setAlignment(al); + this.startRes = 0; + this.endRes = al.getWidth()-1; + this.startSeq = 0; + this.endSeq = al.getHeight()-1; + setFont(font); + + + if(applet!=null) + { + String param = applet.getParameter("showFullId"); + if (param != null) + showFullId = Boolean.valueOf(param).booleanValue(); + + param = applet.getParameter("showAnnotation"); + if (param != null) + showAnnotation = Boolean.valueOf(param).booleanValue(); + + param = applet.getParameter("showConservation"); + if (param != null) + showConservation = Boolean.valueOf(param).booleanValue(); + + param = applet.getParameter("showQuality"); + if (param != null) + showQuality = Boolean.valueOf(param).booleanValue(); + + param = applet.getParameter("showConsensus"); + if (param != null) + showConsensus = Boolean.valueOf(param).booleanValue(); + } + // We must set conservation and consensus before setting colour, + // as Blosum and Clustal require this to be done + updateConservation(); + updateConsensus(); + + if(applet!=null && applet.getParameter("defaultColour")!=null) + { + globalColourScheme = ColourSchemeProperty.getColour(alignment, + applet.getParameter("defaultColour")); + if(globalColourScheme!=null) + globalColourScheme.setConsensus( vconsensus ); + } + } + + + public void showSequenceFeatures(boolean b) + { + showSequenceFeatures = b; + } + + public Vector vconsensus; + AlignmentAnnotation consensus; + AlignmentAnnotation conservation; + AlignmentAnnotation quality; + + public int ConsPercGaps = 25; // JBPNote : This should be a scalable property! + + public void updateConservation() + { + Conservation cons = new jalview.analysis.Conservation("All", + jalview.schemes.ResidueProperties.propHash, 3, + alignment.getSequences(), 0, + alignment.getWidth()-1); + cons.calculate(); + cons.verdict(false, ConsPercGaps); + cons.findQuality(); + int alWidth = alignment.getWidth(); + Annotation [] annotations = new Annotation[alWidth]; + Annotation [] qannotations = new Annotation[alWidth]; + String sequence = cons.getConsSequence().getSequence(); + float minR,minG,minB, maxR,maxG,maxB; + minR = 0.3f; + minG = 0.0f; + minB = 0f; + maxR = 1.0f-minR; maxG=0.9f-minG; maxB=0f-minB; // scalable range for colouring both Conservation and Quality + float min = 0f; + float max = 11f; + float qmin = cons.qualityRange[0].floatValue(); + float qmax = cons.qualityRange[1].floatValue(); + + for (int i = 0; i < alWidth; i++) + { + float value = 0; + try + { + value = Integer.parseInt(sequence.charAt(i) + ""); + } + catch (Exception ex) + { + if (sequence.charAt(i) == '*') value = 11; + if (sequence.charAt(i) == '+') value = 10; + } + float vprop = value-min; + vprop/=max; + annotations[i] = new Annotation(sequence.charAt(i) + "", + "Conservation graph", ' ', value, new Color(minR+maxR*vprop, minG+maxG*vprop, minB+maxB*vprop)); + // Quality calc + value = ((Double) cons.quality.elementAt(i)).floatValue(); + vprop = value - qmin; + vprop/=qmax; + qannotations[i] = new Annotation(" ", + String.valueOf(value), ' ', value, new Color(minR+maxR*vprop, minG+maxG*vprop, minB+maxB*vprop)); + } + + if(conservation==null) + { + conservation = new AlignmentAnnotation("Conservation", + "Conservation of total alignment less than "+ConsPercGaps+"% gaps", + annotations, + 0f, // cons.qualityRange[0].floatValue(), + 11f, // cons.qualityRange[1].floatValue() + 1); + if(showConservation) + alignment.addAnnotation(conservation); + quality = new AlignmentAnnotation("Quality", + "Alignment Quality based on Blosum62 scores", + qannotations, + cons.qualityRange[0].floatValue(), + cons.qualityRange[1].floatValue(), + 1); + if(showQuality) + alignment.addAnnotation(quality); + } + else { + conservation.annotations = annotations; + quality.annotations = qannotations; + quality.graphMax = cons.qualityRange[1].floatValue(); + } + + + } + + public void updateConsensus() + { + Annotation [] annotations = new Annotation[alignment.getWidth()]; + + // this routine prevents vconsensus becoming a new object each time + // consenus is calculated. Important for speed of Blosum62 + // and PID colouring of alignment + if(vconsensus == null) + vconsensus = alignment.getAAFrequency(); + else + { + Vector temp = alignment.getAAFrequency(); + vconsensus.removeAllElements(); + Enumeration e = temp.elements(); + while(e.hasMoreElements()) + { + vconsensus.addElement(e.nextElement()); + } + } + Hashtable hash = null; + for (int i = 0; i2) + { + mouseOver = "["+maxRes+"] "; + maxRes = "+ "; + } + + mouseOver += (int)value+"%"; + annotations[i] = new Annotation(maxRes, mouseOver, ' ', value); + + } + + if(consensus==null) + { + consensus = new AlignmentAnnotation("Consensus", + "PID", annotations, 0f, 100f, 1); + if(showConsensus) + alignment.addAnnotation(consensus); + } + else + consensus.annotations = annotations; + + } + + + public SequenceGroup getSelectionGroup() + { + return selectionGroup; + } + + public void setSelectionGroup(SequenceGroup sg) + { + selectionGroup = sg; + } + + + public boolean getConservationSelected() + { + return conservationColourSelected; + } + + public void setConservationSelected(boolean b) + { + conservationColourSelected = b; + } + + public boolean getAbovePIDThreshold() + { + return abovePIDThreshold; + } + + public void setAbovePIDThreshold(boolean b) + { + abovePIDThreshold = b; + } + + public int getStartRes() { + return startRes; + } + + public int getEndRes() { + return endRes; + } + + public int getStartSeq() { + return startSeq; + } + + public void setGlobalColourScheme(ColourSchemeI cs) + { + globalColourScheme = cs; + } + + public ColourSchemeI getGlobalColourScheme() + { + return globalColourScheme; + } + + + public void setStartRes(int res) { + this.startRes = res; + } + public void setStartSeq(int seq) { + this.startSeq = seq; + } + public void setEndRes(int res) { + if (res > alignment.getWidth()-1) { + System.out.println(" Corrected res from " + res + " to maximum " + (alignment.getWidth()-1)); + res = alignment.getWidth()-1; + } + if (res < 0) { + res = 0; + } + this.endRes = res; + } + public void setEndSeq(int seq) { + if (seq > alignment.getHeight()) { + seq = alignment.getHeight(); + } + if (seq < 0) { + seq = 0; + } + this.endSeq = seq; + } + public int getEndSeq() { + return endSeq; + } + + public void setFont(Font f) { + font = f; + java.awt.Frame temp = new java.awt.Frame(); + temp.addNotify(); + java.awt.FontMetrics fm = temp.getGraphics().getFontMetrics(font); + setCharHeight(fm.getHeight()); + setCharWidth(fm.charWidth('M')); + } + + public Font getFont() { + return font; + } + public void setCharWidth(int w) { + this.charWidth = w; + } + public int getCharWidth() { + return charWidth; + } + public void setCharHeight(int h) { + this.charHeight = h; + } + public int getCharHeight() { + return charHeight; + } + public void setChunkWidth(int w) { + this.chunkWidth = w; + } + public int getChunkWidth() { + return chunkWidth; + } + public void setChunkHeight(int h) { + this.chunkHeight = h; + } + public int getChunkHeight() { + return chunkHeight; + } + public AlignmentI getAlignment() { + return alignment; + } + public void setAlignment(AlignmentI align) { + this.alignment = align; + } + + public void setWrapAlignment(boolean state) { + wrapAlignment = state; + } + public void setShowText(boolean state) { + showText = state; + } + + public void setRenderGaps(boolean state){ + renderGaps = state; + } + + + public boolean getColourText() + { + return showColourText; + } + + public void setColourText(boolean state) + { + showColourText = state; + } + + public void setShowBoxes(boolean state) { + showBoxes = state; + } + + public boolean getWrapAlignment() { + return wrapAlignment; + } + public boolean getShowText() { + return showText; + } + public boolean getShowBoxes() { + return showBoxes; + } + + public char getGapCharacter() { + return getAlignment().getGapCharacter(); + } + public void setGapCharacter(char gap) { + if (getAlignment() != null) { + getAlignment().setGapCharacter(gap); + } + } + public void setThreshold(int thresh) { + threshold = thresh; + } + public int getThreshold() { + return threshold; + } + public void setIncrement(int inc) { + increment = inc; + } + public int getIncrement() { + return increment; + } + public int getIndex(int y) { + int y1 = 0; + int starty = getStartSeq(); + int endy = getEndSeq(); + + for (int i = starty; i <= endy; i++) { + if (i < alignment.getHeight() && alignment.getSequenceAt(i) != null) { + int y2 = y1 + getCharHeight(); + + if (y>=y1 && y <=y2) { + return i; + } + y1 = y2; + } else { + return -1; + } + } + return -1; + } + + public ColumnSelection getColumnSelection() { + return colSel; + } + + public void resetSeqLimits(int height) { + setEndSeq(height/getCharHeight()); + } + public void setCurrentTree(NJTree tree) { + currentTree = tree; + } + public NJTree getCurrentTree() { + return currentTree; + } + + + public void setColourAppliesToAllGroups(boolean b) + { colourAppliesToAllGroups = b; } + + public boolean getColourAppliesToAllGroups() + {return colourAppliesToAllGroups; } + + public boolean getShowFullId() + { + return showFullId; + } + + public void setShowFullId(boolean b) + { + showFullId = b; + } + + public boolean getShowAnnotation() + { + return showAnnotation; + } + + public void setShowAnnotation(boolean b) + { + showAnnotation = b; + } + + public boolean getScaleAboveWrapped() + { return scaleAboveWrapped;} + + public boolean getScaleLeftWrapped() + { return scaleLeftWrapped; } + + public boolean getScaleRightWrapped() + { return scaleRightWrapped; } + + public void setScaleAboveWrapped(boolean b) + { scaleAboveWrapped = b; } + + public void setScaleLeftWrapped(boolean b) + { scaleLeftWrapped = b; } + + public void setScaleRightWrapped(boolean b) + { scaleRightWrapped = b; } + + +} diff --git a/src/jalview/appletgui/AlignmentPanel.java b/src/jalview/appletgui/AlignmentPanel.java new file mode 100755 index 0000000..2b101fd --- /dev/null +++ b/src/jalview/appletgui/AlignmentPanel.java @@ -0,0 +1,430 @@ +package jalview.appletgui; + +import jalview.jbappletgui.GAlignmentPanel; +import jalview.schemes.*; +import jalview.analysis.*; +import jalview.datamodel.*; +import java.awt.*; +import java.awt.event.*; + +public class AlignmentPanel extends GAlignmentPanel implements AdjustmentListener +{ + + AlignViewport av; + OverviewPanel overviewPanel; + SeqPanel seqPanel; + IdPanel idPanel; + IdwidthAdjuster idwidthAdjuster; + public AlignFrame alignFrame; + ScalePanel scalePanel; + AnnotationPanel annotationPanel; + AnnotationLabels alabels; + + // this value is set false when selection area being dragged + boolean fastPaint = true; + + public AlignmentPanel(AlignFrame af, final AlignViewport av) + { + alignFrame = af; + this.av = av; + seqPanel = new SeqPanel (av, this); + idPanel = new IdPanel (av, this); + scalePanel = new ScalePanel(av, this); + idwidthAdjuster = new IdwidthAdjuster(this); + annotationPanel = new AnnotationPanel(this); + alabels = new AnnotationLabels(this); + + + idPanelHolder.add(idPanel, BorderLayout.CENTER); + idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER); + annotationScroller.add(annotationPanel); + annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER); + scalePanelHolder.add(scalePanel, BorderLayout.CENTER); + seqPanelHolder.add(seqPanel, BorderLayout.CENTER); + + fontChanged(); + setScrollValues(0, 0); + + hscroll.addAdjustmentListener(this); + vscroll.addAdjustmentListener(this); + + seqPanel.seqCanvas.addKeyListener( new MyKeyAdapter() ); + idPanel.idCanvas.addKeyListener( new MyKeyAdapter() ); + + addComponentListener(new ComponentAdapter() + { + public void componentResized(ComponentEvent evt) + { + setScrollValues(av.getStartRes(), av.getStartSeq()); + repaint(); + } + }); + + Dimension d = calculateIdWidth(); + idPanel.idCanvas.setSize(d); + + hscrollFillerPanel.setSize(d.width, annotationPanel.getSize().height); + annotationScroller.setSize(annotationPanel.getSize()); + + idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height); + annotationSpaceFillerHolder.setSize(d.width,annotationPanel.getSize().height); + alabels.setSize(d.width,annotationPanel.getSize().height); + + } + + class MyKeyAdapter extends KeyAdapter + { + public void keyPressed(KeyEvent evt) + { + switch(evt.getKeyCode()) + { + case 27: // escape key + av.setSelectionGroup(null); + alignFrame.alignPanel.repaint(); + break; + case KeyEvent.VK_X: + if(evt.isControlDown()) + alignFrame.cut_actionPerformed(null); + break; + case KeyEvent.VK_C: + if(evt.isControlDown()) + alignFrame.copy_actionPerformed(null); + break; + case KeyEvent.VK_V: + if(evt.isControlDown()) + alignFrame.paste(true); + break; + case KeyEvent.VK_A: + if(evt.isControlDown()) + alignFrame.selectAllSequenceMenuItem_actionPerformed(null); + break; + case KeyEvent.VK_DOWN: + alignFrame.moveSelectedSequences(false); + break; + case KeyEvent.VK_UP: + alignFrame.moveSelectedSequences(true); + break; + case KeyEvent.VK_F: + if(evt.isControlDown()) + alignFrame.findMenuItem_actionPerformed(null); + break; + } + } + } + + public void fontChanged() + { + // set idCanvas bufferedImage to null + // to prevent drawing old image + FontMetrics fm = getFontMetrics(av.getFont()); + + scalePanel.setSize(new Dimension(10, av.charHeight+fm.getDescent())); + idwidthAdjuster.setSize(new Dimension(10, av.charHeight+fm.getDescent())); + + annotationPanel.adjustPanelHeight(); + annotationPanel.repaint(); + Dimension d = calculateIdWidth(); + d.setSize(d.width + 4, seqPanel.seqCanvas.getSize().height); + idPanel.idCanvas.setSize(d); + hscrollFillerPanel.setSize(d); + + alignFrame.pack(); + } + + public void setIdWidth(int w, int h) + { + idPanel.idCanvas.setSize(w,h); + idPanelHolder.setSize(w,idPanelHolder.getSize().height); + alabels.setSize(w,alabels.getSize().height); + validate(); + } + Dimension calculateIdWidth() + { + Frame frame = new Frame(); + frame.addNotify(); + Graphics g = frame.getGraphics(); + if(g==null) + { + Frame f = new Frame(); + f.addNotify(); + g = f.getGraphics(); + } + + FontMetrics fm = g.getFontMetrics(av.font); + AlignmentI al = av.getAlignment(); + + int i = 0; + int idWidth = 0; + String id; + while (i < al.getHeight() && al.getSequenceAt(i) != null) + { + SequenceI s = al.getSequenceAt(i); + if(av.getShowFullId()) + id = s.getDisplayId(); + else + id = s.getName(); + + if (fm.stringWidth(id) > idWidth) + idWidth = fm.stringWidth(id); + i++; + } + + // Also check annotation label widths + i=0; + if(al.getAlignmentAnnotation()!=null) + { + fm = g.getFontMetrics(frame.getFont()); + while (i < al.getAlignmentAnnotation().length) + { + String label = al.getAlignmentAnnotation()[i].label; + if (fm.stringWidth(label) > idWidth) + idWidth = fm.stringWidth(label); + i++; + } + } + + return new Dimension(idWidth, idPanel.idCanvas.getSize().height); + } + + + public void highlightSearchResults(int [] results) + { + seqPanel.seqCanvas.highlightSearchResults( results ); + + // do we need to scroll the panel? + if(results!=null && (av.getStartSeq()>results[0] + || av.getEndSeq()results[1] + || av.getEndRes()= av.getAlignment().getHeight()) + return false; + fastPaint = false; + vscroll.setValue(vscroll.getValue() + 1); + } + fastPaint = true; + return true; + } + + public boolean scrollRight(boolean right) + { + + if (right) + { + if (hscroll.getValue() < 1) + return false; + fastPaint = false; + hscroll.setValue(hscroll.getValue() - 1); + } + else + { + if (hextent + hscroll.getValue() >= av.getAlignment().getWidth()) + return false; + fastPaint = false; + hscroll.setValue(hscroll.getValue() + 1); + } + fastPaint = true; + return true; + } + + + public void setScrollValues(int x, int y) + { + + av.setStartRes(x); + av.setStartSeq(y); + av.setEndRes(x + seqPanel.seqCanvas.getSize().width/av.getCharWidth()-1); + + hextent = seqPanel.seqCanvas.getSize().width/av.charWidth; + vextent = seqPanel.seqCanvas.getSize().height/av.charHeight; + + if(hextent > av.alignment.getWidth()) + hextent = av.alignment.getWidth(); + if(vextent > av.alignment.getHeight()) + vextent = av.alignment.getHeight(); + + if(hextent+x > av.getAlignment().getWidth()) + x = av.getAlignment().getWidth()- hextent; + + if(vextent+y > av.getAlignment().getHeight()) + y = av.getAlignment().getHeight() - vextent; + + if(y<0) + y = 0; + + if(x<0) + x=0; + + + int endSeq = y + vextent; + if(endSeq>av.alignment.getHeight()) + endSeq = av.alignment.getHeight(); + + + av.setEndSeq( endSeq ); + hscroll.setValues(x,hextent,0,av.getAlignment().getWidth()); + vscroll.setValues(y,vextent,0,av.getAlignment().getHeight() ); + + } + + + public void adjustmentValueChanged(AdjustmentEvent evt) + { + int oldX = av.getStartRes(); + int oldY = av.getStartSeq(); + + if (evt.getSource() == hscroll) + { + int x = hscroll.getValue(); + av.setStartRes(x); + av.setEndRes(x + seqPanel.seqCanvas.getSize().width/av.getCharWidth()-1); + } + + if (evt.getSource() == vscroll) + { + int offy = vscroll.getValue(); + if (av.getWrapAlignment()) + { + int rowSize = seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width); + av.setStartRes( vscroll.getValue() * rowSize ); + av.setEndRes( (vscroll.getValue()+1) * rowSize ); + } + else + { + av.setStartSeq(offy); + av.setEndSeq(offy + seqPanel.seqCanvas.getSize().height / av.getCharHeight()); + } + } + + if(overviewPanel!=null) + overviewPanel.setBoxPosition(); + + if(av.getWrapAlignment() || !fastPaint) + repaint(); + else + { + idPanel.idCanvas.fastPaint(av.getStartSeq() - oldY); + seqPanel.seqCanvas.fastPaint(av.getStartRes() - oldX, + av.getStartSeq() - oldY); + + scalePanel.repaint(); + if (av.getShowAnnotation()) + annotationPanel.fastPaint(av.getStartRes() - oldX); + } + + } + + public void update(Graphics g) + { + paint (g); + } + + + public void paint(Graphics g) + { + Dimension d = idPanel.idCanvas.getSize(); + idPanel.idCanvas.setSize(d.width, seqPanel.seqCanvas.getSize().height); + annotationSpaceFillerHolder.setSize(d.width,annotationPanel.getSize().height); + alabels.setSize(d.width,annotationPanel.getSize().height); + + alabels.repaint(); + idPanel.idCanvas.repaint(); + seqPanel.seqCanvas.repaint(); + scalePanel.repaint(); + annotationPanel.repaint(); + + + if (av.getWrapAlignment()) + { + int max = av.alignment.getWidth() / seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.seqCanvas.getSize().width); + vscroll.setMaximum(max); + vscroll.setUnitIncrement(1); + vscroll.setVisibleAmount(1); + } + else + { + setScrollValues(av.getStartRes(), av.getStartSeq()); + } + + + + } +} diff --git a/src/jalview/appletgui/AnnotationLabels.java b/src/jalview/appletgui/AnnotationLabels.java new file mode 100755 index 0000000..f51f465 --- /dev/null +++ b/src/jalview/appletgui/AnnotationLabels.java @@ -0,0 +1,99 @@ + +package jalview.appletgui; + +import java.awt.event.*; +import java.awt.*; +import jalview.datamodel.*; + +public class AnnotationLabels extends Panel +{ + boolean active = false; + Image image; + AlignmentPanel ap ; + boolean resizing = false; + int oldY, mouseX; + static String ADDNEW = "Add new row"; + static String HIDE = "Hide this row"; + static String DELETE = "Delete this row"; + static String SHOWALL="Show all hidden rows"; + int selectedRow = 0; + int scrollOffset = 0; + + public AnnotationLabels(AlignmentPanel ap) + { + this.ap = ap; + setLayout(null); + + java.net.URL url = getClass().getResource("/images/idwidth.gif"); + if (url != null) + image = java.awt.Toolkit.getDefaultToolkit().getImage(url); + + try + { + MediaTracker mt = new MediaTracker(this); + mt.addImage(image, 0); + mt.waitForID(0); + } + catch (Exception ex) {} + } + + public void setScrollOffset(int y) + { + scrollOffset = y; + repaint(); + } + + public void paint(Graphics g) + { + drawComponent(g); + } + + public void drawComponent(Graphics g) + { + FontMetrics fm = g.getFontMetrics(g.getFont()); + g.setColor(Color.white); + g.fillRect(0,0, getSize().width, getSize().height); + + g.translate(0, scrollOffset); + g.setColor(Color.black); + + AlignmentAnnotation[] aa = ap.av.alignment.getAlignmentAnnotation(); + int y = g.getFont().getSize(); + int x = 0; + + if(aa!=null) + for(int i=0; i0) // scrollbar pulled right, image to the left + { + transX = (er-sr-horizontal)*av.charWidth; + sr = er - horizontal ; + } + else if(horizontal<0) + { + er = sr-horizontal; + } + + + gg.translate(transX, 0); + + drawComponent(gg, sr, er); + + gg.translate( -transX, 0 ); + + fastPaint = true; + repaint(); +} + + + public void drawComponent(Graphics g, int startRes, int endRes) + { + g.setColor(Color.white); + g.fillRect(0,0,(endRes-startRes) *av.charWidth, getSize().height); + if(av.alignment.getAlignmentAnnotation()==null || av.alignment.getAlignmentAnnotation().length<1) + { + g.setColor(Color.white); + g.fillRect(0,0,getSize().width, getSize().height); + g.setColor(Color.black); + g.drawString("Alignment has no annotations",20,15); + return; + } + + AlignmentAnnotation [] aa = av.alignment.getAlignmentAnnotation(); + + int j, x=0, y=0; + char [] lastSS = new char[aa.length]; + int [] lastSSX= new int[aa.length] ; + int iconOffset = av.charHeight/2; + boolean validRes = false; + //\u03B2 \u03B1 + + for(int i=0; i0) + { + int charOffset = (av.charWidth - fm.charWidth(row.annotations[j].displayCharacter.charAt(0)))/2; + g.setColor( row.annotations[j].colour); + if(j==0) + { + if (row.annotations[0].secondaryStructure == 'H' + || row.annotations[0].secondaryStructure == 'E') + g.drawString(row.annotations[j].displayCharacter, x, + y + iconOffset + 2); + } + else if( (row.annotations[j].secondaryStructure=='H' + || row.annotations[j].secondaryStructure=='E') && + (row.annotations[j-1]==null || + row.annotations[j].secondaryStructure!=row.annotations[j-1].secondaryStructure)) + + g.drawString(row.annotations[j].displayCharacter, x, y + iconOffset + 2); + + if(!row.hasIcons) + g.drawString(row.annotations[j].displayCharacter, x + charOffset, + y + iconOffset + 2); + } + + if(row.hasIcons) + if(!validRes || row.annotations[j].secondaryStructure!=lastSS[i]) + { + switch (lastSS[i]) + { + case 'H': + g.setColor(HELIX_COLOUR); + g.fillRoundRect(lastSSX[i], y+4 + iconOffset, x-lastSSX[i], 7, 8, 8); + break; + case 'E': + g.setColor(SHEET_COLOUR); + g.fillRect(lastSSX[i], y + 4 + iconOffset, x-lastSSX[i]-4, 7); + g.fillPolygon(new int[] {x - 4, x- 4, x } + , new int[]{y+ iconOffset, y + 14+ iconOffset, y + 8+ iconOffset}, 3); + break; + case 'C': + break; + default : + g.setColor(Color.gray); + g.fillRect(lastSSX[i], y+6+ iconOffset, x-lastSSX[i], 2); + break; + } + + if(validRes) + lastSS[i] = row.annotations[j].secondaryStructure; + else + lastSS[i] = ' '; + lastSSX[i] = x; + } + + if (validRes && row.isGraph) + { + g.setColor(new Color(0,0,180)); + int height = (int)((row.annotations[j].value / row.graphMax)*GRAPH_HEIGHT); + + if(row.windowLength>1) + { + int total =0; + for(int i2=j- (row.windowLength/2); i2=av.alignment.getWidth()) + continue; + + total += row.annotations[i2].value; + } + + total/=row.windowLength; + height = (int)( (total / row.graphMax) *GRAPH_HEIGHT); + + } + g.setColor(row.annotations[j].colour); + g.fillRect(x, y-height, av.charWidth, height ); + } + + + } + + x+=av.charWidth; + + if(row.hasIcons) + switch (lastSS[i]) + { + case 'H': + g.setColor(HELIX_COLOUR); + g.fillRoundRect(lastSSX[i], y+4+ iconOffset, x - lastSSX[i], 7, 8, 8); + break; + case 'E': + g.setColor(SHEET_COLOUR); + g.fillRect(lastSSX[i], y + 4+ iconOffset, x - lastSSX[i] - 4, 7); + g.fillPolygon(new int[] + {x - 4, x - 4, x} + , new int[] + {y + iconOffset, y + 14+ iconOffset, y + 7+ iconOffset} + , 3); + break; + case 'C': + break; + default: + g.setColor(Color.gray); + g.fillRect(lastSSX[i], y+6+ iconOffset, x-lastSSX[i], 2); + break; + + } + + if(row.isGraph && row.hasText) + y+=av.charHeight; + if(!row.isGraph) + y+=aa[i].height; + } + } + + // used by overview window + public void drawGraph(Graphics g, AlignmentAnnotation aa,int width, int y) + { + g.setColor(Color.white); + g.fillRect(0,0,width, y); + g.setColor(new Color(0,0,180)); + int x = 0; + for(int j=0; j max) { + max = columnAt(i); + } + } + return max; + } + + public int getMin() { + int min = 1000000000; + + for (int i=0;i= start) + selected.setElementAt(new Integer(temp-change),i); + } + } +} diff --git a/src/jalview/appletgui/CutAndPasteTransfer.java b/src/jalview/appletgui/CutAndPasteTransfer.java new file mode 100755 index 0000000..e4b8c9b --- /dev/null +++ b/src/jalview/appletgui/CutAndPasteTransfer.java @@ -0,0 +1,72 @@ +/******************** + * 2004 Jalview Reengineered + * Barton Group + * Dundee University + * + * AM Waterhouse + *******************/ + +package jalview.appletgui; + +import jalview.jbappletgui.GCutAndPasteTransfer; +import jalview.datamodel.*; +import jalview.io.*; +import java.awt.*; +import java.awt.event.*; + +public class CutAndPasteTransfer extends GCutAndPasteTransfer +{ + public CutAndPasteTransfer(boolean forImport) + { + super(); + + if(!forImport) + { + buttonPanel.setVisible(false); + } + } + + + public String getText() + { + return textarea.getText(); + } + + public void setText(String text) + { + textarea.setText(text); + } + + + protected void ok_actionPerformed(ActionEvent e) + { + String text = getText(); + SequenceI [] sequences = null; + + String format = IdentifyFile.Identify(text, "Paste"); + + // if (FormatProperties.contains( format )) + sequences = FormatAdapter.readFile(text, "Paste", format); + + if(sequences!=null) + { + AlignFrame af = new AlignFrame(new Alignment(sequences)); + jalview.bin.JalviewLite.addFrame(af, "Cut & Paste input - "+format, + AlignFrame.NEW_WINDOW_WIDTH, + AlignFrame.NEW_WINDOW_HEIGHT); + af.statusBar.setText("Successfully pasted alignment file"); + } + + Frame frame = (Frame)this.getParent(); + frame.setVisible(false); + } + + protected void cancel_actionPerformed(ActionEvent e) { + Frame frame = (Frame)this.getParent(); + frame.setVisible(false); + } + + + + +} diff --git a/src/jalview/appletgui/FeatureRenderer.java b/src/jalview/appletgui/FeatureRenderer.java new file mode 100755 index 0000000..a8412f0 --- /dev/null +++ b/src/jalview/appletgui/FeatureRenderer.java @@ -0,0 +1,79 @@ +package jalview.appletgui; + +import jalview.datamodel.*; +import java.awt.*; +import java.util.*; + +public class FeatureRenderer +{ + AlignViewport av; + + SequenceGroup currentSequenceGroup = null; + SequenceGroup [] allGroups = null; + Color resBoxColour; + Graphics graphics; + + public FeatureRenderer(AlignViewport av) + { + this.av = av; + } + + + public void drawSequence(Graphics g,SequenceI seq,SequenceGroup [] sg, int start, int end, int x1, int y1, int width, int height) + { + Vector features = seq.getSequenceFeatures(); + Enumeration e = features.elements(); + while( e.hasMoreElements() ) + { + SequenceFeature sf = (SequenceFeature)e.nextElement(); + if(sf.getStart()>seq.getEnd()) + continue; + + int fstart = seq.findIndex(sf.getStart())-1; + int fend = seq.findIndex(sf.getEnd())-1; + + if( (fstart<=end && fend>=start) ) + { + if(fstart<0) // fix for if the feature we have starts before the sequence start, + fstart = 0;// but the feature end is still valid!! + + if(fstart==fend) + { + g.setColor(Color.red); + g.fillRoundRect( (fstart - start) * width, y1, width, height, 4,4); + g.setColor(Color.white); + + char s = seq.getSequence().charAt(fstart); + FontMetrics fm = g.getFontMetrics(); + int charOffset = (width - fm.charWidth(s))/2; + int pady = height/5; + g.drawString(String.valueOf(s), charOffset + x1 + width * (fstart - start), y1 + height - pady); + + } + else + { + for (int i = fstart; i <= fend; i++) + { + char s = seq.getSequence().charAt(i); + if( jalview.util.Comparison.isGap(s) ) + continue; + + g.setColor(Color.blue); + g.fillRect( (i-start) * width, y1, width, height); + + g.setColor(Color.white); + + FontMetrics fm = g.getFontMetrics(); + int charOffset = (width - fm.charWidth(s)) / 2; + int pady = height / 5; + g.drawString(String.valueOf(s), + charOffset + x1 + width * (i-start), + y1 + height - pady); + } + } + } + + } + } + +} diff --git a/src/jalview/appletgui/Finder.java b/src/jalview/appletgui/Finder.java new file mode 100755 index 0000000..0b1e319 --- /dev/null +++ b/src/jalview/appletgui/Finder.java @@ -0,0 +1,230 @@ +package jalview.appletgui; + +import jalview.jbappletgui.GFinder; +import jalview.datamodel.*; +import java.awt.event.*; +import java.util.*; +import java.awt.*; + +public class Finder extends GFinder +{ + AlignViewport av; + AlignmentPanel ap; + Frame frame; + SuperGroup searchGroup; + + int seqIndex = 0; + int resIndex = 0; + public Finder(final AlignmentPanel ap) + { + this.av = ap.av; + this.ap = ap; + frame = new Frame(); + frame.add(this); + jalview.bin.JalviewLite.addFrame(frame, "Find", 340,120); + frame.repaint(); + frame.addWindowListener(new WindowAdapter() + {public void windowClosing(WindowEvent evt) + { ap.highlightSearchResults( null ); } + }); + } + + public void textfield_actionPerformed(ActionEvent e) + { + doSearch(false); + } + + public void findNext_actionPerformed(ActionEvent e) + { + doSearch(false); + } + + public void findAll_actionPerformed(ActionEvent e) + { + resIndex=0; + seqIndex=0; + doSearch(true); + } + + public void cancel_actionPerformed(ActionEvent e) + { + try{ + // if allResults is null, this effectively switches displaySearch flag in seqCanvas + ap.highlightSearchResults( null ); + ap.idPanel.highlightSearchResults( null ); + // frame.setClosed(true); + }catch(Exception ex){ } + } + + + public void createNewGroup_actionPerformed(ActionEvent e) + { + for(int i=0; i0) + seq = (Sequence)(av.getSelectionGroup().getSequenceAt(0)); + else + seq = (Sequence)av.getAlignment().getSequenceAt(0); + + searchResults.addElement( Integer.toString( av.getAlignment().findIndex(seq) ) ); + searchResults.addElement( Integer.toString( seq.findIndex(res)-1 ) ); + searchResults.addElement( Integer.toString( seq.findIndex(res)-1 ) ); + + }catch(NumberFormatException ex){} + /////////////////////////////////////////////// + + + jalview.schemes.UserColourScheme ucs = new jalview.schemes.UserColourScheme(); + Color [] newColors = new Color[24]; + for(int i=0; i<24; i++) + newColors[i] = new Color(60,160,115); + + ucs.setColourScheme(newColors); + + searchGroup = new SuperGroup(searchString, ucs , true, true, false); + + int end = av.alignment.getHeight(); + + SequenceGroup selection = av.getSelectionGroup(); + if(selection!=null) + if(selection.getSize()<1 || (selection.getEndRes()-selection.getStartRes()<2)) + selection = null; + + while( !found && seqIndex0) + ap.idPanel.highlightSearchResults( idMatch ); + + + if(searchResults.size()>0) + { + allResults = new int[searchResults.size()]; + for(int i=0; i 0) // scroll down + { + ss = es - vertical; + if(ss av.endSeq) + es = av.endSeq; + } + + + + gg.translate(0, transY); + + drawIds(ss, es); + + gg.translate( 0, -transY ); + + + fastPaint = true; + repaint(); + } + + public void update(Graphics g) + { + paint(g); + } + public void paint(Graphics g) + { + if(getSize().height<0 || getSize().width<0) + return; + if (fastPaint) + { + fastPaint = false; + g.drawImage(image, 0, 0, this); + return; + } + + imgHeight = getSize().height; + imgHeight -= imgHeight % av.charHeight; + + if(image==null || imgHeight!=image.getHeight(this)) + { + image = createImage(getSize().width, imgHeight); + gg = image.getGraphics(); + gg.setFont(av.getFont()); + } + + //Fill in the background + gg.setColor(Color.white); + Font italic = new Font(av.getFont().getName(), Font.ITALIC, + av.getFont().getSize()); + gg.setFont(italic); + + gg.fillRect(0, 0, getSize().width, getSize().height); + drawIds( av.getStartSeq(), av.endSeq); + g.drawImage(image, 0, 0, this); + } + + void drawIds(int starty, int endy) + { + Color currentColor = Color.white; + Color currentTextColor = Color.black; + + if (av.getWrapAlignment()) + { + + int rowSize = av.getEndRes() - av.getStartRes(); + // Draw the rest of the panels + + for(int ypos=2*av.charHeight, row=av.getEndRes()-rowSize; + ypos <= getSize().height && row lastid) + selectSeqs(lastid + 1, seq); + + lastid = seq; + alignPanel.repaint(); + } + + public void mouseClicked(MouseEvent e) + { + if (e.getClickCount() == 2) + { + int y = e.getY(); + if(av.getWrapAlignment()) + y-=2*av.charHeight; + + int seq = av.getIndex(y); + String id = av.getAlignment().getSequenceAt(seq).getName(); + + try{ + jalview.bin.JalviewLite.showURL( + "http://srs.ebi.ac.uk/srs7bin/cgi-bin/wgetz?-e+[swall-id:" + id + + "]+-vn+2"); + }catch(Exception ex){ex.printStackTrace();} + } + + } + public void mouseEntered(MouseEvent e) + { + if(scrollThread!=null) + scrollThread.running = false; + } + + public void mouseExited (MouseEvent e) + { + if(av.getWrapAlignment()) + return; + + if(mouseDragging && e.getY()<0 && av.getStartSeq()>0) + { + scrollThread = new ScrollThread(true); + } + + if(mouseDragging && e.getY()>=getSize().height && av.alignment.getHeight()>av.getEndSeq()) + { + scrollThread = new ScrollThread(false); + } + } + + + public void mousePressed(MouseEvent e) { + if (e.getClickCount() == 2) + return; + + int y = e.getY(); + if(av.getWrapAlignment()) + y-=2*av.charHeight; + + int seq = av.getIndex(y); + if (seq == -1) + return; + + if ( (e.getModifiers() & InputEvent.BUTTON3_MASK) == InputEvent.BUTTON3_MASK) + { + APopupMenu popup = new APopupMenu(alignPanel, null); + this.add(popup); + popup.show(this, e.getX(), e.getY()); + return; + } + + + if(!e.isControlDown() && !e.isShiftDown() && av.alignment.findGroup( av.alignment.getSequenceAt(seq))!=null) + { + + SequenceGroup selection = new SequenceGroup(); + SequenceGroup sg = av.alignment.findGroup(av.alignment.getSequenceAt(seq)); + selection.setStartRes(0); + selection.setEndRes(av.alignment.getWidth()-1); + for (int i =0; i< sg.getSize(); i++) + selection.addSequence(sg.getSequenceAt(i)); + + av.setSelectionGroup(selection); + return; + } + + if(av.getSelectionGroup()==null || ( !e.isControlDown() && av.getSelectionGroup()!=null)) + av.setSelectionGroup(new SequenceGroup()); + + av.getSelectionGroup().setStartRes(0); + av.getSelectionGroup().setEndRes(av.alignment.getWidth()-1); + + if(e.isShiftDown() && lastid!=-1) + selectSeqs(lastid, seq); + else + selectSeq(seq); + + alignPanel.repaint(); + } + + void selectSeq(int seq) + { + lastid = seq; + SequenceI pickedSeq = av.getAlignment().getSequenceAt(seq); + av.getSelectionGroup().addOrRemove(pickedSeq); + } + + void selectSeqs(int start, int end) { + + lastid = start; + if (end < start) + { + int tmp = start; + start = end; + end = tmp; + lastid = end; + } + + for (int i = start; i <= end; i++) + av.getSelectionGroup().addSequence(av.getAlignment().getSequenceAt(i)); + + } + + + public void mouseReleased(MouseEvent e) + { + if(scrollThread!=null) + scrollThread.running = false; + + mouseDragging = false; + PaintRefresher.Refresh(this); + } + + public void highlightSearchResults( java.util.Vector found ) + { + idCanvas.setHighlighted( found ); + + if(found == null) + return; + + int index = av.alignment.findIndex( (SequenceI)found.elementAt(0)); + + // do we need to scroll the panel? + if(av.getStartSeq()>index || av.getEndSeq() lastid) + selectSeqs(lastid + 1, seq); + + lastid = seq; + } + else + running = false; + + alignPanel.repaint(); + try + { + Thread.sleep(100); + } + catch (Exception ex) + {} + } + } +} + +} diff --git a/src/jalview/appletgui/IdwidthAdjuster.java b/src/jalview/appletgui/IdwidthAdjuster.java new file mode 100755 index 0000000..e748697 --- /dev/null +++ b/src/jalview/appletgui/IdwidthAdjuster.java @@ -0,0 +1,61 @@ +package jalview.appletgui; + +import java.awt.event.*; +import java.awt.*; + + +public class IdwidthAdjuster extends Panel implements MouseListener, MouseMotionListener +{ + boolean active = false; + int oldX=0; + Image image; + AlignmentPanel ap ; + + public IdwidthAdjuster(AlignmentPanel ap) + { + setLayout(null); + this.ap = ap; + java.net.URL url = getClass().getResource("/images/idwidth.gif"); + if (url != null) + image = java.awt.Toolkit.getDefaultToolkit().getImage(url); + + addMouseListener(this); + addMouseMotionListener(this); + } + + public void mousePressed(MouseEvent evt) + { oldX = evt.getX(); } + + public void mouseReleased(MouseEvent evt){ active = false; repaint(); } + public void mouseEntered(MouseEvent evt) { active = true; repaint();} + public void mouseExited(MouseEvent evt) { active = false; repaint();} + public void mouseDragged(MouseEvent evt) + { + active = true; + Dimension d = ap.idPanel.idCanvas.getSize(); + int dif = evt.getX() - oldX; + + if(d.width+dif>20 || dif>0) + { + ap.setIdWidth(d.width + dif,d.height); + this.setSize(d.width + dif, getSize().height); + } + + oldX = evt.getX(); + } + + public void mouseMoved(MouseEvent evt) {} + public void mouseClicked(MouseEvent evt) {} + + public void paint(Graphics g) + { + g.setColor(Color.white); + g.fillRect(0,0, getSize().width, getSize().height); + if(active) + { + if(image!=null) + g.drawImage(image, getSize().width-20, 2, this); + } + } + +} diff --git a/src/jalview/appletgui/OverviewPanel.java b/src/jalview/appletgui/OverviewPanel.java new file mode 100755 index 0000000..3ba88b4 --- /dev/null +++ b/src/jalview/appletgui/OverviewPanel.java @@ -0,0 +1,264 @@ +package jalview.appletgui; + +import java.awt.event.*; +import java.awt.*; + +public class OverviewPanel extends Panel implements Runnable +{ + Image miniMe; + AlignViewport av; + AlignmentPanel ap; + float scalew = 1f; + float scaleh = 1f; + + public int width, sequencesHeight; + int graphHeight=30; + int boxX=-1, boxY=-1, boxWidth=-1, boxHeight=-1; + + boolean resizing = false; + + Frame nullFrame; + + public OverviewPanel(AlignmentPanel ap) + { + this.av = ap.av; + this.ap = ap; + setLayout(null); + nullFrame = new Frame(); + nullFrame.addNotify(); + + // scale the initial size of overviewpanel to shape of alignment + float initialScale = (float)av.alignment.getWidth()/(float)av.alignment.getHeight(); + if(av.alignment.getWidth() > av.alignment.getHeight()) + { + // wider + width = 400; + sequencesHeight = (int)(400f/initialScale); + } + else + { + // taller + width = (int)(400f*initialScale); + sequencesHeight = 300; + if(width<120) + width = 120; + } + + setSize (new Dimension(width, sequencesHeight+graphHeight)); + addComponentListener(new ComponentAdapter() + { + + public void componentResized(ComponentEvent evt) + { + if( getSize().width!=width || getSize().height!=sequencesHeight+graphHeight) + { + updateOverviewImage(); + } + } + }); + + addMouseMotionListener(new MouseMotionAdapter() + { + public void mouseDragged(MouseEvent evt) + { doMouseDragged(evt);} + }); + + addMouseListener(new MouseAdapter() + { + public void mousePressed(MouseEvent evt) + { doMousePressed(evt);} + public void mouseReleased(MouseEvent evt) + { doMouseReleased(evt);} + }); + + updateOverviewImage(); + + } + + public void doMousePressed(MouseEvent evt) + { + boxX = evt.getX(); + boxY = evt.getY(); + + checkValid(); + repaint(); + } + + public void doMouseReleased(MouseEvent evt) + { + boxX = evt.getX(); + boxY = evt.getY(); + checkValid(); + if(!resizing) + ap.setScrollValues( (int)(boxX/scalew/av.getCharWidth()), + (int)(boxY/scaleh/av.getCharHeight()) ); + } + + public void doMouseDragged(MouseEvent evt) + { + boxX = evt.getX(); + boxY = evt.getY(); + checkValid(); + if(!resizing) + ap.setScrollValues( (int)(boxX/scalew/av.getCharWidth()), + (int)(boxY/scaleh/av.getCharHeight()) ); + repaint(); + ap.repaint(); + } + + void checkValid() + { + if (boxY < 0) + boxY = 0; + + if (boxY > sequencesHeight - boxHeight) + boxY = sequencesHeight - boxHeight+1; + + if (boxX < 0) + boxX = 0; + + if (boxX > width - boxWidth) + boxX = width - boxWidth; + } + + public void updateOverviewImage() + { + if(resizing) + { + return; + } + + resizing = true; + Thread thread = new Thread(this); + thread.start(); + repaint(); + } + + public void run() + { + miniMe = null; + int alwidth = av.alignment.getWidth(); + int alheight = av.alignment.getHeight(); + + if(getSize().width>0 && getSize().height>0) + { + width = getSize().width; + sequencesHeight = getSize().height - graphHeight; + } + + setSize (new Dimension(width, sequencesHeight+graphHeight)); + + int fullsizeWidth = alwidth * av.getCharWidth(); + int fullsizeHeight = alheight * av.getCharHeight(); + + scalew = (float) width / (float) fullsizeWidth; + scaleh = (float) sequencesHeight / (float) fullsizeHeight; + + miniMe = nullFrame.createImage(width, sequencesHeight + graphHeight); + + Graphics mg = miniMe.getGraphics(); + Image consensus = nullFrame.createImage(fullsizeWidth, 60); + Graphics g = consensus.getGraphics(); + ap.annotationPanel.drawGraph(g, av.conservation, fullsizeWidth, 60); + mg.drawImage(consensus, 0, sequencesHeight, width, + sequencesHeight + graphHeight, 0, 0, fullsizeWidth, 60, this); + + + boolean oldRenderGaps = av.renderGaps; + try{ + // We'll have to draw the full size alignment in chunks, as an image of the + // whole alignment requires too much memory + + // Max size depends on the font size, the following is a + // guess at a size which works + int maxSize = 2000 / av.getFont().getSize(); + Image block; + int blockx=0, blocky=0, blockw=0, blockh=0, eRes=0, eSeq=0; + + av.setRenderGaps(false); + for(int sRes=0, chunkx=0; sResalwidth) + eRes = alwidth; + + for(int sSeq=0, chunky=0; sSeqalheight) + eSeq = alheight; + + blocky = 0; + blockx = (int)((float)sRes/(float)alwidth * width); + + block = nullFrame.createImage((eRes-sRes)*av.charWidth, (eSeq-sSeq)*av.charHeight); + g = block.getGraphics(); + + ap.seqPanel.seqCanvas.drawPanel(g, sRes, eRes, sSeq, eSeq, sRes, sSeq, 0); + + blockh = (int)( (float)(eSeq-sSeq)/(float)alheight * sequencesHeight )+1 ; + blockw = (int)( (float)(eRes-sRes)/(float)alwidth * width )+1; + + blocky += (int) ((float)sSeq/(float)alheight* sequencesHeight); + + mg.drawImage(block, blockx, + blocky , + blockx + blockw, + blocky + blockh, + + 0, 0, block.getWidth(null),block.getHeight(null), this); + + block = null; + } + + } + + }catch(OutOfMemoryError error) + { System.out.println("out of memory"); } + + + av.setRenderGaps(oldRenderGaps); + resizing = false; + + setBoxPosition(); + } + + public void setBoxPosition() + { + boxX = (int) (av.getStartRes() * av.getCharWidth() * scalew); + boxY = (int) (av.getStartSeq() * av.getCharHeight() * scaleh); + boxWidth = (int) ((av.getEndRes()-av.getStartRes()+1)* av.getCharWidth() * scalew) ; + boxHeight = (int) (av.getEndSeq() * av.getCharHeight() * scaleh) - boxY; + repaint(); + } + + public void update(Graphics g) + { + paint(g); + } + + public void paint(Graphics g) + { + if(resizing) + { + g.setColor(Color.white); + g.fillRect(0, 0, getSize().width, getSize().height); + g.setColor(Color.black); + + g.setFont(new Font("Verdana", Font.BOLD, 15)); + g.drawString("Recalculating", 5, sequencesHeight/2); + g.drawString("Overview.....", 5, sequencesHeight/2 +20); + } + else + { + if(miniMe!=null) + g.drawImage(miniMe, 0,0,this); + + g.setColor(Color.red); + g.drawRect(boxX, boxY, boxWidth, boxHeight); + g.drawRect(boxX+1, boxY+1, boxWidth-2, boxHeight-2); + } + } + +} diff --git a/src/jalview/appletgui/PCAPanel.java b/src/jalview/appletgui/PCAPanel.java new file mode 100755 index 0000000..2613df5 --- /dev/null +++ b/src/jalview/appletgui/PCAPanel.java @@ -0,0 +1,122 @@ +package jalview.appletgui; + +import jalview.datamodel.*; +import jalview.analysis.PCA; +import jalview.jbappletgui.*; +import java.awt.*; +import java.awt.event.*; +import java.util.*; + + +public class PCAPanel extends GPCAPanel implements Runnable +{ + PCA pca; + int top; + RotatableCanvas rc; + AlignViewport av; + + public void run() + { + // do stuff + } + + public PCAPanel(AlignViewport av, SequenceI[] s) { + + this.av = av; + if(av.getSelectionGroup().getSize()>3) + { + s = new Sequence[av.getSelectionGroup().getSize()]; + for(int i=0; i 1e-4) + { + comps[i] = pca.component(i); + } + } + + ////////////////// + + xCombobox.select(0); + yCombobox.select(1); + zCombobox.select(2); + + top = pca.getM().rows-1; + + Vector points = new Vector(); + float[][] scores = pca.getComponents(top-1,top-2,top-3,100); + + for (int i =0; i < pca.getM().rows; i++ ) + { + SequencePoint sp = new SequencePoint(s[i],scores[i]); + points.addElement(sp); + } + + rc = new RotatableCanvas(av,points,pca.getM().rows); + + //rc.printPoints(); + + add(rc, BorderLayout.CENTER); + } + + + void doDimensionChange() + { + if(top==0) + return; + + int dim1 = top - xCombobox.getSelectedIndex(); + int dim2 = top - yCombobox.getSelectedIndex(); + int dim3 = top - zCombobox.getSelectedIndex(); + + float[][] scores = pca.getComponents(dim1,dim2,dim3,100); + for (int i=0; i < pca.getM().rows; i++) { + ((SequencePoint)rc.points.elementAt(i)).coord = scores[i]; + } + + rc.img = null; + rc.rotmat.setIdentity(); + rc.initAxes(); + rc.paint(rc.getGraphics()); + } + + protected void xCombobox_actionPerformed(ActionEvent e) + { + doDimensionChange(); + } + + protected void yCombobox_actionPerformed(ActionEvent e) + { + doDimensionChange(); + } + + protected void zCombobox_actionPerformed(ActionEvent e) + { + doDimensionChange(); + } + +} diff --git a/src/jalview/appletgui/PaintRefresher.java b/src/jalview/appletgui/PaintRefresher.java new file mode 100755 index 0000000..f696640 --- /dev/null +++ b/src/jalview/appletgui/PaintRefresher.java @@ -0,0 +1,35 @@ +package jalview.appletgui; +import java.awt.*; +import java.util.*; + +public class PaintRefresher +{ + static Vector components = new Vector(); + + public static void Register(Component c) + { + if(!components.contains(c)) + components.addElement(c); + else + components.removeElement(c); + } + + public static void Refresh(Component c) + { + Component temp; + Enumeration e = components.elements(); + while( e.hasMoreElements() ) + { + temp = (Component)e.nextElement(); + + if(!temp.isValid()) + components.removeElement( temp ); + else if( temp == c ) + continue; + + temp.repaint(); + } + + } + +} diff --git a/src/jalview/appletgui/PairwiseAlignPanel.java b/src/jalview/appletgui/PairwiseAlignPanel.java new file mode 100755 index 0000000..939e2f4 --- /dev/null +++ b/src/jalview/appletgui/PairwiseAlignPanel.java @@ -0,0 +1,71 @@ +package jalview.appletgui; + +import jalview.datamodel.*; +import jalview.jbappletgui.GPairwiseAlignPanel; +import jalview.analysis.*; +import java.awt.event.*; +import java.util.*; + + +public class PairwiseAlignPanel extends GPairwiseAlignPanel +{ + Vector sequences = new Vector(); + AlignViewport av; + + public PairwiseAlignPanel(AlignViewport av) + { + super(); + this.av = av; + float scores[][] = new float[av.getAlignment().getHeight()][av.getAlignment().getHeight()]; + double totscore = 0; + int count = av.getSelectionGroup().getSize(); + + int acount = 0; + for (int i = 1; i < count; i++) + { + for (int j = 0; j < i; j++) + { + acount++; + AlignSeq as = new AlignSeq(av.getSelectionGroup().getSequenceAt(i), + av.getSelectionGroup().getSequenceAt(j),"pep"); + + as.calcScoreMatrix(); + as.traceAlignment(); + as.printAlignment(); + scores[i][j] = (float)as.getMaxScore()/(float)as.getASeq1().length; + totscore = totscore + scores[i][j]; + + textarea.append(as.getOutput()); + sequences.addElement( new Sequence( as.getS1().getName(), as.getAStr1()) ); + sequences.addElement( new Sequence( as.getS2().getName(), as.getAStr2()) ); + + + } + } + + if (count > 2) + { + for (int i = 0; i < count;i++) + for (int j = 0; j < i; j++) + jalview.util.Format.print(System.out,"%7.3f",scores[i][j]/totscore); + } + } + + + protected void viewInEditorButton_actionPerformed(ActionEvent e) + { + + Sequence [] seq = new Sequence[sequences.size()]; + + for (int i=0;i 1) + { + + del = ap.av.alignment.removeRedundancy(threshold, sg.sequences); + for (int i = 0; i < del.size(); i++) + if (sg.sequences.contains( (SequenceI) del.elementAt(i))) + sg.deleteSequence( (SequenceI) del.elementAt(i)); + + } + else + { + Vector s = new Vector(); + int i=0; + while(i < ap.av.alignment.getHeight()) + { + s.addElement( ap.av.alignment.getSequenceAt(i) ); + i++; + } + del = ap.av.alignment.removeRedundancy(threshold,s); + for (int j=0; j < del.size(); j++) + { + if (sg.sequences.contains((SequenceI)del.elementAt(j))) + sg.deleteSequence((SequenceI)del.elementAt(j)); + + } + } + + ap.repaint(); + + } + + public void undoButton_actionPerformed(ActionEvent e) + { + undoButton.setEnabled(false); + ap.av.setAlignment( new Alignment(oldAlignment) ); + oldAlignment = null; + ap.repaint(); + } + + + public void valueField_actionPerformed(ActionEvent e) + { + try{ + int i = Integer.parseInt(valueField.getText()); + slider.setValue(i); + } + catch(Exception ex) + { + valueField.setText( slider.getValue()+"" ); + } + } +} diff --git a/src/jalview/appletgui/RotatableCanvas.java b/src/jalview/appletgui/RotatableCanvas.java new file mode 100755 index 0000000..51b436f --- /dev/null +++ b/src/jalview/appletgui/RotatableCanvas.java @@ -0,0 +1,514 @@ +package jalview.appletgui; + +import jalview.math.*; +import jalview.datamodel.*; +import jalview.util.*; + +import java.awt.*; +import java.awt.event.*; +import java.util.*; + + +public class RotatableCanvas extends Panel implements MouseListener, + MouseMotionListener, + KeyListener + //RubberbandListener, + //SequenceSelectionListener +{ + RotatableMatrix idmat = new RotatableMatrix(3,3); + RotatableMatrix objmat = new RotatableMatrix(3,3); + RotatableMatrix rotmat = new RotatableMatrix(3,3); + + //RubberbandRectangle rubberband; + + boolean drawAxes = true; + + int omx = 0; + int mx = 0; + int omy = 0; + int my = 0; + + Image img; + Graphics ig; + + Dimension prefsize; + + float centre[] = new float[3]; + float width[] = new float[3]; + + float max[] = new float[3]; + float min[] = new float[3]; + + float maxwidth; + float scale; + + int npoint; + + Vector points; + float[][] orig; + float[][] axes; + + int startx; + int starty; + + int lastx; + int lasty; + + int rectx1; + int recty1; + int rectx2; + int recty2; + + float scalefactor = 1; + + AlignViewport av; +// Controller controller; + + + public RotatableCanvas(AlignViewport av, + Vector points, int npoint) { + this.points = points; + this.npoint = npoint; + this.av = av; + PaintRefresher.Register(this); +// + prefsize = getPreferredSize(); + orig = new float[npoint][3]; + + for (int i=0; i < npoint; i++) { + SequencePoint sp = (SequencePoint)points.elementAt(i); + for (int j=0; j < 3; j++) { + orig[i][j] = sp.coord[j]; + } + } + //Initialize the matrices to identity + + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3 ; j++) { + if (i != j) { + idmat.addElement(i,j,0); + objmat.addElement(i,j,0); + rotmat.addElement(i,j,0); + } else { + idmat.addElement(i,j,0); + objmat.addElement(i,j,0); + rotmat.addElement(i,j,0); + } + } + } + + axes = new float[3][3]; + initAxes(); + + findCentre(); + findWidth(); + + scale = findScale(); + + // System.out.println("Scale factor = " + scale); + + addMouseListener(this); + addKeyListener(this); + // if (getParent() != null) { + // getParent().addKeyListener(this); + //} + addMouseMotionListener(this); + + // Add rubberband + // rubberband = new RubberbandRectangle(this); + // rubberband.setActive(true); + // rubberband.addListener(this); + } + + /* public boolean handleSequenceSelectionEvent(SequenceSelectionEvent evt) { + redrawneeded = true; + repaint(); + return true; + } + + public void removeNotify() { + controller.removeListener(this); + super.removeNotify(); + }*/ + + public void initAxes() { + for (int i = 0; i < 3; i++) { + for (int j=0; j < 3; j++) { + if (i != j) { + axes[i][j] = 0; + } else { + axes[i][j] = 1; + } + } + } + } + + public void findWidth() { + max = new float[3]; + min = new float[3]; + + max[0] = (float)-1e30; + max[1] = (float)-1e30; + max[2] = (float)-1e30; + + min[0] = (float)1e30; + min[1] = (float)1e30; + min[2] = (float)1e30; + + for (int i = 0; i < 3; i++) { + for (int j = 0; j < npoint; j++) { + SequencePoint sp = (SequencePoint)points.elementAt(j); + if (sp.coord[i] >= max[i]) { + max[i] = sp.coord[i]; + } + if (sp.coord[i] <= min[i]) { + min[i] = sp.coord[i]; + } + } + } + + // System.out.println("xmax " + max[0] + " min " + min[0]); + //System.out.println("ymax " + max[1] + " min " + min[1]); + //System.out.println("zmax " + max[2] + " min " + min[2]); + + width[0] = Math.abs(max[0] - min[0]); + width[1] = Math.abs(max[1] - min[1]); + width[2] = Math.abs(max[2] - min[2]); + + maxwidth = width[0]; + + if (width[1] > width[0]) + maxwidth = width[1]; + if (width[2] > width[1]) + maxwidth = width[2]; + + //System.out.println("Maxwidth = " + maxwidth); + } + + public float findScale() { + int dim, width, height; + if (getSize().width != 0) { + width = getSize().width; + height = getSize().height; + } else { + width = prefsize.width; + height = prefsize.height; + } + + if (width < height) { + dim = width; + } else { + dim = height; + } + + return (float)(dim*scalefactor/(2*maxwidth)); + } + + public void findCentre() { + //Find centre coordinate + findWidth(); + + centre[0] = (max[0] + min[0])/2; + centre[1] = (max[1] + min[1])/2; + centre[2] = (max[2] + min[2])/2; + + // System.out.println("Centre x " + centre[0]); + //System.out.println("Centre y " + centre[1]); + //System.out.println("Centre z " + centre[2]); + } + + public Dimension getPreferredSize() { + if (prefsize != null) { + return prefsize; + } else { + return new Dimension(400,400); + } + } + + public Dimension getMinimumSize() { + return getPreferredSize(); + } + + public void paint(Graphics g) { + //Only create the image at the beginning - + if ((img == null) || (prefsize.width != getSize().width) || (prefsize.height != getSize().height)) { + prefsize.width = getSize().width; + prefsize.height = getSize().height; + + scale = findScale(); + + // System.out.println("New scale = " + scale); + img = createImage(getSize().width,getSize().height); + ig = img.getGraphics(); + + } + + + drawBackground(ig,Color.black); + drawScene(ig); + if (drawAxes == true) + { + drawAxes(ig); + } + + + g.drawImage(img,0,0,this); + } + + public void drawAxes(Graphics g) { + + g.setColor(Color.yellow); + for (int i=0; i < 3 ; i++) { + g.drawLine(getSize().width/2,getSize().height/2, + (int)(axes[i][0]*scale*max[0] + getSize().width/2), + (int)(axes[i][1]*scale*max[1] + getSize().height/2)); + } + } + + public void drawBackground(Graphics g, Color col) { + g.setColor(col); + g.fillRect(0,0,prefsize.width,prefsize.height); + } + + + public void drawScene(Graphics g) { + boolean darker = false; + + int halfwidth = getSize().width/2; + int halfheight = getSize().height/2; + + 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) + halfheight; + float z = sp.coord[1] - centre[2]; + + + + + if (sp.sequence.getColor() == Color.black) + g.setColor(Color.white); + else + g.setColor(sp.sequence.getColor()); + + + if (av.getSelectionGroup() != null) + { + if (av.getSelectionGroup().sequences.contains(((SequencePoint)points.elementAt(i)).sequence)) + g.setColor(Color.gray); + } + if (z < 0) + g.setColor(g.getColor().darker()); + + + g.fillRect(x-3,y-3,6,6); + g.setColor(Color.red); + } +// //Now the rectangle +// if (rectx2 != -1 && recty2 != -1) { +// g.setColor(Color.white); +// +// g.drawRect(rectx1,recty1,rectx2-rectx1,recty2-recty1); +// } + } + + public Dimension minimumsize() { + return prefsize; + } + + public Dimension preferredsize() { + return prefsize; + } + + public void keyTyped(KeyEvent evt) { } + public void keyReleased(KeyEvent evt) { } + + public void keyPressed(KeyEvent evt) { + requestFocus(); + if (evt.getKeyCode() == KeyEvent.VK_UP) { + scalefactor = (float)(scalefactor * 1.1); + scale = findScale(); + } else if (evt.getKeyCode() == KeyEvent.VK_DOWN) { + scalefactor = (float)(scalefactor * 0.9); + scale = findScale(); + } else if (evt.getKeyChar() == 's') { + System.out.println("Rectangle selection"); + if (rectx2 != -1 && recty2 != -1) { + rectSelect(rectx1,recty1,rectx2,recty2); + + } + } + repaint(); + } + + public void printPoints() { + for (int i=0; i < npoint; i++) { + SequencePoint sp = (SequencePoint)points.elementAt(i); + Format.print(System.out,"%5d ", i); + for (int j=0; j < 3;j++) { + Format.print(System.out,"%13.3f ",sp.coord[j]); + } + System.out.println(); + } + } + + public void mouseClicked(MouseEvent evt) { } + public void mouseEntered(MouseEvent evt) { } + public void mouseExited(MouseEvent evt) { } + public void mouseReleased(MouseEvent evt) { } + + public void mousePressed(MouseEvent evt) { + int x = evt.getX(); + int y = evt.getY(); + + mx = x; + my = y; + + omx = mx; + omy = my; + + startx = x; + starty = y; + + rectx1 = x; + recty1 = y; + + rectx2 = -1; + recty2 = -1; + + SequenceI found = findPoint(x,y); + + if (found != null) + { + if (av.getSelectionGroup() != null) + { + av.getSelectionGroup().addOrRemove(found); + PaintRefresher.Refresh(this); + } + else + { + av.setSelectionGroup(new SequenceGroup()); + av.getSelectionGroup().addOrRemove(found); + av.getSelectionGroup().setEndRes(av.alignment.getWidth()); + + } + } + repaint(); + } + + // private void fireSequenceSelectionEvent(Selection sel) { + // controller.handleSequenceSelectionEvent(new SequenceSelectionEvent(this,sel)); + //} + + public void mouseMoved(MouseEvent evt) + { + // SequenceI found = findPoint(evt.getX(), evt.getY()); + } + + public void mouseDragged(MouseEvent evt) { + mx = evt.getX(); + my = evt.getY(); + //Check if this is a rectangle drawing drag + if ((evt.getModifiers() & InputEvent.BUTTON2_MASK) != 0) { +// rectx2 = evt.getX(); +// recty2 = evt.getY(); + } else { + rotmat.setIdentity(); + + rotmat.rotate((float)(my-omy),'x'); + rotmat.rotate((float)(mx-omx),'y'); + + for (int i = 0; i < npoint; i++) { + SequencePoint sp = (SequencePoint)points.elementAt(i); + sp.coord[0] -= centre[0]; + sp.coord[1] -= centre[1]; + sp.coord[2] -= centre[2]; + + //Now apply the rotation matrix + sp.coord= rotmat.vectorMultiply(sp.coord); + + //Now translate back again + sp.coord[0] += centre[0]; + sp.coord[1] += centre[1]; + sp.coord[2] += centre[2]; + } + + for (int i=0; i < 3; i++) { + axes[i] = rotmat.vectorMultiply(axes[i]); + } + omx = mx; + omy = my; + + paint(this.getGraphics()); + } + + } + + public void rectSelect(int x1, int y1, int x2, int y2) { + boolean changedSel = false; + 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); + + if (tmp1 > x1 && tmp1 < x2 && tmp2 > y1 && tmp2 < y2) { + if (av != null) { + if (!av.getSelectionGroup().sequences.contains(sp.sequence)) + { + changedSel = true; + av.getSelectionGroup().addSequence(sp.sequence); + } + } + } + } + // if (changedSel) { + // fireSequenceSelectionEvent(av.getSelection()); + // } + } + public SequenceI findPoint(int x, int y) { + + int halfwidth = getSize().width/2; + int halfheight = getSize().height/2; + + int found = -1; + + for (int i=0; i < npoint; i++) { + + SequencePoint sp = (SequencePoint)points.elementAt(i); + int px = (int)((float)(sp.coord[0] - centre[0])*scale) + halfwidth; + int py = (int)((float)(sp.coord[1] - centre[1])*scale) + halfheight; + + + if (Math.abs(px-x)<3 && Math.abs(py - y) < 3 ) { + found = i; + } + } + if (found != -1) { + return ((SequencePoint)points.elementAt(found)).sequence; + } else { + return null; + } + } +/* public boolean handleRubberbandEvent(RubberbandEvent evt) { + System.out.println("Rubberband handler called in RotatableCanvas with " + + evt.getBounds()); + + Rubberband rb = (Rubberband)evt.getSource(); + + // Clear the current selection (instance variable) + //if ((rb.getModifiers() & Event.SHIFT_MASK) == 0) { + // clearSelection(); + //} + + if (rb.getComponent() == this) { + Rectangle bounds = evt.getBounds(); + rectSelect(bounds.x,bounds.y,bounds.x+bounds.width,bounds.y+bounds.height); + } + + redrawneeded = true; + paint(this.getGraphics()); + + return true; + }*/ + +} diff --git a/src/jalview/appletgui/ScalePanel.java b/src/jalview/appletgui/ScalePanel.java new file mode 100755 index 0000000..51a03cc --- /dev/null +++ b/src/jalview/appletgui/ScalePanel.java @@ -0,0 +1,175 @@ +package jalview.appletgui; + +import jalview.datamodel.*; +import java.awt.*; +import java.awt.event.*; + +public class ScalePanel extends Panel +{ + + protected int offy = 4; + public int width; + + protected AlignViewport av; + AlignmentPanel ap; + + boolean stretchingGroup = false; + + public ScalePanel(AlignViewport av, AlignmentPanel ap) + { + setLayout(null); + this.av = av; + this.ap = ap; + + addMouseListener(new MouseAdapter() + { + public void mousePressed(MouseEvent evt) + { + doMousePressed(evt); + } + public void mouseReleased(MouseEvent evt) + { + doMouseReleased(evt); + } + + }); + addMouseMotionListener(new MouseMotionAdapter() + { + public void mouseDragged(MouseEvent evt) + { + doMouseDragged(evt); + } + }); + + } + + + public void doMousePressed(MouseEvent evt) { + int x = evt.getX(); + int res = x/av.getCharWidth() + av.getStartRes(); + SequenceGroup sg = null; + + if (av.getColumnSelection().contains(res)) + av.getColumnSelection().removeElement(res); + else + { + av.getColumnSelection().addElement(res); + + sg = new SequenceGroup(); + for (int i = 0; i < av.alignment.getSequences().size(); i++) + sg.addSequence(av.alignment.getSequenceAt(i)); + + sg.setStartRes(res); + sg.setEndRes(res); + + ap.annotationPanel.addEditableColumn(res); + } + av.setSelectionGroup(sg); + ap.repaint(); + } + + public void doMouseReleased(MouseEvent evt) + { + if(!stretchingGroup) + return; + + int x = evt.getX(); + int res = x/av.getCharWidth() + av.getStartRes(); + + if (! av.getColumnSelection().contains(res)) + av.getColumnSelection().addElement(res); + + SequenceGroup sg = av.getSelectionGroup(); + + if(res>sg.getStartRes()) + sg.setEndRes(res); + else if(res sg.getStartRes()) + sg.setEndRes(res); + else if (res < sg.getStartRes()) + sg.setStartRes(res); + + ap.annotationPanel.addEditableColumn(res); + ap.repaint(); + } + } + + public void update(Graphics g) + { + paint(g); + } + + public void paint(Graphics g) + { + drawScale(g, av.getStartRes(), av.getEndRes(), getSize().width, getSize().height); + } + +// scalewidth will normally be screenwidth, + public void drawScale(Graphics gg, int startx, int endx, int width, int height) + { + gg.setFont(av.getFont()); + + //Fill in the background + gg.setColor(Color.white); + gg.fillRect(0,0,width, height); + gg.setColor(Color.black); + + + //Fill the selected columns + ColumnSelection cs = av.getColumnSelection(); + gg.setColor(new Color(220,0,0)); + for (int i=0; i= startx && sel <= endx) + gg.fillRect((sel-startx)*av.charWidth,0,av.charWidth, getSize().height); + } + + + // Draw the scale numbers + gg.setColor(Color.black); + int scalestartx = (startx/10) * 10; + + FontMetrics fm = gg.getFontMetrics(av.getFont()); + int y = av.charHeight -fm.getDescent(); + + if(scalestartx%10==0) + scalestartx+=5; + + for (int i=scalestartx;i < endx; i+= 5) + { + if(i%10==0) + { + gg.drawString(String.valueOf(i), (i - startx - 1) * av.charWidth, y); + gg.drawLine( (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2), + y+2, + (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2), + y+fm.getDescent()*2); + } + else + gg.drawLine( (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2), + y+fm.getDescent(), + (int) ( (i - startx - 1) * av.charWidth + av.charWidth / 2), + y+fm.getDescent()*2); + + + } + } + + +} diff --git a/src/jalview/appletgui/SeqCanvas.java b/src/jalview/appletgui/SeqCanvas.java new file mode 100755 index 0000000..15e3c8b --- /dev/null +++ b/src/jalview/appletgui/SeqCanvas.java @@ -0,0 +1,486 @@ +package jalview.appletgui; + +import java.awt.*; +import jalview.datamodel.*; +import jalview.analysis.*; + + +public class SeqCanvas extends Panel +{ + FeatureRenderer fr; + SequenceRenderer sr; + Image img; + Graphics gg; + int imgWidth; + int imgHeight; + + AlignViewport av; + + boolean showScores = false; + boolean displaySearch = false; + int [] searchResults = null; + + int chunkHeight; + int chunkWidth; + + boolean fastPaint = false; + + + public SeqCanvas(AlignViewport av) + { + this.av = av; + fr = new FeatureRenderer(av); + sr = new SequenceRenderer(av); + PaintRefresher.Register(this); + + } + + void drawNorthScale(Graphics g, int startx, int endx,int ypos) { + int scalestartx = startx - startx % 10 + 10; + + g.setColor(Color.black); + + // NORTH SCALE + for (int i = scalestartx; i < endx; i += 10) + { + String string = String.valueOf(i); + g.drawString(string, (i - startx - 1) * av.charWidth, + ypos - av.charHeight / 2); + + g.drawLine( (i - startx - 1) * av.charWidth + av.charWidth / 2, + ypos + 2 - av.charHeight / 2, + (i - startx - 1) * av.charWidth + av.charWidth / 2, ypos - 2); + + } + } + + void drawWestScale(Graphics g, int startx, int endx, int ypos) + { + FontMetrics fm = getFontMetrics(av.getFont()); + ypos+= av.charHeight; + // EAST SCALE + for (int i = 0; i < av.alignment.getHeight(); i++) + { + SequenceI seq = av.alignment.getSequenceAt(i); + int index = startx; + int value = -1; + while (index < endx) + { + if (jalview.util.Comparison.isGap(seq.getCharAt(index))) + { + index++; + continue; + } + + value = av.alignment.getSequenceAt(i).findPosition(index); + break; + } + if(value!=-1) + { + int x = LABEL_WEST - fm.stringWidth(value+""); + g.drawString(value + "", x, ypos + i*av.charHeight - av.charHeight/5); + } + } + } + + void drawEastScale(Graphics g, int startx, int endx, int ypos) +{ + ypos+= av.charHeight; + // EAST SCALE + for (int i = 0; i < av.alignment.getHeight(); i++) + { + SequenceI seq = av.alignment.getSequenceAt(i); + int index = endx; + int value = -1; + while (index > startx) + { + if (jalview.util.Comparison.isGap(seq.getCharAt(index))) + { + index--; + continue; + } + + value = av.alignment.getSequenceAt(i).findPosition(index); + break; + } + if(value!=-1) + g.drawString(value + "", 0, ypos + i*av.charHeight - av.charHeight/5); + } + +} + + + +public void fastPaint(int horizontal, int vertical) +{ + if (horizontal == 0 && vertical == 0 || gg==null) + return; + + gg.copyArea(0, 0, imgWidth, imgHeight, -horizontal * av.charWidth, + -vertical * av.charHeight); + + int sr = av.startRes, er = av.endRes, ss = av.startSeq, es = av.endSeq, + transX = 0, transY = 0; + if (horizontal > 0) // scrollbar pulled right, image to the left + { + transX = (er - sr - horizontal) * av.charWidth; + sr = er - horizontal; + } + else if (horizontal < 0) + er = sr - horizontal; + + else if (vertical > 0) // scroll down + { + ss = es - vertical; + if(ss av.endSeq) + es = av.endSeq; + } + + + gg.translate(transX, transY); + + gg.setColor(Color.white); + gg.fillRect(0,0, (er-sr)*av.charWidth, (es-ss)*av.charHeight); + drawPanel(gg, sr, er, ss, es, sr, ss, 0); + gg.translate( -transX, -transY); + + fastPaint = true; + repaint(); + +} + +/** + * Definitions of startx and endx (hopefully): + * SMJS This is what I'm working towards! + * startx is the first residue (starting at 0) to display. + * endx is the last residue to display (starting at 0). + * starty is the first sequence to display (starting at 0). + * endy is the last sequence to display (starting at 0). + * NOTE 1: The av limits are set in setFont in this class and + * in the adjustment listener in SeqPanel when the scrollbars move. + */ + public void update(Graphics g) + { + paint(g); + } + + public void paint(Graphics g) + { + if (fastPaint) + { + g.drawImage(img, 0, 0, this); + fastPaint = false; + return; + } + + // this draws the whole of the alignment + imgWidth = this.getSize().width; + imgHeight = this.getSize().height; + if(imgWidth<1 || imgHeight<1) + return; + + imgWidth -= imgWidth%av.charWidth; + imgHeight-= imgHeight%av.charHeight; + + if(img==null || imgWidth!=img.getWidth(this) || imgHeight!=img.getHeight(this)) + { + img = createImage(imgWidth, imgHeight); + gg = img.getGraphics(); + gg.setFont(av.getFont()); + } + + gg.setColor(Color.white); + gg.fillRect(0,0,imgWidth,imgHeight); + + chunkWidth = getWrappedCanvasWidth( getSize().width ); + chunkHeight = (av.getAlignment().getHeight() + 2)*av.charHeight; + + av.setChunkHeight(chunkHeight); + av.setChunkWidth(chunkWidth); + + + if (av.getWrapAlignment()) + drawWrappedPanel(gg, getSize().width, getSize().height, av.startRes); + else + drawPanel(gg, av.startRes, av.endRes, av.startSeq, av.endSeq, av.startRes, av.startSeq, 0); + + g.drawImage(img, 0, 0, this); + + } + + int LABEL_WEST, LABEL_EAST; + public int getWrappedCanvasWidth(int cwidth) + { + FontMetrics fm = getFontMetrics(av.getFont()); + + LABEL_EAST = 0; + LABEL_WEST = 0; + + if(av.scaleRightWrapped) + LABEL_EAST = fm.stringWidth( av.alignment.getWidth()+"000" ); + + if(av.scaleLeftWrapped) + LABEL_WEST = fm.stringWidth( av.alignment.getWidth()+"" ); + + return (cwidth - LABEL_EAST -LABEL_WEST)/av.charWidth; + } + + public void drawWrappedPanel(Graphics g, int canvasWidth, int canvasHeight, int startRes) + { + AlignmentI al = av.getAlignment(); + + FontMetrics fm = getFontMetrics(av.getFont()); + + int LABEL_EAST = 0; + if(av.scaleRightWrapped) + LABEL_EAST = fm.stringWidth( al.getWidth()+"000" ); + int LABEL_WEST = 0; + if(av.scaleLeftWrapped) + LABEL_WEST = fm.stringWidth(al.getWidth()+"0"); + + + int cWidth = (canvasWidth - LABEL_EAST -LABEL_WEST)/av.charWidth; + int cHeight = (av.getAlignment().getHeight() + 2)*av.charHeight; + + int endx = startRes+cWidth-1; + int ypos = 2*av.charHeight; + + while (ypos <= canvasHeight && startRes al.getWidth()) + endx = al.getWidth(); + } + + } + + + synchronized public void drawPanel(Graphics g,int x1,int x2, int y1, int y2,int startx, int starty,int offset) { + + g.setFont(av.getFont()); + sr.renderGaps(av.renderGaps); + + SequenceI nextSeq; + + /// First draw the sequences + ///////////////////////////// + for (int i = y1 ; i < y2 ;i++) + { + nextSeq = av.alignment.getSequenceAt(i); + + sr.drawSequence(g, nextSeq, av.alignment.findAllGroups( nextSeq ),x1,x2, + (x1 - startx) * av.charWidth, + offset + AlignmentUtil.getPixelHeight(starty, i, av.charHeight), + av.charWidth,av.charHeight); + + if(av.showSequenceFeatures) + { + fr.drawSequence(g, nextSeq, av.alignment.findAllGroups( nextSeq ), x1, x2, + (x1 - startx) * av.charWidth, + offset + + AlignmentUtil.getPixelHeight(starty, i, av.charHeight), + av.charWidth, av.charHeight); + } + } + // + ///////////////////////////////////// + + // Now outline any areas if necessary + ///////////////////////////////////// + SequenceGroup group = av.getSelectionGroup(); + java.util.Vector groups = av.alignment.getGroups(); + + int sx = -1, sy = -1, ex = -1; + int groupIndex = -1; + if (group == null && groups.size() > 0) + { + group = (SequenceGroup) groups.elementAt(0); + groupIndex = 0; + } + + if (group != null) + do + { + int oldY = -1; + int i = 0; + boolean inGroup = false; + int top=-1, bottom =-1; + for (i = y1; i < y2; i++) + { + sx = (group.getStartRes() - startx) * av.charWidth; + sy = offset + AlignmentUtil.getPixelHeight(starty, i, av.charHeight); + ex = (group.getEndRes() + 1 - group.getStartRes()) * av.charWidth -1; + + if (sx < getSize().width + && ex > 0 + && group.sequences.contains(av.alignment.getSequenceAt(i))) + { + if (bottom == -1 && (i==av.alignment.getHeight()-1 || + !group.sequences.contains(av.alignment.getSequenceAt(i + 1)))) + bottom = sy + av.charHeight ; + + if (!inGroup) + { + if (top == -1 && i==0 || + !group.sequences.contains(av.alignment.getSequenceAt(i - 1))) + top = sy; + + + oldY = sy; + inGroup = true; + if (group == av.getSelectionGroup()) + { + g.setColor(new Color(255,0,0)); + } + else + { + g.setColor(group.getOutlineColour()); + } + } + } + else + { + if (inGroup) + { + g.drawLine(sx, oldY, sx, sy ); + g.drawLine(sx+ex, oldY, sx+ex, sy ); + + if (top != -1) + { + g.drawLine(sx, top, sx + ex, top); + top =-1; + } + if (bottom != -1) + { + g.drawLine(sx, bottom, sx + ex, bottom); + bottom = -1; + } + + + inGroup = false; + } + } + } + + if (inGroup) + { + + if(top!=-1) + { + g.drawLine(sx, top, sx + ex, top); + top =-1; + } + if(bottom!=-1) + { + g.drawLine(sx, bottom-1, sx + ex, bottom-1); + bottom = -1; + + } + sy = offset + AlignmentUtil.getPixelHeight(starty, i, av.charHeight); + g.drawLine(sx, oldY, sx, sy ); + g.drawLine(sx+ex, oldY, sx+ex, sy ); + inGroup = false; + } + groupIndex++; + if (groupIndex >= groups.size()) + break; + + group = (SequenceGroup) groups.elementAt(groupIndex); + + } + while (groupIndex < groups.size()); + + + /// Highlight search Results once all sequences have been drawn + ////////////////////////////////////////////////////////// + if(displaySearch) + { + for(int r=0; r= y1 && searchSeq < y2) + { + SequenceRenderer ssr = (SequenceRenderer) sr; + if(searchStart x2) + searchEnd = x2; + ssr.drawHighlightedText(av.getAlignment().getSequenceAt(searchSeq), + searchStart, + searchEnd, + (searchStart - startx) * av.charWidth, + offset + + AlignmentUtil.getPixelHeight(starty, searchSeq, + av.charHeight), + av.charWidth, + av.charHeight); + } + } + } + + } + + + + public void highlightSearchResults(int [] results) + { + // results are in the order sequence, startRes, endRes + if(results==null) + displaySearch = false; + else + displaySearch = true; + + searchResults = results; + + repaint(); + } + + +} diff --git a/src/jalview/appletgui/SeqPanel.java b/src/jalview/appletgui/SeqPanel.java new file mode 100755 index 0000000..70c2f0c --- /dev/null +++ b/src/jalview/appletgui/SeqPanel.java @@ -0,0 +1,631 @@ +package jalview.appletgui; + +import java.awt.*; +import java.awt.event.*; +import jalview.datamodel.*; +import java.util.*; +import jalview.schemes.*; + + +public class SeqPanel extends Panel +{ + + public SeqCanvas seqCanvas; + public AlignmentPanel ap; + + protected int startres; + protected int lastres; + protected int endres; + + protected int startseq; + protected int padseq; + + protected AlignViewport av; + + // if character is inserted or deleted, we will need to recalculate the conservation + int seqEditOccurred = -1; + + ScrollThread scrollThread = null; + boolean mouseDragging = false; + + + public SeqPanel(AlignViewport avp, AlignmentPanel p) { + this.av = avp; + + seqCanvas = new SeqCanvas(avp); + setLayout(new BorderLayout()); + add(seqCanvas); + + ap = p; + + seqCanvas.addMouseMotionListener( new MouseMotionAdapter() + { + public void mouseMoved(MouseEvent evt) + { + if(av.getWrapAlignment()) + return; + doMouseMoved(evt); } + + public void mouseDragged(MouseEvent evt) + { + if(av.getWrapAlignment()) + return; + if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown()) + doMouseDragged(evt); + else + doMouseDraggedDefineMode(evt); + } + }); + + seqCanvas.addMouseListener( new MouseAdapter() + { + public void mouseReleased(MouseEvent evt) + { + if(av.getWrapAlignment()) + return; + if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown()) + doMouseReleased(evt); + else + doMouseReleasedDefineMode(evt); + } + public void mousePressed(MouseEvent evt) + { + if(av.getWrapAlignment()) + return; + if(evt.isShiftDown() || evt.isAltDown() || evt.isControlDown()) + doMousePressed(evt); + else + doMousePressedDefineMode(evt); + } + public void mouseExited(MouseEvent evt) + { + if (av.getWrapAlignment() || evt.isShiftDown() || evt.isAltDown() || + evt.isControlDown()) + return; + doMouseExitedDefineMode(evt); + + } + public void mouseEntered(MouseEvent evt) + { + if (av.getWrapAlignment() || evt.isShiftDown() || evt.isAltDown() || + evt.isControlDown()) + return; + doMouseEnteredDefineMode(evt); + } + + }); + seqCanvas.repaint(); + } + + + public void doMouseReleased(MouseEvent evt) { + + int x = evt.getX(); + int res = x/av.getCharWidth() + av.getStartRes(); + + endres = res; + + startseq = -1; + startres = -1; + lastres = -1; + if(seqEditOccurred>-1) + updateConservation(seqEditOccurred); + + seqEditOccurred = -1; + + ap.repaint(); + + } + + public void doMousePressed(MouseEvent evt) { + ap.alignFrame.addHistoryItem("sequence edit"); + int seq; + int res; + + int x = evt.getX(); + int y = evt.getY(); + + res = x/av.getCharWidth() + av.getStartRes(); + seq = y/av.getCharHeight() + av.getStartSeq(); + + if (seq < av.getAlignment().getHeight() && + res < av.getAlignment().getSequenceAt(seq).getLength()) + { + //char resstr = align.getSequenceAt(seq).getSequence().charAt(res); + // Find the residue's position in the sequence (res is the position + // in the alignment + + startseq = seq; + + if (startseq == (av.getAlignment().getHeight() - 1)) + padseq = 1; + else + padseq = 1; + + startres = res; + lastres = res; + + } + else + { + startseq = -1; + startres = -1; + lastres = -1; + } + + return; + } + + public void doMouseMoved(MouseEvent evt) + { + int res=0, seq=0; + int x = evt.getX(); + int y = evt.getY(); + if(av.wrapAlignment) + { + y -= 2*av.charHeight; + int chunkHeight = (av.getAlignment().getHeight()+2)*av.charHeight; + + + res = (int)((y/chunkHeight)*(getSize().width/av.charWidth)) + x/av.getCharWidth() + av.getStartRes(); + + y %= chunkHeight; + seq = y / av.getCharHeight() + av.getStartSeq(); + + } + else + { + res = x / av.getCharWidth() + av.getStartRes(); + seq = y / av.getCharHeight() + av.getStartSeq(); + } + + + if(seq>=av.getAlignment().getHeight()) + return; + + SequenceI sequence = av.getAlignment().getSequenceAt(seq); + if(res>sequence.getLength()) + return; + + Object obj = ResidueProperties.aa2Triplet.get( sequence.getCharAt(res)+"" ) ; + String aa = ""; + if(obj!=null) + aa = obj.toString(); + + StringBuffer text = new StringBuffer("Sequence " +(seq+1)+" ID: "+sequence.getName()); + if(aa!="") + text.append(" Residue: "+aa+" ("+ av.getAlignment().getSequenceAt(seq).findPosition(res)+")"); + + ap.alignFrame.statusBar.setText(text.toString()); + + // use aa to see if the mouse pointer is on a + if( av.showSequenceFeatures) + { + Vector features = sequence.getSequenceFeatures(); + Enumeration e = features.elements(); + StringBuffer sbuffer = new StringBuffer(); + + + while (e.hasMoreElements()) + { + SequenceFeature sf = (SequenceFeature) e.nextElement(); + if (sf.getStart() <= sequence.findPosition(res) && + sf.getEnd() >= sequence.findPosition(res)) + { + if(sbuffer.length()>0) + sbuffer.append("; "); + sbuffer.append(sf.getType() + " " + sf.getDescription()); + if(sf.getStatus().length()>0) + sbuffer.append(" ("+sf.getStatus()+")"); + } + + } + } + + + } + + public void doMouseDragged(MouseEvent evt) { + // If we're dragging we're editing + + if(lastres==-1) + return; + + int x = evt.getX(); + + int res = x/av.getCharWidth() + av.getStartRes(); + if (res < 0) + res = 0; + + if (res != lastres) + { + // Group editing + if (evt.isAltDown() || evt.isControlDown()) + { + SequenceGroup sg = av.getSelectionGroup(); + if(sg==null) + av.getAlignment().findGroup(startseq); + if (sg != null) + { + boolean deleteAllowed = false; + if (res < av.getAlignment().getWidth() && res < lastres) + { + /// Are we able to delete? + boolean allGaps = true; + for (int i = 0; i < sg.getSize(); i++) + { + SequenceI s = sg.getSequenceAt(i); + for (int j = lastres-1; j >= res && allGaps; j--) + { + if (!jalview.util.Comparison.isGap(s.getSequence().charAt(j))) + { + res = j + 1; + allGaps = false; + } + } + + if(!deleteAllowed && allGaps) + deleteAllowed = true; + } + } + + // drag to right + if (res < av.getAlignment().getWidth() && res > lastres) + sg.setEndRes(sg.getEndRes() + 1); + + // drag to left + else if (deleteAllowed && res < av.getAlignment().getWidth() && + res < lastres) + sg.setEndRes(sg.getEndRes() - 1); + + + + + for (int i = 0; i < sg.getSize(); i++) + { + SequenceI s = sg.getSequenceAt(i); + int k = av.alignment.findIndex(s); + + // drag to right + if (res < av.getAlignment().getWidth() && res > lastres) + for (int j = lastres; j < res; j++) + insertChar(j, k); + + // drag to left + else if (deleteAllowed && res < av.getAlignment().getWidth() && res < lastres) + { + for (int j = res; j < lastres; j++) + { + deleteChar(j, k); + startres = res; + } + } + } + } + } + else /////Editing a single sequence/////////// + { + if (res < av.getAlignment().getWidth() && res > lastres) + { + // dragging to the right + for (int j = lastres; j < res; j++) + insertChar(j, startseq); + } + else if (res < av.getAlignment().getWidth() && res < lastres) + { + // dragging to the left + for (int j = res; j < lastres; j++) + { + deleteChar(j, startseq); + startres = res; + } + } + + } + + } + + lastres = res; + seqCanvas.repaint(); + } + + public void drawChars(int seqstart, int seqend, int start) { + seqCanvas.drawPanel(seqCanvas.gg, start,av.getEndRes(),seqstart,seqend,av.getStartRes(),av.getStartSeq(),0); + seqCanvas.repaint(); + } + + public void insertChar(int j, int seq) + { + av.alignment.getSequenceAt(seq).insertCharAt(j, av.getGapCharacter()); + seqEditOccurred=seq; + } + + public void deleteChar(int j, int seq) + { + + if ( jalview.util.Comparison.isGap( av.alignment.getSequenceAt(seq).getSequence().charAt(j))) + av.alignment.getSequenceAt(seq).deleteCharAt(j); + + av.alignment.getWidth(); + seqCanvas.repaint(); + seqEditOccurred=seq; + } + + + void updateConservation(int i) + { + av.updateConservation(); + av.updateConsensus(); + } + +////////////////////////////////////////// +/////Everything below this is for defining the boundary of the rubberband +////////////////////////////////////////// + int oldSeq = -1; + public void doMousePressedDefineMode(MouseEvent evt) + { + int res = evt.getX()/av.getCharWidth() + av.getStartRes(); + int seq = evt.getY()/av.getCharHeight() + av.getStartSeq(); + oldSeq = seq; + + SequenceI sequence = (Sequence) av.getAlignment().getSequenceAt(seq); + + if(sequence==null || res>sequence.getLength()) + return; + + stretchGroup = av.getSelectionGroup(); + + if(stretchGroup == null) + { + stretchGroup = av.alignment.findGroup( sequence ); + if(stretchGroup!=null && res>stretchGroup.getStartRes() && resres + || stretchGroup.getEndRes()= res) + { + stretchGroup = allGroups[i]; + av.setSelectionGroup(stretchGroup); + break; + } + } + + if(stretchGroup==null) + { + // define a new group here + SequenceGroup sg = new SequenceGroup(); + sg.setStartRes(res); + sg.setEndRes(res); + sg.addSequence( sequence ); + av.setSelectionGroup( sg ); + stretchGroup = sg; + + if(av.getConservationSelected()) + SliderPanel.setConservationSlider(ap, av.getGlobalColourScheme(), "Background"); + if(av.getAbovePIDThreshold()) + SliderPanel.setPIDSliderSource(ap, av.getGlobalColourScheme(), "Background"); + + } + else if( ( evt.getModifiers() & InputEvent .BUTTON3_MASK ) == InputEvent.BUTTON3_MASK ) + { + APopupMenu popup = new APopupMenu(ap, null); + this.add(popup); + popup.show(this, evt.getX(), evt.getY()); + } + + + if(stretchGroup!=null && stretchGroup.getEndRes()==res) + // Edit end res position of selected group + changeEndRes = true; + + else if(stretchGroup!=null && stretchGroup.getStartRes()==res) + // Edit end res position of selected group + changeStartRes = true; + + } + + boolean changeEndSeq = false; + boolean changeStartSeq = false; + boolean changeEndRes = false; + boolean changeStartRes = false; + SequenceGroup stretchGroup = null; + + public void doMouseReleasedDefineMode(MouseEvent evt) + { + mouseDragging = false; + + if(stretchGroup==null) + return; + + if(stretchGroup.cs instanceof ClustalxColourScheme) + { + stretchGroup.cs = new ClustalxColourScheme(stretchGroup.sequences, av.alignment.getWidth()); + seqCanvas.repaint(); + } + + else if(stretchGroup.cs instanceof ConservationColourScheme) + { + ConservationColourScheme ccs = (ConservationColourScheme)stretchGroup.cs; + stretchGroup.cs = ccs; + SliderPanel.setConservationSlider(ap, stretchGroup.cs, stretchGroup.getName()) ; + + seqCanvas.repaint(); + } + else + { + if(stretchGroup.cs !=null && stretchGroup.cs.canThreshold()) + { + ResidueColourScheme rcs = (ResidueColourScheme) stretchGroup.cs; + SliderPanel.setPIDSliderSource(ap, stretchGroup.cs, stretchGroup.getName()); + } + + } + + + changeEndRes = false; + changeStartRes = false; + stretchGroup = null; + ap.repaint(); + } + + + boolean remove = false; + public void doMouseDraggedDefineMode(MouseEvent evt) + { + int res = evt.getX()/av.getCharWidth() + av.getStartRes(); + int y = evt.getY()/av.getCharHeight() + av.getStartSeq(); + + if(stretchGroup==null) + return; + + if(res>av.alignment.getWidth()) + res = av.alignment.getWidth()-1; + + + if(stretchGroup.getEndRes()==res) + // Edit end res position of selected group + changeEndRes = true; + + else if(stretchGroup.getStartRes()==res) + // Edit start res position of selected group + changeStartRes = true; + + + if(resav.getEndRes()) + res = av.getEndRes(); + + if(changeEndRes) + { + if(res>stretchGroup.getStartRes()-1) + stretchGroup.setEndRes( res ); + } + else if(changeStartRes) + { + if(res oldSeq) + dragDirection = 1; + else if (y < oldSeq) + dragDirection = -1; + + while (y != oldSeq && oldSeq>0 && y 0) + running = ap.scrollUp(true); + + if (mouseDragging && evt.getY() >= getSize().height && + av.alignment.getHeight() > av.getEndSeq()) + running = ap.scrollUp(false); + + if (mouseDragging && evt.getX() < 0) + running = ap.scrollRight(true); + + else if (mouseDragging && evt.getX() >= getSize().width) + running = ap.scrollRight(false); + } + + try + { + Thread.sleep(75); + } + catch (Exception ex) + {} + } + } +} + + + +} + + + + diff --git a/src/jalview/appletgui/SequenceRenderer.java b/src/jalview/appletgui/SequenceRenderer.java new file mode 100755 index 0000000..a13b643 --- /dev/null +++ b/src/jalview/appletgui/SequenceRenderer.java @@ -0,0 +1,188 @@ +package jalview.appletgui; + +import jalview.datamodel.*; +import jalview.schemes.*; +import java.awt.*; + +public class SequenceRenderer +{ + AlignViewport av; + FontMetrics fm; + boolean renderGaps = true; + SequenceGroup currentSequenceGroup = null; + SequenceGroup [] allGroups = null; + Color resBoxColour; + Graphics graphics; + + public SequenceRenderer(AlignViewport av) + { + this.av = av; + } + + + public void renderGaps(boolean b) + { + renderGaps = b; + } + + public Color getResidueBoxColour(ColourSchemeI cs, SequenceI seq, int i) + { + getBoxColour(cs, seq, i); + return resBoxColour; + } + + void getBoxColour(ColourSchemeI cs, SequenceI seq, int i) + { + if (cs != null) + resBoxColour = cs.findColour(seq.getSequence(i, i + 1), i); + else + resBoxColour = Color.white; + } + + public void drawSequence(Graphics g,SequenceI seq,SequenceGroup [] sg, int start, int end, int x1, int y1, int width, int height) + { + allGroups = sg; + + graphics = g; + + drawBoxes(seq, start, end, x1, y1, (int) width, height); + + fm = g.getFontMetrics(); + drawText(seq,start,end,x1,y1,(int)width,height); + + } + + public void drawBoxes(SequenceI seq,int start, int end, int x1, int y1, int width, int height) { + int i = start; + int length = seq.getLength(); + + int curStart = -1; + int curWidth = width; + + Color tempColour = null; + while (i <= end && i < length) + { + if(inCurrentSequenceGroup(i)) + { + if( currentSequenceGroup.getDisplayBoxes()) + getBoxColour(currentSequenceGroup.cs, seq, i); + } + else if(av.getShowBoxes()) + getBoxColour(av.getGlobalColourScheme(), seq, i); + else + resBoxColour = Color.white; + + + if (resBoxColour != tempColour) + { + if(tempColour!=null) + graphics.fillRect(x1+width*(curStart-start),y1,curWidth,height); + graphics.setColor(resBoxColour); + + curStart = i; + curWidth = width; + tempColour = resBoxColour; + + } + else + curWidth += width; + + i++; + } + + + graphics.fillRect(x1+width*(curStart-start),y1,curWidth,height); + } + + public void drawText(SequenceI seq,int start, int end, int x1, int y1, int width, int height) + { + int pady = height/5; + int charOffset=0; + char s; + // Need to find the sequence position here. + + graphics.setColor(Color.black); + String sequence = seq.getSequence(); + for (int i = start; i <= end; i++) + { + if(i=res) + { + currentSequenceGroup = allGroups[i]; + return true; + } + + return false; + } + + public void drawHighlightedText(SequenceI seq,int start, int end, int x1, int y1, int width, int height) + { + int pady = height/5; + int charOffset=0; + graphics.setColor(Color.black); + graphics.fillRect(x1,y1,width*(end-start+1),height); + graphics.setColor(Color.white); + + char s='~'; + // Need to find the sequence position here. + for (int i = start; i <= end; i++) + { + if(i -1 ) + { + if(allGroups!=null) + toChange = ((SequenceGroup)allGroups.elementAt(groupIndex)).cs; + + if (forConservation) + { + if (toChange instanceof ConservationColourScheme) + ( (ConservationColourScheme) toChange).inc = i; + } + else + { + if (toChange.canThreshold()) + ( (ResidueColourScheme) toChange).setThreshold(i); + } + + groupIndex--; + } + + ap.seqPanel.seqCanvas.repaint(); + + } + + public void setAllGroupsCheckEnabled(boolean b) + { + allGroupsCheck.setEnabled(b); + } + + + public void valueField_actionPerformed(ActionEvent e) + { + try{ + int i = Integer.parseInt(valueField.getText()); + slider.setValue(i); + } + catch(Exception ex) + { + valueField.setText( slider.getValue()+"" ); + } + } + + public void setValue(int value) + { + slider.setValue(value); + } + public int getValue() + { + return Integer.parseInt(valueField.getText()); + } + + +} diff --git a/src/jalview/appletgui/TreeCanvas.java b/src/jalview/appletgui/TreeCanvas.java new file mode 100755 index 0000000..7a79492 --- /dev/null +++ b/src/jalview/appletgui/TreeCanvas.java @@ -0,0 +1,430 @@ +package jalview.appletgui; + + +import jalview.analysis.*; +import jalview.datamodel.*; +import jalview.util.*; +import jalview.schemes.*; +import java.awt.*; +import java.awt.event.*; +import java.util.*; + + +public class TreeCanvas extends Panel implements MouseListener +{ + NJTree tree; + ScrollPane scrollPane; + AlignViewport av; + + Font font; + int fontSize = 12; + + boolean fitToWindow = true; + boolean showDistances = false; + boolean showBootstrap = false; + + int offx = 20; + int offy = 20; + + float threshold; + + String longestName; + int labelLength=-1; + + //RubberbandRectangle rubberband; + + Vector listeners; + + Hashtable nameHash = new Hashtable(); + Hashtable nodeHash = new Hashtable(); + + public TreeCanvas(AlignViewport av, NJTree tree, ScrollPane scroller, String label) + { + this.av = av; + this.tree = tree; + scrollPane = scroller; + addMouseListener(this); + tree.findHeight(tree.getTopNode()); + longestName = label; + setLayout(null); + + PaintRefresher.Register(this); + } + public void TreeSelectionChanged(Sequence sequence) + { + SequenceGroup selected = av.getSelectionGroup(); + if(selected == null) + { + selected = new SequenceGroup(); + av.setSelectionGroup(selected); + } + + selected.setEndRes(av.alignment.getWidth()); + selected.addOrRemove(sequence); + + + PaintRefresher.Refresh(this); + repaint(); + } + + + + public void setTree(NJTree tree) { + this.tree = tree; + tree.findHeight(tree.getTopNode()); + } + + public void drawNode(Graphics g,SequenceNode node, float chunk, float scale, int width,int offx, int offy) { + if (node == null) { + return; + } + + if (node.left() == null && node.right() == null) { + // Drawing leaf node + + float height = node.height; + float dist = node.dist; + + int xstart = (int)((height-dist)*scale) + offx; + int xend = (int)(height*scale) + offx; + + int ypos = (int)(node.ycount * chunk) + offy; + + if (node.element() instanceof SequenceI) + { + if ( ( (SequenceI) ( (SequenceNode) node).element()).getColor() == Color.white) + { + g.setColor(Color.black); + } + else + g.setColor( ( (SequenceI) ( (SequenceNode) node).element()).getColor(). + darker()); + + } + else + g.setColor(Color.black); + + + // Draw horizontal line + g.drawLine(xstart,ypos,xend,ypos); + + String nodeLabel = ""; + if (showDistances && node.dist > 0) { + nodeLabel = new Format("%5.2f").form(node.dist); + } + if (showBootstrap) { + if (showDistances) { + nodeLabel = nodeLabel + " : "; + } + nodeLabel = nodeLabel + String.valueOf(node.getBootstrap()); + } + if (! nodeLabel.equals("")) { + g.drawString(nodeLabel,xstart,ypos - 10); + } + + // Colour selected leaves differently + String name = node.getName(); + FontMetrics fm = g.getFontMetrics(font); + int charWidth = fm.stringWidth(node.getName()) + 3; + int charHeight = fm.getHeight(); + + Rectangle rect = new Rectangle(xend+20,ypos-charHeight, + charWidth,charHeight); + + nameHash.put((SequenceI)node.element(),rect); + + SequenceGroup selected = av.getSelectionGroup(); + if (selected!=null && selected.sequences.contains((SequenceI)node.element())) { + g.setColor(Color.gray); + + g.fillRect(xend + 10, ypos - charHeight + 3,charWidth,charHeight); + g.setColor(Color.white); + } + g.drawString(node.getName(),xend+10,ypos); + g.setColor(Color.black); + } else { + drawNode(g,(SequenceNode)node.left(), chunk,scale,width,offx,offy); + drawNode(g,(SequenceNode)node.right(),chunk,scale,width,offx,offy); + + float height = node.height; + float dist = node.dist; + + int xstart = (int)((height-dist)*scale) + offx; + int xend = (int)(height *scale) + offx; + int ypos = (int)(node.ycount *chunk) + offy; + + g.setColor(((SequenceNode)node).color.darker()); + + // Draw horizontal line + g.drawLine(xstart,ypos,xend,ypos); + g.fillRect(xend-2, ypos-2, 4,4); + + int ystart = (int)(((SequenceNode)node.left()) .ycount * chunk) + offy; + int yend = (int)(((SequenceNode)node.right()).ycount * chunk) + offy; + + Rectangle pos = new Rectangle(xend-2,ypos-2,5,5); + nodeHash.put(node,pos); + + g.drawLine((int)(height*scale) + offx, ystart, + (int)(height*scale) + offx, yend); + + if (showDistances && node.dist > 0) { + g.drawString(new Format("%5.2f").form(node.dist),xstart,ypos - 5); + } + + } + } + public Object findElement(int x, int y) { + Enumeration keys = nameHash.keys(); + + while (keys.hasMoreElements()) { + Object ob = keys.nextElement(); + Rectangle rect = (Rectangle)nameHash.get(ob); + + if (x >= rect.x && x <= (rect.x + rect.width) && + y >= rect.y && y <= (rect.y + rect.height)) { + return ob; + } + } + keys = nodeHash.keys(); + + while (keys.hasMoreElements()) { + Object ob = keys.nextElement(); + Rectangle rect = (Rectangle)nodeHash.get(ob); + + if (x >= rect.x && x <= (rect.x + rect.width) && + y >= rect.y && y <= (rect.y + rect.height)) { + return ob; + } + } + return null; + + } + + public void pickNodes(Rectangle pickBox) { + int width = getSize().width; + int height = getSize().height; + + SequenceNode top = tree.getTopNode(); + + float wscale = (float)(width*.8-offx*2)/tree.getMaxHeight() +; + if (top.count == 0) { + top.count = ((SequenceNode)top.left()).count + ((SequenceNode)top.right()).count ; + } + float chunk = (float)(height-offy*2)/top.count; + + pickNode(pickBox,top,chunk,wscale,width,offx,offy); + } + + public void pickNode(Rectangle pickBox, SequenceNode node, float chunk, float scale, int width,int offx, int offy) { + if (node == null) { + return; + } + + if (node.left() == null && node.right() == null) { + float height = node.height; + float dist = node.dist; + + int xstart = (int)((height-dist)*scale) + offx; + int xend = (int)(height*scale) + offx; + + int ypos = (int)(node.ycount * chunk) + offy; + + if (pickBox.contains(new Point(xend,ypos))) { + if (node.element() instanceof SequenceI) { + SequenceI seq = (SequenceI)node.element(); + SequenceGroup sg = av.getSelectionGroup(); + if(sg!=null) + sg.addOrRemove(seq); + } + } + } else { + pickNode(pickBox,(SequenceNode)node.left(), chunk,scale,width,offx,offy); + pickNode(pickBox,(SequenceNode)node.right(),chunk,scale,width,offx,offy); + } + } + + public void setColor(SequenceNode node, Color c) + { + if (node == null) + return; + + if (node.left() == null && node.right() == null) + { + node.color = c; + + if (node.element() instanceof SequenceI) + ((SequenceI)node.element()).setColor(c); + } else + { + node.color = c; + setColor((SequenceNode)node.left(),c); + setColor((SequenceNode)node.right(),c); + } + } + + + public void paint(Graphics g) + { + + font = new Font("Verdana",Font.PLAIN,fontSize); + g.setFont(font); + + FontMetrics fm = g.getFontMetrics(font); + + if(nameHash.size()==0) + repaint(); + + + if( fitToWindow || (!fitToWindow && scrollPane.getSize().height > fm.getHeight() * nameHash.size()+offy ) ) + { + draw(g,scrollPane.getSize().width,scrollPane.getSize().height); + } + else + { + setSize(new Dimension(scrollPane.getSize().width, fm.getHeight() * nameHash.size())); + draw( g,scrollPane.getSize().width, fm.getHeight() * nameHash.size()); + } + + scrollPane.validate(); + } + public int getFontSize() { + return fontSize; + } + public void setFontSize(int fontSize) { + this.fontSize = fontSize; + repaint(); + } + public void draw(Graphics g, int width, int height) { + + g.setColor(Color.white); + g.fillRect(0,0,width,height); + + + labelLength = g.getFontMetrics(font).stringWidth(longestName)+ 20;//20 allows for scrollbar + + float wscale =(float)(width - labelLength -offx*2)/tree.getMaxHeight(); + + SequenceNode top = tree.getTopNode(); + + if (top.count == 0) { + top.count = ((SequenceNode)top.left()).count + ((SequenceNode)top.right()).count ; + } + float chunk = (float)(height-offy*2)/top.count ; + + drawNode(g,tree.getTopNode(),chunk,wscale,width,offx,offy); + + if (threshold != 0) + { + if(av.getCurrentTree() == tree) + g.setColor(Color.red); + else + g.setColor(Color.gray); + + int x = (int)( threshold * (float)(getSize().width-labelLength - 2*offx) +offx ) ; + + g.drawLine(x,0,x,getSize().height); + } + + } + + public void mouseReleased(MouseEvent e) { } + public void mouseEntered(MouseEvent e) { } + public void mouseExited(MouseEvent e) { } + public void mouseClicked(MouseEvent e) { + } + + public void mousePressed(MouseEvent e) { + + av.setCurrentTree(tree); + + int x = e.getX(); + int y = e.getY(); + + Object ob = findElement(x,y); + + if (ob instanceof SequenceI) + { + TreeSelectionChanged((Sequence)ob); + repaint(); + return; + + } else if (ob instanceof SequenceNode) { + SequenceNode tmpnode = (SequenceNode)ob; + tree.swapNodes(tmpnode); + tree.reCount(tree.getTopNode()); + tree.findHeight(tree.getTopNode()); + } else { + // Find threshold + + if (tree.getMaxHeight() != 0) { + threshold = (float)(x - offx)/(float)(getSize().width-labelLength - 2*offx); + + tree.getGroups().removeAllElements(); + tree.groupNodes(tree.getTopNode(),threshold); + setColor(tree.getTopNode(),Color.black); + + av.setSelectionGroup(null); + av.alignment.deleteAllGroups(); + + for (int i=0; i < tree.getGroups().size(); i++) + { + + Color col = new Color((int)(Math.random()*255), + (int)(Math.random()*255), + (int)(Math.random()*255)); + setColor((SequenceNode)tree.getGroups().elementAt(i),col.brighter()); + + Vector l = tree.findLeaves((SequenceNode)tree.getGroups().elementAt(i),new Vector()); + SequenceGroup sg = null; + for (int j = 0; j < l.size(); j++) + { + SequenceNode sn = (SequenceNode) l.elementAt(j); + if(sg==null) + sg = new SequenceGroup("TreeGroup", av.getGlobalColourScheme(), true, true,false,0,av.alignment.getWidth()); + + sg.addSequence( (Sequence) sn.element()); + } + + if (av.getGlobalColourScheme() instanceof ConservationColourScheme) + { + ConservationColourScheme ccs = (ConservationColourScheme) av.getGlobalColourScheme(); + Conservation c = new Conservation("Group", + ResidueProperties.propHash, 3, + sg.sequences, sg.getStartRes(), + sg.getEndRes()); + + c.calculate(); + c.verdict(false, av.ConsPercGaps); + ccs = new ConservationColourScheme(c, ccs.cs); + + sg.cs = ccs; + + } + + + + av.alignment.addGroup(sg); + + } + } + } + + PaintRefresher.Refresh(this); + repaint(); + + } + + public void setShowDistances(boolean state) { + this.showDistances = state; + repaint(); + } + + public void setShowBootstrap(boolean state) { + this.showBootstrap = state; + repaint(); + } + +} + diff --git a/src/jalview/appletgui/TreePanel.java b/src/jalview/appletgui/TreePanel.java new file mode 100755 index 0000000..89ff20f --- /dev/null +++ b/src/jalview/appletgui/TreePanel.java @@ -0,0 +1,101 @@ +package jalview.appletgui; + +import jalview.datamodel.*; +import jalview.analysis.*; +import jalview.jbappletgui.GTreePanel; +import java.awt.event.*; +import java.util.*; + + +public class TreePanel extends GTreePanel +{ + SequenceI[] seq; + String type; + String pwtype; + AlignViewport av; + int start; + int end; + TreeCanvas treeCanvas; + NJTree tree; + + public NJTree getTree() + { + return tree; + } + + public TreePanel(AlignViewport av, Vector seqVector, String type, String pwtype, int s, int e) + { + super(); + + this.type = type; + this.pwtype = pwtype; + + start = s; + end = e; + + String longestName = ""; + seq = new Sequence [seqVector.size()]; + for (int i=0;i < seqVector.size();i++) + { + seq[i] = (Sequence) seqVector.elementAt(i); + if(seq[i].getName().length()>longestName.length()) + longestName = seq[i].getName(); + } + + tree = new NJTree(seq, type, pwtype, start, end); + + treeCanvas = new TreeCanvas(av, tree, scrollPane, longestName); + + tree.reCount(tree.getTopNode()); + tree.findHeight(tree.getTopNode()); + scrollPane.add(treeCanvas); + + } + + +public String getText(String format) { + return null; +} + + protected void fitToWindow_actionPerformed(ActionEvent e) + { + treeCanvas.fitToWindow = fitToWindow.getState(); + repaint(); + } + + + protected void fontSize_actionPerformed(ActionEvent e) + { + /* if( treeCanvas==null ) + return; + + String size = fontSize.getLabel().substring( fontSize.getLabel().indexOf("-")+1); + + Object selection = JOptionPane.showInternalInputDialog(Desktop.desktop, + "Select font size", + "Font size", + JOptionPane.QUESTION_MESSAGE, + null, new String[]{"1","2","4","6","8","10","12","14","16","18","20"} + ,"Font Size - "+size); + if(selection!=null) + { + fontSize.setText("Font Size - " + selection); + + int i = Integer.parseInt(selection.toString()); + treeCanvas.setFontSize(i); + } + scrollPane.setViewportView(treeCanvas); +*/ + } + + protected void distanceMenu_actionPerformed(ActionEvent e) + { + treeCanvas.setShowDistances(distanceMenu.getState()); + } + + protected void bootstrapMenu_actionPerformed(ActionEvent e) + { + treeCanvas.setShowBootstrap(bootstrapMenu.getState()); + } + +} diff --git a/src/jalview/appletgui/UserDefinedColours.java b/src/jalview/appletgui/UserDefinedColours.java new file mode 100755 index 0000000..9f1eb6d --- /dev/null +++ b/src/jalview/appletgui/UserDefinedColours.java @@ -0,0 +1,226 @@ +package jalview.appletgui; + +import jalview.jbappletgui.GUserDefinedColours; +import jalview.datamodel.*; +import jalview.schemes.*; +import jalview.io.*; +import java.io.*; +import java.awt.*; +import java.awt.event.*; +import java.util.*; + + +public class UserDefinedColours extends GUserDefinedColours +{ + + AlignmentPanel ap; + SequenceGroup seqGroup; + Button selectedButton; + Vector oldColours = new Vector(); + ColourSchemeI oldColourScheme; + Frame frame; + + int R = 0, G = 0, B = 0; + + public UserDefinedColours(AlignmentPanel ap, SequenceGroup sg) + { + super(); + frame = new Frame(); + frame.add(this); + jalview.bin.JalviewLite.addFrame(frame, "User defined colours", 420,345 ); + + if(sg!=null) + frame.setTitle( frame.getTitle()+ " ("+sg.getName()+")"); + + + this.ap = ap; + seqGroup = sg; + + + if (seqGroup != null) + oldColourScheme = seqGroup.cs; + else + oldColourScheme = ap.av.getGlobalColourScheme(); + + for (int i = 0; i < 20; i++) + makeButton(ResidueProperties.aa2Triplet.get(ResidueProperties.aa[i]) + + "", ResidueProperties.aa[i]); + + makeButton("B", "B"); + makeButton("Z", "Z"); + makeButton("X", "X"); + makeButton("Gap", "'.','-',' '"); + + } + + protected void rText_actionPerformed(ActionEvent e) { + try{ + int i = Integer.parseInt(rText.getText()); + rScroller.setValue(i); + }catch(NumberFormatException ex){} + } + + protected void gText_actionPerformed(ActionEvent e) { + try{ + int i = Integer.parseInt(gText.getText()); + gScroller.setValue(i); + }catch(NumberFormatException ex){} + + } + + protected void bText_actionPerformed(ActionEvent e) { + try{ + int i = Integer.parseInt(bText.getText()); + bScroller.setValue(i); + }catch(NumberFormatException ex){} + + } + + + protected void rScroller_adjustmentValueChanged(AdjustmentEvent e) { + R = rScroller.getValue(); + rText.setText(R+""); + colourChanged(); + } + + protected void gScroller_adjustmentValueChanged(AdjustmentEvent e) { + G = gScroller.getValue(); + gText.setText(G+""); + colourChanged(); + } + + protected void bScroller_adjustmentValueChanged(AdjustmentEvent e) { + B = bScroller.getValue(); + bText.setText(B+""); + colourChanged(); + } + + public void colourChanged() + { + Color col = new Color(R,G,B); + target.setBackground( col ); + + if(selectedButton!=null) + selectedButton.setBackground( col ); + } + + public void colourButtonPressed(MouseEvent e) + { + selectedButton = (Button)e.getSource(); + Color col = selectedButton.getBackground(); + R = col.getRed(); + G = col.getGreen(); + B = col.getBlue(); + rScroller.setValue(R); + gScroller.setValue(G); + bScroller.setValue(B); + rText.setText(R+""); + gText.setText(G+""); + bText.setText(B+""); + + colourChanged(); + } + + void makeButton(String label, String aa) + { + final Button button = new Button(); + Color col = Color.white; + + + try{ + col = oldColourScheme.findColour(aa, -1); + }catch(Exception ex){} + + button.setBackground( col ); + oldColours.addElement( col ); + button.setLabel( label ); + button.setForeground( col.darker().darker().darker() ); + button.setFont(new java.awt.Font("Verdana", 1, 10)); + button.addMouseListener(new java.awt.event.MouseAdapter() + { + public void mouseClicked(MouseEvent e) + { + colourButtonPressed(e); + } + }); + + buttonPanel.add(button, null); + } + + + protected void okButton_actionPerformed(ActionEvent e) + { + applyButton_actionPerformed(null); + frame.setVisible(false); + } + + protected void applyButton_actionPerformed(ActionEvent e) + { + + Color [] newColours = new Color[24]; + for(int i=0; i<24; i++) + { + Button button = (Button)buttonPanel.getComponent(i); + newColours[i] = button.getBackground(); + } + + UserColourScheme ucs = new UserColourScheme(); + ucs.setThreshold(0); + ucs.setColourScheme( newColours ); + + if(seqGroup!=null) + seqGroup.cs = ucs; + else + ap.av.setGlobalColourScheme(ucs); + + ap.repaint(); + } + + + public static UserColourScheme loadDefaultColours(String file) + { + UserColourScheme ucs = null; + try + { + BufferedReader in = new BufferedReader(new FileReader(file)); + Color [] newColours = new Color[24]; + for (int i = 0; i < 24; i++) + { + newColours[i] = new Color(Integer.parseInt(in.readLine())); + } + + ucs = new UserColourScheme(); + ucs.setThreshold(0); + ucs.setColourScheme(newColours); + + } + catch (Exception ex) + {} + + return ucs; + } + + + protected void cancelButton_actionPerformed(ActionEvent e) + { + UserColourScheme ucs = new UserColourScheme(); + Color [] newColours = new Color[24]; + for(int i=0; i<24; i++) + { + newColours[i] = (Color)oldColours.elementAt(i); + buttonPanel.getComponent(i).setBackground(newColours[i]); + } + + ucs.setColourScheme( newColours ); + if (seqGroup != null) + seqGroup.cs = ucs; + else + ap.av.setGlobalColourScheme(ucs); + + ap.repaint(); + + frame.setVisible(false); + } + + +} diff --git a/src/jalview/bin/JalviewLite.java b/src/jalview/bin/JalviewLite.java new file mode 100755 index 0000000..1ce2066 --- /dev/null +++ b/src/jalview/bin/JalviewLite.java @@ -0,0 +1,122 @@ +package jalview.bin; + +import java.applet.*; +import java.awt.*; +import java.awt.event.*; +import jalview.datamodel.*; +import jalview.io.*; +import jalview.appletgui.AlignFrame; + +public class JalviewLite extends Applet +{ + static int lastFrameX = 200; + static int lastFrameY = 200; + static Applet applet; + boolean fileFound = true; + String file = "No file"; + Button launcher = new Button("Start Jalview"); + + public void init() + { + applet = this; + this.setBackground(Color.white); + + file = getParameter("file"); + if (file != null) + { + add(launcher); + file = applet.getCodeBase() + file; + launcher.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + String format = jalview.io.IdentifyFile.Identify( file, "URL"); + LoadFile(file, "URL", format); + } + }); + } + else + { + file = "NO FILE"; + fileFound = false; + } + } + + + public static void showURL(String url) + { + try{ + applet.getAppletContext().showDocument(new java.net.URL(url), "HELP_WINDOW"); + }catch(Exception ex){} + } + + public void LoadFile(String file, String protocol, String format) + { + LoadingThread loader = new LoadingThread(file, protocol, format, this); + loader.start(); + } + + public static void addFrame(final Frame frame, String title, int width, int height) + { + frame.setLocation(lastFrameX,lastFrameY); + lastFrameX+=40; lastFrameY+=40; + frame.setSize(width,height); + frame.setTitle(title); + frame.addWindowListener(new WindowAdapter() + { + public void windowClosing(WindowEvent e) + { + frame.dispose(); + } + }); + frame.setVisible(true); + } + + + public void paint(Graphics g) + { + if(!fileFound) + { + g.setColor(new Color(200,200,200)); + g.setColor(Color.cyan); + g.fillRect(0,0,getSize().width, getSize().height); + g.setColor(Color.red); + g.drawString("Jalview can't open file", 5, 15); + g.drawString("\""+ file+"\"", 5, 30); + } + } + + class LoadingThread extends Thread + { + String file, protocol, format; + JalviewLite jlapplet; + + public LoadingThread(String file, String protocol, String format, JalviewLite applet) + { + this.file = file; + this.protocol = protocol; + this.format = format; + this.jlapplet = applet; + } + public void run() + { + SequenceI [] sequences = null; + sequences = FormatAdapter.readFile(file, protocol, format); + + if (sequences != null && sequences.length>0) + { + AlignFrame af = new AlignFrame(new Alignment(sequences), jlapplet ); + addFrame(af, file, AlignFrame.NEW_WINDOW_WIDTH, AlignFrame.NEW_WINDOW_HEIGHT); + af.statusBar.setText("Successfully loaded file " + file); + } + else + { + fileFound = false; + remove(launcher); + repaint(); + } + } + } +} + + diff --git a/src/jalview/jbappletgui/GAlignFrame.java b/src/jalview/jbappletgui/GAlignFrame.java new file mode 100755 index 0000000..806ca46 --- /dev/null +++ b/src/jalview/jbappletgui/GAlignFrame.java @@ -0,0 +1,1113 @@ +/******************** + * 2004 Jalview Reengineered + * Barton Group + * Dundee University + * + * AM Waterhouse + *******************/ + +package jalview.jbappletgui; + +import java.awt.event.*; +import java.awt.*; + +public class GAlignFrame extends Frame +{ + protected MenuBar alignFrameMenuBar = new MenuBar(); + protected Menu fileMenu = new Menu(); + protected MenuItem closeMenuItem = new MenuItem(); + protected Menu editMenu = new Menu(); + protected Menu viewMenu = new Menu(); + protected Menu colourMenu = new Menu(); + protected Menu calculateMenu = new Menu(); + protected MenuItem selectAllSequenceMenuItem = new MenuItem(); + protected MenuItem deselectAllSequenceMenuItem = new MenuItem(); + protected MenuItem invertSequenceMenuItem = new MenuItem(); + protected MenuItem remove2LeftMenuItem = new MenuItem(); + protected MenuItem remove2RightMenuItem = new MenuItem(); + protected MenuItem removeGappedColumnMenuItem = new MenuItem(); + protected MenuItem removeAllGapsMenuItem = new MenuItem(); + protected CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem(); + protected CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem(); + protected MenuItem sortPairwiseMenuItem = new MenuItem(); + protected MenuItem sortIDMenuItem = new MenuItem(); + protected MenuItem sortGroupMenuItem = new MenuItem(); + protected MenuItem removeRedundancyMenuItem = new MenuItem(); + protected MenuItem pairwiseAlignmentMenuItem = new MenuItem(); + protected MenuItem PCAMenuItem = new MenuItem(); + protected MenuItem averageDistanceTreeMenuItem = new MenuItem(); + protected MenuItem neighbourTreeMenuItem = new MenuItem(); + BorderLayout borderLayout1 = new BorderLayout(); + public Label statusBar = new Label(); + protected Menu outputTextboxMenu = new Menu(); + protected MenuItem clustalColour = new MenuItem(); + protected MenuItem zappoColour = new MenuItem(); + protected MenuItem taylorColour = new MenuItem(); + protected MenuItem hydrophobicityColour = new MenuItem(); + protected MenuItem helixColour = new MenuItem(); + protected MenuItem strandColour = new MenuItem(); + protected MenuItem turnColour = new MenuItem(); + protected MenuItem buriedColour = new MenuItem(); + protected MenuItem userDefinedColour = new MenuItem(); + protected MenuItem PIDColour = new MenuItem(); + protected MenuItem BLOSUM62Colour = new MenuItem(); + MenuItem njTreeBlosumMenuItem = new MenuItem(); + MenuItem avDistanceTreeBlosumMenuItem = new MenuItem(); + protected CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem(); + protected CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem(); + MenuItem overviewMenuItem = new MenuItem(); + protected MenuItem undoMenuItem = new MenuItem(); + protected MenuItem redoMenuItem = new MenuItem(); + protected CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem(); + MenuItem noColourmenuItem = new MenuItem(); + protected CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem(); + protected CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem(); + MenuItem findMenuItem = new MenuItem(); + Menu searchMenu = new Menu(); + protected CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem(); + protected MenuItem nucleotideColour = new MenuItem(); + MenuItem deleteGroups = new MenuItem(); + MenuItem delete = new MenuItem(); + MenuItem copy = new MenuItem(); + MenuItem cut = new MenuItem(); + Menu Menu1 = new Menu(); + MenuItem pasteNew = new MenuItem(); + MenuItem pasteThis = new MenuItem(); + protected CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem(); + protected MenuItem font = new MenuItem(); + protected CheckboxMenuItem fullSeqId = new CheckboxMenuItem(); + protected CheckboxMenuItem scaleAbove = new CheckboxMenuItem(); + protected CheckboxMenuItem scaleLeft = new CheckboxMenuItem(); + protected CheckboxMenuItem scaleRight = new CheckboxMenuItem(); + MenuItem modifyPID = new MenuItem(); + MenuItem modifyConservation = new MenuItem(); + protected Menu sortByTreeMenu = new Menu(); + Menu sort = new Menu(); + Menu calculate = new Menu(); + MenuItem inputText = new MenuItem(); + Menu helpMenu = new Menu(); + MenuItem documentation = new MenuItem(); + MenuItem about = new MenuItem(); + public GAlignFrame() + { + try + { + jbInit(); + setMenuBar(alignFrameMenuBar); + + MenuItem item; + // dynamically fill save as menu with available formats + for (int i = 0; i < jalview.io.FormatAdapter.formats.size(); i++) { + item = new MenuItem((String) jalview.io.FormatAdapter.formats.elementAt(i)); + item.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + saveAs_actionPerformed(e); + } + }); + + item = new MenuItem((String) jalview.io.FormatAdapter.formats.elementAt(i)); + item.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + outputText_actionPerformed(e); + } + }); + + outputTextboxMenu.add( item ); + } + + } + catch(Exception e) + { + e.printStackTrace(); + } + + } + private void jbInit() throws Exception + { + fileMenu.setLabel("File"); + closeMenuItem.setLabel("Close"); + closeMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + closeMenuItem_actionPerformed(e); + } + }); + editMenu.setLabel("Edit"); + viewMenu.setLabel("View"); + colourMenu.setLabel("Colour"); + calculateMenu.setLabel("Calculate"); + selectAllSequenceMenuItem.setLabel("Select all"); + selectAllSequenceMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + selectAllSequenceMenuItem_actionPerformed(e); + } + }); + deselectAllSequenceMenuItem.setLabel("Deselect All"); + deselectAllSequenceMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + deselectAllSequenceMenuItem_actionPerformed(e); + } + }); + invertSequenceMenuItem.setLabel("Invert Selection"); + invertSequenceMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + invertSequenceMenuItem_actionPerformed(e); + } + }); + remove2LeftMenuItem.setLabel("Remove Left"); + remove2LeftMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + remove2LeftMenuItem_actionPerformed(e); + } + }); + remove2RightMenuItem.setLabel("Remove Right"); + remove2RightMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + remove2RightMenuItem_actionPerformed(e); + } + }); + removeGappedColumnMenuItem.setLabel("Remove Empty Columns"); + removeGappedColumnMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + removeGappedColumnMenuItem_actionPerformed(e); + } + }); + removeAllGapsMenuItem.setLabel("Remove All Gaps"); + removeAllGapsMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + removeAllGapsMenuItem_actionPerformed(e); + } + }); + viewBoxesMenuItem.setLabel("Boxes"); + viewBoxesMenuItem.setState(true); + viewBoxesMenuItem.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + viewBoxesMenuItem_actionPerformed(null); + } + }); + viewTextMenuItem.setLabel("Text"); + viewTextMenuItem.setState(true); + viewTextMenuItem.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + viewTextMenuItem_actionPerformed(null); + } + }); + sortPairwiseMenuItem.setLabel("Pairwise Identity"); + sortPairwiseMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + sortPairwiseMenuItem_actionPerformed(e); + } + }); + sortIDMenuItem.setLabel("ID"); + sortIDMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + sortIDMenuItem_actionPerformed(e); + } + }); + sortGroupMenuItem.setLabel("Group"); + sortGroupMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + sortGroupMenuItem_actionPerformed(e); + } + }); + removeRedundancyMenuItem.setLabel("Remove Redundancy..."); + removeRedundancyMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + removeRedundancyMenuItem_actionPerformed(e); + } + }); + pairwiseAlignmentMenuItem.setLabel("Pairwise Alignments..."); + pairwiseAlignmentMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + pairwiseAlignmentMenuItem_actionPerformed(e); + } + }); + PCAMenuItem.setLabel("Principal Component Analysis..."); + PCAMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + PCAMenuItem_actionPerformed(e); + } + }); + averageDistanceTreeMenuItem.setLabel("Average Distance Using % Identity..."); + averageDistanceTreeMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + averageDistanceTreeMenuItem_actionPerformed(e); + } + }); + neighbourTreeMenuItem.setLabel("Neighbour Joining Using % Identity..."); + neighbourTreeMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + neighbourTreeMenuItem_actionPerformed(e); + } + }); + alignFrameMenuBar.setFont(new java.awt.Font("Verdana", 0, 11)); + statusBar.setBackground(Color.white); + statusBar.setFont(new java.awt.Font("Verdana", 0, 11)); + statusBar.setText("Status bar"); + outputTextboxMenu.setLabel("Output to Textbox"); + clustalColour.setLabel("Clustalx"); + + clustalColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + clustalColour_actionPerformed(e); + } + }); + zappoColour.setLabel("Zappo"); + zappoColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + zappoColour_actionPerformed(e); + } + }); + taylorColour.setLabel("Taylor"); + taylorColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + taylorColour_actionPerformed(e); + } + }); + hydrophobicityColour.setLabel("Hydrophobicity"); + hydrophobicityColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + hydrophobicityColour_actionPerformed(e); + } + }); + helixColour.setLabel("Helix Propensity"); + helixColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + helixColour_actionPerformed(e); + } + }); + strandColour.setLabel("Strand Propensity"); + strandColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + strandColour_actionPerformed(e); + } + }); + turnColour.setLabel("Turn Propensity"); + turnColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + turnColour_actionPerformed(e); + } + }); + buriedColour.setLabel("Buried Index"); + buriedColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + buriedColour_actionPerformed(e); + } + }); + userDefinedColour.setLabel("User Defined..."); + userDefinedColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + userDefinedColour_actionPerformed(e); + } + }); + PIDColour.setLabel("Percentage Identity"); + PIDColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + PIDColour_actionPerformed(e); + } + }); + BLOSUM62Colour.setLabel("BLOSUM62 Score"); + BLOSUM62Colour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + BLOSUM62Colour_actionPerformed(e); + } + }); + avDistanceTreeBlosumMenuItem.setLabel("Average Distance using BLOSUM62..."); + avDistanceTreeBlosumMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + avTreeBlosumMenuItem_actionPerformed(e); + } + }); + njTreeBlosumMenuItem.setLabel("Neighbour Joining using BLOSUM62..."); + njTreeBlosumMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + njTreeBlosumMenuItem_actionPerformed(e); + } + }); + annotationPanelMenuItem.setActionCommand(""); + annotationPanelMenuItem.setState(true); + annotationPanelMenuItem.setLabel("Show Annotations"); + annotationPanelMenuItem.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + annotationPanelMenuItem_actionPerformed(null); + } + }); + colourTextMenuItem.setLabel("Colour Text"); + colourTextMenuItem.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + colourTextMenuItem_actionPerformed(null); + } + }); + overviewMenuItem.setLabel("Overview Window..."); + overviewMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + overviewMenuItem_actionPerformed(e); + } + }); + undoMenuItem.setEnabled(false); + undoMenuItem.setLabel("Undo"); + undoMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + undoMenuItem_actionPerformed(e); + } + }); + redoMenuItem.setEnabled(false); + redoMenuItem.setLabel("Redo"); + redoMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + redoMenuItem_actionPerformed(e); + } + }); + conservationMenuItem.setLabel("By Conservation"); + conservationMenuItem.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + conservationMenuItem_actionPerformed(null); + } + }); + noColourmenuItem.setLabel("None"); + noColourmenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + noColourmenuItem_actionPerformed(e); + } + }); + wrapMenuItem.setLabel("Wrap"); + wrapMenuItem.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + wrapMenuItem_actionPerformed(null); + } + }); + renderGapsMenuItem.setLabel("Show Gaps"); + renderGapsMenuItem.setState(true); + renderGapsMenuItem.addItemListener(new java.awt.event.ItemListener() + { + + public void itemStateChanged(ItemEvent e) + { + + renderGapsMenuItem_actionPerformed(null); + } + }); + findMenuItem.setLabel("Find..."); + findMenuItem.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + findMenuItem_actionPerformed(e); + } + }); + searchMenu.setLabel("Search"); + + abovePIDThreshold.setLabel("Above Identity threshold"); + abovePIDThreshold.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + abovePIDThreshold_actionPerformed(null); + } + }); + nucleotideColour.setLabel("Nucleotide"); + nucleotideColour.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + nucleotideColour_actionPerformed(e); + } + }); + deleteGroups.setLabel("Undefine groups"); + deleteGroups.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + deleteGroups_actionPerformed(e); + } + }); + copy.setLabel("Copy"); + copy.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + copy_actionPerformed(e); + } + }); + cut.setLabel("Cut"); + cut.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + cut_actionPerformed(e); + } + }); + delete.setLabel("Delete"); + delete.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + delete_actionPerformed(e); + } + }); + Menu1.setLabel("Paste"); + pasteNew.setLabel("to new alignment"); + pasteNew.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + pasteNew_actionPerformed(e); + } + }); + pasteThis.setLabel("add to this alignment"); + pasteThis.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + pasteThis_actionPerformed(e); + } + }); + applyToAllGroups.setLabel("Apply Colour To All Groups"); + applyToAllGroups.setState(true); + applyToAllGroups.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + applyToAllGroups_actionPerformed(null); + } + }); + font.setLabel("Font..."); + font.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + font_actionPerformed(e); + } + }); + fullSeqId.setLabel("Show Full Sequence ID"); + fullSeqId.setState(true); + fullSeqId.addItemListener(new java.awt.event.ItemListener() + { + + public void itemStateChanged(ItemEvent e) + { + fullSeqId_actionPerformed(null); + } + }); + scaleAbove.setLabel("Scale Above"); + scaleAbove.setState(true); + scaleAbove.addItemListener(new java.awt.event.ItemListener() + { + + public void itemStateChanged(ItemEvent e) + { + + scaleAbove_actionPerformed(null); + } + }); + scaleLeft.setEnabled(false); + scaleLeft.setState(true); + scaleLeft.setLabel("Scale Left"); + scaleLeft.addItemListener(new java.awt.event.ItemListener() + { + + public void itemStateChanged(ItemEvent e) + { + + scaleLeft_actionPerformed(null); + } + }); + scaleRight.setEnabled(false); + scaleRight.setState(true); + scaleRight.setLabel("Scale Right"); + scaleRight.addItemListener(new java.awt.event.ItemListener() + { + + public void itemStateChanged(ItemEvent e) + { + + scaleRight_actionPerformed(null); + } + }); + modifyPID.setLabel("Modify Identity Threshold..."); + modifyPID.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + modifyPID_actionPerformed(e); + } + }); + modifyConservation.setLabel("Modify Conservation Threshold..."); + modifyConservation.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + modifyConservation_actionPerformed(e); + } + }); + sortByTreeMenu.setLabel("Tree Order"); + sort.setLabel("Sort"); + calculate.setLabel("Calculate Tree"); + inputText.setLabel("Input from textbox"); + inputText.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + inputText_actionPerformed(e); + } + }); + + helpMenu.setLabel("Help"); + documentation.setLabel("Documentation"); + documentation.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + documentation_actionPerformed(e); + } + }); + + about.setLabel("About..."); + about.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + about_actionPerformed(e); + } + }); + + alignFrameMenuBar.add(fileMenu); + alignFrameMenuBar.add(editMenu); + alignFrameMenuBar.add(searchMenu); + alignFrameMenuBar.add(viewMenu); + alignFrameMenuBar.add(colourMenu); + alignFrameMenuBar.add(calculateMenu); + alignFrameMenuBar.add(helpMenu); + fileMenu.add(inputText); + fileMenu.add(outputTextboxMenu); + fileMenu.addSeparator(); + fileMenu.add(closeMenuItem); + editMenu.add(undoMenuItem); + editMenu.add(redoMenuItem); + editMenu.add(cut); + editMenu.add(copy); + editMenu.add(Menu1); + editMenu.add(delete); + editMenu.add(selectAllSequenceMenuItem); + editMenu.add(deselectAllSequenceMenuItem); + editMenu.add(invertSequenceMenuItem); + editMenu.add(deleteGroups); + editMenu.addSeparator(); + editMenu.add(remove2LeftMenuItem); + editMenu.add(remove2RightMenuItem); + editMenu.add(removeGappedColumnMenuItem); + editMenu.add(removeAllGapsMenuItem); + editMenu.add(removeRedundancyMenuItem); + searchMenu.add(findMenuItem); + viewMenu.add(font); + viewMenu.add(fullSeqId); + viewMenu.addSeparator(); + viewMenu.add(wrapMenuItem); + viewMenu.add(scaleAbove); + viewMenu.add(scaleLeft); + viewMenu.add(scaleRight); + viewMenu.addSeparator(); + viewMenu.add(viewBoxesMenuItem); + viewMenu.add(viewTextMenuItem); + viewMenu.add(colourTextMenuItem); + viewMenu.add(renderGapsMenuItem); + viewMenu.add(annotationPanelMenuItem); + viewMenu.addSeparator(); + viewMenu.add(overviewMenuItem); + colourMenu.add(applyToAllGroups); + colourMenu.add(noColourmenuItem); + colourMenu.addSeparator(); + colourMenu.add(clustalColour); + colourMenu.add(BLOSUM62Colour); + colourMenu.add(PIDColour); + colourMenu.add(zappoColour); + colourMenu.add(taylorColour); + colourMenu.add(hydrophobicityColour); + colourMenu.add(helixColour); + colourMenu.add(strandColour); + colourMenu.add(turnColour); + colourMenu.add(buriedColour); + colourMenu.add(nucleotideColour); + colourMenu.add(userDefinedColour); + colourMenu.addSeparator(); + colourMenu.add(conservationMenuItem); + colourMenu.add(modifyConservation); + colourMenu.add(abovePIDThreshold); + colourMenu.add(modifyPID); + calculateMenu.add(sort); + calculateMenu.add(calculate); + calculateMenu.addSeparator(); + calculateMenu.add(pairwiseAlignmentMenuItem); + calculateMenu.add(PCAMenuItem); + this.add(statusBar, BorderLayout.SOUTH); + Menu1.add(pasteNew); + Menu1.add(pasteThis); + sort.add(sortIDMenuItem); + sort.add(sortGroupMenuItem); + sort.add(sortByTreeMenu); + sort.add(sortPairwiseMenuItem); + calculate.add(averageDistanceTreeMenuItem); + calculate.add(neighbourTreeMenuItem); + calculate.add(avDistanceTreeBlosumMenuItem); + calculate.add(njTreeBlosumMenuItem); + helpMenu.add(documentation); + helpMenu.add(about); + } + + protected void saveAs_actionPerformed(ActionEvent e) + { + + } + + protected void outputText_actionPerformed(ActionEvent e) + { + + } + + protected void htmlMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void closeMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void redoMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void undoMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void selectAllSequenceMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void deselectAllSequenceMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void invertSequenceMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void remove2LeftMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void remove2RightMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void removeGappedColumnMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void removeAllGapsMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void wrapMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void viewBoxesMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void viewTextMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void colourTextMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void annotationPanelMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void overviewMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void sortPairwiseMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void sortIDMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void sortGroupMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void removeRedundancyMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void pairwiseAlignmentMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void PCAMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void averageDistanceTreeMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void neighbourTreeMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void njTreeBlosumMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void avTreeBlosumMenuItem_actionPerformed(ActionEvent e) + { + + } + + + + protected void clustalAlignMenuItem_actionPerformed(ActionEvent e) + { + + } + + + + + protected void clustalColour_actionPerformed(ActionEvent e) + { + + } + + protected void zappoColour_actionPerformed(ActionEvent e) + { + + } + + protected void taylorColour_actionPerformed(ActionEvent e) + { + + } + + + protected void hydrophobicityColour_actionPerformed(ActionEvent e) + { + + } + + protected void helixColour_actionPerformed(ActionEvent e) + { + + } + + protected void strandColour_actionPerformed(ActionEvent e) + { + + } + + protected void turnColour_actionPerformed(ActionEvent e) + { + + } + + protected void buriedColour_actionPerformed(ActionEvent e) + { + + } + + + + protected void userDefinedColour_actionPerformed(ActionEvent e) + { + + } + + protected void PIDColour_actionPerformed(ActionEvent e) + { + + } + + protected void BLOSUM62Colour_actionPerformed(ActionEvent e) + { + + } + + + protected void noColourmenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void conservationMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void printMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void renderGapsMenuItem_actionPerformed(ActionEvent e) + { + + } + + protected void findMenuItem_actionPerformed(ActionEvent e) + { + + } + + + protected void abovePIDThreshold_actionPerformed(ActionEvent e) { + + } + + public void sequenceFeatures_actionPerformed(ActionEvent actionEvent) + { + + } + + protected void nucleotideColour_actionPerformed(ActionEvent e) + { + + } + + protected void deleteGroups_actionPerformed(ActionEvent e) + { + + } + + protected void copy_actionPerformed(ActionEvent e) + { + + } + + + protected void cut_actionPerformed(ActionEvent e) + { + + } + + protected void delete_actionPerformed(ActionEvent e) + { + + } + + protected void pasteNew_actionPerformed(ActionEvent e) + { + + } + + protected void pasteThis_actionPerformed(ActionEvent e) + { + + } + + protected void applyToAllGroups_actionPerformed(ActionEvent e) + { + + } + + protected void createPNG_actionPerformed(ActionEvent e) + { + + } + + protected void font_actionPerformed(ActionEvent e) + { + + } + + protected void fullSeqId_actionPerformed(ActionEvent e) + { + + } + + protected void epsFile_actionPerformed(ActionEvent e) + { + + } + + protected void LoadtreeMenuItem_actionPerformed(ActionEvent e) { + + } + + protected void jpred_actionPerformed(ActionEvent e) + { + + } + + protected void scaleAbove_actionPerformed(ActionEvent e) + { + + } + + protected void scaleLeft_actionPerformed(ActionEvent e) + { + + } + + protected void scaleRight_actionPerformed(ActionEvent e) + { + + } + + protected void modifyPID_actionPerformed(ActionEvent e) + { + + } + + protected void modifyConservation_actionPerformed(ActionEvent e) + { + + } + + protected void preferences_actionPerformed(ActionEvent e) + { + + } + + protected void msaAlignMenuItem_actionPerformed(ActionEvent e) { + + } + + protected void inputText_actionPerformed(ActionEvent e) { + + } + + protected void documentation_actionPerformed(ActionEvent e) { + + } + + protected void about_actionPerformed(ActionEvent e) { + + } + + +} + diff --git a/src/jalview/jbappletgui/GAlignmentPanel.java b/src/jalview/jbappletgui/GAlignmentPanel.java new file mode 100755 index 0000000..6a3ed74 --- /dev/null +++ b/src/jalview/jbappletgui/GAlignmentPanel.java @@ -0,0 +1,87 @@ +/******************** + * 2004 Jalview Reengineered + * Barton Group + * Dundee University + * + * AM Waterhouse + *******************/ + +package jalview.jbappletgui; + +import java.awt.*; + +public class GAlignmentPanel extends Panel +{ + protected Panel sequenceHolderPanel = new Panel(); + protected Scrollbar vscroll = new Scrollbar(); + protected Scrollbar hscroll = new Scrollbar(); + protected Panel seqPanelHolder = new Panel(); + BorderLayout borderLayout1 = new BorderLayout(); + BorderLayout borderLayout3 = new BorderLayout(); + protected Panel scalePanelHolder = new Panel(); + protected Panel idPanelHolder = new Panel(); + BorderLayout borderLayout5 = new BorderLayout(); + protected Panel idSpaceFillerPanel1 = new Panel(); + public Panel annotationSpaceFillerHolder = new Panel(); + BorderLayout borderLayout6 = new BorderLayout(); + BorderLayout borderLayout7 = new BorderLayout(); + Panel hscrollHolder = new Panel(); + BorderLayout borderLayout10 = new BorderLayout(); + protected Panel hscrollFillerPanel = new Panel(); + BorderLayout borderLayout11 = new BorderLayout(); + public ScrollPane annotationScroller = new ScrollPane( ScrollPane.SCROLLBARS_NEVER ); + BorderLayout borderLayout4 = new BorderLayout(); + + public GAlignmentPanel() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + } + private void jbInit() throws Exception + { + // idPanelHolder.setPreferredSize(new Dimension(70, 10)); + this.setLayout(borderLayout7); + // sequenceHolderPanel.setPreferredSize(new Dimension(150, 150)); + sequenceHolderPanel.setLayout(borderLayout3); + seqPanelHolder.setLayout(borderLayout1); + scalePanelHolder.setBackground(Color.white); + // scalePanelHolder.setPreferredSize(new Dimension(10, 30)); + scalePanelHolder.setLayout(borderLayout6); + idPanelHolder.setLayout(borderLayout5); + idSpaceFillerPanel1.setBackground(Color.white); + // idSpaceFillerPanel1.setPreferredSize(new Dimension(10, 30)); + idSpaceFillerPanel1.setLayout(borderLayout11); + annotationSpaceFillerHolder.setBackground(Color.white); + // annotationSpaceFillerHolder.setPreferredSize(new Dimension(10, 80)); + annotationSpaceFillerHolder.setLayout(borderLayout4); + hscroll.setOrientation(Scrollbar.HORIZONTAL); + hscrollHolder.setLayout(borderLayout10); + hscrollFillerPanel.setBackground(Color.white); + // hscrollFillerPanel.setPreferredSize(new Dimension(70, 10)); + hscrollHolder.setBackground(Color.white); + // annotationScroller.setPreferredSize(new Dimension(10, 80)); + // this.setPreferredSize(new Dimension(220, 166)); + seqPanelHolder.setBackground(Color.white); + idPanelHolder.setBackground(Color.white); + sequenceHolderPanel.add(scalePanelHolder, BorderLayout.NORTH); + sequenceHolderPanel.add(seqPanelHolder, BorderLayout.CENTER); + seqPanelHolder.add(vscroll, BorderLayout.EAST); + sequenceHolderPanel.add(annotationScroller, BorderLayout.SOUTH); + // Panel3.add(secondaryPanelHolder, BorderLayout.SOUTH); + this.add(idPanelHolder, BorderLayout.WEST); + idPanelHolder.add(idSpaceFillerPanel1, BorderLayout.NORTH); + idPanelHolder.add(annotationSpaceFillerHolder, BorderLayout.SOUTH); + this.add(hscrollHolder, BorderLayout.SOUTH); + hscrollHolder.add(hscroll, BorderLayout.CENTER); + hscrollHolder.add(hscrollFillerPanel, BorderLayout.WEST); + this.add(sequenceHolderPanel, BorderLayout.CENTER); + } + + +} diff --git a/src/jalview/jbappletgui/GCutAndPasteTransfer.java b/src/jalview/jbappletgui/GCutAndPasteTransfer.java new file mode 100755 index 0000000..94aea3f --- /dev/null +++ b/src/jalview/jbappletgui/GCutAndPasteTransfer.java @@ -0,0 +1,85 @@ +/******************** + * 2004 Jalview Reengineered + * Barton Group + * Dundee University + * + * AM Waterhouse + *******************/ + +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + + +public class GCutAndPasteTransfer extends Panel +{ + protected TextArea textarea = new TextArea(); + protected ScrollPane scrollPane = new ScrollPane(); + Button ok = new Button(); + Button cancel = new Button(); + protected Panel buttonPanel = new Panel(); + BorderLayout borderLayout1 = new BorderLayout(); + public GCutAndPasteTransfer() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + + } + private void jbInit() throws Exception + { + textarea.setFont(new java.awt.Font("Verdana", 0, 12)); + textarea.setText("Paste your alignment file here"); + textarea.addMouseListener(new java.awt.event.MouseAdapter() + { + public void mousePressed(MouseEvent e) + { + textarea_mousePressed(e); + } + }); + this.setLayout(borderLayout1); + ok.setLabel("OK"); + ok.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(ActionEvent e) { + ok_actionPerformed(e); + } + }); + cancel.setLabel("Cancel"); + cancel.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(ActionEvent e) { + cancel_actionPerformed(e); + } + }); + scrollPane.setVisible(true); + this.add(scrollPane, BorderLayout.CENTER); + this.add(buttonPanel, BorderLayout.SOUTH); + buttonPanel.add(ok, null); + buttonPanel.add(cancel, null); + scrollPane.add(textarea, null); + + } + + + + + void textarea_mousePressed(MouseEvent e) + { + if(textarea.getText().equals("Paste your alignment file here")) + textarea.setText(""); + } + + protected void ok_actionPerformed(ActionEvent e) { + + } + + protected void cancel_actionPerformed(ActionEvent e) { + + } + +} diff --git a/src/jalview/jbappletgui/GFinder.java b/src/jalview/jbappletgui/GFinder.java new file mode 100755 index 0000000..5a1afbe --- /dev/null +++ b/src/jalview/jbappletgui/GFinder.java @@ -0,0 +1,119 @@ +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + + +public class GFinder extends Panel +{ + Label jLabel1 = new Label(); + protected TextField textfield = new TextField(); + protected Button findAll = new Button(); + protected Button findNext = new Button(); + Panel jPanel1 = new Panel(); + GridLayout gridLayout1 = new GridLayout(); + protected Button createNewGroup = new Button(); + + public GFinder() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + } + private void jbInit() throws Exception + { + jLabel1.setFont(new java.awt.Font("Verdana", 0, 12)); + jLabel1.setText("Find"); + jLabel1.setBounds(new Rectangle(3, 30, 34, 15)); + this.setLayout(null); + textfield.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10)); + textfield.setText(""); + textfield.setBounds(new Rectangle(40, 27, 133, 21)); + textfield.addKeyListener(new java.awt.event.KeyAdapter() + { + public void keyTyped(KeyEvent e) + { + textfield_keyTyped(e); + } + }); + textfield.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + textfield_actionPerformed(e); + } + }); + findAll.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10)); + findAll.setLabel("Find all"); + findAll.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + findAll_actionPerformed(e); + } + }); + findNext.setEnabled(false); + findNext.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10)); + findNext.setLabel("Find Next"); + findNext.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + findNext_actionPerformed(e); + } + }); + jPanel1.setBounds(new Rectangle(180, 5, 141, 64)); + jPanel1.setLayout(gridLayout1); + gridLayout1.setHgap(0); + gridLayout1.setRows(3); + gridLayout1.setVgap(2); + createNewGroup.setEnabled(false); + createNewGroup.setFont(new java.awt.Font("Verdana", Font.PLAIN, 10)); + createNewGroup.setLabel("Create new group"); + createNewGroup.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + createNewGroup_actionPerformed(e); + } + }); + jPanel1.add(findNext, null); + jPanel1.add(findAll, null); + jPanel1.add(createNewGroup, null); + this.add(textfield, null); + this.add(jLabel1, null); + this.add(jPanel1, null); + } + + protected void findNext_actionPerformed(ActionEvent e) + { + + } + + protected void findAll_actionPerformed(ActionEvent e) + { + + } + + + protected void textfield_actionPerformed(ActionEvent e) + { + + } + + void textfield_keyTyped(KeyEvent e) + { + findNext.setEnabled(true); + } + + public void createNewGroup_actionPerformed(ActionEvent e) + { + + } + +} diff --git a/src/jalview/jbappletgui/GFontChooser.java b/src/jalview/jbappletgui/GFontChooser.java new file mode 100755 index 0000000..d83ed0d --- /dev/null +++ b/src/jalview/jbappletgui/GFontChooser.java @@ -0,0 +1,142 @@ +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + + +public class GFontChooser extends Panel +{ + Label label1 = new Label(); + protected Choice fontSize = new Choice(); + protected Choice fontStyle = new Choice(); + Label label2 = new Label(); + Label label3 = new Label(); + protected Choice fontName = new Choice(); + Button ok = new Button(); + Button cancel = new Button(); + Panel panel1 = new Panel(); + Panel panel2 = new Panel(); + Panel panel3 = new Panel(); + BorderLayout borderLayout1 = new BorderLayout(); + BorderLayout borderLayout2 = new BorderLayout(); + BorderLayout borderLayout3 = new BorderLayout(); + Panel panel4 = new Panel(); + Panel panel5 = new Panel(); + BorderLayout borderLayout4 = new BorderLayout(); + + public GFontChooser() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + } + private void jbInit() throws Exception + { + label1.setFont(new java.awt.Font("Verdana", 0, 11)); + label1.setAlignment(Label.RIGHT); + label1.setText("Font: "); + this.setLayout(borderLayout4); + fontSize.setFont(new java.awt.Font("Verdana", 0, 11)); + fontSize.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + fontSize_actionPerformed(); + } + }); + fontStyle.setFont(new java.awt.Font("Verdana", 0, 11)); + fontStyle.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + fontStyle_actionPerformed(); + } + }); + label2.setAlignment(Label.RIGHT); + label2.setFont(new java.awt.Font("Verdana", 0, 11)); + label2.setText("Size: "); + label3.setAlignment(Label.RIGHT); + label3.setFont(new java.awt.Font("Verdana", 0, 11)); + label3.setText("Style: "); + fontName.setFont(new java.awt.Font("Verdana", 0, 11)); + fontName.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + fontName_actionPerformed(); + } + }); + ok.setFont(new java.awt.Font("Verdana", 0, 11)); + ok.setLabel("OK"); + ok.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + ok_actionPerformed(); + } + }); + cancel.setFont(new java.awt.Font("Verdana", 0, 11)); + cancel.setLabel("Cancel"); + cancel.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + cancel_actionPerformed(); + } + }); + this.setBackground(Color.white); + panel1.setLayout(borderLayout1); + panel2.setLayout(borderLayout3); + panel3.setLayout(borderLayout2); + panel5.setBackground(Color.white); + panel4.setBackground(Color.white); + panel1.setBackground(Color.white); + panel2.setBackground(Color.white); + panel3.setBackground(Color.white); + panel1.add(label1, BorderLayout.WEST); + panel1.add(fontName, BorderLayout.CENTER); + panel5.add(panel1, null); + panel5.add(panel3, null); + panel5.add(panel2, null); + panel2.add(label3, BorderLayout.WEST); + panel2.add(fontStyle, BorderLayout.CENTER); + panel3.add(label2, BorderLayout.WEST); + panel3.add(fontSize, BorderLayout.CENTER); + this.add(panel4, BorderLayout.SOUTH); + panel4.add(ok, null); + panel4.add(cancel, null); + this.add(panel5, BorderLayout.CENTER); + + } + + protected void ok_actionPerformed() + { + + } + + protected void cancel_actionPerformed() + { + + } + + protected void fontName_actionPerformed() + { + + } + + protected void fontSize_actionPerformed() + { + + } + + protected void fontStyle_actionPerformed() + { + + } + +} diff --git a/src/jalview/jbappletgui/GPCAPanel.java b/src/jalview/jbappletgui/GPCAPanel.java new file mode 100755 index 0000000..ad8a02e --- /dev/null +++ b/src/jalview/jbappletgui/GPCAPanel.java @@ -0,0 +1,95 @@ +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + +public class GPCAPanel extends Panel +{ + Panel jPanel2 = new Panel(); + Label jLabel1 = new Label(); + Label jLabel2 = new Label(); + Label jLabel3 = new Label(); + protected Choice xCombobox = new Choice(); + protected Choice yCombobox = new Choice(); + protected Choice zCombobox = new Choice(); + FlowLayout flowLayout1 = new FlowLayout(); + BorderLayout borderLayout1 = new BorderLayout(); + + public GPCAPanel() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + + for(int i=1; i<8; i++) + { + xCombobox.addItem("dim "+i); + yCombobox.addItem("dim "+i); + zCombobox.addItem("dim "+i); + } + } + private void jbInit() throws Exception + { + this.setLayout(borderLayout1); + jPanel2.setLayout(flowLayout1); + jLabel1.setFont(new java.awt.Font("Verdana", 0, 12)); + jLabel1.setText("x="); + jLabel2.setFont(new java.awt.Font("Verdana", 0, 12)); + jLabel2.setText("y="); + jLabel3.setFont(new java.awt.Font("Verdana", 0, 12)); + jLabel3.setText("z="); + jPanel2.setBackground(Color.white); + zCombobox.setFont(new java.awt.Font("Verdana", 0, 12)); + zCombobox.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + zCombobox_actionPerformed(null); + } + }); + yCombobox.setFont(new java.awt.Font("Verdana", 0, 12)); + yCombobox.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + yCombobox_actionPerformed(null); + } + }); + xCombobox.setFont(new java.awt.Font("Verdana", 0, 12)); + xCombobox.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + xCombobox_actionPerformed(null); + } + }); + this.add(jPanel2, BorderLayout.SOUTH); + jPanel2.add(jLabel1, null); + jPanel2.add(xCombobox, null); + jPanel2.add(jLabel2, null); + jPanel2.add(yCombobox, null); + jPanel2.add(jLabel3, null); + jPanel2.add(zCombobox, null); + } + + protected void xCombobox_actionPerformed(ActionEvent e) + { + + } + + protected void yCombobox_actionPerformed(ActionEvent e) + { + + } + + protected void zCombobox_actionPerformed(ActionEvent e) + { + + } + +} diff --git a/src/jalview/jbappletgui/GPairwiseAlignPanel.java b/src/jalview/jbappletgui/GPairwiseAlignPanel.java new file mode 100755 index 0000000..ecf3c8d --- /dev/null +++ b/src/jalview/jbappletgui/GPairwiseAlignPanel.java @@ -0,0 +1,51 @@ +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + + +public class GPairwiseAlignPanel extends Panel +{ + protected ScrollPane scrollPane = new ScrollPane(); + protected TextArea textarea = new TextArea(); + protected Button viewInEditorButton = new Button(); + Panel jPanel1 = new Panel(); + BorderLayout borderLayout1 = new BorderLayout(); + + public GPairwiseAlignPanel() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + } + private void jbInit() throws Exception + { + this.setLayout(borderLayout1); + textarea.setFont(new java.awt.Font("Monospaced", 0, 12)); + textarea.setText(""); + viewInEditorButton.setFont(new java.awt.Font("Verdana", 0, 12)); + viewInEditorButton.setLabel("View in alignment editor"); + viewInEditorButton.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + viewInEditorButton_actionPerformed(e); + } + }); + this.add(scrollPane, BorderLayout.CENTER); + scrollPane.add(textarea); + this.add(jPanel1, BorderLayout.SOUTH); + jPanel1.add(viewInEditorButton, null); + } + + protected void viewInEditorButton_actionPerformed(ActionEvent e) + { + + } + +} diff --git a/src/jalview/jbappletgui/GSliderPanel.java b/src/jalview/jbappletgui/GSliderPanel.java new file mode 100755 index 0000000..8f7613a --- /dev/null +++ b/src/jalview/jbappletgui/GSliderPanel.java @@ -0,0 +1,117 @@ +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + +public class GSliderPanel extends Panel +{ + // this is used for conservation colours, PID colours and redundancy threshold + protected Scrollbar slider = new Scrollbar(); + protected TextField valueField = new TextField(); + protected Label label = new Label(); + Panel jPanel1 = new Panel(); + Panel jPanel2 = new Panel(); + protected Button applyButton = new Button(); + protected Button undoButton = new Button(); + FlowLayout flowLayout1 = new FlowLayout(); + protected Checkbox allGroupsCheck = new Checkbox(); + BorderLayout borderLayout1 = new BorderLayout(); + BorderLayout borderLayout2 = new BorderLayout(); + FlowLayout flowLayout2 = new FlowLayout(); + + public GSliderPanel() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + } + private void jbInit() throws Exception + { + this.setLayout(borderLayout2); + // slider.setMajorTickSpacing(10); + // slider.setMinorTickSpacing(1); + // slider.setPaintTicks(true); + slider.setBackground(Color.white); + slider.setFont(new java.awt.Font("Verdana", 0, 11)); + slider.setOrientation(0); + valueField.setFont(new java.awt.Font("Verdana", 0, 11)); + valueField.setText(" "); + valueField.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + valueField_actionPerformed(e); + } + }); + label.setFont(new java.awt.Font("Verdana", 0, 11)); + label.setText("set this label text"); + jPanel1.setLayout(borderLayout1); + jPanel2.setLayout(flowLayout1); + applyButton.setFont(new java.awt.Font("Verdana", 0, 11)); + applyButton.setLabel("Apply"); + applyButton.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + applyButton_actionPerformed(e); + } + }); + undoButton.setEnabled(false); + undoButton.setFont(new java.awt.Font("Verdana", 0, 11)); + undoButton.setLabel("Undo"); + undoButton.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + undoButton_actionPerformed(e); + } + }); + allGroupsCheck.setEnabled(false); + allGroupsCheck.setFont(new java.awt.Font("Verdana", 0, 11)); + allGroupsCheck.setLabel("Apply threshold to all groups"); + allGroupsCheck.setName("Apply to all Groups"); + allGroupsCheck.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + allGroupsCheck_actionPerformed(); + } + }); + this.setBackground(Color.white); + this.setForeground(Color.black); + jPanel2.add(label, null); + jPanel2.add(applyButton, null); + jPanel2.add(undoButton, null); + jPanel2.add(allGroupsCheck); + jPanel1.add(valueField, java.awt.BorderLayout.EAST); + jPanel1.add(slider, java.awt.BorderLayout.CENTER); + this.add(jPanel1, java.awt.BorderLayout.SOUTH); + this.add(jPanel2, java.awt.BorderLayout.CENTER); + } + + protected void valueField_actionPerformed(ActionEvent e) + { + + } + + protected void applyButton_actionPerformed(ActionEvent e) + { + + } + + protected void undoButton_actionPerformed(ActionEvent e) + { + + } + + protected void allGroupsCheck_actionPerformed() + { + + } + +} diff --git a/src/jalview/jbappletgui/GTreePanel.java b/src/jalview/jbappletgui/GTreePanel.java new file mode 100755 index 0000000..e0b56b2 --- /dev/null +++ b/src/jalview/jbappletgui/GTreePanel.java @@ -0,0 +1,108 @@ +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + +public class GTreePanel extends Frame +{ + BorderLayout borderLayout1 = new BorderLayout(); + protected ScrollPane scrollPane = new ScrollPane(); + MenuBar jMenuBar1 = new MenuBar(); + Menu jMenu2 = new Menu(); + protected MenuItem fontSize = new MenuItem(); + protected CheckboxMenuItem bootstrapMenu = new CheckboxMenuItem(); + protected CheckboxMenuItem distanceMenu = new CheckboxMenuItem(); + protected CheckboxMenuItem fitToWindow = new CheckboxMenuItem(); + + public GTreePanel() + { + try + { + jbInit(); + this.setMenuBar(jMenuBar1); + } + catch(Exception e) + { + e.printStackTrace(); + } + + } + private void jbInit() throws Exception + { + setLayout(borderLayout1); + this.setBackground(Color.white); + this.setFont(new java.awt.Font("Verdana", 0, 12)); + jMenu2.setLabel("View"); + fontSize.setLabel("Font Size - 12"); + fontSize.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + fontSize_actionPerformed(e); + } + }); + bootstrapMenu.setLabel("Show Bootstrap values"); + bootstrapMenu.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + bootstrapMenu_actionPerformed(null); + } + }); + distanceMenu.setLabel("Show Distances"); + distanceMenu.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + distanceMenu_actionPerformed(null); + } + }); + fitToWindow.setState(true); + fitToWindow.setLabel("Fit to window"); + fitToWindow.addItemListener(new java.awt.event.ItemListener() + { + public void itemStateChanged(ItemEvent e) + { + fitToWindow_actionPerformed(null); + } + }); + add(scrollPane, BorderLayout.CENTER); + jMenuBar1.add(jMenu2); + jMenu2.add(fitToWindow); + jMenu2.add(fontSize); + jMenu2.add(distanceMenu); + jMenu2.add(bootstrapMenu); + } + + protected void saveMenu_actionPerformed(ActionEvent e) + { + + } + + protected void printMenu_actionPerformed(ActionEvent e) + { + + } + + protected void fontSize_actionPerformed(ActionEvent e) + { + + } + + protected void distanceMenu_actionPerformed(ActionEvent e) + { + + } + + protected void bootstrapMenu_actionPerformed(ActionEvent e) + { + + } + + protected void fitToWindow_actionPerformed(ActionEvent e) + { + + } + + +} diff --git a/src/jalview/jbappletgui/GUserDefinedColours.java b/src/jalview/jbappletgui/GUserDefinedColours.java new file mode 100755 index 0000000..47170b2 --- /dev/null +++ b/src/jalview/jbappletgui/GUserDefinedColours.java @@ -0,0 +1,201 @@ +package jalview.jbappletgui; + +import java.awt.*; +import java.awt.event.*; + + +public class GUserDefinedColours extends Panel +{ + protected Panel buttonPanel = new Panel(); + protected GridLayout gridLayout = new GridLayout(); + Panel jPanel2 = new Panel(); + protected Button okButton = new Button(); + protected Button applyButton = new Button(); + protected Button cancelButton = new Button(); + protected Scrollbar rScroller = new Scrollbar(); + Label label1 = new Label(); + Panel panel2 = new Panel(); + BorderLayout borderLayout1 = new BorderLayout(); + protected TextField rText = new TextField(); + Panel panel3 = new Panel(); + Label label4 = new Label(); + protected Scrollbar gScroller = new Scrollbar(); + protected TextField gText = new TextField(); + BorderLayout borderLayout2 = new BorderLayout(); + Panel panel4 = new Panel(); + Label label5 = new Label(); + protected Scrollbar bScroller = new Scrollbar(); + protected TextField bText = new TextField(); + BorderLayout borderLayout3 = new BorderLayout(); + protected Panel target = new Panel(); + + public GUserDefinedColours() + { + try + { + jbInit(); + } + catch(Exception e) + { + e.printStackTrace(); + } + } + private void jbInit() throws Exception + { + this.setLayout(null); + buttonPanel.setLayout(gridLayout); + gridLayout.setColumns(6); + gridLayout.setRows(4); + okButton.setFont(new java.awt.Font("Verdana", 0, 11)); + okButton.setLabel("OK"); + okButton.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + okButton_actionPerformed(e); + } + }); + applyButton.setFont(new java.awt.Font("Verdana", 0, 11)); + applyButton.setLabel("Apply"); + applyButton.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + applyButton_actionPerformed(e); + } + }); + cancelButton.setFont(new java.awt.Font("Verdana", 0, 11)); + cancelButton.setLabel("Cancel"); + cancelButton.addActionListener(new java.awt.event.ActionListener() + { + public void actionPerformed(ActionEvent e) + { + cancelButton_actionPerformed(e); + } + }); + this.setBackground(new Color(212, 208, 223)); + jPanel2.setBounds(new Rectangle(0, 265, 400, 35)); + buttonPanel.setBounds(new Rectangle(0, 123, 400, 142)); + rScroller.setMaximum(255); + rScroller.setMinimum(0); + rScroller.setOrientation(0); + rScroller.setUnitIncrement(1); + rScroller.addAdjustmentListener(new java.awt.event.AdjustmentListener() { + public void adjustmentValueChanged(AdjustmentEvent e) { + rScroller_adjustmentValueChanged(e); + } + }); + label1.setText("R"); + panel2.setBounds(new Rectangle(20, 29, 180, 19)); + panel2.setLayout(borderLayout1); + rText.setText(" 0"); + rText.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(ActionEvent e) { + rText_actionPerformed(e); + } + }); + panel3.setLayout(borderLayout2); + label4.setText("G"); + gScroller.setMaximum(255); + gScroller.setMinimum(0); + gScroller.setOrientation(0); + gScroller.setUnitIncrement(1); + gScroller.addAdjustmentListener(new java.awt.event.AdjustmentListener() { + public void adjustmentValueChanged(AdjustmentEvent e) { + gScroller_adjustmentValueChanged(e); + } + }); + gText.setText(" 0"); + gText.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(ActionEvent e) { + gText_actionPerformed(e); + } + }); + panel3.setBounds(new Rectangle(19, 54, 181, 20)); + panel4.setLayout(borderLayout3); + label5.setText("B"); + bScroller.setMaximum(255); + bScroller.setMinimum(0); + bScroller.setOrientation(0); + bScroller.setUnitIncrement(1); + bScroller.addAdjustmentListener(new java.awt.event.AdjustmentListener() { + public void adjustmentValueChanged(AdjustmentEvent e) { + bScroller_adjustmentValueChanged(e); + } + }); + bText.setSelectionStart(6); + bText.setText(" 0"); + bText.addActionListener(new java.awt.event.ActionListener() { + public void actionPerformed(ActionEvent e) { + bText_actionPerformed(e); + } + }); + panel4.setBounds(new Rectangle(19, 87, 180, 20)); + target.setBackground(Color.black); + target.setBounds(new Rectangle(229, 26, 134, 79)); + this.add(jPanel2, null); + jPanel2.add(okButton, null); + jPanel2.add(applyButton, null); + jPanel2.add(cancelButton, null); + this.add(buttonPanel, null); + panel2.add(label1, BorderLayout.WEST); + panel2.add(rScroller, BorderLayout.CENTER); + panel2.add(rText, BorderLayout.EAST); + this.add(target, null); + this.add(panel4, null); + panel3.add(label4, BorderLayout.WEST); + panel3.add(gScroller, BorderLayout.CENTER); + panel3.add(gText, BorderLayout.EAST); + this.add(panel2, null); + panel4.add(label5, BorderLayout.WEST); + panel4.add(bScroller, BorderLayout.CENTER); + panel4.add(bText, BorderLayout.EAST); + this.add(panel3, null); + } + + + protected void okButton_actionPerformed(ActionEvent e) + { + + } + + protected void applyButton_actionPerformed(ActionEvent e) + { + + } + + + + protected void cancelButton_actionPerformed(ActionEvent e) + { + + } + + protected void rScroller_adjustmentValueChanged(AdjustmentEvent e) { + + } + + protected void gScroller_adjustmentValueChanged(AdjustmentEvent e) { + + } + + protected void bScroller_adjustmentValueChanged(AdjustmentEvent e) { + + } + + protected void rText_actionPerformed(ActionEvent e) { + + } + + protected void gText_actionPerformed(ActionEvent e) { + + } + + protected void bText_actionPerformed(ActionEvent e) { + + } + + + + +} -- 1.7.10.2