/*
    * 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.BasicStroke;
  import java.awt.Color;
  import java.awt.Point;
  import java.beans.Beans;
  
  public class AcopHisto
  {
    protected int hisIndex; // own histo index number
    protected int npoints; // display points
    protected int displayON, // on or off
        number, // the display order
        markerFlag, marker_ary_cpy, xextent, yextent;
    protected int lockFlag, dismode;
    protected int disBarHisto, disDots;
    protected int xlabON, disFlag, xlabLength;
    protected int wrapindex, wraphigh;
    protected double originxmin, originxmax; // x range
        // CPen pen;
        // LOGBRUSH lb, lbEdge, lbMarker;
    protected int penStyle, penWidth, halfWidth;
    protected BasicStroke stroke;
    protected java.awt.Color penColor;
    protected int pixelWidth;
    protected int[] ix, iy, imy; // converted int array, marker array
    protected double[] x, y; // input display data
    protected String[] str;
    protected double[] markery;
    // char *buf; // diaplay buffer (npoints*4*3] convert integer x and y arrays
    protected int[] dispOn, dispxOn, dispyOn; // diaplay flag for each point(on:
                                              // within the area)
    protected char[] disable;
    protected int[] dispindex; // diaplay index starting point
    protected int[] dispnumber; // number poinst to diaplay
    protected java.awt.Color[] m_tagColorArray; // keep tagged color
    protected java.lang.String[] xlab; // xlabel array
    protected double xext, yext;
    protected boolean colorfilled;
    protected int barlineColorFilled;
    protected int xaryFlag;
    // int aryinput,byref;
    protected int format;
    protected boolean saveInvert;
    protected int DrawDataSize;
    protected double saveYShift, saveYScale, saveXShift, saveXScale;
    protected short tagHist, initTagBuffer; // flag for tagging display
    protected java.awt.Color tagColor, vorColor; // tagging and histo background
                                                  // color for this histogram!
    protected boolean yScaleEnable, errWindowEnable;
    protected java.awt.Color errorColor;
    protected double err_xmin, err_xmax, err_ymin, err_ymax; // error window
                                                              // display rectangle
    protected int arrpoints, nextPos; // for appendscreen
    protected int gaps;
    protected int moving, fFT;
    protected int edgeIndex, edgeMode;
    // CPen edgePen;
    protected BasicStroke edgeStroke;
    protected int edgeStyle, edgeWidth;
    protected java.awt.Color edgeColor;
    protected double edgePercentX, edgePercentY;
    protected double edgeExtentX, edgeExtentY;
    protected int edgePixel;
    // CPen markerPen;
    protected BasicStroke mStroke;
    protected int markerStyle, markerWidth;
    protected java.awt.Color markerColor;
    protected int markerMode;
    protected double markerExtentX, markerExtentY;
    protected double markerPercentX, markerPercentY;
    protected int polycounter; // number of polypoints inside display window
    protected boolean yReferenceEnable;
    protected boolean bindSecondaryY;
    private Acop acop;
    private AcopFFT acopfft;
    private int dotsScale[] = {200, 200, 150, 140, 130, 120, 110, 105};
   public AcopHisto(Acop acop, int index)
   {
     this.acop = acop;
     npoints = 0;
     y = null;
     hisIndex = index;
     // {{INIT_CONTROLS
     // }}
   }
   // {{DECLARE_CONTROLS
   protected int disHisto(int start, int stop)
   {
     int i, j;
     for (j = start; j < stop; j++)
     {
       i = j < npoints ? j : j - npoints;
       if (disable[i] != 0) continue;
       disFlag++;
       disable[i] = 1; // disable
     }
     return 0;
   }
   protected static int getArrayLength(Object inputArray)
   {
     int length;
     if (inputArray == null)
       length = 0;
     else if (inputArray instanceof double[])
       length = ((double[]) inputArray).length;
     else if (inputArray instanceof float[])
       length = ((float[]) inputArray).length;
     else if (inputArray instanceof int[])
       length = ((int[]) inputArray).length;
     else if (inputArray instanceof short[])
       length = ((short[]) inputArray).length;
     else if (inputArray instanceof byte[])
       length = ((byte[]) inputArray).length;
     else if (inputArray instanceof char[])
       length = ((char[]) inputArray).length;
     else if (inputArray instanceof Color[])
       length = ((Color[]) inputArray).length;
     else
       length = 0;
     return length;
   }
   protected static int copyArray(double[] doubleArray, Object inputArray, int start, int length,
       int aryMaxNumber, int loadToDoubleArray)
   {
     int i, j, k;
     if (inputArray instanceof double[])
       for (k = start; k < length; k++)
       {
         i = k - start;
         j = k < aryMaxNumber ? k : (k - aryMaxNumber);
         if (loadToDoubleArray == 1)
           doubleArray[j] = (double) ((double[]) inputArray)[i];
         else
           ((double[]) inputArray)[i] = (double) doubleArray[j];
       }
     else if (inputArray instanceof float[])
       for (k = start; k < length; k++)
       {
         i = k - start;
         j = k < aryMaxNumber ? k : (k - aryMaxNumber);
         if (loadToDoubleArray == 1)
           doubleArray[j] = (double) ((float[]) inputArray)[i];
         else
           ((float[]) inputArray)[i] = (float) doubleArray[j];
       }
     else if (inputArray instanceof int[])
       for (k = start; k < length; k++)
       {
         i = k - start;
         j = k < aryMaxNumber ? k : (k - aryMaxNumber);
         if (loadToDoubleArray == 1)
           doubleArray[j] = (double) ((int[]) inputArray)[i];
         else
           ((int[]) inputArray)[i] = (int) doubleArray[j];
       }
     else if (inputArray instanceof short[])
       for (k = start; k < length; k++)
       {
         i = k - start;
         j = k < aryMaxNumber ? k : (k - aryMaxNumber);
         if (loadToDoubleArray == 1)
           doubleArray[j] = (double) ((short[]) inputArray)[i];
         else
           ((short[]) inputArray)[i] = (short) doubleArray[j];
       }
     else if (inputArray instanceof byte[])
       for (k = start; k < length; k++)
       {
         i = k - start;
         j = k < aryMaxNumber ? k : (k - aryMaxNumber);
         if (loadToDoubleArray == 1)
           doubleArray[j] = (double) ((byte[]) inputArray)[i];
         else
           ((byte[]) inputArray)[i] = (byte) doubleArray[j];
       }
     else if (inputArray instanceof char[])
       for (k = start; k < length; k++)
       {
         i = k - start;
         j = k < aryMaxNumber ? k : (k - aryMaxNumber);
         if (loadToDoubleArray == 1)
           doubleArray[j] = (double) ((char[]) inputArray)[i];
         else
           ((char[]) inputArray)[i] = (char) doubleArray[j];
       }
     else
       length = 0;
     return length;
   }
   protected static int copyCharArray(char[] charArray, Object inputArray, int length)
   {
     int i;
     if (inputArray instanceof double[])
       for (i = 0; i < length; i++)
         charArray[i] = (char) ((double[]) inputArray)[i];
     else if (inputArray instanceof float[])
       for (i = 0; i < length; i++)
         charArray[i] = (char) ((float[]) inputArray)[i];
     else if (inputArray instanceof int[])
       for (i = 0; i < length; i++)
         charArray[i] = (char) ((int[]) inputArray)[i];
     else if (inputArray instanceof short[])
       for (i = 0; i < length; i++)
         charArray[i] = (char) ((short[]) inputArray)[i];
     else if (inputArray instanceof byte[])
       for (i = 0; i < length; i++)
         charArray[i] = (char) ((byte[]) inputArray)[i];
     else if (inputArray instanceof char[])
       for (i = 0; i < length; i++)
         charArray[i] = (char) ((char[]) inputArray)[i];
     else
       length = 0;
     return length;
   }
   protected void keephisto()
   {
     boolean change;
     change = (penWidth != acop.keepWidth || penStyle != acop.keepStyle) ? true : false;
     penWidth = acop.keepWidth;
     halfWidth = penWidth / 2;
     penStyle = acop.keepStyle;
     penColor = acop.keepColor;
     if (change == false) return;
     stroke = AcopConst.createStroke(penWidth, penStyle);
   }
   protected int getDrawnData(Object Yarray, Object Xarray, int Npoints, int StartIndex, int hDisplay)
   {
     int length, num, start, i, j, k;
     num = Npoints; // number of points, at least 1 point
     if (num < 0)
       num = npoints;
     else if (num == 0) return -7;
     start = StartIndex; // start point: 0 to (npoints-1)
     if (start < 0)
       start = 0;
     else if (start >= npoints) return -8;
     if (num + start > npoints) num = npoints - start;
     num += start;
     if (Yarray == null && Xarray == null) return -2;
     if (disFlag != 0)
     {
       for (i = start; i < num; i++)
         if (disable[i] != 0) break;
       if (i != num) num = i;
       if (i == start) return -9; // no valid data
     }
     if (Yarray != null)
     {
       length = getArrayLength(Yarray);
       if (length < num - start)
         length += start;
       else
         length = num;
       copyArray(y, Yarray, start, length, npoints, 0);
     }
     if (Xarray != null)
     {
       length = getArrayLength(Xarray);
       if (length < num - start)
         length += start;
       else
         length = num;
       
       if (Xarray instanceof String[])
         for (k = start; k < num; k++)
         {
           i = k - start;
           j = k < npoints ? k : (k - npoints);
           if ( xlab != null  )
             ((String[])Xarray)[i] = xlab[j];
           else
             ((String[])Xarray)[i] = String.valueOf(j);
         }
       else
         copyArray(x, Xarray, start, num, npoints, 0);
     }
     return num - start; // return number of valid data
   }
   private double[] getPlotableArray(Object data)
   {
     if (data instanceof double[]) return (double[]) data;
     if (data instanceof float[])
     {
       int siz = ((float[])data).length;
       double[] x = new double[siz];
       for (int i = 0; i < siz; i++) x[i] = ((float[]) data)[i];
       return x;
     }
     if (data instanceof byte[])
     {
       int siz = ((byte[])data).length;
       double[] x = new double[siz];
       for (int i = 0; i < siz; i++) x[i] = ((byte[]) data)[i];
       return x;
     }
     if (data instanceof short[])
     {
       int siz = ((short[])data).length;
       double[] x = new double[siz];
       for (int i = 0; i < siz; i++) x[i] = ((short[]) data)[i];
       return x;
     }
     if (data instanceof int[])
     {
       int siz = ((int[])data).length;
       double[] x = new double[siz];
       for (int i = 0; i < siz; i++) x[i] = ((int[]) data)[i];
       return x;
     }
     if (data instanceof long[])
     {
       int siz = ((long[])data).length;
       double[] x = new double[siz];
       for (int i = 0; i < siz; i++) x[i] = ((long[]) data)[i];
       return x;
     }    
     return null;
   }
   protected int updateScreen(boolean AppendFlag, Object Yarray, int Npoints, int StartIndex, Object Xarray)
   {
     int format, i, num, start, j, ndata, fsize, k, newX;
     /*
      * SAFEARRAY FAR* sa; HRESULT hr; char *data; double *df;
      */
     double maximum, xpostmp;
     int aryType, saveNext;
     int refBegin, refEnd; // refresh screen left and right histoindexes
     int enaUpdate, changeStart;
     double lowTmp = 0, highTmp = 0;
     int autoTimeScaling, DataSize;
     boolean tmpboolean;
     double[] yaxis;
     double[] xaxis;
     if (acop.getAcopTransport() != null)
     {
       yaxis = acop.getAcopTransport().getYAxis(Yarray);
       xaxis = acop.getAcopTransport().getXAxis(Xarray);
     }
     else
     {
       yaxis = getPlotableArray(Yarray);
       xaxis = getPlotableArray(Xarray);
     }
     changeStart = 0;
     autoTimeScaling = 0;
     newX = 0;
     if (Npoints < 1)
       Npoints = AppendFlag ? 1 : npoints;
     else if (Npoints > npoints) return -7;
     num = Npoints; // number of points, at least 1 point
     start = StartIndex; // start point: 0 to (npoints-1)
     if (start >= npoints) return -8;
     if (start < 0)
       start = AppendFlag ? nextPos : 0;
     else if (start != nextPos) changeStart = 1;
     saveNext = nextPos;
     if (AppendFlag)
     {
       if (num + gaps > npoints) num = npoints - gaps;
       if (moving == 0)
       {
         // case 1
         if (start >= npoints || (start + num) > npoints)
         { // make a gap
           if (gaps != 0) disHisto(npoints - gaps, npoints);
           // make copy, what about x??
           for (j = 0, i = start - (npoints - gaps - num); i < start; i++, j++)
           {
             y[j] = y[i];
             if (markerFlag != 0) markery[j] = markery[i];
             if (acop.sca[0].xtime == 1) x[j] = x[i]; // time plot
           }
           // change start point
           start = npoints - gaps - num;
           refBegin = 0; // refresh whole screen
           refEnd = npoints;
         }
         else
         // case 2
         {
           // get data from start to start + num, refresh part screen start to
           // start + num, only
           refBegin = start; // refresh only this part
           refEnd = start + num;
         }
         nextPos = start + num;
       }
       else
       {
         fsize = 0;
         if (start >= npoints)
         {
           start = 0;
           fsize = 1;
         }
         if (gaps != 0)
         {
           if (changeStart != 0 || num > gaps)
             disHisto(start + num, start + num + gaps);
           else
             disHisto(start + gaps, start + num + gaps);
         }
         nextPos = start + num;
         // if ((start + num) >= disp[hDisplay]->npoints) disp[hDisplay]->nextPos
         // -= disp[hDisplay]->npoints;
         refBegin = start; // refresh this part + gaps
         refEnd = start + num + gaps;
         if (edgeMode != 0 && fsize != 0) refBegin = npoints - 1;
       }
       num += start;
     }
     else
     // case 0
     {
       if (num + start > npoints) num = npoints - start;
       num += start;
       refBegin = start;
       refEnd = num;
     }
     DataSize = 0;
     fsize = getArrayLength(yaxis);
     if (fsize <= 0)
     {
       if (AppendFlag) nextPos = saveNext;
       return fsize - 1;
     }
     if (fsize < num - start) num = start + fsize;
     enaUpdate = (AppendFlag || (num - start) < npoints) ? 1 : 0;
     // RedrawTextHist = 1;
     // df = disp[hDisplay]->y ; // load new y array
     // SetArrayFromVariant(df, data, start, num, format, aryType, DataSize,
     // disp[hDisplay]->npoints, 1);
     copyArray(y, yaxis, start, num, npoints, 1);
     acop.averagingScaling(y, start, num, hisIndex);
     for (k = start; k < num; k++)
     {
       j = k < npoints ? k : (k - npoints);
       // if ( fabs(disp[hDisplay]->shift) > 1.0e-14 ) df[j] +=
       // (disp[hDisplay]->number * disp[hDisplay]->shift);
       if (Math.abs(saveYShift) > AcopConst.zero_check) y[j] += saveYShift;// shift
                                                                           // first
       y[j] *= saveYScale;
       // enable refreshed or updated points
       if (disFlag != 0 && enaUpdate != 0 && disable[j] != 0)
       {
         disFlag--;
         disable[j] = 0; // enable for update
         if (dismode == AcopConst.mode_polyline)
         {
           dispxOn[j] = 0;
           dispyOn[j] = 0;
         }
       }
     }
     if (saveInvert) for (k = start; k < num; k++)
     {
       i = k < npoints ? k : (k - npoints);
       if (Math.abs(y[i]) > AcopConst.zero_check) y[i] = 1 / y[i];
     }
     // fft => overwrite y array !!! it works only when input whole array!!!
     if (fFT != 0)
     {
       double[] maxPerCut = new double[3];
       maxPerCut[1] = 0.5;
       maxPerCut[2] = 12;
       acopfft.fFT(npoints, y, y, maxPerCut, fFT);
     }
     if (AppendFlag && edgeMode != 0)
     {
       j = num - 1;
       edgeIndex = j < npoints ? j : (j - npoints);
     }
     // check Xarray
     DataSize = 0;
     fsize = getArrayLength(xaxis);
     // if ( fsize == 0 && (aryType || format == disp[hDisplay]->format) )
     if (fsize > 0)
     {
       if (fsize < num - start) num = start + fsize;
       copyArray(x, xaxis, start, num, npoints, 1);
       j = k;
       for (k = start; k < num; k++)
       {
         j = k < npoints ? k : (k - npoints);
         if (Math.abs(saveXShift) > AcopConst.zero_check) x[j] += saveXShift;// shift
                                                                             // first
         x[j] *= saveXScale;
       }
       // should check direction?????
       if (acop.sca[0].xtime == 1 && x[j] > acop.sca[0].max && x[j] > acop.sca[0].usermax)
         autoTimeScaling = (int) (x[j] + gaps * AcopConst.timeScale[acop.sca[0].time_scale]);
       newX = 1;
     }
     if (acop.aFrame.drawFlag == false && acop.m_lock == 0) acop.m_histstart = hisIndex;
     displayON = 1;
     acop.aFrame.drawFlag = true;
     if (dismode == AcopConst.mode_histogram || dismode == AcopConst.mode_histogram_rastoring
         || dismode == AcopConst.mode_dots || dismode == AcopConst.mode_rectangle
         || dismode == AcopConst.mode_circle)
     { // bring to top histogram!
       tagHist = 1;
       acop.lastTagHisto = hisIndex;
     }
     acop.lastDisp = hisIndex;
     // refresh new input data
     if (autoTimeScaling > 1 || (refEnd - refBegin) >= npoints || dismode >= AcopConst.mode_textbox)
     { // redraw complete curver
       if (autoTimeScaling > 1) // one should not use xbestsclae flag!
       {
         maximum = autoTimeScaling - acop.sca[0].usermax;
         acop.sca[0].setDispscale(acop.sca[0].min + maximum, acop.sca[0].max + maximum);
         acop.sca[0].usermin += maximum;
         acop.sca[0].usermax = autoTimeScaling;
         if (acop.sca[1].log != 0)
           acop.sca[1].setDispscale(Math.pow(10.0, acop.sca[1].min), Math.pow(10.0, acop.sca[1].max));
         tmpboolean = acop.sca[0].bestScale;
         acop.sca[0].bestScale = false;
         acop.sca[0].scaleToGrid();
         if (acop.m_marker == 2) acop.setmarkerflag(2); // recalculate marker
                                                         // array
         acop.rescaleFlag = 1;
         acop.rescaleTextFlag = AcopConst.NEW_ZOOM_WINDOW;
         acop.prepareDraw();
         // de.desy.acop.chart.repaint(de.desy.acop.chart.sca[0].ticksRect.x, -de.desy.acop.chart.sca[0].ticksRect.y
         // ,de.desy.acop.chart.sca[0].ticksRect.width, de.desy.acop.chart.sca[0].ticksRect.height);
         // prepareDraw(TRUE, -1, FALSE, nScaleText); // rescale and not set max
         // limit
         acop.sca[0].bestScale = tmpboolean;
       }
       else
       {
         if (acop.wrapAround && acop.sca[0].log == 0) setwrapindex(); // find
                                                                       // wrapindex
         if (acop.m_marker == 2) acop.setmarkerflag(2); // recalculate marker
                                                         // array
         acop.histIndex = hisIndex;
         acop.prepareDraw();
         // prepareDraw(FALSE,hDisplay,FALSE, 0);
       }
     }
     else
     { // fast update
       int[] repLow = new int[2];
       int[] repHigh = new int[2];
       int repeat, lowFlag;
       int xpos1 = 0, xpos2, ittpp, xonLast = 0, yonLast = 0;
       // int *iy, *ix, n;
       double xtemp = 0, ytemp, ttpp, xlast = 0, ylast = 0;
       double lowT = 0, highT = 0, ttmmpp = 0;
       int xxPP = 0; // temperary
       double overflow;
       // LPPOINT ipoint;
       boolean xlow, xhigh, ylow, yhigh;
       repLow[0] = refBegin;
       if (refEnd > npoints || refEnd < refBegin) // Appendscreen case 5
       {
         repeat = 2;
         repHigh[0] = npoints;
         repLow[1] = 0;
         repHigh[1] = refEnd > npoints ? refEnd - npoints : refEnd;
       }
       else
       {
         repeat = 1;
         repHigh[0] = refEnd;
       }
       for (k = 0; k < repeat; k++)
       { // preset for finding refresh window
         xpostmp = xaryFlag == 1 ? -1.7e+308 : 1.7e+308;
         lowFlag = 0;
         lowTmp = 1.7e+308; // for case of ( disp[n]->xaryFlag > 1 )
         highTmp = -1.7e+308;
         for (i = (repLow[k] != 0 ? repLow[k] - 1 : repLow[k]); i < (repHigh[k] == npoints ? repHigh[k]
             : repHigh[k] + 1); i++)
         {
           ytemp = acop.sca[1].log != 0 ? Math.log(AcopConst.log_check(y[i])) / Math.log(10) : y[i];
           xtemp = correctWrapPosition(i);
           ix[i] = (int) ((xtemp - acop.sca[0].min) / acop.sca[0].dispSize * acop.aFrame.dxwidth
               + acop.aFrame.xleft + 0.01);
           iy[i] = (int) (acop.aFrame.histRect.height - ((ytemp - acop.sca[1].min) / acop.sca[1].dispSize * acop.aFrame.histRect.height));
           if (i < repLow[k]) // get left point x position
           {
             if (disable[i] == 0 && (dismode == AcopConst.mode_barline ? dispxOn[i] : dispOn[i]) != 0)
             {
               xpostmp = xtemp;
               lowFlag = 1;
             }
           }
           else if (i < repHigh[k]) // refresh points
           {
             xlow = xtemp < acop.sca[0].min ? true : false;
             xhigh = xtemp > acop.sca[0].max ? true : false;
             ylow = ytemp < acop.sca[1].min ? true : false;
             yhigh = ytemp > acop.sca[1].max ? true : false;
             if (dismode != AcopConst.mode_polyline)
             {
               if (dismode == AcopConst.mode_barline)
               {
                 dispxOn[i] = (xlow || xhigh) ? 0 : 1;
                 dispyOn[i] = (ylow || yhigh) ? 0 : 1;
                 if (i != (repLow[k] != 0 ? repLow[k] - 1 : repLow[k])) // avoid
                                                                         // first
                                                                         // index
                 {
                   if ((dispxOn[i] == 0 && xonLast == 0
                       && ((xlow && xlast > acop.sca[0].max) || (xlast < acop.sca[0].min && xhigh)) && yonLast != 0)
                       || (dispyOn[i] == 0 && yonLast == 0
                           && ((ylow && ylast > acop.sca[1].max) || (ylast < acop.sca[1].min && yhigh)) && dispxOn[i] != 0))
                   {
                     dispxOn[i] = 1;
                     dispyOn[i] = 1;
                   }
                 }
                 // store last value from the first index of the loop
                 xonLast = dispxOn[i];
                 yonLast = dispyOn[i];
                 xlast = xtemp;
                 ylast = ytemp;
                 dispOn[i] = dispxOn[i] * dispyOn[i];
               }
               else if (dismode == AcopConst.mode_dots || dismode == AcopConst.mode_rectangle
                   || dismode == AcopConst.mode_circle)
               {
                 dispOn[i] = (xlow || xhigh || ylow || yhigh) ? 0 : 1;
               }
               else
                 dispOn[i] = (xlow || xhigh) ? 0 : 1;
               if (disable[i] != 0) dispOn[i] = 0; // disable this point
               if (dismode == AcopConst.mode_histogram || dismode == AcopConst.mode_histogram_rastoring)
               { // avoid 100% cpu time to display a huge number!!
                 if (iy[i] < 0)
                   iy[i] = -20;
                 else if (iy[i] > acop.aFrame.histRect.height) iy[i] = acop.aFrame.histRect.height + 20;
               }
             }
             else
             // fastest drawing mode is to use polyline()
             {
               dispOn[i] = disable[i] != 0 ? 0 : 1;
               if (dispOn[i] != 0)
               {
                 dispxOn[i] = 0;
                 if (xlow) dispxOn[i] |= 0x1; // mask 4 cases
                 if (xhigh) dispxOn[i] |= 0x2;
                 if (ylow) dispxOn[i] |= 0x4;
                 if (yhigh) dispxOn[i] |= 0x8;
                 if (dispxOn[i] == 0)
                 {
                   if (dispyOn[i] == 0) // not marked yet
                   {
                     dispyOn[i] = 1; // point inside
                     polycounter++;
                   }
                 }
                 else
                 {
                   if (dispyOn[i] != 0) // was marked
                   {
                     dispyOn[i] = 0; // point outside
                     polycounter--;
                   }
                 }
               }
             }
             if (marker_ary_cpy != 0 && markerFlag != 0) loadMarker(i);
             if (newX != 0 && xaryFlag <= 1 && lowFlag == 1) // check x direction
             {
               if (xaryFlag == 1)
               {
                 if (xpostmp < xtemp) xaryFlag = 2;
               }
               else if (xpostmp > xtemp) xaryFlag = 2;
             }
             if (i == repLow[k] && xaryFlag <= 1) // calculate xpos1 for
                                                   // freshscreen area
             {
               if (lowFlag == 1)
               {
                 if (xaryFlag == 1)
                 {
                   ttpp = xpostmp > xtemp ? xpostmp : xtemp;
                   if (xpostmp > xtemp) xpostmp = xtemp; // select small one
                 }
                 else
                 {
                   ttpp = xpostmp < xtemp ? xpostmp : xtemp;
                   if (xpostmp < xtemp) xpostmp = xtemp; // select large one
                 }
               }
               else
               {
                 xpostmp = xtemp; // set the left one as xpos1
                 lowFlag = 1;
                 ttpp = xtemp;
               }
               xpos1 = (int) ((ttpp - acop.sca[0].min) / acop.sca[0].dispSize * acop.aFrame.dxwidth
                   + acop.aFrame.xleft + 0.01);
             }
             // compare every point for xpos2
             if ((dismode == AcopConst.mode_barline ? dispxOn[i] : dispOn[i]) != 0)
             {
               if (xaryFlag == 1)
               {
                 if (xpostmp > xtemp) xpostmp = xtemp; // select small one
               }
               else
               {
                 if (xpostmp < xtemp) xpostmp = xtemp; // select large one
               }
             }
           }
           else
           { // get right point x position
             if (disable[i] == 0 && (dismode == AcopConst.mode_barline ? dispxOn[i] : dispOn[i]) != 0)
             {
               if (xaryFlag <= 1)
               {
                 if (xaryFlag == 1 ? (xpostmp < xtemp) : (xpostmp > xtemp)) xtemp = xpostmp;
               }
               if (newX != 0 && xaryFlag <= 1 && lowFlag == 1) // check x
                                                               // direction
               {
                 if (xaryFlag == 1)
                 {
                   if (xpostmp < xtemp) xaryFlag = 2;
                 }
                 else if (xpostmp > xtemp) xaryFlag = 2;
               }
             }
             // else if (repeat == 1)xtemp = xpostmp; // load valid xtemp
           }
           // if ( disp[n]->xaryFlag > 1 ) // mixed up and down x
           if (disable[i] == 0 && (dismode == AcopConst.mode_barline ? dispxOn[i] : dispOn[i]) != 0)
           {
             if (xtemp < lowTmp) lowTmp = xtemp;
             if (xtemp > highTmp) highTmp = xtemp;
           }
         }
         if (repeat == 2 && k == 0) // save first part
         {
           lowT = lowTmp;
           highT = highTmp;
           ttmmpp = xtemp;
           xxPP = xpos1; // temperary
         }
       }
       if (dismode == AcopConst.mode_polyline) makePolyArray();
       if (marker_ary_cpy != 0 && markerFlag != 0) marker_ary_cpy = 0;
       for (k = repeat - 1; k >= 0; k--)
       {
         if (repeat == 2 && k == 0)
         {
           lowTmp = lowT;
           highTmp = highT;
           xtemp = ttmmpp;
           xpos1 = xxPP; // restore
         }
         if (xaryFlag <= 1)
         {
           xpos2 = (int) ((xtemp - acop.sca[0].min) / acop.sca[0].dispSize * acop.aFrame.dxwidth
               + acop.aFrame.xleft + 0.01);
         }
         else
         {
           xpos1 = (int) ((lowTmp - acop.sca[0].min) / acop.sca[0].dispSize * acop.aFrame.dxwidth
               + acop.aFrame.xleft + 0.01);
           xpos2 = (int) ((highTmp - acop.sca[0].min) / acop.sca[0].dispSize * acop.aFrame.dxwidth
               + acop.aFrame.xleft + 0.01);
         }
         // if ( (xpos1 >= de.desy.acop.chart.aFrame.histRect.x && xpos1 <=
         // de.desy.acop.chart.aFrame.histRect.x + de.desy.acop.chart.aFrame.histRect.width) ||
         // (xpos2 >= de.desy.acop.chart.aFrame.histRect.x && xpos2 <= de.desy.acop.chart.aFrame.histRect.x +
         // de.desy.acop.chart.aFrame.histRect.width) )
         if ((xpos1 >= 0 && xpos1 <= acop.aFrame.histRect.width)
             || (xpos2 >= 0 && xpos2 <= acop.aFrame.histRect.width))
         {
           if (xaryFlag == 1)
           {
             ittpp = xpos1;
             xpos1 = xpos2;
             xpos2 = ittpp;
           }
           fsize = (edgeMode != 0 && edgePixel > 2) ? (edgePixel + 1) * acop.aFrame.histRect.width : 0;
           if (xpos1 <= xpos2)
           {
             if (xpos1 < 0) xpos1 = 0;
             if (xpos2 > acop.aFrame.histRect.width)
               xpos2 = acop.aFrame.histRect.width;
             else
               xpos2 += penWidth; // disp[tagHist]
             acop.tagRect.x = xpos1 - fsize + acop.aFrame.histRect.x; // +de.desy.acop.chart.tagRect.x;
             acop.tagRect.width = xpos2 + fsize - xpos1 + fsize;
             acop.repaintTagging();
           }
           else
           {
             if (xpos1 < acop.aFrame.histRect.width)
             {
               acop.tagRect.x = xpos1 - fsize + acop.aFrame.histRect.x;
               acop.tagRect.width = acop.aFrame.histRect.width - (xpos1 - fsize);
               acop.repaintTagging();
             }
             if (xpos2 > 0)
             {
               if (xpos2 < acop.aFrame.histRect.width) xpos2 += penWidth; // disp[tagHist]
               acop.tagRect.x = acop.aFrame.histRect.x;
               acop.tagRect.width = xpos2;
               acop.repaintTagging();
             }
           }
         }
       }
     }
     return num - 1; // last updated point, before was hDisplay;
   }
   protected int setHisto(Object ydata, Object xdata, Object dis, java.lang.String[] xlabel, int arraySize,
       int maxNumber, java.awt.Color c)
   {
     int inputNumber, ndata, i, xlength, dislength, tmpPoints;
     int itmp = 0, fftret = 0;
     if (ydata instanceof String[])
     {
       ndata = ((String[]) ydata).length;
       str = new String[ndata];
       for (i = 0; i < ndata; i++)
         str[i] = ((String[]) ydata)[i];
       npoints = ndata;
       return 0;
     }
     if (ydata instanceof String)
     {
       str = ((String) ydata).split("\n");
       npoints = str.length;
       return 0;
     }
     str = null;
     double[] yaxis; // = acop.getAcopTransport().getYAxis(ydata);
     double[] xaxis; // = acop.getAcopTransport().getXAxis(xdata);
     if (acop.getAcopTransport() != null && !Beans.isDesignTime())
     {
       yaxis = acop.getAcopTransport().getYAxis(ydata);
       xaxis = acop.getAcopTransport().getXAxis(xdata);
     }
     else
     {
       yaxis = getPlotableArray(ydata);
       xaxis = getPlotableArray(xdata);
     }
     if (ydata == null) npoints = 0;
     ndata = getArrayLength(yaxis); // ydata.length;
     if (arraySize > 0 && arraySize < ndata) ndata = arraySize; // user given
                                                                 // input size
     xlength = getArrayLength(xaxis);
     dislength = getArrayLength(dis);
     inputNumber = ndata; // at least y array size or less if user give a
                           // smaller number!
     if (maxNumber > ndata) ndata = maxNumber; // user request more memory to be
                                               // allocated!
     if (ndata <= (acop.globalDisplayMode < AcopConst.mode_histogram ? 1 : 0)) return -1;
     for (i = 0; i < 2; i++)
       if (acop.sca[i].usermax <= acop.sca[i].usermin && acop.sca[i].bestScale == false
           && acop.sca[i].log == 0) return -1;
     if (ndata > AcopConst.max_points) ndata = AcopConst.max_points;
     if (y == null || y.length < ndata)
     {
       displayON = 0;
       markerFlag = 0;
       marker_ary_cpy = 0;
       lockFlag = 0;
       if (acop.pTagColorArray == m_tagColorArray) acop.pTagColorArray = null;
       iy = new int[ndata];
       ix = new int[ndata];
       imy = new int[ndata];
       y = new double[ndata];
       x = new double[ndata];
       markery = new double[ndata];
       dispOn = new int[ndata];
       dispxOn = new int[ndata];
       dispyOn = new int[ndata];
       disable = new char[ndata];
       dispindex = new int[ndata];
       dispnumber = new int[ndata];
       m_tagColorArray = new java.awt.Color[ndata];
 //      xlab = new java.lang.String[ndata];
       wrapindex = 0; // drawing dtart index for wraparound
       wraphigh = 0; // right boundary greater than s_xmax
       disFlag = 0;
       originxmin = -1.7e+308;
       originxmax = 1.7e+308;
       initTagBuffer = 0;
       errWindowEnable = acop.errWindowOn;
       yScaleEnable = acop.ScaleEnable;
       yReferenceEnable = acop.ReferenceEnable;
       err_xmin = acop.e_xmin;
       err_xmax = acop.e_xmax;
       err_ymin = acop.e_ymin;
       err_ymax = acop.e_ymax;
       edgeIndex = 0;
     }
     bindSecondaryY = false;
     arrpoints = inputNumber; // input data length, user given or y size
     npoints = ndata; // total displayable data
     if (xlength > ndata) xlength = ndata;
     if (dislength > ndata) dislength = ndata;
     errorColor = acop.m_errorColor;
     polycounter = 0;
     if ( npoints > 5000 && acop.drawWidth > 1 && !acop.forceWidth) acop.drawWidth = 1; //2008-11 hwu
     if (stroke == null || penWidth != acop.drawWidth || penStyle != acop.drawStyle)
     {
       penWidth = acop.drawWidth;
       penStyle = acop.drawStyle;
       stroke = AcopConst.createStroke(penWidth, penStyle);
     }
     penColor = c; // getForeground();
     halfWidth = acop.drawWidth / 2;
     xaryFlag = 0;
     // fill in the LeadingEdge parameters here:
     gaps = acop.LeadingEdgeGapSize;
     if (gaps >= npoints) gaps = 0;
     moving = acop.LeadingEdgeMotion;
     edgeMode = acop.LeadingEdgeMode;
     edgeExtentX = acop.LeadingEdgeXExtent;
     edgeExtentY = acop.LeadingEdgeYExtent;
     edgePercentX = -1;
     edgePercentY = -1;
     edgePixel = acop.LeadingEdgeWidth; // de.desy.acop.chart.aFrame.dxwidth;
     edgeColor = acop.LeadingEdgeColor;
     if (edgeStroke == null || edgeWidth != acop.LeadingEdgeWidth || edgeStyle != acop.LeadingEdgeStyle)
       edgeStroke = AcopConst.createStroke(acop.LeadingEdgeWidth, acop.LeadingEdgeStyle);
     edgeWidth = acop.LeadingEdgeWidth;
     edgeStyle = acop.LeadingEdgeStyle;
     // fill in the marker parameters here:
     if (mStroke == null || markerWidth != acop.m_markerWidth || markerStyle != acop.m_markerStyle)
       mStroke = AcopConst.createStroke(acop.m_markerWidth, acop.m_markerStyle);
     markerMode = acop.m_markerMode;
     markerStyle = acop.m_markerStyle;
     markerWidth = acop.m_markerWidth;
     markerColor = acop.m_markerColor;
     markerExtentX = acop.m_markerXExtent;
     markerExtentY = acop.m_markerYExtent;
     markerPercentX = -1;
     markerPercentY = -1;
     if (acop.globalDisplayMode == AcopConst.mode_histogram
         || acop.globalDisplayMode == AcopConst.mode_histogram_rastoring || acop.globalDisplayMode == AcopConst.mode_dots
         || acop.globalDisplayMode == AcopConst.mode_rectangle || acop.globalDisplayMode == AcopConst.mode_circle)
     { // bring to top histogram!
       if (acop.pTagColorArray == null) // init tagColorArray only for first
                                         // time, Dont care data size changed!!
       {
         acop.nElement = ndata;
         for (i = 0; i < ndata; i++)
           m_tagColorArray[i] = penColor;
         acop.pTagColorArray = m_tagColorArray;
         acop.TagBackColor = penColor;
       }
       else if (initTagBuffer == 0
           || (dismode != AcopConst.mode_histogram && dismode != AcopConst.mode_histogram_rastoring
               && dismode != AcopConst.mode_dots && dismode != AcopConst.mode_rectangle && dismode != AcopConst.mode_circle))
       { // new buffer or change mode ==> sign new backgroud color (tagging
         // inheritance!!)
         for (i = 0; i < ndata; i++)
         {
           if (i < acop.nElement)
             m_tagColorArray[i] = acop.TagBackColor == acop.pTagColorArray[i] ? penColor
                 : acop.pTagColorArray[i];
           else
             m_tagColorArray[i] = penColor;
         }
         acop.pTagColorArray = m_tagColorArray;
         acop.TagBackColor = penColor;
         acop.nElement = ndata;
       }
       else if (vorColor != penColor)
       { // only change vorcolor
         for (i = 0; i < ndata; i++)
           if (m_tagColorArray[i] == vorColor) m_tagColorArray[i] = penColor;
         acop.pTagColorArray = m_tagColorArray;
         acop.TagBackColor = penColor;
         acop.nElement = ndata;
       }
       initTagBuffer = 1;
       tagHist = 1;
       tagColor = acop.m_tagColor; // store pen color and tagging color, sign top
                                   // hist number
       vorColor = penColor; // TagBackColor;
       acop.lastTagHisto = hisIndex;
     }
     else
       tagHist = 0;
     if (xlabel == null)
       xlabON = 0;
     else
     {
       xlabON = 1;
       xlabLength = xlabel.length;
       if ( xlab == null || xlab.length != ndata) xlab = new java.lang.String[ndata];
       for (i = 0; i < xlabel.length; i++)
       {
         if (i >= ndata) break;
         xlab[i] = xlabel[i];
       }
     }
     tmpPoints = arrpoints < npoints ? arrpoints : npoints;
     copyArray(y, yaxis, 0, tmpPoints, tmpPoints, 1);
     acop.averagingScaling(y, 0, npoints, hisIndex);
     if (xlength != 0) copyArray(x, xaxis, 0, xlength, xlength, 1);
     for (i = xlength; i < tmpPoints; i++)
     {
       if (xaxis == null)
         x[i] = i;
       else
         x[i] = x[xlength - 1];
     }
     disFlag = 0;
     if (dislength != 0) copyCharArray(disable, dis, dislength);
     for (i = 0; i < tmpPoints; i++)
     {
       if (dis == null)
         disable[i] = 0;
       else if (i < dislength)
       {
         if (disable[i] != 0) disFlag++;
       }
       else
       {
         disable[i] = 1;
         disFlag++;
       }
     }
     if (arrpoints < npoints) for (i = arrpoints; i < ndata; i++)
     {
       y[i] = y[arrpoints - 1];
       x[i] = x[arrpoints - 1];
       disable[i] = 1;
       disFlag++;
     }
     for (i = 0; i < ndata; i++)
     {
       if (i >= npoints) break;
       if (Math.abs(acop.XShift) > AcopConst.zero_check) x[i] += acop.XShift; // shift
                                                                               // first
       if (Math.abs(acop.XScale) > AcopConst.zero_check) x[i] *= acop.XScale;
       if (Math.abs(acop.YShift) > AcopConst.zero_check) y[i] += acop.YShift; // shift
                                                                               // first
       if (Math.abs(acop.YScale) > AcopConst.zero_check) y[i] *= acop.YScale;
       if (acop.invert && Math.abs(y[i]) > AcopConst.zero_check) y[i] = 1 / y[i];
       if (xaxis == null) continue; // dont check x array
       if (i > 0)
       {
         if (itmp == 0) // check down
         {
           if (x[i] < x[i - 1])
           {
             fftret++;
             if (i != 1 && fftret == 1) fftret++; // catch first up then down
             itmp = 1;
           }
         }
         else
         { // check up
           if (x[i] > x[i - 1])
           {
             fftret++;
             itmp = 0;
           }
         }
       }
     }
     saveXShift = acop.XShift;
     saveXScale = acop.XScale;
     saveYShift = acop.YShift;
     saveYScale = acop.YScale;
     saveInvert = acop.invert;
     if (xaxis == null)
       xaryFlag = acop.XShift < 0 ? 1 : 0;
     else
       xaryFlag = fftret;
     fFT = acop.FFT;
     if (fFT != 0) // fft => overwrite y array
     {
       if (acopfft == null) acopfft = new AcopFFT();
       double[] maxPerCut = new double[3];
       maxPerCut[1] = 0.5;
       maxPerCut[2] = 12;
       acopfft.fFT(npoints, y, y, maxPerCut, fFT);
     }
     nextPos = disFlag < npoints ? npoints : 0;
     // set nextPos for Appendscreen if available data points are less then
     // requested maxpoints
     if (arrpoints < npoints && disFlag == npoints - arrpoints) nextPos = arrpoints;
     return 0;
   }
   private Color selTagErrPen(java.awt.Graphics2D a, int i, Color lastColor)
   {
     Color selColor;
     // error color take precedence
     if (errWindowEnable && (x[i] < err_xmin || x[i] > err_xmax || y[i] < err_ymin || y[i] > err_ymax))
       selColor = errorColor;
     else if (tagHist != 0 && acop.m_tagging)
       selColor = m_tagColorArray[i];
     else
       selColor = penColor;
     if (selColor != lastColor) a.setColor(selColor);
     return selColor;
   }
   protected void setExtent()
   {
     if (dismode != AcopConst.mode_rectangle && dismode != AcopConst.mode_circle && dismode != AcopConst.mode_dots && disDots == 0 ) return;
     if ( dismode != AcopConst.mode_dots && disDots == 0 )
     {
       xextent = (short) (acop.aFrame.dxwidth * Math.abs(xext / 2) / (acop.sca[0].log != 0 ? (Math.pow(10.0,
         acop.sca[0].max) - Math.pow(10.0, acop.sca[0].min)) : acop.sca[0].dispSize));
       yextent = (short) (acop.aFrame.histRect.height * Math.abs(yext / 2) / (acop.sca[1].log != 0 ? (Math.pow(
         10.0, acop.sca[1].max) - Math.pow(10.0, acop.sca[1].min)) : acop.sca[1].dispSize));   
     }
     else if ( disDots != 0 )
     {
       if ( penWidth > 7 )
       {
         xextent = penWidth * 105 / 100;
         yextent = penWidth * 105 / 100;
       }
       else
       {
         xextent = penWidth * dotsScale[penWidth] / 100;
         yextent = penWidth * dotsScale[penWidth] / 100;
       }
     }
     else
     {
       xextent = 1;
       yextent = 1;     
     }
     if (xextent == 0) xextent = penWidth;
     if (yextent == 0) yextent = penWidth;
   }
   private void loadMarker(int i)
   {
     double ytemp;
     if (marker_ary_cpy == 1) // store marker array
     {
       markery[i] = y[i];
       imy[i] = iy[i];
     }
     else
     // get stored marker array
     {
       ytemp = acop.sca[1].log != 0 ? Math.log(AcopConst.log_check(markery[i])) / Math.log(10) : markery[i];
       imy[i] = (int) (acop.aFrame.histRect.height - ((ytemp - acop.sca[1].min) / acop.sca[1].dispSize * acop.aFrame.histRect.height));
       // avoid 100% cpu time to display a huge number!!
       if (imy[i] < 0)
         imy[i] = -20;
       else if (imy[i] > acop.aFrame.histRect.height) imy[i] = acop.aFrame.histRect.height + 20;
     }
   }
   private double correctWrapPosition(int i)
   {
     double xtemp;
     xtemp = acop.sca[0].log != 0 ? Math.log(AcopConst.log_check(x[i])) / Math.log(10) : x[i];
     if (acop.wrapAround == false || wraphigh == 0 || acop.sca[0].log != 0) return xtemp;
     if (wraphigh < 0)
     {
       if (i >= -(wraphigh + 1))
       {
         if (xaryFlag == 1)
           xtemp += (acop.wrapxmax - acop.wrapxmin);
         else
           xtemp -= (acop.wrapxmax - acop.wrapxmin);
       }
     }
     else
     {
       if (i < wraphigh)
       {
         if (xaryFlag == 1)
           xtemp -= (acop.wrapxmax - acop.wrapxmin);
         else
           xtemp += (acop.wrapxmax - acop.wrapxmin);
       }
     }
     return xtemp;
   }
   protected void mapScreen(int index)
   {
     double xtemp, ytemp;
     int kk, i, start, stop, scaleIndex;
     boolean xlow, xhigh, ylow, yhigh;
     int xonLast = 0, yonLast = 0;
     double xlast = 0, ylast = 0;
     String stmp;
     if (index < 0)
     {
       start = 0;
       stop = npoints;
       polycounter = 0;
     }
     else
     {
       start = index;
       stop = index + 1;
     }
     String allStmp = "";
     scaleIndex = bindSecondaryY ? 2 : 1;
     for (kk = start, i = wrapindex; kk < stop; kk++, i++)
     {
       if (i >= npoints) i = 0;
       if (dismode == AcopConst.mode_textbox)
       {
         if (str != null)
         {
           if (i >= str.length) return;
           stmp = "(" + String.valueOf(hisIndex) + "," + String.valueOf(i) + ")  " + str[i];
         }
         else
         {
           stmp = "(" + String.valueOf(hisIndex) + "," + String.valueOf(i) + ")  " + String.valueOf(x[i])
               + "    " + AcopConst.textFormat.format(y[i]);
         }
         if (disable != null && i < disable.length && disable[i] != 0) stmp += " [disabled]";
 //        acop.listTextBox.add(stmp); // addItem(stmp);
         allStmp = allStmp + stmp + "\n";
         continue;
       }
       ytemp = acop.sca[scaleIndex].log != 0 ? Math.log(AcopConst.log_check(y[i])) / Math.log(10) : y[i];
       xtemp = correctWrapPosition(i);
       ix[i] = (int) ((xtemp - acop.sca[0].min) / acop.sca[0].dispSize * acop.aFrame.dxwidth
           + acop.aFrame.xleft + 0.01);
       iy[i] = (int) (acop.aFrame.histRect.height - ((ytemp - acop.sca[scaleIndex].min) / acop.sca[scaleIndex].dispSize * acop.aFrame.histRect.height));
       xlow = xtemp < acop.sca[0].min ? true : false;
       xhigh = xtemp > acop.sca[0].max ? true : false;
       ylow = ytemp < acop.sca[scaleIndex].min ? true : false;
       yhigh = ytemp > acop.sca[scaleIndex].max ? true : false;
       if (ix[i] < -acop.aFrame.histRect.width * 4)
         ix[i] = -acop.aFrame.histRect.width * 4;
       else if (ix[i] > acop.aFrame.histRect.width * 4) ix[i] = acop.aFrame.histRect.width * 4;
       if (dismode != AcopConst.mode_polyline) // map x,y to display area
       {
         if (dismode == AcopConst.mode_barline)
         {
           dispxOn[i] = (xlow || xhigh) ? 0 : 1;
           dispyOn[i] = (ylow || yhigh) ? 0 : 1;
           if ((wrapindex != npoints && i != wrapindex) || (wrapindex == npoints && i != 0)) // avoid
                                                                                             // first
                                                                                             // point
           {
             if ((dispxOn[i] == 0 && xonLast == 0
                 && ((xlow && xlast > acop.sca[0].max) || (xlast < acop.sca[0].min && xhigh)) && yonLast != 0)
                 || (dispyOn[i] == 0 && yonLast == 0
                     && ((ylow && ylast > acop.sca[scaleIndex].max) || (ylast < acop.sca[scaleIndex].min && yhigh)) && dispxOn[i] != 0))
             {
               dispxOn[i] = 1;
               dispyOn[i] = 1;
             }
           }
           // store last value
           xonLast = dispxOn[i];
           yonLast = dispyOn[i];
           xlast = xtemp;
           ylast = ytemp;
           dispOn[i] = dispxOn[i] * dispyOn[i];
         }
         else if (dismode == AcopConst.mode_dots || dismode == AcopConst.mode_rectangle
             || dismode == AcopConst.mode_circle)
         {
           dispOn[i] = (xlow || xhigh || ylow || yhigh) ? 0 : 1;
         }
         else
           dispOn[i] = (xlow || xhigh) ? 0 : 1;
         if (disable[i] != 0) dispOn[i] = 0; // disable this point
         if (dismode == AcopConst.mode_histogram || dismode == AcopConst.mode_histogram_rastoring)
         { // avoid 100% cpu time to display a huge number!!
           if (iy[i] < 0)
             iy[i] = -20;
           else if (iy[i] > acop.aFrame.histRect.height) iy[i] = acop.aFrame.histRect.height + 20;
         }
       }
       else
       // fastest drawing mode is to use polyline()
       {
         dispOn[i] = disable[i] != 0 ? 0 : 1;
         if (dispOn[i] != 0)
         {
           dispxOn[i] = 0;
           dispyOn[i] = 0;
           if (xlow) dispxOn[i] |= 0x1; // mask 4 cases
           if (xhigh) dispxOn[i] |= 0x2;
           if (ylow) dispxOn[i] |= 0x4;
           if (yhigh) dispxOn[i] |= 0x8;
           if (dispxOn[i] == 0)
           {
             if (dispyOn[i] == 0 || index < 0) // not marked yet
             {
               dispyOn[i] = 1; // point inside
               polycounter++;
             }
           }
           else if (index >= 0 && dispyOn[i] != 0) // was marked
           {
             dispyOn[i] = 0; // point outside
             polycounter--;
           }
         }
       }
       if (marker_ary_cpy != 0 && markerFlag != 0) loadMarker(i);
     }
     if (dismode == AcopConst.mode_textbox)
     {
       acop.textArea.setText(allStmp);
       acop.textArea.setCaretPosition(0);
     }
     if (dismode == AcopConst.mode_polyline) makePolyArray();
     if (marker_ary_cpy != 0 && markerFlag != 0) marker_ary_cpy = 0;
   }
   protected int getIndex(int x)
   {
     int i, j, tmpflg = 0, XarrayElement, xtmp;
     if (ix == null) return 0;
     if (dismode == AcopConst.mode_textbox) return 0;
     for (i = 0, j = wrapindex; i < npoints; i++, j++)
     {
       if (j >= npoints) j = 0;
       if (j == wrapindex)
       {
         if (xaryFlag == 1)
         {
           if (x >= ix[j])
           {
             tmpflg = 1;
             break;
           }
         }
         else
         {
           if (x < ix[j])
           {
             tmpflg = 1;
             break;
           }
         }
         xtmp = penWidth;
       }
       else
       {
         xtmp = j == 0 ? npoints - 1 : j - 1;
         // TODO: there's (sometimes) an array index out of bound exception here when there's a
         // mouse move over a text-mode display. 
         // 1). why ?
         // 2).  text mode should not even check for this event
         xtmp = (ix[j] - ix[xtmp]) / 2;
       }
       if (xaryFlag == 1)
       {
         if (x >= ix[j] + xtmp) break;
       }
       else
       {
         if (x < ix[j] - xtmp) break;
       }
     }
     if (tmpflg == 1)
       XarrayElement = j;
     else
     {
       if (xaryFlag == 1)
       {
         XarrayElement = j == npoints ? j - 1 : j;
       }
       else
       {
         if (wrapindex != 0 && j == 0) j = npoints;
         XarrayElement = j == 0 ? 0 : j - 1;
       }
     }
     return XarrayElement;
   }
   protected int getHistoIndex(double x, double y)
   {
     int devX;
     double tmpX;
     tmpX = acop.sca[0].log != 0 ? Math.log(AcopConst.log_check(x)) / Math.log(10) : x;
     devX = (int) ((tmpX - acop.sca[0].min) * acop.aFrame.dxwidth / acop.sca[0].dispSize + acop.aFrame.xleft);
     return getIndex(devX);
   }
   protected int getMousePosition(Point point, double[] userPoint)
   {
     int i, j, tmpflg = 0, XarrayElement, xtmp;
     point.x -= acop.aFrame.histRect.x;
     point.y -= acop.aFrame.histRect.y;
     userPoint[0] = acop.sca[0].dispSize * (point.x - acop.aFrame.xleft) / acop.aFrame.dxwidth
         + acop.sca[0].min;
     userPoint[1] = acop.sca[1].dispSize * (acop.aFrame.histRect.height - point.y)
         / acop.aFrame.histRect.height + acop.sca[1].min;
     if (acop.sca[0].log != 0) userPoint[0] = Math.pow(10.0, userPoint[0]);
     if (acop.sca[1].log != 0) userPoint[1] = Math.pow(10.0, userPoint[1]);
     return getIndex(point.x);
   }
   protected double maxOf(double arr[])
   {
     int i;
     double max = -1.7E308;
     if (disFlag == 0)
     {
       for (i = 0; i < npoints; i++)
         if (arr[i] > max) max = arr[i];
     }
     else
     {
       for (i = 0; i < npoints; i++)
       {
         if (disable[i] != 0) continue;
         if (arr[i] > max) max = arr[i];
       }
     }
     return max;
   }
   protected double minOf(double arr[])
   {
     int i;
     double min = 1.7E308;
     if (disFlag == 0)
     {
       for (i = 0; i < npoints; i++)
         if (arr[i] < min) min = arr[i];
     }
     else
     {
       for (i = 0; i < npoints; i++)
       {
         if (disable[i] != 0) continue;
         if (arr[i] < min) min = arr[i];
       }
     }
     return min;
   }
   protected void getMaxWindow()
   {
     double off, tmin, tmax;
     int setFirstTime = 0;
     if (npoints < 2)
     {
       tmax = x[0] + 1;
       tmin = x[0] - 1;
     }
     else
     {
       tmax = maxOf(x);
       tmin = minOf(x);
       // all points disabled!
       if (Math.abs(tmax + 1.7e+308) < AcopConst.zero_check
           && Math.abs(originxmin + 1.7e+308) < AcopConst.zero_check
           && Math.abs(originxmax - 1.7e+308) < AcopConst.zero_check)
       {
         setFirstTime = 1;
         tmax = acop.sca[0].dispSize / 2 + 1;
         tmin = tmax - 2;
       }
       off = (tmax - tmin) / (2 * (npoints - 1));
       if (off < AcopConst.zero_check) off = 1;
       tmax += off;
       tmin -= off;
     }
     // if different x size, then
     if (Math.abs(tmax - originxmax) > AcopConst.zero_check
         || Math.abs(tmin - originxmin) > AcopConst.zero_check || setFirstTime != 0)
     {
       originxmax = tmax;
       originxmin = tmin;
       if (hisIndex == acop.m_histstart)
       {
         acop.wrapxmin = originxmin;
         acop.wrapxmax = originxmax;
       }
     }
     if (acop.sca[0].log != 0) setwrapindex();
   }
   protected void setwrapindex()
   {
     int i, j, highfound;
     double xtemp;
     if (acop.sca[0].min < acop.wrapxmin && acop.sca[0].max < acop.wrapxmax)
       j = xaryFlag == 1 ? 2 : 1; // left
     else if (acop.sca[0].max > acop.wrapxmax && acop.sca[0].min > acop.wrapxmin)
       j = xaryFlag == 1 ? 1 : 2;// right
     else
       j = 0;
     wrapindex = wraphigh = 0;
     if (j > 0)
     {
       for (i = 0, highfound = -1; i < npoints; i++)
       {
         xtemp = x[i];
         if (j == 1)
         {
           if (xaryFlag == 1)
           {
             if (xtemp <= acop.wrapxmin + (acop.sca[0].max - acop.wrapxmax) // ???
                                                                             // change
                                                                             // to
                                                                             // <=
                 && xtemp <= acop.sca[0].min) break;
           }
           else
           {
             if (xtemp >= acop.wrapxmax - (acop.wrapxmin - acop.sca[0].min) // ???
                                                                             // change
                                                                             // to
                                                                             // >=
                 && xtemp >= acop.sca[0].max) break;
           }
         }
         else
         {
           if (xaryFlag == 1)
           {
             if (xtemp >= acop.wrapxmax - (acop.wrapxmin - acop.sca[0].min) && xtemp > acop.sca[0].max)
               highfound = i;
             if (xtemp <= acop.sca[0].max) break;
           }
           else
           {
             if (xtemp <= acop.wrapxmin + (acop.sca[0].max - acop.wrapxmax) && xtemp < acop.sca[0].min)
               highfound = i;
             if (xtemp >= acop.sca[0].min) break;
           }
         }
       }
       wrapindex = i == npoints ? 0 : i;
       if (j == 1)
       {
         if (i != npoints) wraphigh = -(wrapindex + 1);
       }
       else if (highfound != -1)
       {
         wraphigh = highfound;
         if (highfound < npoints - 1 && i != npoints)
           wraphigh = i == (highfound + 1) ? highfound : highfound + 1;
         wraphigh++;
       }
       // disp[n]->wraphigh = (j == 1) ? 0 : (k+1);
     }
   }
   private void makePolyArray()
   {
     int i, j, k, kk;
     if (disFlag == 0 && (acop.wrapAround == false || acop.sca[0].log != 0))
     {
       dispindex[0] = 0;
       dispnumber[0] = npoints; // # of points
       dispindex[1] = -1;
     }
     else
     {
       j = 0;
       k = 0;
       dispindex[k] = -1;
       for (kk = 0, i = wrapindex; kk < npoints && k < npoints; kk++, i++)
       {
         if (i >= npoints) i = 0;
         if (dispOn[i] != 0)
         {
           if (wrapindex != 0 && wraphigh > 0 && i >= wraphigh && i < wrapindex) break;
           if (dispindex[k] == -1) dispindex[k] = i; // load first index
           j++;
           if (wrapindex != 0 && i == (npoints - 1))
           {
             dispnumber[k] = j; // # of points
             j = 0;
             dispindex[++k] = -1;
           }
         }
         else
         {
           if (dispindex[k] != -1)
           {
             dispnumber[k] = j; // # of points
             j = 0;
             dispindex[++k] = -1;
           }
         }
       }
       if (dispindex[k] != -1)
       {
         dispnumber[k] = j;
         dispindex[++k] = -1;
       }
     }
   }
   private void drawPoly(java.awt.Graphics2D a, int pstart, int pend)
   {
     if ( pstart == 0 )
     {
       a.drawPolyline(ix,iy,pend);
       return;
     }
     int[] tix = new int[pend-pstart], tiy = new int[pend-pstart];
     System.arraycopy(ix, pstart, tix, 0, pend-pstart);
     System.arraycopy(iy, pstart, tiy, 0, pend-pstart);
     a.drawPolyline(tix,tiy,pend-pstart);
   }
   
   protected void drawhist(java.awt.Graphics2D a)
   {
     int i, j, k, OndisFlag, wx, wy, mx;
     Color selColor, lastColor;
     boolean colorCheck;
     if (displayON == 0) return;
     a.setColor(penColor);
     lastColor = penColor; // init tag drawing
     if (dismode == AcopConst.mode_textbox)
     {
       acop.listTextBox.setVisible(true);
       return;
     }
     a.setStroke(stroke);
     acop.listTextBox.setVisible(false);
     if (dismode == AcopConst.mode_polyline)
     {
       double tantheta, atantheta, abssin, abscos, delta;
       int xstart, ystart, xstart2, ystart2, delx, dely;
       /*
        * for (i=wrapindex, j=0; j<npoints -1; j++,i++) { if ( i >= npoints ) i =
        * 0; // i: current point k = i+1; if ( k >= npoints ) k = 0; // i:
        * current point if ( dispOn[i] == 0 || dispOn[k] == 0 ) continue; //
        * aLine.DrawAcopLine(ix[i],iy[i],ix[k],iy[k]);
        * a.drawLine(ix[i],iy[i],ix[k],iy[k]); } if ( i >= -10 ) return;
        */
       for (i = 0; i < npoints; i++)
       {
         if ((wx = dispindex[i]) == -1) break;
         wy = wx; // load first index
         for (j = 1; j < dispnumber[i]; j++)
         {
           // both outside, draw last part if there is one, then set index = -1
           if ((dispxOn[wx + j] & dispxOn[wx + j - 1]) != 0)
           {
             if (wy != -1 && (wx + j - 1) > wy)
             {
 //              a.drawPolyline(tix,tiy,wx+j-wy);
               drawPoly(a, wy, wx+j);
               if ( disDots != 0 )
               {
               for (k = wy; k < wx + j - 1; k++)
               {
 //                a.drawLine(ix[k], iy[k], ix[k + 1], iy[k + 1]);
                 if ( disDots != 0 && dispyOn[k] != 0) a.fillRect(ix[k] - xextent, iy[k] - yextent, xextent * 2, yextent * 2);
               }
               if ( disDots != 0 && dispyOn[k+1] != 0) a.fillRect(ix[k+1] - xextent, iy[k+1] - yextent, xextent * 2, yextent * 2);
               }
             }
             wy = -1;
             continue;
           }
           // otherwise: if nindex not yet set, load new index number
           if (wy == -1)
           {
             // pdc->MoveTo(ipoint[wx+j-1].x, ipoint[wx+j-1].y); // move to
             // lastpoint
             wy = wx + j - 1;
           }
           // pdc->LineTo(ipoint[wx+j].x, ipoint[wx+j].y);
         }
         // draw last part if there is one
         if (wy != -1 && (wx + j - 1) > wy)
         {
           // drawPolyline(ix[wy],iy[wy],wx+j-wy);
           drawPoly(a, wy, wx+j);
           if ( disDots != 0 )
           {
           for (k = wy; k < wx + j - 1; k++)
           {
 //            a.drawLine(ix[k], iy[k], ix[k + 1], iy[k + 1]);
             if ( disDots != 0 && dispyOn[k] != 0) a.fillRect(ix[k] - xextent, iy[k] - yextent, xextent * 2, yextent * 2);
           }
           if ( disDots != 0 && dispyOn[k] != 0) a.fillRect(ix[k] - xextent, iy[k] - yextent, xextent * 2, yextent * 2);
           }
         }
       }
       if (acop.wrapAround && wrapindex != 0 && acop.sca[0].log == 0) // connect
                                                                       // end
                                                                       // with
                                                                       // begining
       {
         i = npoints - 1;
         if (dispOn[0] != 0 && dispOn[i] != 0 && (dispxOn[0] & dispxOn[i]) == 0)
         {
           OndisFlag = 0;
           if (xaryFlag == 1)
           {
             if (ix[0] <= ix[i]) OndisFlag = 1;
           }
           else if (ix[0] >= ix[i]) OndisFlag = 1;
           if (OndisFlag != 0) a.drawLine(ix[0], iy[0], ix[i], iy[i]);
         }
       }
       // if ( i >= -10 ) return;
       /*
        * if ( penWidth < 2 ) a.drawPolyline(ix, iy, npoints); else { //
        * java.awt.Polygon poly = new java.awt.Polygon(ix, iy, npoints); // Line
        * penLine = new Line(); for (i = 0; i < npoints-1; i++) { if ( ix[i] ==
        * ix[i+1] || iy[i] == iy[i+1] ) {
        * a.drawLine(ix[i],iy[i],ix[i+1],iy[i+1]); continue; } tantheta =
        * (iy[i+1]-iy[i])/(ix[i+1]-ix[i]); atantheta = Math.atan(tantheta);
        * abssin = Math.abs(Math.sin(atantheta)); abscos =
        * Math.abs(Math.cos(atantheta)); // abssin = Math.abs(tantheta /
        * Math.sqrt(1+tantheta*tantheta)); // abscos = Math.abs(abssin/tantheta);
        * if ( tantheta > 1 || tantheta < -1 ) { delta = 1/tantheta; if (tantheta<0.)
        * abscos = -abscos; } else { delta = tantheta; if (tantheta<0.) abssin =
        * -abssin; } xstart = (int)(ix[i] - penWidth / 2 * abssin); xstart2 =
        * (int)(ix[i+1] - penWidth / 2 * abssin); ystart = (int)(iy[i] + penWidth /
        * 2 * abscos); ystart2 = (int)(iy[i+1] + penWidth / 2 * abscos); // for
        * (int j = 0; j < penWidth; j++) // { // delx = (int) (j * abssin); //
        * dely = (int) (j * abscos); // AcopLine.a.drawLine(xstart+delx,
        * ystart-dely,xstart2+delx, ystart2-dely); // } if ( tantheta > 1 ||
        * tantheta < -1 ) { delx = (int) (penWidth * abssin); for (j=0; j < delx;
        * j++) { dely = (int) (delta * j) ; a.drawLine(xstart+j, ystart
        * -dely,xstart2+j, ystart2-dely); } } else { dely = (int) (penWidth *
        * abscos); for (j=0; j < dely; j++) { delx = (int) (delta * j) ;
        * a.drawLine(xstart+delx, ystart-j ,xstart2+delx, ystart2-j); } } } //
        * for (int j = 0; j < penWidth; j++) // for (int i = 0; i < npoints-1;
        * i++) AcopLine.a.drawLine(ix[i],iy[i]-penWidth / 2+ j
        * ,ix[i+1],iy[i+1]-penWidth / 2 + j); }
        */
     }
     else if (dismode == AcopConst.mode_barline)
     {
       for (i = wrapindex, j = 0; j < npoints - 1; j++, i++)
       {
         if (i >= npoints) i = 0; // i: current point
         k = i + 1;
         if (k >= npoints) k = 0; // i: current point
         if (disable[k] != 0 || disable[i] != 0) continue; // current disable
         
         if ( disBarHisto != 0 )
         {
           mx = ix[i] + (ix[k]-ix[i])/2;
           if ( barlineColorFilled == 0 )
           {
           a.drawLine(ix[i], iy[i], mx, iy[i]);
           a.drawLine(mx, iy[i], mx, iy[k]);
           a.drawLine(mx, iy[k], ix[k], iy[k]);         
           }
           else if ( barlineColorFilled < 0 )
           {
             a.fillRect(ix[i], iy[i], mx - ix[i], acop.aFrame.histRect.height - iy[i]);
             a.fillRect(mx, iy[k], ix[k] - mx, acop.aFrame.histRect.height - iy[k]);
           }
           else
           {
             a.fillRect(ix[i], 0, mx - ix[i], iy[i]);          
             a.fillRect(mx, 0, ix[k] - mx, iy[k]);          
           }
         }
         else
         {
           if ( barlineColorFilled == 0 )
           {
           a.drawLine(ix[i], iy[i], ix[k], iy[i]);
           a.drawLine(ix[k], iy[i], ix[k], iy[k]);
           }
           else if ( barlineColorFilled < 0 )
             a.fillRect(ix[i], iy[i], ix[k] - ix[i], acop.aFrame.histRect.height - iy[i]);
           else
             a.fillRect(ix[i], 0, ix[k] - ix[i],  iy[i]);
         }
         if ( disDots != 0 ) a.fillRect(ix[k] - xextent, iy[k] - yextent, xextent * 2, yextent * 2);
       }
     }
     else if (dismode == AcopConst.mode_histogram || dismode == AcopConst.mode_histogram_rastoring)
     {
       colorCheck = (errWindowEnable || (tagHist != 0 && acop.m_tagging)) ? true : false;
       for (i = 0; i < npoints; i++)
       {
         if (dispOn[i] == 0) continue;
         // a.drawLine(ix[i],de.desy.acop.chart.aFrame.histRect.height,ix[i],iy[i]);
         if (colorCheck && (selColor = selTagErrPen(a, i, lastColor)) != lastColor) lastColor = selColor;
         if (iy[i] != acop.yzero)
         {
           a.drawLine(ix[i], acop.yzero, ix[i], iy[i]);
           if ( disDots != 0 ) a.fillRect(ix[i] - xextent, iy[i] - yextent, xextent * 2, yextent * 2);
         }
         else
           a.drawRect(ix[i] - 1, iy[i] - 1, 2, 2);
       }
     }
     else if (dismode == AcopConst.mode_dots)
     {
       colorCheck = (errWindowEnable || (tagHist != 0 && acop.m_tagging)) ? true : false;
       for (i = 0; i < npoints; i++)
       {
         if (dispOn[i] == 0) continue;
         if (colorCheck && (selColor = selTagErrPen(a, i, lastColor)) != lastColor) lastColor = selColor;
 //        a.fillRect(ix[i] - 1, iy[i] - 1, 3, 3);
         a.fillRect(ix[i] - xextent, iy[i] - yextent, xextent * 2 + 1, yextent * 2 + 1);
       }
     }
     else if (dismode == AcopConst.mode_rectangle)
     {
       colorCheck = (errWindowEnable || (tagHist != 0 && acop.m_tagging)) ? true : false;
       for (i = 0; i < npoints; i++)
       {
         if (dispOn[i] == 0) continue;
         if (colorCheck && (selColor = selTagErrPen(a, i, lastColor)) != lastColor) lastColor = selColor;
         if (colorfilled)
           a.fillRect(ix[i] - xextent, iy[i] - yextent, xextent * 2, yextent * 2);
         else
           a.drawRect(ix[i] - xextent, iy[i] - yextent, xextent * 2, yextent * 2);
       }
     }
     else if (dismode == AcopConst.mode_circle)
     {
       colorCheck = (errWindowEnable || (tagHist != 0 && acop.m_tagging)) ? true : false;
       for (i = 0; i < npoints; i++)
       {
         if (dispOn[i] == 0) continue;
         if (colorCheck && (selColor = selTagErrPen(a, i, lastColor)) != lastColor) lastColor = selColor;
         a.drawOval(ix[i] - xextent, iy[i] - yextent, xextent * 2, yextent * 2);
       }
     }
     else
     {
       acop.listTextBox.setVisible(true);
     }
     if (edgeMode != 0) drawLeadingEdgeMarker(a);
     drawMarker(a);
   }
   private void drawLeadingEdgeMarker(java.awt.Graphics2D a)
   {
     int mx;
     a.setColor(edgeColor);
     a.setStroke(edgeStroke);
     if ((edgeMode & 0x1) != 0)
     {
       if (edgePercentX < 0)
       {
         if (edgeExtentX < 0)
           edgePercentX = 1;
         else
           edgePercentX = (acop.sca[0].log != 0 ? Math.log(edgeExtentX) / Math.log(10) : edgeExtentX)
               / (acop.sca[0].xtime != 0 ? acop.sca[0].dispSize : (acop.sca[0].tick_max - acop.sca[0].tick_min)) / 2;
         edgePixel = (int) (acop.aFrame.dxwidth * edgePercentX * 2);
         if (edgePixel < edgeWidth) edgePixel = edgeWidth;
       }
       mx = (int) (acop.aFrame.dxwidth * edgePercentX);
       if ( mx < 1 ) mx = 1; // at least 1 pixel
       a.drawLine(ix[edgeIndex] - mx, iy[edgeIndex], ix[edgeIndex] + mx, iy[edgeIndex]);
     }
     if ((edgeMode & 0x2) != 0)
     {
       if (edgePercentY < 0)
       {
         if (edgeExtentY < 0)
           edgePercentY = 1;
         else
           edgePercentY = (acop.sca[1].log != 0 ? Math.log(edgeExtentY) / Math.log(10) : edgeExtentY)
               / acop.sca[1].dispSize / 2;
       }
       mx = (int) (acop.aFrame.histRect.height * edgePercentY);
       a.drawLine(ix[edgeIndex], iy[edgeIndex] - mx, ix[edgeIndex], iy[edgeIndex] + mx);
     }
   }
   private void drawMarker(java.awt.Graphics2D a)
   {
     int wy, mx, tickflag;
     if (acop.m_marker == 0 || markerFlag == 0) return;
     if (acop.m_markerMode == 0)
     {
       if (acop.saveMarkerWidth != penWidth)
       {
         acop.markerStroke = AcopConst.createStroke(penWidth, AcopConst.PS_SOLID);
         acop.saveMarkerWidth = penWidth;
       }
       a.setColor(acop.m_markerColor);
       a.setStroke(acop.markerStroke);
     }
     else
     {
       a.setColor(markerColor);
       a.setStroke(mStroke);
     }
     for (int i = 0; i < npoints; i++)
     {
       if (dispOn[i] == 0) continue;
       tickflag = acop.m_marker == 2 ? imy[i] : iy[i];
       mx = ix[i];
       if (acop.m_markerMode == 0)
       {
         if (tickflag > 0 && tickflag < acop.aFrame.histRect.height)
           a.drawLine(mx - acop.m_markerWidth, tickflag, mx + acop.m_markerWidth, tickflag);
       }
       else
       // new one
       {
         if ((markerMode & 0x1) != 0)
         {
           if (markerPercentX < 0) // new one
           {
             if (markerExtentX < 0)
               markerPercentX = 1;
             else
               markerPercentX = (acop.sca[0].log != 0 ? Math.log(markerExtentX) / Math.log(10) : markerExtentX)
                   / (acop.sca[0].xtime != 0 ? acop.sca[0].dispSize : (acop.sca[0].tick_max - acop.sca[0].tick_min)) / 2;
           }
           wy = (int) (acop.aFrame.histRect.width * markerPercentX);
           if ( wy < 1 ) wy = 1; // at least 1 pixel
           a.drawLine(mx - wy, tickflag, mx + wy, tickflag);
         }
         if ((markerMode & 0x2) != 0)
         {
           if (markerPercentY < 0)
           {
             if (markerExtentY < 0)
               markerPercentY = 1;
             else
               markerPercentY = (acop.sca[1].log != 0 ? Math.log(markerExtentY) / Math.log(10) : markerExtentY)
                   / acop.sca[1].dispSize / 2;
           }
           wy = (int) (acop.aFrame.histRect.height * markerPercentY);
           a.drawLine(mx, tickflag - wy, mx, tickflag + wy);
         }
       }
     }
   }
   // }}
 }