Layer.h

Go to the documentation of this file.

#pragma once
 
#include "../Layer.h"
#include "../Geometry/Bounds.h"
 
namespace Gorgon { namespace Input {
 
        class Layer : public Gorgon::Layer {
        public:
            using Gorgon::Layer::Layer;
 
 
            void SetHitCheck(std::function<bool(Layer &, Geometry::Point)> fn) {
                hitcheck = fn;
            }
            
            void SetHitCheck(std::function<bool(Geometry::Point)> fn) {
                hitcheck = [fn](Layer &, Geometry::Point point) { return fn(point); };
            }
 
            template<class C_>
            void SetHitCheck(C_ &c, bool(C_::*fn)(Layer &, Geometry::Point)) {
                C_ *my = &c;
                hitcheck = [fn, my](Layer &layer, Geometry::Point point) { return (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetHitCheck(C_ &c, bool(C_::*fn)(Geometry::Point)) {
                C_ *my = &c;
                hitcheck = [fn, my](Layer &, Geometry::Point point) { return (my->*fn)(point); };
            }
 
            template<class C_>
            void SetHitCheck(C_ *my, bool(C_::*fn)(Layer &, Geometry::Point)) {
                hitcheck = [fn, my](Layer &layer, Geometry::Point point) { return (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetHitCheck(C_ *my, bool(C_::*fn)(Geometry::Point)) {
                hitcheck = [fn, my](Layer &, Geometry::Point point) { return (my->*fn)(point); };
            }
            
            void ResetHitCheck() {
                hitcheck = {};
            }
 
            
            
            void SetClick(std::function<void(Layer &, Geometry::Point, Input::Mouse::Button)> fn) {
                click = fn;
            }
            
            void SetClick(std::function<void(Geometry::Point, Input::Mouse::Button)> fn) {
                click = [fn](Layer &, Geometry::Point point, Input::Mouse::Button btn) { fn(point, btn); };
            }
 
            template<class C_>
            void SetClick(C_ &c, void(C_::*fn)(Layer &, Geometry::Point, Input::Mouse::Button)) {
                C_ *my = &c;
                click = [fn, my](Layer &layer, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(layer, point, btn); };
            }
            
            template<class C_>
            void SetClick(C_ &c, void(C_::*fn)(Geometry::Point, Input::Mouse::Button)) {
                C_ *my = &c;
                click = [fn, my](Layer &, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(point, btn); };
            }
 
            template<class C_>
            void SetClick(C_ *my, void(C_::*fn)(Layer &, Geometry::Point, Input::Mouse::Button)) {
                click = [fn, my](Layer &layer, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(layer, point, btn); };
            }
            
            template<class C_>
            void SetClick(C_ *my, void(C_::*fn)(Geometry::Point, Input::Mouse::Button)) {
                click = [fn, my](Layer &, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(point, btn); };
            }
            
            void SetClick(std::function<void(Layer &, Input::Mouse::Button)> fn) {
                click = [fn](Layer &layer, Geometry::Point, Input::Mouse::Button btn) { fn(layer, btn); };
            }
            
            void SetClick(std::function<void(Input::Mouse::Button)> fn) {
                click = [fn](Layer &, Geometry::Point, Input::Mouse::Button btn) { fn(btn); };
            }
 
            template<class C_>
            void SetClick(C_ &c, void(C_::*fn)(Layer &, Input::Mouse::Button)) {
                C_ *my = &c;
                click = [fn, my](Layer &layer, Input::Mouse::Button btn) { (my->*fn)(layer, btn); };
            }
            
            template<class C_>
            void SetClick(C_ &c, void(C_::*fn)(Input::Mouse::Button)) {
                C_ *my = &c;
                click = [fn, my](Layer &, Geometry::Point, Input::Mouse::Button btn) { (my->*fn)(btn); };
            }
 
            template<class C_>
            void SetClick(C_ *my, void(C_::*fn)(Layer &, Input::Mouse::Button)) {
                click = [fn, my](Layer &layer, Input::Mouse::Button btn) { (my->*fn)(layer, btn); };
            }
            
            template<class C_>
            void SetClick(C_ *my, void(C_::*fn)(Input::Mouse::Button)) {
                click = [fn, my](Layer &, Geometry::Point, Input::Mouse::Button btn) { (my->*fn)(btn); };
            }
            
            void SetClick(std::function<void(Layer &, Geometry::Point)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) fn(layer, point); };
            }
            
            void SetClick(std::function<void(Geometry::Point)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) fn(point); };
            }
 
            template<class C_>
            void SetClick(C_ &c, void(C_::*fn)(Layer &, Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                click = [fn, my, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetClick(C_ &c, void(C_::*fn)(Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                click = [fn, my, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(point); };
            }
 
            template<class C_>
            void SetClick(C_ *my, void(C_::*fn)(Layer &, Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, my, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetClick(C_ *my, void(C_::*fn)(Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, my, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(point); };
            }
            
            void SetClick(std::function<void(Layer &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, btn](Layer &layer, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) fn(layer); };
            }
            
            void SetClick(std::function<void()> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) fn(); };
            }
 
            template<class C_>
            void SetClick(C_ &c, void(C_::*fn)(Layer &), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                click = [fn, my, btn](Layer &layer, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetClick(C_ &c, std::function<void(C_ &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                click = [fn, my, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(); };
            }
 
            template<class C_>
            void SetClick(C_ *my, void(C_::*fn)(Layer &), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, my, btn](Layer &layer, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetClick(C_ *my, std::function<void(C_ &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                click = [fn, my, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(); };
            }
            
            void ResetClick() {
                click = {};
            }
 
            
            
            void SetDown(std::function<void(Layer &, Geometry::Point, Input::Mouse::Button)> fn) {
                down = fn;
            }
            
            void SetDown(std::function<void(Geometry::Point, Input::Mouse::Button)> fn) {
                down = [fn](Layer &, Geometry::Point point, Input::Mouse::Button btn) { fn(point, btn); };
            }
 
            template<class C_>
            void SetDown(C_ &c, void(C_::*fn)(Layer &, Geometry::Point, Input::Mouse::Button)) {
                C_ *my = &c;
                down = [fn, my](Layer &layer, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(layer, point, btn); };
            }
            
            template<class C_>
            void SetDown(C_ &c, void(C_::*fn)(Geometry::Point, Input::Mouse::Button)) {
                C_ *my = &c;
                down = [fn, my](Layer &, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(point, btn); };
            }
 
            template<class C_>
            void SetDown(C_ *my, void(C_::*fn)(Layer &, Geometry::Point, Input::Mouse::Button)) {
                down = [fn, my](Layer &layer, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(layer, point, btn); };
            }
            
            template<class C_>
            void SetDown(C_ *my, void(C_::*fn)(Geometry::Point, Input::Mouse::Button)) {
                down = [fn, my](Layer &, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(point, btn); };
            }
            
            void SetDown(std::function<void(Layer &, Input::Mouse::Button)> fn) {
                down = [fn](Layer &layer, Geometry::Point, Input::Mouse::Button btn) { fn(layer, btn); };
            }
            
            void SetDown(std::function<void(Input::Mouse::Button)> fn) {
                down = [fn](Layer &, Geometry::Point, Input::Mouse::Button btn) { fn(btn); };
            }
 
            template<class C_>
            void SetDown(C_ &c, void(C_::*fn)(Layer &, Input::Mouse::Button)) {
                C_ *my = &c;
                down = [fn, my](Layer &layer, Input::Mouse::Button btn) { (my->*fn)(layer, btn); };
            }
            
            template<class C_>
            void SetDown(C_ &c, void(C_::*fn)(Input::Mouse::Button)) {
                C_ *my = &c;
                down = [fn, my](Layer &, Geometry::Point, Input::Mouse::Button btn) { (my->*fn)(btn); };
            }
 
            template<class C_>
            void SetDown(C_ *my, void(C_::*fn)(Layer &, Input::Mouse::Button)) {
                down = [fn, my](Layer &layer, Input::Mouse::Button btn) { (my->*fn)(layer, btn); };
            }
            
            template<class C_>
            void SetDown(C_ *my, void(C_::*fn)(Input::Mouse::Button)) {
                down = [fn, my](Layer &, Geometry::Point, Input::Mouse::Button btn) { (my->*fn)(btn); };
            }
            
            void SetDown(std::function<void(Layer &, Geometry::Point)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) fn(layer, point); };
            }
            
            void SetDown(std::function<void(Geometry::Point)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) fn(point); };
            }
 
            template<class C_>
            void SetDown(C_ &c, void(C_::*fn)(Layer &, Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                down = [fn, my, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetDown(C_ &c, void(C_::*fn)(Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                down = [fn, my, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(point); };
            }
 
            template<class C_>
            void SetDown(C_ *my, void(C_::*fn)(Layer &, Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, my, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetDown(C_ *my, void(C_::*fn)(Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, my, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(point); };
            }
            
            void SetDown(std::function<void(Layer &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, btn](Layer &layer, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) fn(layer); };
            }
            
            void SetDown(std::function<void()> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) fn(); };
            }
 
            template<class C_>
            void SetDown(C_ &c, void(C_::*fn)(Layer &), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                down = [fn, my, btn](Layer &layer, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetDown(C_ &c, std::function<void(C_ &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                down = [fn, my, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(); };
            }
 
            template<class C_>
            void SetDown(C_ *my, void(C_::*fn)(Layer &), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, my, btn](Layer &layer, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetDown(C_ *my, std::function<void(C_ &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                down = [fn, my, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(); };
            }
            
            void ResetDown() {
                down = {};
            }
 
            
            
            void SetUp(std::function<void(Layer &, Geometry::Point, Input::Mouse::Button)> fn) {
                up = fn;
            }
            
            void SetUp(std::function<void(Geometry::Point, Input::Mouse::Button)> fn) {
                up = [fn](Layer &, Geometry::Point point, Input::Mouse::Button btn) { fn(point, btn); };
            }
 
            template<class C_>
            void SetUp(C_ &c, void(C_::*fn)(Layer &, Geometry::Point, Input::Mouse::Button)) {
                C_ *my = &c;
                up = [fn, my](Layer &layer, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(layer, point, btn); };
            }
            
            template<class C_>
            void SetUp(C_ &c, void(C_::*fn)(Geometry::Point, Input::Mouse::Button)) {
                C_ *my = &c;
                up = [fn, my](Layer &, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(point, btn); };
            }
 
            template<class C_>
            void SetUp(C_ *my, void(C_::*fn)(Layer &, Geometry::Point, Input::Mouse::Button)) {
                up = [fn, my](Layer &layer, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(layer, point, btn); };
            }
            
            template<class C_>
            void SetUp(C_ *my, void(C_::*fn)(Geometry::Point, Input::Mouse::Button)) {
                up = [fn, my](Layer &, Geometry::Point point, Input::Mouse::Button btn) { (my->*fn)(point, btn); };
            }
            
            void SetUp(std::function<void(Layer &, Input::Mouse::Button)> fn) {
                up = [fn](Layer &layer, Geometry::Point, Input::Mouse::Button btn) { fn(layer, btn); };
            }
            
            void SetUp(std::function<void(Input::Mouse::Button)> fn) {
                up = [fn](Layer &, Geometry::Point, Input::Mouse::Button btn) { fn(btn); };
            }
 
            template<class C_>
            void SetUp(C_ &c, void(C_::*fn)(Layer &, Input::Mouse::Button)) {
                C_ *my = &c;
                up = [fn, my](Layer &layer, Input::Mouse::Button btn) { (my->*fn)(layer, btn); };
            }
            
            template<class C_>
            void SetUp(C_ &c, void(C_::*fn)(Input::Mouse::Button)) {
                C_ *my = &c;
                up = [fn, my](Layer &, Geometry::Point, Input::Mouse::Button btn) { (my->*fn)(btn); };
            }
 
            template<class C_>
            void SetUp(C_ *my, void(C_::*fn)(Layer &, Input::Mouse::Button)) {
                up = [fn, my](Layer &layer, Input::Mouse::Button btn) { (my->*fn)(layer, btn); };
            }
            
            template<class C_>
            void SetUp(C_ *my, void(C_::*fn)(Input::Mouse::Button)) {
                up = [fn, my](Layer &, Geometry::Point, Input::Mouse::Button btn) { (my->*fn)(btn); };
            }
            
            void SetUp(std::function<void(Layer &, Geometry::Point)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) fn(layer, point); };
            }
            
            void SetUp(std::function<void(Geometry::Point)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) fn(point); };
            }
 
            template<class C_>
            void SetUp(C_ &c, void(C_::*fn)(Layer &, Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                up = [fn, my, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetUp(C_ &c, void(C_::*fn)(Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                up = [fn, my, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(point); };
            }
 
            template<class C_>
            void SetUp(C_ *my, void(C_::*fn)(Layer &, Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, my, btn](Layer &layer, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetUp(C_ *my, void(C_::*fn)(Geometry::Point), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, my, btn](Layer &, Geometry::Point point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(point); };
            }
            
            void SetUp(std::function<void(Layer &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, btn](Layer &layer, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) fn(layer); };
            }
            
            void SetUp(std::function<void()> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) fn(); };
            }
 
            template<class C_>
            void SetUp(C_ &c, void(C_::*fn)(Layer &), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                up = [fn, my, btn](Layer &layer, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetUp(C_ &c, std::function<void(C_ &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                C_ *my = &c;
                up = [fn, my, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(); };
            }
 
            template<class C_>
            void SetUp(C_ *my, void(C_::*fn)(Layer &), Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, my, btn](Layer &layer, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetUp(C_ *my, std::function<void(C_ &)> fn, Input::Mouse::Button btn = Input::Mouse::Button::Left) {
                up = [fn, my, btn](Layer &, Geometry::Point, Input::Mouse::Button b) { if(b&&btn) (my->*fn)(); };
            }
            
            void ResetUp() {
                up = {};
            }
            
            
 
            void SetMove(std::function<void(Layer &, Geometry::Point)> fn) {
                move = fn;
            }
            
            void SetMove(std::function<void(Geometry::Point)> fn) {
                move = [fn](Layer &, Geometry::Point point) { fn(point); };
            }
 
            template<class C_>
            void SetMove(C_ &c, void(C_::*fn)(Layer &, Geometry::Point)) {
                C_ *my = &c;
                move = [fn, my](Layer &layer, Geometry::Point point) { (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetMove(C_ &c, void(C_::*fn)(Geometry::Point)) {
                C_ *my = &c;
                move = [fn, my](Layer &, Geometry::Point point) { (my->*fn)(point); };
            }
 
            template<class C_>
            void SetMove(C_ *my, void(C_::*fn)(Layer &, Geometry::Point)) {
                move = [fn, my](Layer &layer, Geometry::Point point) { (my->*fn)(layer, point); };
            }
            
            template<class C_>
            void SetMove(C_ *my, void(C_::*fn)(Geometry::Point)) {
                move = [fn, my](Layer &, Geometry::Point point) { (my->*fn)(point); };
            }
            
            void ResetMove() {
                move = {};
            }
 
  
 
            void SetScroll(std::function<bool(Layer &, Geometry::Point, float)> fn) {
                vscroll = fn;
            }
 
            void SetScroll(std::function<bool(Geometry::Point, float)> fn) {
                vscroll = [fn](Layer &, Geometry::Point point, float amount) { return fn(point, amount); };
            }
 
            template<class C_>
            void SetScroll(C_ &c, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                C_ *my = &c;
                vscroll = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetScroll(C_ &c, bool(C_::*fn)(Geometry::Point, float)) {
                C_ *my = &c;
                vscroll = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            template<class C_>
            void SetScroll(C_ *my, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                vscroll = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetScroll(C_ *my, bool(C_::*fn)(Geometry::Point, float)) {
                vscroll = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            void SetScroll(std::function<bool(Layer &, float)> fn) {
                vscroll = [fn](Layer &layer, Geometry::Point, float amount) { return fn(layer, amount); };
            }
 
            void SetScroll(std::function<bool(float)> fn) {
                vscroll = [fn](Layer &, Geometry::Point, float amount) { return fn(amount); };
            }
 
            template<class C_>
            void SetScroll(C_ &c, bool(C_::*fn)(Layer &, float)) {
                C_ *my = &c;
                vscroll = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetScroll(C_ &c, bool(C_::*fn)(float)) {
                C_ *my = &c;
                vscroll = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            template<class C_>
            void SetScroll(C_ *my, bool(C_::*fn)(Layer &, float)) {
                vscroll = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetScroll(C_ *my, bool(C_::*fn)(float)) {
                vscroll = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            void ResetScroll() {
                vscroll ={};
            }
 
 
 
            void SetHScroll(std::function<bool(Layer &, Geometry::Point, float)> fn) {
                hscroll = fn;
            }
 
            void SetHScroll(std::function<bool(Geometry::Point, float)> fn) {
                hscroll = [fn](Layer &, Geometry::Point point, float amount) { return fn(point, amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ &c, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                C_ *my = &c;
                hscroll = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ &c, bool(C_::*fn)(Geometry::Point, float)) {
                C_ *my = &c;
                hscroll = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ *my, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                hscroll = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ *my, bool(C_::*fn)(Geometry::Point, float)) {
                hscroll = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            void SetHScroll(std::function<bool(Layer &, float)> fn) {
                hscroll = [fn](Layer &layer, Geometry::Point, float amount) { return fn(layer, amount); };
            }
 
            void SetHScroll(std::function<bool(float)> fn) {
                hscroll = [fn](Layer &, Geometry::Point, float amount) { return fn(amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ &c, bool(C_::*fn)(Layer &, float)) {
                C_ *my = &c;
                hscroll = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ &c, bool(C_::*fn)(float)) {
                C_ *my = &c;
                hscroll = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ *my, bool(C_::*fn)(Layer &, float)) {
                hscroll = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetHScroll(C_ *my, bool(C_::*fn)(float)) {
                hscroll = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            void ResetHScroll() {
                hscroll ={};
            }
 
 
 
            void SetZoom(std::function<bool(Layer &, Geometry::Point, float)> fn) {
                zoom = fn;
            }
 
            void SetZoom(std::function<bool(Geometry::Point, float)> fn) {
                zoom = [fn](Layer &, Geometry::Point point, float amount) { return fn(point, amount); };
            }
 
            template<class C_>
            void SetZoom(C_ &c, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                C_ *my = &c;
                zoom = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetZoom(C_ &c, bool(C_::*fn)(Geometry::Point, float)) {
                C_ *my = &c;
                zoom = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            template<class C_>
            void SetZoom(C_ *my, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                zoom = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetZoom(C_ *my, bool(C_::*fn)(Geometry::Point, float)) {
                zoom = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            void SetZoom(std::function<bool(Layer &, float)> fn) {
                zoom = [fn](Layer &layer, Geometry::Point, float amount) { return fn(layer, amount); };
            }
 
            void SetZoom(std::function<bool(float)> fn) {
                zoom = [fn](Layer &, Geometry::Point, float amount) { return fn(amount); };
            }
 
            template<class C_>
            void SetZoom(C_ &c, bool(C_::*fn)(Layer &, float)) {
                C_ *my = &c;
                zoom = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetZoom(C_ &c, bool(C_::*fn)(float)) {
                C_ *my = &c;
                zoom = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            template<class C_>
            void SetZoom(C_ *my, bool(C_::*fn)(Layer &, float)) {
                zoom = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetZoom(C_ *my, bool(C_::*fn)(float)) {
                zoom = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            void ResetZoom() {
                zoom ={};
            }
 
 
 
            void SetRotate(std::function<bool(Layer &, Geometry::Point, float)> fn) {
                rotate = fn;
            }
 
            void SetRotate(std::function<bool(Geometry::Point, float)> fn) {
                rotate = [fn](Layer &, Geometry::Point point, float amount) { return fn(point, amount); };
            }
 
            template<class C_>
            void SetRotate(C_ &c, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                C_ *my = &c;
                rotate = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetRotate(C_ &c, bool(C_::*fn)(Geometry::Point, float)) {
                C_ *my = &c;
                rotate = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            template<class C_>
            void SetRotate(C_ *my, bool(C_::*fn)(Layer &, Geometry::Point, float)) {
                rotate = [fn, my](Layer &layer, Geometry::Point point, float amount) { return (my->*fn)(layer, point, amount); };
            }
 
            template<class C_>
            void SetRotate(C_ *my, bool(C_::*fn)(Geometry::Point, float)) {
                rotate = [fn, my](Layer &, Geometry::Point point, float amount) { return (my->*fn)(point, amount); };
            }
 
            void SetRotate(std::function<bool(Layer &, float)> fn) {
                rotate = [fn](Layer &layer, Geometry::Point, float amount) { return fn(layer, amount); };
            }
 
            void SetRotate(std::function<bool(float)> fn) {
                rotate = [fn](Layer &, Geometry::Point, float amount) { return fn(amount); };
            }
 
            template<class C_>
            void SetRotate(C_ &c, bool(C_::*fn)(Layer &, float)) {
                C_ *my = &c;
                rotate = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetRotate(C_ &c, bool(C_::*fn)(float)) {
                C_ *my = &c;
                rotate = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            template<class C_>
            void SetRotate(C_ *my, bool(C_::*fn)(Layer &, float)) {
                rotate = [fn, my](Layer &layer, Geometry::Point, float amount) { return (my->*fn)(layer, amount); };
            }
 
            template<class C_>
            void SetRotate(C_ *my, bool(C_::*fn)(float)) {
                rotate = [fn, my](Layer &, Geometry::Point, float amount) { return (my->*fn)(amount); };
            }
 
            void ResetRotate() {
                rotate ={};
            }
 
            
            
            void SetOver(std::function<void(Layer &)> fn) {
                over = fn;
            }
            
            void SetOver(std::function<void()> fn) {
                over = [fn](Layer &) { fn(); };
            }
 
            template<class C_>
            void SetOver(C_ &c, void(C_::*fn)(Layer &)) {
                C_ *my = &c;
                over = [fn, my](Layer &layer) { (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetOver(C_ &c, std::function<void(C_ &)> fn) {
                C_ *my = &c;
                over = [fn, my](Layer &) { (my->*fn)(); };
            }
 
            template<class C_>
            void SetOver(C_ *my, void(C_::*fn)(Layer &)) {
                over = [fn, my](Layer &layer) { (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetOver(C_ *my, std::function<void(C_ &)> fn) {
                over = [fn, my](Layer &) { (my->*fn)(); };
            }
            
            void ResetOver() {
                over = {};
            }
 
 
            
            void SetOut(std::function<void(Layer &)> fn) {
                out = fn;
            }
            
            void SetOut(std::function<void()> fn) {
                out = [fn](Layer &) { fn(); };
            }
 
            template<class C_>
            void SetOut(C_ &c, void(C_::*fn)(Layer &)) {
                C_ *my = &c;
                out = [fn, my](Layer &layer) { (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetOut(C_ &c, std::function<void(C_ &)> fn) {
                C_ *my = &c;
                out = [fn, my](Layer &) { (my->*fn)(); };
            }
 
            template<class C_>
            void SetOut(C_ *my, void(C_::*fn)(Layer &)) {
                out = [fn, my](Layer &layer) { (my->*fn)(layer); };
            }
            
            template<class C_>
            void SetOut(C_ *my, std::function<void(C_ &)> fn) {
                out = [fn, my](Layer &) { (my->*fn)(); };
            }
            
            void ResetOut() {
                out = {};
            }
            
            void FireClick(Geometry::Point location, Input::Mouse::Button button) {
                if(click)
                    click(*this, location, button);
            }
            
            
        protected:
            std::function<bool(Layer &, Geometry::Point)> hitcheck;
            std::function<void(Layer &, Geometry::Point, Input::Mouse::Button)> click;
            std::function<void(Layer &, Geometry::Point, Input::Mouse::Button)> down;
            std::function<void(Layer &, Geometry::Point, Input::Mouse::Button)> up;
            std::function<void(Layer &, Geometry::Point)> move;
            std::function<void(Layer &)> over;
            std::function<void(Layer &)> out;
            std::function<bool(Layer &, Geometry::Point, float amount)> vscroll;
            std::function<bool(Layer &, Geometry::Point, float amount)> hscroll;
            std::function<bool(Layer &, Geometry::Point, float amount)> zoom;
            std::function<bool(Layer &, Geometry::Point, float amount)> rotate;
            
            Geometry::Transform3D mytransform;
            
 
            virtual bool propagate_mouseevent(Input::Mouse::EventType event, Geometry::Point location, Input::Mouse::Button button, float amount, MouseHandler &handlers) override;
        };
 
} }