From 344f759dad28c8b3866d7942bd8927ef1caaf6ab Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 18:16:12 -0700
Subject: add per-class args structs

---
 common/rawaccel-userspace.hpp | 44 ++++++++++++++++----------------
 common/rawaccel.hpp           | 58 ++++++++++++++++++++++++++-----------------
 2 files changed, 56 insertions(+), 46 deletions(-)

(limited to 'common')

diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index 82a9e98..3e8886f 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -17,9 +17,7 @@ void error(const char* s) {
 }
 
 mouse_modifier parse(int argc, char** argv) {
-    double degrees = 0;
-    vec2d sens = { 1, 1 };
-    accel_args accel_args{};
+    modifier_args modifier_args{};
 
     auto make_opt_vec = [](vec2d& v, auto first_flag, auto... rest) {
         return clipp::option(first_flag, rest...) & (
@@ -40,64 +38,64 @@ mouse_modifier parse(int argc, char** argv) {
     };
 
     // default options
-    auto opt_sens = "sensitivity (default = 1)" % make_opt_vec(sens, "sens");
+    auto opt_sens = "sensitivity (default = 1)" % make_opt_vec(modifier_args.sens, "sens");
 
     auto opt_rot = "counter-clockwise rotation (default = 0)" % (
         clipp::option("rotate") &
-        clipp::number("degrees", degrees)
+        clipp::number("degrees", modifier_args.degrees)
     );
     
     // mode-independent accel options
     auto opt_weight = "accel multiplier (default = 1)" % 
-        make_opt_vec(accel_args.weight, "weight");
+        make_opt_vec(modifier_args.acc_fn_args.weight, "weight");
 
     auto opt_offset = "speed (dots/ms) where accel kicks in (default = 0)" % (
-        clipp::option("offset") & clipp::number("speed", accel_args.offset)
+        clipp::option("offset") & clipp::number("speed", modifier_args.acc_fn_args.acc_args.offset)
     );
 
     auto opt_cap = "accel scale cap (default = 9)" % 
-        make_opt_vec(accel_args.cap, "cap");
+        make_opt_vec(modifier_args.acc_fn_args.cap, "cap");
 
     auto opt_tmin = "minimum time between polls (default = 0.4)" % (
         clipp::option("tmin") &
-        clipp::number("ms", accel_args.time_min)
+        clipp::number("ms", modifier_args.acc_fn_args.acc_args.time_min)
     );
 
-    auto accel_var = (clipp::required("accel") & clipp::number("num", accel_args.accel)) % "ramp rate";
-    auto limit_var = (clipp::required("limit") & clipp::number("scale", accel_args.lim_exp)) % "limit";
+    auto accel_var = (clipp::required("accel") & clipp::number("num", modifier_args.acc_fn_args.acc_args.accel)) % "ramp rate";
+    auto limit_var = (clipp::required("limit") & clipp::number("scale", modifier_args.acc_fn_args.acc_args.lim_exp)) % "limit";
 
     // modes
     auto noaccel_mode = "no-accel mode" % (
-        clipp::command("off", "noaccel").set(accel_args.accel_mode, accel_implementation_t::id<accel_noaccel>)
+        clipp::command("off", "noaccel").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_noaccel>)
     );
     auto lin_mode = "linear accel mode:" % (
-        clipp::command("linear").set(accel_args.accel_mode, accel_implementation_t::id<accel_linear>),
+        clipp::command("linear").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_linear>),
         accel_var
     );
     auto classic_mode = "classic accel mode:" % (
-        clipp::command("classic").set(accel_args.accel_mode, accel_implementation_t::id<accel_classic>),
+        clipp::command("classic").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_classic>),
         accel_var,
-        (clipp::required("exponent") & clipp::number("num", accel_args.lim_exp)) % "exponent"
+        (clipp::required("exponent") & clipp::number("num", modifier_args.acc_fn_args.acc_args.lim_exp)) % "exponent"
     );
     auto nat_mode = "natural accel mode:" % (
-        clipp::command("natural").set(accel_args.accel_mode, accel_implementation_t::id<accel_natural>),
+        clipp::command("natural").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_natural>),
         accel_var,
         limit_var
     );
     auto log_mode = "logarithmic accel mode:" % (
-        clipp::command("logarithmic").set(accel_args.accel_mode, accel_implementation_t::id<accel_logarithmic>),
+        clipp::command("logarithmic").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_logarithmic>),
         accel_var
     );
     auto sig_mode = "sigmoid accel mode:" % (
-        clipp::command("sigmoid").set(accel_args.accel_mode, accel_implementation_t::id<accel_sigmoid>),
+        clipp::command("sigmoid").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_sigmoid>),
         accel_var,
         limit_var,
-        (clipp::required("midpoint") & clipp::number("speed", accel_args.midpoint)) % "midpoint"
+        (clipp::required("midpoint") & clipp::number("speed", modifier_args.acc_fn_args.acc_args.midpoint)) % "midpoint"
     );
     auto pow_mode = "power accel mode:" % (
-        clipp::command("power").set(accel_args.accel_mode, accel_implementation_t::id<accel_power>) >> [&] { accel_args.accel = 1; },
-        (clipp::required("exponent") & clipp::number("num", accel_args.lim_exp)) % "exponent",
-        (clipp::option("scale") & clipp::number("num", accel_args.accel)) % "scale factor"
+        clipp::command("power").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_power>) >> [&] { modifier_args.acc_fn_args.acc_args.accel = 1; },
+        (clipp::required("exponent") & clipp::number("num", modifier_args.acc_fn_args.acc_args.lim_exp)) % "exponent",
+        (clipp::option("scale") & clipp::number("num", modifier_args.acc_fn_args.acc_args.accel)) % "scale factor"
     );
 
     auto accel_mode_exclusive = (lin_mode | classic_mode | nat_mode | log_mode | sig_mode | pow_mode);
