{ import: sdl }
{ import: MiniCairo }
{ import: Views }
{ import: Views-drawing }
{ import: Views-properties }
{ import: Views-events }
{ import: Colour }
{ import: Shape }
{ import: Event }
{ import: EventHandler }

TestCase : Object ()
TestCase assert: result equals: expected
[
    result = expected ifTrue: [^ 'success' putln].
    ('failure: expected = ', expected printString, ' result = ', result printString) putln.
]

TestCase testView
[
    | view translated world |
    'TestCase >> testView' putln.
    view := (Rectangle origin: 10, 10 extent: 20, 30) shapedView transformView.
    translated := view translateBy: 10, 10.
    self assert: translated bounds origin equals: 20, 20.
    world := WorldView new.
    world add: translated.
    translated translateBy: 10, 10.
    self assert: translated bounds origin equals: 30, 30.
    world add: view.
    self assert: view equals: translated.
    self assert: (view translateBy: 10, 10) container equals: world contents.
]

TestCase testTransform
[
    | t |
    t := Transform2D withIdentity translatedBy: 20, 10.
    self assert: (10, 10 transformedBy: t) equals: 30, 20.
    t translatedBy: 10, 10.
    self assert: (0, 0 transformedBy: t) equals: 20, 10.
    t translateBy: 10, 10.
    self assert: (0, 0 transformedBy: t) equals: 30, 20.
]


WorldView : View (eventHandler damage)

WorldView new
[
    self := super new.
    eventHandler := EventHandler withWorld: self.
]

WorldView shape [^ Rectangle origin: 0, 0 extent: 640, 480]

WorldView dispatchEvent: anEvent
[
    | view |
    anEvent ifFalse: [^self].
    anEvent handler: eventHandler.
    eventHandler handleEvent: anEvent.
]

WorldView pushEventHandler: anEventHandler
[
    anEventHandler previous: eventHandler.
    eventHandler := anEventHandler.
]

WorldView popEventHandler: anEventHandler
[
    eventHandler == anEventHandler ifFalse: [self error: 'non-LIFO event handlers'].
    eventHandler := eventHandler previous.
]

WorldView globalToLocal: aPointOrShape
[
    ^aPointOrShape
]

WorldView damaged: aRectangle
[
    damage := damage = nil ifTrue: [aRectangle]
        ifFalse: [damage union: aRectangle].
]

WorldView forceDamageToScreenOn: aCanvas
[
    damage ifNil: [^self].
    damage := (damage intersect: self bounds) expanded outsetBy: 2,2.
	self drawOn: aCanvas in: damage.
"    aCanvas setSourceR: 0 G: 1 B: 0;
        rectangle: clipRectangle;
        setStrokeWidth: 2;
        stroke."
	damage := nil.
]

[ TestCase testView. TestCase testTransform. ]

[
    | sdl cairo r view world isRunning eventHandler |
    sdl := SDL new.
    sdl setVideoMode : 640 : 480 : 32 : 0.
    cairo := Cairo createImageSurfaceCreateForData: sdl pixels : 640, 480.

    r := Rectangle origin: 10, 10 extent: 100, 100.
    view := r shapedView.
    view strokeColour: (Colour withR: 0.5 G: 0.6 B: 0.7).
    view strokeWidth: 3.
    view fillColour: (Colour withR: 0.6 G: 0.8 B: 0.9).
    view := view transformView.

    world := WorldView new.
    world fillColour: Colour white.
    world add: view.

    view propertyAt: #pointerDownEvent put: [:v :event | event handler beginDragging: v from: event].

    world drawOn: cairo in: world bounds.
    isRunning := true.
    [isRunning] whileTrue: [
        | event key |
        world forceDamageToScreenOn: cairo.
        sdl flip.
        event := sdl waitEvent.
        (event isKindOf: Event) ifTrue: [
    	    event localPosition: event  position.
            world dispatchEvent: event.
        ]].

    SDL quit.
]