I would appreciate some help with camera movement and zoom. Is there any easier way with cleaner code, or simply how can I improve it?

* Window size: 800x600  
* Image size: 1200x900

This is my code so far (you can move with the camera only around the image and use zoom):

    package game.engine.gui;

    import java.awt.Graphics2D;
    import java.awt.Point;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseWheelEvent;

    public class Camera {
    
    public boolean isEnabled = true;
    public int offsetX = 0;
    public int offsetY = 0;
    public float zoom = 1;
    private Point mouseLocation;
    private int maxOffsetXZoom = 200;
    private int maxOffsetYZoom = 150;
    private final int maxOffsetX = 200;
    private final int maxOffsetY = 150;
    private final float maxZoom = 1.2F;
    private final float minZoom = 0.7F;

    public Camera() { }
    
    public void draw(Graphics2D g) { }
    
    public void update() { }
    
    public void mousePressed(MouseEvent e) { mouseLocation = e.getPoint(); }
    
    public void mouseReleased(MouseEvent e) { }
    
    public void mouseMoved(MouseEvent e) { }
    
    public void mouseDragged(MouseEvent e)
    {
        int newoffsetX = offsetX - (mouseLocation.x - e.getX());
        int newoffsetY = offsetY -  (mouseLocation.y - e.getY());
            
        if(newoffsetX > maxOffsetXZoom) offsetX = maxOffsetXZoom;
        else if(newoffsetX  < -maxOffsetXZoom + (maxOffsetX-maxOffsetXZoom) * 4) offsetX = -maxOffsetXZoom + (maxOffsetX-maxOffsetXZoom) * 4;
        else offsetX = newoffsetX;
            
        if(newoffsetY  > maxOffsetYZoom) offsetY = maxOffsetYZoom;
        else if(newoffsetY < -maxOffsetYZoom - 25 + (maxOffsetY-maxOffsetYZoom) * 4) offsetY = -maxOffsetYZoom - 25 + (maxOffsetY-maxOffsetYZoom) * 4;
        else offsetY = newoffsetY;
            
        mouseLocation = e.getPoint();
    }
    
    public void mouseScrolled(MouseWheelEvent e)
    {
        if (e.getWheelRotation() < 0) {
            if(zoom<maxZoom) zoom += 0.05;
        } else {
            if(zoom>minZoom) zoom -= 0.05;
        }
        maxOffsetXZoom = (int) (maxOffsetX * zoom);
        maxOffsetYZoom = (int) (maxOffsetY * zoom);
        if(offsetX > maxOffsetXZoom) offsetX = maxOffsetXZoom;
        else if(offsetX  < -maxOffsetXZoom + (maxOffsetX-maxOffsetXZoom) * 4) offsetX = -maxOffsetXZoom + (maxOffsetX-maxOffsetXZoom) * 4;
            
        if(offsetY  > maxOffsetYZoom) offsetY = maxOffsetYZoom;
        else if(offsetY < -maxOffsetYZoom - 25 + (maxOffsetY-maxOffsetYZoom) * 4) offsetY = -maxOffsetYZoom - 25 + (maxOffsetY-maxOffsetYZoom) * 4;
    }
    }

It works, but I think it's a huge mess and also if the image size was different it would require a lot of changes. I am using my own engine.