X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FAlignmentPanel.java;h=0cbdfbe3e3fe813a9b4433e4496b14d4e8c3ead8;hb=ac07859006686a2c62bcf57b24742eb610bc46f0;hp=11c9e2b2f9a8494e6d976e0c9af471ca6a37acb9;hpb=49901c2879a03b48fafb84a251e976230459c77f;p=jalview.git

diff --git a/src/jalview/gui/AlignmentPanel.java b/src/jalview/gui/AlignmentPanel.java
index 11c9e2b..0cbdfbe 100755
--- a/src/jalview/gui/AlignmentPanel.java
+++ b/src/jalview/gui/AlignmentPanel.java
@@ -1,71 +1,193 @@
 package jalview.gui;
 
 import jalview.jbgui.GAlignmentPanel;
+import jalview.schemes.*;
+import jalview.analysis.*;
+import jalview.datamodel.*;
 import java.awt.*;
 import java.awt.event.*;
+import java.awt.print.*;
+import java.io.*;
+import java.awt.image.*;
+import org.jibble.epsgraphics.*;
+import javax.imageio.*;
 
-public class AlignmentPanel extends GAlignmentPanel implements AdjustmentListener
+
+
+public class AlignmentPanel extends GAlignmentPanel implements AdjustmentListener, Printable
 {
 
   AlignViewport     av;
   OverviewPanel overviewPanel;
   SeqPanel   seqPanel;
   IdPanel    idPanel;
+  IdwidthAdjuster idwidthAdjuster;
   public AlignFrame alignFrame;
   ScalePanel scalePanel;
-  ScorePanel scorePanel;
+  AnnotationPanel annotationPanel;
+  AnnotationLabels alabels;
 
-  public boolean    groupEdit = false;
+  // this value is set false when selection area being dragged
+  boolean fastPaint = true;
 
-  public AlignmentPanel(AlignFrame af, AlignViewport av)
+  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);
-    scorePanel = new ScorePanel(av);
+
+    scalePanel = new ScalePanel(av, this);
 
     idPanelHolder.add(idPanel, BorderLayout.CENTER);
-    idPanel.addNotify();
+    idwidthAdjuster = new IdwidthAdjuster(this);
+    idSpaceFillerPanel1.add(idwidthAdjuster, BorderLayout.CENTER);
+
+    annotationPanel = new AnnotationPanel(this);
+    alabels = new AnnotationLabels(this);
+
+    annotationSpaceFillerHolder.setPreferredSize(annotationPanel.getPreferredSize());
+    annotationScroller.setPreferredSize(annotationPanel.getPreferredSize());
+    annotationScroller.setViewportView(annotationPanel);
+    annotationSpaceFillerHolder.add(alabels, BorderLayout.CENTER);
+
+    Dimension d = calculateIdWidth();
+    d.setSize( d.width+4, d.height);
+    idPanel.idCanvas.setPreferredSize( d );
+    hscrollFillerPanel.setPreferredSize( d );
+
     scalePanelHolder.add(scalePanel, BorderLayout.CENTER);
-    scorePanelHolder.add(scorePanel, BorderLayout.CENTER);
     seqPanelHolder.add(seqPanel, BorderLayout.CENTER);
-    setScrollValues(0,0);
+
+    javax.swing.SwingUtilities.invokeLater(new Runnable()
+     {
+       public void run()
+       {
+         invalidate();
+         setScrollValues(0,0);
+         Dimension d = calculateIdWidth();
+         d.setSize( d.width+4, d.height);
+         idPanel.idCanvas.setPreferredSize( d );
+         RefreshPanels();
+       }
+    });
+
 
     hscroll.addAdjustmentListener(this);
     vscroll.addAdjustmentListener(this);
-    selectAll(false);
 
     addComponentListener(new ComponentAdapter()
    {
-       public void componentResized(ComponentEvent evt)
+     public void componentResized(ComponentEvent evt)
      {
           RefreshPanels();
      }
    });
 
