myimage.java

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

import java.awt.*;
import java.util.Vector;
import java.util.Enumeration;
import java.awt.event.*;
import java.lang.Math;
import java.awt.image.ImageObserver;
import javax.swing.*;

/**
 * this is the class that contains the offscreen images on which the 
 * jumpshot data is drawn. 2 offscreen images are used, one for states
 * and arrows (img) and the other for time line (timeImg). Functions 
 * for drawing rectangles and arrows are
 * present here. 
 */
class MyImage {
  ProgramCanvas canvas;

  int imgIdH;     //id of this object 
  double begT;    //staring time of this object
  double endT;    //ending time of this object
  int _xPix;      //width of the entire image in pixels
  int _yPix;      //height of the entire image in pixels
  
  Image rulerImg; //offscreen image for displaying the time ruler
  
  // prevent drawing thin states or arrows repeatedly over one another.
  private int prev_state_beg_pos;
  private int prev_arrow_beg_pos;
  
  //Configuration variables for the arrows.
  public Color printLineColor, normLineColor;
  public Color circleColor;             //Color of the circle of arrow
  public Color hiColor = Color.red;     //Arrow ring Color
  public Color normColor = Color.white; //Arrow Color
  public int lrad = 1;                  //Radius of the little cirle
  public int brad = 3;                  //Radius of the bigger circle
  public int angle = 40;                //central angle of the arrow head
  public int ht = 20;                   //height of the arrow head
  
  public int max = 8; //The maximum size of the time string in time ruler
  
  private int numDisp;
  private Display [] dispA;
  private Vector dtypeV;
  
  public MyImage (int idH, int x, int y, Vector d, ProgramCanvas p) {
    imgIdH = idH;
    _xPix = x; _yPix = y;
    canvas = p;
    dtypeV = d;
    normLineColor = normColor;
    circleColor = hiColor;
    printLineColor = Color.black;
    setupDisps (); 
  }
  
  public MyImage (int x, int y, Vector d, ProgramCanvas p) {
    _xPix = x; _yPix = y;
    canvas = p;
    dtypeV = d; numDisp = d.size ();
    normLineColor = normColor;
    circleColor = hiColor;
    printLineColor = Color.black;
  }
  
  void paintStuff1 (int x, Graphics g, ImageObserver io) {
    g.drawImage (rulerImg, x, canvas.allDispHt, io);
    
    for (int i = 0; i < numDisp; i++)
        g.drawImage (dispA [i].img1, x, i * canvas.eachDispHt, io);
  }
  
  void paintStuff2 (int x, Graphics g, ImageObserver io) {
    g.drawImage (rulerImg, x, canvas.allDispHt, io);
    
    for (int i = 0; i < numDisp; i++) {
      if (dispA [i].dtype == CONST.TIMELINES) 
	g.drawImage (dispA [i].img2, x, i * canvas.eachDispHt, io);
      else 
	g.drawImage (dispA [i].img1, x, i * canvas.eachDispHt, io);
    }
  }
  
  private void setupDisps () {
    numDisp = dtypeV.size ();
    
    //Get offscreen images from canvas
    rulerImg = canvas.getOffScreenImage (_xPix, canvas.rulerHt);
    
    dispA = new Display [numDisp];
    
    for (int i = 0; i < numDisp; i++) {
      int dtype = ((Integer)dtypeV.elementAt (i)).intValue ();
      
      Image im1 = canvas.getOffScreenImage (_xPix, canvas.eachDispHt), im2;
      
      if (dtype == CONST.TIMELINES)
          im2 = canvas.getOffScreenImage (_xPix, canvas.eachDispHt);
      else im2 = null;
      
      dispA [i] = new Display (dtype, im1, im2);
    }
  }

    /**
     * set time values and draw stuff
     */
    void drawRegion (double b, double e) {
        begT = b; endT = e;
        drawStuff ();
    }
  
