// EPS: Elgaard Positioning System: GPS navigation software.
// Copyright (C) 1997, 1999, 2000  Niels Elgaard Larsen

//     This program is free software; you can redistribute it and/or modify
//     it under the terms of the GNU General Public License as published by
//     the Free Software Foundation; either version 2 of the License, or
//     (at your option) any later version.

//     This program is distributed in the hope that it will be useful,
//     but WITHOUT ANY WARRANTY; without even the implied warranty of
//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//     GNU General Public License for more details.

//     You should have received a copy of the GNU General Public License
//     along with this program; if not, write to the Free Software
//     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

// Niels Elgaard Larsen, <URL:mailto:elgaard@diku.dk>
// <URL:http://www.diku.dk/users/elgaard/>


import java.awt.*;
import java.io.*;
import java.net.*;
import java.lang.Math;
import java.util.Date;
import java.text.DecimalFormat;
import java.awt.event.*;

class ImageGMap extends EPSCanvas implements Runnable, MouseListener,
  MouseMotionListener, KeyListener {
  static DecimalFormat speedFormat = new DecimalFormat("#.00");
  static DecimalFormat distFormat = new DecimalFormat("#.00");
  Date simTime = new Date(0) ;
  ICF theCF;
  Point  mouseScreenPos = new Point(0,0);

  int ttx;
  int tx;
  int tty;
  int ty=500;
  boolean mouseUp = true;
  static boolean CursorPaint= false;
  Graphics cg;
  boolean alive = true;
  boolean NMEA=false;
    static int sDelta = 50;


  int tx0=0,ty0=0;
  int cx0=0, cy0=0;
  int cx1=0, cy1=0;
  Pos bottomLeftPos;
  String oldpos = "";
  int XCharts;
  int YCharts;
  int ScreenWidth;
  int ScreenHeight;
  Font waypointFont = new Font("Helvetica", Font.PLAIN, 12);
  Font routeFont = new Font("Helvetica", Font.PLAIN, 20);
  int nLoadMaps0=5;
  int nLoadMaps = nLoadMaps0;
  int nLoadMapsMax = 5*nLoadMaps0;
  String imgNames="?";

  double xres=0d, yres=0d;  // pixels per degree

  Dimension ChartDim;
  Dimension minDim;
  Dimension prefDim;

  double fLong, fLat;

  ChartInfo loadedMaps[][];
  Pos cCursor=null;
  Pos oldcCursor=null;

  GMenv menv;
  Usync musync= new Usync(this);

  ImageGMap(GMenv e, ICF cf){
    Pos startPos;
    menv =e;
    setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));

    //System.out.println(" I UGM env= " +menv);
    loadedMaps = new ChartInfo[nLoadMapsMax*2+1][nLoadMapsMax*2+1];
    theCF = cf;

    CAux.perr("NOW CHARTS",8);
    CAux.readCharts( menv.epsBase, menv.chartdir, menv);
    // readCharts sets menv.cw and menv.ch.
    // FIXME. What happens if charts are added while running.

    bottomLeftPos = new Pos(0d,0d, theCF.mMapDatum.theDatum);

    fLong = ((double) menv.cw)/60d; //width of charts in degrees
    fLat = ((double) menv.ch)/60d;   //width of charts in degrees


    prefDim = new Dimension(600,500);
    minDim = new Dimension(300,200);
    startPos = new Pos(menv.initLong, menv.initLat, theCF.mMapDatum.theDatum);
    System.out.println("Starting at  " + startPos.toString(GMenv.posFormat));
    ScreenWidth = prefDim.width;
    ScreenHeight = prefDim.height;

    yres = (float) menv.initZoom;
    xres = yres*Math.sqrt(Math.cos(startPos.y.r()));

    ChartDim = new Dimension((int) (xres*fLong), (int) (yres*fLat));

    // FIXME ScreenWidth and ScreenHeight should be correct here.
    // But is be unknown at this time
    // System.out.println(" ssz= " +getSize());

    jumpTo(startPos, true);

    setBackground(new Color(240,230,140));
    addMouseListener(this);
    addMouseMotionListener(this);
    addKeyListener(this);

    // Math.rint() dos not work on the HP's at least with Netscape

    CAux.perr("Now reading inital data files ",1);

    if (GMenv.wpfile.wval != null) {
      CAux.perr("wpfile "+GMenv.wpfile,1);
      aWP.theWP.readWayPoints(theCF.outArea,theCF.waypointList,menv.epsBase, GMenv.wpfile.wval ,
                              theCF.fileFormat,menv);
    }

    if (GMenv.rtfile.wval != null){
      CAux.perr("RTfile "+GMenv.rtfile,1);
      RouteC.readRoutes(theCF.outArea,theCF.routeList,theCF.routeWPList, theCF.waypointList,
                        menv.epsBase, GMenv.rtfile.wval,theCF.fileFormat,menv);
    }

    if (GMenv.trfile.wval != null){
        CAux.perr("TRfile "+GMenv.trfile,1);
        TrackC.readTracks(menv.epsBase,GMenv.trfile.wval, theCF.fileFormat,menv);
    }
  }

  public Dimension getMinimumSize(){
    return (minDim);
  }

    //public Dimension getPreferredSize(){
    //return (prefDim);
    //}

    public void run() {
        //     System.out.println("Running ");
      Thread thisThread = Thread.currentThread();

        while (ChartFrame1.hThread==thisThread){
            if (musync.shouldWork()) {
                paintupd();
                FullPaint = true;
                repaint(500);
            }
        }
    }


    int lrnd(double dd) {
        if (dd>=0d){
            return((int)dd);
        } else {
            return((int)(dd+Double.MIN_VALUE-1));
        }
    }

    public  void mouseDragged(MouseEvent me) {
    }


    public  void mouseMoved(MouseEvent me) {
        mouseScreenPos = me.getPoint();
        // CAux.perr("mmv="+mouseScreenPos ,2);
    }


    public void mousePressed (MouseEvent evt) {
        int x,y;
        x = evt.getX() - tx;
        y = ty - evt.getY();
        String pos;

        pos= pix2pos(x,y).toString(Pone.MD);
        if (0!=(evt.getModifiers() & MouseEvent.BUTTON3_MASK)) {
            trackLog(evt.getX(),evt.getY());
        } else if (0!=(evt.getModifiers() & MouseEvent.BUTTON2_MASK)) {
            newTrackLog();
        } else if (0!=(evt.getModifiers() & MouseEvent.META_MASK)) {
            newTrackLog();
        } else {
            showPos(evt.getX(),evt.getY());
        }
    }

    public void mouseEntered (MouseEvent evt) {
        //System.out.println("IG event "+ event);
        requestFocus();
    }

    public void mouseExited (MouseEvent evt) {}

    public void mouseReleased (MouseEvent evt) {}

    void horzScroll(int px) {
        tx0 += px;
        ttx += px;
        FullPaint = true;
        musync.upd(300);
    }

    public void mouseClicked (MouseEvent me) {
        if (me.getClickCount() == 2) {
            Pos pos;
            int x,y;
            x = me.getX() - tx;
            y = ty - me.getY();
            pos= pix2pos(x,y);
            CAux.perr("doubleclick at" + pos.toString(Pone.MD), 2);
            ggoto(pos);
            FullPaint = true;
            musync.upd(50);
        }
    }

  public void keyReleased(KeyEvent kevt) {
  }

    void vertScroll(int py) {
        ty0 += py;
        tty +=py;
        FullPaint = true;
        musync.upd(300);
    }
    public void keyTyped(KeyEvent kevt) {
    }


    public void keyPressed(KeyEvent kevt) {

        char tk = Character.toLowerCase(kevt.getKeyChar());
        int kc = kevt.getKeyCode();
        CAux.perr("KEY pressed" + kc,2);
        if (tk=='t'){
            // trackLog(kevt.getX(),kevt.getY());
        } else if (tk=='p'){
            Pos mpos = screenPix2Pos(mouseScreenPos.x, mouseScreenPos.y);
            theCF.setLLPos(mpos);
        } else if (tk=='n'){
            newTrackLog();
        } else if (tk=='z'){
            theCF.pLabel.setText(" test " + "tx("+tx+","+ty+","+tty+")"+
                                 " res("+xres+","+yres+")");
        } else if (kc == KeyEvent.VK_LEFT /*|| kc == KeyEvent.VK_KP_LEFT*/) {
            ttx -= sDelta;
            FullPaint = true;
            musync.upd(300);
        } else if (kc == KeyEvent.VK_RIGHT /*|| kc == KeyEvent.VK_KP_RIGHT */ ) {
            ttx += sDelta;
            FullPaint = true;
            musync.upd(300);
        } else if (kc == KeyEvent.VK_UP /* || kc == KeyEvent.VK_KP_UP*/ ) {
            tty += sDelta;
            FullPaint = true;
            musync.upd(300);
        } else if (kc == KeyEvent.VK_DOWN  /* || kc == KeyEvent.VK_KP_DOWN*/ ) {
            tty -= sDelta;
            FullPaint = true;
            musync.upd(300);
        } else if (/* kc == KeyEvent.VK_PLUS  || */ kc == KeyEvent.VK_ADD  ) {
          CAux.perr("KEY PLUS",2);
          theCF.newZoom(1.25f);
        } else if (/* kc == KeyEvent.VK_MINUS ||*/  kc == KeyEvent.VK_SUBTRACT) {
          CAux.perr("KEY MINUS",2);
          theCF.newZoom(0.8f);
        } else {
          CAux.perr("?? KEY " + kc,2);
        }

}

  void newTrackLog()  {
      TrackC.insertTrack(null);
      theCF.pLabel.setText(" Starting New track");
  }


  void showPos(int sx, int sy)  {
      int x,y;
      cCursor = screenPix2Pos(sx,sy);

      CursorPaint = true;
      repaint();

    // System.out.println("Mouse  cx ("+cx+","+cy+")"+"sxy("+sx+","+sy+")"+
    //   "xy=("+x+","+y+")" );
      if (cCursor != null){
          if (cCursor.theDatum == theCF.mPositionDatum.theDatum) {
              theCF.pLabel.setText(" pos: " +  cCursor.toString(GMenv.posFormat));
          } else {
              theCF.pLabel.setText(" pos: " +
                                   cCursor.toString(GMenv.posFormat) +
                                   " ("+cCursor.theDatum.name + ")  "+
                                   cCursor.toDatum(theCF.mPositionDatum.theDatum).toString(GMenv.posFormat) +
                                   "("+theCF.mPositionDatum.theDatum.name + ")"
                                   );
          }
      }
  }


    void trackLog(int sx, int sy)  {
        Pos mc = screenPix2Pos(sx, sy);
        TrackC.insertTrack(new TRPos(mc, simTime));
        theCF.pLabel.setText(
                             //"x(" + x +","+ y + ")"+
                             //" tx("+tx+","+ty+"/"+tty+")" +
                             //" sx("+sx+","+sy+") pos:" +
                             "Setting track log at " +
                             mc.toString(GMenv.posFormat)
                             //+" blp=" + bottomLeftPos.toString(theCF.posFm)
                             );
        AnnoPaint = true;
        repaint(20);
  }

    int pos2xpix(Pos p){
        return((int)Math.round ((p.toDatum(theCF.mapDatum()).x.p - bottomLeftPos.x.p)*xres));
    }


    int pos2ypix(Pos p){
        return((int) ((p.toDatum(theCF.mapDatum()).y.p - bottomLeftPos.y.p)*yres+0.5));
    }


    int pos2sxpix(Pos p){
        return((int) ((p.toDatum(theCF.mapDatum()).x.p - bottomLeftPos.x.p)*xres +(double)tx));
    }

    int pos2tsypix(Pos ppos){
        /* pixels from bottom of canvas */
        return((int) ((ppos.toDatum(theCF.mapDatum()).y.p - bottomLeftPos.y.p)*yres -(double)tty));
    }

    int pos2sypix(Pos p){
        /* pixels from top of canvas */
        return((int) (ty-(p.toDatum(theCF.mapDatum()).y.p - bottomLeftPos.y.p)*yres));
    }

  boolean onScreen(Pos p) {
      int sx,sy;
      sx = pos2sxpix(p);
      sy = pos2sypix(p);
      return(onScreen(sx,sy));
  }

    boolean onScreen(int sx, int sy) {
        return (sx>=0 && sy >=0 && sx < ScreenWidth && sy < ScreenHeight);
    }

    boolean onScreen(int sx0, int sy0, int sx1, int sy1) {
        //FIXME does this line show on the screen ?
        if ((sx0 <0 && sx1 < 0) ||
            (sx0 > ScreenWidth && sx1 > ScreenWidth) ||
            (sy0 <0 && sy1 < 0)||
            (sy0 > ScreenHeight && sy1 > ScreenHeight)
            ) {
            return (false);
        } else {
            return(true);
        }
    }


    public void plotWP(Graphics g){
        int nw;
        WayPoint theWP;
        g.setColor(GMenv.getColor(GMenv.WAYPOINTCOLOR));
        g.setFont(waypointFont);
        g.setPaintMode();
        for (nw=0; nw<aWP.theWP.nWP;nw++){
            int sx,sy;
            theWP = aWP.theWP.wayPoints[nw];
            if (theWP==null) {
            } else {
                Pos nwpos = theWP.wpos.toDatum(theCF.mapDatum());
                sx = tx + pos2xpix(nwpos);
                sy = ty - pos2ypix(nwpos);
                theWP.routeHere = 0;
                if (onScreen(sx,sy)){
                    //  System.out.println("plot wp nWP=:" + aWP.theWP.nWP +"sxy=  "+ sx+"," +sy);
                    g.fillArc(sx-4,sy-4,8,8,0,360);
                    CAux.drawString(g,aWP.theWP.wayPoints[nw].name,sx,sy,2,
                                    GMenv.getColor(GMenv.WAYPOINTCOLOR));
                }
            }
        }
    }


    public void plotTR(Graphics g) {
        int nt;
        plotTrInit(g);

        for (nt=0; nt<TrackC.nTR;nt++) {
            plotTrNext(g, TrackC.track[nt]);
        }
    }

    public void plotTR_NMEA(Graphics g) {
        int nt=0;

        g.setPaintMode();
        g.setColor(GMenv.getColor(GMenv.TRACKCOLOR));

        while ((nt < TrackC.nTR) && TrackC.lastPlotted!=null &&
               (TrackC.track[nt]==null || TrackC.track[nt] != TrackC.lastPlotted)) {
            nt ++;
        }
        nt++;
        while (nt<TrackC.nTR) {
            //System.out.println(" nmgg"+ TrackC.track[nt]);
            plotTrNext(g, TrackC.track[nt]);
            nt ++;
        }
  }

    public void plotTrInit(Graphics g) {
        g.setPaintMode();
        g.setFont(theCF.annoFont);
        g.setColor(GMenv.getColor(GMenv.TRACKCOLOR));
        TrackC.lastPlotted = TrackC.track[0];
        TrackC.lastTimed = TrackC.lastPlotted;
  }

    public void plotTrNext(Graphics g, TRPos theTP) {
        int nt;
        int sx,sy;
        int oldsx=0,oldsy=0;
        long oldtime=-1;
        double dist=0f;
        int mindistq = 60*25; // ca.pixels
        long td;
        long tdmin= 60000; //milliseconds
        int px,py;
        Pos ntpos = null;
        //  System.out.println("GMAP Plot TR: "+ TrackC.nTR);

        if (theTP == null || theTP.tpos==null) {
            TrackC.lastPlotted = theTP;
            TrackC.lastTimed = null;
            TrackC.adist = 0d;
            return;
        }

        ntpos = theTP.tpos.toDatum(theCF.mapDatum());
        if (TrackC.lastPlotted != null && TrackC.lastPlotted.tpos != null) {
            sx = pos2sxpix(ntpos);
            sy = pos2sypix(ntpos);
            oldsx = pos2sxpix(TrackC.lastPlotted.tpos.toDatum(theCF.mapDatum()));
            oldsy = pos2sypix(TrackC.lastPlotted.tpos.toDatum(theCF.mapDatum()));

            if (TrackC.lastTimed!=null) {
                oldtime = TrackC.lastTimed.tm.getTime();
                td = theTP.tm.getTime() - oldtime;
                // CAux.perr("td = getTime "+ theTP.tm.getTime()+ " oldt=" + oldtime,2);
                TrackC.adist += theTP.tpos.dist(TrackC.lastPlotted.tpos);

                if (TrackC.adist*xres < mindistq/2) {
                    TrackC.mx = sx;
                    TrackC.my = sy;
                    TrackC.mfound = true;
                } else if (TrackC.mfound) {
                    TrackC.mx = (sx +oldsx)/2;
                    TrackC.my = (sy +oldsy)/2;
                    TrackC.mfound = false;
                }
                //CAux.perr(" td="+td+" mx="+TrackC.mx+" my="+TrackC.my +
                //  "  adist=" + TrackC.adist +"/"+ TrackC.adist*xres,9);
                if ((TrackC.adist*xres > mindistq*1852) && (td<0 ||td > tdmin)) {
                    if (onScreen(sx,sy)) {
                        g.fillRect(sx-4,sy-4,8,8);
                        CAux.perr("IGM speed  dist="+TrackC.adist + "  td="+ td + "  ialt"+(TrackC.adist*1000d/td),2);
                        CAux.drawString(g,
                                        speedFormat.format((TrackC.adist*1000d/td)*GMenv.speedMul+0.005) +
                                        GMenv.speedUnitName,
                                        TrackC.mx,TrackC.my,1,Color.black);
                    }
                    g.setColor(GMenv.getColor(GMenv.TRACKCOLOR));
                    TrackC.adist = 0d;
                    TrackC.mfound = true;
                    TrackC.lastTimed = theTP;
                }
            }

            if (onScreen(sx,sy,oldsx,oldsy)) {
                g.fillArc(sx,sy,4,4,0,360);
                if (TrackC.lastPlotted.tpos!=null){
                    g.drawLine(sx,sy,oldsx,oldsy);
                }
            }
    }
        TrackC.lastPlotted = theTP;
        if (TrackC.lastPlotted == null || TrackC.lastTimed ==null) {
            TrackC.lastTimed = theTP;
        }
    }


    public void plotRT(Graphics g){
        int rt;
        Pos p0, p1;
        int th;
        FontMetrics fm;
        Pos nrpos;

        WayPoint theWP;
        g.setFont(routeFont);
        for (rt=0; rt<RouteC.nRT;rt++){
            Route theRT = RouteC.routes[rt];
            int nw;
            double sumDist=0d;
            int sx0,sy0;

            g.setPaintMode();
            g.setFont(theCF.annoFontB);
            fm = g.getFontMetrics();
            th = fm.getHeight();
            if (theRT.wpts.nWP >0){
                int sy2;
                nrpos = theRT.wpts.wayPoints[0].wpos.toDatum(theCF.mapDatum());

                sx0 = tx + pos2xpix(nrpos);
                sy0 = ty - pos2ypix(nrpos);
                theRT.wpts.wayPoints[0].routeHere++;
                sy2 = sy0-theRT.wpts.wayPoints[0].routeHere*th-4;
                CAux.drawString(g,"Start: " + theRT.name +  " 0 "+GMenv.lengthUnitName, sx0,sy2,2,
                                GMenv.getColor(GMenv.ROUTECOLOR));
            }
            for (nw=1; nw<theRT.wpts.nWP;nw++){
                int sx1,sy1;
                p0 =theRT.wpts.wayPoints[nw-1].wpos.toDatum(theCF.mapDatum());
                p1 = theRT.wpts.wayPoints[nw].wpos.toDatum(theCF.mapDatum());
                sx0 = tx + pos2xpix(p0);
                sy0 = ty - pos2ypix(p0);
                sx1 = tx + pos2xpix(p1);
                sy1 = ty - pos2ypix(p1);
                sumDist += p0.dist(p1);

                if (onScreen(sx0,sy0,sx1,sy1)){
                    String ofText = distFormat.format(sumDist * GMenv.lengthMul+0.005) +  " "+
                        GMenv.lengthUnitName + " of "+ theRT.name;
                    int sy2;

                    theRT.wpts.wayPoints[nw].routeHere++;
                    g.setColor(Color.white);
                    sy2 = sy1-theRT.wpts.wayPoints[nw].routeHere*th-4;
                    CAux.drawString(g,ofText, sx1,sy2,2, GMenv.getColor(GMenv.ROUTECOLOR));
                    g.drawLine(sx0,sy0,sx1,sy1);
                    CAux.drawString(g,distFormat.format(p0.dist(p1)* GMenv.lengthMul+0.005) +
                                    GMenv.lengthUnitName +", " +
                                    ((int)(p0.icoursedg(p1)+0.5)) + "\u00B0",
                                    (sx0+sx1)/2,(sy0+sy1)/2,2,GMenv.getColor(GMenv.ROUTECOLOR));
                    // g.drawString("dist:" + "x0="+p0.x.r()+" y0="+p0.y.r()+
                    // "x1"+p1.x.r()+"y1"+p1.y.r()+
                    // "==" + p0.dist(p1),
                    //  (sx0+sx1)/2,(sy0+sy1)/2);

                }
            }
            g.setFont(routeFont);
        }
  }


    void makeGrid(Graphics g){
        int dx,dy;
        int sx,sy;
        double fx,fy;
        double fmax;

        g.setFont(theCF.annoFont);
        dx = tx % ChartDim.width;
        dy = -tty % ChartDim.height;

        fmax = (double) ScreenWidth;
        for (fx=dx; fx<fmax; fx+=(double)ChartDim.width){
            g.setColor(Color.black);
            g.drawLine((int)fx,ScreenHeight,(int)fx,0);
        }
        //    System.out.println(" grid  ty="+ ty+" tty="+tty+ " dy= "+dy);

        g.setColor(Color.black);
        for (fy=(double)(ScreenHeight-dy); fy>=0f ; fy-= (double)ChartDim.height){
            sy = (int) fy;
            g.drawLine(0,sy,ScreenWidth,sy);
        }
    }


    void plotcCur(Graphics g, Pos cc) {
        int sx,sy;
        int rc = 4;
        int rd = 8;
        if (cc==null){
            return;
        }
        sx = tx+pos2xpix(cc);
        sy = ty-pos2ypix(cc);
        g.setColor(GMenv.getColor(GMenv.TRACKCOLOR));
        g.setXORMode(Color.black);
        //    System.out.println("ccu  tx ("+tx+","+ty+")"+"sxy("+sx+","+sy+")");

        g.fillArc(sx-rc, sy-rc, 2*rc+1, 2*rc+1,0,360);
        g.drawArc(sx-rd, sy-rd, 2*rd+1, 2*rd+1,0,360);
    }

    public void annotate(Graphics g){
        FontMetrics fm;
        int minWidth;
        int nPerMin;

        int dfac[] = {2,5,10,30,60,120,300,600};
        int mfac[] = {2,5,10,20,50,100,200,500,1000};
        Pos blc;
        blc = bottomLeftPos.eCopy();
        blc.theDatum = theCF.mPositionDatum.theDatum;


        plotWP(g);
        plotTR(g);
        plotRT(g);
        makeGrid(g);
        g.setColor(Color.black);
        g.drawRect(0,0,ScreenWidth,10);
        g.drawRect(0,0,10,ScreenHeight);
        g.setFont(theCF.annoFont);
        double sx,sy;

        double dx,dy;
        int dx0,dy0;
        double xunit = xres/60d;
        double yunit = yres/60d;
        double xCunit = 1.0/60.0;
        double yCunit = 1.0/60.0;

        // Giancarlo zoom fix
    //2,3,4,5,6,10,12,15,20,30
        if (xunit < 20d || yunit < 20d ){
            int nDegree=0;
            while ((nDegree <= 8) && (xunit < 20d || yunit < 20d)) {
                xunit = xres/60*dfac[nDegree];
                yunit = yres/60*dfac[nDegree];
                xCunit = dfac[nDegree]/60d;
                yCunit = dfac[nDegree]/60d;
                nDegree++;
            }
            while (xunit < 20d || yunit < 20d) {
                xunit *= 2;
                yunit *= 2;
                xCunit *= 2;
                yCunit *= 2;
            }
        } else {
            nPerMin=0;
            while (nPerMin<8 && xunit > 100d && yunit > 100d ) {
                xunit = xres/60d/mfac[nPerMin];
                yunit = yres/60d/mfac[nPerMin];
                xCunit = 1d/60d/mfac[nPerMin];
                yCunit = 1d/60d/mfac[nPerMin];
                nPerMin++;
            }
            while (xunit > 100d && yunit > 100d ) {
                xunit = xres/60d/10d;
                yunit = yres/60d/10d;
                xCunit = 1d/60d/10d;
                yCunit = 1d/60d/10d;
            }
        }

        Pos dmd = bottomLeftPos.eCopy();
        Pos dmdP;
        dmd.theDatum = theCF.mPositionDatum.theDatum;
        //System.out.println(" dD =  " + bottomLeftPos.toDatum(theCF.mPositionDatum.theDatum)
        //      .toDatum(theCF.mMapDatum.theDatum));

        dmdP = dmd.toDatum(theCF.mMapDatum.theDatum);
        dx0 = ((pos2sxpix(dmdP)));
        dy0 = ((pos2tsypix(dmdP)));
        dx = (double)(dx0 % xunit);
        dy = (double)(dy0 % yunit);
        CAux.perr("anno: dx0="+dx0+" dy0="+dy0 +" xunit="+xunit+" yunit="+yunit,8);
        //CAux.perr("anno: dx="+dx+" dy="+dy,5);ww

        //System.out.println(" (dx,dy) =  (" + dx + ","+ dy+ ") (xres,yres)=("+xres+","+yres+")");

        for (sx = dx ;  sx < ScreenWidth; sx = sx+xunit){
            g.drawLine( (int)sx,1,(int)sx,10);
        }
        for (sy = ScreenHeight - dy; sy >0; sy -= yunit){
            g.drawLine( 1,(int)sy,10,(int)sy);
        }
        // Print Long. positions on border
        fm = g.getFontMetrics();
        minWidth = fm.stringWidth("55g88.88  ");


        if (minWidth> xres/60d && xunit<minWidth) {
            xunit=xres/60d;
            yunit=yres/60d;
            xCunit=1d/60d;
            yCunit=1d/60d;
            int nDegree=0;
            while ((nDegree <= 8) && ((double)ScreenWidth/xunit >10d ||
                                      (double)ScreenHeight/(yunit) >10d ||
                                      (xunit < minWidth))) {
                xunit = xres/60*dfac[nDegree];
                yunit = yres/60*dfac[nDegree];
                xCunit = dfac[nDegree]/60d;
                yCunit = dfac[nDegree]/60d;
                nDegree++;
            }
        }

        while ((double)ScreenWidth/xunit >10d || (double)ScreenHeight/(yunit) >10d
               || (xunit < minWidth)){
            if ((double)ScreenWidth/xunit >30d){
                xunit *=10d;
                yunit *=10d;
                xCunit *=10d;
                yCunit *=10d;
            } else {
                xunit *=2d;
                yunit *=2d;
                xCunit *=2d;
                yCunit *=2d;
            }
        }


        int xunitoff = (int) ((tx+pos2xpix(dmdP)) / xunit);
        int yunitoff = (int) ((-tty+pos2ypix(dmdP) ) / yunit);

        blc.x.p -= ( xunitoff * xCunit);
        blc.y.p -= ( yunitoff * yCunit);
        CAux.perr("yCunit="+yCunit+" ty="+ty+" p2p="+ pos2ypix(dmdP)+
                  " blc="+blc.toString(Pone.MDD) + "  mul="+ yunitoff,9);
        //blc.y.p += (dy0 / yunit) * yCunit;
        //CAux.perr("anno: blp=" +dmd+"   dmdP="+dmdP + " inv="+dmdP.toDatum(theCF.mPositionDatum.theDatum),5);

        if (xunit*yunit>100f) {
            String spos;
            int pformat=Pone.DMM;

            dx = pos2sxpix(blc);
            dy = pos2tsypix(blc);

            // Print Long. positions on border
            //    System.out.println("Lat ba1r= yunit" + yunit + " dy=" + dy);
            if ((xunit * 60 >= xres) && (yunit * 60 >= yres)) {
                pformat = Pone.DM;
            }
            for (sx = dx ; sx <ScreenWidth; sx += xunit){
                g.drawLine((int)sx+1,1,(int)sx+1,20);
                spos = blc.x.toString(pformat);
                CAux.drawString(g,spos,(int)sx - fm.stringWidth(spos)/2,(int)30,1,Color.black);
                blc.x.p += xCunit;
            }

            // Print Lat. positions on border
            //       System.out.println("Lat bar= yunit" + yunit + " dy=" + dy);
            for (sy = ScreenHeight - dy ;sy >34; sy -= yunit){
                // 34 to awoid overwriting long. position
                g.drawLine( 1,(int)sy,20,(int)sy);
                spos = blc.y.toString(pformat);
                CAux.drawString(g,spos, 22,(int)sy + fm.getHeight()/2 -2,1,Color.black);
                blc.y.p += yCunit;
            }
        }
    }


    Pos screenPix2Pos(int sx, int sy){
        return(pix2pos(sx-tx, ty-sy));
    }

    Pos pix2pos(int x, int y){
        // Convert offset in pixels from BottomLeftPos to pos.
        return(new Pos(
                       ((double) x)/xres + bottomLeftPos.x.p,
                       ((double) y)/yres + bottomLeftPos.y.p,
                       theCF.mMapDatum.theDatum
                       )
               );
    }

    int pos2cx(Pos pos) {
        return ((int)lrnd((pos.x.p- bottomLeftPos.x.p)/fLong));
    }

    int pos2cy(Pos pos) {
        return ((int)lrnd((pos.y.p- bottomLeftPos.y.p/fLat)));
    }

  public boolean imageUpdate(Image img, int flags, int x, int y, int w, int h){
      //       CAux.perr("GMAP Image Update : "+ "  fl="+flags +
      //  " pos=(" + x + "," + y + ")" +
      //  " dim=(" + w + "," + h + ")",8);
      if ((flags & ALLBITS)!=0) {
          CAux.perr("GMAP Image Update fin: "+img + "  fl="+flags +
                    " pos=(" + x + "," + y + ")" +
                    " dim=(" + w + "," + h + ")",2);
          //FullPaint = true;
          UpdatePaint = true;
          //UpdatePaint = false;
          repaint(40);
      } else {
          //CAux.perr("GMAP Image Update   fl="+flags,2 );
      }

      return (true);
  }


    synchronized void updCursor(Graphics g) {
        plotcCur(g,oldcCursor);
        plotcCur(g,cCursor);
        oldcCursor = cCursor;
    }

  public void update(Graphics g) {

    CAux.perr("update fp="+FullPaint+ " UP="+ UpdatePaint, 2);

      if (FullPaint) {
          FullPaint = false;
          CursorPaint = false;
          NMEAPaint = false;
          UpdatePaint = false;
          AnnoPaint = false;
          g.clearRect(0, 0,ScreenWidth, ScreenHeight);
          paint1(g, false);
          annotate(g);
          return;
      }

      if (UpdatePaint) {
          UpdatePaint = false;
          paint1(g,true);
          annotate(g);
          return;
      }

      if (CursorPaint) {
          CursorPaint = false;
          updCursor(g);
      }

      if (NMEAPaint) {
          NMEAPaint = false;
          plotTR_NMEA(g);
          return;
      }

      if (AnnoPaint){
          AnnoPaint = false;
          annotate(g);
      }
  }

    int ldv(int a,int b) {
        if (a>=0) {
            return (a/b);
        } else {
            return ((a-b+1)/b);
        }
  }



    public void paint(Graphics g) {
        //System.out.println("PAINT");
        boolean mustUpdate;
        //Uncomment this for Java 2


//         try {
//             Graphics2D g2 = (Graphics2D) g;
//             g2.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
//             g2.setRenderingHint( RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
//         } catch (NoClassDefFoundError ex) {
//             CAux.perr("not 2D, FINE!",2);
//         }

        cg=g;
        mustUpdate = (ScreenWidth==getSize().width && ScreenHeight==getSize().height);

        if (mustUpdate) {
            FullPaint = true;
            update(g);
        } else {
            musync.upd(100);
        }
    }


    public void ggoto(Pos newPos){
        int cx, cy;
        Pos newMapPos;
        theCF.horz.setValue(500);
        theCF.vert.setValue(500);
        newMapPos= newPos.toDatum(theCF.mapDatum());

        ttx = tx0 = (int)((newMapPos.x.p - bottomLeftPos.x.p)*xres - (double)ScreenWidth/2f);
        tty = ty0 = (int)((newMapPos.y.p - bottomLeftPos.y.p)*yres - (double)ScreenHeight/2f);
        FullPaint =true;
        CAux.perr("blp="+ bottomLeftPos,8);
        CAux.perr("ggoto " + newPos + " ttx="+ttx+" tty="+tty,7);
        musync.upd(0);
        repaint(100);
  }



    public void jumpTo(Pos newPos, boolean center){
        int cx,cy;
        Pos newMapPos;

        newMapPos= newPos.toDatum(theCF.mapDatum());

        CAux.perr("Cleaning up XC=(" + XCharts+ ","+YCharts+")" + "cxy="+
                  "("+cx0 +","+cy0+") nlm="+nLoadMaps,3);

        CAux.perr("Jumping from "+ bottomLeftPos + ":XC(" + XCharts+ ","+YCharts+")",3);
        CAux.perr("Jumpto"+newMapPos,5);

        // Make sure we COPY here
        theCF.horz.setValue(500);
        theCF.vert.setValue(500);

        bottomLeftPos.x.p = newMapPos.x.p;
        bottomLeftPos.y.p = newMapPos.y.p;


        //System.out.println(" blp0 = " +bottomLeftPos + " xres ="+xres+ " yres ="+yres + "SH="+ScreenHeight);
        if (center) {
            bottomLeftPos.x.p -= ScreenWidth/xres/2;
            bottomLeftPos.y.p -= ScreenHeight/yres/2;
        }
        bottomLeftPos.x.p = ((double)((int)(bottomLeftPos.x.p/fLong)))*fLong;
        bottomLeftPos.y.p = ((double)((int)(bottomLeftPos.y.p/fLat)))*fLat;

        CAux.perr("Jumping to "+ newPos +" blp="+bottomLeftPos + " fLong="+fLong,3);
        // Let's help garbage collection
        for (cx= -nLoadMaps; cx<=nLoadMaps; cx++){
            for (cy= -nLoadMaps; cy<=nLoadMaps; cy++){
                if (loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax] != null){
                    if (loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax].loadedFrom !=null) {
                        loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax].loadedFrom.chart=null;
                    }
                    loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax].tried=0;
                }
      }
        }

    // We should at least holdt a screenful at this zooming
        if (nLoadMaps <= XCharts || nLoadMaps <= YCharts) {
            nLoadMaps = Math.max(XCharts,YCharts)+4;
            if (nLoadMaps > nLoadMapsMax) {
                loadedMaps = new ChartInfo[nLoadMaps*2+1][nLoadMaps*2+1];
                nLoadMapsMax = nLoadMaps;
            }
            CAux.perr("New LoadMaps",2);
        }

        ttx = tx0 = (int)((newMapPos.x.p - bottomLeftPos.x.p)*xres - (double)ScreenWidth/2f);
        tty = ty0 = (int)((newMapPos.y.p - bottomLeftPos.y.p)*yres - (double)ScreenHeight/2f);

        tx = -ttx;
        ty = tty + ScreenHeight;

        cx0 = ldv(-tx,ChartDim.width);
        cy0 = ldv(tty,ChartDim.height);

        cx1 = ldv((-tx+ScreenWidth-1),ChartDim.width);
        cy1 = ldv((tty+ScreenHeight-1),ChartDim.height);
        CAux.perr("Jumping to ttx="+ ttx+" tty="+tty,3);
  }


    public void paintupd() {
        int cx,cy;
        String chartName;
        URL chartURL=null;
        Pos newPos=new Pos();
        oldpos="";

        yres = (float) menv.initZoom * (theCF.zoom/100d);
        xres = yres*Math.sqrt(Math.cos(bottomLeftPos.y.r()));

        fLong = ((double) menv.cw)/60d; //width of charts in degrees
        fLat = ((double) menv.ch)/60d;   //width of charts in degrees

        ChartDim.height = (int) Math.rint(yres*fLat);
        ChartDim.width = (int) Math.rint(xres*fLong);


        ScreenWidth=getSize().width;
        ScreenHeight=getSize().height;

        XCharts= (ScreenWidth + ChartDim.width -1)/ ChartDim.width;
        YCharts= (ScreenHeight + ChartDim.height -1)/ ChartDim.height;

        yres = ChartDim.height / fLat;
        xres = ChartDim.width / fLong;
        tx = -ttx;
        ty = tty + ScreenHeight;

        cx0 = ldv(-tx,ChartDim.width);
        cy0 = ldv(tty,ChartDim.height);

        cx1 = ldv((-tx+ScreenWidth-1),ChartDim.width);
        cy1 = ldv((tty+ScreenHeight-1),ChartDim.height);
        CAux.perr("paintupd ttx="+ttx+" tty="+tty,5);

        if (nLoadMaps <= cx1-cx0 || nLoadMaps <= cy1-cy0) {
            nLoadMaps = Math.max(cx1-cx0,cy1-cy0)+5;
            if (nLoadMaps > nLoadMapsMax) {
                loadedMaps = new ChartInfo[nLoadMaps*2+1][nLoadMaps*2+1];
                nLoadMapsMax = nLoadMaps;
            }

            CAux.perr("New LoadMaps",2);
        } else if (nLoadMaps>2*(cx1-cx0+1) && nLoadMaps > 2*(cy1-cy0+1) &&
                   nLoadMaps>2*nLoadMaps0+2) {
            // scrink cache
            int mx,my;
            for (mx=nLoadMaps/2+1; mx < nLoadMapsMax; mx++) {
                for (my=nLoadMaps/2+1; my < nLoadMapsMax; my++) {
                    loadedMaps[ mx+nLoadMapsMax][ my+nLoadMapsMax] = null;
                    loadedMaps[-mx+nLoadMapsMax][-my+nLoadMapsMax] = null;
                }
            }
            nLoadMaps = nLoadMaps/2;
    }

        // System.out.println(" PUU tx = "+tx +" ty="+ty+" fLat="+fLat+" cy0="+ cy0);

        if ((Math.abs(cy0)+XCharts> nLoadMaps) || (Math.abs(cx0)+XCharts> nLoadMaps)) {
            newPos = screenPix2Pos(ScreenWidth/2,ScreenHeight/2);
            jumpTo(newPos, false);
            tx = -ttx;
            ty = tty + ScreenHeight;
            FullPaint =true;
            repaint(500);
        }
        CAux.perr("cx0="+cx0+" cx1="+cx1+" cy0="+cy0+" cy1="+cy1,7);

        for (cx=cx0; cx<=cx1 && Math.abs(cx)<=nLoadMaps ;cx++){
            for (cy=cy0; cy<=cy1 && Math.abs(cy)<=nLoadMaps;cy++){
                ChartInfo thisCI=loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax];
                Pos thePos;
                String imgName="??";
                int imgSuffix;
                ChartRect theRect=null;

                thePos = pix2pos(cx*ChartDim.width,cy*ChartDim.height);
                // System.out.println(" p " + cx+","+cy+" = "+thePos.toString(1)+" to be loaded");
                CAux.perr("ImageGMap find pos="+thePos+ " ch="+menv.ch+ " cw="+menv.cw,2);

                theRect = Rects.find(thePos, menv.ch, menv.cw,(int)yres);
                CAux.perr("ImageGMap found "+theRect,2);

                if (theRect!=null && (thisCI==null || thisCI.tried ==0 || thisCI.loadedFrom==null ||
                                      (thisCI.loadedFrom.zoom < theCF.zoom && thisCI.loadedFrom.zoom < 101)||
                                      theRect.dpd != thisCI.loadedFrom.dpd)) {

                    loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax] = thisCI = new ChartInfo();

                    thisCI.tried=1;
                    imgName= theRect.toString();
                    chartName = menv.chartdir+ "/" + imgName;
                    CAux.perr("ImageGM loading "+ chartName + "XXXX",2);
                    thisCI.loadedFrom = theRect;

                    if (theRect.chart==null || (theRect.zoom < theCF.zoom && theRect.zoom < 101)) {
                        try {
                            theCF.outArea.append("Loading chart: "+ " "+ imgName+"\n");
                        } catch (NoSuchMethodError ex) {
                            System.out.println("Loading chart: "+ " "+ imgName+"\n");
                        }
                        try {
                            chartURL = new URL(menv.epsBase, chartName);
                            CAux.perr("CHARTSURL:" + chartURL+ "  cn="+chartName, 2);
                        }catch (MalformedURLException me) {
                            System.out.println("MalformedURLException: " + me);
                        }
                        //System.out.println("Map load imgs="+ imgSuffix + " cn="+chartName +
                        //     " URL:"+cx +","+cy+ " URL:"+ chartURL);
                        if (chartURL!=null){
                            if (menv.epsBase.getProtocol().equals("file")) {
                                theRect.chart = ChartFrame1.fShield.getImage(getToolkit(),ChartFrame1.urlDecode(chartURL.getFile()));
                                //theRect.chart = getToolkit().getImage(ChartFrame1.urlDecode(chartURL.getFile()));
                            } else {
                                theRect.chart = getToolkit().getImage(chartURL);
                            }
                            theRect.cw0 = theRect.chart.getWidth(null);
                            theRect.ch0 = theRect.chart.getHeight(null);
                            // jdk10 getToolkit().prepareImage(theRect.chart, ChartDim.width, ChartDim.height,this);
                        }
                        //              thisCI.loadedFrom = theRect;
                    }
                }

                if ((thisCI!=null) && thisCI.loadedFrom!=null && ((thisCI.loadedFrom.chart!=null)
                                                                  //  ||(loadedMaps[cx+nLoadMaps][cy+nLoadMaps].tried==0)
                                                                  )
                    ) {
                    CAux.perr("ImageGM try "+ imgName,2);

                    thisCI.tried++;
                    if (thisCI.loadedFrom.zoom != theCF.zoom) {
                        // For low zoom get scaled image to save memeory
                        if ((theCF.zoom < 101) && thisCI.loadedFrom.getdLong()*xres<2000) {
                            thisCI.loadedFrom.zoom = theCF.zoom;
                            CAux.perr("Scaling to :"+ ((int) (thisCI.loadedFrom.getdLong()*xres+0.5)) +
                                      "," + ((int) (thisCI.loadedFrom.getdLat() *yres+0.5)), 3);
                            CAux.perr("scale Image orig=("+
                                      thisCI.loadedFrom.chart.getWidth(null)+ "," +
                                      thisCI.loadedFrom.chart.getHeight(null)+")"
                                      ,2);

                            thisCI.loadedFrom.chart =
                                thisCI.loadedFrom.chart.getScaledInstance(
                                                                          (int) (thisCI.loadedFrom.getdLong()*xres+0.5),
                                                                          (int) (thisCI.loadedFrom.getdLat() *yres+0.5),
                                                                          Image.SCALE_DEFAULT);
                            CAux.perr("scale Image cwh=("+
                                      thisCI.loadedFrom.chart.getWidth(null)+ "," +
                                      thisCI.loadedFrom.chart.getHeight(null)+") should("+
                                      (int) (thisCI.loadedFrom.getdLong()*xres+0.5) + "," +
                                             (int) (thisCI.loadedFrom.getdLat() *yres+0.5)+ ")"
                                         ,5);
                        } else {
                            //getToolkit().checkImage(thisCI.chart, ChartDim.width, ChartDim.height,this);
                            //getToolkit().prepareImage(thisCI.chart, ChartDim.width, ChartDim.height,this);
                        }
                    }
                }
            }
        }
    }


    public void paint1(Graphics g, boolean isUp) {
        int cx,cy;
        CAux.perr("paint1 cx: "+cx0+ "_" + cx1 + "  ,cy: "+cy0+"_"+ cy1 + " isUp="+ isUp, 2 );

        g.setPaintMode();
        for (cx=cx0; cx<=cx1 && Math.abs(cx)<=nLoadMaps ;cx++) {
            for (cy=cy0; cy<=cy1 && Math.abs(cy)<=nLoadMaps;cy++) {
                ChartInfo thisCI=loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax];
                //CAux.perr("paint1 if cx="+cx+" cy=" + cy + " lms="+loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax],2);
                if ((thisCI!=null) && (thisCI.loadedFrom!=null) &&
                    ((thisCI.loadedFrom.chart!=null)
                     // ||(thisCI.tried==0)
                     )) {
                    if (!thisCI.fin || (! isUp)) {
                        CAux.perr("thisCI="+ thisCI.fin,2);

                        loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax].tried++;

                    // System.out.println("Chart file cx("+cx+","+cy +  ")" +
                    //  "cx0("+cx0+","+cy0  + " draw at " +
                    //  (tx+cx*ChartDim.width) +"," +
                    // + (ty-(cy+1)*ChartDim.height));

                    // FIXME: This could be optimized by drawing multible screen rectangles at a time.

                    try {
                        int ch,cw;
                        Image theChart = thisCI.loadedFrom.chart;
                        ChartRect lf = thisCI.loadedFrom;
                        cw = theChart.getWidth(null);
                        ch = theChart.getHeight(null);
                        // Begin Use this with JDK 1.1
                        int dx1,dy1,dx2,dy2,sx1,sx2,sy1,sy2;

                        dx1=Math.max(tx + cx*ChartDim.width,0);
                        dx2=Math.min(tx + (cx+1)*ChartDim.width, ScreenWidth);

                        dy1=Math.max(ty - (cy+1)*ChartDim.height,0);
                        dy2=Math.min(ty - (cy)*ChartDim.height,ScreenHeight);

                        double x1a = Math.max(bottomLeftPos.x.p + cx*fLong, (ttx/xres+bottomLeftPos.x.p));
                        double x1s = (ScreenWidth-tx)/xres + bottomLeftPos.x.p;
                        double x1r = bottomLeftPos.x.p + (cx+1)*fLong;

                        double y1a = Math.max(bottomLeftPos.y.p + cy*fLat,tty/yres+bottomLeftPos.y.p);
                        double y1s = (ty)/yres + bottomLeftPos.y.p;
                        double y1u = bottomLeftPos.y.p + (cy+1)*fLat;

                        sx1 = Math.max((int) ((double)cw*(x1a - lf.getLong())/lf.getdLong() + 0.5),0);
                        sx2= (int)((Math.min(x1s,x1r) - lf.getLong())*(double)cw/lf.getdLong() +0.5);

                        sy2=ch-Math.max((int)(ch*(y1a - lf.getLat())/lf.getdLat()+0.5),0);
                        sy1=ch-(int) ((Math.min(y1s,y1u) - lf.getLat())*(double)ch/lf.getdLat()+0.5);

                        CAux.perr("theChart="+theChart+" DLF=("+lf.getLong()+","+lf.getLat()+ ")" +
                                  "DLF=("+lf.getdLong()+","+lf.getdLat()+ ")",2);

                        CAux.perr("drawImage cxy=("+cx+ ","+cy+")  cwh=("+ cw + ","
                                  + ch + ") xyres=("+xres + ","+yres+") x1a="+x1a+" x1s="+x1s+" x1r="+x1r, 2);

                        CAux.perr("drawImage "+ thisCI + ": "+ "d1=("+dx1+","+dy1 + ") d2=("+dx2+","+dy2+
                                  ")  s1=("+sx1+","+sy1+") s2=("+sx2+","+sy2+")", 2);

                        if (CAux.tLevel > 0) {
                            g.drawLine(dx1,dy1,dx2,dy2);
                        }

                        thisCI.fin=g.drawImage(theChart,
                                               dx1, dy1,
                                               dx2, dy2,
                                               sx1, sy1,
                                               sx2, sy2,
                                               this /* Image observer */);
                        //     System.out.println(" src=("+sx1 +","+sy1+"),("+sx2 +","+sy2+"),"+
                        //     "dst=("+dx1 +","+dy1+"),("+dx2 +","+dy2+")");

                        //       img - the specified image to be drawn
                        //       dx1 - the x coordinate of the first corner of the destination rectangle
                        //       dy1 - the y coordinate of the first corner of the destination rectangle
                        //       dx2 - the x coordinate of the second corner of the destination rectangle
                        //       dy2 - the y coordinate of the second corner of the destination rectangle
                        //       sx1 - the x coordinate of the first corner of the source rectangle
                        //       sy1 - the y coordinate of the first corner of the source rectangle
                        //       sx2 - the x coordinate of the second corner of the source rectangle
                        //       sy2 - the y coordinate of the second corner of the source rectangle

                    } catch (NullPointerException me) {
                        CAux.perr("NP IN IG: ",-1);
                    } catch (NoSuchMethodError e) {
                        CAux.perr(" Not JDK11 graphic",-2);
                        g.drawImage(loadedMaps[cx+nLoadMapsMax][cy+nLoadMapsMax].loadedFrom.chart,
                                    tx + cx*ChartDim.width, ty - (cy+1)*ChartDim.height,
                                    ChartDim.width, ChartDim.height,this);
                    }
                    }
                }
            }
        }
        plotcCur(g,cCursor);
    }
}

class ChartInfo {
    // One of these for each chart grid
    ChartRect loadedFrom=null;
    int tried = 0;
    boolean fin = false;

    public String toString() {
        return ("CI:  LF="+ loadedFrom);
    }
}

class ChartDisp {
    // One of these for each grid
    ChartInfo theChart;
    int tried = 0;
    boolean fin = false;
}

class Usync {
   private boolean again=true;
   private boolean working=false;
   private ImageGMap GMhandle;
   private int toWait=400;

   Usync(ImageGMap h) {
     GMhandle =h;
   }


   public synchronized void upd(int wt) {
     toWait = wt;
     if (working) {
       again = true;
       notify();
     } else {
       again = true;
       notify();
     }
   }


public synchronized boolean shouldWork() {
    boolean ta = again;
    again=false;
    working = ta;
    if (!ta) {
        try {
            wait();
        } catch (InterruptedException e) {
        }
        while (again){
            again=false;
            try {
                wait(toWait);
            } catch (InterruptedException e) {
            }
        }
    }
    return (true);
}
}