module tk.events;

import tk.types;
import tk.geometry;

//
// Should we pass the screen and model points into
// the events or pass a transform in separately to the handler
//

abstract class Event {
    this() {
    }

    private {
    }
}

final class ExposeEvent : Event {
    this() {
        super();
    }

    private {
    }
}

abstract class InputEvent : Event {
    this(Mask mask) {
        mMask = mask;
    }

    const(Mask) mask() const { return mMask; }

    private {
        Mask mMask;
    }
}

final class CrossingEvent : InputEvent {
    this(Mask mask) {
        super(mask);
    }

    private {
    }
}

final class KeyEvent : InputEvent {
    this(string str, uint value, Mask mask) {
        super(mask);
        mStr = str;
        mValue = value;
    }

    string str() const { return mStr; }

    override string toString() const {
        return std.string.format("Key event: %s, %d, %s", mStr, mValue, mMask);
    }

    private {
        string mStr;
        uint mValue;
    }
}

abstract class PointerEvent : InputEvent {
    this(in Point screen_point, in Point model_point, Mask mask) {
        super(mask);
        mScreenPoint = screen_point;
        mModelPoint = model_point;
    }

    Point screen_point() const { return mScreenPoint; }
    Point model_point() const { return mModelPoint; }

    private {
        Point mScreenPoint;
        Point mModelPoint;
    }
}

final class ButtonEvent : PointerEvent {
    this(ButtonAction button_action,
         ButtonName button_name,
         Point screen_point,
         Point model_point,
         Mask mask) {   
        super(screen_point, model_point, mask);
        mButtonAction = button_action;
        mButtonName = button_name;
    }

    override string toString() const {
        return std.string.format("Button event: %s, %s, %s, %s, %s",
                                 enumToString(mButtonAction), enumToString(mButtonName),
                                 mScreenPoint, mModelPoint, mMask);
    }

    ButtonAction button_action() const { return mButtonAction; }
    ButtonName button_name() const { return mButtonName; }

    private {
        ButtonAction mButtonAction;
        ButtonName mButtonName;
    }
}

final class MotionEvent : PointerEvent {
    this(in Point screen_point,
         in Point model_point,
         Mask mask) {
        super(screen_point, model_point, mask);
    }

    override string toString() const {
        return std.string.format("Motion event: %s, %s, %s",
                                 mScreenPoint, mModelPoint, mMask);
    }
}

final class ScrollEvent : PointerEvent {
    this(in ScrollDirection scroll_direction,
         in Point screen_point,
         in Point model_point,
         Mask mask) {
        super(screen_point, model_point, mask);
        mScrollDirection = scroll_direction;
    }

    override string toString() const {
        return std.string.format("Scroll event: %s, %s, %s, %s",
                                 enumToString(mScrollDirection), mScreenPoint, mModelPoint, mMask);
    }

    ScrollDirection scroll_direction() const { return mScrollDirection; }

    private {
        ScrollDirection mScrollDirection;
    }
}