import javafx.ui.canvas.*;
import javafx.ui.*;
import java.lang.System;
import javax.swing.Timer;
import java.awt.event.ActionListener;
import java.awt.Toolkit;
import java.lang.Thread;
import java.lang.Exception;
import java.awt.Robot;
import java.awt.Rectangle;
import java.awt.Image as JavaImg;
import java.awt.image.BufferedImage;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.util.Random;
import java.awt.Dimension;

var size = Toolkit.getDefaultToolkit().getScreenSize();

var image = Image {image: getDesktop()};


var pattern = new Pattern {
	content: ImageView {
		image: bind image
	}
};

class ImageRect extends Rect {
	attribute dx: Number;
	attribute dy: Number;
}


operation getDesktop():JavaImg {
	var r = new Robot();
	var s = Toolkit.getDefaultToolkit().getScreenSize();
	var bimg = r.createScreenCapture(new Rectangle((Integer)0, (Integer)0, (Integer)s.width, (Integer)s.height));
	var bi = new BufferedImage(bimg.getWidth(), bimg.getHeight(), bimg.getType());
    var g = (Graphics2D) bi.getGraphics();
    g.drawImage(bimg, 0, 0, null);
    bimg = bi;
    return bimg;
}


class RotateModel {
	attribute zoom: Number;
	attribute rotate: Number;
	attribute alpha: Number;
	attribute elapsed: Number;
	attribute bouncingImages: Number;
	attribute goUp: Boolean;
	attribute fillPattern: Pattern;
	attribute imageRect: ImageRect*;
	operation animate();
}

attribute RotateModel.elapsed = bind [0..100] dur 300000 linear;

attribute RotateModel.bouncingImages = bind [0..999999] dur 9999990 linear;

attribute RotateModel.zoom = 1.0;
attribute RotateModel.rotate = 0;
attribute RotateModel.alpha = 1.0;
attribute RotateModel.goUp = false;

var rotModel = RotateModel { zoom: 1.0, rotate: 0, alpha: 1.0, goUp: false, fillPattern: bind pattern};

trigger on RotateModel.bouncingImages = value {
	var i = 0;
	var size = Toolkit.getDefaultToolkit().getScreenSize();
	while (i < sizeof imageRect) {
		
		if (imageRect[i].x < 10 or imageRect[i].x >= size.width-20) {
  			imageRect[i].dx = - imageRect[i].dx;
		}	
		if (imageRect[i].y < 10 or imageRect[i].y >= size.height-20) {
   			imageRect[i].dy = - imageRect[i].dy;
		}
	
		imageRect[i].x += imageRect[i].dx;
		imageRect[i].y += imageRect[i].dy;
		i ++;
	}
}	


trigger on RotateModel.elapsed = value {
	goUp = not goUp;
	animate();
	if (sizeof imageRect <= 10) {
		var size = Toolkit.getDefaultToolkit().getScreenSize();
		var random = new Random();
		var imgRect = ImageRect { 
			x: random.nextInt((Integer)size.width), y: random.nextInt((Integer)size.height), 
			width:100, height: 100, dx: 60, dy: 60, 
			//opacity: bind (1.0 - alpha),
			fill: fillPattern,
			strokeWidth: 2
		};
		insert imgRect into imageRect;
	}
}

var transformGroup = false;

operation RotateModel.animate() {    
    if (goUp) {
		zoom = [0.00,0.01..1.0] dur 2000 linear;
		rotate = [0..360] dur 2000 linear;
		alpha = [0.100,0.101..1.00] dur 2000 linear;
	} else {
		zoom = [1.000,0.999..0.0] dur 2000 linear;
		rotate = [360..0] dur 2000 linear;
		alpha = [1.00,0.999..0.100] dur 2000 linear;
    }
}


Frame {

	width: bind size.width
    height: bind size.height
    undecorated: true
    resizable: true
	disposeOnClose: true	
	background: black
		
	content: Canvas {
		
		background: RadialGradient {
			cx: size.width/2
			cy: size.height/2
			radius: size.height/2
			
			stops: [Stop {
               	offset: 0
               	color: red
            },
            
            Stop {
               	offset: 1
               	color: black
            }]
		}
		
		
		onMouseClicked: operation(e:MouseEvent) {
			if (e.button == 1) {
				transformGroup = not transformGroup;
			} else {
				System.exit(0);
			}
		}
		
		content: bind [Group {
			transform: bind if (transformGroup) then [rotate(360 - rotModel.rotate, size.width/2, size.height/2)] else rotate(0, size.width/2, size.height/2)
			
			content: [Rect {
				transform: bind [rotate(360, size.width/2, size.height/2), scale(rotModel.zoom, rotModel.zoom), rotate(rotModel.rotate, size.width/2, size.height/2)]
				x: 0
				y: 0
				width: bind size.width
				height: bind size.height
				opacity: bind rotModel.alpha
				fill: pattern 
			}, 
			Arc {
				transform: bind [rotate(180, size.width/2, size.height/2), scale(rotModel.zoom, rotModel.zoom), rotate(rotModel.rotate, size.width/2, size.height/2)]
				x: 0
				y: 0
				width: bind size.width
				height: bind size.height
				startAngle: 0
				length: bind rotModel.rotate
				closure: PIE
				opacity: bind (1.0 - rotModel.alpha)
				fill: pattern
			}, 
			Circle {
				transform: bind [rotate(90, size.width/2, size.height/2), scale(rotModel.zoom, rotModel.zoom), rotate(rotModel.rotate, size.width/2, size.height/2)]
				cx: bind size.width/2
				cy: bind size.height/2
				radius: bind size.height/2
				opacity: bind (1.0 - rotModel.alpha)
				fill: pattern
			}, 
			QuadCurve {
				transform: bind [rotate(270, size.width/2, size.height/2), scale(rotModel.zoom, rotModel.zoom), rotate(rotModel.rotate, size.width/2, size.height/2)]
        		x1: 0
        		y1: 0
        		ctrlx: bind (2 * size.width)
        		ctrly: bind size.height/2
        		x2: 0
        		y2: bind size.height
        		opacity: bind (1.0 - rotModel.alpha)
        		fill: pattern
        	}]
        }, rotModel.imageRect]
    }
    visible: true
}