    /**
     * set starting and ending time values
     */
    void setTimes (double b, double e) {begT = b; endT = e;}
  
    /**
     * draw all things in the offscreen images
     */
    void drawStuff () {
        for ( int i = 0; i < numDisp; i++ ) 
            if ( dispA [i].dtype == CONST.TIMELINES )
                drawTimeLines (dispA [i]);
            else drawMtnRanges (dispA [i]);
    
        Graphics g = rulerImg.getGraphics();
        drawTimeRuler(g);
        g.dispose ();
    }
  
  void printStuff (Graphics g) {
    for (int i = 0; i < numDisp; i++) {
      if (((Integer)dtypeV.elementAt (i)).intValue () == CONST.TIMELINES)
          drawTimeLines (g);
      else drawMtnRanges (g);
      g.translate (0, canvas.eachDispHt);
    }
    
    drawTimeRuler (g);
  }
  
  private void drawTimeLines (Display d) {
    Graphics g1 = d.img1.getGraphics (), g2 = d.img2.getGraphics ();
    
    //Image Background
    g1.setColor (canvas.parent.normImgBColor);
    g2.setColor (canvas.parent.normImgBColor);
    g1.fillRect (0, 0, _xPix, canvas.eachDispHt);
    g2.fillRect (0, 0, _xPix, canvas.eachDispHt);
    
    //Top and bottom borders
    g1.setColor (canvas.parent.rulerColor);
    g2.setColor (canvas.parent.rulerColor);
    g1.fill3DRect (0, 0, _xPix, canvas.hBWt, true);
    g2.fill3DRect (0, 0, _xPix, canvas.hBWt, true);
    g1.fill3DRect (0, canvas.eachDispHt - canvas.hBWt,
                   _xPix, canvas.hBWt, true);
    g2.fill3DRect (0, canvas.eachDispHt - canvas.hBWt,
                   _xPix, canvas.hBWt, true);

    drawStates (g1, g2);
    drawArrows (g1, g2);
  
    g1.dispose ();
    g2.dispose ();
  }
  
  private void drawTimeLines (Graphics g) {
    //Image background
    g.setColor (canvas.parent.printImgBColor);
    g.fillRect (0, 0, _xPix, canvas.eachDispHt);
    
    //Top and bottom borders
    g.setColor (canvas.parent.rulerColor);
    g.fill3DRect (0, 0, _xPix, canvas.hBWt, true);
    g.fill3DRect (0, canvas.eachDispHt - canvas.hBWt, _xPix, canvas.hBWt, true);

    drawStates (g, null);
    drawArrows (g, null);
  }
  
  private void drawMtnRanges (Display d) {
    Graphics g = d.img1.getGraphics ();
    drawMtnRanges (g);
    g.dispose ();
  }
  
  private void drawMtnRanges (Graphics g) {
    //Image background
    if (g instanceof PrintGraphics) g.setColor (canvas.parent.printImgBColor);
    else g.setColor (canvas.parent.normImgBColor);
    g.fillRect (0, 0, _xPix, canvas.eachDispHt);
    
    //Top and bottom borders
    g.setColor (canvas.parent.rulerColor);
    g.fill3DRect (0, 0, _xPix, canvas.hBWt, true);
    g.fill3DRect (0, canvas.eachDispHt - canvas.hBWt, _xPix, canvas.hBWt, true);
    
    drawMtns (g);
  }
  