@@ -121,7 +119,7 @@ mouse_modifier parse(int argc, char** argv) {
         std::exit(0);
     }
 
-    return mouse_modifier(-degrees, sens, accel_args);
+    return mouse_modifier(modifier_args);
 }
 
 } // rawaccel
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 08829dd..9cfa5e7 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -9,6 +9,13 @@
 
 namespace rawaccel {
 
+// Error throwing calls std libraries which are unavailable in kernel mode.
+#ifdef _KERNEL_MODE
+    void error(const char*) {}
+#else
+    void error(const char* s);
+#endif
+
     /// <summary> Struct to hold vector rotation details. </summary>
     struct rotator {
 
@@ -66,25 +73,15 @@ namespace rawaccel {
         accel_scale_clamp() = default;
     };
 
-// Error throwing calls std libraries which are unavailable in kernel mode.
-#ifdef _KERNEL_MODE
-    void error(const char*) {}
-#else
-    void error(const char* s);
-#endif
-
     using milliseconds = double;
 
     /// <summary> Struct to hold arguments for an acceleration function. </summary>
     struct accel_args {
-        int accel_mode = 0;
         milliseconds time_min = 0.4;
         double offset = 0;
         double accel = 0;
         double lim_exp = 2;
         double midpoint = 0;
-        vec2d weight = { 1, 1 };
-        vec2d cap = { 0, 0 };
     };
 
     /// <summary>
@@ -255,6 +252,14 @@ namespace rawaccel {
     /// <summary> Tagged union to hold all accel implementations and allow "polymorphism" via a visitor call. </summary>
     using accel_implementation_t = tagged_union<accel_linear, accel_classic, accel_natural, accel_logarithmic, accel_sigmoid, accel_power, accel_noaccel>;
 
+    struct accel_fn_args {
+        accel_args acc_args = accel_args{};
+        int accel_mode = 0;
+        milliseconds time_min = 0.4;
+        vec2d weight = { 1, 1 };
+        vec2d cap = { 0, 0 };
+    };
+
     /// <summary> Struct for holding acceleration application details. </summary>
     struct accel_function {
 
@@ -278,16 +283,16 @@ namespace rawaccel {
         /// <summary> The object which sets a min and max for the acceleration scale. </summary>
         vec2<accel_scale_clamp> clamp;
 
-        accel_function(accel_args args) {
+        accel_function(accel_fn_args args) {
             accel.tag = args.accel_mode;
-            accel.visit([&](auto& a){ a = {args}; });
+            accel.visit([&](auto& a){ a = {args.acc_args}; });
 
             // Verification is performed by the accel_implementation object
             // and therefore must occur after the object has been instantiated
-            verify(args);
+            verify(args.acc_args);
 
             time_min = args.time_min;
-            speed_offset = args.offset;
+            speed_offset = args.acc_args.offset;
             weight = args.weight;
             clamp.x = accel_scale_clamp(args.cap.x);
             clamp.y = accel_scale_clamp(args.cap.y);
@@ -335,6 +340,13 @@ namespace rawaccel {
         accel_function() = default;
     };
 
+    struct modifier_args
+    {
+        double degrees = 0;
+        vec2d sens = { 1, 1 };
+        accel_fn_args acc_fn_args = accel_fn_args{};
+    };
+
     /// <summary> Struct to hold variables and methods for modifying mouse input </summary>
     struct mouse_modifier {
         bool apply_rotate = false;
@@ -343,19 +355,19 @@ namespace rawaccel {
         accel_function accel_fn;
         vec2d sensitivity = { 1, 1 };
 
-        mouse_modifier(double degrees, vec2d sens, accel_args accel_args)
-            : accel_fn(accel_args)
+        mouse_modifier(modifier_args args)
+            : accel_fn(args.acc_fn_args)
         {
-            apply_rotate = degrees != 0;
-            if (apply_rotate) rotate = rotator(degrees);
+            apply_rotate = args.degrees != 0;
+            if (apply_rotate) rotate = rotator(args.degrees);
             else rotate = rotator();
 
-            apply_accel = (accel_args.accel_mode != 0 &&
-						   accel_args.accel_mode != accel_implementation_t::id<accel_noaccel>);
+            apply_accel = (args.acc_fn_args.accel_mode != 0 &&
+						   args.acc_fn_args.accel_mode != accel_implementation_t::id<accel_noaccel>);
 
-            if (sens.x == 0) sens.x = 1;
-            if (sens.y == 0) sens.y = 1;
-            sensitivity = sens;
+            if (args.sens.x == 0) args.sens.x = 1;
+            if (args.sens.y == 0) args.sens.y = 1;
+            sensitivity = args.sens;
         }
 
         /// <summary>
-- 
cgit v1.2.3