/*
    * Copyright (c) 2006 Stiftung Deutsches Elektronen-Synchroton,
    * Member of the Helmholtz Association, (DESY), HAMBURG, GERMANY.
    *
    * THIS SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN "../AS IS" BASIS.
    * WITHOUT WARRANTY OF ANY KIND, EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
    * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSE AND
    * NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
    * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
   * THE USE OR OTHER DEALINGS IN THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE
   * IN ANY RESPECT, THE USER ASSUMES THE COST OF ANY NECESSARY SERVICING, REPAIR OR
   * CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE.
   * NO USE OF ANY SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
   * DESY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
   * OR MODIFICATIONS.
   * THE FULL LICENSE SPECIFYING FOR THE SOFTWARE THE REDISTRIBUTION, MODIFICATION,
   * USAGE AND OTHER RIGHTS AND OBLIGATIONS IS INCLUDED WITH THE DISTRIBUTION OF THIS
   * PROJECT IN THE FILE LICENSE.HTML. IF THE LICENSE IS NOT INCLUDED YOU MAY FIND A COPY
   * AT HTTP://WWW.DESY.DE/LEGAL/LICENSE.HTM
   */
  
  package de.desy.acop.chart;
  
  
  import java.awt.AWTEvent;
  import java.awt.BasicStroke;
  import java.awt.Color;
  import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.FontMetrics;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.Point;
  import java.awt.Rectangle;
  import java.awt.event.ActionEvent;
  import java.awt.event.ComponentEvent;
  import java.awt.event.MouseEvent;
  import java.awt.geom.AffineTransform;
  import java.awt.geom.Rectangle2D;
  import java.awt.image.BufferedImage;
  import java.awt.print.PageFormat;
  import java.awt.print.Printable;
  import java.awt.print.PrinterException;
  import java.awt.print.PrinterJob;
  import java.beans.Beans;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.Serializable;
  import java.util.Vector;
  import javax.swing.AbstractAction;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTextArea;
  import javax.swing.plaf.basic.BasicGraphicsUtils;
  import com.cosylab.gui.components.customizer.AbstractCustomizerPanel;
  import com.cosylab.gui.components.util.PopupManageable;
  import com.cosylab.gui.components.util.PopupManager;
  import com.sun.image.codec.jpeg.JPEGCodec;
  import com.sun.image.codec.jpeg.JPEGImageDecoder;
  import de.desy.acop.transport.AcopTransport;
  
  /**
   * @brief Advanced Component Oriented Programming ACOP offers a powerful
   *        interface for both data acquisition and data rendition in a common
   *        bean.
   */
  public class Acop extends JPanel implements Printable,Serializable, PopupManageable
  {
    /**
     * 
     */
    private static final long serialVersionUID = 351823797042270731L;
    protected AcopHisto[] histo = new AcopHisto[AcopConst.MAX_DISPLAY]; // maximum
                                                                        // 100
    protected int globalDisplayMode, enableDots, enableBarlineHisto;
    // added by ike to demonstrate simple customizer
  	private AbstractCustomizerPanel customizer;
  	private PopupManager popupManager;
  	private boolean popupEnabled;
    protected boolean frameBorderOn;
    boolean forceWidth = false;
    private int n_display;
    protected int m_lock;
    protected boolean drawTicks = true; // after new scalling
    protected boolean repainHisto = false;
    protected int rescaleFlag = 2;
    protected int histIndex = -1;
    private int loadXYindex = 0;
    private int m_filled = 0; // N_DISPLAY is filled
    private int m_keep = 0; // # of keeped histogram
    protected int lastDisp = 0;
    protected int lastTagHisto = 0;
    private int m_numberkeep = 0;
    private int m_keepstart = 0;
    protected AcopAxis[] axis = new AcopAxis[AcopConst.MAX_AXIS];
    protected AcopText[] ptext = new AcopText[AcopConst.MAX_TEXT]; // maximum 100
    private int n_text;
   private int loadTextIndex = 0;
   protected boolean textFlag = false; // Ondraw text?
   protected int rescaleTextFlag = 0;
   private double[] g_rdata = new double[512];
   private boolean RandomInitialized = false;
   private BasicStroke stroke = new BasicStroke(1.0f);
   // private Stroke penLine = null;
   // private int dxmin, dxmax, dymin, dymax, dxwidth, dywidth;
   private double xwidth, ywidth;
   private Rectangle titleRect = new Rectangle();
   // private Rectangle histRect = new Rectangle();
   protected Rectangle histRoundRect = new Rectangle();
   private Rectangle xRect = new Rectangle();
   private Rectangle yRect = new Rectangle();
   protected Rectangle yAxisRect = new Rectangle();
   protected Rectangle tagRect = new Rectangle();
   private Rectangle zoomRect = new Rectangle();
   private int changeScaleWidth;
   private int fLeft, fRight, fTop, fBottom;
   private int fLeftPixel, fRightPixel, fTopPixel, fBottomPixel;
   private int HistLeft, HistRight, leftPixel, HistRectleftReference;
   protected boolean errWindowOn = false;
   protected boolean ScaleEnable = false; // yScaleArray on-off
   protected boolean ReferenceEnable = false;
   // protected int xleft, xright, dxwidth;
   protected double[][] bufferedMin = new double[AcopConst.lengthZoom][3];
   protected double[][] bufferedMax = new double[AcopConst.lengthZoom][3];
   protected int zoomIndex, zoomLogFlag;
   protected boolean isZoomed;
   protected boolean zoomFlag, movie; // zoom is on?
   protected Point moviepoint;
   protected int saveBestFlag;
   protected double moviePercent = 0.01;
   protected int movieLogCnt = 10;
   protected int xCnt = 0;
   protected int yCnt = 0;
   // protected double s_xmin, s_xmax, s_ymin, s_ymax; // user display rectangle
   protected int time_scale;
   protected double tick_xmin, tick_xmax; // ticks area
   protected int m_histstart = 0; // reference index of base histogram
   protected double wrapxmin, wrapxmax; // wrap x range
   private int mouseX, mouseY, mouseLastX, mouseLastY;
   private Point mStart, mEnd, mousepoint;
   private double mouseConvert[] = new double[2];
   private int mouseIndex;
   protected AcopScale[] sca = new AcopScale[3];
   // private AcopLine gridLine = new AcopLine();
   protected AcopFrame aFrame = new AcopFrame();
   //protected AcopTransport transport = new AcopTransport(this);
   // private BasicGraphicsUtils bGraphic = new BasicGraphicsUtils();
   private Vector AcopListeners = new Vector();
   private java.awt.image.BufferedImage ima;
 //  private java.awt.Graphics2D g2dima;
   private String yZoomRatio, xZoomRatio, bufferedZoomRatio;
   protected int yzero;
   protected java.awt.Color foreColor, backColor;
   private boolean captionChanged;
   private java.awt.Font captionFont;
   private double lastTextx, lastTexty;
   private int nBackRegions;
   private boolean backgroundRegionFixed;
   private int backkgroundRegionType[] = new int[AcopConst.MAX_BACKGROUND_REGION];
   private Rectangle2D.Double[] backRegionUserRect = new Rectangle2D.Double[AcopConst.MAX_BACKGROUND_REGION]; // userinput
                                                                                                               // rectangle
   private Rectangle[] backRegionRect = new Rectangle[AcopConst.MAX_BACKGROUND_REGION]; // converted
                                                                                         // device
                                                                                         // rect
   private Color[] backRegionColor = new Color[AcopConst.MAX_BACKGROUND_REGION]; // userinput
                                                                                 // color
   private BufferedImage[] backRegionImage = new BufferedImage[AcopConst.MAX_BACKGROUND_REGION]; // userinput
                                                                                                 // images
   protected Color pTagColorArray[];
   protected int nElement;
   protected Color TagBackColor; // init with forecolor
   private long mousePreviousClickTime, previousButton;
   private Point rButtonPoint;
   protected double yReferenceArray[];
   protected int yRASize, yRAdataSize;
   protected double yWindowArray[];
   protected int yWASize, yWAdataSize;
   protected double e_xmin, e_xmax, e_ymin, e_ymax; // error window display
                                                     // rectangle
   protected BasicStroke markerStroke;
   protected int m_marker;
   protected int saveMarkerWidth;
   protected double xlabelRotateGrad, xlabelcos, xlabelsin;
   protected int xlabelQudrant, xlabelAxis;
   protected int printScreenPosition;
   private int averagingIndex, averagingLength, NumberAveragingData;
   private double totalWeight;
   private double[] averageWeight = new double[AcopConst.N_DEF_DISPLAY];
   private double[][] averagingBuffer = new double[AcopConst.N_DEF_DISPLAY][];
   protected BasicStroke cursorMarkerStroke;
   private Point mMovePoint = new Point(); // for mouse
   private Point mOffsetMovePoint = new Point(); // for traslated coordinate
   private int cursorStay, cursorMarkerFlag, cursorix, cursoriy, cursorwx, cursorwy;
   private double cursorXPercent, cursorYPercent;
   private double cursorXposition, cursorYposition;
   public int printScreen()
   {
     return printScreen(0);
   }
   public int printScreen(int position)
   {
     PrinterJob printerJob = PrinterJob.getPrinterJob();
     PageFormat pageFormat = printerJob.defaultPage();
     printScreenPosition = (position < 0 || position > 2) ? 0 : position;
     if (printerJob.pageDialog(pageFormat) != pageFormat)
     {
       if (printerJob.printDialog())
       {
         printerJob.setPrintable(this);
         try
         {
           printerJob.print();
         }
         catch (PrinterException e)
         {
           // TODO Auto-generated catch block
           e.printStackTrace();
         }
       }
       else
         System.out.println("PrintDialog was cancelled");
     }
     return 0;
   }
   public int print(Graphics printG, PageFormat pageFormat, int pageIndex)
   {
     if (pageIndex == 0)
     {
       Graphics2D g = (Graphics2D) printG;
       double x1, x2, x3, y1, y2, y3, tmp, scale, offsetX, offsetY;
       x1 = pageFormat.getImageableWidth();
       x2 = this.getSize().width;
       x3 = pageFormat.getImageableX();
       y1 = pageFormat.getImageableHeight();
       y2 = this.getSize().height;
       y3 = pageFormat.getImageableY();
       tmp = x1 / x2;
       scale = y1 / y2;
       offsetX = 0;
       offsetY = 0;
       if (printScreenPosition != 0)
       {
         if (tmp < scale)
         {
           offsetY = y1 - y2 * tmp;
           if (printScreenPosition == 1) offsetY /= 2;
         }
         else
         {
           offsetX = x1 - x2 * scale;
           if (printScreenPosition == 1) offsetX /= 2;
         }
       }
       if (tmp < scale) scale = tmp;
       double xMargin = (pageFormat.getImageableWidth() - this.getSize().width * scale) / 2 + offsetX;
       double yMargin = (pageFormat.getImageableHeight() - this.getSize().height * scale) / 2 + offsetY;
       g.translate(pageFormat.getImageableX() + xMargin, pageFormat.getImageableY() + yMargin);
       g.scale(scale, scale);
       paint(g);
       return PAGE_EXISTS;
     }
     else
       return NO_SUCH_PAGE;
   }
   public int setBackgroundRegion(Rectangle2D.Double[] colorRegionRect, Color[] regionColor, boolean fixed)
   {
     return setBackgroundRegion(colorRegionRect, regionColor, null, null, fixed);
   }
   public int setBackgroundRegion(Rectangle2D.Double[] imageRegionRect, String[] imageFilename, boolean fixed)
   {
     return setBackgroundRegion(null, null, imageRegionRect, imageFilename, fixed);
   }
   public int setBackgroundRegion(Rectangle2D.Double[] colorRegionRect, Color[] regionColor,
       Rectangle2D.Double[] imageRegionRect, String[] imageFilename, boolean fixed)
   {
     int numColorRegion, numImageRegion, numRegion, colorLength, imageLength;
     if ((colorRegionRect == null && imageRegionRect == null) || // no rectangle
         (regionColor == null && imageFilename == null))
     {
       nBackRegions = 0;
       return 0;
     }
     numColorRegion = (colorRegionRect != null && regionColor != null) ? colorRegionRect.length : 0;
     numImageRegion = (imageRegionRect != null && imageFilename != null) ? imageRegionRect.length : 0;
     if (numColorRegion <= 0 && numImageRegion <= 0)
     {
       nBackRegions = 0;
       return 0;
     }
     colorLength = regionColor != null ? regionColor.length : 0;
     imageLength = imageFilename != null ? imageFilename.length : 0;
     numRegion = numColorRegion + numImageRegion;
     if (numRegion > AcopConst.MAX_BACKGROUND_REGION) numRegion = AcopConst.MAX_BACKGROUND_REGION;
     for (int i = 0; i < numRegion; i++) // load user region and color array or
                                         // images
     {
       backRegionUserRect[i] = i < numColorRegion ? colorRegionRect[i] : imageRegionRect[i - numColorRegion];
       if (backRegionUserRect[i] == null)
       {
         backkgroundRegionType[i] = 0;
         continue;
       }
       if (i < numColorRegion)
       {
         backRegionColor[i] = i < colorLength ? regionColor[i] : regionColor[i - 1];
         backkgroundRegionType[i] = 1;
       }
       else
       {
         backkgroundRegionType[i] = 2;
         if (i - numColorRegion >= imageLength)
           backRegionImage[i] = backRegionImage[i - 1];
         else
           try
           {
             InputStream in = new FileInputStream(imageFilename[i - numColorRegion]);
             JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(in);
             backRegionImage[i] = decoder.decodeAsBufferedImage();
           }
           catch (IOException e)
           {
             e.printStackTrace();
             throw new Error("Could not load " + backRegionImage[i] + " with JPEGImageDecoder");
           }
       }
     }
     backgroundRegionFixed = fixed;
     if (numRegion > 0)
     {
       nBackRegions = numRegion;
       convertBackgroundRegion(true);
     }
     return numRegion;
   }
   private void convertBackgroundRegion(boolean fourceConvert)
   {
     int xpos, xlength, ypos, ylength;
     if (nBackRegions == 0) return;
     if (!fourceConvert && backgroundRegionFixed) return;
     for (int i = 0; i < nBackRegions; i++) // convert
     {
       if (backkgroundRegionType[i] == 0) continue;
       ylength = (int) (aFrame.histRect.height * backRegionUserRect[i].height / sca[1].dispSize);
       ypos = (int) (aFrame.histRect.y - ylength + aFrame.histRect.height
           * (1. - (backRegionUserRect[i].y - sca[1].min) / sca[1].dispSize));
       xpos = (int) (aFrame.histRect.x + aFrame.histRect.width * (backRegionUserRect[i].x - sca[0].min)
           / sca[0].dispSize);
       xlength = (int) (aFrame.histRect.width * backRegionUserRect[i].width / sca[0].dispSize);
       backRegionRect[i] = new Rectangle(xpos, ypos, xlength, ylength);
     }
   }
   public int setDisplayGap(int pixel)
   {
     return setDisplayGap(pixel, pixel);
   }
   public int setDisplayGap(int xPixel, int yPixel)
   {
     return setDisplayGap(xPixel, xPixel, yPixel, yPixel);
   }
   public int setDisplayGap(int xLeftPixel, int xRightPixel, int yTopPixel, int yBottomPixel)
   {
     if (xLeftPixel < 0 || xLeftPixel >= aFrame.histRect.width / 2) xLeftPixel = 0;
     if (xRightPixel < 0 || xRightPixel >= aFrame.histRect.width / 2) xRightPixel = 0;
     if (yTopPixel < 0 || yTopPixel >= aFrame.histRect.height / 2) yTopPixel = 0;
     if (yBottomPixel < 0 || yBottomPixel >= aFrame.histRect.height / 2) yBottomPixel = 0;
     fLeftPixel = xLeftPixel;
     fRightPixel = xRightPixel;
     fTopPixel = yTopPixel;
     fBottomPixel = yBottomPixel;
     scaleFrameDraw();
     return xLeftPixel;
   }
   protected void averagingScaling(double df[], int start, int stop, int index)
   {
     int i, j, max;
     double maximum;
     if (averagingDepth > 0) // averaging
     {
       if (averagingLength == 0)
         NumberAveragingData = histo[index].npoints;
       else if (++averagingIndex == averagingDepth) averagingIndex = 0;
       if (averagingLength < averagingDepth)
       {
         if (averagingBuffer[averagingIndex] == null || averagingBuffer[averagingIndex].length < NumberAveragingData)
           averagingBuffer[averagingIndex] = new double[NumberAveragingData];
         averagingLength++;
         // calculate averaging exponential function
         totalWeight = 0;
         for (i = 0; i < averagingLength; i++)
           totalWeight += averageWeight[i];
       }
       max = histo[index].npoints < NumberAveragingData ? histo[index].npoints : NumberAveragingData;
       System.arraycopy(df, 0, averagingBuffer[averagingIndex], 0, max);
       if (averagingLength > 1) for (j = start; j < stop; j++)
       {
         if (j >= max) break;
         maximum = 0;
         for (i = 0; i < averagingLength; i++)
         {
           if (averagingMode == 0)
             maximum += averagingBuffer[i][j];
           else
             maximum += (averagingBuffer[i][j] * averageWeight[i]);
         }
         df[j] = maximum / (averagingMode == 0 ? averagingLength : totalWeight);
       }
     }
     if (yWAdataSize > 0 && histo[index].yScaleEnable)
     {
       max = histo[index].npoints < yWAdataSize ? histo[index].npoints : yWAdataSize;
       for (i = start; i < stop && i < max; i++)
         df[i] *= yWindowArray[i];
     }
     if (yRAdataSize > 0 && histo[index].yReferenceEnable)
     {
       max = histo[index].npoints < yRAdataSize ? histo[index].npoints : yRAdataSize;
       for (i = start; i < stop && i < max; i++)
         df[i] -= yReferenceArray[i];
     }
   }
   public int weightFunction(Object WeightArray)
   {
     return weightFunction(WeightArray, 0);
   }
   public int weightFunction(Object WeightArray, int ArraySize)
   {
     int ndata;
     ndata = AcopHisto.getArrayLength(WeightArray);
     if (ndata <= 0) return -1;
     if (ArraySize > 0 && ArraySize < ndata) ndata = ArraySize;
     if (yWindowArray == null || yWASize < ndata)
     {
       yWindowArray = new double[ndata];
       yWASize = ndata;
     }
     AcopHisto.copyArray(yWindowArray, WeightArray, 0, ndata, ndata, 1);
     yWAdataSize = ndata;
     return 0;
   }
   public int referenceFunction(Object ReferenceArray)
   {
     return referenceFunction(ReferenceArray, 0);
   }
   public int referenceFunction(Object ReferenceArray, int ArraySize)
   {
     int ndata;
     ndata = AcopHisto.getArrayLength(ReferenceArray);
     if (ndata <= 0) return -1;
     if (ArraySize > 0 && ArraySize < ndata) ndata = ArraySize;
     if (yReferenceArray == null || yRASize < ndata)
     {
       yReferenceArray = new double[ndata];
       yRASize = ndata;
     }
     AcopHisto.copyArray(yReferenceArray, ReferenceArray, 0, ndata, ndata, 1);
     yRAdataSize = ndata;
     return 0;
   }
   public boolean isErrorWindowOn()
   {
     return isErrorWindowOn(-1, -1);
   }
   public boolean isErrorWindowOn(int hDisplay)
   {
     return isErrorWindowOn(hDisplay, -1);
   }
   public boolean isErrorWindowOn(boolean turnON)
   {
     return isErrorWindowOn(-1, turnON ? 1 : 0);
   }
   public boolean isErrorWindowOn(int hDisplay, boolean turnON)
   {
     return isErrorWindowOn(hDisplay, turnON ? 1 : 0);
   }
   private boolean isErrorWindowOn(int hDisplay, int value)
   {
     boolean arayon;
     if (hDisplay < -1 || hDisplay >= n_display) return false; // out of range,
                                                               // -1 to set for
                                                               // default value
     if (value < 0 || value > 1) // reading
       return (hDisplay == -1 || histo[hDisplay] == null) ? errWindowOn : histo[hDisplay].errWindowEnable;
     arayon = value != 0 ? true : false;
     if (hDisplay != -1)
     {
       if (histo[hDisplay] == null) return false;
       histo[hDisplay].errWindowEnable = arayon;
       return histo[hDisplay].errWindowEnable;
     }
     errWindowOn = arayon; // set default value and all the rest
     for (int i = 0; i < n_display; i++)
     {
       if (histo[i] == null) break;
       histo[i].errWindowEnable = arayon;
     }
     return arayon;
   }
   public boolean isWeighted(int hDisplay)
   {
     return isWeighted(hDisplay, -1);
   }
   public boolean isWeighted(int hDisplay, int value)
   {
     boolean arayon;
     if (hDisplay < -1 || hDisplay >= n_display) return false; // out of range,
                                                               // -1 to set for
                                                               // default value
     if (value < 0 || value > 1) // reading
       return (hDisplay == -1 || histo[hDisplay] == null) ? ScaleEnable : histo[hDisplay].yScaleEnable;
     arayon = value != 0 ? true : false;
     if (hDisplay != -1)
     {
       if (histo[hDisplay] == null) return false;
       histo[hDisplay].yScaleEnable = arayon;
       return histo[hDisplay].yScaleEnable;
     }
     ScaleEnable = arayon; // set default value and all the rest
     for (int i = 0; i < n_display; i++)
     {
       if (histo[hDisplay] == null) break;
       histo[hDisplay].yScaleEnable = arayon;
     }
     return arayon;
   }
   public boolean isReferenced(int hDisplay)
   {
     return isReferenced(hDisplay, -1);
   }
   public boolean isReferenced(int hDisplay, int value)
   {
     boolean arayon;
     if (hDisplay < -1 || hDisplay >= n_display) return false; // out of range,
                                                               // -1 to set for
                                                               // default value
     if (value < 0 || value > 1)
       // reading
       return (hDisplay == -1 || histo[hDisplay] == null) ? ReferenceEnable : histo[hDisplay].yReferenceEnable;
     arayon = value != 0 ? true : false;
     if (hDisplay != -1)
     {
       if (histo[hDisplay] == null) return false;
       histo[hDisplay].yReferenceEnable = arayon;
       return histo[hDisplay].yReferenceEnable;
     }
     ReferenceEnable = arayon; // set default value and all the rest
     for (int i = 0; i < n_display; i++)
     {
       if (histo[i] == null) break;
       histo[i].yReferenceEnable = arayon;
     }
     return arayon;
   }
   public void SetZoom(boolean XMax, boolean XMin, boolean YMax, boolean YMin, boolean SecondaryYMax, boolean SecondaryYMin, double xmx, double xmn,
       double ymx, double ymn, double ymxSecondary, double ymnSecondary)
   {
     int dezoomFlag = 0, i;
     double[] storemin = new double[3];
     double[] storemax = new double[3];
     if (histo[m_histstart] == null || !aFrame.drawFlag) return;
     if (!XMax) xmx = sca[0].getMax();
     if (!XMin) xmn = sca[0].getMin();
     if (!YMax) ymx = sca[1].getMax();
     if (!YMin) ymn = sca[1].getMin();
     if (!SecondaryYMax) ymxSecondary = sca[2].getMax();
     if (!SecondaryYMin) ymnSecondary = sca[2].getMin();
     if (xmn >= xmx)
     {
       xmn = sca[0].usermin;
       xmx = sca[0].usermax;
     }
     if (ymn >= ymx)
     {
       ymn = sca[1].usermin;
       ymx = sca[1].usermax;
     }
     if (ymnSecondary >= ymxSecondary)
     {
       ymnSecondary = sca[2].usermin;
       ymxSecondary = sca[2].usermax;
     }
     if ((zooming & 0x4) != 0)
     {
       dezoomFlag = 0;
       if (zoomIndex > 0) // compare size
       {
         for (i = 0; i < 3; i++)
         {
           storemin[i] = sca[i].getMin();
           storemax[i] = sca[i].getMax();
         }
         if (Math.abs((xmx - xmn) - (storemax[0] - storemin[0])) < AcopConst.zero_check
             && Math.abs((ymx - ymn) - (storemax[1] - storemin[1])) < AcopConst.zero_check
             && Math.abs((ymxSecondary - ymnSecondary) - (storemax[2] - storemin[2])) < AcopConst.zero_check) return;
         if ((xmx - xmn) > (storemax[0] - storemin[0]) || (ymx - ymn) > (storemax[1] - storemin[1]) || (ymxSecondary - ymnSecondary) > (storemax[2] - storemin[2]))
         {
           dezoomFlag = 1;
           if (zoomIndex == 1) // finish zoom
           {
             xmn = sca[0].usermin;
             xmx = sca[0].usermax;
             ymn = sca[1].usermin;
             ymx = sca[1].usermax;
             ymnSecondary = sca[2].usermin;
             ymxSecondary = sca[2].usermax;
           }
         }
       }
       if (dezoomFlag == 0 && zoomIndex < AcopConst.lengthZoom)
       {
         for (i = 0; i < 3; i++)
         {
           storemin[i] = sca[i].getMin();
           storemax[i] = sca[i].getMax();
         }
       }
     }
     sca[0].setDispscale(xmn, xmx);
     sca[1].setDispscale(ymn, ymx);
     sca[2].setDispscale(ymnSecondary, ymxSecondary);
     if (sca[0].isOriginMaxMin() && sca[1].isOriginMaxMin())
     {
       isZoomed = false;
       if ((zooming & 0x4) != 0) zoomIndex = 0;
     }
     else
     {
       isZoomed = true;
       if ((zooming & 0x4) != 0)
       {
         if (dezoomFlag != 0)
         {
           zoomIndex--;
           for (i = 0; i < 3; i++)
           {
             sca[i].setDispscale(bufferedMin[zoomIndex][i], bufferedMax[zoomIndex][i]);
             if (sca[i].log != 0) sca[i].setDispscale(Math.pow(10.0, sca[i].min), Math.pow(10.0, sca[i].max));
           }
           bufferedZoomRatio = "Z" + zoomIndex;
         }
         else if (zoomIndex < AcopConst.lengthZoom)
         {
           for (i = 0; i < 3; i++)
           {
             bufferedMin[zoomIndex][i] = storemin[i];
             bufferedMax[zoomIndex][i] = storemax[i];
             if ( zoomIndex > 0 && sca[i].log != 0 )
             {
               if ( storemin[i] > 0 ) bufferedMin[zoomIndex][i] = Math.log(storemin[i]) / Math.log(10);
               if ( storemax[i] > 0 ) bufferedMax[zoomIndex][i] = Math.log(storemax[i]) / Math.log(10);
             }
           }
           zoomIndex++;
           bufferedZoomRatio = "Z" + zoomIndex;
         }
       }
     }
     zoomFlag = false;
     sca[0].scaleToGrid();
     if (m_marker == 2) setmarkerflag(2); // recalculate marker array
       // prepareDraw(TRUE, -1, FALSE, nScaleText); // rescale and not set max
       // limit
     rescaleFlag = 1;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw(); // rescale and not set max limit
     yZoomRatio = "V" + (int) (sca[1].userSize / sca[1].dispSize + 0.5) + ":1";
     xZoomRatio = "H" + (int) (sca[0].userSize / sca[0].dispSize + 0.5) + ":1";
   }
   public void SetZoom(boolean XMax, boolean XMin, boolean YMax, boolean YMin, double xmx, double xmn,
       double ymx, double ymn)
   {
     SetZoom(XMax, XMin, YMax, YMin, false, false, xmx, xmn, ymx, ymn, 0, 0);
   }
   public int getScaledCoordinates(Object Coordinates)
   {
     int arySize, i; // return up to 6 values: Left, Right, Bottom, Top,
                     // SecondaryBottom, SecondaryTop
     if (Coordinates == null) return 0;
     arySize = AcopHisto.getArrayLength(Coordinates);
     if (arySize == 0) return 0;
     if (arySize > 6) arySize = 6;
     double[] tmpData = new double[arySize];
     for (i = 0; i < arySize; i++)
       tmpData[i] = (i % 2 == 0) ? sca[i / 2].getMin() : sca[i / 2].getMax();
     arySize = AcopHisto.copyArray(tmpData, Coordinates, 0, arySize, arySize, 0);
     return arySize;
   }
   public int getDrawnData(Object Yarray, Object Xarray, int Npoints, int StartIndex, int hDisplay)
   {
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     return histo[hDisplay].getDrawnData(Yarray, Xarray, Npoints, StartIndex, hDisplay);
   }
   public int getDrawnData(Object Yarray, Object Xarray, int hDisplay, double xPosition, double yPosition)
   {
     int dataIndex;
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     dataIndex = histo[hDisplay].getHistoIndex(xPosition, yPosition);
     return histo[hDisplay].getDrawnData(Yarray, Xarray, 1, dataIndex, hDisplay);
   }
   private void setlimit()
   {
     isZoomed = false; // new change!
     if ((zooming & 0x4) != 0) zoomIndex = 0;
     for (int i = 0; i < 3; i++)
       sca[i].setscale();
   }
   // setup HistoRect... ...
   private void scaleframe()
   {
     Rectangle r = getBounds();
     fLeft = frameWidth + frameLeftOffset; // init 4 offset
     fRight = frameWidth + frameRightOffset;
     fTop = frameWidth + frameTopOffset;
     fBottom = frameWidth + frameBottomOffset;
     if (fLeft < 0)
       fLeft = 0; // check x
     else if (fLeft >= r.width) fLeft = r.width - 1;
     if (fRight < 0)
       fRight = 0;
     else if ((fRight + fLeft) >= r.width) fRight = r.width - fLeft - 1;
     if (fTop < 0)
       fTop = 0; // check y
     else if (fTop >= r.height) fTop = r.height - 1;
     if (fBottom < 0)
       fBottom = 0;
     else if ((fBottom + fTop) >= r.height) fBottom = r.height - fTop - 1;
     // titleRect.setBounds(r.x+fLeft, r.y, r.width-fLeft-fRight, fTop);
     // titleRect.setBounds(fLeft, 0, r.width-fLeft-fRight, fTop);
     titleRect.setBounds(0, 0, r.width, fTop);
     // histRect.setBounds(r.x+fLeft, r.y+fTop, r.width-fLeft-fRight,
     // r.height-fTop-fBottom);
     // aFrame.histRect.setBounds(fLeft, fTop, r.width-fLeft-fRight,
     // r.height-fTop-fBottom);
     aFrame.histRect.setBounds(fLeft + fLeftPixel, fTop + fTopPixel, r.width - fLeft - fRight - fLeftPixel
         - fRightPixel, r.height - fTop - fBottom - fTopPixel - fBottomPixel);
     aFrame.zoomIcon.setBounds(aFrame.histRect.x + aFrame.histRect.width - aFrame.ZoomExtent,
         aFrame.histRect.y + 1, aFrame.ZoomExtent - 1, aFrame.ZoomExtent - 1);
     // histRoundRect.setBounds(aFrame.histRect.x - 1,aFrame.histRect.y -
     // 1,aFrame.histRect.width + 2,aFrame.histRect.height + 2);
     histRoundRect.setBounds(aFrame.histRect.x - fLeftPixel - 1, aFrame.histRect.y - fTopPixel - 1,
         aFrame.histRect.width + fLeftPixel + fRightPixel + 2, aFrame.histRect.height + fTopPixel
             + fBottomPixel + 2);
     // xRect.setBounds(r.x, r.y+r.height-fBottom, r.width, fBottom);
     xRect.setBounds(0, r.height - fBottom, r.width, fBottom);
     setTickRectangle(0);
     // yRect.setBounds(r.x, r.y, fLeft, r.height);
     yRect.setBounds(0, 0, fLeft, r.height);
     // yAxisRect.setBounds(r.x+r.width-fRight, r.y, fRight, r.height);
     yAxisRect.setBounds(r.width - fRight, 0, fRight, r.height);
     setTickRectangle(1);
     tagRect.setBounds(histRoundRect); // tagging
     HistRectleftReference = aFrame.histRect.x + leftPixel;
     listTextBox
         .setBounds(aFrame.histRect.x, aFrame.histRect.y, aFrame.histRect.width, aFrame.histRect.height);
   }
   // setup which rectangle used for ticks
   private void setTickRectangle(int i)
   {
     Rectangle tmpRect;
     if (sca[i].leftBottom) // take lower Rect for x and left Rect for y
     {
       sca[i].ticksRect = i == 0 ? xRect : yRect;
       tmpRect = i == 0 ? titleRect : yAxisRect;
     }
     else
     {
       sca[i].ticksRect = i == 0 ? titleRect : yAxisRect;
       tmpRect = i == 0 ? xRect : yRect;
     }
     if (i == 1) // secondasy Y ticks and label area
     {
       sca[2].ticksRect = tmpRect;
       sca[2].labelRect = sca[i].leftBottom != sca[i].leftBottLabel ? sca[i].ticksRect : tmpRect;
       sca[2].leftBottom = sca[i].leftBottom ? false : true;
       sca[2].leftBottLabel = sca[i].leftBottLabel ? false : true;
     }
     sca[i].labelRect = sca[i].leftBottom == sca[i].leftBottLabel ? sca[i].ticksRect : tmpRect;
   }
   private boolean drawOneHist(int num)
   {
     Graphics2D a = (Graphics2D) getGraphics();
     if (a == null) return false; // currently not displayable!!
     a.setClip(histRoundRect.x, histRoundRect.y, histRoundRect.width, histRoundRect.height);
     a.translate(aFrame.histRect.x, aFrame.histRect.y);
     histo[num].drawhist(a);
     a.translate(-aFrame.histRect.x, -aFrame.histRect.y);
     a.dispose();
     return true;
   }
   protected void prepareDraw()
   {
     double xtemp, ytemp;
     int i, j, start, ende, ret;
     if (randomData == true && sca[0].usermax > sca[0].usermin && sca[1].usermax > sca[1].usermin)
     {
       if (RandomInitialized == false)
       {
         for (i = 0; i < 512; i++)
           g_rdata[i] = Math.sin(i * 6.2832 / 512.);
         RandomInitialized = true;
       }
       xtemp = sca[0].userSize + 1; // one more point for the right edge!
       if (xtemp < 1.0) xtemp = 1.0;
       j = (int) xtemp;
       double[] ppvdata = new double[j];
       for (i = 0; i < j; i++)
         ppvdata[i] = sca[1].usermin + (1 + g_rdata[j >= 512 ? i % 512 : (int) (i * 512 / xtemp) % 512])
             * sca[1].userSize / 2;
       if (histo[0] == null)
       {
         histo[0] = new AcopHisto(this, 0);
       }
       if (histo[0].setHisto(ppvdata, null, null, null, 0, 0, foreColor) == 0)
       {
         if (wrapAround) histo[0].getMaxWindow();
         aFrame.drawFlag = true;
         histo[0].displayON = 1;
         histo[0].dismode = globalDisplayMode;
         histo[0].disDots = enableDots;
         histo[0].disBarHisto = enableBarlineHisto;
         histo[0].xext = XExtent;
         histo[0].yext = YExtent;
         histo[0].colorfilled = colorFilled;
         histo[0].barlineColorFilled = barlineColorFilled;
         loadXYindex = 0;
         lastDisp = 0;
       }
     }
     if (rescaleFlag == 2) 
     {
       setlimit(); // load m_xmin... ...
       sca[0].scaleToGrid();
     }
     if (rescaleFlag > 0)
     {
       for (i = 0; i < 3; i++)
         sca[i].xyscale(rescaleFlag == 2 ? true : false); // set new min max(2007 hwu before was true)
 //      convertBackgroundRegion(false);
     }
     // 2009-5-26
     if (rescaleFlag > 0 || drawTicks) convertBackgroundRegion(false);
     
     if (histIndex < 0 || histIndex >= n_display)
     {
       start = 0;
       ende = n_display;
     }
     else
     {
       start = histIndex;
       ende = histIndex + 1;
     }
     if (aFrame.drawFlag) for (i = start; i < ende; i++)
     {
       if (histo[i] == null) break;
       if (histo[i].displayON == 0 && i != m_histstart) continue;
       // if ( disp[n]->dismode >= AcopConst.mode_textbox ) continue;
       // scale screen: xleft, xright and dxwidth! getOxleftright(0);
       if (i == m_histstart) aFrame.getOxleftright(histo[i], sca[0]);
       // find wrapindex
       if (wrapAround && rescaleFlag != 0 && sca[0].log == 0) histo[i].setwrapindex();
       histo[i].setExtent();
       if (i == m_histstart)
       {
         if (histo[i].dismode == AcopConst.mode_textbox)
         {
           //listTextBox.removeAll();
           String allStmp = "";
           textArea.setText(allStmp);
         }
         else
           listTextBox.setVisible(false);
       }
       // map to screen coordinate
       histo[i].mapScreen(-1);
     }
     if (rescaleTextFlag > 0) for (i = 0; i < n_text; i++)
     {
       if (ptext[i] == null) break;
       ptext[i].rescaleText(rescaleTextFlag);
     }
     // if ( aFrame.drawFlag == false )
     // {
     // aFrame.xleft = 0;
     // aFrame.xright = aFrame.histRect.width;
     // aFrame.dxwidth =aFrame.xright - aFrame.xleft;
     // aFrame.absxleft = aFrame.xleft + aFrame.histRect.x;
     // return;
     // }
 //    if (rescaleFlag > 0 && cursorStay > 0)
     if ((rescaleFlag > 0 || drawTicks) && cursorStay > 0)  // 2009-4-30
     {
       mMovePoint.x = sca[0].getScreenPosition(cursorXposition);
       mMovePoint.y = sca[1].getScreenPosition(cursorYposition);   
     }
     if (sca[1].log != 0)
       yzero = aFrame.histRect.height;
     else if (sca[1].max >= 0 && sca[1].min <= 0)
       yzero = (int) (aFrame.histRect.height * (1 + sca[1].min / sca[1].dispSize));
     else
       yzero = (int) ((sca[1].max > 0 && sca[1].min > 0) ? aFrame.histRect.height : 0);
     if (repainHisto == true && drawTicks == false && rescaleFlag == 0 && rescaleTextFlag == 0
         && start + 1 == ende)
     {
       if (drawOneHist(start) == false) repaintHisto();
     }
     else if (rescaleFlag > 0 || drawTicks)
       repaint();
     // else if ( start == ende - 1 && repainHisto == false )
     // histo[start].drawhist(null);
     else
       repaintHisto();
     rescaleTextFlag = 0;
     rescaleFlag = 0;
     drawTicks = false;
     histIndex = -1;
     repainHisto = false;
   }
   private void setGlobalDisplayMode()
   {
     globalDisplayMode = displayMode;
     if ( displayMode > AcopConst.mode_textbox )
     {
       if ( displayMode == AcopConst.mode_polyline_dots ) globalDisplayMode = AcopConst.mode_polyline;
       if ( displayMode == AcopConst.mode_barline_dots ) globalDisplayMode = AcopConst.mode_barline;
       if ( displayMode == AcopConst.mode_histogram_dots ) globalDisplayMode = AcopConst.mode_histogram;
       if ( displayMode == AcopConst.mode_histogram_rastoring_dots ) globalDisplayMode = AcopConst.mode_histogram_rastoring;
       if ( displayMode != AcopConst.mode_barline_histo ) enableDots = 1;
       else enableDots = 0;
       if ( displayMode == AcopConst.mode_barline_histo ||  displayMode == AcopConst.mode_barline_histo_dots )
       {
         globalDisplayMode = AcopConst.mode_barline;
         enableBarlineHisto = 1;
       }
       else enableBarlineHisto = 0;
     }
     else
     {
       enableDots = 0;
       enableBarlineHisto = 0;
     }
     
   }
   
   public Acop()
   {
 	  //setDoubleBuffered(false);
 	// {{INIT_CONTROLS
     setLayout(null);
     setSize(502, 350);
     setPreferredSize(new Dimension(502, 350));
     setMinimumSize(new Dimension(100, 100));
     setPopupEnabled(true);
     captionPosition = 1;
     captionChanged = true;
     keepColor = Color.gray;
     keepWidth = 1;
     keepStyle = AcopConst.PS_SOLID;
     m_tagColor = Color.cyan;
     m_tagging = false;
     pTagColorArray = null;
     nElement = 0;
     m_marker = 0;
     saveMarkerWidth = 0;
     m_markerColor = Color.black;
     m_markerMode = 0;
     m_markerStyle = AcopConst.PS_SOLID;
     m_markerWidth = 1;
     m_markerXExtent = -1;
     m_markerYExtent = -1;
     m_cursorMarkerColor = Color.black;
     rev_cursorMarkerColor = Color.white;
     m_cursorMarkerMode = 0;
     m_cursorMarkerStyle = AcopConst.PS_SOLID;
     m_cursorMarkerWidth = 1;
     cursorMarkerStroke = AcopConst.createStroke(m_cursorMarkerWidth, m_cursorMarkerStyle);
     m_cursorMarkerXExtent = -1;
     m_cursorMarkerYExtent = -1;
     mMovePoint.setLocation(-1, -1);
     mOffsetMovePoint.setLocation(-1, -1);
     cursorStay = 0;
     cursorXPercent = -1;
     cursorYPercent = -1;
     cursorMarkerFlag = 0;
     cursorix = 0;
     cursoriy = 0;
     cursorwx = 0;
     cursorwy = 0;
     m_errorColor = Color.red;
     colorFilled = true;
     averagingMode = 0;
     averagingDepth = 0;
     averagingIndex = 0;
     averagingLength = 0;
     NumberAveragingData = 0;
     for (int i = 0; i < AcopConst.N_DEF_DISPLAY; i++)
       averageWeight[i] = Math.exp((double) i);
     FFT = 0;
     printScreenPosition = 0;
     for (int i = 0; i < 3; i++)
     {
       if (i < 2) axis[i] = new AcopAxis(this, i);
       sca[i] = new AcopScale(this, i == 0 ? true : false);
       // load pointer into AcopScale class
       sca[i].ticks = -1;
       sca[i].fineTicks = 1;
       sca[i].grid = false;
       sca[i].leftBottom = i < 2 ? true : false;
       sca[i].bestScale = true;  // 2007 hwu false;
       sca[i].ticktext = true;
       sca[i].log = 0;
       sca[i].xtime = 0;
       sca[i].tickLabelForeColor = Color.gray;
       sca[i].leftBottLabel = true;
       sca[i].OnFlag = i < 2 ? true : false;
       sca[i].setUserscale(i == 0 ? 0 : -100, 100);
     }
     textArea = new JTextArea();
 //  listTextBox = new java.awt.List();
     listTextBox = new JScrollPane(textArea);
     this.add(listTextBox);
     listTextBox.setVisible(false);
     nBackRegions = 0;
     changeScaleWidth = 0;
     invert = false;
     XShift = 0;
     XScale = 1;
     YShift = 0;
     YScale = 1;
     leftPixel = 0;
     RandomInitialized = false;
     randomData = Beans.isDesignTime();
     randomText = Beans.isDesignTime();
     frameWidth = 30;
     frameLeftOffset = 10; // 2007 hwu
     frameRightOffset = 0;
     frameTopOffset = 0;
     frameBottomOffset = 0;
     graphStyle = 0;
     aFrame.leftTimeLabel = true;
     aFrame.absTimeDisplay = false;
     aFrame.histogramPosition = 1;
     aFrame.frameForeColor = Color.gray;
     aFrame.frameFont = new Font("MonoSpaced", Font.PLAIN, 12);
     caption = "test";
     displayMode = AcopConst.mode_polyline; // AcopConst.mode_histogram;
     setGlobalDisplayMode();
     e_xmin = 0;
     e_xmax = 100;
     drawWidth = 1; // 1 pixel
     drawStyle = AcopConst.PS_SOLID;// DASH_DOT ;//AcopConst.PS_SOLID;
     e_ymin = -100;
     e_ymax = 100;
     // penLine = new BasicStroke(3);
     m_lock = 0;
     screenDepth = 20;
     n_display = screenDepth;
     textDepth = 20;
     n_text = textDepth; // copConst.MAX_TEXT;
     m_filled = 0;
     barlineColorFilled = 0;
     wrapxmin = -1.7e+308;
     wrapxmax = 1.7e+308; // wrap x range
     zoomIndex = 0;
     zoomLogFlag = 0;
     zooming = 7;  // 2007 hwo buffered zooming   3;
     isZoomed = false;
     zoomFlag = false;
     reuseScreen = false;
     reuseText = false;
     XExtent = 0;
     YExtent = 0;
     xlabelRotation = 0;
     foreColor = getForeground();
     backColor = getBackground();
     wrapAround = false;
     printTextStickyAttribute = 0;
     printTextLocation = 0;
     printTextRotation = 0;
     LeadingEdgeColor = getForeground();
     LeadingEdgeGapSize = 0;
     LeadingEdgeMotion = 0;
     LeadingEdgeMode = 0;
     LeadingEdgeWidth = 1;
     LeadingEdgeStyle = AcopConst.PS_SOLID;
     LeadingEdgeXExtent = -1;
     LeadingEdgeYExtent = -1;
     yRASize = yRAdataSize = 0;
     yWASize = yWAdataSize = 0;
     fLeft = 0;
     fRight = 0;
     fTop = 0;
     fBottom = 0;
     fLeftPixel = 0;
     fRightPixel = 0;
     fTopPixel = 0;
     fBottomPixel = 0;
     frameBorderOn = true;
     if ((zooming & 0x7) != 0) setZoomingWindow(zooming & 0x4);
     scaleFrameDraw();
     if (Beans.isDesignTime() && randomData == true)
     {
       prepareDraw();
       // System.out.println("DesignTime and RandomData");
     }
     // if ( randomData == true ) prepareDraw();
     enableEvents(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK | AWTEvent.COMPONENT_EVENT_MASK);
     // }}
   }
   // {{DECLARE_CONTROLS
   // }}
 
 //  public void addPropertyChangeListener(String s, java.beans.PropertyChangeListener pcl)
 //  {
 //    System.out.println(" property change!!!" + s);
 //    if ( s.equals("background") ) System.out.println("  background event!!!");
 //    this.addPropertyChangeListener(
 //        new PropertyChangeListener() {
 //          public void propertyChange(PropertyChangeEvent e)
 //            {
 //                if (e.getPropertyName().equals("background")) {
 //                  System.out.println("  background event!!!"); // TODO Auto-generated Event stub AcopMouseClick()              
 //                }
 //            }
 //        }          
 //    );
 //  }
 
   //  public void this. .addPropertyChangeListener("foreground", new PropertyChangeListener()
 //      {
     //public void propertyChange(PropertyChangeEvent event)
     //{
     //}
 //    });
 
   
   public int lockCursorMarker(boolean Enable)
   {
     return lockCursorMarker(Enable, false, 0, false, 0);
   }
   public int lockCursorMarker(boolean Enable, double Xposition, double Yposition)
   {
     return lockCursorMarker(Enable, true, Xposition, true, Yposition);
   }
   public int lockCursorMarker(boolean Enable, boolean xInput, double Xposition, boolean yInput,
       double Yposition)
   {
     int on;
     if (m_cursorMarkerMode == 0) return -1; // has to turn mode on first!
     on = Enable ? 1 : 0;
     cursorStay = on;
     if (cursorStay > 0)
     {
       if (xInput)
         mMovePoint.x = sca[0].getScreenPosition(Xposition);
       else
         Xposition = sca[0].getUserPosition(mMovePoint.x);
       if (yInput)
         mMovePoint.y = sca[1].getScreenPosition(Yposition);
       else
         Yposition = sca[1].getUserPosition(mMovePoint.y);
       cursorXposition = Xposition;
       cursorYposition = Yposition;
     }
     if (aFrame.drawFlag) repaintHisto();
     return on;
   }
   private void drawCursorMarker(Graphics2D g2d, Point point)
   { int modeTmp;
     Rectangle Cliprect = null;
     int initFlag = g2d == null ? 0 : 1;
     if (g2d == null) // called from mouse move, first map and clip, then remove
                       // previous line first
     {
       g2d = (Graphics2D) getGraphics();
       Cliprect = g2d.getClipBounds();
       if (Cliprect != null)
       {
         if (Cliprect.intersects(histRoundRect) == false) return;
       }
     }
     g2d.setXORMode(rev_cursorMarkerColor);
 //    g2d.setXORMode(m_cursorMarkerColor);
     // g2d.setColor(m_cursorMarkerColor);
     g2d.setStroke(cursorMarkerStroke);
     if (initFlag == 0) // called from mouse move, first map and clip, then
                         // remove previous line first
     {
       g2d.clipRect(histRoundRect.x, histRoundRect.y, histRoundRect.width, histRoundRect.height);
       // g2d.translate(aFrame.histRect.x, aFrame.histRect.y);
       if (cursorMarkerFlag == 2) // already onscreen, repaint it without the cursor line
       {
         modeTmp = m_cursorMarkerMode;
         m_cursorMarkerMode = 0;
         paintImmediately(histRoundRect);
         m_cursorMarkerMode = modeTmp;
       }
       else if (cursorMarkerFlag != 0) // if already onscreen, remove previous line first
       {
         if ((m_cursorMarkerMode & 0x2) != 0)
           g2d.drawLine(cursorwy, cursorwx - cursoriy, cursorwy, cursorwx + cursoriy);
         if ((m_cursorMarkerMode & 0x1) != 0)
           g2d.drawLine(cursorwy - cursorix, cursorwx, cursorwy + cursorix, cursorwx);
       }
     }
     // calculate new position
     cursorwx = point.y;
     cursorwy = point.x;
     if (initFlag != 0)
     {
       cursorwx -= aFrame.histRect.y;  // 2009-1 bug fix
       cursorwy -= aFrame.histRect.x;
     }
     if ((m_cursorMarkerMode & 0x1) != 0)
     {
       if (initFlag != 0)
       {
         if (cursorXPercent < 0)
         {
           if (m_cursorMarkerXExtent < 0)
             cursorXPercent = 1;
           else
             cursorXPercent = ((sca[0].log != 0) ? Math.log(m_cursorMarkerXExtent) / Math.log(10)
                 : m_cursorMarkerXExtent)
                 / (sca[0].tick_max - sca[0].tick_min) / 2;
         }
         cursorix = (int) (aFrame.histRect.width * cursorXPercent);
       }
       g2d.drawLine(cursorwy - cursorix, cursorwx, cursorwy + cursorix, cursorwx);
     }
     if ((m_cursorMarkerMode & 0x2) != 0)
     {
       if (initFlag != 0)
       {
         if (cursorYPercent < 0)
         {
           if (m_cursorMarkerYExtent < 0)
             cursorYPercent = 1;
           else
             cursorYPercent = ((sca[1].log != 0) ? Math.log(m_cursorMarkerYExtent) / Math.log(10)
                 : m_cursorMarkerYExtent)
                 / sca[1].dispSize / 2;
         }
         cursoriy = (int) (aFrame.histRect.height * cursorYPercent);
       }
       g2d.drawLine(cursorwy, cursorwx - cursoriy, cursorwy, cursorwx + cursoriy);
     }
     g2d.setPaintMode();
     if (initFlag == 0)
     {
       // g2d.translate(-aFrame.histRect.x, -aFrame.histRect.y);
       g2d.setClip(Cliprect);
       g2d.dispose();
     }
     if (initFlag != 0)
     {
       cursorwx += aFrame.histRect.y;  // 2009-1 bug fix
       cursorwy += aFrame.histRect.x;
     }
     cursorMarkerFlag = initFlag == 1 ? 2 : 1; // cursor is on screen!
   }
   private void setZoomingWindow(int bufferedZoomFlag)
   {
     aFrame.ZoomExtent = bufferedZoomFlag != 0 ? 20 : 36;
     // zoom icon indicator
     aFrame.zoomIcon.setBounds(aFrame.histRect.x + aFrame.histRect.width - aFrame.ZoomExtent,
         aFrame.histRect.y + 1, aFrame.ZoomExtent - 1, aFrame.ZoomExtent - 1);
   }
   public java.lang.String getPrintedText(double[] leftBottom, double[] size, double[] position, int hText)
   {
     if (hText < 0 || hText >= n_text || ptext[hText] == null) return "Input Error!";
     return ptext[hText].getPrintedText(leftBottom, size, position);
   }
   public boolean isZoomed()
   {
     return this.isZoomed;
   }
   public int getHistogramOffsetLeft()
   {
     return aFrame.xleft;
   }
   public int getHistogramOffsetRight()
   {
     return aFrame.histRect.width - aFrame.xright;
   }
   public double getScaleLeft()
   {
     return sca[0].getMin();
   }
   public double getScaleRight()
   {
     return sca[0].getMax();
   }
   public double getScaleTop()
   {
     return sca[1].getMax();
   }
   public double getScaleBottom()
   {
     return sca[1].getMin();
   }
   private int loadAxis(int index, boolean AxisOn, Object PositionArray, int ArraySize, Color[] ColorArray,
       int[] StyleArray, int[] WidthArray)
   {
     int ret;
     ret = axis[index].axisON != AxisOn ? 1 : 0;
     axis[index].axisON = AxisOn;
     if (ArraySize < 1 && ArraySize != -1) return -1; // wrong input
     if (ArraySize != -1)
       ret += axis[index].loadData(ArraySize, PositionArray, ColorArray, StyleArray, WidthArray);
     if (ret != 0 && aFrame.drawFlag) repaintHisto();
     return 0;
   }
   public int xAxis(boolean AxisOn)
   {
     return loadAxis(0, AxisOn, null, -1, null, null, null);
   }
   public int yAxis(boolean AxisOn)
   {
     return loadAxis(1, AxisOn, null, -1, null, null, null);
   }
   public int xAxis(boolean AxisOn, Object PositionArray, int ArraySize, Color[] ColorArray, int[] StyleArray,
       int[] WidthArray)
   {
     return loadAxis(0, AxisOn, PositionArray, ArraySize, ColorArray, StyleArray, WidthArray);
   }
   public int yAxis(boolean AxisOn, Object PositionArray, int ArraySize, Color[] ColorArray, int[] StyleArray,
       int[] WidthArray)
   {
     return loadAxis(1, AxisOn, PositionArray, ArraySize, ColorArray, StyleArray, WidthArray);
   }
   public int refreshScreen(Object Yarray, int hDisplay, int Npoints, int StartIndex, Object Xarray)
   {
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     return histo[hDisplay].updateScreen(false, Yarray, Npoints, StartIndex, Xarray);
   }
   public int refreshScreen(Object Yarray, int hDisplay, Object Xarray)
   {
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     return histo[hDisplay].updateScreen(false, Yarray, -1, -1, Xarray);
   }
   public int refreshScreen(Object Yarray, int hDisplay)
   {
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     return histo[hDisplay].updateScreen(false, Yarray, -1, -1, null);
   }
   public int appendScreen(Object Yarray, int hDisplay, int Npoints, int StartIndex, Object Xarray)
   {
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     return histo[hDisplay].updateScreen(true, Yarray, Npoints, StartIndex, Xarray);
   }
   public int appendScreen(Object Yarray, int hDisplay, Object Xarray)
   {
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     return histo[hDisplay].updateScreen(true, Yarray, -1, -1, Xarray);
   }
   public int appendScreen(Object Yarray, int hDisplay)
   {
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null) return -1;
     return histo[hDisplay].updateScreen(true, Yarray, -1, -1, null);
   }
   public int draw(Object ydata)
   {
     return draw(ydata, null, null, null, 0, 0);
   }
   
   public int draw(Object ydata, Object xdata, boolean bindToSecondaryAxis) {
 	  return draw(ydata, xdata, null, null, 0, 0,bindToSecondaryAxis);
   }
   public int draw(Object ydata, Object xdata)
   {
     return draw(ydata, xdata, null, null, 0, 0);
   }
   public int draw(Object ydata, Object xdata, Object disable)
   {
     return draw(ydata, xdata, disable, null, 0, 0);
   }
   public int draw(Object ydata, Object xdata, Object disable, java.lang.String[] xlabel)
   {
     return draw(ydata, xdata, disable, xlabel, 0, 0);
   }  
   public int draw(Object ydata, Object xdata, Object disable, java.lang.String[] xlabel, int ArraySize,
 	      int MaxNumber) {
 	  return draw(ydata,xdata,disable,xlabel,ArraySize,MaxNumber,false);
   }
   
   public int draw(Object ydata, Object xdata, Object disable, java.lang.String[] xlabel, int ArraySize,
       int MaxNumber, boolean bindToSecondaryAxis)
   {
     int i, tmp;
     if (m_lock == n_display) return -1; // no free slot to draw
     // this slot should not be overwrite
     if (aFrame.drawFlag == true && histo[loadXYindex] != null && histo[loadXYindex].displayON == 1)
     {
       // find next free slot
       for (i = loadXYindex + 1, tmp = 0; tmp < n_display; i++, tmp++)
       {
         if (i == n_display)
         {
           i = 0;
           m_filled = 1;
         }
         if (histo[i] == null || (histo[i].lockFlag == 0 && histo[i].displayON == 0))
           break;
         else if (reuseScreen && histo[i].lockFlag == 0) break;
       }
       if (tmp < n_display)
         loadXYindex = i;
       else
         return -2; // no free slot to draw
     }
     if (histo[loadXYindex] == null)
     {
       histo[loadXYindex] = new AcopHisto(this, loadXYindex);
       if (loadXYindex == 0 && aFrame.drawFlag == false && textFlag == true)
         rescaleTextFlag = AcopConst.NEW_PRINT_WINDOW;
       if (loadXYindex == 0 && textFlag == false) // first time;
       {
       }
     }
     if (histo[loadXYindex].setHisto(ydata, xdata, disable, xlabel, ArraySize, MaxNumber, foreColor) != 0)
       return -3;
     // if ( aFrame.drawFlag == false && textFlag == false ) drawTicks = true;
     if (aFrame.drawFlag == false)
       drawTicks = true;
     else
       drawTicks = false;
     // if ( histo[0].displayON != 0 ) repainHisto = true; // it was On
     if (aFrame.drawFlag == true && histo[loadXYindex].displayON == 0) repainHisto = true; // it
                                                                                           // was
                                                                                           // On
     aFrame.drawFlag = true;
     histo[loadXYindex].displayON = 1;
     histo[loadXYindex].dismode = globalDisplayMode;
     histo[loadXYindex].disDots = enableDots;
     histo[loadXYindex].disBarHisto = enableBarlineHisto;
     histo[loadXYindex].xext = XExtent;
     histo[loadXYindex].yext = YExtent;
     histo[loadXYindex].colorfilled = colorFilled;
     histo[loadXYindex].barlineColorFilled = barlineColorFilled;
     if (m_keep == 0)
     {
       if (m_filled != 0 && m_lock == 0) // no refrence!
       {
         m_histstart = loadXYindex + 1;
         if (m_histstart >= n_display) m_histstart = 0;
       }
     }
     else
     // move start pointer, change lasthist to keeppen
     {
       if (m_numberkeep == m_keep)
       {
         histo[m_keepstart].displayON = 0; // turn off one
         if (m_lock == 0) for (i = ++m_keepstart;; i++) // find histstart
           {
             if (i >= n_display) i = 0;
             if (i == loadXYindex) break;
             if (histo[i].displayON != 0)
             {
               m_histstart = i;
               break;
             }
           }
       }
     }
     if (wrapAround)
       histo[loadXYindex].getMaxWindow();
     else
       histo[loadXYindex].wrapindex = 0;
     histIndex = loadXYindex;
     lastDisp = loadXYindex;
     
       if (loadXYindex < 0 || loadXYindex >= n_display) return -1;
       if (histo[loadXYindex] != null && histo[loadXYindex].displayON != 0 && histo[loadXYindex].lockFlag == 0)
       {
         histo[loadXYindex].bindSecondaryY = bindToSecondaryAxis;
       }
     
     prepareDraw();
     m_keep = 0;
     return (loadXYindex);
   }
   public void clearScreen()
   {
     clearScreen(-1, 0);
   }
   public void clearScreen(int hDisplay)
   {
     clearScreen(hDisplay, 0);
   }
   public void clearScreen(int hDisplay, int KeepDepth)
   {
     int i, j, num, tmp;
     if (aFrame.drawFlag == false) return;
     m_keep = KeepDepth; // number of kepted histogram
     if (m_keep < 0 || m_keep >= n_display) m_keep = 0;
     num = hDisplay; // histo number to be turned off
     if (num < 0 || num >= n_display) num = -1;
     // RedrawTextHist = 1;
     if (m_keep == 0 && num < 0) // turn all off, if not locked
     {
       if (m_lock == 0) // no locked histo, then reset
       {
         if (textFlag == false) drawTicks = true;
         aFrame.drawFlag = false;
         m_filled = 0;
         m_histstart = 0;
         loadXYindex = 0; // reset index, make displayflag to FALSE
         // if ( modeChange == TRUE )
         // {
         // drawTicks = TRUE;
         // modeChange = FALSE;
         // }
       }
       for (i = 0; i < n_display; i++)
         if (histo[i] != null && histo[i].lockFlag == 0) histo[i].displayON = 0;
     }
     else
     {
       if (num >= 0) // clear hist num
       {
         if (histo[num] != null && histo[num].displayON != 0 && histo[num].lockFlag == 0)
         {
           histo[num].displayON = 0;
           if (num == m_histstart) // change m_histstart to next visible histo
           {
             for (i = 0, j = m_histstart; i < n_display; i++, j++) // is all
                                                                   // histo off?
             {
               if (j >= n_display) j = 0;
               if (histo[j] != null && histo[j].displayON != 0)
               {
                 m_histstart = num;
                 break;
               }
             }
           }
         }
         else if (m_keep == 0) return; // already off -> nothing changed
       }
       if (m_keep > n_display - m_lock) m_keep = n_display - m_lock;
       if (m_keep != 0) // keep # of background histograms
       { // find keep start
         for (m_numberkeep = tmp = j = 0, i = loadXYindex + 1; j < m_keep;)
         {
           if (--i < 0) i += n_display;
           if (histo[i] == null || histo[i].lockFlag == 0) j++; // keep empty or
                                                                 // notlocked
           if (histo[i] != null && histo[i].displayON != 0)
           {
             tmp++; // # of displayON
             if (histo[i].lockFlag == 0)
             {
               // turn keep to keep-pen, -color....
               histo[i].keephisto();
               m_numberkeep++;
               m_keepstart = i; // keephisto start #
               // hide tagging display for this keeped histogram!
               if (histo[i].dismode == AcopConst.mode_histogram
                   || histo[i].dismode == AcopConst.mode_histogram_rastoring
                   || histo[i].dismode == AcopConst.mode_dots || histo[i].dismode == AcopConst.mode_rectangle
                   || histo[i].dismode == AcopConst.mode_circle) histo[i].tagHist = 0;
             }
           }
         }
         if (m_lock == 0 && m_numberkeep != 0) m_histstart = m_keepstart; // first
                                                                           // visible
                                                                           // histo
         aFrame.drawFlag = (m_lock != 0 || tmp != 0) ? true : false;
         if (textFlag == false && aFrame.drawFlag == false) drawTicks = true;
         for (j = loadXYindex + 1;; j++) // turn rest off
         {
           if (j >= n_display) j = 0;
           if (j == i) break;
           if (histo[j] != null && histo[j].lockFlag == 0) histo[j].displayON = 0;
         }
       }
       else
       { // is all histo off?
         for (i = 0, j = m_histstart; i < n_display; i++, j++)
         {
           if (j >= n_display) j = 0;
           if (histo[j] != null && histo[j].displayON != 0) break;
         }
         if (i == n_display)
         {
           aFrame.drawFlag = false;
           if (textFlag == false) drawTicks = true;
         }
       }
     }
     if (drawTicks || histo[m_histstart].dismode >= AcopConst.mode_textbox
         || (aFrame.drawFlag == false && textFlag == false))
       this.repaint();
     else
       repaintHisto();
   }
   public void recallScreen(int hDisplay)
   {
     int num;
     num = hDisplay; // number to be turned on
     if (num < 0 || num >= n_display) return;
     if (histo[num] == null) return;
     if (aFrame.drawFlag == false && m_lock == 0) m_histstart = num;
     if (histo[num].displayON == 0)
     {
       // RedrawTextHist = 1;
       histo[num].displayON = 1;
       aFrame.drawFlag = true;
       if (histo[num].dismode == AcopConst.mode_histogram
           || histo[num].dismode == AcopConst.mode_histogram_rastoring
           || histo[num].dismode == AcopConst.mode_dots || histo[num].dismode == AcopConst.mode_rectangle
           || histo[num].dismode == AcopConst.mode_circle)
       { // bring to top histogram!
         histo[num].tagHist = 1;
         lastTagHisto = num;
       }
       lastDisp = num;
       // find wrapindex
       if (wrapAround && sca[0].log == 0) histo[num].setwrapindex();
       // prepareDraw(FALSE,num,FALSE, 0);
       if (drawTicks)
       {
         this.repaint();
         drawTicks = false;
       }
       else
         drawOneHist(num);
     }
   }
   public long lockScreen(int LockOn, int hDisplay)
   {
     int num, ende, lock, i;
     lock = LockOn; // lock all the histo you see! (<0, 0, >0)
     num = hDisplay; // or unlock them as user requested
     if (num < 0 || num >= n_display)
     {
       num = 0;
       ende = n_display - 1;
     }
     else
     {
       ende = num;
     }
     if (lock < 0) // return current lock flag (ON or OFF) -> read only
     {
       if (num != ende)
         return m_lock; // number of locked histos
       else
         return histo[num] != null ? histo[num].lockFlag : -1;
     }
     else if (lock > 0 && aFrame.drawFlag == false) return -1; // nothing to lock
     for (i = num; num <= ende; num++)
     {
       if (histo[num] == null) continue;
       if (lock == 0) // unlock
       {
         if (histo[num].lockFlag == 1)
         {
           histo[num].lockFlag = 0;
           m_lock--;
         }
       }
       else if (histo[num].displayON != 0) // lock it if on the screen
       {
         if (histo[num].lockFlag == 0)
         {
           histo[num].lockFlag = 1;
           // first locked as histstart
           if (m_lock++ == 0 && num != m_histstart) m_histstart = num;
         }
       }
     }
     return (i != ende) ? m_lock : (histo[num] == null ? 0 : histo[ende].lockFlag);
   }
   public int printText(java.lang.String Text)
   {
     return callPrintText(Text, 0, 0, false);
   }
   public int printText(java.lang.String Text, double Xposition, double Yposition)
   {
     return callPrintText(Text, Xposition, Yposition, true);
   }
   protected int callPrintText(java.lang.String Text, double Xposition, double Yposition, boolean positionFlag)
   {
     int resca, i, firstDraw;
     if (Text.indexOf(13) == 0) return -1; // linefeed in the begining
     // the current visible slot should not be overwrite
     if (textFlag == true && ptext[loadTextIndex] != null && ptext[loadTextIndex].textON == true)
     {
       // find next free slot
       for (i = loadTextIndex + 1, resca = 0; resca < n_text; i++, resca++)
       {
         if (i == n_text) i = 0;
         if (ptext[i] == null)
         {
           ptext[i] = new AcopText(this);
           break;
         }
         else if (ptext[i].textON == false)
           break;
         else if (reuseText) break;
       }
       if (resca < n_text)
       {
         loadTextIndex = i;
       }
       else
       {
         return -1; // no free slot to prntText
       }
     }
     firstDraw = 0;
     if (ptext[loadTextIndex] == null)
     {
       ptext[loadTextIndex] = new AcopText(this);
       if (loadTextIndex == 0 && aFrame.drawFlag == false)
       {
         firstDraw = 1;
         setlimit(); // load m_xmin... ...
         sca[0].scaleToGrid();
         for (i = 0; i < 3; i++)
           sca[i].xyscale(true); // set new min max
         scaleframe();
         aFrame.xleft = 0;
         aFrame.xright = aFrame.histRect.width;
         aFrame.dxwidth = aFrame.xright - aFrame.xleft;
         aFrame.absxleft = aFrame.xleft + aFrame.histRect.x;
       }
     }
     if (positionFlag == false) // load last positions
     {
       Xposition = lastTextx;
       Yposition = lastTexty;
     }
     if (ptext[loadTextIndex].printText(Text, Xposition, Yposition, foreColor, getFont()) == 0)
     {
       // i = loadTextIndex;
       // if ( ++loadTextIndex == n_text ) loadTextIndex = 0;
       // return i;
       // store last positions
       lastTextx = ptext[loadTextIndex].lastTextx;
       lastTexty = ptext[loadTextIndex].lastTexty;
       if (firstDraw != 0) repaint();
       // resca = loadTextIndex;
       // if ( ++loadTextIndex == n_text ) loadTextIndex = 0;
       // if ( disp[0] == 0 && scalecall < 2 ) {
       // InvalidateControl(NULL); // draw ticks and grid...if no histo at all
       // scalecall = 2;
       // }
       return (loadTextIndex);
     }
     return -1;
   }
   public void clearText()
   {
     clearText(-1);
   }
   public void clearText(int hText)
   {
     int start, ende, i, cnt;
     start = hText;
     if (start < 0 || start >= n_text)
     {
       start = 0;
       ende = n_text - 1;
     }
     else
       ende = start;
     for (cnt = 0, i = 0; i < n_text; i++)
     {
       if (ptext[i] == null) continue;
       if (ptext[i].textON == false) continue;
       if (i >= start && i <= ende)
       {
         ptext[i].textON = false;
         if (ptext[i].outside == false)
           this.repaint(ptext[i].textRect.x, ptext[i].textRect.y, ptext[i].textRect.width,
               ptext[i].textRect.height);
       }
       else
         cnt++;
     }
     textFlag = cnt != 0 ? true : false;
     if (textFlag == false)
     {
       // scalecall = 0;
       if (aFrame.drawFlag == false)
       {
         this.repaint();
         drawTicks = true;
       }
     }
     if (start != ende) loadTextIndex = 0;
   }
   public void recallText(int hText)
   {
     int start;
     start = hText;
     if (start < 0 || start >= n_text) return;
     if (ptext[start] == null || ptext[start].textON == true) return;
     // if ( ptext[start].moveable && ptext[start].rescaled ) rescaleText(start,
     // ptext[start]->moveable, FALSE, ptext[start]->scalable);
     textFlag = true;
     ptext[start].textON = true;
     ptext[start].rescaleText(0); // use intern flag
     if (ptext[start].outside == true) return;
     if (drawTicks)
     {
       this.repaint();
       drawTicks = false;
     }
     else
       ptext[start].printUserText(null);
   }
   public int refreshText(java.lang.String Text, int hText)
   {
     if (hText < 0 || hText >= n_text || ptext[hText] == null) return -1;
     ptext[hText].refreshText(Text);
     return hText;
   }
   public void setAveragingDepth(int averagingDepth)
   {
     if (this.averagingDepth == averagingDepth) return;
     if (averagingDepth < 2 || averagingDepth > AcopConst.N_DEF_DISPLAY) averagingDepth = 0;
     averagingIndex = 0;
     averagingLength = 0;
     NumberAveragingData = 0;
     int oldValue = this.averagingDepth;
     this.averagingDepth = averagingDepth;
     firePropertyChange("averagingDepth", oldValue, this.averagingDepth);
   }
   public int getAveragingDepth()
   {
     return this.averagingDepth;
   }
   public void setAveragingMode(int averagingMode)
   {
     if (this.averagingMode == averagingMode || averagingMode < 0 || averagingMode > 1) return;
     int oldValue = this.averagingMode;
     this.averagingMode = averagingMode;
     firePropertyChange("averagingMode", oldValue, this.averagingMode);
   }
   public int getAveragingMode()
   {
     return this.averagingMode;
   }
   public void setCaption(java.lang.String caption)
   {
 //    if (this.caption != null && this.caption.equals(caption)) return; 
     captionChanged = true;
     String oldValue = this.caption;
     this.caption = caption;
     this.repaint(titleRect.x, titleRect.y, titleRect.width, titleRect.height);
     firePropertyChange("caption", oldValue, this.caption);
   }
   public java.lang.String getCaption()
   {
     return this.caption;
   }
   public void setCaptionLocation(int captionPosition)
   {
 	if (this.captionPosition == captionPosition) return;
 	int oldValue = this.captionPosition;
     this.captionPosition = captionPosition;
     this.repaint(titleRect.x, titleRect.y, titleRect.width, titleRect.height);
     firePropertyChange("captionPosition", oldValue, this.captionPosition);
   }
   public int getCaptionLocation()
   {
     return this.captionPosition;
   }
   public void setDisplayMode(int displayMode)
   // throws PropertyVetoException
   {
     if (this.displayMode == displayMode) return;
     /*
      * Integer oldValue = new Integer(this.displayMode); Integer newValue = new
      * Integer(displayMode); veto.fireVetoableChange("displayMode" ,oldValue,
      * newValue); this.displayMode = displayMode;
      * changes.firePropertyChange("displayMode" ,oldValue, newValue); if (
      * displayMode < AcopConst.mode_polyline ) displayMode =
      * AcopConst.mode_polyline; if ( displayMode > AcopConst.mode_textbox )
      * displayMode = AcopConst.mode_textbox;
      */
     if (displayMode < AcopConst.mode_polyline || displayMode > AcopConst.mode_barline_histo_dots) return;
     int oldValue = this.displayMode;
     this.displayMode = displayMode;
     setGlobalDisplayMode();
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("displayMode", oldValue, this.displayMode);
   }
   public int getDisplayMode()
   {
     return this.displayMode;
   }
   public void setDrawWidth(int drawWidth)
   {
     if (this.drawWidth == drawWidth) return;
     if (drawWidth < 1) drawWidth = 1;
     int oldValue = this.drawWidth;
     this.drawWidth = drawWidth;
     if (randomData == true) repaintHisto();
     // prepareDraw(2, -1); // rescale and reset limit
     firePropertyChange("drawWidth", oldValue, this.drawWidth);
   }
   public int getDrawWidth()
   {
     return this.drawWidth;
   }
   private void checkRange(int flag, double value)
   {
     if ( flag == 1 )  // xMin input
     {
       if (sca[0].usermax <= value + AcopConst.zero_check)
       {
         if (Math.abs(value) < AcopConst.zero_check)
           sca[0].usermax = value + 10;
         else
           sca[0].usermax = value + 0.5 * Math.abs(value);
       }
       sca[0].setUserscale(value, sca[0].usermax);
     }
     else if ( flag == 2 )  // xMax input
     {
       if (value <= sca[0].usermin + AcopConst.zero_check)
       {
         if (Math.abs(value) < AcopConst.zero_check)
           sca[0].usermin = value - 10;
         else
           sca[0].usermin = value - 0.5 * Math.abs(value);
       }
       sca[0].setUserscale(sca[0].usermin, value);     
     }
     else if ( flag == 3 )
     {
       if (sca[1].usermax <= value + AcopConst.zero_check)
       {
         if (Math.abs(value) < AcopConst.zero_check)
           sca[1].usermax = value + 10;
         else
           sca[1].usermax = value + 0.5 * Math.abs(value);
       }
       sca[1].setUserscale(value, sca[1].usermax);
     }
     else if ( flag == 4 )
     {
       if (value <= sca[1].usermin + AcopConst.zero_check)
       {
         if (Math.abs(value) < AcopConst.zero_check)
           sca[1].usermin = value - 10;
         else
           sca[1].usermin = value - 0.5 * Math.abs(value);
       }
       sca[1].setUserscale(sca[1].usermin, value);
     }
   }
   public void setXRange(double xMin, double xMax)
   {
     if (Math.abs(sca[0].usermin - xMin) < AcopConst.zero_check) return;
     if (Math.abs(sca[0].usermax - xMax) < AcopConst.zero_check) return;
     double oldValue = sca[0].usermin;
     double oldValueMax = sca[0].usermax;
     drawTicks = true;
     checkRange(1, xMin);
     checkRange(2, xMax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("xMin", oldValue, sca[0].usermin);
     firePropertyChange("xMax", oldValueMax, sca[0].usermax);
   }
   public void setYRange(double yMin, double yMax)
   {
     if (Math.abs(sca[1].usermin - yMin) < AcopConst.zero_check) return;
     if (Math.abs(sca[1].usermax - yMax) < AcopConst.zero_check) return;
     double oldValue = sca[1].usermin;
     double oldValueMax = sca[1].usermax;
     drawTicks = true;
     checkRange(3, yMin);
     checkRange(4, yMax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("yMin", oldValue, sca[1].usermin);
     firePropertyChange("yMax", oldValueMax, sca[1].usermax);
   }
   public void setXYRange(double xMin, double xMax, double yMin, double yMax)
   {
     if (Math.abs(sca[0].usermin - xMin) < AcopConst.zero_check) return;
     if (Math.abs(sca[0].usermax - xMax) < AcopConst.zero_check) return;
     if (Math.abs(sca[1].usermin - yMin) < AcopConst.zero_check) return;
     if (Math.abs(sca[1].usermax - yMax) < AcopConst.zero_check) return;
     double oldValue = sca[0].usermin;
     double oldValueMax = sca[0].usermax;
     double oldValueY = sca[1].usermin;
     double oldValueYMax = sca[1].usermax;
     drawTicks = true;
     checkRange(1, xMin);
     checkRange(2, xMax);
     checkRange(3, yMin);
     checkRange(4, yMax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("xMin", oldValue, sca[0].usermin);
     firePropertyChange("xMax", oldValueMax, sca[0].usermax);
     firePropertyChange("yMin", oldValueY, sca[1].usermin);
     firePropertyChange("yMax", oldValueYMax, sca[1].usermax);
   }
   public void setXMin(double xMin)
   {
     if (Math.abs(sca[0].usermin - xMin) < AcopConst.zero_check) return;
     double oldValue = sca[0].usermin;
     drawTicks = true;
     if (sca[0].usermax <= xMin + AcopConst.zero_check)
     {
       if (Math.abs(xMin) < AcopConst.zero_check)
         sca[0].usermax = xMin + 10;
       else
         sca[0].usermax = xMin + 0.5 * Math.abs(xMin);
     }
 
     sca[0].setUserscale(xMin, sca[0].usermax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("xMin", oldValue, sca[0].usermin);
     // prepareDraw(TRUE, -1, TRUE, 0);
   }
   public double getXMin()
   {
     return sca[0].usermin;
   }
   public void setXMax(double xMax)
   {
     if (Math.abs(sca[0].usermax - xMax) < AcopConst.zero_check) return;
     double oldValue = sca[0].usermax;
     drawTicks = true;
     if (xMax <= sca[0].usermin + AcopConst.zero_check)
     {
       if (Math.abs(xMax) < AcopConst.zero_check)
         sca[0].usermin = xMax - 10;
       else
         sca[0].usermin = xMax - 0.5 * Math.abs(xMax);
     }
 
     sca[0].setUserscale(sca[0].usermin, xMax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("xMax", oldValue, sca[0].usermax);
   }
   public double getXMax()
   {
     return sca[0].usermax;
   }
   public void setYMin(double yMin)
   {
     if (Math.abs(sca[1].usermin - yMin) < AcopConst.zero_check) return;
     double oldValue = sca[1].usermin;
     if (m_marker == 2) setmarkerflag(2); // store origin value
     drawTicks = true;
     if (sca[1].usermax <= yMin + AcopConst.zero_check)
     {
       if (Math.abs(yMin) < AcopConst.zero_check)
         sca[1].usermax = yMin + 10;
       else
         sca[1].usermax = yMin + 0.5 * Math.abs(yMin);
     }
 
     sca[1].setUserscale(yMin, sca[1].usermax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("yMin", oldValue, sca[1].usermin);
   }
   public double getYMin()
   {
     return sca[1].usermin;
   }
   public void setYMax(double yMax)
   {
     if (Math.abs(sca[1].usermax - yMax) < AcopConst.zero_check) return;
     double oldValue = sca[1].usermax;
     if (m_marker == 2) setmarkerflag(2); // store origin value
     drawTicks = true;
     if (yMax <= sca[1].usermin + AcopConst.zero_check)
     {
       if (Math.abs(yMax) < AcopConst.zero_check)
         sca[1].usermin = yMax - 10;
       else
         sca[1].usermin = yMax - 0.5 * Math.abs(yMax);
     }
     
     sca[1].setUserscale(sca[1].usermin, yMax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("yMax", oldValue, sca[1].usermax);
   }
   public double getYMax()
   {
     return sca[1].usermax;
   }
   public void setSecondaryYMin(double SecondaryYMin)
   {
     if (Math.abs(sca[2].usermin - SecondaryYMin) < AcopConst.zero_check) return;
     double oldValue = sca[2].usermin;
     if (sca[2].usermax <= SecondaryYMin + AcopConst.zero_check)
     {
       if (Math.abs(SecondaryYMin) < AcopConst.zero_check)
         sca[2].usermax = SecondaryYMin + 10;
       else
         sca[2].usermax = SecondaryYMin + 0.5 * Math.abs(SecondaryYMin);
     }
     
     sca[2].setUserscale(SecondaryYMin, sca[2].usermax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("secondaryYMin", oldValue, SecondaryYMin);
   }
   public double getSecondaryYMin()
   {
     return sca[2].usermin;
   }
   public void setSecondaryYMax(double setSecondaryYMax)
   {
     if (Math.abs(sca[2].usermax - setSecondaryYMax) < AcopConst.zero_check) return;
     double oldValue = sca[2].usermax;
     if (setSecondaryYMax <= sca[2].usermin + AcopConst.zero_check)
     {
       if (Math.abs(setSecondaryYMax) < AcopConst.zero_check)
         sca[2].usermin = setSecondaryYMax - 10;
       else
         sca[2].usermin = setSecondaryYMax - 0.5 * Math.abs(setSecondaryYMax);
     }
    
     sca[2].setUserscale(sca[2].usermin, setSecondaryYMax);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
     firePropertyChange("secondaryYMax", oldValue, setSecondaryYMax);
   }
   public double getSecondaryYMax()
   {
     return sca[2].usermax;
   }
   private void scaleFrameDraw()
   {
     scaleframe();
     //    rescaleFlag = 1; //2005-Feb
     drawTicks = true;     // 2009-4 fix problem of ""The AcopChart is not repainted or validated when its size changes."
     rescaleTextFlag = AcopConst.NEW_TEXT_WINDOW;
     if (aFrame.drawFlag)
       prepareDraw();
     else
       changeScaleWidth = 0;
   }
   public void setFrameWidth(int frameWidth)
   {
     if (this.frameWidth == frameWidth) return;
     int oldValue = this.frameWidth;
     this.frameWidth = frameWidth;
     scaleFrameDraw();
     firePropertyChange("frameWidth", oldValue, this.frameWidth);
   }
   public int getFrameWidth()
   {
     return this.frameWidth;
   }
   public void setFrameLeftOffset(int frameLeftOffset)
   {
     if (this.frameLeftOffset == frameLeftOffset) return;
     int oldValue = this.frameLeftOffset;
     this.frameLeftOffset = frameLeftOffset;
     scaleFrameDraw();
     firePropertyChange("frameLeftOffset", oldValue, this.frameLeftOffset);
   }
   public int getFrameLeftOffset()
   {
     return this.frameLeftOffset;
   }
   public void setFrameRightOffset(int frameRightOffset)
   {
     if (this.frameRightOffset == frameRightOffset) return;
     int oldValue = this.frameRightOffset;
     this.frameRightOffset = frameRightOffset;
     scaleFrameDraw();
     firePropertyChange("frameRightOffset", oldValue, this.frameRightOffset);
   }
   public int getFrameRightOffset()
   {
     return this.frameRightOffset;
   }
   public void setFrameTopOffset(int frameTopOffset)
   {
     if (this.frameTopOffset == frameTopOffset) return;
     int oldValue = this.frameTopOffset;
     this.frameTopOffset = frameTopOffset;
     scaleFrameDraw();
     firePropertyChange("frameTopOffset", oldValue, this.frameTopOffset);
   }
   public int getFrameTopOffset()
   {
     return this.frameTopOffset;
   }
   public void setFrameBottomOffset(int frameBottomOffset)
   {
     if (this.frameBottomOffset == frameBottomOffset) return;
     int oldValue = this.frameBottomOffset;
     this.frameBottomOffset = frameBottomOffset;
     scaleFrameDraw();
     firePropertyChange("frameBottmOffset", oldValue, this.frameBottomOffset);
   }
   public int getFrameBottomOffset()
   {
     return this.frameBottomOffset;
   }
   public void setFrameForeColor(java.awt.Color frameForeColor)
   {
 	if (aFrame.frameForeColor != null && aFrame.frameForeColor.equals(frameForeColor)) return;
 	Color oldValue = aFrame.frameForeColor;
     aFrame.frameForeColor = frameForeColor;
     this.repaint();
     firePropertyChange("frameForColor", oldValue, aFrame.frameForeColor);
   }
   public java.awt.Color getFrameForeColor()
   {
     return aFrame.frameForeColor;
   }
   public void setXTickLabelColor(java.awt.Color xTickLabelColor)
   {
 	  if (sca[0].tickLabelForeColor != null && sca[0].tickLabelForeColor.equals(xTickLabelColor)) return;
 	  Color oldValue = sca[0].tickLabelForeColor;
     sca[0].tickLabelForeColor = xTickLabelColor;
     this.repaint(sca[0].ticksRect.x, sca[0].ticksRect.y, sca[0].ticksRect.width, sca[0].ticksRect.height);
     if (sca[0].leftBottom != sca[0].leftBottLabel)
       this.repaint(sca[0].labelRect.x, sca[0].labelRect.y, sca[0].labelRect.width, sca[0].labelRect.height);
     firePropertyChange("xTickLabelColor", oldValue, sca[0].tickLabelForeColor);
   }
   public java.awt.Color getXTickLabelColor()
   {
     return sca[0].tickLabelForeColor;
   }
   public void setYTickLabelColor(java.awt.Color yTickLabelColor)
   {
 	  if (sca[1].tickLabelForeColor != null && sca[1].tickLabelForeColor.equals(yTickLabelColor)) return;
 	  Color oldValue = sca[1].tickLabelForeColor;
     sca[1].tickLabelForeColor = yTickLabelColor;
     this.repaint(sca[1].ticksRect.x, sca[1].ticksRect.y, sca[1].ticksRect.width, sca[1].ticksRect.height);
     if (sca[1].leftBottom != sca[1].leftBottLabel)
       this.repaint(sca[1].labelRect.x, sca[1].labelRect.y, sca[1].labelRect.width, sca[1].labelRect.height);
     firePropertyChange("yTickLabelColor", oldValue, sca[1].tickLabelForeColor);
   }
   public java.awt.Color getYTickLabelColor()
   {
     return sca[1].tickLabelForeColor;
   }
   public void setSecondaryYTickLabelColor(java.awt.Color secondaryYTickLabelColor)
   {
 	  if (sca[2].tickLabelForeColor != null && sca[2].tickLabelForeColor.equals(secondaryYTickLabelColor)) return;
 	  Color oldValue = sca[2].tickLabelForeColor;
     sca[2].tickLabelForeColor = secondaryYTickLabelColor;
     firePropertyChange("secondaryYTickLabelColor", oldValue, sca[2].tickLabelForeColor);
     if (sca[2].OnFlag == false) return;
     this.repaint(sca[2].ticksRect.x, sca[2].ticksRect.y, sca[2].ticksRect.width, sca[2].ticksRect.height);
     if (sca[2].leftBottom != sca[2].leftBottLabel)
       this.repaint(sca[2].labelRect.x, sca[2].labelRect.y, sca[2].labelRect.width, sca[2].labelRect.height);
 
   }
   public java.awt.Color getSecondaryYTickLabelColor()
   {
     return sca[2].tickLabelForeColor;
   }
   public void setSecondaryYAxisOn(boolean secondaryYAxisOn)
   {
 	  if (sca[2].OnFlag == secondaryYAxisOn) return;
     sca[2].OnFlag = secondaryYAxisOn;
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     if (aFrame.drawFlag == false) return;
     prepareDraw(); // rescale and reset limit
     firePropertyChange("secondaryYAxisOn", !secondaryYAxisOn, secondaryYAxisOn);
   }
   public boolean isSecondaryYAxisOn()
   {
     return sca[2].OnFlag;
   }
   public void setSecondaryYLogOn(boolean secondaryYLogOn)
   {
 	  int temp = secondaryYLogOn ? 1 : 0 ;
 	  if (temp == sca[2].log) return;
 	  int oldValue = sca[2].log;
     sca[2].log = temp;
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     if (aFrame.drawFlag == false) return;
     prepareDraw(); // rescale and reset limit
     firePropertyChange("secondaryYLogOn", oldValue, sca[2].log);
   }
   public boolean isSecondaryYLogOn()
   {
     return sca[2].log != 0 ? true : false ;
   }
   public void setFrameFont(java.awt.Font frameFont)
   {
 	if (aFrame.frameFont != null && aFrame.frameFont.equals(frameFont)) return;
 	Font oldValue = aFrame.frameFont;
     aFrame.frameFont = frameFont;
     this.repaint();
     firePropertyChange("frameFont", oldValue, aFrame.frameFont);
   }
   public java.awt.Font getFrameFont()
   {
     return aFrame.frameFont;
   }
   public void setDrawStyle(int drawStyle)
   // throws PropertyVetoException
   {
     if (this.drawStyle != drawStyle)
     {
       /*
        * Integer oldValue = new Integer(this.drawStyle); Integer newValue = new
        * Integer(drawStyle); veto.fireVetoableChange("drawStyle" ,oldValue,
        * newValue); this.drawStyle = drawStyle;
        * changes.firePropertyChange("drawStyle" ,oldValue, newValue);
        */
       if (drawStyle < AcopConst.PS_SOLID || drawStyle > AcopConst.PS_DASH_DOT) return;
       int oldValue = this.drawStyle;
       this.drawStyle = drawStyle;
       if (randomData == true)
       {
         rescaleFlag = 2;
         prepareDraw(); // rescale and reset limit
       }
       firePropertyChange("drawStyle", oldValue, this.drawStyle);
     }
   }
   public int getDrawStyle()
   {
     return this.drawStyle;
   }
   public void setFFT(int fFT)
   {
     if (fFT < 0 || fFT > AcopConst.FFT_RI_INVERSE) fFT = 0;
     if (this.FFT == fFT) return;
     int oldValue = this.FFT;
     this.FFT = fFT;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("fFT", oldValue, this.FFT);
   }
   public int getFFT()
   {
     return this.FFT;
   }
   public void setGraphStyle(int graphStyle)
   {
     int changeYlog = 0;
     if (this.graphStyle == graphStyle) return;
     int oldValue = this.graphStyle;
     if (graphStyle < 0 || graphStyle > 5) graphStyle = 0;
     switch (graphStyle)
     {
       default:
       case 0: // lin-lin
         if (sca[1].log != 0) changeYlog = 1;
         sca[0].log = 0;
         sca[1].log = 0;
         sca[0].xtime = 0;
         break;
       case 1: // lin-log
         if (sca[1].log == 0) changeYlog = 1;
         sca[0].log = 0;
         sca[1].log = 1;
         sca[0].xtime = 0;
         break;
       case 2: // log-lin
         if (sca[1].log != 0) changeYlog = 1;
         sca[0].log = 1;
         sca[1].log = 0;
         sca[0].xtime = 0;
         break;
       case 3: // log-log
         if (sca[1].log == 0) changeYlog = 1;
         sca[0].log = 1;
         sca[1].log = 1;
         sca[0].xtime = 0;
         break;
       case 4: // time-lin
         if (sca[1].log != 0) changeYlog = 1;
         sca[0].log = 0;
         sca[1].log = 0;
         sca[0].xtime = 1;
         break;
       case 5: // time-log
         if (sca[1].log == 0) changeYlog = 1;
         sca[0].log = 0;
         sca[1].log = 1;
         sca[0].xtime = 1;
         break;
     }
     if (changeYlog != 0 && m_marker == 2) setmarkerflag(2); // recalculate
                                                             // marker array
     this.graphStyle = graphStyle;
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw(); // rescale and reset limit
     firePropertyChange("graphStyle", oldValue, this.graphStyle);
   }
   public int getGraphStyle()
   {
     return this.graphStyle;
   }
   public void setGridStyle(int gridStyle)
   {
     if (AcopScale.gridLineMode == gridStyle) return;
     int oldValue = AcopScale.gridLineMode;
     AcopScale.gridLineMode = gridStyle;
     AcopScale.gridStroke = AcopConst.createStroke(AcopScale.gridLineWidth, AcopScale.gridLineMode);
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("gridStyle", oldValue, AcopScale.gridLineMode);
   }
   public int getGridStyle()
   {
     return AcopScale.gridLineMode;
   }
   public void setGridColor(java.awt.Color gridColor)
   {
     if (AcopScale.gridLineColor == gridColor) return;
     Color oldValue = AcopScale.gridLineColor;
     AcopScale.gridLineColor = gridColor;
     AcopScale.gridStroke = AcopConst.createStroke(AcopScale.gridLineWidth, AcopScale.gridLineMode);
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("gridColor", oldValue, AcopScale.gridLineColor);
   }
   public java.awt.Color getGridColor()
   {
     return AcopScale.gridLineColor;
   }
   public void setGridWidth(int gridWidth)
   {
     if (AcopScale.gridLineWidth == gridWidth) return;
     if (gridWidth < 1) gridWidth = 1;
     int oldValue = AcopScale.gridLineWidth;
     AcopScale.gridLineWidth = gridWidth;
     AcopScale.gridStroke = AcopConst.createStroke(AcopScale.gridLineWidth, AcopScale.gridLineMode);
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("gridWidth", oldValue, AcopScale.gridLineWidth);
   }
   public int getGridWidth()
   {
     return AcopScale.gridLineWidth;
   }
   public void setKeepStyle(int keepStyle)
   {
 	if (this.keepStyle == keepStyle) return;
 	int oldValue = this.keepStyle;	
     this.keepStyle = keepStyle;
     if (aFrame.drawFlag && m_keep != 0) repaintHisto();
     firePropertyChange("keepStyle", oldValue, this.keepStyle);
   }
   public int getKeepStyle()
   {
     return this.keepStyle;
   }
   public void setKeepColor(java.awt.Color keepColor)
   {
 	if (this.keepColor != null && this.keepColor.equals(keepColor)) return;
 	Color oldValue = this.keepColor;
     this.keepColor = keepColor;
     if (aFrame.drawFlag && m_keep != 0) repaintHisto();
     firePropertyChange("keepColor", oldValue, this.keepColor);
   }
   public java.awt.Color getKeepColor()
   {
     return this.keepColor;
   }
   public void setKeepWidth(int keepWidth)
   {
 	if (keepWidth == this.keepWidth) return;
     if (keepWidth < 1) keepWidth = 1;
     int oldValue = this.keepWidth;
     this.keepWidth = keepWidth;
     if (aFrame.drawFlag && m_keep != 0) repaintHisto();
     firePropertyChange("keepWidth", oldValue, this.keepWidth);
   }
   public int getKeepWidth()
   {
     return this.keepWidth;
   }
   public void setHistogramPosition(int histogramPosition)
   {
 	if (aFrame.histogramPosition == histogramPosition) return;
 	int oldValue = aFrame.histogramPosition;
     aFrame.histogramPosition = histogramPosition;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("histogramPosition", oldValue, aFrame.histogramPosition);
   }
   public int getHistogramPosition()
   {
     return aFrame.histogramPosition;
   }
   public void setInvert(boolean invert)
   {
 	if (this.invert == invert) return;
     this.invert = invert;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("invert", !this.invert, this.invert);
   }
   public boolean isInvert()
   {
     return this.invert;
   }
 
   public void setFrameBorderOn(boolean frameBorderOn)
   {
   if (this.frameBorderOn == frameBorderOn) return;
     this.frameBorderOn = frameBorderOn;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("frameBorderOn", !this.frameBorderOn, this.frameBorderOn);
   }
   public boolean isFrameBorderOn()
   {
     return this.frameBorderOn;
   }
 
   public void setRandomData(boolean randomData)
   {
 	if (this.randomData == randomData) return;
     this.randomData = randomData;
     if (randomData)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     else
       clearScreen(-1, 0);
     
     firePropertyChange("randomData", !randomData, randomData);
   }
   public boolean isRandomData()
   {
     return this.randomData;
   }
   public void setRandomText(boolean randomText)
   {
 	  if (this.randomText == randomText) return;
     this.randomText = randomText;
     if (randomData)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     else
       clearScreen(-1, 0);
     firePropertyChange("randomText", !randomText, randomText);
   }
   public boolean isRandomText()
   {
     return this.randomText;
   }
   public void setReuseScreen(boolean reuseScreen)
   {
 	if (this.reuseScreen == reuseScreen) return;
     this.reuseScreen = reuseScreen;
     firePropertyChange("reuseScreen", !reuseScreen, reuseScreen);
   }
   public boolean isReuseScreen()
   {
     return this.reuseScreen;
   }
   public void setReuseText(boolean reuseText)
   {
 	if (this.reuseText == reuseText) return;
     this.reuseText = reuseText;
     firePropertyChange("reuseText", !reuseText, reuseText);
   }
   public boolean isReuseText()
   {
     return this.reuseText;
   }
   public void setScreenDepth(int screenDepth)
   {
 	  if (this.screenDepth == screenDepth) return;
 	  
     int itmp = screenDepth;
     // if ( Beans.isDesignTime() == false ) return;
     // design mode
     if (itmp > AcopConst.MAX_DISPLAY)
       itmp = AcopConst.MAX_DISPLAY;
     else if (itmp < 1) itmp = 1;
     if (histo[itmp - 1] != null) return;
     screenDepth = itmp;
     int oldValue = this.screenDepth;
     n_display = screenDepth;
     this.screenDepth = screenDepth;
     firePropertyChange("screenDepth", oldValue, this.screenDepth);
   }
   public int getScreenDepth()
   {
     return this.screenDepth;
   }
   public void setTextDepth(int textDepth)
   {
     
     int itmp = textDepth;
     // if ( Beans.isDesignTime() == false ) return;
     // design mode
     if (itmp > AcopConst.MAX_TEXT)
       itmp = AcopConst.MAX_TEXT;
     else if (itmp < 1) itmp = 1;
     if (ptext[itmp - 1] != null) return;
     textDepth = itmp;
     if (this.textDepth == textDepth) return;
     n_text = textDepth;
     int oldValue = this.textDepth;
     this.textDepth = textDepth;
     firePropertyChange("textDepth", oldValue, this.textDepth);
   }
   public int getTextDepth()
   {
     return this.textDepth;
   }
   public void setWrapAround(boolean wrapAround)
   {
     int i;
     if (this.wrapAround == wrapAround) return;
     this.wrapAround = wrapAround;
     if (wrapAround) for (i = 0; i < n_display; i++)
       if (histo[i] != null && histo[i].displayON != 0)
         histo[i].getMaxWindow();
       else
         for (i = 0; i < n_display; i++)
           if (histo[i] != null && histo[i].displayON != 0) histo[i].wrapindex = 0;
     if (aFrame.drawFlag || textFlag)
     {
       // if ( wrapAround == false ) rescaleFlag = 1;
       // rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
       rescaleFlag = wrapAround == false ? 2 : 0;
       rescaleTextFlag = wrapAround == false ? AcopConst.NEW_ZOOM_WINDOW : 0;
       prepareDraw();
     }
     else if (wrapAround == false) drawTicks = true;
     firePropertyChange("wrapAround", !this.wrapAround, this.wrapAround);
   }
   public boolean isWrapAround()
   {
     return this.wrapAround;
   }
   public void setZooming(int zooming)
   {
     if (this.zooming == zooming) return;
     int oldValue = this.zooming;
     if (zooming <= 7 && zooming >= 4)
       zoomIndex = 0;
     else if (zooming < 0 || zooming > 3) zooming = 0;
     if ((zooming & 0x7) != 0) setZoomingWindow(zooming & 0x4);
     if ((zooming & 0x7) == 0 && isZoomed == true)
     {
       if (m_marker == 2) setmarkerflag(2); // restore marker array
         // prepareDraw(TRUE, -1, TRUE, nScaleText); // rescale and set max limit
       rescaleFlag = 2;
       rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
       prepareDraw();
       isZoomed = false;
       zoomIndex = 0;
     }
     this.zooming = zooming;
     firePropertyChange("zooming", oldValue, this.zooming);
   }
   public int getZooming()
   {
     return this.zooming;
   }
   public void setXAxisLabel(java.lang.String xAxisLabel)
   {
 	  if (sca[0].AxisLabel != null && sca[0].AxisLabel.equals(xAxisLabel)) return;
 	  String oldValue = sca[0].AxisLabel;
     sca[0].AxisLabel = xAxisLabel;
     this.repaint(sca[0].labelRect.x, sca[0].labelRect.y, sca[0].labelRect.width, sca[0].labelRect.height);
     firePropertyChange("xAxisLabel", oldValue, sca[0].AxisLabel);
   }
   public java.lang.String getXAxisLabel()
   {
     return sca[0].AxisLabel;
   }
   public void setYAxisLabel(java.lang.String YAxisLabel)
   {
 	  if (sca[1].AxisLabel != null && sca[1].AxisLabel.equals(YAxisLabel)) return;
 	  String oldValue = sca[1].AxisLabel;
     sca[1].AxisLabel = YAxisLabel;
     this.repaint(sca[1].labelRect.x, sca[1].labelRect.y, sca[1].labelRect.width, sca[1].labelRect.height);
     firePropertyChange("yAxisLabel", oldValue, sca[1].AxisLabel);
   }
   public java.lang.String getYAxisLabel()
   {
     return sca[1].AxisLabel;
   }
   public void setSecondaryYAxisLabel(java.lang.String SecondaryYAxisLabel)
   {
 	  if (sca[2].AxisLabel != null && sca[2].AxisLabel.equals(SecondaryYAxisLabel)) return;
 	  String oldValue = sca[2].AxisLabel;
 	sca[2].AxisLabel = SecondaryYAxisLabel;
     this.repaint(sca[2].labelRect.x,sca[2].labelRect.y,sca[2].labelRect.width,sca[2].labelRect.height);
     firePropertyChange("secondaryYAxisLabel", oldValue, sca[2].AxisLabel);
   }
 
   public java.lang.String getSecondaryYAxisLabel()
   {
 	return sca[2].AxisLabel;
   }
   public void setXBestScale(boolean XBestScale)
   {
 	  if (sca[0].bestScale == XBestScale) return;
     sca[0].bestScale = XBestScale;
     firePropertyChange("xBestScale", !XBestScale, XBestScale);
     if (sca[0].log != 0) return;
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw(); // rescale and reset limit
   }
   public boolean isXBestScale()
   {
     return sca[0].bestScale;
   }
   public void setYBestScale(boolean YBestScale)
   {
 	  if (sca[1].bestScale == YBestScale) return;
     sca[1].bestScale = YBestScale;
     firePropertyChange("yBestScale", !sca[1].bestScale, sca[1].bestScale);
     if (sca[1].log != 0) return;
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw(); // rescale and reset limit
   }
   public boolean isYBestScale()
   {
     return sca[1].bestScale;
   }
   public void setSecondaryYBestScale(boolean SecondaryYBestScale)
   {
 	  if (sca[2].bestScale == SecondaryYBestScale) return;
     sca[2].bestScale = SecondaryYBestScale;
     if (sca[2].log != 0) return;
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw(); // rescale and reset limit
     firePropertyChange("secondaryYBestScale", !SecondaryYBestScale, SecondaryYBestScale);
   }
   public boolean isSecondaryYBestScale()
   {
     return sca[2].bestScale;
   }
   public void setXExtent(double XExtent)
   {
 	  if (this.XExtent == XExtent) return;
 	  double oldValue = this.XExtent;
     this.XExtent = XExtent;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("xExtent", oldValue, XExtent);
   }
   public double getXExtent()
   {
     return this.XExtent;
   }
   public void setYExtent(double YExtent)
   {
 	  if (this.YExtent == YExtent) return;
 	  double oldValue = this.YExtent;
     this.YExtent = YExtent;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("yExtent", oldValue, this.YExtent);
   }
   public double getYExtent()
   {
     return this.YExtent;
   }
   public void setXFineTicks(int XFineTicks)
   {
 	  if (sca[0].fineTicks == XFineTicks) return;
 	  int oldValue = sca[0].fineTicks;
     sca[0].fineTicks = XFineTicks;
     if (randomData == true || sca[0].log == 0)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("xFineTicks", oldValue, sca[0].fineTicks);
   }
   public int getXFineTicks()
   {
     return sca[0].fineTicks;
   }
   public void setYFineTicks(int YFineTicks)
   {
 	if (sca[1].fineTicks == YFineTicks) return;
 	int oldValue = sca[1].fineTicks;
     sca[1].fineTicks = YFineTicks;
     if (randomData == true || sca[1].log == 0)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("yFineTicks", oldValue, sca[1].fineTicks);
   }
   public int getYFineTicks()
   {
     return sca[1].fineTicks;
   }
   public void setSecondaryYFineTicks(int SecondaryYFineTicks)
   {
 	  if (sca[2].fineTicks == SecondaryYFineTicks) return;
 	  int oldValue = sca[2].fineTicks;
     sca[2].fineTicks = SecondaryYFineTicks;
     if (randomData == true || sca[2].log == 0)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("secondaryYFineTicks", oldValue, sca[2].fineTicks);
   }
   public int getSecondaryYFineTicks()
   {
     return sca[2].fineTicks;
   }
   public void setXGrid(boolean XGrid)
   {
 	  if (sca[0].grid == XGrid) return;
     sca[0].grid = XGrid;
     repaintHisto();
     firePropertyChange("xGrid", !XGrid, XGrid);
   }
   public boolean isXGrid()
   {
     return sca[0].grid;
   }
   public void setYGrid(boolean YGrid)
   {
 	  if (sca[1].grid == YGrid) return;
     sca[1].grid = YGrid;
     repaintHisto();
     firePropertyChange("yGrid", !sca[1].grid, sca[1].grid);
   }
   public boolean isYGrid()
   {
     return sca[1].grid;
   }
   public void setXScale(double XScale)
   {
 	  if (this.XScale == XScale) return;
 	  double oldValue = this.XScale;
     this.XScale = XScale;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("xScale", oldValue, this.XScale);
   }
   public double getXScale()
   {
     return this.XScale;
   }
   public void setYScale(double YScale)
   {
 	  if (this.YScale == YScale) return;
 	  double oldValue = this.YScale;
     this.YScale = YScale;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("yScale", oldValue, this.YScale);
   }
   public double getYScale()
   {
     return this.YScale;
   }
   public void setXShift(double XShift)
   {
 	  if (this.XShift == XShift) return;
 	  double oldValue = this.XShift;
     this.XShift = XShift;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("xShift", oldValue, this.XShift);
   }
   public double getXShift()
   {
     return this.XShift;
   }
   public void setYShift(double YShift)
   {
 	  if (this.YShift == YShift) return;
 	  double oldValue = this.YShift;
     this.YShift = YShift;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("yShift", oldValue, this.YShift);
   }
   public double getYShift()
   {
     return this.YShift;
   }
   public void setXTicks(int XTicks)
   {
 	  if (sca[0].ticks == XTicks) return;
 	  int oldValue = sca[0].ticks;
     sca[0].ticks = XTicks;
     if (randomData == true || sca[0].log == 0)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("xTicks", oldValue, sca[0].ticks);
   }
   public int getXTicks()
   {
     return sca[0].ticks;
   }
   public void setYTicks(int YTicks)
   {
 	  if (sca[1].ticks == YTicks) return;
 	  int oldValue = sca[1].ticks;
     sca[1].ticks = YTicks;
     if (randomData == true || sca[1].log == 0)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("yTicks", oldValue, sca[1].ticks);
   }
   public int getYTicks()
   {
     return sca[1].ticks;
   }
   public void setSecondaryYTicks(int SecondaryYTicks)
   {
 	  if (sca[2].ticks == SecondaryYTicks) return;
 	  int oldValue = sca[2].ticks;
     sca[2].ticks = SecondaryYTicks;
     if (randomData == true || sca[2].log == 0)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("secondaryYTicks", oldValue, sca[2].ticks);
   }
   public int getSecondaryYTicks()
   {
     return sca[2].ticks;
   }
   public void setXTicksBottom(boolean XTicksBottom)
   {
     if (sca[0].leftBottom == XTicksBottom) return;
     sca[0].leftBottom = XTicksBottom;
     setTickRectangle(0);
     this.repaint();
     firePropertyChange("xTicksBottom", !sca[0].leftBottom, sca[0].leftBottom);
   }
   public boolean getXTicksBottom()
   {
     return sca[0].leftBottom;
   }
   public void setYTicksLeft(boolean YTicksLeft)
   {
     if (sca[1].leftBottom == YTicksLeft) return;
     sca[1].leftBottom = YTicksLeft;
     setTickRectangle(1);
     this.repaint();
     firePropertyChange("yTicksLeft", !sca[1].leftBottom, sca[1].leftBottom);
   }
   public boolean getYTicksLeft()
   {
     return sca[1].leftBottom;
   }
   public void setXTickText(boolean XTickText)
   {
 	  if (sca[0].ticktext == XTickText);
     sca[0].ticktext = XTickText;
     this.repaint(sca[0].ticksRect.x, sca[0].ticksRect.y, sca[0].ticksRect.width, sca[0].ticksRect.height);
     firePropertyChange("xTickText", !sca[0].ticktext, sca[0].ticktext);
   }
   public boolean isXTickText()
   {
     return sca[0].ticktext;
   }
   public void setYTickText(boolean YTickText)
   {
 	  if (sca[1].ticktext == YTickText) return;
     sca[1].ticktext = YTickText;
     this.repaint(sca[1].ticksRect.x, sca[1].ticksRect.y, sca[1].ticksRect.width, sca[1].ticksRect.height);
     firePropertyChange("yTickText", !sca[1].ticktext, sca[1].ticktext);
   }
   public boolean isYTickText()
   {
     return sca[1].ticktext;
   }
   public void setSecondaryYTickText(boolean SecondaryYTickText)
   {
 	  if (sca[2].ticktext == SecondaryYTickText) return;
 	sca[2].ticktext = SecondaryYTickText;
     this.repaint(sca[2].ticksRect.x,sca[2].ticksRect.y,sca[2].ticksRect.width,sca[2].ticksRect.height);
     firePropertyChange("secondaryYTickText", !SecondaryYTickText, SecondaryYTickText);
   }
   public boolean isSecondaryYTickText()
   {
 	return sca[2].ticktext;
   }
   public int bindToSecondaryYScale(int hDisplay, boolean bind)
   { int ret = 0;
     if (hDisplay < 0 || hDisplay >= n_display) return -1;
     if (histo[hDisplay] != null && histo[hDisplay].displayON != 0 && histo[hDisplay].lockFlag == 0)
     {
       histo[hDisplay].bindSecondaryY = bind;
       ret = bind ? 1 : 0;
       prepareDraw();
     }
     else ret = -1;
     return ret;
   }
   public int bindToSecondaryYScale(int hDisplay)
   {
     return bindToSecondaryYScale(hDisplay, true);
   }
   public void setColorFilled(boolean colorFilled)
   {
 	if (this.colorFilled == colorFilled) return;
     this.colorFilled = colorFilled;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
     firePropertyChange("colorFilled", !this.colorFilled, colorFilled);
   }
   public boolean isColorFilled()
   {
     return this.colorFilled;
   }
   public void setLeftTimeLabel(boolean leftTimeLabel)
   {
 	  if (aFrame.leftTimeLabel == leftTimeLabel) return;
     aFrame.leftTimeLabel = leftTimeLabel;
     if (sca[0].xtime != 0)
     {
       sca[0].scaleToGrid();
       // if ( fBottom > 0 ) Invalidate(&xRect);
     }
     firePropertyChange("leftTimeLabel", !leftTimeLabel, leftTimeLabel);
   }
   public boolean isLeftTimeLabel()
   {
     return aFrame.leftTimeLabel;
   }
   public void setAbsTimeDisplay(boolean absTimeDisplay)
   {
     if (aFrame.absTimeDisplay == absTimeDisplay) return;
     aFrame.absTimeDisplay = absTimeDisplay;
     if (sca[0].xtime != 0)
     {
       sca[0].scaleToGrid();
     }
     firePropertyChange("absTimeDisplay", !absTimeDisplay, absTimeDisplay);
   }
   public boolean isAbsTimeDisplay()
   {
     return aFrame.absTimeDisplay;
   }
   public void setLeftYLabel(boolean leftYLabel)
   {
     if (sca[1].leftBottLabel == leftYLabel) return;
     sca[1].leftBottLabel = leftYLabel;
     setTickRectangle(1);
     if (aFrame.drawFlag == false || randomData == false) return;
     this.repaint();
     firePropertyChange("leftYLabel", !leftYLabel, leftYLabel);
   }
   public boolean isLeftYLabel()
   {
     return sca[1].leftBottLabel;
   }
   public void setBottomXLabel(boolean bottomXLabel)
   {
     if (sca[0].leftBottLabel == bottomXLabel) return;
     sca[0].leftBottLabel = bottomXLabel;
     setTickRectangle(0);
     firePropertyChange("bottomXLabel", !sca[0].leftBottLabel, sca[0].leftBottLabel);
     if (aFrame.drawFlag == false || randomData == false) return;
     this.repaint();
   }
   public boolean isBottomXLabel()
   {
     return sca[0].leftBottLabel;
   }
   public void setBarlineColorFilled(int barlineColorFilled)
   {
     if (this.barlineColorFilled == barlineColorFilled || this.barlineColorFilled * barlineColorFilled > 0 ) return;
     int oldValue = this.barlineColorFilled;
     this.barlineColorFilled = barlineColorFilled;
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("barlineColorFilled", oldValue, this.barlineColorFilled);
   }
   public int getBarlineColorFilled()
   {
     return this.barlineColorFilled;
   }
   public void setPrintTextStickyAttribute(int printTextStickyAttribute)
   {
     if (this.printTextStickyAttribute == printTextStickyAttribute) return;
     int oldValue = this.printTextStickyAttribute;
     this.printTextStickyAttribute = printTextStickyAttribute;
     firePropertyChange("printTextStickyAttribute", oldValue, this.printTextStickyAttribute);
   }
   public int getPrintTextStickyAttribute()
   {
     return this.printTextStickyAttribute;
   }
   public void setPrintTextLocation(int printTextLocation)
   {
     if (this.printTextLocation == printTextLocation) return;
     int oldValue = this.printTextLocation;
     this.printTextLocation = printTextLocation;
     firePropertyChange("printTextLocation", oldValue, this.printTextLocation);
   }
   public int getPrintTextLocation()
   {
     return this.printTextLocation;
   }
   public void setPrintTextRotation(int printTextRotation)
   {
     if (this.printTextRotation == printTextRotation) return;
     int oldValue = this.printTextRotation;
     this.printTextRotation = printTextRotation;
     firePropertyChange("printTextRotation", oldValue, this.printTextRotation);
   }
   public int getPrintTextRotation()
   {
     return this.printTextRotation;
   }
   public void setXlabelRotation(int xlabelRotation)
   {
     xlabelRotation = xlabelRotation % 360;
     if (this.xlabelRotation == xlabelRotation) return;
     int oldValue = this.xlabelRotation;
     this.xlabelRotation = xlabelRotation;
     if (xlabelRotation == 90 || xlabelRotation == -270)
       xlabelAxis = 1;
     else if (xlabelRotation == 180 || xlabelRotation == -180)
       xlabelAxis = 2;
     else if (xlabelRotation == 270 || xlabelRotation == -90)
       xlabelAxis = 3;
     else
       xlabelAxis = 0;
     xlabelRotateGrad = xlabelRotation * Math.PI / 180;
     xlabelcos = Math.cos(xlabelRotateGrad);
     xlabelsin = Math.sin(xlabelRotateGrad);
     if (xlabelsin > 0)
       xlabelQudrant = xlabelcos < 0 ? 2 : 1;
     else
       xlabelQudrant = xlabelcos < 0 ? 3 : 4;
     firePropertyChange("xLabelRotation", oldValue, this.xlabelRotation);
   }
   public int getXlabelRotation()
   {
     return this.xlabelRotation;
   }
   public int leadingEdge(int LeadingEdgeMode, int hDisplay)
   {
     int num, ende;
     if (LeadingEdgeMode < 0 || LeadingEdgeMode > 3) LeadingEdgeMode = 0;
     if (hDisplay < 0 || hDisplay >= n_display)
     {
       num = 0;
       ende = n_display - 1;
     }
     else
       ende = num = n_display;
     for (; num <= ende; num++)
     {
       if (histo[hDisplay] == null) continue;
       histo[num].edgeMode = LeadingEdgeMode;
     }
     return LeadingEdgeMode;
   }
   public int leadingEdge(int hDisplay)
   {
     if (hDisplay < 0 || hDisplay >= n_display)
       return LeadingEdgeMode;
     else if (histo[hDisplay] == null)
       return 0;
     else
       return histo[hDisplay].edgeMode;
   }
   public void setLeadingEdgeColor(java.awt.Color LeadingEdgeColor)
   {
     if (this.LeadingEdgeColor == LeadingEdgeColor) return;
     Color oldValue = this.LeadingEdgeColor;
     this.LeadingEdgeColor = LeadingEdgeColor;
     firePropertyChange("leadingEdgeColor", oldValue, this.LeadingEdgeColor);
   }
   public java.awt.Color getLeadingEdgeColor()
   {
     return this.LeadingEdgeColor;
   }
   public void setLeadingEdgeGapSize(int LeadingEdgeGapSize)
   {
     if (this.LeadingEdgeGapSize == LeadingEdgeGapSize) return;
     int oldValue = this.LeadingEdgeGapSize;
     this.LeadingEdgeGapSize = LeadingEdgeGapSize;
     firePropertyChange("leadingEdgeGapSize", oldValue, this.LeadingEdgeGapSize);
   }
   public int getLeadingEdgeGapSize()
   {
     return this.LeadingEdgeGapSize;
   }
   public void setLeadingEdgeMotion(int LeadingEdgeMotion)
   {
     if (this.LeadingEdgeMotion == LeadingEdgeMotion) return;
     int oldValue = this.LeadingEdgeMotion;
     this.LeadingEdgeMotion = LeadingEdgeMotion;
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("leadingEdgeMotion", oldValue, this.LeadingEdgeMotion);
   }
   public int getLeadingEdgeMotion()
   {
     return this.LeadingEdgeMotion;
   }
   public void setLeadingEdgeMode(int LeadingEdgeMode)
   {
     if (LeadingEdgeMode < 0 || LeadingEdgeMode > 3) LeadingEdgeMode = 0;
     if (this.LeadingEdgeMode == LeadingEdgeMode) return;
     int oldValue = this.LeadingEdgeMode;
     this.LeadingEdgeMode = LeadingEdgeMode;
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("leadingEdgeMode", oldValue, this.LeadingEdgeMode);
   }
   public int getLeadingEdgeMode()
   {
     return this.LeadingEdgeMode;
   }
   public void setLeadingEdgeWidth(int LeadingEdgeWidth)
   {
     if (LeadingEdgeWidth < 0) LeadingEdgeWidth = 1;
     if (this.LeadingEdgeWidth == LeadingEdgeWidth) return;
     int oldValue = this.LeadingEdgeWidth;
     this.LeadingEdgeWidth = LeadingEdgeWidth;
     firePropertyChange("leadingEdgeWidth", oldValue, this.LeadingEdgeWidth);
   }
   public int getLeadingEdgeWidth()
   {
     return this.LeadingEdgeWidth;
   }
   public void setLeadingEdgeStyle(int LeadingEdgeStyle)
   {
     if (LeadingEdgeStyle < AcopConst.PS_SOLID) LeadingEdgeStyle = AcopConst.PS_SOLID;
     if (this.LeadingEdgeStyle == LeadingEdgeStyle) return;
     int oldValue = this.LeadingEdgeStyle;
     this.LeadingEdgeStyle = LeadingEdgeStyle;
     firePropertyChange("leadingEdgeStyle", oldValue, this.LeadingEdgeStyle);
   }
   public int getLeadingEdgeStyle()
   {
     return this.LeadingEdgeStyle;
   }
   public void setLeadingEdgeXExtent(double LeadingEdgeXExtent)
   {
     if (Math.abs(this.LeadingEdgeXExtent - LeadingEdgeXExtent) < AcopConst.zero_check) return;
     double oldValue = this.LeadingEdgeXExtent;
     this.LeadingEdgeXExtent = LeadingEdgeXExtent;
     firePropertyChange("leadingEdgeXExtent", oldValue, this.LeadingEdgeXExtent);
   }
   public double getLeadingEdgeXExtent()
   {
     return this.LeadingEdgeXExtent;
   }
   public void setLeadingEdgeYExtent(double LeadingEdgeYExtent)
   {
     if (Math.abs(this.LeadingEdgeYExtent - LeadingEdgeYExtent) < AcopConst.zero_check) return;
     double oldValue = this.LeadingEdgeYExtent;
     this.LeadingEdgeYExtent = LeadingEdgeYExtent;
     firePropertyChange("leadingEdgeYExtent", oldValue, this.LeadingEdgeYExtent);
   }
   public double getLeadingEdgeYExtent()
   {
     return this.LeadingEdgeYExtent;
   }
   // public void addMouseMoveListener(MouseMoveListener mo)
   // {
   // }
   // public void removeMouseMoveListener(MouseMoveListener mo)
   // {
   // }
   public void autoScale(boolean xmx, boolean xmn, boolean ymx, boolean ymn)
   {
     autoScale(xmx, xmn, ymx, ymn, -1);
   }
   public void autoScale(boolean xmx, boolean xmn, boolean ymx, boolean ymn, int hIndex)
   {
     double autotmp, checkXmin, checkXmax, xMax, xMin;
     double[] yMin = new double[2]; 
     double[] yMax = new double[2];
     double[] autotmpY = new double[2];
     int [] yFlags = new int[2];
     int [] autoflgY = new int[2];
     int i, j, autoflg, start, stop, yIndex;
     if (!xmx && !xmn && !ymx && !ymn) return;
     if (histo[m_histstart] == null) return;
     if (hIndex < -1 || hIndex >= n_display) return;
     if (hIndex != -1 && histo[hIndex] == null) return;
     if (hIndex != -1)
     {
       start = hIndex;
       stop = hIndex + 1;
 //      yIndex = histo[hIndex].bindSecondaryY ? 2 : 1;
     }
     else
     {
       start = 0;
       stop = n_display;
     }
     xMax = sca[0].usermax;
     if (xmx) for (i = start, autoflg = 0; i < stop && histo[i] != null; i++)
     {
       if (i != m_histstart && histo[i].displayON == 0) continue;
       autotmp = histo[i].maxOf(histo[i].x);
       if (autoflg == 0)
       {
         xMax = autotmp;
         autoflg = 1;
       }
       else if (xMax < autotmp) xMax = autotmp;
     }
     xMin = sca[0].usermin;
     if (xmn) for (i = start, autoflg = 0; i < stop && histo[i] != null; i++)
     {
       if (i != m_histstart && histo[i].displayON == 0) continue;
       autotmp = histo[i].minOf(histo[i].x);
       if (autoflg == 0)
       {
         xMin = autotmp;
         autoflg = 1;
       }
       else if (xMin > autotmp) xMin = autotmp;
     }
     for (i=0;i<2;i++)
     {
       yFlags[i] = autoflgY[i] = 0;
       yMax[i] = sca[i+1].usermax;
     }
 //    yMax = sca[yIndex].usermax;
     if (ymx) for (i = start; i < stop && histo[i] != null; i++)
     {
       if (i != m_histstart && histo[i].displayON == 0) continue;
       yIndex = histo[i].bindSecondaryY ? 1 : 0;
       yFlags[yIndex]++;
       if (xmx && xmn)
         autotmpY[yIndex] = histo[i].maxOf(histo[i].y);
       else
       {
         checkXmin = sca[0].getMin();
         checkXmax = sca[0].getMax();
         autotmpY[yIndex] = -1.7E308;
         for (j = 0; j < histo[i].npoints; j++)
         {
           if (histo[i].disable[j] != 0) continue;
           if (xmx == false && histo[i].x[j] > checkXmax) continue;
           if (xmn == false && histo[i].x[j] < checkXmin) continue;
           if (histo[i].y[j] > autotmpY[yIndex]) autotmpY[yIndex] = histo[i].y[j];
         }
       }
       if (autoflgY[yIndex] == 0)
       {
         yMax[yIndex] = autotmpY[yIndex];
         autoflgY[yIndex] = 1;
       }
       else if (yMax[yIndex] < autotmpY[yIndex]) yMax[yIndex] = autotmpY[yIndex];
     }
     for (i=0;i<2;i++)
     {
       autoflgY[i] = 0;
       yMin[i] = sca[i+1].usermin;
     }
 //    yMin = sca[yIndex].usermin;
     if (ymn)
       for (i = start; i < stop && histo[i] != null; i++)
       {
         if (i != m_histstart && histo[i].displayON == 0) continue;
         yIndex = histo[i].bindSecondaryY ? 1 : 0;
         yFlags[yIndex]++;
         if (xmx && xmn)
           autotmpY[yIndex] = histo[i].minOf(histo[i].y);
         else
         {
           checkXmin = sca[0].getMin();
           checkXmax = sca[0].getMax();
           autotmpY[yIndex] = 1.7E308;
           for (j = 0; j < histo[i].npoints; j++)
           {
             if (histo[i].disable[j] != 0) continue;
             if (xmx == false && histo[i].x[j] > checkXmax) continue;
             if (xmn == false && histo[i].x[j] < checkXmin) continue;
             if (histo[i].y[j] < autotmpY[yIndex])
               if (sca[yIndex+1].log == 0 || histo[i].y[j] > 1.0e-30) autotmpY[yIndex] = histo[i].y[j];
           }
         }
         if (autoflgY[yIndex] == 0)
         {
           yMin[yIndex] = autotmpY[yIndex];
           autoflgY[yIndex] = 1;
         }
         else if (yMin[yIndex] > autotmpY[yIndex]) yMin[yIndex] = autotmpY[yIndex];
       }
     if (xMax <= xMin + AcopConst.zero_check)
     {
       autotmp = Math.abs(xMin);
       if (autotmp < AcopConst.zero_check)
       {
         xMin -= 5;
         xMax = xMin + 10;
       }
       else
       {
         xMin -= (0.5 * autotmp);
         xMax = xMin + autotmp;
       }
     }
     for (i = 0; i < 2; i++)
     {
       if ( yFlags[i] == 0 ) continue;
       if (yMax[i] <= yMin[i] + AcopConst.zero_check)
       {
         if ( !ymn && ymx )
         {
           autotmp = Math.abs(yMin[i]);
           if (autotmp < AcopConst.zero_check) yMax[i] = yMin[i] + 10;
           else yMax[i] = yMin[i] + Math.abs(yMin[i]);
         }
         else if ( ymn && !ymx )
         {
           autotmp = Math.abs(yMax[i]);
           if (autotmp < AcopConst.zero_check) yMin[i] = yMax[i] - 10;
           else yMin[i] = yMax[i] - Math.abs(yMax[i]);       
         }
         else
         {
           autotmp = Math.abs(yMin[i]);
           if (autotmp < AcopConst.zero_check)
           {
             yMin[i] -= 5;
             yMax[i] = yMin[i] + 10;
           }
           else
           {
             yMin[i] -= (0.5 * autotmp);
             yMax[i] = yMin[i] + autotmp;
           }
         }
       }
     }
     if (xmx || xmn) sca[0].setUserscale(xMin, xMax);
     if (ymx || ymn) for (i=0; i<2; i++) if (yFlags[i] != 0) sca[i+1].setUserscale(yMin[i], yMax[i]);
     // prepareDraw(TRUE, -1, TRUE, 0);
     rescaleFlag = 2;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw();
   }
   protected void onRButtonDown(Point point)
   {
     if (aFrame.drawFlag == false && textFlag == false) return;
     if (aFrame.drawFlag && histo[m_histstart].dismode == AcopConst.mode_textbox) return;
     if ((isZoomed || (wrapAround && sca[0].log == 0)) && histRoundRect.contains(point))
     {
       movie = true;
       moviepoint = point;
       saveBestFlag = (sca[0].bestScale ? 1 : 0) + (sca[1].bestScale ? 2 : 0);
       sca[0].bestScale = false;
       sca[1].bestScale = false;
     }
     if (isZoomed) rButtonPoint = point;
   }
   private void doBufferedZoom()
   {
     int i;
     if ((zooming & 0x4) != 0 && zoomIndex > 0 )
     {
       zoomIndex--;
       for (i = 0; i < 3; i++)
       {
         sca[i].setDispscale(bufferedMin[zoomIndex][i], bufferedMax[zoomIndex][i]);
         if (sca[i].log != 0) sca[i].setDispscale(Math.pow(10.0, sca[i].min), Math.pow(10.0, sca[i].max));
       }
       bufferedZoomRatio = "Z" + zoomIndex;
       if (zoomIndex != 0) sca[0].scaleToGrid();
     }
     if (m_marker == 2) setmarkerflag(2); // recalculate marker array
     rescaleFlag = zoomIndex == 0 ? 2 : 1;
     rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
     prepareDraw(); // rescale and not set max limit
     if (zoomIndex == 0) isZoomed = false;
     notifyAcop(AcopEvent.ACOP_MOUSE_ZOOM_EVENT);
   }
   protected void onRButtonUp(Point point)
   {
     if (movie == false)
     {
       if (!isZoomed || (zooming & 0x4) == 0 || rButtonPoint != point) return;
       doBufferedZoom();
       return;
     }
     movie = false;
     if (saveBestFlag != 0)
     {
       if ((saveBestFlag & 0x1) != 0) sca[0].bestScale = true;
       if ((saveBestFlag & 0x2) != 0) sca[1].bestScale = true;
     }
   }
   protected void onMouseMove(Point point)
   {
     double mx, my, x, y, tx, ty, xcheckmin, xcheckmax;
     boolean reScale;
     int i;
     double[] low = new double[3];
     double[] high = new double[3];
     reScale = true;
     // from log back to nomal for re-scaling
     for (i = 0; i < 3; i++)
     {
       if (i == 2 && sca[i].OnFlag == false) continue;
       low[i] = sca[i].getMin();
       high[i] = sca[i].getMax();
       // x = sca[0].getMin();
       // tx= sca[0].getMax();
       // y = sca[1].getMin();
       // ty= sca[1].getMax();
     }
     if (wrapAround == false || sca[0].log != 0)
     {
       xcheckmin = sca[0].usermin;
       xcheckmax = sca[0].usermax;
     }
     else
     {
       xcheckmin = wrapxmin - sca[0].dispSize - AcopConst.zero_check;
       xcheckmax = wrapxmax + sca[0].dispSize + AcopConst.zero_check;
     }
     if ((point.x < moviepoint.x && low[0] > xcheckmin) || (point.x > moviepoint.x && high[0] < xcheckmax)
         || (point.y > moviepoint.y && low[1] > sca[1].usermin)
         || (point.y < moviepoint.y && high[1] < sca[1].usermax))
     {
       for (i = 0; i < 3; i++)
       {
         if (i == 2 && sca[i].OnFlag == false) continue;
         if (sca[i].log != 0) sca[i].setDispscale(low[i], high[i]);
       }
       x = sca[0].dispSize * moviePercent; // shift 10 percent
       if (point.x < moviepoint.x)
       {
         if (sca[0].log != 0)
         {
           if ((++xCnt < movieLogCnt) || (sca[0].usermin < AcopConst.zero_check && sca[0].min < 0.1)
               || sca[0].min / 10 < sca[0].usermin)
             reScale = false;
           else
           {
             sca[0].setDispscale(sca[0].min / 10, sca[0].max / 10);
             xCnt = 0;
           }
         }
         else
         {
           if (sca[0].min - x < xcheckmin) x = sca[0].min - xcheckmin;
           sca[0].setDispscale(sca[0].min - x, sca[0].max - x);
           if (wrapAround && sca[0].max <= wrapxmin)
             sca[0].setDispscale(wrapxmax - sca[0].dispSize, wrapxmax);
         }
       }
       else if (point.x > moviepoint.x)
       {
         if (sca[0].log != 0)
         {
           if ((--xCnt <= -movieLogCnt) && sca[0].max * 10 <= sca[0].usermax)
           {
             sca[0].setDispscale(sca[0].min * 10, sca[0].max * 10);
             xCnt = 0;
           }
           else
             reScale = false;
         }
         else
         {
           if (sca[0].max + x > xcheckmax) x = xcheckmax - sca[0].max;
           sca[0].setDispscale(sca[0].min + x, sca[0].max + x);
           if (wrapAround && sca[0].min >= wrapxmax)
             sca[0].setDispscale(wrapxmin, wrapxmin + sca[0].dispSize);
         }
       }
       for (i = 1; i < 3; i++) // loop y and y2
       {
         if (i == 2 && sca[i].OnFlag == false) continue;
         y = sca[i].dispSize * moviePercent; // shift 10 percent
         if (point.y > moviepoint.y)
         {
           if (sca[i].log != 0)
           {
             if ((++yCnt < movieLogCnt) || (sca[i].usermin < AcopConst.zero_check && sca[i].min < 0.1)
                 || sca[i].min / 10 < sca[i].usermin)
               reScale = false;
             else
             {
               sca[i].setDispscale(sca[i].min / 10, sca[i].max / 10);
               yCnt = 0;
             }
           }
           else
           {
             if (sca[i].min - y < sca[i].usermin) y = sca[i].min - sca[i].usermin;
             sca[i].setDispscale(sca[i].min - y, sca[i].max - y);
           }
         }
         else if (point.y < moviepoint.y)
         {
           if (sca[i].log != 0)
           {
             if ((--yCnt <= -movieLogCnt) && sca[i].max * 10 <= sca[i].usermax)
             {
               sca[i].setDispscale(sca[i].min * 10, sca[i].max * 10);
               yCnt = 0;
             }
             else
               reScale = false;
           }
           else
           {
             if (sca[i].max + y > sca[i].usermax) y = sca[i].usermax - sca[i].max;
             sca[i].setDispscale(sca[i].min + y, sca[i].max + y);
           }
         }
       }
       if (reScale == true)
       {
         sca[0].scaleToGrid();
         if (m_marker == 2) setmarkerflag(2); // restore marker array
         rescaleFlag = 1;
         rescaleTextFlag = AcopConst.NEW_MOVE_WINDOW;
         prepareDraw(); // rescale but keep present limit
         // prepareDraw(TRUE, -1, FALSE, 0); // rescale but keep present limit
         if (isZoomed && zooming != 0x4) notifyAcop(AcopEvent.ACOP_MOUSE_ZOOM_EVENT);
         // if ( isZoomed ) FireCursorZoom(s_xmax, s_xmin, s_ymax, s_ymin);
       }
       else
         for (i = 0; i < 3; i++)
         {
           if (i == 2 && sca[i].OnFlag == false) continue;
           if (sca[i].log != 0)
             sca[i].setDispscale(Math.log(sca[i].min) / Math.log(10), Math.log(sca[i].max) / Math.log(10));
         }
     }
     moviepoint = point;
   }
   protected void onLButtonDown(Point point)
   {
     if (histo[m_histstart] == null || aFrame.drawFlag == false) return;
     if (histo[m_histstart].dismode == AcopConst.mode_textbox) return;
     if ((zooming & 0x7) != 0)
     {
       zoomFlag = true;
       zoomRect.setBounds(point.x, point.y, 0, 0);
       mStart = point;
       mEnd = point;
       Graphics2D a = (Graphics2D) getGraphics();
       a.setXORMode(Color.darkGray);
       BasicGraphicsUtils.drawDashedRect(a, point.x, point.y, 0, 0);
       a.setPaintMode();
       a.dispose();
       // mEnd = mStart = point;
       // zoomRect2 = zoomRect;
       // CClientDC dc(this); // draw zoom rectangle
       // dc.DrawDragRect( &zoomRect2, size, NULL, size, NULL, NULL );
     }
     else
     {
       // mClickPoint = point;
       // mDoubleClickPoint = mClickPoint;
       // mDoubleClickPoint.x++;
     }
   }
   protected void onLButtonUp(Point point)
   {
     double ftmp, curPos;
     double x, y;
     double[] storemin = new double[3];
     double[] storemax = new double[3];
     int i;
     if (zoomFlag == false) return;
     zoomFlag = false;
     if (mEnd.equals(point) == false || mStart == point) return;
     Graphics2D a = (Graphics2D) getGraphics(); // get rid of zoom drag
                                                 // rectangle
     a.setXORMode(Color.darkGray);
     BasicGraphicsUtils.drawDashedRect(a, zoomRect.x, zoomRect.y, zoomRect.width, zoomRect.height);
     a.setPaintMode();
     a.dispose();
     // zoom outside the histo rectangle
     if (zoomRect.x + zoomRect.width < aFrame.histRect.x
         || zoomRect.x > aFrame.histRect.x + aFrame.histRect.width
         || zoomRect.y + zoomRect.height < aFrame.histRect.y
         || zoomRect.y > aFrame.histRect.y + aFrame.histRect.height) return;
     // zoom inside the histo rectangle and 2 pixel at least
     if (zoomRect.width > 2 && zoomRect.height > 2
         && (zoomRect.width < aFrame.histRect.width || zoomRect.height < aFrame.histRect.height))
     {
       if ((zooming & 0x4) != 0 && zoomIndex < AcopConst.lengthZoom) for (i = 0; i < 3; i++)
       {
         storemin[i] = sca[i].min;
         storemax[i] = sca[i].max;
       }
       if ((zooming & 0x1) != 0 || zooming == 0x4) // x zooming
       {
         ftmp = (zoomRect.x - aFrame.absxleft) * sca[0].dispSize / aFrame.dxwidth + sca[0].min;
         curPos = (zoomRect.x + zoomRect.width - aFrame.absxleft) * sca[0].dispSize / aFrame.dxwidth
             + sca[0].min;
         if (curPos < sca[0].max) sca[0].setDispscale(sca[0].min, curPos);
         if (ftmp > sca[0].min) sca[0].setDispscale(ftmp, sca[0].max);
       }
       if ((zooming & 0x2) != 0 || zooming == 0x4)
         // y and y2 zooming
         for (i = 1; i < 3; i++)
         {
           if (i == 2 && sca[i].OnFlag == false) continue;
           ftmp = (1. - (double) (zoomRect.y - aFrame.histRect.y) / aFrame.histRect.height) * sca[i].dispSize
               + sca[i].min;
           curPos = (1. - (double) (zoomRect.y + zoomRect.height - aFrame.histRect.y) / aFrame.histRect.height)
               * sca[i].dispSize + sca[i].min;
           if (curPos > sca[i].min) sca[i].setDispscale(curPos, sca[i].max);
           if (ftmp < sca[i].max) sca[i].setDispscale(sca[i].min, ftmp);
         }
       for (i = 0; i < 3; i++) // from log back to nomal for re-scaling
       {
         if (sca[i].log != 0)
           sca[i].setDispscale(Math.pow(10.0, sca[i].min), Math.pow(10.0, sca[i].max));
         else if (sca[i].max < sca[i].min + AcopConst.zero_check)
           sca[i].setDispscale(sca[i].min, sca[i].min + AcopConst.zero_check);
       }
       if (wrapAround && sca[0].log == 0)
       {
         if (sca[0].min > wrapxmax)
         {
           ftmp = wrapxmax - wrapxmin;
           sca[0].max -= ftmp;
           sca[0].min -= ftmp;
         }
         else if (sca[0].max < wrapxmin)
         {
           ftmp = wrapxmax - wrapxmin;
           sca[0].max += ftmp;
           sca[0].min += ftmp;
         }
       }
       isZoomed = true;
       sca[0].scaleToGrid();
       if (m_marker == 2) setmarkerflag(2); // recalculate marker array
         // prepareDraw(TRUE, -1, FALSE, nScaleText); // rescale and not set max
         // limit
       rescaleFlag = 1;
       rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
       prepareDraw(); // rescale and not set max limit
       yZoomRatio = "V" + (int) (sca[1].userSize / sca[1].dispSize + 0.5) + ":1";
       xZoomRatio = "H" + (int) (sca[0].userSize / sca[0].dispSize + 0.5) + ":1";
       if ((zooming & 0x4) != 0 && zoomIndex < AcopConst.lengthZoom)
       {
         for (i = 0; i < 3; i++)
         {
           bufferedMin[zoomIndex][i] = storemin[i];
           bufferedMax[zoomIndex][i] = storemax[i];
         }
         zoomIndex++;
         bufferedZoomRatio = "Z" + zoomIndex;
       }
       notifyAcop(AcopEvent.ACOP_MOUSE_ZOOM_EVENT);
       // FireCursorZoom(s_xmax, s_xmin, s_ymax, s_ymin);
     }
     // else if ( isZoomed && aFrame.zoomIcon.contains(point) ) doBufferedZoom();
     else if (zoomRect.width >= aFrame.histRect.width && zoomRect.height >= aFrame.histRect.height)
       doBufferedZoom(); // return back to original setting
       // { // return back to original setting
       // if ( isZoomed && (sca[0].isOriginMaxMin() == false ||
       // sca[1].isOriginMaxMin() == false) )
       // {
       // rescaleFlag = 2;
       // if ( m_marker == 2 ) setmarkerflag(2); // restore marker array
       // rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
       // prepareDraw();
       // notifyAcop(AcopEvent.ACOP_MOUSE_ZOOM_EVENT);
       // }
       // isZoomed = false;
     // }
     // else
     // {
     // InvalidateControl(&zoomRect);
     // if ( getMousePosition(point, x, y, TRUE) ) FireCursorClick(XarrayElement,
     // x, y);
     // }
     // }
   }
   // public void resize(int width, int height)
   // {
   // if ( changeScaleWidth == 0 ) return;
   // scaleframe();
   // this.repaint();
   // }
   protected void processComponentEvent(ComponentEvent componentEvent)
   {
     // make sue listeners are notified
     super.processComponentEvent(componentEvent);
     switch (componentEvent.getID())
     {
       case ComponentEvent.COMPONENT_RESIZED: // resized
         scaleFrameDraw();
         break;
       case ComponentEvent.COMPONENT_MOVED: // moved
         break;
       default:
         break;
     }
   }
   protected void processMouseEvent(MouseEvent mouseEvent)
   {
     // make sue listeners are notified
     super.processMouseEvent(mouseEvent);
     mouseX = mouseEvent.getX();
     mouseY = mouseEvent.getY();
     mousepoint = mouseEvent.getPoint();
     switch (mouseEvent.getID())
     {
       case MouseEvent.MOUSE_ENTERED: // enter to de.desy.acop.chart area
         mouseIndex = -1;
         notifyAcop(AcopEvent.ACOP_MOUSE_ENTER_EVENT);
         break;
       case MouseEvent.MOUSE_EXITED: // go out of de.desy.acop.chart area
         mouseIndex = -1;
         notifyAcop(AcopEvent.ACOP_MOUSE_EXIT_EVENT);
         break;
       case MouseEvent.MOUSE_PRESSED: // mouse down
         if ((mouseEvent.getModifiers() & MouseEvent.BUTTON1_MASK) != 0)
           if (!mouseEvent.isControlDown()) onLButtonDown(mousepoint); // left button
         else if ((mouseEvent.getModifiers() & MouseEvent.BUTTON3_MASK) != 0) // right
                                                                               // button
           onRButtonDown(mousepoint); // left button
           notifyAcop(AcopEvent.ACOP_MOUSE_PRESSED_EVENT);
         break;
       case MouseEvent.MOUSE_RELEASED: // mouse up
         if ((mouseEvent.getModifiers() & MouseEvent.BUTTON1_MASK) != 0)
           onLButtonUp(mousepoint); // left button
         else if ((mouseEvent.getModifiers() & MouseEvent.BUTTON3_MASK) != 0) // right
                                                                               // button
           onRButtonUp(mousepoint); // left button
         break;
       case MouseEvent.MOUSE_CLICKED: // mouse click
         long mouseEventTime = mouseEvent.getWhen();
         long mouseButton = mouseEvent.getButton();
         boolean doubleClick;
         if (mouseButton == previousButton && (mouseEventTime - mousePreviousClickTime < 300))
           doubleClick = true;
         else
           doubleClick = false;
         mousePreviousClickTime = mouseEventTime;
         previousButton = mouseEvent.getButton();
         if (doubleClick) // implement double click events
         {
           if (histRoundRect.contains(mousepoint) && aFrame.drawFlag)
             mouseIndex = histo[m_histstart].getMousePosition(mousepoint, mouseConvert);
           else
             mouseIndex = -1;
           if (isZoomed) // return to original size
           {
             rescaleFlag = 2;
             if (m_marker == 2) setmarkerflag(2); // restore marker array
             rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
             prepareDraw();
             isZoomed = false;
             notifyAcop(AcopEvent.ACOP_MOUSE_ZOOM_EVENT);
           }
           notifyAcop(AcopEvent.ACOP_MOUSE_DCLICK_EVENT);
         }
         // FireCursorClick(XarrayElement, x, y);
         // mouseEvent.notifyAll();
         else if (isZoomed && aFrame.zoomIcon.contains(mousepoint))
           doBufferedZoom();
         // / {
         // / rescaleFlag = 2;
         // /// if ( m_marker == 2 ) setmarkerflag(2); // restore marker array
         // / rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
         // / prepareDraw();
         // / isZoomed = false;
         // / notifyAcop(AcopEvent.ACOP_MOUSE_ZOOM_EVENT);
         // / }
         else
         {
           if (histRoundRect.contains(mousepoint) && aFrame.drawFlag)
             mouseIndex = histo[m_histstart].getMousePosition(mousepoint, mouseConvert);
           else
             mouseIndex = -1;
           notifyAcop(AcopEvent.ACOP_MOUSE_CLICK_EVENT);
         }
 		if (mouseEvent.getButton()==MouseEvent.BUTTON3) getPopupManager().showPopup(this,mouseEvent.getX(),mouseEvent.getY());
         break;
       default:
         break;
     }
   }
   protected void processMouseMotionEvent(MouseEvent mouseMotionEvent)
   {
     int rWidth, rHeight, recX, recY;
     // make sue listeners are notified
     super.processMouseMotionEvent(mouseMotionEvent);
     mouseX = mouseMotionEvent.getX();
     mouseY = mouseMotionEvent.getY();
     mousepoint = mouseMotionEvent.getPoint();
     switch (mouseMotionEvent.getID())
     {
       case MouseEvent.MOUSE_MOVED: // mouse move
         if (aFrame.drawFlag && histRoundRect.contains(mousepoint))
         {
           if (m_cursorMarkerMode != 0 && cursorStay == 0) drawCursorMarker(null, mousepoint);
           mMovePoint.x = mousepoint.x;
           mMovePoint.y = mousepoint.y;
           mouseIndex = histo[m_histstart].getMousePosition(mousepoint, mouseConvert);
           notifyAcop(AcopEvent.ACOP_MOUSE_MOVE_EVENT);
         }
         // if ( getMousePosition(point, mx, my, TRUE) )
         // FireCursorMove(XarrayElement, mx, my);
         break;
       case MouseEvent.MOUSE_DRAGGED: // mouse dragging
         if (zoomFlag)
         {
           Graphics2D a = (Graphics2D) getGraphics();
           a.setXORMode(Color.darkGray);
           BasicGraphicsUtils.drawDashedRect(a, zoomRect.x, zoomRect.y, zoomRect.width, zoomRect.height);
           mEnd = mousepoint;
           rWidth = Math.abs(mEnd.x - mStart.x);
           rHeight = Math.abs(mEnd.y - mStart.y);
           recX = Math.min(mEnd.x, mStart.x);
           recY = Math.min(mEnd.y, mStart.y);
           zoomRect.setBounds(recX, recY, rWidth, rHeight);
           BasicGraphicsUtils.drawDashedRect(a, recX, recY, rWidth, rHeight);
           a.setPaintMode();
           a.dispose();
         }
         else if (movie)
           onMouseMove(mousepoint);
         else if (aFrame.drawFlag && m_cursorMarkerMode != 0 && cursorStay == 0
             && histRoundRect.contains(mousepoint))
         {
           drawCursorMarker(null, mousepoint);
           mMovePoint.x = mousepoint.x;
           mMovePoint.y = mousepoint.y;
         }
         break;
       default:
         break;
     }
   }
   private void drawtext(java.awt.Graphics2D g2d)
   {
     if (textFlag == false) return;
     Rectangle Cliprect = g2d.getClipBounds();
     if (Cliprect != null)
     {
       if (Cliprect.intersects(histRoundRect) == false) return;
     }
     g2d.clipRect(histRoundRect.x, histRoundRect.y, histRoundRect.width, histRoundRect.height);
     g2d.translate(aFrame.histRect.x, aFrame.histRect.y);
     for (int i = 0; i < n_text; i++)
     {
       if (ptext[i] == null) break;
       ptext[i].printUserText(g2d);
     }
     g2d.translate(-aFrame.histRect.x, -aFrame.histRect.y);
     g2d.setClip(Cliprect);
   }
   private void drawhist(java.awt.Graphics2D g2d)
   {
     if (aFrame.drawFlag == false && textFlag == false) return;
     Rectangle Cliprect = g2d.getClipBounds();
     if (Cliprect != null)
     {
       if (Cliprect.intersects(histRoundRect) == false) return;
     }
     g2d.clipRect(histRoundRect.x, histRoundRect.y, histRoundRect.width, histRoundRect.height);
     g2d.translate(aFrame.histRect.x, aFrame.histRect.y);
     for (int i = 0; i < 2; i++)
       sca[i].drawGrid(g2d);
     for (int i = 0; i < 2; i++)
       axis[i].drawAxis(g2d);
     if (aFrame.drawFlag) for (int i = 0; i < n_display; i++)
     {
       if (histo[i] == null) break;
       histo[i].drawhist(g2d);
     }
     if (aFrame.drawFlag && m_cursorMarkerMode != 0 && histRoundRect.contains(mMovePoint))
     {
       /* set pencolor to black (for first histo?) to avoid the color change of cursorMarker pen  */
       g2d.setColor(Color.black);
       if ( cursorStay > 0 )  // 2009-5-4 tootip may change the mouse position, reload the original value
       {
         mMovePoint.x = sca[0].getScreenPosition(cursorXposition);
         mMovePoint.y = sca[1].getScreenPosition(cursorYposition);      
       }
       drawCursorMarker(g2d, mMovePoint);
     }
     else
       cursorMarkerFlag = 0; // no cursor drawn on screen!
     g2d.translate(-aFrame.histRect.x, -aFrame.histRect.y);
     g2d.setClip(Cliprect);
   }
   private void captionPaint(java.awt.Graphics2D g2d)
   {
     FontMetrics fMetrix;
     int xPosition, len, hei;
     Rectangle Cliprect = g2d.getClipBounds();
     if ( caption == null ) return;  /* 2008-2 hwu*/
     if (Cliprect != null)
     {
       if (Cliprect.intersects(titleRect) == false) return;
     }
     if (captionFont == null || captionChanged == true || randomData == true)
     {
       captionFont = new Font(g2d.getFont().getAttributes());
       captionChanged = false;
     }
     Font tmpFont = g2d.getFont();
     AffineTransform transform = g2d.getTransform();
     g2d.clipRect(titleRect.x, titleRect.y, titleRect.width + 1, titleRect.height + 1);
     g2d.setFont(captionFont);
     fMetrix = g2d.getFontMetrics();
     len = fMetrix.stringWidth(caption);
     hei = (fMetrix.getDescent() + fMetrix.getAscent()) / 2;
     if (captionPosition == 1)
       xPosition = (titleRect.width - len) / 2;
     else if (captionPosition < 1)
       xPosition = 2;
     else
       xPosition = titleRect.width - len - 2;
     g2d.setColor(aFrame.frameForeColor);
     g2d.drawString(caption, xPosition, sca[0].leftBottom ? (fTop - 4) : (fTop - 4 - hei * 2));
     g2d.setTransform(transform);
     g2d.setFont(tmpFont);
     g2d.setClip(Cliprect);
   }
   private void backgroundPaint(java.awt.Graphics2D g2d, Rectangle Cliprect, Rectangle acopRect)
   {
     int i;
     if (nBackRegions == 0)
     {
       g2d.setColor(getBackground());
 //      g2dima.setBackground(g2d.getBackground());
       if (Cliprect == null)
         g2d.fillRect(0,0,acopRect.width, acopRect.height);
 //        g2dima.clearRect(0, 0, acopRect.width, acopRect.height);
       else
         g2d.fillRect(Cliprect.x, Cliprect.y, Cliprect.width, Cliprect.height);
 //        g2dima.clearRect(Cliprect.x, Cliprect.y, Cliprect.width, Cliprect.height);
       return;
     }
     g2d.setColor(getBackground());
 //    g2dima.setBackground(g2d.getBackground());
     if (false) // what to do for the display gap?????
     {
       if (Cliprect == null || Cliprect.intersects(titleRect) == true)
         g2d.fillRect(titleRect.x, titleRect.y, titleRect.width, titleRect.height);
 //        g2dima.clearRect(titleRect.x, titleRect.y, titleRect.width, titleRect.height);
       if (Cliprect == null || Cliprect.intersects(xRect) == true)
         g2d.fillRect(xRect.x, xRect.y, xRect.width, xRect.height);
 //        g2dima.clearRect(xRect.x, xRect.y, xRect.width, xRect.height);
       if (Cliprect == null || Cliprect.intersects(yRect) == true)
         g2d.fillRect(yRect.x, yRect.y, yRect.width, yRect.height);
 //        g2dima.clearRect(yRect.x, yRect.y, yRect.width, yRect.height);
       if (Cliprect == null || Cliprect.intersects(yAxisRect) == true)
         g2d.fillRect(yAxisRect.x, yAxisRect.y, yAxisRect.width, yAxisRect.height);
 //        g2dima.clearRect(yAxisRect.x, yAxisRect.y, yAxisRect.width, yAxisRect.height);
     }
     else
     {
       if (Cliprect == null)
         g2d.fillRect(0,0,acopRect.width, acopRect.height);
 //        g2dima.clearRect(0, 0, acopRect.width, acopRect.height);
       else
         g2d.fillRect(Cliprect.x, Cliprect.y, Cliprect.width, Cliprect.height);
 //        g2dima.clearRect(Cliprect.x, Cliprect.y, Cliprect.width, Cliprect.height);
     }
     g2d.clipRect(histRoundRect.x, histRoundRect.y, histRoundRect.width, histRoundRect.height);
     Rectangle tmpCliprect = g2d.getClipBounds();
     for (i = 0; i < nBackRegions; i++)
     {
       if (backkgroundRegionType[i] == 0) continue;
       if (tmpCliprect != null && tmpCliprect.intersects(backRegionRect[i]) == false) continue;
       if (backkgroundRegionType[i] == 1)
       {
         g2d.setColor(backRegionColor[i]);
 //        g2dima.setBackground(backRegionColor[i]);
         g2d.fillRect(backRegionRect[i].x, backRegionRect[i].y, backRegionRect[i].width,
           backRegionRect[i].height);
 //        g2dima.clearRect(backRegionRect[i].x, backRegionRect[i].y, backRegionRect[i].width,backRegionRect[i].height);
       }
       else if (backkgroundRegionType[i] == 2)
         g2d.drawImage(backRegionImage[i], backRegionRect[i].x, backRegionRect[i].y,
             backRegionRect[i].width, backRegionRect[i].height, this);
     }
     g2d.setClip(Cliprect);
   }
   public void update(java.awt.Graphics a)
   {
     this.paint(a);
   }
   /* (non-Javadoc)
    * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
    */
   @Override
   protected void paintComponent(Graphics g) {
 	//super.paintComponent(g);
 //    java.awt.Graphics2D g2d = (Graphics2D) g;
     java.awt.Graphics2D g2dima = (Graphics2D) g;
     Rectangle r = getBounds();
     
     int i;
 /* 2007 do not use double buffer any more hwu
     if (ima == null || r.width != ima.getWidth() || r.height != ima.getHeight())
     {
       // ima = new java.awt.image.BufferedImage(r.width, r.height,
       // BufferedImage.TYPE_INT_RGB);
       ima = new java.awt.image.BufferedImage(r.width, r.height, BufferedImage.TYPE_INT_ARGB);
       g2dima = ima.createGraphics();
     }
 */
 //    g2dima = g2d; //2007
     Rectangle Cliprect = g2dima.getClipBounds(); // get original clip area
 
     // Ike: this method is not really painting background, but just clears it and in swint this
     // leaves white background
     backgroundPaint(g2dima, Cliprect, r);
     
     // Ike: in swing you have to paint yourself your gackground
 //    g2dima.setColor(getBackground());
 //    g2dima.fillRect(0,0,ima.getWidth(),ima.getHeight());
     
     g2dima.setColor(aFrame.frameForeColor); // draw border
     if ( frameBorderOn )
     g2dima.drawRect(0, 0, r.width - 1, r.height - 1);
     captionPaint(g2dima); // paint caption
     if (changeScaleWidth == 0) // prepare random data only once
     {
       scaleframe();
       /*
        * if ( Beans.isDesignTime() && randomData == true ) { prepareDraw();
        * System.out.println("DesignTime and RandomData"); }
        */
       changeScaleWidth = 1;
     }
     if (Cliprect == null || Cliprect.intersects(histRoundRect) == true)
     {
       g2dima.setColor(aFrame.frameForeColor);
       g2dima.drawRect(histRoundRect.x, histRoundRect.y, histRoundRect.width, histRoundRect.height);
     }
     drawhist(g2dima);
 //    drawtext(g2dima);
     g2dima.setStroke(stroke);
     if (isZoomed && (Cliprect == null || Cliprect.intersects(aFrame.zoomIcon) == true))
     {
       g2dima.setColor(aFrame.frameForeColor);
       g2dima.setFont(aFrame.frameFont);
       g2dima.drawRect(aFrame.zoomIcon.x, aFrame.zoomIcon.y, aFrame.zoomIcon.width, aFrame.zoomIcon.height);
       g2dima.clipRect(aFrame.zoomIcon.x, aFrame.zoomIcon.y, aFrame.zoomIcon.width, aFrame.zoomIcon.height);
       if ((zooming & 0x4) != 0)
         g2dima.drawString(bufferedZoomRatio, aFrame.zoomIcon.x + 1, aFrame.zoomIcon.y
             + aFrame.zoomIcon.height - 1);
       else
       {
         g2dima.drawString(yZoomRatio, aFrame.zoomIcon.x + 1, aFrame.zoomIcon.y + aFrame.zoomIcon.width / 2);
         g2dima.drawString(xZoomRatio, aFrame.zoomIcon.x + 1, aFrame.zoomIcon.y + aFrame.zoomIcon.width - 1);
       }
       g2dima.setClip(Cliprect);
     }
     if ((textFlag == true || (aFrame.drawFlag == true && histo[m_histstart].dismode != AcopConst.mode_textbox))
         && (fLeft > 0 || fRight > 0 || fBottom > 0 || fTop > 0))
     {
       for (i = 0; i < 3; i++)
       {
         if (i == 2 && sca[i].OnFlag == false) continue;
         sca[i].drawTicks(g2dima, histo[m_histstart]);
       }
     }
     drawtext(g2dima);
     if (zoomFlag && (Cliprect == null || Cliprect.intersects(zoomRect) == true))
     {
       g2dima.setXORMode(Color.darkGray);
       BasicGraphicsUtils.drawDashedRect(g2dima, zoomRect.x, zoomRect.y, zoomRect.width, zoomRect.height);
       g2dima.setPaintMode();
     }
     // TODO Ike: not necessary to call inside paintComponent method, because children are painted inside
     // paintChildren method in parent JPanel
     //super.paint(g2dima); // paint all children
 /* 2007 do not use double buffer any more hwu   
     if (Cliprect == null)
       g2d.drawImage(ima, 0, 0, this);
     else
       g2d.drawImage(ima, Cliprect.x, Cliprect.y, Cliprect.x + Cliprect.width, Cliprect.y + Cliprect.height,
           Cliprect.x, Cliprect.y, Cliprect.x + Cliprect.width, Cliprect.y + Cliprect.height, this);
 */          
     // MotifGraphicsUtils.drawStringInRect(a,caption,
     // frameWidth+frameLeftOffset,
     // 0,
     // titleRect.width,
     // frameWidth,
     // MotifGraphicsUtils.CENTER);
     // todo. Add overriding code here.
   }
 /*  public void paintAll(java.awt.Graphics a)
   {
     // todo. Add overriding code here.
   }*/
   public static void main(String argv[])
   {
     class DriverFrame extends java.awt.Frame
     {
       public DriverFrame()
       {
         addWindowListener(new java.awt.event.WindowAdapter()
         {
           public void windowClosing(java.awt.event.WindowEvent event)
           {
             dispose(); // free the system resources
             System.exit(0); // close the application
           }
           public void windowOpened(java.awt.event.WindowEvent event)
           {
             int test = 3;
           }
         });
         setLayout(null);
         setSize(400, 300);
         add(new Acop());
       }
     }
     new DriverFrame().show();
   }
      
   /*
    * public void addPropertyChangeListener(java.beans.PropertyChangeListener
    * pcl) { if (changes == null) changes = new
    * symantec.itools.beans.PropertyChangeSupport(this);
    * changes.addPropertyChangeListener("",pcl); } public void
    * removePropertyChangeListener(java.beans.PropertyChangeListener pcl) { if
    * (changes != null) changes.removePropertyChangeListener("",pcl); } public
    * void addVetoableChangeListener(java.beans.VetoableChangeListener vcl) { if
    * (veto == null) veto = new
    * symantec.itools.beans.VetoableChangeSupport(this);
    * veto.addVetoableChangeListener("",vcl); } public void
    * removeVetoableChangeListener(java.beans.VetoableChangeListener vcl) { if
    * (veto != null) veto.removeVetoableChangeListener("",vcl); }
    */
   public synchronized void addAcopListener(AcopListener l)
   {
     if (!AcopListeners.contains(l)) AcopListeners.addElement(l);
   }
   public synchronized void removeAcopListener(AcopListener l)
   {
     if (AcopListeners.contains(l)) AcopListeners.removeElement(l);
   }
   // notify listening objects of Acop
   protected void notifyAcop(int id)
   {
     // create the event object
     if (id == AcopEvent.ACOP_MOUSE_CLICK_EVENT || id == AcopEvent.ACOP_MOUSE_MOVE_EVENT
         || id == AcopEvent.ACOP_MOUSE_ENTER_EVENT || id == AcopEvent.ACOP_MOUSE_EXIT_EVENT
         || id == AcopEvent.ACOP_MOUSE_ZOOM_EVENT /*|| id == AcopEvent.ACOP_RECEIVE_EVENT*/
         || id == AcopEvent.ACOP_MOUSE_DCLICK_EVENT || id == AcopEvent.ACOP_MOUSE_PRESSED_EVENT)
     {
       AcopEvent evt;
       if (id == AcopEvent.ACOP_MOUSE_ZOOM_EVENT)
         evt = new AcopEvent(this, id, sca[0].min, sca[1].min, sca[0].max, sca[1].max);
       else /*if (id != AcopEvent.ACOP_RECEIVE_EVENT)*/
         evt = new AcopEvent(this, id, mouseIndex, mousepoint.x, mousepoint.y, mouseConvert[0],
             mouseConvert[1]);
 /*      else
         evt = new AcopEvent(this, id, 1, 1); // link id ans error
 */      Vector v;
       synchronized (this)
       {
         v = (Vector) AcopListeners.clone();
       }
       // fire events
       int cnt = v.size();
       for (int i = 0; i < cnt; i++)
       {
         AcopListener client = (AcopListener) v.elementAt(i);
         if (id == AcopEvent.ACOP_MOUSE_CLICK_EVENT)
           client.acopMouseClick(evt);
         else if (id == AcopEvent.ACOP_MOUSE_DCLICK_EVENT)
           client.acopMouseDoubleClick(evt);
         else if (id == AcopEvent.ACOP_MOUSE_MOVE_EVENT)
           client.acopMouseMove(evt);
         else if (id == AcopEvent.ACOP_MOUSE_ENTER_EVENT)
           client.acopMouseEnter(evt);
         else if (id == AcopEvent.ACOP_MOUSE_EXIT_EVENT)
           client.acopMouseExit(evt);
         else if (id == AcopEvent.ACOP_MOUSE_ZOOM_EVENT)
           client.acopMouseZoom(evt);
         else if (id == AcopEvent.ACOP_MOUSE_PRESSED_EVENT) 
           client.acopMousePressed(evt);
         //else if (id == AcopEvent.ACOP_RECEIVE_EVENT) client.AcopReceive(evt);
       }
     }
   }
   public void notifyAcop(int id, int link, int code)
   {
     // create the event object
     if (id == AcopEvent.ACOP_MOUSE_CLICK_EVENT || id == AcopEvent.ACOP_MOUSE_MOVE_EVENT
         || id == AcopEvent.ACOP_MOUSE_ENTER_EVENT || id == AcopEvent.ACOP_MOUSE_EXIT_EVENT
         || id == AcopEvent.ACOP_MOUSE_ZOOM_EVENT || /*id == AcopEvent.ACOP_RECEIVE_EVENT
         ||*/ id == AcopEvent.ACOP_MOUSE_DCLICK_EVENT || id == AcopEvent.ACOP_MOUSE_PRESSED_EVENT)
     {
       AcopEvent evt;
       if (id == AcopEvent.ACOP_MOUSE_ZOOM_EVENT) {
         evt = new AcopEvent(this, id, sca[0].min, sca[1].min, sca[0].max, sca[1].max);
       } else {
         evt = new AcopEvent(this, id, mouseIndex, mousepoint.x, mousepoint.y, mouseConvert[0],
             mouseConvert[1]);
       }
         Vector v;
       synchronized (this)
       {
         v = (Vector) AcopListeners.clone();
       }
       // fire events
       int cnt = v.size();
       for (int i = 0; i < cnt; i++)
       {
         AcopListener client = (AcopListener) v.elementAt(i);
         if (id == AcopEvent.ACOP_MOUSE_CLICK_EVENT)
           client.acopMouseClick(evt);
         else if (id == AcopEvent.ACOP_MOUSE_DCLICK_EVENT)
           client.acopMouseDoubleClick(evt);
         else if (id == AcopEvent.ACOP_MOUSE_MOVE_EVENT)
           client.acopMouseMove(evt);
         else if (id == AcopEvent.ACOP_MOUSE_ENTER_EVENT)
           client.acopMouseEnter(evt);
         else if (id == AcopEvent.ACOP_MOUSE_EXIT_EVENT)
           client.acopMouseExit(evt);
         else if (id == AcopEvent.ACOP_MOUSE_ZOOM_EVENT)
           client.acopMouseZoom(evt);
         else if (id == AcopEvent.ACOP_MOUSE_PRESSED_EVENT) 
             client.acopMousePressed(evt);
         /*else if (id == AcopEvent.ACOP_RECEIVE_EVENT) client.AcopReceive(evt);*/
       }
     }
   }
   public void setCursorMarkerColor(java.awt.Color cursorMarkerColor)
   {
     // cursorColor = ~(TranslateColor(m_cursorMarkerColor) ^
     // TranslateColor(GetBackColor())) & 0xffffff;
     if (m_cursorMarkerColor == cursorMarkerColor) return;
     Color oldValue = m_cursorMarkerColor;
     m_cursorMarkerColor = cursorMarkerColor;
 //    rev_cursorMarkerColor = new Color(~m_cursorMarkerColor.getRGB());
     rev_cursorMarkerColor = new Color(~m_cursorMarkerColor.getRGB() ^ ~backColor.getRGB());
     if (m_cursorMarkerMode != 0 && aFrame.drawFlag) repaintHisto();
     firePropertyChange("cursorMarkerColor", oldValue, m_cursorMarkerColor);
   }
   public java.awt.Color getCursorMarkerColor()
   {
     return m_cursorMarkerColor;
   }
   public void setCursorMarkerMode(int cursorMarkerMode)
   {
     cursorMarkerMode = (cursorMarkerMode < 0 || cursorMarkerMode > 3) ? 0 : cursorMarkerMode;
     if (m_cursorMarkerMode == cursorMarkerMode) return;
     int oldValue = m_cursorMarkerMode;
     m_cursorMarkerMode = cursorMarkerMode;
     if (m_cursorMarkerMode != 0 && histRoundRect.contains(mMovePoint) == false)
     {
       mMovePoint.x = histRoundRect.x + histRoundRect.width / 2;
       mMovePoint.y = histRoundRect.y + histRoundRect.height / 2;
     }
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("cursorMarkerMode", oldValue, m_cursorMarkerMode);
   }
   public int getCursorMarkerMode()
   {
     return this.m_cursorMarkerMode;
   }
   public void setCursorMarkerStyle(int cursorMarkerStyle)
   {
     if (m_cursorMarkerStyle == cursorMarkerStyle) return;
     int oldValue = m_cursorMarkerStyle;
     m_cursorMarkerStyle = cursorMarkerStyle;
     cursorMarkerStroke = AcopConst.createStroke(m_cursorMarkerWidth, m_cursorMarkerStyle);
     if (m_cursorMarkerMode != 0 && aFrame.drawFlag) repaintHisto();
     firePropertyChange("cursorMarkerStyle", oldValue, m_cursorMarkerStyle);
   }
   public int getCursorMarkerStyle()
   {
     return m_cursorMarkerStyle;
   }
   public void setCursorMarkerWidth(int cursorMarkerWidth)
   {
     if (m_cursorMarkerWidth == cursorMarkerWidth) return;
     int oldValue = m_cursorMarkerWidth;
     m_cursorMarkerWidth = cursorMarkerWidth;
     cursorMarkerStroke = AcopConst.createStroke(m_cursorMarkerWidth, m_cursorMarkerStyle);
     if (m_cursorMarkerMode != 0 && aFrame.drawFlag) repaintHisto();
     firePropertyChange("cursorMarkerWidth", oldValue, m_cursorMarkerWidth);
   }
   public int getCursorMarkerWidth()
   {
     return m_cursorMarkerWidth;
   }
   public void setCursorMarkerXExtent(double cursorMarkerXExtent)
   {
     if (m_cursorMarkerXExtent == cursorMarkerXExtent) return;
     double oldValue = m_cursorMarkerXExtent;
     m_cursorMarkerXExtent = cursorMarkerXExtent;
     cursorXPercent = -1;
     if (m_cursorMarkerMode != 0 && aFrame.drawFlag) repaintHisto();
     firePropertyChange("cursorMarkerXExtent", oldValue, m_cursorMarkerXExtent);
   }
   public double getCursorMarkerXExtent()
   {
     return m_cursorMarkerXExtent;
   }
   public void setCursorMarkerYExtent(double cursorMarkerYExtent)
   {
     if (m_cursorMarkerYExtent == cursorMarkerYExtent) return;
     double oldValue = m_cursorMarkerYExtent;
     m_cursorMarkerYExtent = cursorMarkerYExtent;
     cursorYPercent = -1;
     if (m_cursorMarkerMode != 0 && aFrame.drawFlag) repaintHisto();
     firePropertyChange("cursorMarkerYExtent", oldValue, m_cursorMarkerYExtent);
   }
   public double getCursorMarkerYExtent()
   {
     return m_cursorMarkerYExtent;
   }
   public void setMarkerColor(java.awt.Color markerColor)
   {
     if (m_markerColor == markerColor) return;
     Color oldValue = m_markerColor;
     m_markerColor = markerColor;
     if (m_markerMode == 0 && aFrame.drawFlag) repaintHisto();
     firePropertyChange("markerColor", oldValue, m_markerColor);
   }
   public java.awt.Color getMarkerColor()
   {
     return m_markerColor;
   }
   public void setMarkerMode(int markerMode)
   {
     markerMode = (markerMode < 0 || markerMode > 3) ? 0 : markerMode;
     if (this.m_markerMode == markerMode) return;
     int oldValue = m_markerMode;
     m_markerMode = markerMode;
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("markerMode", oldValue, m_markerMode);
   }
   public int getMarkerMode()
   {
     return this.m_markerMode;
   }
   public void setMarkerStyle(int markerStyle)
   {
     if (this.m_markerStyle == markerStyle) return;
     int oldValue = m_markerStyle;
     m_markerStyle = markerStyle;
     firePropertyChange("markerStyle", oldValue, m_markerStyle);
   }
   public int getMarkerStyle()
   {
     return this.m_markerStyle;
   }
   public void setMarkerWidth(int markerWidth)
   {
     if (this.m_markerWidth == markerWidth) return;
     int oldValue = m_markerWidth;
     m_markerWidth = markerWidth;
     firePropertyChange("markerWidth", oldValue, m_markerWidth);
   }
   public int getMarkerWidth()
   {
     return this.m_markerWidth;
   }
   public void setMarkerXExtent(double markerXExtent)
   {
     if (this.m_markerXExtent == markerXExtent) return;
     double oldValue = m_markerXExtent;
     m_markerXExtent = markerXExtent;
     firePropertyChange("markerXExtent", oldValue, m_markerXExtent);
   }
   public double getMarkerXExtent()
   {
     return this.m_markerXExtent;
   }
   public void setMarkerYExtent(double markerYExtent)
   {
     if (this.m_markerYExtent == markerYExtent) return;
     double oldValue = m_markerYExtent;
     m_markerYExtent = markerYExtent;
     firePropertyChange("markerYExtent", oldValue, m_markerYExtent);
   }
   public double getMarkerYExtent()
   {
     return this.m_markerYExtent;
   }
   public int errorWindow(double XMax, double XMin, double YMax, double YMin)
   {
     return errorWindow(-1, XMax, XMin, YMax, YMin);
   }
   public int errorWindow(int hDisplay, double XMax, double XMin, double YMax, double YMin)
   {
     int i, start, stop, on;
     // out of range, -1 to set for default value
     if (hDisplay < -1 || hDisplay > n_display) return -1;
     on = 0;
     start = hDisplay;
     stop = hDisplay + 1;
     if (hDisplay == -1) // set all
     {
       start = 0;
       stop = n_display;
       e_xmax = XMax; // set default
       e_xmin = XMin;
       e_ymax = YMax;
       e_ymin = YMin;
     }
     for (i = start; i < stop; i++)
     {
       if (histo[i] == null) break;
       histo[i].err_xmax = XMax;
       histo[i].err_xmin = XMin;
       histo[i].err_ymax = YMax;
       histo[i].err_ymin = YMin;
       if (histo[i].errWindowEnable && histo[i].displayON != 0) on = 1;
     }
     if (aFrame.drawFlag && on != 0) repaintHisto();
     return 0;
   }
   public void setErrorColor(java.awt.Color errorColor)
   {
     if (m_errorColor == errorColor) return;
     Color oldValue = m_errorColor;
     m_errorColor = errorColor;
     if (histo[lastDisp] != null) histo[lastDisp].errorColor = m_errorColor;
     firePropertyChange("errorColor", oldValue, m_errorColor);
   }
   public java.awt.Color getErrorColor()
   {
     return m_errorColor;
   }
   public void setTagColor(java.awt.Color tagColor)
   {
     if (m_tagColor == tagColor) return;
     Color oldValue = m_tagColor;
     m_tagColor = tagColor;
     for (int i = 0; i < n_display; i++)
     {
       if (histo[i] == null) break;
       histo[i].tagColor = m_tagColor;
     }
     firePropertyChange("tagColor", oldValue, m_tagColor);
   }
   public java.awt.Color getTagColor()
   {
     return m_tagColor;
   }
   public void setTagging(boolean tagging)
   {
     if (this.m_tagging == tagging) return;
     this.m_tagging = tagging;
     if (aFrame.drawFlag) repaintHisto();
     firePropertyChange("tagging", !m_tagging, m_tagging);
   }
   public boolean isTagging()
   {
     return this.m_tagging;
   }
   public void clearTags(int hDisplay)
   {
     int i, j, ok, start, stop;
     if (pTagColorArray == null) return; // no hoistogram at all!
     if (hDisplay >= 0 && hDisplay < n_display) // tag one histogram only!
     {
       start = n_display;
       stop = start + 1;
     }
     else
     {
       start = 0;
       stop = n_display;
     }
     ok = 0;
     for (j = start; j < stop; j++) // clear all histogram tagging array!!
     {
       if (histo[j] == null) break;
       if (histo[j].dismode == AcopConst.mode_histogram
           || histo[j].dismode == AcopConst.mode_histogram_rastoring
           || histo[j].dismode == AcopConst.mode_dots || histo[j].dismode == AcopConst.mode_rectangle
           || histo[j].dismode == AcopConst.mode_circle)
       {
         ok = 1;
         for (i = 0; i < histo[j].npoints; i++)
           histo[j].m_tagColorArray[i] = histo[j].vorColor;
       }
     }
     if (ok != 0 && m_tagging && aFrame.drawFlag) repaintHisto();
   }
   private void repaintHisto()
   {
     this.repaint(histRoundRect.x, histRoundRect.y, histRoundRect.width, histRoundRect.height);
   }
   // read global marker flag
   public boolean marker()
   {
     return m_marker != 0 ? true : false;
   }
   // read marker flag for hDisplay
   public boolean marker(int hDisplay)
   {
     if (hDisplay < 0 || hDisplay >= n_display)
       return marker();
     else if (histo[hDisplay] == null)
       return false;
     else
       return histo[hDisplay].markerFlag != 0 ? true : false;
   }
   // set marker flag for all displays shown
   public boolean marker(boolean MarkerOn)
   {
     return marker(MarkerOn, -1);
   }
   // set marker flag for hDisplay only
   public boolean marker(boolean MarkerOn, int hDisplay)
   {
     int num, ende;
     m_marker = MarkerOn ? 2 : 0; // mark what you see!
     num = hDisplay;
     if (num < 0 || num >= n_display)
     {
       num = 0;
       ende = n_display - 1;
     }
     else
       ende = num;
     for (; num <= ende; num++)
     {
       if (histo[num] == null) continue;
       if (m_marker == 0)
         histo[num].markerFlag = 0;
       else if (histo[num].displayON != 0) histo[num].markerFlag = 1;
     }
     if (m_marker == 2) setmarkerflag(1); // copy once only
     // prepareDraw(FALSE, -1, FALSE, 0);
     if (aFrame.drawFlag)
       prepareDraw(); // dont scale keep old limit
     else
       changeScaleWidth = 0;
     return m_marker != 0 ? true : false;
   }
   protected void setmarkerflag(int flag)
   {
     for (int n = 0; n < n_display; n++)
     {
       if (histo[n] == null) break;
       if (flag == 2 || histo[n].displayON != 0) histo[n].marker_ary_cpy = flag;
     }
   }
   public boolean isTagged(int index, int hDisplay)
   {
     return isTagged(index, -1, hDisplay);
   }
   public boolean isTagged(int index, int value, int hDisplay)
   {
     boolean tagon;
     int j, found, lasfDisp, lastTagON, start, stop;
     if (pTagColorArray == null) return false; // no hoistogram at all!
     if (index < -1) return false; // out of range, -1 to set colors for all
     found = 0;
     lastTagON = -1;
     if (hDisplay >= 0 && hDisplay < n_display) // tag one histogram only!
     {
       start = hDisplay;
       stop = start + 1;
     }
     else
     {
       start = 0;
       stop = n_display;
     }
     tagon = value == 1 ? true : false; // setting
     for (j = start; j < stop; j++) // loop all histograms to mark tagging color
     {
       if (histo[j] == null) break;
       if (histo[j].dismode == AcopConst.mode_histogram
           || histo[j].dismode == AcopConst.mode_histogram_rastoring
           || histo[j].dismode == AcopConst.mode_dots || histo[j].dismode == AcopConst.mode_rectangle
           || histo[j].dismode == AcopConst.mode_circle)
       {
         if (index >= histo[j].npoints) continue; // out of range
         if (found == 0) // first found
         {
           if (value < 0 || value > 1)
             // reading
             return index == -1 ? m_tagging : (histo[j].m_tagColorArray[index] == histo[j].vorColor ? false
                 : true);
           found = 1;
           lasfDisp = j;
         }
         if (index != -1) // set color for this index only
           histo[j].m_tagColorArray[index] = tagon ? histo[j].tagColor : histo[j].vorColor;
         else
           // set color for all indexes
           for (int i = 0; i < histo[j].npoints; i++)
             histo[j].m_tagColorArray[i] = tagon ? histo[j].tagColor : histo[j].vorColor;
         if (histo[j].tagHist != 0) lasfDisp = j;
         if (j == lastTagHisto && histo[j].displayON != 0) lastTagON = j;
       }
     }
     if (found == 0) return false;
     // last recalled, refreshed or drawed, and still be seen on screen
     if (lastTagON >= 0) lastDisp = lastTagON;
     if (m_tagging && aFrame.drawFlag)
     {
       if (index == -1)
         repaintHisto();
       else
       {
         int xpos, left, right, low = 0, high = 0;
         // loop all histograms to mark tagging color
         for (lasfDisp = start; lasfDisp < stop; lasfDisp++)
         {
           if (histo[lasfDisp] == null) break;
           xpos = histo[lasfDisp].ix[index];
           if (histo[lasfDisp].dismode == AcopConst.mode_histogram
               || histo[lasfDisp].dismode == AcopConst.mode_histogram_rastoring)
           {
             left = xpos - histo[lasfDisp].penWidth;
             right = xpos + histo[lasfDisp].penWidth;
           }
           else
           {
             left = xpos - histo[lasfDisp].xextent;
             right = xpos + histo[lasfDisp].xextent;
           }
           if (lasfDisp == start)
           {
             low = left;
             high = right;
             continue;
           }
           if (low > left) low = left;
           if (high < right) high = right;
         }
         tagRect.x = low + aFrame.histRect.x;
         tagRect.width = high - low;
         repaintTagging();
       }
     }
     return tagon;
   }
   protected void repaintTagging()
   {
     this.repaint(tagRect.x, tagRect.y, tagRect.width, tagRect.height);
   }
   public int getTaggedColor(Color[] ColorArray, int Npoints, int StartIndex, int hDisplay)
   {
     int format, num, start, ndata;
     int aryType, refType, NoInputY, DataSize, i, j, k;
     if (hDisplay < 0 || hDisplay >= n_display || histo[hDisplay] == null
         || histo[hDisplay].m_tagColorArray == null) return -1;
     num = Npoints; // number of points, at least 1 point
     if (num < 1) num = histo[hDisplay].npoints;
     start = StartIndex; // start point: 0 to (npoints-1)
     if (start < 0 || start >= histo[hDisplay].npoints) return -8;
     if (num + start > histo[hDisplay].npoints) num = histo[hDisplay].npoints - start;
     num += start;
     if (ColorArray == null) return -2;
     ndata = ColorArray.length;
     if (ndata < num - start) num = start + ndata;
     for (k = start; k < num; k++)
     {
       i = k - start;
       j = k < histo[hDisplay].npoints ? k : (k - histo[hDisplay].npoints);
       ColorArray[i] = histo[hDisplay].m_tagColorArray[j];
     }
     return num - start; // return number of valid data
   }
 
   public void setForeground(Color c)
   {
     //    super.setForeground(c);
     if (foreColor == c) return;
     //Color oldValue = foreColor;
     Color oldValue = getForeground();
     super.setForeground(c);
     foreColor = c;
     if (randomData == true)
     {
       rescaleFlag = 2;
       prepareDraw(); // rescale and reset limit
     }
 //    firePropertyChange("foreColor", oldValue, foreColor);
     firePropertyChange("foreground", oldValue, foreColor);
   }
   
 //  public java.awt.Color getForeground()
 //  {
 //    return foreColor;
 //  }
   public void setBackground(Color c)
   {
     if (backColor == c) return;
     Color oldValue = getBackground();
     super.setBackground(c);
     // cursorColor = ~(TranslateColor(m_cursorMarkerColor) ^ TranslateColor(GetBackColor())) & 0xffffff;
     if (m_cursorMarkerColor != null) rev_cursorMarkerColor = new Color(~m_cursorMarkerColor.getRGB() ^ ~c.getRGB());
     backColor = c;
     firePropertyChange("background", oldValue, backColor);
   }
   
   // PropertyDescriptor ReceiveQueueDepth = new
   // PropertyDescriptor("ReceiveQueueDepth",beanClass,
   // "getReceiveQueueDepth","setReceiveQueueDepth");
 //  protected java.awt.List listTextBox;
   JScrollPane listTextBox;
   JTextArea textArea;
   protected java.lang.String caption = "";
   protected int captionPosition;
   protected int barlineColorFilled;
   protected int frameWidth;
   // protected java.awt.Color frameForeColor;
   protected int frameLeftOffset;
   protected int frameRightOffset;
   protected int frameTopOffset;
   protected int frameBottomOffset;
   protected int displayMode;
   // protected double xMin;
   // protected double xMax;
   // protected double yMin;
   // protected double yMax;
   protected int drawWidth;
   // protected java.awt.Font frameFont;
   // protected int XTicks;
   protected double XScale;
   protected double XShift;
   protected int graphStyle;
   // protected int YTicks;
   protected double YScale;
   protected boolean wrapAround;
   protected double YShift;
   protected double YExtent;
   protected int screenDepth;
   protected int keepStyle;
   // protected boolean YGrid;
   // protected boolean XGrid;
   protected int zooming;
   // protected java.lang.String YAxisLabel = "";
   protected int keepWidth;
   protected boolean randomData;
   protected boolean randomText;
   // protected int XFineTicks;
   protected boolean invert;
   protected int drawStyle;
   // protected boolean XTickText;
   protected boolean reuseText;
   protected java.awt.Color keepColor;
   // protected boolean xBestScale;
   protected int averagingMode, averagingDepth;
   protected int FFT;
   protected double XExtent;
   // protected boolean YTickText;
   // protected int histogramPosition;
   // protected int YFineTicks;
   protected boolean reuseScreen;
   protected int textDepth;
   // protected java.lang.String XAxisLabel = "";
   // protected boolean yBestScale;
   protected boolean colorFilled;
   // protected boolean leftTimeLabel;
   protected int xlabelRotation;
   protected int printTextStickyAttribute;
   protected int printTextLocation;
   protected int printTextRotation;
   protected java.awt.Color m_tagColor;
   protected boolean m_tagging;
   protected java.awt.Color m_errorColor;
   protected java.awt.Color LeadingEdgeColor;
   protected int LeadingEdgeGapSize;
   protected int LeadingEdgeMotion;
   protected int LeadingEdgeMode;
   protected int LeadingEdgeWidth;
   protected int LeadingEdgeStyle;
   protected double LeadingEdgeXExtent;
   protected double LeadingEdgeYExtent;
   protected java.awt.Color m_markerColor;
   protected int m_markerMode;
   protected int m_markerStyle;
   protected int m_markerWidth;
   protected double m_markerXExtent;
   protected double m_markerYExtent;
   protected java.awt.Color m_cursorMarkerColor;
   protected java.awt.Color rev_cursorMarkerColor;
   protected int m_cursorMarkerMode;
   protected int m_cursorMarkerStyle;
   protected int m_cursorMarkerWidth;
   protected double m_cursorMarkerXExtent;
   protected double m_cursorMarkerYExtent;
   private AcopTransport acopTransport = null; //new AcopTransport();
   /**
    * @return Returns the acopTransport.
    */
   public AcopTransport getAcopTransport()
   {
     if (acopTransport == null) acopTransport = new AcopTransport();
     return acopTransport;
   }
   /**
    * @param acopTransport The acopTransport to set.
    */
   public void setAcopTransport(AcopTransport acopTransport)
   {
     this.acopTransport = acopTransport;
   }
   
   // private symantec.itools.beans.PropertyChangeSupport changes = null;
   // private symantec.itools.beans.VetoableChangeSupport veto = null;
   
 	/**
 	 * Returns popup manager for adding popup actions.
 	 *
 	 * @see com.cosylab.gui.components.util.PopupManageable#getPopupManager()
 	 */
 	public PopupManager getPopupManager()
 	{
 		if (popupManager == null) {
 			popupManager = new PopupManager(this, false);
 			popupManager.addAction(new AbstractAction("Preferences...") {
 				private static final long serialVersionUID = 1L;
 
 					public void actionPerformed(ActionEvent e)
 					{
 						getCustomizer().showDialog();
 					}
 				});
 		}
 
 		return popupManager;
 	}
 	
 	/**
 	 * Return true if the popup menu is enabled or false otherwise.
 	 * 
 	 * @return true if popup is enabled
 	 */
 	public boolean isPopupEnabled() {
 		return popupEnabled;
 	}
 	
 	/**
 	 * Enables or disables the popup menu.
 	 * 
 	 * @param enabled true if enable or false if disableds
 	 */
 	public void setPopupEnabled(boolean enabled) {
 		if (popupEnabled == enabled) return;
 		popupEnabled = enabled;
 		if (enabled) {
 			addMouseListener(getPopupManager().getMouseHook());
 		} else {
 			removeMouseListener(getPopupManager().getMouseHook());
 		}
 		firePropertyChange("popupEnabled",!popupEnabled,popupEnabled);
 	}
 	/**
 	 * Returns the Customizer instance for this component.
 	 *
 	 * @return the Customizer instance for this component.
 	 */
 	public AbstractCustomizerPanel getCustomizer()
 	{
 		if (customizer == null) {
 			customizer = AbstractCustomizerPanel.findCustomizer(this);
 			customizer.setObject(this);
 		}
 
 		return customizer;
 	}
 	
 	public boolean isZoomFlag() {
 		return zoomFlag;
 	}
 
 	/**
 	 * Sets the force width parameter. If true the set width will be forced
 	 * even if the mmount of data is huge.
 	 * 
 	 * @param force true if width is force or false otherwise
 	 */
 	public void setForceWidth(boolean force) {
 		if (forceWidth == force) return;
 		this.forceWidth = force;
 		firePropertyChange("forceWidth",!forceWidth,forceWidth);
 	}
 	
 	/**
 	 * Returns true if forced width is turned on or false otherwise.
 	 * 
 	 * @return true if on
 	 */
 	public boolean isForceWidth() {
 		return forceWidth;
 	}
 }