  /**
   * draw all states
   */
    private void drawStates (Graphics g1, Graphics g2)
    {
        StateGroupList visible_groups = canvas.all_states.visible;
        int            grp_seq_idx;
        double         py;
        int            idx;
    
        Enumeration groups = visible_groups.elements();
        while ( groups.hasMoreElements() ) {
            StateGroup cur_grp = (StateGroup) groups.nextElement();
      
            if ( cur_grp.dispStatus ) {
                grp_seq_idx = visible_groups.GetSeqIndexAt( cur_grp.groupID );
                py = canvas.GetStateGroupYCord( grp_seq_idx );
                draw(cur_grp, py, g1, g2); 
	
                prev_state_beg_pos = -1;

                for ( idx = cur_grp.size() - 1; idx >= 0; idx-- ) {
                    StateInterval cur_state = (StateInterval)
                                              cur_grp.elementAt( idx );
                    if ( cur_state.info.stateDef.checkbox.isSelected() )
                        if ( !(    cur_state.info.endT < begT
                                || cur_state.info.begT > endT )) {
                            if ( cur_state.info.blink )
                                 canvas.blink = true;
                            draw(cur_state, py, g1, g2);
	                }
	        }
            } 
        }
     }

  /**
   * draw mountain ranges
   */
  private void drawMtns (Graphics g) {
    Vector mtns = canvas.parent.mtns;
    Enumeration enum = mtns.elements ();
    prev_state_beg_pos = -1;
    
    while (enum.hasMoreElements ()) {
      MtnInfo currMtn = (MtnInfo)enum.nextElement ();
      
      if (!(currMtn.endT < begT || currMtn.begT > endT)) {
	double lenT = endT - begT;
	double timeDiff = currMtn.begT - begT;
	double effT = (timeDiff > 0)? timeDiff : 0.0;
	
	double t;
	if ((currMtn.endT - begT) > lenT) t = lenT;
	else t = (currMtn.endT - begT);
	
	int width = canvas.getW (effT, t);
	
	int x = canvas.getEvtXCord (effT);
	int l = canvas.totalProc;
	
	//	if (!(x == prev_state_beg_pos && (width == 0 || width == 1))) {
	for (int i = 0; i < currMtn.s.length; i++) {
	  RecDef statedef = (RecDef) canvas.parent.stateDefs.elementAt(i);
	  if (currMtn.s [i] > 0 && statedef.checkbox.isSelected ()) {
	    if ((l - currMtn.s [i]) < 0) break;
	      
	    double ycord = canvas.hBWt
                         + ((canvas.eachDispIHt / (double)canvas.totalProc)
                         * (l - currMtn.s [i]));
	    double limit = canvas.hBWt
                         + ((canvas.eachDispIHt / (double)canvas.totalProc) * l)
                         - 1;
	    
	    double height = limit - ycord + 1;
	    if (height == 0) height = 1;
	      
	    double d = Math.rint (ycord);
	    double diff = d - ycord;
	      
	    int yc = (int)d; 
	    int ht = (int)Math.rint (height - diff); 
	      
	    if (width == 0) width = 1;
	      
	    g.setColor (statedef.color);
	    g.fillRect (x, yc, width, ht);
	    
	    l -= currMtn.s [i];
	  }
	}
	//	}
	prev_state_beg_pos = x;
      }
    }
  }

  /**
   * draw arrows
   */
  private void drawArrows( Graphics g1, Graphics g2 )
  {
      RecDef        arrowdef;
      Enumeration   arrows;
      ArrowInfo     arrow;
      Color         arrow_color;

      Enumeration arrowdefs = canvas.parent.arrowDefs.elements();
      while ( arrowdefs.hasMoreElements() ) {
          arrowdef = ( RecDef ) arrowdefs.nextElement();
          if (    arrowdef.stateVector.size() > 0
               && arrowdef.checkbox.isSelected() ) {
              arrows = arrowdef.stateVector.elements();
              arrow_color = arrowdef.color;
              while ( arrows.hasMoreElements() ) {
                  arrow = ( ArrowInfo ) arrows.nextElement();
                  if ( check( arrow, begT, endT ) ) {
                      draw( arrow, g1, arrow_color );
                      if ( arrow.blink )
                          canvas.blink = true;
                      if ( g2 != null && !arrow.blink )
                          draw( arrow, g2, arrow_color );
                  }