sclass ImageSurface extends Surface {
  BufferedImage image;
  double zoomX = 1, zoomY = 1, zoomFactor = 1.5;
  private Rectangle selection;
  new L<AutoCloseable> tools;
  
  // use overlays now
  O overlay; // voidfunc(Graphics2D)
  L<G2Drawable> overlays = syncL();
  
  Runnable onSelectionChange;
  settable bool verbose;
  bool noMinimumSize = true;
  S titleForUpload;
  O onZoom;
  bool specialPurposed; // true = don't show image changing commands in popup menu
  settable bool allowPaste;
  settable bool zoomable = true;
  bool noAlpha; // set to true to speed up drawing if you don't use alpha
  O interpolationMode = RenderingHints.VALUE_INTERPOLATION_BILINEAR;
  O onNewImage; // use imageChanged event instead
  BufferedImage imageToDraw; // if you want to draw a different image
  File file; // where image was loaded from
  bool autoZoomToDisplay; // only works 100% when not in scrollpane
  settable bool repaintInThread; // after setImage, repaint in same thread
  BoolVar showingVar;
  
  Pt mousePosition;
  event mousePositionChanged;
  event imageChanged;
  event userModifiedImage(BufferedImage image);
 
  public ImageSurface() {
    this(dummyImage());
  }
  
  static BufferedImage dummyImage() {
    ret whiteImage(1);
  }
  
  *(File file) {
    setImage(file);
  }

  *(MakesBufferedImage image) {
    this(image != null ? image.getBufferedImage() : dummyImage());
  }
  
  *(BufferedImage image) {
    setImage(image);
    clearSurface = false;

    // perform auto-zoom when shown, resized or when parent resized
    bindToComponent(this, l0 performAutoZoom, null);
    onResize(this, l0 performAutoZoom);
    onEnclosingScrollPaneResize(this, l0 performAutoZoom);
    
    componentPopupMenu2(this, ImageSurface_popupMenuMaker());
    new ImageSurfaceSelector(this);
    
    jHandleFileDrop(this, voidfunc(File f) { setImage(loadBufferedImage(f)) });
    
    imageSurfaceOnHover(this, p -> {
      mousePosition = p;
      mousePositionChanged();
    });
  }

  public ImageSurface(RGBImage image, double zoom) {
    this(image);
    setZoom(zoom);
  }

  // point is already in image coordinates
  protected void fillPopupMenu(JPopupMenu menu, Point point) {
    if (zoomable) {
      JMenuItem miZoomReset = new JMenuItem("Zoom 100%");
      miZoomReset.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          setZoom(1.0);
          centerPoint(point);
        }
      });
      menu.add(miZoomReset);
  
      JMenuItem miZoomIn = new JMenuItem("Zoom in");
      miZoomIn.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          zoomIn(zoomFactor);
          centerPoint(point);
        }
      });
      menu.add(miZoomIn);
  
      JMenuItem miZoomOut = new JMenuItem("Zoom out");
      miZoomOut.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          zoomOut(zoomFactor);
          centerPoint(point);
        }
      });
      menu.add(miZoomOut);
  
      menu.add(jMenuItemStayCheckedOnClick("Zoom to window",
        -> autoZoomToDisplay,
        -> setAutoZoomToDisplay(true)));
      
      addMenuItem(menu, "Show full screen", r { showFullScreen() });
      
      S col = "";
      
      if (hasImage()) pcall {
        int rgb = getPixel(getImage(), point.x, point.y);
        col = " #" + takeLast(6, intToHex(rgb));
      }
      
      addMenuItem(menu, "Point: " + point.x + "," + point.y + col + " (image: " + w() + "*" + h() + ")", null);
  
      menu.addSeparator();
    }

    if (!specialPurposed)
      addMenuItem(menu, "Load image...", r { selectFile("Load image",
        voidfunc(File f) { setImage(loadImage2(f)) }) });
    addMenuItem(menu, "Save image...", r { saveImage() });
    ifdef ImageSurface_AllowUpload
      addMenuItem(menu, "Upload image...", r { uploadTheImage() });
    endifdef
    addMenuItem(menu, "Copy image to clipboard", r { copyImageToClipboard(getImage()) });
    if (!specialPurposed || allowPaste)
      addMenuItem(menu, "Paste image from clipboard", r { loadFromClipboard() });
      
    if (!specialPurposed)
      addMenuItem(menu, "Load image snippet...", r {
        selectImageSnippet(voidfunc(S imageID) {
          setImage(loadImage2(imageID))
        });
      });
    if (selection != null)
      addMenuItem(menu, "Crop", r { crop() });
    if (!specialPurposed)
      addMenuItem(menu, "No image", r { noImage() });
  }
  
  void noImage() { setImage((BufferedImage) null); }
  
  void crop() {
    if (selection == null) ret;
    BufferedImage img = cloneClipBufferedImage(getImage(), selection);
    selection = null;
    setUserModifiedImage(img);
  }
  
  void setUserModifiedImage(BufferedImage img) {
    setImage(img);
    userModifiedImage(img);
  }
  
  void loadFromClipboard() {
    BufferedImage img = getImageFromClipboard();
    if (img != null)
      setUserModifiedImage(img);
  }
  
  swappable File defaultImageDir() { ret getProgramDir(); }

  void saveImage() {
    var image = getImage();
    JFileChooser fileChooser = new JFileChooser(defaultImageDir());
    if (fileChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
      try {
        main saveImage(image, file = fileChooser.getSelectedFile());
      } catch e {
        popup(e);
      }
    }
  }
  
  void drawImageItself(int w, int h, Graphics2D g) {
    int iw = getZoomedWidth(), ih = getZoomedHeight();
    if (interpolationMode == RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR || zoomX >= 1 || zoomY >= 1) {
      // faster
      g.drawImage(image, 0, 0, iw, ih, null);
    } else
      g.drawImage(resizeImage(image, iw, ih), 0, 0, null); // smoother
  }

  swappable void drawBackground(int w, int h, Graphics2D g) {
    g.setColor(or(getBackground(), Color.white));
    g.fillRect(0, 0, w, h);
  }

  public void render(int w, int h, Graphics2D g) {
    if (verbose) _print("render");
    g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, interpolationMode);
    drawBackground(w, h, g);
    BufferedImage image = or(imageToDraw, this.image);
    if (!hasImage())
      drawBackground(w, h, g);
    else {
      bool alpha = !noAlpha && hasTransparency(image);
      if (alpha)
        drawBackground(w, h, g);
    
      drawImageItself(w, h, g);
      
      int iw = getZoomedWidth(), ih = getZoomedHeight();
      if (!alpha) {
        g.fillRect(iw, 0, w-iw, h);
        g.fillRect(0, ih, iw, h-ih);
      }
    }

    if (overlay != null) {
      if (verbose) _print("render overlay");
      pcallF(overlay, g);
    }
    
    for (var overlay : cloneList(overlays)) pcall {
      overlay.drawOn(cloneGraphics(g));
    }

    if (selection != null) {
      if (verbose) _print("render selection");
      // drawRect is inclusive, selection is exclusive, so... whatever, tests show it's cool.
      drawSelectionRect(g, selection, Color.green, Color.white);
    }
  }

  public void drawSelectionRect(Graphics2D g, Rectangle selection, Color green, Color white) {
    drawSelectionRect(g, selection, green, white, zoomX, zoomY);
  }
  
  public void drawSelectionRect(Graphics2D g, Rectangle selection, Color green, Color white, double zoomX, double zoomY) {
    g.setColor(green);
    int top = (int) (selection.y * zoomY);
    int bottom = (int) ((selection.y+selection.height) * zoomY);
    int left = (int) (selection.x * zoomX);
    int right = (int) ((selection.x+selection.width) * zoomX);
    g.drawRect(left-1, top-1, right-left+1, bottom-top+1);
    g.setColor(white);
    g.drawRect(left - 2, top - 2, right - left + 3, bottom - top + 3);
  }

  public ImageSurface setZoom(double zoom) {
    setZoom(zoom, zoom);
    this;
  }

  public void setZoom(double zoomX, double zoomY) {
    autoZoomToDisplay = false;
    setZoom_dontChangeAutoZoom(zoomX, zoomY);
  }
  
  public void setZoom_dontChangeAutoZoom(double zoomX, double zoomY default zoomX) {
    if (this.zoomX == zoomX && this.zoomY == zoomY) ret;
    if (verbose) _print("Setting zoom");
    this.zoomX = zoomX;
    this.zoomY = zoomY;
    revalidateMe();
    repaint();
    centerPoint(new Point(getImage().getWidth()/2, getImage().getHeight()/2));

    pcallF(onZoom);
  }

  public scaffolded Dimension getMinimumSize() {
    if (noMinimumSize) ret new Dimension(1, 1);
    int w = getZoomedWidth();
    int h = getZoomedHeight();
    Dimension min = super.getMinimumSize();
    ret printIfScaffoldingEnabled(this, new Dimension(Math.max(w, min.width), Math.max(h, min.height)));
  }

  int getZoomedHeight() {
    return (int) (h() * zoomY);
  }

  int getZoomedWidth() {
    return (int) (w() * zoomX);
  }

  bool isShowing_quick() {
    if (showingVar == null) swing {
      showingVar if null = componentShowingVar(ImageSurface.this);
    }
    
    ret showingVar!;
  }
  
  public void setImageIfShowing_thisThread(BufferedImage etc image) {
    if (isShowing_quick())
      setImage_thisThread(image);
  }
  
  void setImage(File file) {
    setFile(file);
    setImage(loadImage2(file));
  }

  public void setImage(MakesBufferedImage image) swing {
    setImage_thisThread(image);
  }
  
  public void setImage(BufferedImage img) swing {
    setImage_thisThread(img);
  }
    
  public void setImage_thisThread(BufferedImage etc img) {
    BufferedImage newImage = img != null ? img : dummyImage();
    BufferedImage oldImage = image;
    image = newImage;
    if (verbose) print("Old image size:" + imageSize(oldImage) + ", new image size: " + imageSize(newImage));
    bool sameSize = imagesHaveSameSize(oldImage, newImage);
    if (!sameSize) {
      if (verbose) _print("New image size");
      revalidateMe();
    }
    quickRepaint();
    pcallF(onNewImage);
    if (!sameSize && autoZoomToDisplay) zoomToDisplaySize();
    imageChanged();
  }
  
  void setImageAndZoomToDisplay(BufferedImage img) {
    setImage(img);
    zoomToDisplaySize();
  }

  public BufferedImage getImage() {
    return image;
  }

  public double getZoomX() {
    return zoomX;
  }

  public double getZoomY() {
    return zoomY;
  }

  public scaffolded Dimension getPreferredSize() {
    ret printIfScaffoldingEnabled(this, new Dimension(getZoomedWidth(), getZoomedHeight()));
  }

  /** returns a scrollpane with the scroll-mode prevent-garbage-drawing fix applied */
  public JScrollPane makeScrollPane() {
    JScrollPane scrollPane = new JScrollPane(this);
    scrollPane.getViewport().setScrollMode(JViewport.BACKINGSTORE_SCROLL_MODE);
    return scrollPane;
  }

  public void zoomToWindow() { zoomToDisplaySize(); }
  public void zoomToDisplaySize() swing {
    if (!hasImage()) return;
    Dimension display = getDisplaySize();
    if (display.width == 0 || display.height == 0) ret;
    int w = w(), h = h();
    double xRatio = (display.width-5)/(double) w;
    double yRatio = (display.height-5)/(double) h;
    if (scaffoldingEnabled(this))
      printVars zoomToDisplaySize(+display, +w, +h, +xRatio, +yRatio);
    setZoom_dontChangeAutoZoom(min(xRatio, yRatio));
    revalidateMe();
  }

  /** tricky magic to get parent scroll pane */
  private scaffolded Dimension getDisplaySize() {
    Container c = getParent();
    while (c != null) {
      if (c instanceof JScrollPane)
        return c.getSize();
      c = c.getParent();
    }
    return getSize();
  }
  
  public void setSelection(Rect r) {
    setSelection(toRectangle(r));
  }

  public void setSelection(Rectangle r) {
    if (neq(selection, r)) {
      selection = r;
      pcallF(onSelectionChange);
      quickRepaint();
    }
  }

  public Rectangle getSelection() {
    return selection;
  }

  public RGBImage getRGBImage() {
    return new RGBImage(getImage());
  }
  
  // p is in image coordinates
  void centerPoint(Point p) {
    JScrollPane sp = enclosingScrollPane(this);
    if (sp == null) ret;
      
    p = new Point((int) (p.x*getZoomX()), (int) (p.y*getZoomY()));
    final JViewport viewport = sp.getViewport();
    Dimension viewSize = viewport.getExtentSize();
    
    //_print("centerPoint " + p);
    int x = max(0, p.x-viewSize.width/2);
    int y = max(0, p.y-viewSize.height/2);
    
    //_print("centerPoint " + p + " => " + x + "/" + y);
    p = new Point(x,y);
    //_print("centerPoint " + p);
    final Point _p = p;
    awtLater(r {
      viewport.setViewPosition(_p);
    });
  }
  
  Pt pointFromEvent(MouseEvent e) {
    ret pointFromComponentCoordinates(new Pt(e.getX(), e.getY()));
  }
  
  Pt pointFromComponentCoordinates(Pt p) {
    ret new Pt((int) (p.x/zoomX), (int) (p.y/zoomY));
  }
  
  Pt pointToComponentCoordinates(double x, double y) {
    ret new Pt((int) (x*zoomX), (int) (y*zoomY));
  }
  
  void uploadTheImage {
    //call(hotwire(/*#1007313*/#1016427), "go", getImage(), titleForUpload);
    ifdef ImageSurface_AllowUpload
      var img = getImage();
      JTextField tf = jTextField(titleForUpload);
      showFormTitled("Upload Image (PNG)",
        "Image title (optional)", tf, func {
          disableSubmitButton(getFrame(tf));
          thread "Upload Image" {
            try {
              messageBox("Image uploaded as " + uploadPNGToImageServer(img, titleForUpload = getTextTrim(tf)));
              disposeFrame(tf);
            } catch e {
              enableSubmitButton(getFrame(tf));
              messageBox(e);
            }
          }
          false;
        });
    endifdef
  }
  
  void showFullScreen() {
    showFullScreenImageSurface(getImage());
  }
  
  void zoomIn(double f) { setZoom(getZoomX()*f, getZoomY()*f); }
  void zoomOut(double f) { setZoom(getZoomX()/f, getZoomY()/f); }
  
  selfType setFile(File f) { file = f; this; }
  
  void setOverlay(IVF1<Graphics2D> overlay) {
    this.overlay = overlay;
  }
  
  bool hasImage() { ret image != null; }
  public int w() { ret image.getWidth(); }
  public int h() { ret image.getHeight(); }
  
  void setPixelated aka pixelate(bool b) {
    assertTrue(b);
    imageSurface_pixelated(this);
  }
  
  selfType setAutoZoomToDisplay aka autoZoomToDisplay(bool b) {
    if (autoZoomToDisplay = b)
      zoomToDisplaySize();
    this;
  }
  
  void quickRepaint() {
    if (repaintInThread)
      paintImmediately(0, 0, getWidth(), getHeight());
    else
      repaint();
  }
  
  void setTool(ImageSurfaceMouseHandler tool) swing {
    removeAllTools();
    addTool(tool);
  }
  
  bool hasTool(AutoCloseable tool) {
    ret swing(-> tools.contains(tool));
  }
  
  void addTool(ImageSurfaceMouseHandler tool) swing {
    if (!tools.contains(tool))
      tool.register(this);
  }
  
  void removeTool(AutoCloseable tool) swing {
    if (tools.contains(tool)) {
      close(tool);
      tools.remove(tool);
    }
  }
  
  void removeAllTools aka clearTools() {
    closeAllAndClear(tools);
  }
  
  void performAutoZoom {
    if (autoZoomToDisplay) zoomToDisplaySize();
  }
  
  void revalidateMe() {
    revalidateIncludingFullCenterContainer(this);
  }
  
  void addOverlay(G2Drawable overlay) {
    overlays.add(overlay);
    repaint();
  }
  
  void clearOverlays() {
    if (nempty(overlays)) {
      overlays.clear();
      repaint();
    }
  }
  
  void setOverlay(G2Drawable overlay) {
    clearOverlays();
    if (overlay != null) addOverlay(overlay);
  }
  
  void loadImage(File f) {
    setImage(loadImage2(f));
  }
  
  JComponent visualize() {
    ret jscroll_center_borderless(this);
  }
  
  void standardZoom() {
    setZoom(1.0);
  }
  
  !include #1034645 // print
} // end of ImageSurface

// static function allows garbage collection 
static VF2<ImageSurface, JPopupMenu> ImageSurface_popupMenuMaker() {
  ret voidfunc(ImageSurface is, JPopupMenu menu) {
    Point p = is.pointFromEvent(componentPopupMenu_mouseEvent.get()).getPoint();
    is.fillPopupMenu(menu, p);
  };
}