+   setFocusable(true);
+   addKeyListener(new KeyAdapter()
+   {
+     public void keyPressed(KeyEvent evt)
+     {
+       switch(evt.getKeyCode())
+       {
+         case  27: // escape key
+           av.setSelectionGroup(null);
+           RefreshPanels();
+           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 int countSelected()
+  Dimension calculateIdWidth()
   {
-    return av.getSelection().size();
-  }
-
-  public void selectAll(boolean flag) {
-    int i = 0;
-    if (flag) {
-      while (i < av.getAlignment().getHeight()) {
-        if (! av.getSelection().contains(av.getAlignment().getSequenceAt(i))) {
-          av.getSelection().addElement(av.getAlignment().getSequenceAt(i));
-        }
-        i++;
-      }
-    } else {
-      av.getSelection().clear();
+    Graphics g = this.getGraphics();
+    if(g==null)
+    {
+      javax.swing.JFrame f = new javax.swing.JFrame();
+      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(alabels.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, 12);
   }
 
+
+ 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[0]
+                        || av.getStartRes()>results[1]
+                        || av.getEndRes()<results[2]))
+       setScrollValues(results[1], results[0]);
+
+
+ }
+
+
  public OverviewPanel getOverviewPanel()
  {
    return overviewPanel;
@@ -77,57 +199,145 @@ public class AlignmentPanel extends GAlignmentPanel implements AdjustmentListene
  }
 
 
-  public void setGraphPanelVisible(boolean b)
+  public void setAnnotationVisible(boolean b)
   {
-    scorePanelHolder.setVisible(b);
-    idSpaceFillerPanel.setVisible(b);
-    RefreshPanels();
+    annotationSpaceFillerHolder.setVisible(b);
+    annotationScroller.setVisible(b);
+    javax.swing.SwingUtilities.invokeLater(new Runnable()
+     {
+       public void run()
+       {
+         RefreshPanels();
+       }
+    });
+
   }
 
+
   public void setWrapAlignment(boolean wrap)
   {
-
-      scalePanelHolder.setVisible(!wrap);
-      scorePanelHolder.setVisible(!wrap);
-
-      hscroll.setVisible(!wrap);
-      idSpaceFillerPanel.setVisible(!wrap);
-      idSpaceFillerPanel1.setVisible(!wrap);
+    scalePanelHolder.setVisible(!wrap);
+    hscroll.setVisible(!wrap);
+    idwidthAdjuster.setVisible(!wrap);
+
+    av.setShowAnnotation(!wrap);
+    annotationScroller.setVisible(!wrap);
+    annotationSpaceFillerHolder.setVisible(!wrap);
+    idSpaceFillerPanel1.setVisible(!wrap);
+    javax.swing.SwingUtilities.invokeLater(new Runnable()
+     {
+       public void run()
+       {
+         RefreshPanels();
+       }
+    });
 
   }
 
 
-  public void setColourScheme(jalview.schemes.ColourSchemeI cs, boolean conservation)
+  public void setColourScheme()
   {
-    seqPanel.setColourScheme(cs, conservation);
-    if(overviewPanel!=null)
-      overviewPanel.updateOverviewImage();
+    ColourSchemeI cs = av.getGlobalColourScheme();
+
+    if(av.getConservationSelected())
+    {
+
+       Alignment al = (Alignment)av.getAlignment();
+       Conservation c = new Conservation("All",
+                            ResidueProperties.propHash, 3, al.getSequences(), 0,
+                            al.getWidth() );
+
+       c.calculate();
+       c.verdict(false, av.ConsPercGaps);
+       ConservationColourScheme ccs = new ConservationColourScheme(c, cs);
+
+       av.setGlobalColourScheme( ccs );
+
+    }
+
+    RefreshPanels();
   }
 
 
   public void RefreshPanels()
   {
-    invalidate();
-    validate();
-    idPanel.idCanvas.paintFlag = true;
-    idPanelHolder.setPreferredSize( idPanel.idCanvas.getPreferredSize() );
-    seqPanel.seqCanvas.paintFlag = true;
-    setScrollValues(av.getStartRes(), av.getStartSeq());
-    av.getConsensus(true);
-    repaint();
 
-    if(overviewPanel!=null)
-      overviewPanel.updateOverviewImage();
+    Dimension d = idPanel.idCanvas.getPreferredSize();
+    idPanelHolder.setPreferredSize(d);
+    hscrollFillerPanel.setPreferredSize(new Dimension(d.width, 12));
 
+    if (av.getWrapAlignment())
+    {
+      int max = av.alignment.getWidth() / seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.seqCanvas.getWidth());
+      vscroll.setValues(0, 1, 0, max);
+    }
+    else
+    {
+      if (overviewPanel != null)
+        overviewPanel.updateOverviewImage();
+      setScrollValues(av.getStartRes(), av.getStartSeq());
+    }
+
+    validate();
+    repaint();
   }
 
+
   int hextent = 0;
   int vextent = 0;
 
+  // return value is true if the scroll is valid
+  public boolean scrollUp(boolean up)
+  {
+    if(up)
+    {
+      if(vscroll.getValue()<1)
+        return false;
+      fastPaint  = false;
+      vscroll.setValue(vscroll.getValue() - 1);
+    }
+    else
+    {
+     if(vextent+vscroll.getValue() >= 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)
   {
-    hextent = (int)(seqPanel.seqCanvas.getWidth()/av.getCharWidth());
-    vextent = seqPanel.seqCanvas.getHeight()/av.getCharHeight();
+    hextent = seqPanel.seqCanvas.getWidth()/av.charWidth;
+    vextent = seqPanel.seqCanvas.getHeight()/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;
@@ -143,37 +353,319 @@ public class AlignmentPanel extends GAlignmentPanel implements AdjustmentListene
 
     hscroll.setValues(x,hextent,0,av.getAlignment().getWidth());
     vscroll.setValues(y,vextent,0,av.getAlignment().getHeight() );
-    seqPanel.seqCanvas.paintFlag = true;
-    repaint();
 
   }
 
 
   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 + (int)(seqPanel.seqCanvas.getWidth()/av.getCharWidth()-1));
+      av.setEndRes(x + seqPanel.seqCanvas.getWidth()/av.getCharWidth()-1);
     }
 
     if (evt.getSource() == vscroll)
     {
-        int offy = vscroll.getValue();
+      int offy = vscroll.getValue();
+      if (av.getWrapAlignment())
+      {
+        int rowSize = seqPanel.seqCanvas.getWrappedCanvasWidth(seqPanel.seqCanvas.getWidth());
+        av.setStartRes( vscroll.getValue() * rowSize );
+        av.setEndRes( (vscroll.getValue()+1) * rowSize );
+      }
+      else
+      {
         av.setStartSeq(offy);
-        av.setEndSeq(offy + seqPanel.seqCanvas.getHeight()/av.getCharHeight());
+        av.setEndSeq(offy + seqPanel.seqCanvas.getHeight() / av.getCharHeight());
+      }
     }
 
 
     if(overviewPanel!=null)
       overviewPanel.setBoxPosition();
 
+    if(av.getWrapAlignment() || !fastPaint)
+      repaint();
+    else
+    {
+      seqPanel.seqCanvas.fastPaint(av.getStartRes() - oldX,
+                                   av.getStartSeq() - oldY);
+      idPanel.idCanvas.fastPaint(av.getStartSeq() - oldY);
+      scalePanel.repaint();
+      if (av.getShowAnnotation())
+        annotationPanel.fastPaint(av.getStartRes() - oldX);
+    }
 
-    repaint();
   }
 
+  public int print(Graphics pg, PageFormat pf, int pi) throws PrinterException
+  {
+    pg.translate((int)pf.getImageableX(), (int)pf.getImageableY());
+
+    int pwidth = (int) pf.getImageableWidth();
+    int pheight = (int) pf.getImageableHeight();
+
+    if (av.getWrapAlignment())
+      return printWrappedAlignment(pg, pwidth,pheight, pi);
+    else
+      return printUnwrapped(pg,pwidth, pheight,pi);
+  }
+
+  public int printUnwrapped(Graphics pg, int pwidth, int pheight, int pi) throws PrinterException
+  {
+
+    int idWidth = calculateIdWidth().width + 4;
+
 
+    pg.setColor(Color.white);
+    pg.fillRect(0,0,pwidth, pheight);
+    pg.setFont( av.getFont() );
+
+    ////////////////////////////////////
+    /// How many sequences and residues can we fit on a printable page?
+    int totalRes = (pwidth - idWidth)/av.getCharWidth();
+    int totalSeq = (int)((pheight - 30)/av.getCharHeight())-1;
+    int pagesWide = av.getAlignment().getWidth() / totalRes +1;
+    int pagesHigh = av.getAlignment().getHeight() / totalSeq +1;
+
+    if (pi >= pagesWide*pagesHigh)
+     return Printable.NO_SUCH_PAGE;
+
+    /////////////////////////////
+    /// Only print these sequences and residues on this page
+    int startRes, endRes, startSeq, endSeq;
+    startRes = (pi % pagesWide) * totalRes;
+    endRes = startRes + totalRes-1;
+    if(endRes>av.getAlignment().getWidth())
+      endRes = av.getAlignment().getWidth();
+
+     startSeq = (pi / pagesWide) * totalSeq;
+     endSeq = startSeq + totalSeq;
+     if(endSeq > av.getAlignment().getHeight())
+       endSeq = av.getAlignment().getHeight();
+
+
+    ////////////////
+    //draw Scale
+    pg.translate(idWidth,0);
+    scalePanel.drawScale(pg, startRes, endRes, pwidth-idWidth);
+
+    pg.translate(-idWidth, 30);
+    ////////////////
+    // Draw the ids
+    Color currentColor=null;
+    Color currentTextColor=null;
+    for(int i=startSeq; i<endSeq; i++)
+    {
+      if (av.getSelectionGroup()!=null && av.getSelectionGroup().sequences.contains(av.getAlignment().getSequenceAt(i)))
+      {
+        currentColor = Color.gray;
+        currentTextColor = Color.black;
+      }
+      else
+      {
+        currentColor = av.getAlignment().getSequenceAt(i).getColor();
+        currentTextColor = Color.black;
+      }
+
+      pg.setColor(currentColor);
+      pg.fillRect(0,  jalview.analysis.AlignmentUtil.getPixelHeight(startSeq, i, av.getCharHeight()),
+                              idWidth,
+                              av.getCharHeight());
+
+      pg.setColor(currentTextColor);
+
+      String string = av.getAlignment().getSequenceAt(i).getName();
+      if(av.getShowFullId())
+        string = av.getAlignment().getSequenceAt(i).getDisplayId();
+
+      pg.drawString(string, 0,  jalview.analysis.AlignmentUtil.getPixelHeight
+                    (startSeq, i, av.getCharHeight()) + av.getCharHeight() - (av.getCharHeight() / 5));
+    }
+
+    // draw main sequence panel
+    pg.translate(idWidth,0);
+    seqPanel.seqCanvas.drawPanel(pg,startRes,endRes,startSeq,endSeq,startRes,startSeq,0);
+
+
+    if(av.getShowAnnotation())
+      {
+        pg.translate(-idWidth,(endSeq-startSeq)*av.charHeight);
+        alabels.drawComponent((Graphics2D)pg);
+        pg.translate(idWidth,0);
+        annotationPanel.drawComponent((Graphics2D) pg, startRes, endRes+1);
+      }
+
+    return Printable.PAGE_EXISTS;
+  }
+
+
+  public int printWrappedAlignment(Graphics pg, int pwidth, int pheight, int pi) throws PrinterException
+  {
+
+    int idWidth = calculateIdWidth().width+4;
+
+    if( seqPanel.seqCanvas.getWidth() < pwidth-idWidth)
+      pwidth = seqPanel.seqCanvas.getWidth() + idWidth;
+
+
+    pg.setColor(Color.white);
+    pg.fillRect(0,0,pwidth, pheight);
+    pg.setFont( av.getFont() );
+
+    ////////////////////////////////////
+    /// How many sequences and residues can we fit on a printable page?
+    AlignmentI da = av.alignment;
+    int endy   = da.getHeight();
+    int chunkHeight =  (da.getHeight() + 2)*av.charHeight;
+    int chunkWidth  =   (pwidth-idWidth)/av.charWidth;
+
+    int noChunksOnPage = pheight / chunkHeight;
+    int totalChunks = da.getWidth() / chunkWidth;
+
+    if ( pi*noChunksOnPage > totalChunks )
+     return Printable.NO_SUCH_PAGE;
+
+    ////////////////
+    // Draw the ids
+    pg.setClip(0,0,pwidth, noChunksOnPage*chunkHeight);
+
+    pg.setColor(Color.black);
+
+    int rowSize =  av.getEndRes() - av.getStartRes();
+    // Draw the rest of the panels
+
+    for(int ypos=2*av.charHeight, row=av.getEndRes(); row<av.alignment.getWidth();
+        ypos += av.chunkHeight, row+=rowSize )
+    {
+      for (int i = 0; i < endy; i++)
+      {
+        SequenceI s = da.getSequenceAt(i);
+        String string = s.getName();
+        if (av.getShowFullId())
+          string = s.getDisplayId();
+
+        pg.drawString(string, 0,
+                      AlignmentUtil.getPixelHeight(0, i, av.charHeight) + ypos +
+                      av.charHeight - (av.charHeight / 5));
+      }
+    }
+
+    // draw main sequence panel
+    pg.translate(idWidth,0);
+    seqPanel.seqCanvas.drawWrappedPanel(pg, pwidth-idWidth, pheight, pi*noChunksOnPage*chunkWidth);
+
+
+    return Printable.PAGE_EXISTS;
+
+  }
+
+
+  public void makeEPS()
+  {
+    int height = (av.alignment.getWidth() / av.getChunkWidth() +1) * av.chunkHeight;
+    int width = seqPanel.getWidth() + idPanel.getWidth();
+
+    if (!av.getWrapAlignment())
+    {
+      height = (av.alignment.getHeight()+1) * av.charHeight + 30;
+      width = idPanel.getWidth() + av.alignment.getWidth() * av.charWidth;
+    }
+    if(av.getShowAnnotation())
+   {
+     height += annotationPanel.getPreferredSize().height;
+   }
+
+    try
+    {
+      jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(jalview.bin.Cache.getProperty(
+          "LAST_DIRECTORY"), new String[]{"eps"}, "Encapsulated Postscript");
+      chooser.setFileView(new jalview.io.JalviewFileView());
+      chooser.setDialogTitle("Create EPS file from alignment");
+      chooser.setToolTipText("Save");
+
+      int value = chooser.showSaveDialog(this);
+      if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
+        return;
+
+      jalview.bin.Cache.setProperty("LAST_DIRECTORY",chooser.getSelectedFile().getPath());
+      FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());
+      EpsGraphics2D pg = new EpsGraphics2D("Example", out, 0, 0, width, height);
+
+        if (av.getWrapAlignment())
+          printWrappedAlignment(pg, width, height, 0);
+        else
+          printUnwrapped(pg, width, height, 0);
+
+
+        pg.flush();
+        pg.close();
+    }
+    catch (Exception ex)
+    {
+      ex.printStackTrace();
+    }
+  }
+
+  public void makePNG()
+  {
+      int height = (av.alignment.getWidth() / av.getChunkWidth() +1) * av.chunkHeight;
+      int width = seqPanel.getWidth() + idPanel.getWidth();
+
+      if (!av.getWrapAlignment())
+      {
+        height = (av.alignment.getHeight()+1) * av.charHeight + 30;
+        width = idPanel.getWidth() + av.alignment.getWidth() * av.charWidth;
+      }
+
+      if(av.getShowAnnotation())
+      {
+        height += annotationPanel.getPreferredSize().height;
+      }
+
+
+System.out.println(width +" "+height);
+
+    try
+    {
+      jalview.io.JalviewFileChooser chooser = new jalview.io.JalviewFileChooser(jalview.bin.Cache.getProperty(
+          "LAST_DIRECTORY"), new String[]{"png"}, "Portable network graphics");
+      chooser.setFileView(new jalview.io.JalviewFileView());
+      chooser.setDialogTitle("Create EPS file from alignment");
+      chooser.setToolTipText("Save");
+
+      int value = chooser.showSaveDialog(this);
+      if (value != jalview.io.JalviewFileChooser.APPROVE_OPTION)
+        return;
+
+      jalview.bin.Cache.setProperty("LAST_DIRECTORY",chooser.getSelectedFile().getPath());
+      FileOutputStream out = new FileOutputStream(chooser.getSelectedFile());
+
+      BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+      Graphics png = bi.getGraphics();
+
+
+        if (av.getWrapAlignment())
+          printWrappedAlignment(png, width, height, 0);
+        else
+          printUnwrapped(png, width, height, 0);
+
+        ImageIO.write(bi, "png", out);
+        out.close();
+    }
+    catch (Exception ex)
+    {
+      ex.printStackTrace();
+    }
+  }
 
 }
+
+
+
+