Compare commits

...

1704 Commits

Author SHA1 Message Date
Serge
524b84fc38 Detect Battery Saver state 2023-09-18 13:45:12 +02:00
Serge
3bd59a4c4d Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-18 12:04:48 +02:00
Serge
96f07606f5 Version bump 2023-09-18 12:04:43 +02:00
Serge
ea96af51b8 Update README.md 2023-09-18 10:00:08 +02:00
Serge
0669bcb2d1 Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-17 11:49:08 +02:00
Serge
67a42c4a21 Touchpad toggle https://github.com/seerge/g-helper/issues/1313
Miniled status tweak https://github.com/seerge/g-helper/issues/1319
2023-09-17 11:49:05 +02:00
Serge
de98588235 Update README.md 2023-09-14 11:26:56 +02:00
Serge
dffb239ea7 MUX switch for Vivobooks / Zenbooks https://github.com/seerge/g-helper/issues/1301 2023-09-13 13:26:35 +02:00
Serge
6a6c1f1455 Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-12 19:31:53 +02:00
Serge
bd3b2647b4 Fixed exception at Fans+Power https://github.com/seerge/g-helper/issues/1303 2023-09-12 19:31:51 +02:00
Serge
cebc42126a Merge pull request #1296 from seerge/l10n_main
New Crowdin updates
2023-09-12 11:10:03 +02:00
Serge
2985b2f31c New translations Strings.resx (Polish) 2023-09-11 21:48:15 +02:00
Serge
335f5b38a5 Hide Calibrate button on not supported models 2023-09-11 19:40:58 +02:00
Serge
4dd9daa95c Version Bump 2023-09-11 14:34:23 +02:00
Serge
10db075ece Custom command arguments https://github.com/seerge/g-helper/issues/1292 2023-09-11 12:03:52 +02:00
Serge
a800eae020 Pre-entered max fan speeds 2023-09-10 12:31:18 +02:00
Serge
eb21fb2020 Backlight init delay 2023-09-09 17:01:02 +02:00
Serge
600e6a9404 Cleanup 2023-09-09 14:27:43 +02:00
Serge
4b0fbcbf10 Cleanup 2023-09-09 13:52:29 +02:00
Serge
215aec34b9 Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-09 13:07:57 +02:00
Serge
9cba686a3c Fan Calibration 2023-09-09 13:07:55 +02:00
Serge
43a7eb8b32 Merge pull request #1284 from seerge/l10n_main
New Crowdin updates
2023-09-09 12:40:55 +02:00
Serge
08eb867ae7 New translations Strings.resx (Lithuanian) 2023-09-09 10:32:25 +02:00
Serge
5c59c34a6c Merge pull request #1278 from seerge/l10n_main
New Crowdin updates
2023-09-09 00:48:26 +02:00
Serge
ae2dae8a97 New translations Strings.resx (Portuguese, Brazilian) 2023-09-08 23:12:31 +02:00
Serge
c06969ba8f New translations Strings.resx (Vietnamese) 2023-09-08 23:12:31 +02:00
Serge
496d55f88b New translations Strings.resx (Chinese Simplified) 2023-09-08 23:12:30 +02:00
Serge
2b16372ec4 New translations Strings.resx (Ukrainian) 2023-09-08 23:12:29 +02:00
Serge
041aa40a6d New translations Strings.resx (Turkish) 2023-09-08 23:12:28 +02:00
Serge
55c1dd7e16 New translations Strings.resx (Portuguese) 2023-09-08 23:12:27 +02:00
Serge
2ec2f669fb New translations Strings.resx (Polish) 2023-09-08 23:12:26 +02:00
Serge
17ea6157a6 New translations Strings.resx (Lithuanian) 2023-09-08 23:12:25 +02:00
Serge
d5bdf180a8 New translations Strings.resx (Korean) 2023-09-08 23:12:24 +02:00
Serge
a7d5ac5de9 New translations Strings.resx (Italian) 2023-09-08 23:12:24 +02:00
Serge
b103623099 New translations Strings.resx (Hungarian) 2023-09-08 23:12:23 +02:00
Serge
751f4d0331 New translations Strings.resx (German) 2023-09-08 23:12:22 +02:00
Serge
1f536d8d84 New translations Strings.resx (Spanish) 2023-09-08 23:12:21 +02:00
Serge
c900121644 New translations Strings.resx (French) 2023-09-08 23:12:20 +02:00
Serge
9ce038fe19 New translations Strings.resx (Romanian) 2023-09-08 23:12:19 +02:00
Serge
1f66038ab9 Version bump 2023-09-08 22:04:41 +02:00
Serge
04d2eb53a2 Merge pull request #1277 from seerge/Fan-Calibration
Fan calibration
2023-09-08 21:45:41 +02:00
Serge
f55a3c0824 Merge pull request #1276 from seerge/l10n_main
New Crowdin updates
2023-09-08 21:45:18 +02:00
Serge
8f0e4431e6 Label 2023-09-08 21:45:17 +02:00
Serge
bff2676b64 Calibrate in turbo mode 2023-09-08 19:47:12 +02:00
Serge
e9e5fe1cc9 Simplification 2023-09-08 19:37:09 +02:00
Serge
e6a78fc8f7 Fan Calibration 2023-09-08 19:32:37 +02:00
Serge
0e3efcf547 Calibration 2023-09-08 19:12:57 +02:00
Serge
5c5b4f297c New translations Strings.resx (Polish) 2023-09-08 19:03:48 +02:00
Serge
6f1c2ce7c1 Merge pull request #1272 from seerge/l10n_main
New Crowdin updates
2023-09-08 13:24:48 +02:00
Serge
e26feb7025 New translations Strings.resx (Chinese Simplified) 2023-09-08 05:33:49 +02:00
Serge
fef0042870 New translations Strings.resx (Chinese Traditional) 2023-09-08 02:51:36 +02:00
Serge
5a1a303ce7 Merge pull request #1270 from seerge/l10n_main
New Crowdin updates
2023-09-07 17:36:23 +02:00
Serge
5849dc0ce9 New translations Strings.resx (Portuguese, Brazilian) 2023-09-07 17:30:25 +02:00
Serge
31ca13692b New translations Strings.resx (Vietnamese) 2023-09-07 17:30:23 +02:00
Serge
49cfbc6235 New translations Strings.resx (Chinese Traditional) 2023-09-07 17:30:22 +02:00
Serge
b577e5ed90 New translations Strings.resx (Chinese Simplified) 2023-09-07 17:30:21 +02:00
Serge
3c9dca0c62 New translations Strings.resx (Ukrainian) 2023-09-07 17:30:20 +02:00
Serge
818b87fe87 New translations Strings.resx (Turkish) 2023-09-07 17:30:19 +02:00
Serge
e177207799 New translations Strings.resx (Portuguese) 2023-09-07 17:30:18 +02:00
Serge
df4cf40a5b New translations Strings.resx (Lithuanian) 2023-09-07 17:30:17 +02:00
Serge
23082d59ba New translations Strings.resx (Korean) 2023-09-07 17:30:16 +02:00
Serge
708170b1ef New translations Strings.resx (Italian) 2023-09-07 17:30:15 +02:00
Serge
3a0131a577 New translations Strings.resx (Hungarian) 2023-09-07 17:30:14 +02:00
Serge
d1f4da5473 New translations Strings.resx (German) 2023-09-07 17:30:13 +02:00
Serge
91967638af New translations Strings.resx (Spanish) 2023-09-07 17:30:12 +02:00
Serge
d9a972f6a9 New translations Strings.resx (French) 2023-09-07 17:30:11 +02:00
Serge
ce4c9bb48c New translations Strings.resx (Romanian) 2023-09-07 17:30:10 +02:00
Serge
26c74fa1df New translations Strings.resx (Polish) 2023-09-07 17:30:09 +02:00
Serge
4ae3fb4e3d Boot Sound 2023-09-07 17:29:35 +02:00
Serge
20e7dd96a1 Cleanup 2023-09-07 17:07:34 +02:00
Serge
d36cd409a4 XGM Config Flag 2023-09-07 15:37:09 +02:00
Serge
082eceed9a Update checker 2023-09-07 13:44:31 +02:00
Serge
46c91d1956 Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-07 10:06:58 +02:00
Serge
edfb829988 XGM activation https://github.com/seerge/g-helper/issues/729 2023-09-07 10:06:56 +02:00
Serge
83cb28e99c Update README.md 2023-09-06 22:11:38 +02:00
Serge
957916bfdf XGM Special Activation 2023-09-06 21:51:09 +02:00
Serge
2f98606a7d XG Mobile tweaks 2023-09-06 19:58:14 +02:00
Serge
c791421c3e Merge pull request #1264 from seerge/G14-2021-Matrix
Anime Matrix tweaks
2023-09-06 19:04:55 +02:00
Serge
fa79a72247 Anime Matrix tweaks 2023-09-06 19:03:27 +02:00
Serge
831f7b8989 Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-06 16:01:20 +02:00
Serge
77800475cb Matrix Clock 2023-09-06 16:01:18 +02:00
Serge
96553a162c Merge pull request #1262 from seerge/l10n_main
New Crowdin updates
2023-09-06 13:56:27 +02:00
Serge
d1e987f4da New translations Strings.resx (Polish) 2023-09-06 13:54:28 +02:00
Serge
a1fb740c27 TUF Backlight for new models https://github.com/seerge/g-helper/issues/1250 2023-09-06 13:50:48 +02:00
Serge
cff47002e1 Matrix memory optimisations 2023-09-05 23:51:14 +02:00
Serge
c34ba9c620 Cleanup 2023-09-05 23:31:18 +02:00
Serge
3da2d042c8 Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-05 21:39:00 +02:00
Serge
b93499c20d Anime Matrix Editor 2023-09-05 21:38:58 +02:00
Serge
feb7f1915e Update README.md 2023-09-04 22:37:53 +02:00
Serge
bd7f494830 Merge pull request #1247 from seerge/l10n_main
New Crowdin updates
2023-09-03 19:07:33 +02:00
Serge
1fc5095a65 New translations Strings.resx (Chinese Traditional) 2023-09-03 19:07:10 +02:00
Serge
920ed5e176 Update README.md 2023-09-03 18:33:26 +02:00
Serge
fce9cddd02 XGM for devices without dGPU https://github.com/seerge/g-helper/issues/1235 2023-09-03 15:53:43 +02:00
Serge
3332bd4b36 Merge branch 'main' of https://github.com/seerge/g-helper 2023-09-03 14:14:55 +02:00
Serge
56289abc36 Allow XGM connection from any dGPU mode for models w/o dGPU https://github.com/seerge/g-helper/issues/1235
Hide Backlight OSD if asus OSD is running
2023-09-03 14:14:54 +02:00
Serge
9be02a102d Merge pull request #1240 from seerge/l10n_main
New Crowdin updates
2023-09-02 17:52:56 +02:00
Serge
e1e94e1118 New translations Strings.resx (Portuguese) 2023-09-02 15:26:19 +02:00
Serge
2ffd08e754 Merge pull request #1236 from IceStormNG/asus-mouse-support
Pugio II (P705) Support
2023-09-02 00:56:42 +02:00
IceStormNG
0378b65763 Added Pugio II (P705) Mouse configuration 2023-09-02 00:54:16 +02:00
IceStormNG
5dd3760e90 Fixed mapping of animation speed values in the UI (how was that bug not found yet?) 2023-09-02 00:53:33 +02:00
IceStormNG
e7eb7fab8a Make low battery warning values configureable per mouse 2023-09-02 00:53:00 +02:00
IceStormNG
ce128adc4f Only open one Mouse settings window and also make it the topmost window. 2023-09-02 00:52:15 +02:00
Serge
a794f8ed5f Single color backlight for keyboard version 22/23 https://github.com/seerge/g-helper/issues/1230 2023-08-31 23:33:44 +02:00
Serge
9d30f2f83e Version bump 2023-08-31 12:09:27 +02:00
Serge
b93f1a385b Arrow lock for DUO https://github.com/seerge/g-helper/issues/1224 2023-08-30 23:49:32 +02:00
Serge
6bb4ba4119 Screenpad hotkey for DUO https://github.com/seerge/g-helper/issues/1215 2023-08-30 14:41:20 +02:00
Serge
178cb04002 Turn off display fix https://github.com/seerge/g-helper/issues/1218
Zephyrus DUO Screenpad hotkey https://github.com/seerge/g-helper/issues/1215
2023-08-30 12:45:07 +02:00
Serge
2d41cd62a8 Clasmshell tooltip https://github.com/seerge/g-helper/issues/1207 2023-08-29 11:48:59 +02:00
Serge
f9e4e89c15 Vivobook backlight control https://github.com/seerge/g-helper/issues/1208 2023-08-29 00:00:55 +02:00
Serge
02717c47be Fan ranges for ancient devices https://github.com/seerge/g-helper/issues/1206 2023-08-28 19:11:32 +02:00
Serge
cc010053b2 Minor tweaks 2023-08-27 13:05:10 +02:00
Serge
9bcc0fccd7 Update README.md 2023-08-24 18:09:20 +02:00
Serge
d8df9b03bf Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-24 15:07:54 +02:00
Serge
abfa2388e4 Cleanup 2023-08-24 15:07:52 +02:00
Serge
670f91efa8 Merge pull request #1170 from Oleg52/force-set-gpu-mode
add force set gpu param
2023-08-24 15:03:15 +02:00
Serge
70d442c409 Merge pull request #1171 from seerge/l10n_main
New Crowdin updates
2023-08-24 15:00:39 +02:00
Serge
5f018fa7b5 New translations Strings.resx (Portuguese) 2023-08-24 14:45:40 +02:00
Oleg Yermolenko
94f0b900de add force set gpu param 2023-08-24 14:06:52 +03:00
Serge
e17ff8fc94 Version Bump 2023-08-24 12:37:18 +02:00
Serge
bd4ee506ac Vivo Mode swap https://github.com/seerge/g-helper/issues/1168 2023-08-24 12:03:44 +02:00
Serge
8c5b224dc2 Vivobook modes swap https://github.com/seerge/g-helper/issues/1168 2023-08-24 12:01:26 +02:00
Serge
f111b5449e Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-24 11:54:11 +02:00
Serge
47f86d222f Minior tweaks 2023-08-24 11:54:09 +02:00
Serge
f9b7073dd7 Merge pull request #1166 from seerge/l10n_main
New Crowdin updates
2023-08-23 19:11:30 +02:00
Serge
a6c11f2ce3 New translations Strings.resx (Portuguese) 2023-08-23 14:01:14 +02:00
Serge
46fad77bac Update README.md 2023-08-23 12:31:14 +02:00
Serge
22a96fcce0 Update README.md 2023-08-23 12:29:37 +02:00
Serge
6df0dc8e9e Merge pull request #1155 from seerge/l10n_main
New Crowdin updates
2023-08-22 18:46:43 +02:00
Serge
ee7c0c6dab New translations Strings.resx (Portuguese) 2023-08-22 15:16:03 +02:00
Serge
6e086da024 New translations Strings.resx (Portuguese) 2023-08-22 14:12:34 +02:00
Serge
292d2a8ebc New translations Strings.resx (Portuguese) 2023-08-22 12:50:32 +02:00
Serge
52e78a8665 Merge pull request #1150 from seerge/l10n_main
New Crowdin updates
2023-08-22 10:49:58 +02:00
Serge
a97bfc2a58 Version bump 2023-08-22 10:39:34 +02:00
Serge
15001d987a Fix Default Curve 2023-08-22 10:37:31 +02:00
Serge
ecbeee82d8 Merge pull request #1153 from charlespeng/fix-default-fan-curve-buffer-size
Fix default fan curve buffer size
2023-08-22 10:28:04 +02:00
Charles Peng
e6c59283c1 Fix default fan curve buffer size 2023-08-22 15:08:30 +08:00
Serge
495b695589 New translations Strings.resx (Polish) 2023-08-22 01:31:34 +02:00
Serge
6ac7d7cc4d New translations Strings.resx (Portuguese) 2023-08-21 23:56:19 +02:00
Serge
0c328b1fda Update README.md 2023-08-21 18:35:01 +02:00
Serge
bd8a670424 Merge pull request #1146 from charlespeng/save-backlight-level-according-to-power-status
Save backlight level according to power status
2023-08-21 12:13:36 +02:00
Charles Peng
5f1139f132 Save backlight level according to power status 2023-08-21 16:04:05 +08:00
Serge
188b01c158 Merge pull request #1142 from seerge/l10n_main
New Crowdin updates
2023-08-21 00:59:32 +02:00
Serge
8307fabe15 New translations Strings.resx (Portuguese) 2023-08-20 19:25:59 +02:00
Serge
cead02eed2 Merge pull request #1141 from seerge/l10n_main
New Crowdin updates
2023-08-20 17:26:42 +02:00
Serge
fabf63655b New translations Strings.resx (Portuguese, Brazilian) 2023-08-20 17:26:04 +02:00
Serge
da2f887c68 New translations Strings.resx (Portuguese, Brazilian) 2023-08-20 17:24:25 +02:00
Serge
26dbd77b05 PT-BR 2023-08-20 17:24:02 +02:00
Serge
63382b748f Merge pull request #1140 from seerge/l10n_main
New Crowdin updates
2023-08-20 17:21:53 +02:00
Serge
1e2a5b0479 New translations Strings.resx (Portuguese, Brazilian) 2023-08-20 17:21:18 +02:00
Serge
341e747f7e New translations Strings.resx (Portuguese) 2023-08-20 17:21:15 +02:00
Serge
348f5a8ea1 Merge pull request #1139 from seerge/l10n_main
New Crowdin updates
2023-08-20 17:17:03 +02:00
Serge
c0b6c444b4 New translations Strings.resx (Portuguese, Brazilian) 2023-08-20 17:16:34 +02:00
Serge
f8d07bad1b New translations Strings.resx (Portuguese) 2023-08-20 17:16:30 +02:00
Serge
a138ebe0e7 New translations Strings.resx (French) 2023-08-20 16:42:09 +02:00
Serge
2260b01480 Merge pull request #1137 from IceStormNG/asus-mouse-support
Support for ROG Harpe Ace Aim Lab Edition (P713).
2023-08-20 15:13:25 +02:00
IceStormNG
9761f10398 Support for Harpe Ace Aim Lab Edition (P713). 2023-08-20 15:08:11 +02:00
Serge
984cb2f53e GPU detection https://github.com/seerge/g-helper/issues/1112 2023-08-19 12:51:33 +02:00
Serge
7c80a02cef Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-19 12:40:32 +02:00
Serge
f545d48179 GPU detection https://github.com/seerge/g-helper/issues/1114
Resetting custom fan curve on XGM on disconnect https://github.com/seerge/g-helper/issues/1123
2023-08-19 12:40:30 +02:00
Serge
07df99aaae Merge pull request #1126 from seerge/l10n_main
New Crowdin updates
2023-08-19 10:31:34 +02:00
Serge
6f60e1af1f Merge pull request #1129 from IceStormNG/main
Added windows based dark mode detection via config override
2023-08-19 10:14:45 +02:00
Serge
e0080ca879 New translations Strings.resx (Italian) 2023-08-19 09:33:58 +02:00
IceStormNG
eaf2483558 Added windows based dark mode detection via config override 2023-08-19 09:06:54 +02:00
Serge
8cac276925 New translations Strings.resx (Vietnamese) 2023-08-19 05:38:10 +02:00
Serge
499c83e3b0 New translations Strings.resx (Vietnamese) 2023-08-19 04:07:58 +02:00
Serge
ba0764aa85 New translations Strings.resx (Spanish) 2023-08-18 20:11:36 +02:00
Serge
53c1ee4c71 New translations Strings.resx (Lithuanian) 2023-08-18 18:51:34 +02:00
Serge
fe1891a2a9 New translations Strings.resx (German) 2023-08-18 18:51:33 +02:00
Serge
0ffb9f11d4 Merge pull request #1122 from seerge/l10n_main
New Crowdin updates
2023-08-18 18:49:52 +02:00
Serge
307cc81f18 Merge pull request #1125 from IceStormNG/main
Dark/Light Mode override
2023-08-18 18:48:44 +02:00
IceStormNG
2384649e09 Better handling for null values. 2023-08-18 18:37:58 +02:00
IceStormNG
4952675749 Light/Dark mode override 2023-08-18 18:36:34 +02:00
Serge
e2596ed9cb Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-18 18:15:14 +02:00
Serge
190786a15a Internal screen detection 2023-08-18 18:15:12 +02:00
Serge
9bcf3f36f8 New translations Strings.resx (Vietnamese) 2023-08-18 16:34:05 +02:00
Serge
26e1ae4d7b New translations Strings.resx (Chinese Traditional) 2023-08-18 16:34:04 +02:00
Serge
98af882970 New translations Strings.resx (Chinese Simplified) 2023-08-18 16:34:03 +02:00
Serge
5835e71947 New translations Strings.resx (Ukrainian) 2023-08-18 16:34:02 +02:00
Serge
f46580bd1b New translations Strings.resx (Turkish) 2023-08-18 16:34:01 +02:00
Serge
a282da6fd7 New translations Strings.resx (Portuguese) 2023-08-18 16:34:00 +02:00
Serge
1420d17413 New translations Strings.resx (Polish) 2023-08-18 16:33:59 +02:00
Serge
b7b6270565 New translations Strings.resx (Lithuanian) 2023-08-18 16:33:58 +02:00
Serge
49eb45749a New translations Strings.resx (Korean) 2023-08-18 16:33:57 +02:00
Serge
ec709f37e8 New translations Strings.resx (Italian) 2023-08-18 16:33:56 +02:00
Serge
615c58ac3c New translations Strings.resx (Hungarian) 2023-08-18 16:33:55 +02:00
Serge
20d698febd New translations Strings.resx (German) 2023-08-18 16:33:54 +02:00
Serge
3bb6bf3228 New translations Strings.resx (Spanish) 2023-08-18 16:33:53 +02:00
Serge
9674f034dd New translations Strings.resx (French) 2023-08-18 16:33:51 +02:00
Serge
f11ed679d9 New translations Strings.resx (Romanian) 2023-08-18 16:33:51 +02:00
Serge
2bb5087a63 Merge pull request #1120 from IceStormNG/asus-mouse-support
Internal improvements for mouse support
2023-08-18 15:20:11 +02:00
IceStormNG
e4aa5f0283 Cleanup of left-overs that shouldn't be there 2023-08-18 15:17:03 +02:00
IceStormNG
18b664a123 Default Profile is 0, so use that if decoding fails to have a sane fallback. 2023-08-18 15:09:12 +02:00
IceStormNG
1d03eb064a Allow subclasses to read whether packet logger is enabled or not 2023-08-18 15:08:40 +02:00
IceStormNG
0ad058ec4a Added feature to read and edit Acceleration and Deceleration values. It seems like only the Harpe Ace really does something with it even though all AimPoint Mice respond to it and store the value. 2023-08-18 15:08:08 +02:00
IceStormNG
18b54886ed Improved packet handling to deal better with empty packets and errors. 2023-08-18 15:05:55 +02:00
IceStormNG
f79a91fb78 Make reportId a constructor variable as some mice might not require 0x00 as most do. 2023-08-18 15:04:49 +02:00
Serge
584755ea93 Cleanup 2023-08-18 12:29:21 +02:00
Serge
3652e4d0ff 50W limit max for Ally 2023-08-18 12:16:19 +02:00
Serge
0069234563 Version bump 2023-08-18 01:23:02 +02:00
Serge
d92a1880ee Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-17 20:28:51 +02:00
Serge
dd72e2b573 Screen detection fix 2023-08-17 20:28:48 +02:00
Serge
10714d1002 Update README.md 2023-08-17 19:58:22 +02:00
Serge
daad1bca53 Merge pull request #1109 from IceStormNG/asus-mouse-support
Support for ROG Keris Wireless Aimpoint (P709_Wireless)
2023-08-17 14:29:17 +02:00
IceStormNG
c82ec8a005 Adds ROG Keris Wireless Aimpoint (P709_Wireless) 2023-08-17 14:25:31 +02:00
IceStormNG
9fbea0a3d3 Fixes crash when DPI was not read yet. 2023-08-17 14:23:55 +02:00
Serge
ed06247206 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-17 10:52:10 +02:00
Serge
1e7bd816f2 Config overrides https://github.com/seerge/g-helper/issues/1105 2023-08-17 10:52:09 +02:00
Serge
592c4aa07a Update README.md 2023-08-16 14:57:06 +02:00
Serge
59f3aa9af4 Merge pull request #1096 from IceStormNG/main
AniMeMatrix fix for GU604
2023-08-15 23:52:43 +02:00
IceStormNG
8df825e250 AniMeMatrix fix for GU604 2023-08-15 23:27:14 +02:00
Serge
a985cc5bbb Darktheme fix https://github.com/seerge/g-helper/issues/1092
ACPI modes support for Vivobook https://github.com/seerge/g-helper/issues/1089
2023-08-15 13:59:07 +02:00
Serge
bd7985e817 Merge pull request #1093 from seerge/l10n_main
New Crowdin updates
2023-08-15 13:57:22 +02:00
Serge
8706f9f03c New translations Strings.resx (Ukrainian) 2023-08-15 12:53:23 +02:00
Serge
5c6a587745 App dark/light theme detection https://github.com/seerge/g-helper/issues/1092 2023-08-15 12:00:08 +02:00
Serge
de4905f84f Power mode saving https://github.com/seerge/g-helper/issues/1091 2023-08-15 11:21:20 +02:00
Serge
121a9224e9 Power mode saving 2023-08-15 11:19:10 +02:00
Serge
af9626e385 Version bump 2023-08-14 17:32:15 +02:00
Serge
6b3db926fc GPU Aura Mode 2023-08-14 17:19:22 +02:00
Serge
8f8be7a13e Single Color Modes 2023-08-14 16:55:25 +02:00
Serge
12450dbba4 Merge pull request #1084 from seerge/gpu_clock_limit
Gpu clock limit
2023-08-14 16:51:45 +02:00
Serge
4f6de3c6a3 GPU Mode Backlight 2023-08-14 16:48:16 +02:00
Serge
d89420e0f1 Merge pull request #1074 from seerge/l10n_main
New Crowdin updates
2023-08-14 12:06:32 +02:00
Serge
ddc13e0dec New translations Strings.resx (Korean) 2023-08-14 10:07:50 +02:00
Serge
61a3d782e8 New translations Strings.resx (Korean) 2023-08-14 08:37:33 +02:00
Serge
b1c8aa97c8 New translations Strings.resx (Korean) 2023-08-14 07:06:19 +02:00
Serge
3a50ee1784 New translations Strings.resx (Korean) 2023-08-14 05:31:39 +02:00
Serge
a69ce3592f New translations Strings.resx (Polish) 2023-08-13 18:48:23 +02:00
Serge
b49ae96dfe New translations Strings.resx (Polish) 2023-08-13 17:48:00 +02:00
Serge
4c989c9d75 Clock Limit tweaks 2023-08-13 15:48:54 +02:00
Serge
2282e56aad GPU Clock Limiting 2023-08-13 12:53:28 +02:00
Serge
982f2e8e32 Merge pull request #1069 from seerge/l10n_main
New Crowdin updates
2023-08-13 12:14:23 +02:00
Serge
e90f19e3e2 New translations Strings.resx (Chinese Simplified) 2023-08-13 05:08:45 +02:00
Serge
6d6a9c68f2 Merge pull request #1063 from seerge/l10n_main
New Crowdin updates
2023-08-12 17:49:57 +02:00
Serge
8138e44cdd New translations Strings.resx (Chinese Traditional) 2023-08-12 17:16:01 +02:00
Serge
ef788798b7 Version Bump 2023-08-12 16:27:51 +02:00
Serge
07d81e6072 Merge pull request #1062 from seerge/power_modes
Power Mode control
2023-08-12 16:23:24 +02:00
Serge
708e3aa40f Update README.md 2023-08-12 16:22:48 +02:00
Serge
3075e22e1e Power Mode control 2023-08-12 16:04:39 +02:00
Serge
b15109d13e Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-11 22:37:17 +02:00
Serge
c491087a29 Set Balanced plan by default 2023-08-11 22:37:14 +02:00
Serge
cf08ae0789 Update README.md 2023-08-11 22:20:25 +02:00
Serge
624f15be65 Merge pull request #1053 from seerge/l10n_main
New Crowdin updates
2023-08-11 21:58:50 +02:00
Serge
4789d0d782 New translations Strings.resx (Spanish) 2023-08-11 17:36:43 +02:00
Serge
f8fd8a9695 New translations Strings.resx (Italian) 2023-08-11 17:36:42 +02:00
Serge
91cfb8d38c New translations Strings.resx (Lithuanian) 2023-08-11 17:36:41 +02:00
Serge
130d9b73fb Cleanup 2023-08-11 16:01:30 +02:00
Serge
604d24ebbe Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-11 14:27:40 +02:00
Serge
8c3a74a991 FN-Lock Toggle 2023-08-11 14:27:38 +02:00
Serge
ed143a7bba Merge pull request #1048 from seerge/l10n_main
New Crowdin updates
2023-08-11 14:24:29 +02:00
Serge
ac5f1ec1b5 New translations Strings.resx (Vietnamese) 2023-08-11 13:04:07 +02:00
Serge
403db3057c New translations Strings.resx (Ukrainian) 2023-08-11 13:04:06 +02:00
Serge
4dac7b8e9d New translations Strings.resx (Turkish) 2023-08-11 13:04:06 +02:00
Serge
a856f87146 New translations Strings.resx (Portuguese) 2023-08-11 13:04:05 +02:00
Serge
d733101a26 New translations Strings.resx (Polish) 2023-08-11 13:04:04 +02:00
Serge
89741a5e8a New translations Strings.resx (Korean) 2023-08-11 13:04:03 +02:00
Serge
f00026b53a New translations Strings.resx (Hungarian) 2023-08-11 13:04:02 +02:00
Serge
5004358fe2 New translations Strings.resx (German) 2023-08-11 13:04:01 +02:00
Serge
97f6565024 New translations Strings.resx (Spanish) 2023-08-11 13:04:00 +02:00
Serge
f1a69ebad3 New translations Strings.resx (French) 2023-08-11 13:03:59 +02:00
Serge
bf6c3e636e New translations Strings.resx (Romanian) 2023-08-11 13:03:58 +02:00
Serge
a4e98a9fb1 New translations Strings.resx (Italian) 2023-08-11 13:03:57 +02:00
Serge
8b717f856a New translations Strings.resx (Lithuanian) 2023-08-11 13:03:56 +02:00
Serge
4d8f093a4b New translations Strings.resx (Chinese Traditional) 2023-08-11 13:03:55 +02:00
Serge
c699c82bbe New translations Strings.resx (Chinese Simplified) 2023-08-11 13:03:54 +02:00
Serge
5634d75672 Single Color 2023-08-11 12:58:20 +02:00
Serge
cf33b0cc52 Single Color detection 2023-08-11 12:51:03 +02:00
Serge
ddbaeb623b New translations Strings.resx (Lithuanian) 2023-08-11 07:47:01 +02:00
Serge
3efb2e0db9 Version Bump 2023-08-11 00:02:40 +02:00
Serge
8159aec53b New translations Strings.resx (Vietnamese) 2023-08-10 23:57:14 +02:00
Serge
564efb2f32 New translations Strings.resx (Ukrainian) 2023-08-10 23:57:14 +02:00
Serge
4dfcd6a5f9 New translations Strings.resx (Turkish) 2023-08-10 23:57:13 +02:00
Serge
0aa4d873d0 New translations Strings.resx (Portuguese) 2023-08-10 23:57:12 +02:00
Serge
911c01b6b2 New translations Strings.resx (Polish) 2023-08-10 23:57:11 +02:00
Serge
3a5e5fa227 New translations Strings.resx (Korean) 2023-08-10 23:57:10 +02:00
Serge
bf5786aca6 New translations Strings.resx (Hungarian) 2023-08-10 23:57:10 +02:00
Serge
ed065d00dc New translations Strings.resx (German) 2023-08-10 23:57:09 +02:00
Serge
6aa899d989 New translations Strings.resx (Spanish) 2023-08-10 23:57:08 +02:00
Serge
417d156300 New translations Strings.resx (French) 2023-08-10 23:57:07 +02:00
Serge
2471edd82f New translations Strings.resx (Romanian) 2023-08-10 23:57:06 +02:00
Serge
196eda7463 New translations Strings.resx (Italian) 2023-08-10 23:57:05 +02:00
Serge
1d63376c99 New translations Strings.resx (Lithuanian) 2023-08-10 23:57:05 +02:00
Serge
846b05b89e New translations Strings.resx (Chinese Traditional) 2023-08-10 23:57:04 +02:00
Serge
0f3b660824 New translations Strings.resx (Chinese Simplified) 2023-08-10 23:57:03 +02:00
Serge
14565cf8fa Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-10 23:39:48 +02:00
Serge
3d5c0d5ade GPU tweaks 2023-08-10 23:39:45 +02:00
Serge
14e0adaca8 Merge pull request #1044 from seerge/l10n_main
New Crowdin updates
2023-08-10 22:46:36 +02:00
Serge
4365d3b4cb New translations Strings.resx (Italian) 2023-08-10 17:21:13 +02:00
Serge
62ca72e684 New translations Strings.resx (Italian) 2023-08-10 15:32:06 +02:00
Serge
71c0c10f29 New translations Strings.resx (Lithuanian) 2023-08-10 09:44:15 +02:00
Serge
8733ef34d3 New translations Strings.resx (Chinese Traditional) 2023-08-10 05:07:14 +02:00
Serge
ff0a12d104 New translations Strings.resx (Chinese Simplified) 2023-08-10 04:10:42 +02:00
Serge
fe628319b7 Update README.md 2023-08-09 23:37:52 +02:00
Serge
86c11beee6 Update README.md 2023-08-09 23:30:23 +02:00
Serge
e45a72f6c6 Update README.md 2023-08-09 23:28:51 +02:00
Serge
88af725a08 Merge pull request #1039 from seerge/l10n_main
New Crowdin updates
2023-08-09 19:19:31 +02:00
Serge
d3fee87802 Update README.md 2023-08-09 18:49:21 +02:00
Serge
ea61e428da Eco mode GPU fix 2023-08-09 18:43:19 +02:00
Serge
7d5bd42f53 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-09 18:02:40 +02:00
Serge
78c689eb08 Increased GPU restart delay 2023-08-09 18:02:32 +02:00
Serge
69c2f6ff6e Update README.md 2023-08-09 17:56:36 +02:00
Serge
b59db1432a New translations Strings.resx (Vietnamese) 2023-08-09 15:43:05 +02:00
Serge
4f85cd32aa New translations Strings.resx (Chinese Traditional) 2023-08-09 15:43:04 +02:00
Serge
f0d6d25e93 New translations Strings.resx (Chinese Simplified) 2023-08-09 15:43:03 +02:00
Serge
2d6d4093e9 New translations Strings.resx (Ukrainian) 2023-08-09 15:43:03 +02:00
Serge
8fc167fd57 New translations Strings.resx (Turkish) 2023-08-09 15:43:02 +02:00
Serge
475110af09 New translations Strings.resx (Portuguese) 2023-08-09 15:43:01 +02:00
Serge
3fc4621dc9 New translations Strings.resx (Polish) 2023-08-09 15:43:00 +02:00
Serge
43ddf6585c New translations Strings.resx (Lithuanian) 2023-08-09 15:42:59 +02:00
Serge
61d155d936 New translations Strings.resx (Korean) 2023-08-09 15:42:58 +02:00
Serge
d133162579 New translations Strings.resx (Italian) 2023-08-09 15:42:57 +02:00
Serge
fff4612a8d New translations Strings.resx (Hungarian) 2023-08-09 15:42:55 +02:00
Serge
d6f410c6e6 New translations Strings.resx (German) 2023-08-09 15:42:54 +02:00
Serge
ab11965d50 New translations Strings.resx (Spanish) 2023-08-09 15:42:53 +02:00
Serge
6071f41c33 New translations Strings.resx (French) 2023-08-09 15:42:52 +02:00
Serge
e220ad73b3 Hibernate After control 2023-08-09 14:11:04 +02:00
Serge
f7b9efc3cb Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-09 11:37:24 +02:00
Serge
e19f815498 Re-init anime matrix on wake up https://github.com/seerge/g-helper/issues/1038 2023-08-09 11:37:22 +02:00
Serge
cf95bb1faa Merge pull request #1019 from MrChenYukun/main
Update README.zh-CN.md
2023-08-09 10:32:00 +02:00
Serge
c9b7e4b2af Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-08 17:16:01 +02:00
Serge
1827450f4b Restored RGB for GA503RM https://github.com/seerge/g-helper/discussions/1033, limited max power slider for X13 https://github.com/seerge/g-helper/issues/1029 2023-08-08 17:15:57 +02:00
Serge
a990770ce1 Merge pull request #1025 from seerge/l10n_main
New Crowdin updates
2023-08-08 13:35:44 +02:00
Serge
8bf20a9ed1 New translations Strings.resx (Polish) 2023-08-08 12:12:59 +02:00
Serge
48674dcf90 Accessible controls 2023-08-08 01:03:06 +02:00
Serge
4be50d68da Merge pull request #1016 from seerge/l10n_main
New Crowdin updates
2023-08-07 17:10:22 +02:00
chenyukun1
0c6d31950e unify symbols 2023-08-07 18:44:54 +08:00
chenyukun1
80e8c8fcc2 add FAQ section translation to README.zh-CN.md 2023-08-07 18:39:00 +08:00
Serge
0c7621b798 New translations Strings.resx (Spanish) 2023-08-06 19:53:42 +02:00
Serge
3efe8fb67e Micmute from external keyboards 2023-08-06 18:57:19 +02:00
Serge
5c613af9f2 Cleanup 2023-08-06 16:48:25 +02:00
Serge
e33c13bd19 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-06 14:49:19 +02:00
Serge
d764a20dc7 TUF brightness fix https://github.com/seerge/g-helper/issues/990 2023-08-06 14:49:17 +02:00
Serge
39a61b5118 Update README.md 2023-08-05 21:51:14 +02:00
Serge
f93594c4ae Universal brightness fix 2023-08-05 21:46:46 +02:00
Serge
3700e4469d Universal brightness fix 2023-08-05 21:26:07 +02:00
Serge
60a154851f Update README.md 2023-08-05 21:21:32 +02:00
Serge
8c621fe6d5 Update README.md 2023-08-05 21:20:23 +02:00
Serge
d01fe2e4b0 Update README.md 2023-08-05 19:05:49 +02:00
Serge
08382a6ec5 Update README.md 2023-08-05 17:06:02 +02:00
Serge
6746916425 Add files via upload 2023-08-05 17:04:21 +02:00
Serge
934ed919e4 Update README.md 2023-08-05 17:02:30 +02:00
Serge
53b0dc343c Update README.md 2023-08-05 16:45:36 +02:00
Serge
c04f26ae00 Update README.md 2023-08-05 16:34:34 +02:00
Serge
3b5587d2e1 Update README.md 2023-08-05 16:29:41 +02:00
Serge
cc48e04530 Merge pull request #1010 from Rakaveli/main
Support for rog keris eva edition mouse
2023-08-05 15:53:02 +02:00
Rakaveli
29f0de9cba wrong wireless flag fixed 2023-08-05 18:11:18 +05:00
Rakaveli
f9a7bd0fe0 Added support for rog keris eva edition mouse 2023-08-05 17:58:22 +05:00
Serge
1c25824bcf Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-05 13:17:52 +02:00
Serge
0fec4c9620 Optimized USB-C fix 2023-08-05 13:17:50 +02:00
Serge
2206411bea Merge pull request #1006 from seerge/l10n_main
New Crowdin updates
2023-08-05 12:43:36 +02:00
Serge
62efe79b7a New translations Strings.resx (Lithuanian) 2023-08-05 10:47:04 +02:00
Serge
327cf0e9dd New translations Strings.resx (Chinese Traditional) 2023-08-05 03:25:59 +02:00
Serge
fa3d9d1f81 - 2023-08-04 22:20:33 +02:00
Serge
cb0996eca9 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-04 22:05:41 +02:00
Serge
3a5dbbf2ea Bindings 2023-08-04 22:05:39 +02:00
Serge
1062aba6a4 Merge pull request #1001 from seerge/l10n_main
New Crowdin updates
2023-08-04 22:03:13 +02:00
Serge
849faa5029 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-04 21:59:04 +02:00
Serge
f242e74d07 Empty Default actions for CC / Padles on Ally 2023-08-04 21:59:02 +02:00
Serge
98a0c21355 Bindings fixes 2023-08-04 21:36:44 +02:00
Serge
7e2206d20c New translations Strings.resx (Ukrainian) 2023-08-04 18:27:11 +02:00
Serge
5f05672a3f New translations Strings.resx (Lithuanian) 2023-08-04 18:27:10 +02:00
Serge
ea812ae645 Update README.md 2023-08-04 15:59:26 +02:00
Serge
83eed09f48 Update README.md 2023-08-04 15:40:19 +02:00
Serge
d834264ef2 Merge pull request #992 from seerge/l10n_main
New Crowdin updates
2023-08-04 11:17:42 +02:00
Serge
df0ff6c284 New translations Strings.resx (Chinese Simplified) 2023-08-04 05:26:30 +02:00
Serge
bab796bae1 New translations Strings.resx (German) 2023-08-03 22:31:21 +02:00
Serge
2097a42973 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-03 21:32:05 +02:00
Serge
458527ce2b Version Bump 2023-08-03 21:32:03 +02:00
Serge
c93f2277cf Universal brightness control 2023-08-03 21:28:05 +02:00
Serge
013bedcf9a Update README.md 2023-08-03 19:39:40 +02:00
Serge
39731fc2e8 Update README.md 2023-08-03 19:37:01 +02:00
Serge
2c1877a321 Update README.md 2023-08-03 19:34:47 +02:00
Serge
31ebbc3d18 Charge label fix 2023-08-03 19:07:30 +02:00
Serge
1447b10992 Merge pull request #985 from seerge/l10n_main
New Crowdin updates
2023-08-03 18:57:57 +02:00
Serge
ffaf3b4ab8 New translations Strings.resx (Polish) 2023-08-03 17:59:14 +02:00
Serge
7ca0dc4a85 New translations Strings.resx (Vietnamese) 2023-08-03 17:59:13 +02:00
Serge
7d3c54ef4c New translations Strings.resx (Chinese Traditional) 2023-08-03 17:59:12 +02:00
Serge
dd55a9ae4b New translations Strings.resx (Chinese Simplified) 2023-08-03 17:59:11 +02:00
Serge
4fff5ddb0a New translations Strings.resx (Ukrainian) 2023-08-03 17:59:10 +02:00
Serge
c657b79422 New translations Strings.resx (Turkish) 2023-08-03 17:59:09 +02:00
Serge
b3a8a9abef New translations Strings.resx (Portuguese) 2023-08-03 17:59:09 +02:00
Serge
6995637aec New translations Strings.resx (Lithuanian) 2023-08-03 17:59:08 +02:00
Serge
0cb0ff12a5 New translations Strings.resx (Korean) 2023-08-03 17:59:07 +02:00
Serge
f582882828 New translations Strings.resx (Italian) 2023-08-03 17:59:06 +02:00
Serge
4b6736c255 New translations Strings.resx (Hungarian) 2023-08-03 17:59:05 +02:00
Serge
246fbc9437 New translations Strings.resx (German) 2023-08-03 17:59:04 +02:00
Serge
e135d58c46 New translations Strings.resx (Spanish) 2023-08-03 17:59:03 +02:00
Serge
9bf4396902 New translations Strings.resx (French) 2023-08-03 17:59:02 +02:00
Serge
60e88c0b45 New translations Strings.resx (Romanian) 2023-08-03 17:59:01 +02:00
Serge
8ec72ec94d Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-03 17:15:49 +02:00
Serge
b808efb502 Added Battery Charge 2023-08-03 17:15:46 +02:00
Serge
92f9333800 Merge pull request #984 from IceStormNG/asus-mouse-support
TUF Gaming M3 support
2023-08-03 17:10:07 +02:00
IceStormNG
3c4a6c5e95 Added TUF Gaming M3 2023-08-03 17:05:26 +02:00
Serge
b22fffe81a Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-03 14:21:14 +02:00
Serge
dcecfbaeda Heatmap cleanup 2023-08-03 14:21:12 +02:00
Serge
2a6d02b1cb Tuf keybindings https://github.com/seerge/g-helper/issues/975 2023-08-03 13:48:24 +02:00
Serge
048f68e2ff UI Tweaks 2023-08-03 13:14:54 +02:00
Serge
ac66642623 Merge pull request #977 from ktemkin/ally_buttons
add as much button support as we can to the RC71 (ROG Ally)
2023-08-03 12:44:46 +02:00
Kate Temkin
8d9999c6c7 add as much button support as we can to the RC71 (ROG Ally) 2023-08-02 20:52:15 -06:00
IceStormNG
977e7cc8c4 Angle tuning limits are now variable and can be overriden per mouse. 2023-08-02 21:44:03 +02:00
Serge
662d5fb414 Aura Fix 2023-08-02 20:44:31 +02:00
Serge
3e0dc9ee7d Heatmap Alt fix 2023-08-02 18:25:27 +02:00
Serge
9cef990edf Revert aura tweak 2023-08-02 15:01:41 +02:00
Serge
f288f1fbf4 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-02 14:43:17 +02:00
Serge
5561101093 Aura 2023-08-02 14:43:15 +02:00
Serge
a27906b1b7 Merge pull request #970 from seerge/l10n_main
New Crowdin updates
2023-08-02 11:13:13 +02:00
IceStormNG
659a408225 Disable packet logger for release builds. 2023-08-02 10:32:25 +02:00
Serge
3d4fab99b6 New translations Strings.resx (Chinese Simplified) 2023-08-02 04:29:56 +02:00
Serge
7c5f5a9b24 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-02 00:30:48 +02:00
Serge
e9ae5c9dc8 Brightness fix for TUF506 2023-08-02 00:30:46 +02:00
Serge
33311611ab Fixed heatmap https://github.com/seerge/g-helper/issues/967 2023-08-01 23:54:13 +02:00
Serge
d50ec93e94 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-01 22:45:39 +02:00
Serge
fbdfdd2f03 Skip custom keybindings https://github.com/seerge/g-helper/issues/960 2023-08-01 22:45:38 +02:00
Serge
cbe05b1a7c Update README.md 2023-08-01 22:30:14 +02:00
Serge
f32f70f145 2 Heatmap modes, one can blink, another one don't work on some devices 2023-08-01 20:24:16 +02:00
Serge
409febb48f Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-01 20:02:36 +02:00
Serge
df132ee196 Aura Fix Attempt 2023-08-01 20:02:34 +02:00
Serge
63b93cab0b Update README.md 2023-08-01 18:31:31 +02:00
Serge
9b1170d364 Update README.md 2023-08-01 14:10:17 +02:00
Serge
0dba6d7a42 Update README.md 2023-08-01 14:09:42 +02:00
Serge
d82deb9860 Fn+Np Enter support https://github.com/seerge/g-helper/issues/963 2023-08-01 13:20:11 +02:00
Serge
3307a95955 Merge branch 'main' of https://github.com/seerge/g-helper 2023-08-01 12:23:26 +02:00
Serge
392b437913 Ctrl+M1/M2 for TUF 2023-08-01 12:23:23 +02:00
Serge
8312d8700e Merge pull request #962 from seerge/l10n_main
New Crowdin updates
2023-08-01 11:20:08 +02:00
Serge
f8110ef661 New translations Strings.resx (Lithuanian) 2023-08-01 08:30:05 +02:00
Serge
4da8f599ab New translations Strings.resx (Ukrainian) 2023-07-31 22:32:17 +02:00
Serge
0aa1e81665 Merge pull request #958 from seerge/l10n_main
New Crowdin updates
2023-07-31 22:21:55 +02:00
Serge
ffe07b42b5 Update README.md 2023-07-31 20:53:34 +02:00
Serge
d7dd4db144 New translations Strings.resx (Polish) 2023-07-31 20:40:23 +02:00
Serge
c81cb85112 New translations Strings.resx (Ukrainian) 2023-07-31 20:40:20 +02:00
Serge
e24f7679a6 New translations Strings.resx (Italian) 2023-07-31 20:40:17 +02:00
Serge
b4b3034e92 New translations Strings.resx (Hungarian) 2023-07-31 20:40:16 +02:00
Serge
9c452a2172 New translations Strings.resx (Spanish) 2023-07-31 20:40:14 +02:00
Serge
86bc0f4e5d Merge pull request #957 from IceStormNG/asus-mouse-support
Adds support for Gladius III Wireless (P706_Wireless).
2023-07-31 18:35:10 +02:00
IceStormNG
8f59ff5e3d Adds support for Gladius III Wireless (P706_Wireless). Renamed the other Gladius III (Wireless Aimpoint) to differentiate them. Fixes a crashbug that can occurs when opening the 2023-07-31 18:21:28 +02:00
Serge
a8db22b22b Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-31 17:51:02 +02:00
Serge
bffd68ead4 Aura Tweaks 2023-07-31 17:50:59 +02:00
Serge
46c0f89632 Merge pull request #955 from seerge/l10n_main
New Crowdin updates
2023-07-31 17:50:07 +02:00
Serge
08c28ed0d0 New translations Strings.resx (Chinese Traditional) 2023-07-31 17:15:58 +02:00
Serge
f24f2dcec3 New translations Strings.resx (Vietnamese) 2023-07-31 16:08:52 +02:00
Serge
f7b2a5b893 New translations Strings.resx (Chinese Simplified) 2023-07-31 16:08:51 +02:00
Serge
da34a5af56 New translations Strings.resx (Turkish) 2023-07-31 16:08:49 +02:00
Serge
fa9d73e629 New translations Strings.resx (Portuguese) 2023-07-31 16:08:48 +02:00
Serge
e1b6e3057d New translations Strings.resx (Lithuanian) 2023-07-31 16:08:47 +02:00
Serge
5bb3b67979 New translations Strings.resx (Korean) 2023-07-31 16:08:46 +02:00
Serge
4046982698 New translations Strings.resx (German) 2023-07-31 16:08:43 +02:00
Serge
4f80d1ced6 New translations Strings.resx (French) 2023-07-31 16:08:41 +02:00
Serge
22799caedc New translations Strings.resx (Romanian) 2023-07-31 16:08:40 +02:00
Serge
107b09c6dc Merge pull request #954 from IceStormNG/asus-mouse-support
Adds Button debounce (button response time) setting for supported mice.
2023-07-31 13:08:20 +02:00
IceStormNG
4f2fdc55ee Adds Button debounce (button response time) setting for supported mice. 2023-07-31 13:05:31 +02:00
Serge
16674b773d Merge pull request #950 from seerge/l10n_main
New Crowdin updates
2023-07-31 13:03:07 +02:00
Serge
1e8bbba24e Merge pull request #953 from IceStormNG/asus-mouse-support
Added Rog Strix Impact II Wireless mouse support.
2023-07-31 13:02:46 +02:00
IceStormNG
b5451cfc21 Added Rog Strix Impact II Wireless mouse support. Hint: Has the same DPI switching Problem as the Keris. 2023-07-31 12:40:40 +02:00
Serge
6507dee307 New translations Strings.resx (Chinese Simplified) 2023-07-31 07:59:33 +02:00
Serge
930b885ac0 Merge pull request #943 from seerge/l10n_main
New Crowdin updates
2023-07-31 01:13:28 +02:00
Serge
22377a4ba9 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-31 00:08:47 +02:00
Serge
85cd10132e Setting Standard mode prior to going Ultimate 2023-07-31 00:08:45 +02:00
Serge
643e29e25a New translations Strings.resx (Spanish) 2023-07-30 22:02:10 +02:00
Serge
70c41b311c Update bug_report.md 2023-07-30 22:00:47 +02:00
Serge
85880c16c1 Update README.md 2023-07-30 21:59:35 +02:00
Serge
3ff0335985 Restored fallback CPU temp reading method 2023-07-30 21:52:28 +02:00
Serge
3bafaaada0 Aura Fix 3 2023-07-30 20:25:13 +02:00
Serge
584c641b18 Aura Fix 2023-07-30 20:11:41 +02:00
Serge
ca1875d57a Aura Fix 2 2023-07-30 20:08:44 +02:00
Serge
03c45994dc Aura Fix 2023-07-30 20:00:36 +02:00
Serge
f0cbec6ea1 New translations Strings.resx (Lithuanian) 2023-07-30 18:52:02 +02:00
Serge
72fe01bb34 Merge pull request #940 from seerge/l10n_main
New Crowdin updates
2023-07-30 18:26:55 +02:00
Serge
50ae8ae843 Merge pull request #941 from IceStormNG/asus-mouse-support
Mouse support fixes
2023-07-30 17:58:53 +02:00
Serge
14e3d41def New translations Strings.resx (Lithuanian) 2023-07-30 17:52:38 +02:00
Serge
200a2a9eb9 New translations Strings.resx (Polish) 2023-07-30 17:52:37 +02:00
IceStormNG
769c490d21 Give lighting zone table layout a proper name 2023-07-30 17:30:02 +02:00
IceStormNG
0da5002804 Only set new mouse profile if it actually changed. 2023-07-30 17:29:26 +02:00
IceStormNG
5bf579fec5 Imroved handling for mice with only a single lighting zone. 2023-07-30 17:28:08 +02:00
Serge
1038d4479c Merge pull request #939 from seerge/l10n_main
New Crowdin updates
2023-07-30 16:49:07 +02:00
Serge
78d663c62c New translations Strings.resx (German) 2023-07-30 16:48:49 +02:00
Serge
2f96adb204 Merge pull request #938 from IceStormNG/asus-mouse-support
Added Rog Keris Wireless
2023-07-30 16:40:07 +02:00
IceStormNG
e6f9be1bfd Merge branch 'seerge:main' into asus-mouse-support 2023-07-30 16:30:54 +02:00
IceStormNG
297cec6e77 Added Rog Keris Wireless mouse support 2023-07-30 16:30:34 +02:00
Serge
5aca01b21e Z13 rear-window 2023-07-30 16:20:53 +02:00
Serge
3df2193afb Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-30 16:20:19 +02:00
Serge
ed513e4469 Merge pull request #937 from seerge/l10n_main
New Crowdin updates
2023-07-30 15:30:01 +02:00
Serge
c398537a1f Rear window backlight for Z13 2023-07-30 15:28:53 +02:00
Serge
42641f5627 New translations Strings.resx (Vietnamese) 2023-07-30 15:28:28 +02:00
Serge
7b10532650 New translations Strings.resx (Chinese Traditional) 2023-07-30 15:28:27 +02:00
Serge
eb4d4c3d70 New translations Strings.resx (Turkish) 2023-07-30 15:28:26 +02:00
Serge
43c93d6a70 New translations Strings.resx (Portuguese) 2023-07-30 15:28:25 +02:00
Serge
bd26dfb774 New translations Strings.resx (Lithuanian) 2023-07-30 15:28:24 +02:00
Serge
c4aa38c82b New translations Strings.resx (Korean) 2023-07-30 15:28:23 +02:00
Serge
c0597e01b6 New translations Strings.resx (Italian) 2023-07-30 15:28:22 +02:00
Serge
8a6c4e1cee New translations Strings.resx (Hungarian) 2023-07-30 15:28:22 +02:00
Serge
0a77176bcc New translations Strings.resx (German) 2023-07-30 15:28:21 +02:00
Serge
35fc78d757 New translations Strings.resx (Spanish) 2023-07-30 15:28:20 +02:00
Serge
407206309a New translations Strings.resx (French) 2023-07-30 15:28:19 +02:00
Serge
51bc8143dd New translations Strings.resx (Romanian) 2023-07-30 15:28:18 +02:00
Serge
98bac7171a New translations Strings.resx (Chinese Simplified) 2023-07-30 15:28:17 +02:00
Serge
839ef140ff New translations Strings.resx (Ukrainian) 2023-07-30 15:28:16 +02:00
Serge
c3e97caf49 New translations Strings.resx (Polish) 2023-07-30 15:28:15 +02:00
Serge
96319f4dbb Merge pull request #935 from IceStormNG/asus-mouse-support
Auto refresh mice when hovering the button
2023-07-30 14:00:18 +02:00
IceStormNG
cbccd5b641 Merge branch 'seerge:main' into asus-mouse-support 2023-07-30 13:49:27 +02:00
IceStormNG
4742c33466 Auto refresh mice when hovering over their buttons and the mouse is marked as "Not ready". 2023-07-30 13:48:53 +02:00
Serge
81681eb7c4 Merge pull request #934 from IceStormNG/asus-mouse-support
Added Lighting zones for supported mice.
2023-07-30 13:47:41 +02:00
IceStormNG
7c80a32fc2 Added Lighting zones for supported mice. 2023-07-30 13:42:35 +02:00
Serge
9cb2904632 FX707 fix, AuraPower refactoring 2023-07-30 13:32:01 +02:00
Serge
40859a06d0 Merge pull request #933 from IceStormNG/asus-mouse-support
Added support for ASUS TUF Gaming M4 Wireless (P306_Wireless) Mouse
2023-07-30 12:20:37 +02:00
IceStormNG
b00ac96e99 Merge branch 'main' into asus-mouse-support
# Conflicts:
#	app/Peripherals/PeripheralsProvider.cs
2023-07-30 11:56:07 +02:00
IceStormNG
c7c14a9211 byte 3 is only 2 for mice with XY DPIs. 2023-07-30 11:23:38 +02:00
IceStormNG
78cbfc8813 Added TUF M4 Wireless mouse. 2023-07-30 11:18:15 +02:00
IceStormNG
569519aeea Mice with only one DPI per setting read through a different packet 2023-07-30 11:17:21 +02:00
IceStormNG
3cfd7e01ca Renamed Gladius III to Gladius III Aimpoint as there is also a regular Gladius III 2023-07-30 11:16:53 +02:00
IceStormNG
93b6c360d6 Handling of error responses from the mouse and some mice spam packets through the interface. Read again, until you get the matching USB packet or a timeout happens (aka: No data left in the buffer). 2023-07-30 11:10:31 +02:00
IceStormNG
15ba1b8c38 Allow override of "SetDPIProfil" function if needed 2023-07-30 11:09:27 +02:00
IceStormNG
2f35889a61 Measure mouse I/O for diagnostics purpose. 2023-07-30 10:56:01 +02:00
IceStormNG
e0e86962d1 Re-ordered sync 2023-07-30 10:54:33 +02:00
IceStormNG
cdde8afc7e Somem ice have separate X/Y DPI settings (not supported yet, but needs to be read differently from the mouse). 2023-07-30 10:54:09 +02:00
IceStormNG
0af87ecdac Variable DPI Increment as some mice do not use 50 per step but 100. 2023-07-30 10:50:09 +02:00
IceStormNG
4b3d18347c Variable max brightness as some mice do not use 0-100 but 0-4 as brightness values. 2023-07-30 10:49:26 +02:00
IceStormNG
8c2ee50c93 Fixed DPI button colors for mice with no custom DPI colors. 2023-07-30 10:48:31 +02:00
IceStormNG
6d66831770 Simplified exception naming 2023-07-30 10:48:02 +02:00
IceStormNG
e0795dd16b Adjust timeout to lower values. The typical mouse response time is between 1 and 40ms. 300 should be more than enough to fail earlier when the device does not respond. 2023-07-30 10:47:35 +02:00
IceStormNG
b0733d9254 Refresh the mouse only every 20s in background. When GHelper becomes visible, force refresh all devices. 2023-07-30 10:46:10 +02:00
Serge
0d757ef06d Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-29 18:52:57 +02:00
Serge
d19aaf804a Heatmap fix 2023-07-29 18:52:53 +02:00
Serge
41adef4786 Merge pull request #919 from seerge/l10n_main
New Crowdin updates
2023-07-29 00:00:48 +02:00
Serge
9ee3ae7359 New translations Strings.resx (Chinese Simplified) 2023-07-28 17:20:38 +02:00
Serge
bd0f97c5d9 New translations Strings.resx (Chinese Simplified) 2023-07-28 13:59:51 +02:00
Serge
f85644bd2b Merge pull request #913 from seerge/l10n_main
New Crowdin updates
2023-07-28 13:49:38 +02:00
Serge
62f1263951 New translations Strings.resx (Chinese Simplified) 2023-07-28 12:21:04 +02:00
Serge
1fcd0f2b97 New translations Strings.resx (Chinese Simplified) 2023-07-28 10:17:37 +02:00
Serge
73baf548a4 New translations Strings.resx (Chinese Simplified) 2023-07-28 07:51:13 +02:00
Serge
6357a22e38 New translations Strings.resx (Ukrainian) 2023-07-28 02:54:21 +02:00
Serge
3a08ee8d7c New translations Strings.resx (Polish) 2023-07-28 02:54:20 +02:00
Serge
af67684e91 New translations Strings.resx (Polish) 2023-07-28 01:47:09 +02:00
Serge
a877904b46 New translations Strings.resx (Ukrainian) 2023-07-28 00:49:53 +02:00
Serge
f090b4a44e New translations Strings.resx (Polish) 2023-07-28 00:49:52 +02:00
Serge
b3f5a2dfa2 Skip Updates param 2023-07-28 00:06:57 +02:00
Serge
6029660860 Added timer to prevent checking for Mice multiple times in a row 2023-07-28 00:06:01 +02:00
Serge
b304ce22b9 MaxRPM calibration tweaks 2023-07-27 23:50:31 +02:00
Serge
b7910d9f79 Close updates on main window close 2023-07-27 19:46:05 +02:00
Serge
505b3a9e4a Merge pull request #907 from IceStormNG/asus-mouse-support
ASUS Mouse: Resolved deadlocks
2023-07-27 11:21:56 +02:00
IceStormNG
42a346b19e Wait for mouse data before opening the window so the user does not see the form populating data. 2023-07-27 10:41:23 +02:00
IceStormNG
7c42f87751 Check for dispose before trying to Invoke. 2023-07-27 10:40:41 +02:00
IceStormNG
a323bd85ab Mouse refreshes battery again during "ReadSensors". But it does that nonblocking and event driven. 2023-07-27 10:19:17 +02:00
IceStormNG
6e4b5226f5 Do not refresh battery on main thread. 2023-07-27 10:14:06 +02:00
IceStormNG
acaa8bc523 Added missing import for synchronized annotation 2023-07-27 10:13:46 +02:00
IceStormNG
ef31935b24 Improved handling of critical sections to solve deadlocks. 2023-07-27 10:13:24 +02:00
Serge
a9c104d388 Duo keys 2023-07-27 01:41:25 +02:00
Serge
bc9d6be0d6 Deadlock 2023-07-27 00:25:30 +02:00
Serge
d37e06d399 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-27 00:06:30 +02:00
Serge
d49832ae0f Restoring Aura Call 2023-07-27 00:06:28 +02:00
Serge
f318d09b9b Merge pull request #902 from seerge/l10n_main
New Crowdin updates
2023-07-26 23:58:50 +02:00
Serge
5cd77bb5cc Merge pull request #905 from IceStormNG/clamshell-power-user-settings
Clamshell power user settings
2023-07-26 23:58:27 +02:00
Serge
6b4d18c9c5 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-26 23:57:22 +02:00
Serge
5830220a3d Performance tweaks 2023-07-26 23:57:20 +02:00
IceStormNG
dfe4bebe58 Only write the setting if it does not exist yet. 2023-07-26 23:19:36 +02:00
IceStormNG
cff2c9af0b Save lid action to config file during startup if user has set it to hibernate or shutdown. 2023-07-26 23:15:28 +02:00
IceStormNG
e16a50f1f2 Safeguard to prevent users from choosing invalid options. 2023-07-26 21:16:30 +02:00
IceStormNG
254e6a8633 Users can set a config option clamshell_default_lid_action to set their desired option when clamshell is not engaged. 2023-07-26 21:14:03 +02:00
IceStormNG
ccb413b2e6 Clamshell mode is now properly off by default 2023-07-26 21:13:24 +02:00
Serge
e2ea79b758 Merge pull request #904 from IceStormNG/asus-mouse-support
Asus mouse fixes
2023-07-26 21:09:30 +02:00
IceStormNG
c1043efc53 Merge branch 'seerge:main' into asus-mouse-support 2023-07-26 21:02:30 +02:00
IceStormNG
6c6c93b378 Better handling of wireless devies that get turned off. The dongle still responds but it sends empty packets. 2023-07-26 21:01:39 +02:00
IceStormNG
f9a8665290 Properly save the new dpi profile so it stays selected also when the mouse is powered off and on again. 2023-07-26 20:46:53 +02:00
IceStormNG
54d7dfe4f8 Safeguards to prevent crash when closing the window in the exact moment the battery is updated. 2023-07-26 20:32:09 +02:00
Serge
eeb53cb483 New translations Strings.resx (Lithuanian) 2023-07-26 20:23:50 +02:00
Serge
b9625f2748 Aura color 2023-07-26 19:26:23 +02:00
Serge
8d41c228e0 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-26 19:13:12 +02:00
Serge
0146a40244 Heatmap fix 2023-07-26 19:13:10 +02:00
Serge
98534c9b43 Merge pull request #899 from seerge/l10n_main
New Crowdin updates
2023-07-26 18:11:16 +02:00
Serge
67aa2b5af8 New translations Strings.resx (Lithuanian) 2023-07-26 17:47:40 +02:00
IceStormNG
a451125475 Additional logging for dispose and disconnet events. 2023-07-26 15:08:27 +02:00
IceStormNG
fb3ffba343 Log energy settings only as they're supported. 2023-07-26 15:08:03 +02:00
IceStormNG
86ded739d6 Allow enabling packet logger through variable for test builds. 2023-07-26 15:07:39 +02:00
IceStormNG
80e8d54b57 UI fixes for mouse. Only register for events once the view is shown to prevent crashes. Add some additional logging for troubleshooting. Run Mouse sync asynchronously 2023-07-26 15:06:06 +02:00
Serge
f0f05fa1fd New translations Strings.resx (Chinese Traditional) 2023-07-26 09:40:55 +02:00
Serge
b7a4027b41 New translations Strings.resx (Chinese Traditional) 2023-07-26 08:27:58 +02:00
Serge
5f3958ce2b Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-26 00:48:38 +02:00
Serge
dcf4fa5a48 TUF Heatmap fix 2023-07-26 00:48:37 +02:00
Serge
6ace1fdd63 Merge pull request #897 from seerge/l10n_main
New Crowdin updates
2023-07-25 23:55:36 +02:00
Serge
243e307f0a New translations Strings.resx (Spanish) 2023-07-25 23:04:52 +02:00
Serge
8e53a94a13 Merge pull request #896 from seerge/l10n_main
New Crowdin updates
2023-07-25 22:09:53 +02:00
Serge
4f337a7100 New translations Strings.resx (Spanish) 2023-07-25 22:03:23 +02:00
Serge
b1a9bfe68d G14 2020 Extra fix 2023-07-25 22:01:03 +02:00
Serge
c9fc3e788a Div by zero fix 2023-07-25 20:25:07 +02:00
Serge
64e6216fc0 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-25 19:34:52 +02:00
Serge
dfa3b8d270 UI 2023-07-25 19:34:50 +02:00
Serge
355ad69721 Merge pull request #889 from IceStormNG/asus-mouse-support
USB packet logger only for debug builds or if enabled in config
2023-07-25 19:22:49 +02:00
IceStormNG
a706d447f6 Only do packet logging if config usb_packet_logger is 1 or if it is a debug build. 2023-07-25 19:18:51 +02:00
IceStormNG
834952ca33 Use device correct name for logging 2023-07-25 19:14:40 +02:00
Serge
f8ba867440 Merge pull request #888 from seerge/l10n_main
New Crowdin updates
2023-07-25 18:58:04 +02:00
Serge
19b317d271 New translations Strings.resx (Vietnamese) 2023-07-25 18:57:37 +02:00
Serge
ecbb24a038 New translations Strings.resx (Chinese Traditional) 2023-07-25 18:57:36 +02:00
Serge
1151d314f9 New translations Strings.resx (Chinese Simplified) 2023-07-25 18:57:35 +02:00
Serge
ac43eed1c4 New translations Strings.resx (Ukrainian) 2023-07-25 18:57:34 +02:00
Serge
d554637497 New translations Strings.resx (Turkish) 2023-07-25 18:57:33 +02:00
Serge
25c1da63a7 New translations Strings.resx (Portuguese) 2023-07-25 18:57:32 +02:00
Serge
ded3f3ce54 New translations Strings.resx (Polish) 2023-07-25 18:57:31 +02:00
Serge
39501133c7 New translations Strings.resx (Lithuanian) 2023-07-25 18:57:30 +02:00
Serge
41673c5c7e New translations Strings.resx (Korean) 2023-07-25 18:57:28 +02:00
Serge
b3d2993017 New translations Strings.resx (Italian) 2023-07-25 18:57:27 +02:00
Serge
27f72aeef1 New translations Strings.resx (Hungarian) 2023-07-25 18:57:26 +02:00
Serge
e97bba573a New translations Strings.resx (German) 2023-07-25 18:57:25 +02:00
Serge
8a6a5a55db New translations Strings.resx (Spanish) 2023-07-25 18:57:24 +02:00
Serge
f2b45a0a8d New translations Strings.resx (French) 2023-07-25 18:57:23 +02:00
Serge
91df051c38 New translations Strings.resx (Romanian) 2023-07-25 18:57:22 +02:00
Serge
46871f00c0 MaxRPM for XGM 2023-07-25 18:53:50 +02:00
Serge
7bd2c7ea43 UI 2023-07-25 18:15:06 +02:00
Serge
e909676c2d FN + Nm-Enter binding 2023-07-25 18:03:54 +02:00
Serge
0ed7166059 Merge pull request #887 from IceStormNG/asus-mouse-support
Asus mouse support (at least for 2 mice for now)
2023-07-25 17:46:39 +02:00
IceStormNG
7cdb95f7a4 Remove unnecessary imports 2023-07-25 17:25:31 +02:00
IceStormNG
aeea6e8177 Merge branch 'main' into asus-mouse-support
# Conflicts:
#	app/Settings.Designer.cs
2023-07-25 17:20:45 +02:00
Serge
e67f6b54cb Merge pull request #882 from seerge/l10n_main
New Crowdin updates
2023-07-25 12:05:37 +02:00
Serge
ac6c71252d New translations Strings.resx (Romanian) 2023-07-25 08:16:37 +02:00
Serge
12a962d75d Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-25 01:50:47 +02:00
Serge
fab464feb5 Heatmap 2023-07-25 01:50:46 +02:00
Serge
3fbd956f1c Merge pull request #879 from seerge/l10n_main
New Crowdin updates
2023-07-25 01:22:29 +02:00
Serge
ed4a4a43a1 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-25 00:09:31 +02:00
Serge
702e6ccb0a Added Heatmap backlight mode 2023-07-25 00:09:30 +02:00
Serge
c533511166 New translations Strings.resx (Romanian) 2023-07-24 22:48:30 +02:00
Serge
0039a6aeef Merge pull request #877 from seerge/l10n_main
New Crowdin updates
2023-07-24 22:35:50 +02:00
Serge
aefd29c459 New translations Strings.resx (Romanian) 2023-07-24 21:45:16 +02:00
IceStormNG
90ba7b6c08 Added more features to be selected and deselected individually. Renamed the P711 to Gladius III. Mouse classes will be named by their product name, not their internal name to find them easier. 2023-07-24 19:19:31 +02:00
IceStormNG
c67f079f30 Merge branch 'main' into asus-mouse-support
# Conflicts:
#	app/Settings.Designer.cs
2023-07-24 18:53:55 +02:00
IceStormNG
fce0801f3b Smaller buttons for the mouse 2023-07-24 18:05:30 +02:00
IceStormNG
f70285c017 Allow DPI changes via text input 2023-07-24 18:04:46 +02:00
Serge
7b4e342f04 UI 2023-07-24 16:45:00 +02:00
IceStormNG
150c2c75d6 Put image to the side to have more space for text 2023-07-24 16:33:23 +02:00
IceStormNG
5c065a3857 Fixed crash if speed is reported as 0. 2023-07-24 16:20:16 +02:00
IceStormNG
e0a517f42f Merge branch 'main' into asus-mouse-support
# Conflicts:
#	app/Settings.Designer.cs
#	app/Settings.cs
2023-07-24 15:41:33 +02:00
IceStormNG
966f9107fb Code re-format 2023-07-24 15:29:56 +02:00
IceStormNG
badbb174cd Also hide the color button if colors cannot be set 2023-07-24 15:29:21 +02:00
IceStormNG
03a942b57e Support for proper "Off" Lighting mode 2023-07-24 15:29:03 +02:00
Serge
4086098f58 Hide Keyboard section for G14 2020 completely 2023-07-24 14:53:09 +02:00
Serge
a9dd06de64 UI 2023-07-24 14:48:04 +02:00
Serge
46cbc26d92 UI 2023-07-24 14:34:14 +02:00
Serge
73f7c9f33e Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-24 14:26:37 +02:00
Serge
ef6de6ad2a UI Re-arrangements 2023-07-24 14:26:35 +02:00
IceStormNG
93ad46a685 Well.. this should've been implemented already. 2023-07-24 14:14:57 +02:00
IceStormNG
4d686b6115 Fixed IDs for P711. It's apparently always mi_00. Even if the ASUS driver lists something else. 2023-07-24 14:14:43 +02:00
IceStormNG
3b5cfe958d Polling rates are fixed index numbers for all mice. 0 is immer 125Hz for example, if the mouse, like the Ckakram, do not support 125Hz, the first valid polling rate is 250Hz = 1. 2023-07-24 14:14:09 +02:00
Serge
132df330a4 Merge pull request #865 from seerge/l10n_main
New Crowdin updates
2023-07-23 22:58:05 +02:00
IceStormNG
217074c640 P711 apparently supports all modes even though Armoury Crate does not list them all (as per OpenRGB) 2023-07-23 20:52:47 +02:00
IceStormNG
6e312111ac Merge branch 'seerge:main' into asus-mouse-support 2023-07-23 20:47:53 +02:00
Serge
99296ebb1c Rear Lightbar support 2023-07-23 20:14:57 +02:00
IceStormNG
f0eadd4628 Show charging in brackets. 2023-07-23 18:58:38 +02:00
IceStormNG
d4b0b484aa Added Gladius III (P711) experimental class. 2023-07-23 18:57:02 +02:00
IceStormNG
6f70b54cd4 Unregister event handlers on close 2023-07-23 18:55:24 +02:00
IceStormNG
3c1b61dc82 This can be simplified to reduce redundant code. 2023-07-23 18:53:21 +02:00
Serge
5240fcc8e7 New translations Strings.resx (Lithuanian) 2023-07-23 18:48:29 +02:00
IceStormNG
65d25917b1 Merge branch 'seerge:main' into asus-mouse-support 2023-07-23 18:38:00 +02:00
IceStormNG
378d81bafe Added UI to change ASUS mouse settings. 2023-07-23 18:37:30 +02:00
IceStormNG
5f29e98955 Fixed lighting decode 2023-07-23 18:30:26 +02:00
IceStormNG
5cb5b8cdaf Make sure to tell the mouse to flush the settings when we changed something 2023-07-23 18:30:07 +02:00
IceStormNG
8e19dcb677 Notify on Battery status update 2023-07-23 18:29:34 +02:00
IceStormNG
e825612396 Disable the button if the mouse is not ready yet. 2023-07-23 17:54:37 +02:00
IceStormNG
117ffd0f62 Various fixes in the protocol. Now it is tested and works (at least with the Chakram X in Dongle mode.) 2023-07-23 17:54:09 +02:00
Serge
5291206cb3 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-23 17:17:54 +02:00
Serge
2747387847 Fix Aura UI 2023-07-23 17:17:52 +02:00
Serge
bd1a11a15a Update README.md 2023-07-23 14:46:02 +02:00
Serge
c2262c0f89 Moved Aura commands to parallel thread 2023-07-23 14:36:22 +02:00
Serge
88aaf94441 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-23 13:33:08 +02:00
Serge
20b99810cb Standard mode fix 2023-07-23 13:33:05 +02:00
Serge
7b327a4481 Merge pull request #856 from seerge/l10n_main
New Crowdin updates
2023-07-23 12:39:23 +02:00
IceStormNG
890032a81b Auto-reposition window after resize caused by detection of a new device. 2023-07-23 11:58:15 +02:00
IceStormNG
18384bbddc Added Peripherals Panel to main window (buttons have no function yet... coming soon) 2023-07-23 11:57:44 +02:00
IceStormNG
c1900e75ec Helper function to tint images 2023-07-23 11:55:47 +02:00
IceStormNG
ab2dd4d685 Added mouse icon 2023-07-23 11:54:54 +02:00
IceStormNG
f9f96bd807 Restructured to generic Interface for easier extension. 2023-07-23 11:52:31 +02:00
IceStormNG
df616b486d Register for device listener on startup 2023-07-23 10:55:06 +02:00
IceStormNG
d8b2836819 Improved connect and disconnect handling with better cleanup and less exceptions. 2023-07-23 10:54:37 +02:00
IceStormNG
4ef7f5b4cb Expose Dispose function for overriding 2023-07-23 10:53:59 +02:00
IceStormNG
7dfe830dac Better disconnect handling 2023-07-23 10:53:30 +02:00
Serge
6f40dadfcb New translations Strings.resx (Chinese Simplified) 2023-07-23 09:59:11 +02:00
IceStormNG
86c960e01b Merge branch 'seerge:main' into asus-mouse-support 2023-07-22 22:55:16 +02:00
IceStormNG
f80db2c770 Added ASUS Mouse Control Protocol + Implementation for Chakram X (Dongle and Wired) 2023-07-22 22:51:03 +02:00
IceStormNG
d9cba16218 Added additional logic to the AnimeMatrix USB classes to re-use them. 2023-07-22 22:47:14 +02:00
Serge
a004924a42 Merge 2023-07-22 19:23:36 +02:00
Serge
ef442da885 Merge 2023-07-22 19:23:29 +02:00
Serge
eab2ef695d Hide Unsupported elements in Extra 2023-07-22 19:20:44 +02:00
Serge
0291920a55 Merge pull request #844 from seerge/l10n_main
New Crowdin updates
2023-07-22 11:39:35 +02:00
Serge
633c841d7f New translations Strings.resx (Chinese Traditional) 2023-07-22 01:48:49 +02:00
Serge
f2f4df5693 New translations Strings.resx (Spanish) 2023-07-21 20:47:51 +02:00
Serge
4592d729d3 New translations Strings.resx (Italian) 2023-07-21 18:26:01 +02:00
Serge
8cedcb7b5d Merge pull request #841 from seerge/l10n_main
New Crowdin updates
2023-07-21 18:05:15 +02:00
Serge
37d133bd7c Merge pull request #842 from IceStormNG/clamshell-mode-fixes
Clamshell mode fixes
2023-07-21 15:50:51 +02:00
IceStormNG
3f87730375 Fixed a typo 2023-07-21 15:45:42 +02:00
IceStormNG
d99c3a8301 Assign handler via code so the settings assignment does not trigger the handler 2023-07-21 15:42:40 +02:00
IceStormNG
fbc792cb1d Only instanciate if needed. 2023-07-21 15:40:24 +02:00
IceStormNG
5498bb9398 This name makes more sense as it only checks for requirements 2023-07-21 15:39:23 +02:00
IceStormNG
25f842df9d Only touch power settings if the user checks the box. But always disable the changes back to the defaults when the user unchecks it. 2023-07-21 15:38:26 +02:00
Serge
987ee1c000 New translations Strings.resx (Polish) 2023-07-21 14:46:05 +02:00
Serge
afe760f58d Merge pull request #840 from seerge/l10n_main
New Crowdin updates
2023-07-21 13:00:18 +02:00
Serge
b07f0a09fa New translations Strings.resx (Chinese Simplified) 2023-07-21 12:59:52 +02:00
Serge
2b26791dc0 New translations Strings.resx (Ukrainian) 2023-07-21 12:59:51 +02:00
Serge
8db6939b30 Update README.md 2023-07-21 12:47:21 +02:00
Serge
29bcb810b4 Update release.yml 2023-07-21 11:40:51 +02:00
Serge
62837e0ecc Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-21 11:33:24 +02:00
Serge
e1fb6d27a5 UI Tweaks 2023-07-21 11:33:22 +02:00
Serge
b49ab894ac Merge pull request #837 from seerge/l10n_main
New Crowdin updates
2023-07-21 01:04:45 +02:00
Serge
1166a51e4a New translations Strings.resx (German) 2023-07-20 23:38:07 +02:00
Serge
0e26838eb3 New translations Strings.resx (Spanish) 2023-07-20 22:22:12 +02:00
Serge
c0585156e8 New translations Strings.resx (Lithuanian) 2023-07-20 22:22:11 +02:00
Serge
a358632f41 Battery Health UI 2023-07-20 20:01:03 +02:00
Serge
55a3677a37 Version Bump 2023-07-20 19:36:59 +02:00
Serge
1e89039b02 Battery Health UI changes 2023-07-20 18:08:11 +02:00
Serge
2c0fdb7773 Merge pull request #836 from seerge/l10n_main
New Crowdin updates
2023-07-20 17:09:00 +02:00
Serge
2aedbc7a24 New translations Strings.resx (Vietnamese) 2023-07-20 17:07:27 +02:00
Serge
ea22d910ad New translations Strings.resx (Chinese Traditional) 2023-07-20 17:07:26 +02:00
Serge
90cec227c5 New translations Strings.resx (Chinese Simplified) 2023-07-20 17:07:25 +02:00
Serge
d1f6cb11ee New translations Strings.resx (Ukrainian) 2023-07-20 17:07:24 +02:00
Serge
836ebbeebf New translations Strings.resx (Turkish) 2023-07-20 17:07:23 +02:00
Serge
c13b35ca1e New translations Strings.resx (Portuguese) 2023-07-20 17:07:22 +02:00
Serge
bab99b0006 New translations Strings.resx (Polish) 2023-07-20 17:07:21 +02:00
Serge
cc8c87387a New translations Strings.resx (Korean) 2023-07-20 17:07:19 +02:00
Serge
0bc19a3eaa New translations Strings.resx (Italian) 2023-07-20 17:07:18 +02:00
Serge
716ee5ccf3 New translations Strings.resx (Hungarian) 2023-07-20 17:07:17 +02:00
Serge
8c03980dc9 New translations Strings.resx (German) 2023-07-20 17:07:16 +02:00
Serge
7d5056ac62 New translations Strings.resx (Spanish) 2023-07-20 17:07:15 +02:00
Serge
d2cb5173be New translations Strings.resx (French) 2023-07-20 17:07:14 +02:00
Serge
80d5117345 New translations Strings.resx (Romanian) 2023-07-20 17:07:13 +02:00
Serge
a516ee443d New translations Strings.resx (Lithuanian) 2023-07-20 17:07:13 +02:00
Serge
977208e883 Merge pull request #835 from IceStormNG/battery-health
Added battery health reading to below the battery charge limiter bar.
2023-07-20 16:43:46 +02:00
IceStormNG
fc53159a51 Battery health is now a tooltip similarly to the other tooltips. Is only refreshed once every 15 Minutes at most, and only if the user hovers over the battery panel. 2023-07-20 16:32:42 +02:00
Serge
8b29a89efa Merge pull request #833 from seerge/l10n_main
New Crowdin updates
2023-07-20 15:30:21 +02:00
IceStormNG
584bd155d6 Added battery health reading to below the battery charge limiter bar. 2023-07-20 14:52:17 +02:00
Serge
c81bd65bd5 New translations Strings.resx (German) 2023-07-20 14:48:23 +02:00
Serge
a4b44565ea Fan Scale multiplier 2023-07-20 13:25:44 +02:00
Serge
ca13de2e43 Merge pull request #828 from seerge/l10n_main
New Crowdin updates
2023-07-20 11:52:04 +02:00
Serge
9dbcab6b4e New translations Strings.resx (Spanish) 2023-07-20 10:15:25 +02:00
Serge
76df61092d New translations Strings.resx (French) 2023-07-20 01:38:52 +02:00
Serge
39039b4710 New translations Strings.resx (French) 2023-07-19 23:51:13 +02:00
Serge
acb3ba7589 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-19 23:43:28 +02:00
Serge
a97ab6dbc8 UI Tweaks 2023-07-19 23:43:26 +02:00
Serge
6be0222f31 Merge pull request #820 from seerge/l10n_main
New Crowdin updates
2023-07-19 22:09:03 +02:00
Serge
1a99771762 Merge pull request #826 from IceStormNG/clamshell-misdetection-nvidia
Prevent the Nvidia Advanced Optimimus "fake" display to be considered an external display.
2023-07-19 20:45:31 +02:00
IceStormNG
283814afa6 Prevent the Nvidia Advanced Optimimus "fake" display to be considered an external display. 2023-07-19 20:38:29 +02:00
Serge
3d81a889a8 New translations Strings.resx (Chinese Traditional) 2023-07-19 17:38:30 +02:00
Serge
a52724fe09 New translations Strings.resx (Ukrainian) 2023-07-19 17:38:29 +02:00
Serge
66839b4836 New translations Strings.resx (Lithuanian) 2023-07-19 17:38:28 +02:00
Serge
526baf41ea New translations Strings.resx (Ukrainian) 2023-07-19 16:20:32 +02:00
Serge
a90bb19f72 New translations Strings.resx (Polish) 2023-07-19 16:20:31 +02:00
Serge
3de3cb0f29 New translations Strings.resx (Italian) 2023-07-19 16:20:30 +02:00
Serge
b607561b14 New translations Strings.resx (German) 2023-07-19 16:20:29 +02:00
Serge
3045151789 New translations Strings.resx (Spanish) 2023-07-19 16:20:28 +02:00
Serge
e7a4537098 Cleanup 2023-07-19 16:17:05 +02:00
Serge
3b6f3488ea Merge pull request #818 from IceStormNG/fix-color-codes
Fixed: Keyboard color cannot be set to white anymore
2023-07-19 16:16:47 +02:00
Serge
19dad2a257 Merge pull request #819 from seerge/l10n_main
New Crowdin updates
2023-07-19 16:14:48 +02:00
Serge
d100b804c3 New translations Strings.resx (German) 2023-07-19 15:07:21 +02:00
Serge
b9aa3ab710 New translations Strings.resx (Spanish) 2023-07-19 15:07:20 +02:00
Serge
c7c25c988f New translations Strings.resx (Lithuanian) 2023-07-19 15:07:19 +02:00
IceStormNG
460e586d67 -1 is a valid color for ToARGB(). In this case it is pure white. Which is not usable anymore with those checks in place. 2023-07-19 14:36:35 +02:00
Serge
6ca5abe547 Merge pull request #816 from seerge/l10n_main
New Crowdin updates
2023-07-19 13:39:30 +02:00
Serge
cbc618c539 New translations Strings.resx (Vietnamese) 2023-07-19 13:18:58 +02:00
Serge
c8f3c99a08 New translations Strings.resx (Chinese Traditional) 2023-07-19 13:18:57 +02:00
Serge
9716bea53b New translations Strings.resx (Chinese Simplified) 2023-07-19 13:18:56 +02:00
Serge
46fec97a0a New translations Strings.resx (Ukrainian) 2023-07-19 13:18:56 +02:00
Serge
06d0ccc32f New translations Strings.resx (Turkish) 2023-07-19 13:18:55 +02:00
Serge
212598b2bc New translations Strings.resx (Portuguese) 2023-07-19 13:18:54 +02:00
Serge
bde2f7ff42 New translations Strings.resx (Polish) 2023-07-19 13:18:53 +02:00
Serge
d794efa4da New translations Strings.resx (Korean) 2023-07-19 13:18:52 +02:00
Serge
a8b2e5f75b New translations Strings.resx (Italian) 2023-07-19 13:18:51 +02:00
Serge
5b8d7a58b3 New translations Strings.resx (Hungarian) 2023-07-19 13:18:50 +02:00
Serge
fba5ad0819 New translations Strings.resx (German) 2023-07-19 13:18:49 +02:00
Serge
0aa5826cf6 New translations Strings.resx (Spanish) 2023-07-19 13:18:48 +02:00
Serge
c6d4ad32aa New translations Strings.resx (French) 2023-07-19 13:18:48 +02:00
Serge
e225c5fdf0 New translations Strings.resx (Romanian) 2023-07-19 13:18:47 +02:00
Serge
328ffcd3ae New translations Strings.resx (Lithuanian) 2023-07-19 13:18:46 +02:00
Serge
bb8d10986b Merge pull request #817 from IceStormNG/clamshell-detection
Automatic Clamshell Mode Toggle
2023-07-19 12:22:22 +02:00
Carsten Braun
595336288a Added automatic toggle for "Lid Action" when external display and power is connected to keep the laptop awake when lid is closed (known as Clamshell Mode). 2023-07-19 11:54:51 +02:00
Serge
3598f5dec8 Improved stop/disable service command 2023-07-19 11:38:06 +02:00
Serge
12da3288b3 New translations Strings.resx (Lithuanian) 2023-07-19 11:33:35 +02:00
Serge
2b8d82b58f AsusCert service fix 2023-07-19 00:31:32 +02:00
Serge
15ae5179f0 Merge pull request #813 from jadonclegg/brightnessControls
Added hotkeys for brightness control.
2023-07-19 00:19:23 +02:00
Jadon Clegg
a84e7c89e4 Merge branch 'seerge:main' into brightnessControls 2023-07-18 15:46:44 -06:00
jadon
9e91d76c97 Removed extra log call 2023-07-18 15:42:00 -06:00
jadon
97e1cd3372 Added hotkeys for using ctrl / shift + vol up / down to control screen / keyboard brightness. 2023-07-18 15:37:25 -06:00
Serge
97cb08a888 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-18 22:26:17 +02:00
Serge
21048b6aa1 Auto Init Aura 2023-07-18 22:26:15 +02:00
Serge
7d949786ba Update README.md 2023-07-18 22:25:54 +02:00
Serge
55664a7b95 Update README.md 2023-07-18 19:42:25 +02:00
Serge
74ff754e58 Update README.md 2023-07-18 19:37:56 +02:00
Serge
840c07b366 GA402X power limits 2023-07-18 19:36:49 +02:00
Serge
74e67f7a01 Added GA402XV to the list of devices that require fan curve for PPTs 2023-07-18 16:56:54 +02:00
Serge
9f5521bc52 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-18 15:47:55 +02:00
Serge
1b8de79667 Re-connect to GPU in fans+power 2023-07-18 15:47:53 +02:00
Serge
93936fb32a Merge pull request #806 from seerge/l10n_main
New Crowdin updates
2023-07-18 14:10:25 +02:00
Serge
7e1aef10d7 New translations Strings.resx (Chinese Traditional) 2023-07-18 13:33:05 +02:00
Serge
48ef9172f1 New translations Strings.resx (Chinese Simplified) 2023-07-18 13:33:04 +02:00
Serge
fdd5c3ccd6 New translations Strings.resx (Ukrainian) 2023-07-18 13:33:03 +02:00
Serge
3da3c163d3 Merge pull request #804 from seerge/l10n_main
New Crowdin updates
2023-07-18 12:59:03 +02:00
Serge
001ffbaa90 New translations Strings.resx (Romanian) 2023-07-18 12:35:32 +02:00
Serge
53a592a033 New translations Strings.resx (Hungarian) 2023-07-18 12:35:31 +02:00
Serge
1b2148da25 New translations Strings.resx (Vietnamese) 2023-07-18 12:35:30 +02:00
Serge
da4c08e09e New translations Strings.resx (Chinese Traditional) 2023-07-18 12:35:29 +02:00
Serge
ed86c588de New translations Strings.resx (Chinese Simplified) 2023-07-18 12:35:28 +02:00
Serge
6f310b01a1 New translations Strings.resx (Ukrainian) 2023-07-18 12:35:27 +02:00
Serge
94bf868271 New translations Strings.resx (Turkish) 2023-07-18 12:35:26 +02:00
Serge
2e7201fb37 New translations Strings.resx (Portuguese) 2023-07-18 12:35:25 +02:00
Serge
7172f5440a New translations Strings.resx (Polish) 2023-07-18 12:35:24 +02:00
Serge
f125493e96 New translations Strings.resx (Korean) 2023-07-18 12:35:23 +02:00
Serge
375a37f7d9 New translations Strings.resx (Italian) 2023-07-18 12:35:22 +02:00
Serge
8be1c62e32 New translations Strings.resx (German) 2023-07-18 12:35:21 +02:00
Serge
3eb0546874 New translations Strings.resx (Spanish) 2023-07-18 12:35:20 +02:00
Serge
78d02b9ed8 New translations Strings.resx (French) 2023-07-18 12:35:19 +02:00
Serge
b46e932a0d Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-18 12:33:32 +02:00
Serge
3ce473f78d Added battery charge readings (next to discharge) 2023-07-18 12:33:29 +02:00
Serge
9459778463 New translations Strings.resx (Korean) 2023-07-18 11:59:38 +02:00
Serge
19603d107f Update README.md 2023-07-17 19:24:08 +02:00
Serge
91a507b98d Merge pull request #797 from seerge/l10n_main
New Crowdin updates
2023-07-17 19:13:54 +02:00
Serge
231b90a295 New translations Strings.resx (Chinese Simplified) 2023-07-17 05:06:33 +02:00
Serge
0bd766302b Merge pull request #793 from seerge/l10n_main
New Crowdin updates
2023-07-16 23:44:22 +02:00
Serge
f9f1089d0e New translations Strings.resx (Chinese Traditional) 2023-07-16 18:52:26 +02:00
Serge
b9d7110935 New translations Strings.resx (Polish) 2023-07-16 18:52:26 +02:00
Serge
61716e7336 Merge pull request #792 from seerge/l10n_main
New Crowdin updates
2023-07-16 17:09:36 +02:00
Serge
fecf1cfece Hide UV warning 2023-07-16 17:08:29 +02:00
Serge
a31303624a Removed Undervolting sliders for not supported models 2023-07-16 17:04:15 +02:00
Serge
721aeb7e6a New translations Strings.resx (Romanian) 2023-07-16 14:57:41 +02:00
Serge
b0f2f018eb New translations Strings.resx (Hungarian) 2023-07-16 14:57:40 +02:00
Serge
aed3e3fe32 New translations Strings.resx (Vietnamese) 2023-07-16 14:57:39 +02:00
Serge
1e2e1ddcfb New translations Strings.resx (Chinese Traditional) 2023-07-16 14:57:38 +02:00
Serge
fa33c7f514 New translations Strings.resx (Chinese Simplified) 2023-07-16 14:57:38 +02:00
Serge
13248d18bf New translations Strings.resx (Ukrainian) 2023-07-16 14:57:37 +02:00
Serge
545f584d0d New translations Strings.resx (Turkish) 2023-07-16 14:57:36 +02:00
Serge
86af2535d2 New translations Strings.resx (Portuguese) 2023-07-16 14:57:35 +02:00
Serge
c172654044 New translations Strings.resx (Polish) 2023-07-16 14:57:34 +02:00
Serge
6be351aba3 New translations Strings.resx (Korean) 2023-07-16 14:57:33 +02:00
Serge
443a8a34d4 New translations Strings.resx (Italian) 2023-07-16 14:57:32 +02:00
Serge
ebc63e8b5f New translations Strings.resx (German) 2023-07-16 14:57:31 +02:00
Serge
9638b1468a New translations Strings.resx (Spanish) 2023-07-16 14:57:30 +02:00
Serge
51b1f0ced5 New translations Strings.resx (French) 2023-07-16 14:57:29 +02:00
Serge
e593fa3a76 ScreenPad brightness control 2023-07-16 14:48:21 +02:00
Serge
f419cb8eed Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-15 20:13:02 +02:00
Serge
0ecca82652 Internal screen detection 2023-07-15 20:13:00 +02:00
Serge
5cf10a4aab Merge pull request #784 from seerge/l10n_main
New Crowdin updates
2023-07-15 13:13:41 +02:00
Serge
152a4e04c5 Brightness hotkeys fix 2023-07-15 13:11:38 +02:00
Serge
39d9f9b465 New translations Strings.resx (Chinese Simplified) 2023-07-15 04:20:27 +02:00
Serge
4167096617 New translations Strings.resx (Polish) 2023-07-15 01:37:10 +02:00
Serge
4d8c2b5f6a New translations Strings.resx (Polish) 2023-07-15 00:20:17 +02:00
Serge
e5f0d77d05 Added keyboard backlight init on every startup / wake up 2023-07-14 17:17:06 +02:00
Serge
01d9b6edf4 Removed GU603 from manual mode list 2023-07-14 16:56:50 +02:00
Serge
0aea639baf Fixed services count button / colors 2023-07-14 14:45:33 +02:00
Serge
5cbf292996 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-14 13:16:28 +02:00
Serge
a6c9f01f46 UI Fixes 2023-07-14 13:16:26 +02:00
Serge
d91a9229e5 Merge pull request #777 from seerge/l10n_main
New Crowdin updates
2023-07-14 12:47:51 +02:00
Serge
a77f859441 New translations Strings.resx (Chinese Simplified) 2023-07-14 10:35:02 +02:00
Serge
e2b2035b08 New translations Strings.resx (Italian) 2023-07-13 23:51:42 +02:00
Serge
837d2ab38e F11 fix 2023-07-13 22:42:36 +02:00
Serge
3ffcc53b58 Version bump 2023-07-13 21:20:56 +02:00
Serge
b538a919ae UI Tweaks 2023-07-13 21:13:18 +02:00
Serge
dece8159d8 Merge pull request #774 from seerge/l10n_main
New Crowdin updates
2023-07-13 15:19:39 +02:00
Serge
edc9dbf77f Improved Screen detection 2023-07-13 15:02:33 +02:00
Serge
9bdd7ef321 New translations Strings.resx (Hungarian) 2023-07-13 14:02:11 +02:00
Serge
a7d9327175 New translations Strings.resx (Polish) 2023-07-13 14:02:10 +02:00
Serge
084e257e90 New translations Strings.resx (Hungarian) 2023-07-13 13:06:20 +02:00
Serge
8623c78f60 New translations Strings.resx (Italian) 2023-07-13 13:06:19 +02:00
Serge
f1bb689842 New translations Strings.resx (Italian) 2023-07-13 11:54:12 +02:00
Serge
2f85b19a2d Merge pull request #770 from seerge/l10n_main
New Crowdin updates
2023-07-13 11:06:26 +02:00
Serge
5ace593833 New translations Strings.resx (Italian) 2023-07-13 10:30:59 +02:00
Serge
f4862c3703 New translations Strings.resx (Vietnamese) 2023-07-13 03:26:53 +02:00
Serge
8299a87130 New translations Strings.resx (Polish) 2023-07-13 02:24:54 +02:00
Serge
be2043d539 New translations Strings.resx (Romanian) 2023-07-13 01:29:00 +02:00
Serge
562a92e6bb New translations Strings.resx (Polish) 2023-07-13 01:28:59 +02:00
Serge
4485fabb4d Merge pull request #767 from seerge/l10n_main
New Crowdin updates
2023-07-13 00:49:52 +02:00
Serge
b13a736643 New translations Strings.resx (Italian) 2023-07-13 00:19:29 +02:00
Serge
97f45810c9 New translations Strings.resx (Hungarian) 2023-07-12 21:08:49 +02:00
Serge
9e89b3f52b New translations Strings.resx (Hungarian) 2023-07-12 20:06:03 +02:00
Serge
45a64f6d2e New translations Strings.resx (Romanian) 2023-07-12 18:16:13 +02:00
Serge
deff61aaa4 New translations Strings.resx (Ukrainian) 2023-07-12 18:16:12 +02:00
Serge
4409a980a4 New translations Strings.resx (Romanian) 2023-07-12 16:43:22 +02:00
Serge
5b30c10e91 New translations Strings.resx (Chinese Simplified) 2023-07-12 14:46:59 +02:00
Serge
03667973d9 New translations Strings.resx (Polish) 2023-07-12 14:46:58 +02:00
Serge
ac4254393b New translations Strings.resx (Italian) 2023-07-12 14:46:57 +02:00
Serge
fc2a7b2b94 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-12 14:17:44 +02:00
Serge
b8782f264b UI tweaks 2023-07-12 14:17:42 +02:00
Serge
66082eee9f Merge pull request #762 from seerge/l10n_main
New Crowdin updates
2023-07-12 13:48:47 +02:00
Serge
6b52f9e8d1 New translations Strings.resx (Hungarian) 2023-07-12 13:14:40 +02:00
Serge
2f62801cd7 New translations Strings.resx (Polish) 2023-07-12 13:14:40 +02:00
Serge
767f943020 New translations Strings.resx (Polish) 2023-07-12 12:13:04 +02:00
Serge
cd9754190b New translations Strings.resx (Chinese Traditional) 2023-07-12 09:49:01 +02:00
Serge
32e366f1f6 New translations Strings.resx (Chinese Traditional) 2023-07-12 08:51:33 +02:00
Serge
964a630c81 New translations Strings.resx (Chinese Simplified) 2023-07-12 08:51:32 +02:00
Serge
06cdef6b7e New translations Strings.resx (Chinese Simplified) 2023-07-12 07:50:21 +02:00
Serge
1b70bf416c New translations Strings.resx (Chinese Simplified) 2023-07-12 06:16:14 +02:00
Serge
678169ecf1 New translations Strings.resx (Chinese Simplified) 2023-07-12 05:19:13 +02:00
Serge
b1fcbed100 New translations Strings.resx (Chinese Simplified) 2023-07-12 04:04:29 +02:00
Serge
c41bc3bc20 New translations Strings.resx (Chinese Traditional) 2023-07-12 03:06:56 +02:00
Serge
4ce72f3bb3 New translations Strings.resx (Italian) 2023-07-12 00:12:32 +02:00
Serge
7866b10c6d Merge pull request #761 from seerge/l10n_main
New Crowdin updates
2023-07-12 00:07:14 +02:00
Serge
720771a64c New translations Strings.resx (Italian) 2023-07-11 22:56:57 +02:00
Serge
1d381855ba New translations Strings.resx (Italian) 2023-07-11 21:50:39 +02:00
Serge
ae4a452123 Merge pull request #760 from seerge/l10n_main
New Crowdin updates
2023-07-11 20:56:14 +02:00
Serge
ce1680618b New translations Strings.resx (Vietnamese) 2023-07-11 20:55:35 +02:00
Serge
de633936fd New translations Strings.resx (Chinese Traditional) 2023-07-11 20:55:34 +02:00
Serge
0821ef5e5a New translations Strings.resx (Chinese Simplified) 2023-07-11 20:55:33 +02:00
Serge
e3f6127877 New translations Strings.resx (Ukrainian) 2023-07-11 20:55:32 +02:00
Serge
33f32d182c New translations Strings.resx (Turkish) 2023-07-11 20:55:31 +02:00
Serge
db875cac09 New translations Strings.resx (Portuguese) 2023-07-11 20:55:30 +02:00
Serge
5c7bd327c3 New translations Strings.resx (Polish) 2023-07-11 20:55:29 +02:00
Serge
f8c4750682 New translations Strings.resx (Korean) 2023-07-11 20:55:28 +02:00
Serge
1125b0dc4e New translations Strings.resx (Italian) 2023-07-11 20:55:27 +02:00
Serge
47a6162012 New translations Strings.resx (German) 2023-07-11 20:55:27 +02:00
Serge
2a603c7a00 New translations Strings.resx (Spanish) 2023-07-11 20:55:26 +02:00
Serge
5d83c2109c New translations Strings.resx (French) 2023-07-11 20:55:24 +02:00
Serge
9cdcdb7b15 Translations 2023-07-11 20:55:13 +02:00
Serge
229a8e1848 Merge pull request #758 from seerge/l10n_main
New Crowdin updates
2023-07-11 18:56:46 +02:00
Serge
838c9c476e Merge branch 'main' into l10n_main 2023-07-11 18:56:41 +02:00
Serge
3cc36435f0 New translations Strings.resx (Portuguese) 2023-07-11 18:48:38 +02:00
Serge
9e43558298 New translations Strings.resx (Polish) 2023-07-11 18:48:37 +02:00
Serge
8f7e696a3b New translations Strings.resx (Italian) 2023-07-11 18:48:36 +02:00
Serge
1451412dfb New translations Strings.resx (German) 2023-07-11 18:48:35 +02:00
Serge
06519ad986 New translations Strings.resx (Spanish) 2023-07-11 18:48:34 +02:00
Serge
f1c9b41de2 New translations Strings.resx (French) 2023-07-11 18:48:33 +02:00
Serge
1887e5a4b1 New translations Strings.resx (Vietnamese) 2023-07-11 18:41:12 +02:00
Serge
db21159385 New translations Strings.resx (Chinese Traditional) 2023-07-11 18:41:11 +02:00
Serge
7ba74f7b76 New translations Strings.resx (Chinese Simplified) 2023-07-11 18:41:10 +02:00
Serge
a2289c63a6 New translations Strings.resx (Ukrainian) 2023-07-11 18:41:09 +02:00
Serge
2e90a954f0 New translations Strings.resx (Turkish) 2023-07-11 18:41:08 +02:00
Serge
cab1d625ff New translations Strings.resx (Portuguese) 2023-07-11 18:41:07 +02:00
Serge
fbd136f74b New translations Strings.resx (Polish) 2023-07-11 18:41:06 +02:00
Serge
06404d24d9 New translations Strings.resx (Korean) 2023-07-11 18:41:05 +02:00
Serge
8db210b2e0 New translations Strings.resx (Italian) 2023-07-11 18:41:04 +02:00
Serge
1f99a6152c New translations Strings.resx (German) 2023-07-11 18:41:02 +02:00
Serge
9bbbb02ae0 New translations Strings.resx (Spanish) 2023-07-11 18:41:01 +02:00
Serge
5a5498367e New translations Strings.resx (French) 2023-07-11 18:41:00 +02:00
Serge
597723024f Translations 2023-07-11 18:40:46 +02:00
Serge
32a76d0280 New translations Strings.resx (Vietnamese) 2023-07-11 18:26:17 +02:00
Serge
7ad41d2548 New translations Strings.resx (Chinese Traditional) 2023-07-11 18:26:16 +02:00
Serge
a9c8c31461 New translations Strings.resx (Chinese Simplified) 2023-07-11 18:26:15 +02:00
Serge
d465d24333 New translations Strings.resx (Ukrainian) 2023-07-11 18:26:14 +02:00
Serge
decbf6216b New translations Strings.resx (Turkish) 2023-07-11 18:26:13 +02:00
Serge
ab82b66667 New translations Strings.resx (Portuguese) 2023-07-11 18:26:12 +02:00
Serge
8530fadd14 New translations Strings.resx (Polish) 2023-07-11 18:26:11 +02:00
Serge
c26e722411 New translations Strings.resx (Korean) 2023-07-11 18:26:10 +02:00
Serge
957e57f05a New translations Strings.resx (Italian) 2023-07-11 18:26:09 +02:00
Serge
fc1fe4399d New translations Strings.resx (German) 2023-07-11 18:26:08 +02:00
Serge
bed6485b76 New translations Strings.resx (Spanish) 2023-07-11 18:26:07 +02:00
Serge
bc0d769703 New translations Strings.resx (French) 2023-07-11 18:26:06 +02:00
Serge
d96b97dafd New translations Strings.resx (Portuguese, Brazilian) 2023-07-11 18:21:50 +02:00
Serge
0724550f0e New translations Strings.resx (Vietnamese) 2023-07-11 18:21:49 +02:00
Serge
14fb7efd85 New translations Strings.resx (Chinese Traditional) 2023-07-11 18:21:49 +02:00
Serge
bd2a8ad5f5 New translations Strings.resx (Chinese Simplified) 2023-07-11 18:21:48 +02:00
Serge
074f9ffa70 New translations Strings.resx (Ukrainian) 2023-07-11 18:21:47 +02:00
Serge
ed123947b0 New translations Strings.resx (Turkish) 2023-07-11 18:21:46 +02:00
Serge
c0d410cd33 New translations Strings.resx (Polish) 2023-07-11 18:21:45 +02:00
Serge
34cf810804 New translations Strings.resx (Korean) 2023-07-11 18:21:44 +02:00
Serge
79a6a6348e New translations Strings.resx (Italian) 2023-07-11 18:21:43 +02:00
Serge
ea5414d050 New translations Strings.resx (German) 2023-07-11 18:21:42 +02:00
Serge
ec427ab7a5 New translations Strings.resx (Spanish) 2023-07-11 18:21:41 +02:00
Serge
e7a8f21b16 New translations Strings.resx (French) 2023-07-11 18:21:40 +02:00
Serge
a4c8105218 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-11 18:20:57 +02:00
Serge
9a80e488fa UI Tweaks 2023-07-11 18:20:56 +02:00
Serge
38271ae318 New translations Strings.resx (Portuguese, Brazilian) 2023-07-11 18:19:14 +02:00
Serge
a3c02c0509 New translations Strings.resx (Vietnamese) 2023-07-11 18:19:13 +02:00
Serge
cb38e89569 New translations Strings.resx (Ukrainian) 2023-07-11 18:19:11 +02:00
Serge
d1c696be66 New translations Strings.resx (Turkish) 2023-07-11 18:19:10 +02:00
Serge
a5aa93a93b New translations Strings.resx (Polish) 2023-07-11 18:19:09 +02:00
Serge
2ad7403bf1 New translations Strings.resx (Korean) 2023-07-11 18:19:08 +02:00
Serge
3c0443b2fb New translations Strings.resx (Italian) 2023-07-11 18:19:08 +02:00
Serge
03dea7df17 New translations Strings.resx (German) 2023-07-11 18:19:07 +02:00
Serge
7075ae8e49 New translations Strings.resx (Spanish) 2023-07-11 18:19:06 +02:00
Serge
06b1506aa6 New translations Strings.resx (French) 2023-07-11 18:19:05 +02:00
Serge
078a3dfb55 Update Crowdin configuration file 2023-07-11 18:18:31 +02:00
Serge
a12f27df9c New translations Strings.resx (Portuguese, Brazilian) 2023-07-11 18:15:33 +02:00
Serge
b29a03e90c New translations Strings.resx (Vietnamese) 2023-07-11 18:15:32 +02:00
Serge
45c92fc0cc New translations Strings.resx (Chinese Traditional) 2023-07-11 18:15:31 +02:00
Serge
ad3e79389c New translations Strings.resx (Chinese Simplified) 2023-07-11 18:15:30 +02:00
Serge
39d8b5b8c0 New translations Strings.resx (Ukrainian) 2023-07-11 18:15:29 +02:00
Serge
703b81ed76 New translations Strings.resx (Turkish) 2023-07-11 18:15:29 +02:00
Serge
d5c3e61cb9 New translations Strings.resx (Polish) 2023-07-11 18:15:28 +02:00
Serge
0b2da9dbfc New translations Strings.resx (Korean) 2023-07-11 18:15:27 +02:00
Serge
2fc1c4413a New translations Strings.resx (Italian) 2023-07-11 18:15:26 +02:00
Serge
5048e3e7d4 New translations Strings.resx (German) 2023-07-11 18:15:25 +02:00
Serge
1e49d89397 New translations Strings.resx (Spanish) 2023-07-11 18:15:24 +02:00
Serge
f1ad319149 New translations Strings.resx (French) 2023-07-11 18:15:23 +02:00
Serge
c00d9aa56c Update Crowdin configuration file 2023-07-11 18:15:08 +02:00
Serge
949148ca16 Update README.md 2023-07-11 13:35:35 +02:00
Serge
f01b763cd3 UI Tweaks 2023-07-11 13:18:35 +02:00
Serge
8a03b221e9 Resources Cleanup 2023-07-11 13:07:48 +02:00
Serge
1d642a106b Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-11 00:05:17 +02:00
Serge
ebf4025578 Backlight label 2023-07-11 00:05:15 +02:00
Serge
36e8e91b16 UI Tweaks 2023-07-11 00:02:11 +02:00
Serge
5b6a62cf52 Merge pull request #750 from marcelomijas/main
Update Spanish translation
2023-07-09 21:52:24 +02:00
Marcelo Moreno
8eb3eaf3cf Update Spanish tanslation 2023-07-09 20:21:34 +02:00
Serge
dec26ca85b Translation Updates 2023-07-09 15:11:41 +02:00
Serge
00132f50c4 Merge pull request #746 from Constrat/it-transl
Added first Italian translation
2023-07-09 13:24:14 +02:00
David
04f62b3359 fix: english translation typos / errors 2023-07-09 12:17:12 +02:00
David
d13307164e Final REV 2023-07-09 12:05:04 +02:00
David
ba8f3489a2 Added first Italian translation
Some senteces might be too long for the UI. Not really sure.
2023-07-08 23:04:53 +02:00
Serge
e0cca33ab9 Extended MicMute support 2023-07-08 22:13:35 +02:00
Serge
c5cd747a63 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-06 20:03:39 +02:00
Serge
2942f17bca Fixed backlight controls for FN-Lock and Optimization Service 2023-07-06 20:03:37 +02:00
Serge
bfff7101fc Update README.md 2023-07-06 16:43:42 +02:00
Serge
bb5aeba9e7 Fix for GA402XI 2023-07-05 17:15:47 +02:00
Serge
2d4e794084 Added option to disable tablet mode switch in config 2023-07-05 14:55:52 +02:00
Serge
5f1c926527 Keyboard listener retry 2023-07-04 23:07:55 +02:00
Serge
dc40b317f8 Default temp limit 2023-07-04 16:47:44 +02:00
Serge
db595d54f6 Init Limit 2023-07-04 10:56:24 +02:00
Serge
2c317d9a18 More logs 2023-07-03 21:11:03 +02:00
Serge
1e26696eb6 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-03 20:56:16 +02:00
Serge
feff220a9b Adjust power modes only when needed 2023-07-03 20:56:14 +02:00
Serge
a05c47a05c Update README.md 2023-07-03 20:55:23 +02:00
Serge
5b08bfbe92 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-03 18:18:48 +02:00
Serge
606f43380b Minor fixes 2023-07-03 18:18:46 +02:00
Serge
657e09adb0 Update README.md 2023-07-02 21:48:59 +02:00
Serge
188c566097 Update SECURITY.md 2023-07-01 23:07:04 +02:00
Serge
828a1cd13c Update README.md 2023-07-01 20:16:12 +02:00
Serge
c69d3b7c1c Update README.md 2023-07-01 13:48:58 +02:00
Serge
767865ab19 Merge branch 'main' of https://github.com/seerge/g-helper 2023-07-01 11:46:48 +02:00
Serge
ec7350cf5c Optimized mode switch from Ultimate 2023-07-01 11:46:46 +02:00
Serge
d33813b50d Merge pull request #702 from IceStormNG/german-translation
Updated German translation
2023-06-30 15:10:33 +02:00
Carsten Braun
d803b1eede Correction to not cut off text 2023-06-30 15:06:23 +02:00
Carsten Braun
81b73517df Translated the latest changes to German 2023-06-30 14:59:56 +02:00
IceStormNG
dbbf8b4016 Merge branch 'seerge:main' into german-translation 2023-06-30 14:47:40 +02:00
Serge
c4adb1eb8b Cleanup 2023-06-30 14:30:50 +02:00
Serge
dea2b73d7f Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-29 18:18:44 +02:00
Serge
3fb61d3bf1 X13 tweaks 2023-06-29 18:18:42 +02:00
Serge
b83d8d35a4 Update README.md 2023-06-28 19:25:01 +02:00
Serge
8a3708e850 Cleanup 2023-06-28 10:59:53 +02:00
Serge
0e728ccc64 Reset UV 2023-06-27 16:10:00 +02:00
Serge
1a12162ba1 Re-apply temp-limit 2023-06-27 13:42:06 +02:00
Serge
5b5cd0e97a Check for Optimus only on AMD CPU models 2023-06-26 23:29:28 +02:00
Serge
1167d6c380 GPU and Screen Controls 2023-06-26 19:27:50 +02:00
Serge
d0d44c3ef1 More cleanup 2023-06-26 16:46:15 +02:00
Serge
164d417b06 Cleanup 2023-06-25 13:58:17 +02:00
Serge
e1acea9ad9 Merge pull request #673 from marcelomijas/main
Update Spanish translation
2023-06-24 20:27:31 +02:00
Marcelo Moreno
083b74e739 Update Spanish translation
And also... I just learned how to compile with VS... so I expect less "Spanish translation fix" commits.

Little by little :')
2023-06-24 19:55:29 +02:00
Serge
1413fce8f1 Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-24 16:22:45 +02:00
Serge
666dea9bfd GPU apps stopping fix 2023-06-24 16:22:43 +02:00
Serge
41bccc3a56 Update README.md 2023-06-24 15:12:33 +02:00
Serge
976ca50e50 Update README.md 2023-06-24 14:52:43 +02:00
Serge
81b6a6d61c Update README.md 2023-06-24 14:49:46 +02:00
Serge
7f6bdda39a Stop GPU apps button 2023-06-24 13:08:06 +02:00
Serge
96dc22072a UI tweaks 2023-06-24 11:32:59 +02:00
Serge
3c02d5cd95 Optimus check 2023-06-23 19:37:51 +02:00
Serge
e58a396cbd CPU power limits for old devices 2023-06-22 15:53:35 +02:00
IceStormNG
ba9a290ad0 Merge branch 'seerge:main' into german-translation 2023-06-21 20:43:58 +02:00
Serge
40ecdf0d35 Max GPU core/memory config settings 2023-06-20 16:20:14 +02:00
Serge
f31b05dcd1 Aura cleanup 2023-06-20 13:48:32 +02:00
Serge
d778838ad4 Release script 2023-06-19 16:15:33 +02:00
Serge
b177dacf8b Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-19 13:53:09 +02:00
Serge
6e9cc51a5f G15 Advantage Edition TDP 2023-06-19 13:53:07 +02:00
IceStormNG
58fd6650db Merge branch 'seerge:main' into german-translation 2023-06-19 07:18:15 +02:00
Serge
e2a6b770a0 Update README.md 2023-06-18 17:32:16 +02:00
Serge
055e83e976 Default temp fix 2023-06-18 15:28:52 +02:00
Serge
40be93b60d UV/Temp reset fix 2023-06-18 15:23:29 +02:00
Serge
2c2eed4fe2 Temp limit and update checker 2023-06-18 14:59:37 +02:00
Serge
8d6b277fda Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-17 13:24:16 +02:00
Serge
d3de136dd3 Exception handling 2023-06-17 12:32:58 +02:00
Serge
8e6f54e833 Update README.md 2023-06-17 10:39:06 +02:00
Serge
0b030da41b Undervolting 2023-06-17 10:32:30 +02:00
IceStormNG
4d0bc74179 Merge branch 'seerge:main' into german-translation 2023-06-16 23:15:30 +02:00
Serge
05aae069b4 Update README.md 2023-06-15 12:29:44 +02:00
Serge
28e949bee4 Power modes fix 2023-06-15 12:21:48 +02:00
Serge
9a82a54b04 Verion bump 2023-06-15 00:14:08 +02:00
Serge
8aff60546a UI Fixes 2023-06-15 00:09:00 +02:00
Serge Samusya
d5039207ec Rog Ally Aura support 2023-06-15 00:04:33 +02:00
Carsten Braun
66316d3016 Translated additional strings 2023-06-14 17:36:40 +02:00
Serge
f940d343c3 Translations update 2023-06-14 09:19:17 +02:00
Serge
1848612434 UI Tweaks 2023-06-14 09:17:45 +02:00
Serge
fe253de0e1 Merge pull request #618 from weslleykawan/patch-2
(PT-BR) Translation Update 2 (Strings.pt-br.resx)
2023-06-14 09:16:52 +02:00
Weslley K
7211fd5f22 (PT-BR) Translation Update 2 (Strings.pt-br.resx)
- Resolved previous translation issues

- Updated:
 
 <data name="AutoRefreshTooltip" xml:space="preserve">
    <value>Menor taxa de atualização quando estiver na bateria</value>
  </data>

  <data name="MinRefreshTooltip" xml:space="preserve">
    <value>Taxa de atualização à 60Hz para economizar bateria</value>
  </data>

  <data name="MaxRefreshTooltip" xml:space="preserve">
    <value>Taxa de atualização máxima e menor latência</value>
  </data>

Please offer a version so I can test if everything is working as it should.

I want to be part of the PT-BR translation of this project from now on.
2023-06-13 20:33:58 -03:00
Serge
c1a8eb12f9 Merge pull request #616 from weslleykawan/patch-1
(PT-BR) Translation update (Strings.pt-br.resx)
2023-06-13 16:51:24 +02:00
Weslley K
0477d03ecc (PT-BR) Translation update (Strings.pt-br.resx)
Added/updated strings:

    <data name="VolumeDown" xml:space="preserve">
    <value>Abaixar o volume</value>
  </data>

  <data name="VolumeUp" xml:space="preserve">
    <value>Aumentar o volume</value>
  </data>

    <data name="VolumeMute" xml:space="preserve">
    <value>Silenciar microfone</value>
  </data>

  <data name="WindowTop" xml:space="preserve">
    <value>Manter a janela do aplicativo sempre no topo</value>
  </data>

   <data name="Updates" xml:space="preserve">
    <value>Atualizações</value>
  </data>

    <data name="FnLock" xml:space="preserve">
    <value>Processar teclas de atalho Fn+F sem pressionar Fn</value>
  </data>

   <data name="KillGpuApps" xml:space="preserve">
    <value>Parar todos os aplicativos que usam a GPU ao alternar para o modo Eco</value>
  </data>

  <data name="Boot" xml:space="preserve">
    <value>Ao ligar</value>
  </data>

  <data name="Brightness" xml:space="preserve">
    <value>Nível do brilho</value>
  </data>

  <data name="BacklightTimeout" xml:space="preserve">
    <value>Tempo limite da iluminação na bateria (em segundos)</value>
  </data>

    <data name="BacklightTimeoutPlugged" xml:space="preserve">
    <value>Tempo limite da iluminação carregando (0 - sempre ligado)</value>
  </data>

  <data name="LaptopBacklight" xml:space="preserve">
    <value>Configurações de iluminação</value>
  </data>

  <data name="ApplyWindowsPowerPlan" xml:space="preserve">
    <value>Ajuste automático dos modos de energia do Windows</value>
  </data>

    <data name="AsusServicesRunning" xml:space="preserve">
    <value>Serviços da Asus em execução</value>
  </data>

<data name="Start" xml:space="preserve">
    <value>Iniciar</value>
  </data>
  <data name="StartingServices" xml:space="preserve">
    <value>Iniciando os serviços</value>
  </data>
  <data name="StartupError" xml:space="preserve">
    <value>Erro de inicialização</value>
  </data>
  <data name="Stop" xml:space="preserve">
    <value>Parar</value>
  </data>
  <data name="StoppingServices" xml:space="preserve">
    <value>Parando os serviços</value>
  </data>
2023-06-13 10:30:31 -03:00
Serge
e923d82732 Update README.md 2023-06-13 12:34:11 +02:00
Serge
6558d66e8d Update README.md 2023-06-13 12:21:21 +02:00
Serge
ec8605dfe6 UI Fixes 2023-06-13 00:54:11 +02:00
Serge
ac462b628f Driver updater fix, new turbo boost modes 2023-06-12 19:07:57 +02:00
Serge
1cd9c30c4a UI Tweaks 2023-06-12 14:41:47 +02:00
Serge
c575b17aba UI Tweaks 2023-06-11 23:32:13 +02:00
Serge
d2e0e6f51e Colors for custom modes 2023-06-11 17:09:17 +02:00
Serge
0dae1c9115 Custom mode renaming 2023-06-11 14:50:01 +02:00
Serge
16e085d9f1 Custom modes 2023-06-11 00:27:58 +02:00
Serge
6b04ffa172 Version bump 2023-06-09 21:55:47 +02:00
Serge
15e4310016 Clock fix 2023-06-09 21:53:31 +02:00
Serge
3abe924525 Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-09 21:29:02 +02:00
Serge
691f187b7d Improved backlight sync with optimization service 2023-06-09 21:28:59 +02:00
Serge
8e4c0dada7 Update README.md 2023-06-09 15:44:13 +02:00
Serge
f535818fb0 Update README.md 2023-06-09 14:14:21 +02:00
Serge
ce75d2c778 Update README.md 2023-06-09 12:45:08 +02:00
Serge
c755213472 Merge pull request #573 from hellotale/patch-2
Update and fix Korean translation
2023-06-08 14:57:01 +02:00
hellotale
60e8712131 Update and rename Strings.kr.resx to Strings.ko.resx 2023-06-08 21:30:24 +09:00
Serge
2c817b46ef Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-08 13:20:28 +02:00
Serge
e16f612311 Driver updater fix 2023-06-08 13:20:26 +02:00
Serge
4ce4b4bbf7 Update README.md 2023-06-08 12:03:13 +02:00
Serge
f9303ced8a Merge pull request #570 from marcelomijas/main
Spanish translation fix for "Updates" + more
2023-06-08 11:55:28 +02:00
Serge
f000a03395 Update README.md 2023-06-08 11:51:30 +02:00
Marcelo Moreno
90205e9231 Start/stop Spanish translation 2023-06-08 11:51:26 +02:00
Marcelo Moreno
e65270c961 Spanish translation fix for "Updates" 2023-06-08 11:34:13 +02:00
Serge
306dfe2bd7 XGM button fix 2023-06-08 11:17:06 +02:00
Serge
ca7dfff357 Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-07 22:52:05 +02:00
Serge
59288b9422 Integrated debloater 2023-06-07 22:52:04 +02:00
Serge
46ff8deb44 Merge pull request #558 from marcelomijas/main
Update Spanish translation
2023-06-07 22:21:51 +02:00
Marcelo Moreno
e6e8877531 Update Spanish translation 2023-06-07 21:48:57 +02:00
Serge
b13306b989 Added brightness control to M-hotkeys 2023-06-07 16:34:40 +02:00
Serge
838dc039ac Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-07 15:16:34 +02:00
Serge
0702f95e0c Driver Updater improvements 2023-06-07 15:16:32 +02:00
Serge
f42fcf2f73 Merge pull request #554 from hellotale/patch-1
Add Korean translation
2023-06-07 12:07:15 +02:00
hellotale
6a7e1ddaa3 Add Korean translation 2023-06-07 16:25:57 +09:00
Serge
57ffcb8c7f Added manual mode config flag 2023-06-06 22:54:08 +02:00
Serge
5425bd0128 Color Profiles 2023-06-06 22:06:45 +02:00
Serge
328cd8f9f1 Minor refactoring 2023-06-06 13:17:13 +02:00
Serge
38739ca8f6 CPU power limits 2023-06-06 11:38:11 +02:00
Serge
a3e235e886 Added PPT fix for M16, G17 (2023) and F15 (2022) 2023-06-06 10:59:49 +02:00
Serge
678f4b0eb7 UI tweaks 2023-06-05 22:32:50 +02:00
Serge
4bbfbd0382 Driver Updates 2023-06-05 17:31:59 +02:00
Serge
4c8291c74b S15 fix 2023-06-05 11:49:56 +02:00
Serge
e9060ad8c0 Update README.md 2023-06-04 23:29:42 +02:00
Serge
f26585e73c Version bump 2023-06-04 23:21:29 +02:00
Serge
9f7da4c20a GPU Section UI fixes 2023-06-04 23:20:37 +02:00
Serge
eff45c1485 Curve editor fix 2023-06-04 23:09:56 +02:00
Serge
be6e5e8f23 Varibright control 2023-06-04 17:21:31 +02:00
Serge
17083eef21 Check for optimization service before setting backlight 2023-06-04 12:18:51 +02:00
Serge
d5b098335b Kill GPU apps for AMD, Optimus fix 2023-06-04 01:25:39 +02:00
Serge
acb2efdd00 Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-03 22:17:48 +02:00
Serge
92fa210898 UI tweaks 2023-06-03 22:17:46 +02:00
Serge
6dd4e07efe Merge pull request #527 from marcelomijas/main
Update Spanish translation
2023-06-03 18:07:41 +02:00
Marcelo Moreno
ae6972db76 Update Spanish translation
- Translation for the new Fn+F without Fn feature.
- Translation for the Fn-Lock toggle.
- Update backlight timeout translation.
2023-06-03 18:03:42 +02:00
Serge
b3f7b1027f Merge pull request #524 from lswlc33/patch-3
upadte translate
2023-06-03 14:31:22 +02:00
雪中明月
8929daa604 upadte translate 2023-06-03 20:24:13 +08:00
Serge
eb522214f0 UI Tweaks 2023-06-02 21:25:18 +02:00
Serge
1222377c33 Update README.zh-CN.md 2023-06-02 21:14:32 +02:00
Serge
933f07d666 Update README.md 2023-06-02 21:14:02 +02:00
Serge
8f95f6a1bb Update README.md 2023-06-02 21:13:12 +02:00
Serge
f2c32b2e9a Add files via upload 2023-06-02 21:11:05 +02:00
Serge
ddb591b79a Backlight fixes 2023-06-02 14:06:12 +02:00
Serge
65b4192393 Backlight fixes 2023-06-02 13:37:43 +02:00
Serge
846cc6e867 Autoupdate fix 2023-06-02 13:16:09 +02:00
Serge
ddac5a23be Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-02 12:57:11 +02:00
Serge
4f6db4ae0a Save backlight levels per battery / power 2023-06-02 12:57:09 +02:00
Serge
14dd96dee3 Merge pull request #507 from Hoangdus/main
Improve Vietnamese Translation.
2023-06-02 11:54:27 +02:00
Hoangdus
79ff24bbb7 Fix a small translation error 2023-06-02 03:50:19 +07:00
Hoangdus
b715bd0391 Improve Vietnamese Translation 2023-06-02 03:10:36 +07:00
Serge
b97a06eb56 Merge branch 'main' of https://github.com/seerge/g-helper 2023-06-01 20:07:53 +02:00
Serge
e69845e858 Added FN+C binding for Fn-Lock 2023-06-01 20:07:51 +02:00
Serge
b832ba6e8b Update README.md 2023-06-01 17:34:39 +02:00
Serge
314d25c751 Backlight fix 2023-06-01 15:24:51 +02:00
Serge
b52163949c Auto brightness tweak 2023-06-01 15:18:41 +02:00
Serge
f0ee2b8aac Fn-lock support for optimization service 2023-06-01 14:32:29 +02:00
Serge
1603f625ed FN-Lock support for case when optimization service is running 2023-06-01 14:19:43 +02:00
Serge
8f66006791 Fn-lock tweaks 2023-06-01 12:52:35 +02:00
Serge
39387041fe UI fixes 2023-05-31 17:41:24 +02:00
Serge
400b2cd6cb FN-lock 2023-05-31 17:33:53 +02:00
Serge
b20442e61f Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-31 17:23:54 +02:00
Serge
6d219511fc FN-Lock preparations 2023-05-31 17:23:52 +02:00
Serge
2282820453 Merge pull request #491 from marcelomijas/main
Spanish translation small fix
2023-05-31 11:51:11 +02:00
Marcelo Moreno
d4fcfe8895 Spanish translation small fix
Added translations for keyboard backlight timeout but they were too large... This is a shorter translation.
2023-05-31 11:36:13 +02:00
Serge
8eb923a703 PPT labels 2023-05-30 22:43:42 +02:00
Serge
59548be543 PPT UI tweaks 2023-05-30 21:35:21 +02:00
Serge
1596ce84e8 PPT labels fixes 2023-05-30 18:58:44 +02:00
Serge
f670b9e0dc Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-30 14:55:52 +02:00
Serge
52c2987c88 UI tweaks 2023-05-30 14:55:50 +02:00
Serge
c9aa910035 Merge pull request #485 from marcelomijas/main
Update Spanish translation
2023-05-30 12:19:58 +02:00
Marcelo Moreno
22f648a23f Update Spanish translation 2023-05-30 12:18:31 +02:00
Serge
9255a8554d Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-30 00:33:27 +02:00
Serge
859f4f55c3 GPU sliders fix 2023-05-30 00:33:24 +02:00
Serge
7e3872939b Update README.md 2023-05-29 23:54:59 +02:00
Serge
2556583451 Update README.md 2023-05-29 23:53:19 +02:00
Serge
20e7d220e5 Added APU slider 2023-05-29 22:07:08 +02:00
Serge
2f5543ce84 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-29 19:39:00 +02:00
Serge
4c55e16f2e UI tweaks 2023-05-29 19:38:57 +02:00
Serge
30544e74d7 Update README.md 2023-05-29 19:18:25 +02:00
Serge
f5925accb3 Merge pull request #475 from MDowski/patch-2
Update to Polish translation
2023-05-29 15:31:29 +02:00
MD
842ea2a92d Update to Polish translation
Tweaks in declination and words shortening.
2023-05-29 14:58:37 +02:00
Serge
1ca97bd3f4 Updated translations 2023-05-29 14:36:55 +02:00
Serge
8a1dd9f137 Bumped version number 2023-05-29 13:15:54 +02:00
Serge
325f16cf55 Added optimization service to debloat.bat 2023-05-29 13:15:23 +02:00
Serge
42cc1bdb98 Added option to stop all GPU apps before setting Eco 2023-05-29 12:16:19 +02:00
Serge
83a2d1dc9f Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-28 21:43:26 +02:00
Serge
3aae223b15 Added Ctr+Shif+F12 binding to toggle app window 2023-05-28 21:43:24 +02:00
Serge
b22d2f8ceb Update README.md 2023-05-28 21:26:05 +02:00
Serge
2041861a14 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-28 16:09:46 +02:00
Serge
dfc3c0e515 UI tweaks 2023-05-28 16:09:44 +02:00
Serge
796ec34284 Update README.md 2023-05-28 14:06:12 +02:00
Serge
50894a59d3 USB adjustment 2023-05-28 12:15:43 +02:00
Serge
1472004d4b Backlight timeouts 2023-05-28 12:02:29 +02:00
Serge
36c42ed05f Merge pull request #468 from etylix/main
Add Vietnamese translations
2023-05-28 11:45:04 +02:00
Hoang Pham Anh Duy
66220351f1 Add Vietnamese translations 2023-05-28 16:40:49 +07:00
Serge
8f2c8842e0 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-27 22:44:55 +02:00
Serge
1cda822820 Backlight control fix 2023-05-27 22:44:54 +02:00
Serge
2afba74dd5 Update README.md 2023-05-26 11:52:29 +02:00
Serge
e69f9d1014 Update README.md 2023-05-26 11:48:13 +02:00
Serge
47d96aca61 Keybinding fix 2023-05-25 13:30:33 +02:00
Serge
f36fb6ca55 Hide GPU fans from UI if they don't exist in system 2023-05-24 23:47:08 +02:00
Serge
e765b4f037 Tweaks and fixes 2023-05-24 14:34:43 +02:00
Serge
f395c706f6 UI tweaks 2023-05-23 20:49:56 +02:00
Serge
444fdcdd97 Backlight fix 2023-05-23 15:27:00 +02:00
Serge
b874900393 French language fixes 2023-05-23 11:14:03 +02:00
Serge
05aad0f1ad Matrix tweaks 2023-05-23 10:58:27 +02:00
Serge
a34cc1cb03 Animatrix clock fix 2023-05-22 21:57:21 +02:00
Serge
8c557344db Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-22 17:57:08 +02:00
Serge
5b2a4cb065 UI tweaks 2023-05-22 17:57:06 +02:00
Serge
51bcad8bbe Merge pull request #434 from marcelomijas/main
Spanish translation of new key functions
2023-05-22 16:26:13 +02:00
Marcelo Moreno
125aa44e6c Spanish translation of new key functions 2023-05-22 16:21:58 +02:00
Serge
9e6ca7c2e2 Bumped version to 0.67 2023-05-22 16:15:24 +02:00
Serge
252cc9d868 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-22 13:31:03 +02:00
Serge
0b03b62a2d Extended support for Z13 external keyboard 2023-05-22 13:31:01 +02:00
Serge
ff7a5463d6 Update README.md 2023-05-22 11:44:10 +02:00
Serge
5134aaca9d Native brightness OSD 2023-05-22 11:18:57 +02:00
Serge
2a5c2e02ac Anime matrix fix 2023-05-21 21:23:55 +02:00
Serge
80e3971dad m1,m2 bindings 2023-05-21 20:44:04 +02:00
Serge
ac60986646 Sleep Fix 2023-05-21 19:19:26 +02:00
Serge
1e0169a71d Added M1/M2 keys and keyboard init 2023-05-21 19:01:43 +02:00
Serge
e0346a8af8 UI Tweaks 2023-05-21 18:06:41 +02:00
Serge
4ee97fdbc4 XGM Fixes 2023-05-21 17:42:15 +02:00
Serge
34075b67d4 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-21 12:27:54 +02:00
Serge
4ed9675d99 Refactoring 2023-05-21 12:27:52 +02:00
Serge
af3538e105 Update README.md 2023-05-21 00:24:57 +02:00
Serge
d818405e04 Bumped version to 0.65 2023-05-20 23:14:15 +02:00
Serge
9794229f3f Extra icons for OSD 2023-05-20 22:59:17 +02:00
Serge
9f56959c67 Some OSD notifications 2023-05-20 21:51:02 +02:00
Serge
09e6676b7c Merge pull request #418 from marcelomijas/main
Update Spanish translation
2023-05-20 20:51:57 +02:00
Serge
6adb2e2fcf Keyboard Reading 2023-05-20 20:50:58 +02:00
Marcelo Moreno
08cc4409a9 Update Spanish translation 2023-05-20 20:37:54 +02:00
Serge
1ac0f2be08 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-20 14:28:08 +02:00
Serge
05e66d3b95 Tweaks 2023-05-20 14:28:05 +02:00
Serge
0f8f1e9ce5 Merge pull request #300 from tbateson/main
Add GitHub workflows
2023-05-20 11:51:42 +02:00
Thomas Bateson
d37b46c588 Add GitHub workflows 2023-05-19 13:32:31 -05:00
Serge
020a7d074f Some renamings 2023-05-19 19:14:07 +02:00
Serge
7eb7cc9f78 UI tweaks 2023-05-19 16:09:27 +02:00
Serge
38d60e88ea Fixed anime matrix crash 2023-05-19 13:46:49 +02:00
Serge
0cc16765b6 Update README.md 2023-05-19 11:27:24 +02:00
Serge
96f705806b Update README.md 2023-05-19 11:17:27 +02:00
Serge
d1cceda2ab UI Tweaks 2023-05-19 10:40:16 +02:00
Serge
381b4dd3e8 Merge pull request #409 from TomBonnot/main
Adding French and Português Version
2023-05-19 00:16:11 +02:00
Tom Bonnot
a99dcbf445 Last changes on portuguese-brazilian version + deleting .idea files 2023-05-18 18:12:44 -04:00
Tom Bonnot
4751383a3a Saving progress on pt-br translation 2023-05-18 15:50:32 -04:00
Serge
06320afcb3 Audio visualizer 2023-05-18 18:21:09 +02:00
Serge
0eb6209eda Matrix audio visualizer 2023-05-18 17:42:19 +02:00
Tom Bonnot
a342cab9a6 Final version for French translation 2023-05-18 11:40:02 -04:00
Tom Bonnot
12c6482f61 Adding pt-br and completion of fr version (might need some corrections) 2023-05-18 10:30:05 -04:00
Tom Bonnot
20933bfd8d First commit - French version 2023-05-18 09:51:30 -04:00
Serge
c66c8e9030 Custom keybinding for mode toggle 2023-05-17 20:33:41 +02:00
Serge
14b677514b Update README.md 2023-05-17 17:17:13 +02:00
Serge
ce266ffe07 Merge pull request #402 from IceStormNG/german-translation
German translation
2023-05-17 16:51:04 +02:00
Serge
f29410fa2a Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-17 14:52:09 +02:00
Serge
7117b58746 ACPI events listener 2023-05-17 14:52:06 +02:00
Carsten Braun
0456fa013c Improbed a few translations and fixed typos. 2023-05-17 13:11:11 +02:00
Carsten Braun
6a4aa4e138 Localize fan speed labels in the main window 2023-05-17 10:47:41 +02:00
IceStormNG
d75067b40c Merge branch 'seerge:main' into german-translation 2023-05-17 10:39:02 +02:00
Carsten Braun
de45038911 Translated the App to German. Added a few additional resources for localization 2023-05-16 16:20:00 +02:00
Serge
e23c727e79 Update README.md 2023-05-16 15:44:30 +02:00
Serge
2f2c534278 Merge pull request #394 from lswlc33/main
Update Strings.zh-CN.resx
2023-05-16 15:21:34 +02:00
Serge
bdbec79aba UI tweaks 2023-05-16 15:19:53 +02:00
雪中明月
e3d0a04fa4 Update Strings.zh-CN.resx 2023-05-16 21:12:58 +08:00
Serge
4dd7d41cf4 Merge pull request #392 from IceStormNG/windows-power-plan-changes-optional
Windows power plan changes optional
2023-05-16 14:53:58 +02:00
Carsten Braun
8370217cef This is not a perf config but a regular config value. 2023-05-16 13:34:40 +02:00
Carsten Braun
63c1829edd We can reference the checkbox directly 2023-05-16 13:34:26 +02:00
Carsten Braun
69e5a0448e Accomodate for non-exitent settings value 2023-05-16 13:30:08 +02:00
Carsten Braun
b74b9ae257 Fix nullability 2023-05-16 13:29:48 +02:00
Carsten Braun
71e007d8ad Fixed UI that VS Forms Designer broke 2023-05-16 13:29:31 +02:00
Carsten Braun
6896166c3c Fixed French translation value 2023-05-16 12:36:26 +02:00
Carsten Braun
fd89d9c13a Changed string to "Power Mode" instead of "power plan" 2023-05-16 12:33:15 +02:00
Carsten Braun
8bec153da8 Fixed localization key for french 2023-05-16 12:30:57 +02:00
Carsten Braun
7d968f5f08 Do not set default value. 2023-05-16 12:24:06 +02:00
Carsten Braun
ac5fc3f96e Revert "Revert "Adjustment of Windows Power Overlay is now optional""
This reverts commit 8804d19567.
2023-05-16 12:21:28 +02:00
Serge
8590d0301a Merge pull request #391 from seerge/revert-385-windows-power-plan-changes-optional
Revert "Adjustment of Windows Power Overlay is now optional"
2023-05-16 11:39:41 +02:00
Serge
8804d19567 Revert "Adjustment of Windows Power Overlay is now optional" 2023-05-16 11:38:17 +02:00
Serge
57ce0631a3 Merge pull request #385 from IceStormNG/windows-power-plan-changes-optional
Adjustment of Windows Power Overlay is now optional
2023-05-16 11:30:41 +02:00
Carsten Braun
b796f9f9d4 Moved checkbox to 2023-05-16 10:41:02 +02:00
Serge
f39563fcdf Added touchpad toggle for tablet mode on x13/x16 2023-05-15 23:59:21 +02:00
Serge
853d0c231d Auto update 2023-05-15 22:23:16 +02:00
Serge
df3324d641 Auto update 2023-05-15 22:21:41 +02:00
Serge
75c90ee155 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-15 22:11:29 +02:00
Serge
4015e0a7f7 Added auto-update checker 2023-05-15 22:11:27 +02:00
Carsten Braun
2a82e41894 Adjustment of Windows Power Overlay is now optional 2023-05-15 13:23:20 +02:00
Serge
a5541dfe10 Update README.md 2023-05-14 19:52:02 +02:00
Serge
fd3a139c47 Aura tweaks 2023-05-14 10:28:48 +02:00
Serge
608b8571d4 Fix for turkish keyboard, tweak for default fan curves 2023-05-13 22:13:00 +02:00
Serge
82a39bcfa1 Merge pull request #375 from IceStormNG/animematrix-for-GU604
Supports AniMeMatrix for Zephyrus M16 2023 (GU604)
2023-05-13 18:24:37 +02:00
Carsten Braun
f9ccd92dc6 Supports AniMeMatrix for Zephyrus M16 2023 (GU604) 2023-05-13 18:10:18 +02:00
Serge
1fadc6c31e Hotfix for possible crash 2023-05-13 09:43:26 +02:00
Serge
0b7dd42a5d UI tweak 2023-05-12 17:21:04 +02:00
Serge
51cd700e25 Improved GPU restart 2023-05-12 15:51:57 +02:00
Serge
7484253007 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-12 14:06:19 +02:00
Serge
f5cf768017 Display workaround 2023-05-12 14:06:15 +02:00
Serge
ca57669596 NV Clocks tweaks 2023-05-11 19:38:53 +02:00
Serge
35f1a3a25b Clock tweak 2023-05-11 11:18:42 +02:00
Serge
b7afe94b8d Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-11 10:52:41 +02:00
Serge
97c97e8e19 Eco tweaks 2023-05-11 10:52:40 +02:00
Serge
ffc5a6f641 Update README.md 2023-05-11 00:40:30 +02:00
Serge
f87e6c5c88 Update README.md 2023-05-11 00:39:07 +02:00
Serge
22f136fe9e Crash fix 2023-05-11 00:35:03 +02:00
Serge
6d85376734 Extra logs 2023-05-10 23:24:54 +02:00
Serge
62512a7c05 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-10 18:38:51 +02:00
Serge
7a6301328c GPU Restart 2023-05-10 18:38:49 +02:00
Serge
3c6c4d122d Update README.md 2023-05-10 15:31:20 +02:00
Serge
0142c25929 Overclocking logic, added restart-gpu workaround 2023-05-10 14:06:33 +02:00
Serge
27bc7339d8 Merge pull request #351 from marcelomijas/main
Update Spanish translation
2023-05-09 22:11:44 +02:00
Marcelo Moreno
2985fe378c Small fix... 2023-05-09 22:09:36 +02:00
Marcelo Moreno
71daba25a8 Update Spanish translation
Update the Spanish translation file so it has the same fields as the original "Strings.resx", and translated the new items. :)
2023-05-09 22:01:09 +02:00
Serge
16feeb05a1 Clocks fixes 2023-05-09 18:21:07 +02:00
Serge
c69bf65c84 Clocks fixes 2023-05-09 18:02:59 +02:00
Serge
56ea434626 Aura fix 2023-05-09 17:16:10 +02:00
Serge
432508cfc5 GPU settings tweaks 2023-05-09 16:51:15 +02:00
Serge
deb515066d Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-09 16:13:40 +02:00
Serge
ac19a822f7 GPU eco check 2023-05-09 16:13:35 +02:00
Serge
41caaefc97 Improved aura logging 2023-05-09 16:05:57 +02:00
Serge
a4488fa93b GPU Settings will be saved and auto-applied for each mode 2023-05-09 14:29:52 +02:00
Serge
57c893ef77 XGMobile backlight control 2023-05-08 19:33:49 +02:00
Serge
07020c3561 Extra aura control 2023-05-08 11:00:41 +02:00
Serge
ea134b640b Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-08 10:39:11 +02:00
Serge
5c3f1259f6 Extra Backlight control 2023-05-08 10:39:09 +02:00
Serge
09fd4e4a13 Update README.md 2023-05-08 09:58:36 +02:00
Serge
31c48eb998 Update README.md 2023-05-07 21:12:38 +02:00
Serge
0c1f216853 Update README.md 2023-05-07 20:54:07 +02:00
Serge
83dc491b64 Update README.md 2023-05-07 19:42:52 +02:00
Serge
a75d1ad604 Eco mode overclocking fix 2023-05-07 18:12:15 +02:00
Serge
88f466103e Eco mode overclocking fix 2023-05-07 18:10:18 +02:00
Serge
efb9b73ff5 Anime matrix clock fix 2023-05-07 12:14:49 +02:00
Serge
2c4bdb87aa Typo fix 2023-05-07 11:53:22 +02:00
Serge
832f13d8e4 UI tweaks 2023-05-07 11:17:45 +02:00
Serge
479572e39d Startup admin restarter 2023-05-07 00:24:47 +02:00
Serge
460267aac7 GPU overclocking fixes 2023-05-07 00:14:26 +02:00
Serge
e71c8e32ef GPU boost / temp limits control 2023-05-06 19:12:50 +02:00
Serge
6fe6492df3 GPU clocks tweaks 2023-05-06 18:17:37 +02:00
Serge
c61f4d1608 Experimental GPU overclock 2023-05-06 14:40:52 +02:00
Serge
8e1099545a Overdrive fix 2023-05-05 12:35:55 +02:00
Serge
7740678cd4 Added on/off control for aura lightbar, lid and logo 2023-05-05 11:44:33 +02:00
Serge
c6faec9628 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-04 13:55:50 +02:00
Serge
3a5c4de9b6 Context menu 2023-05-04 13:55:49 +02:00
Serge
f90fec24b9 Update README.md 2023-05-03 19:56:58 +02:00
Serge
240537dbd4 Merge pull request #315 from marcelomijas/main
Added Spanish translation for new options
2023-05-03 19:56:17 +02:00
Marcelo Moreno
cc3c16cdf1 Added Spanish translation for new options
Added Spanish translation for the new options:
- dGPU off in Optimized mode when on USB-charger.
- Minilled related options.
2023-05-03 19:19:17 +02:00
Serge
a7c662a0d4 Merge branch 'main' of https://github.com/seerge/g-helper 2023-05-03 18:18:44 +02:00
Serge
b0958cb2fc Translations fix 2023-05-03 18:18:42 +02:00
Serge
29f27ed4d6 Update README.md 2023-05-03 18:07:31 +02:00
Serge
801096299b Anime matrix tweaks 2023-05-03 17:53:21 +02:00
Serge
5ed1de0fcf Added option to keep dGPU off on usb-c 2023-05-03 16:49:12 +02:00
Serge
0ec0a382e9 Merge 2023-05-01 15:13:15 +02:00
Serge
e810adb358 Added Screen Toggle feature for M3 button 2023-05-01 15:12:08 +02:00
Serge
dc6c94fe4a Merge pull request #305 from sklynic/main
Minor update of zh-CN translation
2023-05-01 12:04:24 +02:00
sklynic
8479c129ff Update translation of zh-CN 2023-05-01 17:58:47 +08:00
Serge
3173c2e688 Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-27 10:14:15 +02:00
Serge
730ba0a2f9 Matrix logging 2023-04-27 10:14:13 +02:00
Serge
d26a83287d Update README.md 2023-04-22 22:42:11 +02:00
Serge
47deb669d1 UI tweaks 2023-04-22 00:09:22 +02:00
Serge
a30f5d801b UI tweaks 2023-04-21 23:32:02 +02:00
Serge
75f4b9f2c5 Update README.md 2023-04-21 16:19:26 +02:00
Serge
2289f36ba5 Create FUNDING.yml 2023-04-21 16:13:27 +02:00
Serge
6322e25e78 Merge pull request #279 from marcelomijas/main
Spanish translation fix for v0.55
2023-04-21 15:01:10 +02:00
seerge
62c0147548 - 2023-04-21 14:59:19 +02:00
seerge
9bd2688da2 UI tweaks 2023-04-21 14:59:06 +02:00
Marcelo Moreno
9649814085 Add files via upload 2023-04-21 14:46:03 +02:00
seerge
1ebc2021f6 KB Brightness control for TUF models 2023-04-20 14:53:37 +02:00
seerge
52b165f250 Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-19 17:42:01 +02:00
seerge
b2ed390bdf XGMobile support 2023-04-19 17:41:59 +02:00
Serge
1588f84c97 Update README.md 2023-04-19 16:46:28 +02:00
seerge
a3a2fdfe14 Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-18 17:50:12 +02:00
seerge
2c867eb960 UI tweaks 2023-04-18 17:50:10 +02:00
Serge
6fbf4f2a49 Merge pull request #258 from lswlc33/main
Update Strings.zh-CN.resx
2023-04-16 19:01:35 +02:00
Serge
d4ecb2bcf3 Merge pull request #259 from lswlc33/patch-2
Update README.zh-CN.md
2023-04-16 19:01:26 +02:00
雪中明月
c70c6ef4d6 Update README.zh-CN.md 2023-04-16 21:30:14 +08:00
雪中明月
5d77d5c700 Update Strings.zh-CN.resx 2023-04-16 21:23:01 +08:00
seerge
89f096778d Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-16 13:55:03 +02:00
seerge
2b9fc913ad TUF keyboard adjustment 2023-04-16 13:55:01 +02:00
Serge
4acbf5adf1 Merge pull request #256 from lswlc33/main
update readme.md's language switch button
2023-04-16 13:03:47 +02:00
seerge
48ea1b588f Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-16 13:01:36 +02:00
seerge
cb15161fc4 Warning label when custom fan profile is not supported 2023-04-16 13:01:34 +02:00
雪中明月
d95a612788 Update README.md 2023-04-16 18:55:46 +08:00
雪中明月
0a724926ee update readme.md's language switch button 2023-04-16 10:50:20 +00:00
Serge
353ed998db Update README.md 2023-04-16 11:44:23 +02:00
seerge
0afee18f20 Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-15 20:12:35 +02:00
seerge
8154883d49 It's fine 2023-04-15 20:12:33 +02:00
Serge
feb4198c0f Merge pull request #250 from marcelomijas/main
"Keyboard backlight" extra options Spanish translation fix
2023-04-15 19:48:25 +02:00
Marcelo Moreno
6edf2d9447 Add files via upload 2023-04-15 19:42:51 +02:00
seerge
25f0af1103 AdjustAllLevels fixes 2023-04-15 16:02:07 +02:00
Serge
4f9cc4a94e Merge pull request #237 from hungqbui/main
Add fan levels auto-adjust
2023-04-15 01:12:15 +02:00
Serge
e973f09f4e Update README.md 2023-04-15 01:11:40 +02:00
Serge
cd0662e11f Update README.md 2023-04-14 17:58:09 +02:00
seerge
ee43af2824 Clock fix for devices with low DPI 2023-04-14 17:50:26 +02:00
Serge
d620ca010c Update README.md 2023-04-13 21:10:57 +02:00
seerge
6bd77ab45b UI tweaks 2023-04-13 18:53:14 +02:00
Hung Bui
99a490996d Fix OutOfBounds error, and correct variables name 2023-04-13 11:23:56 -05:00
seerge
096ea3b8e9 Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-13 18:01:29 +02:00
Serge
5f10f5b1e8 Update README.md 2023-04-13 19:25:58 +02:00
seerge
36219383ce UI tweaks 2023-04-13 18:01:27 +02:00
seerge
78862c6558 Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-13 17:21:27 +02:00
Serge
b53a46bb3b Update README.md 2023-04-13 18:21:28 +02:00
seerge
15a681af3b G513 fix 2023-04-13 17:21:25 +02:00
Serge
6341ec7d34 Update README.md 2023-04-13 11:37:31 +02:00
Hung Bui
596c47d371 Add fan levels auto-adjust 2023-04-12 19:07:53 -05:00
seerge
7ff8fec35c Fix for zw-TW translation 2023-04-12 21:51:11 +02:00
seerge
b96185222c Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-12 14:40:47 +02:00
seerge
3346bd5f0e Fans tip fix 2023-04-12 14:40:45 +02:00
Serge
34404feb5b Update bug_report.md 2023-04-12 13:06:07 +02:00
seerge
552bc1020d Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-12 12:05:59 +02:00
seerge
6d0bb5bef7 Boost dropdown fix 2023-04-12 12:05:57 +02:00
Serge
00d80ce7a9 Update bug_report.md 2023-04-12 11:19:52 +02:00
seerge
08e1ed54cd Added fix for Traditional Chinese 2023-04-11 23:25:46 +02:00
seerge
97a22c59f7 - 2023-04-11 22:46:13 +02:00
seerge
d2aa5e9c42 UI tweaks 2023-04-11 22:40:13 +02:00
seerge
2cb0ffab4b Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-11 22:30:19 +02:00
seerge
e3cb2bb4a1 Minor tweaks 2023-04-11 22:30:17 +02:00
Serge
5a734c00c1 Update README.zh-CN.md 2023-04-11 22:19:03 +02:00
Serge
d85ec73a27 Update README.zh-CN.md 2023-04-11 22:18:17 +02:00
Serge
4b9eb99870 Merge pull request #223 from marcelomijas/main
Spanish translation length fix
2023-04-11 21:15:31 +02:00
Marcelo Moreno
c9b939b876 Add files via upload 2023-04-11 20:57:06 +02:00
seerge
9562f77c6f Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-11 19:42:47 +02:00
seerge
7120d2a009 GPU usage tweak 2023-04-11 19:42:44 +02:00
Serge
4fa4295748 Update README.md 2023-04-11 19:31:35 +02:00
Serge
23f28a8ce5 Update README.md 2023-04-11 19:29:47 +02:00
Serge
a94321df04 Merge pull request #221 from sklynic/main
Added zh-CN translation for README and minor edit
2023-04-11 19:25:18 +02:00
sklynic
9917f5543c Synchronized translation for readme 2023-04-12 01:20:40 +08:00
sklynic
78367727ae Merge branch 'seerge:main' into main 2023-04-12 01:14:12 +08:00
Serge
32b83d724d Update README.md 2023-04-11 19:13:41 +02:00
Serge
77b420483d Update README.md 2023-04-11 19:12:46 +02:00
sklynic
9b7842a5e9 Added zh-CN for readme and minor edit 2023-04-12 01:11:45 +08:00
seerge
bee7f35475 Custom Power schemes support 2023-04-11 18:50:12 +02:00
seerge
2daf1f5434 Translations - es 2023-04-11 16:43:07 +02:00
Serge
e979bf708f Merge pull request #219 from marcelomijas/main
Spanish translation
2023-04-11 16:42:09 +02:00
Marcelo Moreno
4d60b1f36d Spanish translation 2023-04-11 16:26:28 +02:00
Serge
8a7c35c7cc Merge pull request #218 from hkaancaliskan/patch-1
Turkish language support
2023-04-11 14:12:40 +02:00
hkaancaliskan
2ecdcd196d pass 2 for turkish 2023-04-11 14:44:00 +03:00
hkaancaliskan
fdd2373b37 first pass for turkish 2023-04-11 14:39:05 +03:00
seerge
ca7ed6c7e9 - 2023-04-11 12:39:48 +02:00
seerge
0cad6bd7a9 Translations 2023-04-11 12:39:31 +02:00
Serge
4545eac93d Merge pull request #217 from lswlc33/main
Improve Chinese translation
2023-04-11 12:36:45 +02:00
Serge
c43e4937d6 Update README.md 2023-04-11 12:33:29 +02:00
雪中明月
e74d730f0c Update Strings.zh.resx 2023-04-11 13:12:36 +08:00
lswlc33
676da38b5f Improve Chinese translation 2023-04-11 09:56:23 +08:00
seerge
b3563e0857 Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-11 01:25:41 +02:00
seerge
b2a01a8bdc Translations 2023-04-11 01:25:39 +02:00
Serge
74fd05d048 Update bug_report.md 2023-04-10 18:42:48 +02:00
Serge
12dc05c5b9 Delete custom.md 2023-04-10 18:41:53 +02:00
seerge
e82dab5e7c Fix for FX507 models 2023-04-09 15:24:09 +02:00
seerge
602dfea1a6 - 2023-04-09 12:26:38 +02:00
seerge
c13a6e9ded Custom keybinds for performance modes 2023-04-09 12:14:47 +02:00
seerge
e11027963f UI tweaks 2023-04-08 13:45:27 +02:00
seerge
9d2b8b506e Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-07 13:37:02 +02:00
seerge
988c9e11dd Theme change fix 2023-04-07 13:37:00 +02:00
Serge
2c6bb32e4a Update README.md 2023-04-07 12:10:19 +02:00
Serge
e33a0d05ed Update README.md 2023-04-07 12:06:11 +02:00
Serge
1c283766aa Update README.md 2023-04-06 23:41:08 +02:00
Serge
f2ef6d197f Update README.md 2023-04-06 14:31:51 +02:00
seerge
13ec0f8911 GPU use simplified for now 2023-04-06 12:19:32 +02:00
seerge
fcf213f1a0 - 2023-04-06 00:02:17 +02:00
seerge
c73b4fce97 Added NVidia GPU usage 2023-04-05 20:25:05 +02:00
seerge
aab1e08729 IsUsedGPU fix 2023-04-05 19:59:10 +02:00
seerge
cf3a84aa3d Added GPU usage check 2023-04-05 19:33:53 +02:00
seerge
8d119b386d - 2023-04-05 13:02:02 +02:00
seerge
0605e63433 UI tweaks 2023-04-04 16:36:26 +02:00
seerge
4634404ed4 Fans + power ui simplification 2023-04-03 21:17:16 +02:00
seerge
dcfaf665cd Force GPU mode 2023-04-02 22:50:13 +02:00
seerge
15e791cbfd Merge branch 'main' of https://github.com/seerge/g-helper 2023-04-02 11:57:01 +02:00
seerge
5d86c821f6 Minor fixes 2023-04-02 11:56:59 +02:00
Serge
e5de404e5c Update README.md 2023-04-01 17:48:46 +02:00
Serge
13aa98e954 Update README.md 2023-04-01 17:40:36 +02:00
seerge
75c397d7a4 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-31 23:08:06 +02:00
seerge
0ad8efdb7d GPU temp reading 2023-03-31 23:08:04 +02:00
Serge
2064f29433 Update README.md 2023-03-31 23:07:43 +02:00
seerge
890c50d90e Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-31 20:05:16 +02:00
seerge
bd207113f8 Fix for possible fan issues on old laptops 2023-03-31 20:05:14 +02:00
Serge
650a5ff5c0 Update bug_report.md 2023-03-31 17:29:57 +02:00
Serge
01ce91a474 Update bug_report.md 2023-03-31 15:58:28 +02:00
seerge
253e1eb095 Added Strix/Scar built in aura modes 2023-03-31 13:50:10 +02:00
seerge
b95768d547 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-31 11:45:48 +02:00
seerge
dfbfd16d23 Clock fix 2023-03-31 11:45:46 +02:00
Serge
3eeac0353a Update README.md 2023-03-30 22:03:21 +02:00
Serge
5e7c9a4191 Update README.md 2023-03-30 21:56:59 +02:00
seerge
ee84ba6304 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-30 21:10:36 +02:00
seerge
d15c6cb073 Improved logging 2023-03-30 21:10:35 +02:00
Serge
1e683a0884 Update README.md 2023-03-30 15:00:04 +02:00
Serge
1ad48bf763 Update README.md 2023-03-30 13:54:53 +02:00
Serge
dcc052a574 Update README.md 2023-03-30 13:54:40 +02:00
Serge
38fca560df Update README.md 2023-03-30 12:14:29 +02:00
seerge
7e0459bd44 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-30 11:57:13 +02:00
seerge
228ad70b8d UI tweaks 2023-03-30 11:57:11 +02:00
Serge
b42e565cd6 Update README.md 2023-03-30 11:53:54 +02:00
Serge
e021d59737 Update README.md 2023-03-30 11:20:50 +02:00
Serge
dba7967ad5 Update README.md 2023-03-30 11:12:24 +02:00
seerge
a7a7170676 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-30 00:00:22 +02:00
seerge
1d43ca3ce4 Max fan RPM auto calibration 2023-03-30 00:00:20 +02:00
Serge
ff7618f16f Update README.md 2023-03-29 23:33:14 +02:00
seerge
bb947bf8bf Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-29 23:32:14 +02:00
seerge
63092d8415 Removed unsupported aura modes for some models 2023-03-29 23:32:12 +02:00
Serge
6fbce2f495 Update README.md 2023-03-29 21:06:36 +02:00
seerge
8d89a04608 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-29 17:51:28 +02:00
seerge
0cbc48d526 Added old cpu temp reading as fallback 2023-03-29 17:51:25 +02:00
Serge
81013ca0be Update README.md 2023-03-29 17:32:07 +02:00
seerge
af2509fc17 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-29 17:04:24 +02:00
seerge
136b5b4f55 Added native temp sensors, brightness controll, etc 2023-03-29 17:04:22 +02:00
Serge
4e2abff942 Update README.md 2023-03-29 13:58:03 +02:00
Serge
2c8a11fc24 Update README.md 2023-03-29 12:26:19 +02:00
seerge
8af8823ee4 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-29 12:19:02 +02:00
seerge
ec0a1b710e New slider 2023-03-29 12:19:00 +02:00
Serge
2ac2e84161 Update README.md 2023-03-28 22:09:06 +02:00
seerge
14dc1741f7 New battery slider 2023-03-28 20:11:30 +02:00
seerge
fbed195194 - 2023-03-28 16:35:20 +02:00
seerge
0d002edf65 Animatrix fix for 2020/2021 models 2023-03-28 16:05:24 +02:00
seerge
28a17562a8 CPU boost per mode 2023-03-28 14:19:51 +02:00
seerge
583cb677d0 Added option to disable screen overdrive 2023-03-27 15:21:52 +02:00
seerge
1888fe7bd9 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-27 14:28:31 +02:00
seerge
089b339e61 Minor tweaks 2023-03-27 14:28:28 +02:00
Serge
cab4a04339 Update README.md 2023-03-27 13:02:14 +02:00
seerge
7ab3b450cd Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-26 19:31:43 +02:00
seerge
ea2dc7b75d Animatrix tweaks 2023-03-26 19:31:41 +02:00
Serge
ccd69a8628 Update README.md 2023-03-26 14:40:12 +02:00
Serge
c1d23159a0 Update debloat.bat 2023-03-26 14:17:53 +02:00
Serge
1c865624e6 Update debloat.bat 2023-03-26 14:06:13 +02:00
seerge
4853c09c2c Added model name, and custom fan+ in profile names 2023-03-25 20:28:27 +01:00
seerge
08704d6826 Added sleep/awake/boot/shutdown control for keyboards 2023-03-25 16:21:47 +01:00
seerge
6edbcf5ecd Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-25 14:37:40 +01:00
seerge
7702dc8e38 Support for TUF RGB keyboards and other fixes 2023-03-25 14:37:37 +01:00
Serge
94391358ef Update README.md 2023-03-25 09:49:48 +01:00
Serge
feecd193ac Update README.md 2023-03-25 01:14:34 +01:00
Serge
444f7c76f0 Update README.md 2023-03-24 21:19:14 +01:00
Serge
701423fa0e Update README.md 2023-03-24 17:29:29 +01:00
Serge
7b3a6d319b Update README.md 2023-03-24 12:52:14 +01:00
seerge
8bc9325b3f Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-24 11:20:51 +01:00
seerge
64195c5082 Prevent multiple auto-applies when windows calls power event too often 2023-03-24 11:20:48 +01:00
Serge
2297532323 Update README.md 2023-03-23 22:17:47 +01:00
Serge
daac8b0a45 Update README.md 2023-03-23 22:16:25 +01:00
Serge
f061e3f43a Update README.md 2023-03-23 22:14:29 +01:00
seerge
85e02549f1 Update checker fixes 2023-03-23 20:04:25 +01:00
seerge
9053764930 Speedup update checker 2023-03-23 13:26:09 +01:00
seerge
64871e5554 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-23 00:38:06 +01:00
seerge
b1c778b30d Minor tweaks 2023-03-23 00:38:03 +01:00
Serge
6932bb1889 Update README.md 2023-03-22 17:55:10 +01:00
seerge
c90a342ce8 Fixed possible memory leack with clock ticks 2023-03-22 17:28:09 +01:00
seerge
f223ca4a33 Added informational toolip 2023-03-22 17:15:20 +01:00
seerge
023607da4b Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-22 14:38:04 +01:00
seerge
264631ab77 Added animatrix Clock 2023-03-22 14:38:01 +01:00
Serge
1bd5d79983 Update README.md 2023-03-21 17:40:06 +01:00
seerge
83b184a061 - 2023-03-21 15:23:41 +01:00
seerge
9ff572b8f6 UI tweaks, mid fan support 2023-03-21 13:14:53 +01:00
seerge
cdb633be04 Anime matrix fixes 2023-03-21 11:11:31 +01:00
seerge
7cb9b1f64f Mid Fan support 2023-03-21 01:24:42 +01:00
seerge
06be8c726e Improved Animatrix rendering 2023-03-20 23:27:13 +01:00
seerge
265c6ce417 - 2023-03-20 21:09:11 +01:00
seerge
add852ce5d Animatrix tweaks 2023-03-20 21:07:05 +01:00
seerge
d4a5164b16 - 2023-03-20 19:18:07 +01:00
seerge
14618ee19e Possible fix for theme switching 2023-03-20 19:04:41 +01:00
seerge
0b3a75e373 Minor tweaks 2023-03-20 18:02:38 +01:00
seerge
64e390a61f UI tweaks 2023-03-20 17:10:18 +01:00
seerge
1cd808de07 Auto theme change 2023-03-20 16:42:51 +01:00
seerge
d82f1c8d70 Fix crash for gputemp reader 2023-03-20 15:43:51 +01:00
seerge
9189cf0a46 Dark Theme 2023-03-20 14:38:56 +01:00
seerge
3a7c4278a0 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-20 14:32:47 +01:00
seerge
7065ba8661 Dark Theme 2023-03-20 14:32:45 +01:00
Serge
1bce4a4b51 Update README.md 2023-03-20 11:45:16 +01:00
Serge
468f9c4034 Update bug_report.md 2023-03-19 23:45:02 +01:00
seerge
4d347df45c Attempt to fix auto gpu switch 2023-03-19 21:59:22 +01:00
seerge
d7f1d1d5fd Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-19 17:39:32 +01:00
seerge
6800ae38dd Custom fan-axis for 401 model 2023-03-19 17:39:30 +01:00
Serge
9b2b96fbf0 Update README.md 2023-03-19 13:57:02 +01:00
seerge
04b3a15d8f Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-19 10:27:35 +01:00
seerge
aae0570340 - 2023-03-19 10:27:32 +01:00
Serge
b142d566da Update README.md 2023-03-18 20:56:37 +01:00
seerge
a9115d0dff Screenshot 2023-03-18 18:46:35 +01:00
Serge
e3a3e81245 Merge pull request #96 from seerge/new_ui
New UI
2023-03-18 18:38:35 +01:00
seerge
c50c1807ca UI fixes, tooltips for fan control 2023-03-18 17:57:09 +01:00
seerge
5767320437 Fixes for scaling, and layout 2023-03-18 15:13:34 +01:00
seerge
74846097db Optimized icons 2023-03-17 22:39:53 +01:00
seerge
5b89556ed3 New UI 2023-03-17 22:28:33 +01:00
Serge
845b182b55 Update README.md 2023-03-17 15:28:41 +01:00
Serge
b7cfd04560 Rename stop-asus-sv.bat to debloat.bat 2023-03-17 15:28:23 +01:00
Serge
6ffd464ec4 Update README.md 2023-03-17 15:14:04 +01:00
seerge
e7dd3ce203 - 2023-03-17 15:13:49 +01:00
Serge
d06dae9015 Update README.md 2023-03-17 15:11:44 +01:00
Serge
1b208e1a74 Update README.md 2023-03-17 15:11:00 +01:00
seerge
6befab190b Folders 2023-03-17 15:10:39 +01:00
seerge
5d3eaa0055 Merge branch 'main' of https://github.com/seerge/g-helper 2023-03-17 15:08:03 +01:00
seerge
667f1a997c Folder cleanup 2023-03-17 15:08:01 +01:00
Serge
4542221a58 Update README.md 2023-03-17 15:03:58 +01:00
seerge
5fd7b74519 Folder reorganisation 2023-03-17 15:03:09 +01:00
Serge
014ee635d6 Update README.md 2023-03-17 01:31:24 +01:00
Serge
1dff60d574 Create default.html 2023-03-17 01:18:00 +01:00
Serge
7395f0be69 Update README.md 2023-03-16 23:07:38 +01:00
seerge
e3019a313a UI fixes 2023-03-16 22:59:50 +01:00
seerge
9653b81cd3 Revert "Update _config.yml"
This reverts commit 9713cb6fa4.
2023-03-16 22:59:34 +01:00
Serge
9713cb6fa4 Update _config.yml 2023-03-16 22:51:51 +01:00
Serge
10053eda10 Update _config.yml 2023-03-16 22:42:42 +01:00
Serge
ef1bbc1fce Update _config.yml 2023-03-16 22:36:31 +01:00
seerge
3fde8c1fa9 Screenshot 2023-03-16 18:56:09 +01:00
seerge
efd6707e61 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-16 15:39:27 +01:00
seerge
8032ea3fc7 UI tweaks 2023-03-16 15:39:25 +01:00
Serge
d0a232d888 Update README.md 2023-03-15 22:55:42 +01:00
Serge
a6bd18f019 Update README.md 2023-03-15 22:53:16 +01:00
seerge
a09c252c2e Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-15 21:25:51 +01:00
seerge
99d3c61897 Kill app on Eco switch 2023-03-15 21:25:49 +01:00
Serge
4a6decb0be Update README.md 2023-03-15 21:25:10 +01:00
Serge
80b9fdb8ac Update README.md 2023-03-15 19:14:49 +01:00
Serge
e3c293942c Update README.md 2023-03-15 17:47:38 +01:00
Serge
42e910e635 Create _config.yml 2023-03-15 17:44:18 +01:00
Serge
18b6ae07b2 Update README.md 2023-03-15 17:30:17 +01:00
Serge
fa2875fbee Update README.md 2023-03-15 17:29:17 +01:00
Serge
f2bfb24fb4 Update README.md 2023-03-15 17:27:22 +01:00
Serge
adc81721ac Update README.md 2023-03-15 17:21:50 +01:00
Serge
9da061d621 Update README.md 2023-03-15 17:12:07 +01:00
Serge
274c04bf61 Update README.md 2023-03-15 14:15:29 +01:00
Serge
2d286ca04f Update README.md 2023-03-15 14:14:47 +01:00
Serge
2c1fa01863 Create SECURITY.md 2023-03-15 14:11:46 +01:00
Serge
0370ef7bc0 Update issue templates 2023-03-15 14:10:33 +01:00
Serge
2f2ef23ee4 Create CONTRIBUTING.md 2023-03-15 14:09:57 +01:00
Serge
756ed44741 Create CODE_OF_CONDUCT.md 2023-03-15 14:08:49 +01:00
Serge
efb6a087b4 Merge pull request #86 from seerge/add-license-1
Create LICENSE
2023-03-15 14:07:13 +01:00
Serge
4e6f55c24d Create LICENSE 2023-03-15 14:05:01 +01:00
Serge
c029df357a Update README.md 2023-03-15 12:45:49 +01:00
Serge
8d19b5f89c Update README.md 2023-03-15 12:24:54 +01:00
seerge
7683e68df3 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-14 23:07:52 +01:00
seerge
e45bcdf8a5 Adjusted PPTs for 2021 model, added windows PowerModes 2023-03-14 23:07:49 +01:00
Serge
ab8d42c216 Update README.md 2023-03-14 17:55:25 +01:00
seerge
d248fcf384 Screenshot 2023-03-14 17:53:15 +01:00
seerge
9bb5e41a5d Fixed auto resolution switching in some exotic cases 2023-03-14 15:39:56 +01:00
seerge
bc965c003d Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-14 14:21:23 +01:00
seerge
a6cfc91de2 Added log cleanup 2023-03-14 14:21:20 +01:00
Serge
9ca6ec657f Update README.md 2023-03-14 12:55:22 +01:00
seerge
89d7930323 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-13 23:30:02 +01:00
seerge
e26d26b498 - 2023-03-13 23:28:58 +01:00
seerge
a6d0dde4b0 - 2023-03-13 23:28:58 +01:00
seerge
f68d53aaf4 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-13 23:28:58 +01:00
seerge
a2ea3d18fd UI Tweaks 2023-03-13 23:28:58 +01:00
seerge
f77fcc940f Merge pull request #82 from ZimM-LostPolygon/gpu-temperature
fix: improved GPU temperature reliability
2023-03-13 23:28:58 +01:00
seerge
dd4d85f254 Turbo boost dropdown 2023-03-13 23:28:57 +01:00
seerge
2afbde814f fix: improved GPU temperature reliability 2023-03-13 23:28:57 +01:00
seerge
b6b06a3802 UI tweaks 2023-03-13 23:28:57 +01:00
seerge
4d58945688 Minor fixes 2023-03-13 23:28:57 +01:00
seerge
9aaf0159e5 Merged GPU temp reader 2023-03-13 23:28:57 +01:00
seerge
3cbaf1eb52 Merge pull request #74 from ZimM-LostPolygon/gpu-temperature
feat: added GPU temperature indication.
2023-03-13 23:28:57 +01:00
seerge
c76fbeab37 New sleep/wake up detection 2023-03-13 23:28:56 +01:00
seerge
15d580bbe3 fix: fixed crash when launched in Eco mode 2023-03-13 23:28:56 +01:00
seerge
2ec64bf8b5 feat: added GPU temperature indication. Supports both NVIDIA and AMD discrete GPUs
feat: immediately update sensors when opening GHelper window
2023-03-13 23:28:56 +01:00
seerge
254be71e88 - 2023-03-13 23:21:06 +01:00
seerge
e9ec8f0e8f - 2023-03-13 23:14:28 +01:00
seerge
0ef44a0495 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-13 23:07:31 +01:00
seerge
e725760b24 UI Tweaks 2023-03-13 23:07:28 +01:00
seerge
a83ab4884e Merge pull request #82 from ZimM-LostPolygon/gpu-temperature
fix: improved GPU temperature reliability
2023-03-13 23:07:12 +01:00
Serhii Yolkin
7bfd10c65d fix: improved GPU temperature reliability 2023-03-13 22:45:12 +01:00
seerge
67b541b145 Turbo boost dropdown 2023-03-13 21:46:11 +01:00
seerge
f1ae14652f UI tweaks 2023-03-13 21:20:46 +01:00
seerge
223ead2f4e Minor fixes 2023-03-13 20:25:35 +01:00
seerge
a211dd412f Merged GPU temp reader 2023-03-13 20:02:59 +01:00
seerge
550e9fc036 Merge pull request #74 from ZimM-LostPolygon/gpu-temperature
feat: added GPU temperature indication.
2023-03-13 19:52:33 +01:00
seerge
8fe01e8790 New sleep/wake up detection 2023-03-13 19:38:39 +01:00
seerge
f0abe22b5d Logger and minor changes 2023-03-13 18:33:27 +01:00
Serhii Yolkin
ef0993e442 fix: fixed crash when launched in Eco mode 2023-03-13 17:47:11 +01:00
Serhii Yolkin
62ac478761 feat: added GPU temperature indication. Supports both NVIDIA and AMD discrete GPUs
feat: immediately update sensors when opening GHelper window
2023-03-13 17:35:35 +01:00
seerge
a7e8ba3241 Scheduler warning 2023-03-13 12:10:29 +01:00
seerge
b46f0fb887 Removed scheduler call on each run 2023-03-13 11:38:54 +01:00
seerge
a39c084bdf Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-12 16:16:35 +01:00
seerge
f0c291bea4 Minor tweaks 2023-03-12 16:16:32 +01:00
seerge
d04a20367b Update README.md 2023-03-12 13:36:09 +01:00
seerge
888e49fe40 Update README.md 2023-03-12 13:35:40 +01:00
seerge
4875a22f38 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-12 13:27:55 +01:00
seerge
ea2e8a7c24 UI Tweaks 2023-03-12 13:27:44 +01:00
seerge
6ec94e4ac3 Update README.md 2023-03-11 14:28:17 +01:00
seerge
5334d1e4ed Screenshot 2023-03-11 12:47:17 +01:00
seerge
9f339806d4 UI Fixes 2023-03-11 12:41:34 +01:00
seerge
54a4668e2a Under the hood changes 2023-03-10 23:32:12 +01:00
seerge
71d2a6ce05 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-10 21:50:22 +01:00
seerge
92d1b97b95 Fix for UI lag on GPU switch 2023-03-10 21:50:20 +01:00
seerge
4b9a53cef8 Update README.md 2023-03-10 15:51:20 +01:00
seerge
068694d7d1 Update README.md 2023-03-10 13:45:49 +01:00
seerge
43c6def162 Update checker 2023-03-09 20:54:32 +01:00
seerge
306697f026 Added possible fix for bios unsetting ppts after wake up 2023-03-09 16:03:39 +01:00
seerge
c5a32cc9d5 Moved turbo boost checkbox to Fans and Power window 2023-03-09 14:10:13 +01:00
seerge
51acd9a612 Fix for startup checkbox 2023-03-09 11:28:02 +01:00
seerge
457a37049c - 2023-03-08 22:51:33 +01:00
seerge
6d2cece4f2 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-08 22:44:16 +01:00
seerge
265611009c Improved internal display detection 2023-03-08 22:44:14 +01:00
seerge
2714b6dca7 Update README.md 2023-03-08 20:04:38 +01:00
seerge
f6de5eba64 Screenshot 2023-03-08 20:03:24 +01:00
seerge
13f7c81689 Fix animatrix 2021 size 2023-03-08 19:43:52 +01:00
seerge
8c0d84b65b Fix for possible animatrix custom picture support on older (2021) models 2023-03-08 19:15:21 +01:00
seerge
4e6fa6d9b0 Auto Apply power limits 2023-03-08 17:25:11 +01:00
seerge
be133cd238 Minor fixes 2023-03-07 21:19:04 +01:00
seerge
30f678d08f Hide unsupported power sliders 2023-03-07 16:10:56 +01:00
seerge
cf201632d5 New built in monitor detection system 2023-03-07 15:23:06 +01:00
seerge
003a19d94b Auto off for matrix on battery 2023-03-06 19:57:47 +01:00
seerge
6c3d4b9cb2 Added ACPI alert 2023-03-06 18:34:26 +01:00
seerge
aa62330c1c UI Fixes 2023-03-06 13:30:04 +01:00
seerge
954861f2b1 Timers fix 2023-03-06 00:46:35 +01:00
seerge
e3e9022111 Timer fix 2023-03-06 00:14:37 +01:00
seerge
24014dd20f Fix 2023-03-05 23:26:39 +01:00
seerge
321bc2623d Added support for animated GIF in animatrix 2023-03-05 23:14:48 +01:00
seerge
52b07843a2 UI Fixes 2023-03-05 19:59:07 +01:00
seerge
5038ff2315 Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-05 18:23:40 +01:00
seerge
c8f4c4b0d4 Added more actions for m3/m4, fixed scaling 2023-03-05 18:23:38 +01:00
seerge
319401af5d Update README.md 2023-03-04 13:34:27 +01:00
seerge
aa30f472ad Update README.md 2023-03-04 12:57:41 +01:00
seerge
b40eb50e90 Readme 2023-03-04 00:23:04 +01:00
seerge
1f47b031f6 Screenshot 2023-03-04 00:22:48 +01:00
seerge
84a3f01267 Readme 2023-03-04 00:13:30 +01:00
seerge
f9488fbf2f Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-04 00:12:02 +01:00
seerge
43d2ed656a Added animatrix control thanks to https://github.com/vddCore/Starlight 2023-03-04 00:11:59 +01:00
seerge
e9fa181d4e Fixed missing fan curve 2023-03-03 14:17:09 +01:00
seerge
58aa838e51 Update README.md 2023-03-03 12:50:28 +01:00
seerge
96c85f69fe Show performance notifications only when mode changes 2023-03-03 12:41:53 +01:00
seerge
8f215dafab Minor fixes 2023-03-03 01:00:47 +01:00
seerge
b3636fd447 Remember performance mode for plugged / battery 2023-03-02 21:05:02 +01:00
seerge
ed579f25d6 PPT for 2021 model 2023-03-02 19:17:10 +01:00
seerge
6a71a64c96 Removed GSharphelper task removal 2023-03-02 14:07:12 +01:00
seerge
ac69f1317e New screenshot 2023-03-02 13:01:06 +01:00
seerge
4b38d380b5 Fan label calibration 2023-03-02 12:51:56 +01:00
seerge
9a2f9afe5b Minor fixes, fan RPM display 2023-03-02 12:22:52 +01:00
seerge
ce9ec1b6df Merge branch 'main' of https://github.com/seerge/g14-helper 2023-03-02 00:07:15 +01:00
seerge
e68282050b Fan curve auto apply 2023-03-02 00:07:07 +01:00
seerge
6b8f61fab4 Update README.md 2023-03-01 18:36:53 +01:00
seerge
f59070cb96 Minor fixes 2023-03-01 11:45:43 +01:00
seerge
f47a00fde2 Update README.md 2023-02-28 19:42:30 +01:00
seerge
b15c15974e New screenshot 2023-02-28 19:25:04 +01:00
seerge
b5c47de3f2 Added power limits 2023-02-28 19:17:16 +01:00
seerge
6b88fe67d3 Fix for possible missing fans curve on G15 2023-02-28 17:32:47 +01:00
seerge
3ff2a5f946 New screenshot 2023-02-27 18:43:48 +01:00
seerge
c73c05c24a Project settings 2023-02-27 18:40:47 +01:00
seerge
1131035254 Basic key bindings, second keyboard color, minor fixes 2023-02-27 18:16:05 +01:00
219 changed files with 41925 additions and 3850 deletions

128
.github/CODE_OF_CONDUCT.md vendored Normal file
View File

@@ -0,0 +1,128 @@
# Contributor Covenant Code of Conduct
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.
## Our Standards
Examples of behavior that contributes to a positive environment for our
community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.
Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.
## Scope
This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
.
All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the
reporter of any incident.
## Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:
### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.
### 2. Warning
**Community Impact**: A violation through a single incident or series
of actions.
**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.
### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.
### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior, harassment of an
individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within
the community.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.0, available at
https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by [Mozilla's code of conduct
enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at
https://www.contributor-covenant.org/translations.

1
.github/CONTRIBUTING.md vendored Normal file
View File

@@ -0,0 +1 @@
Please, feel free to contribute. Especially if you own model differnt from G14 2022 and can offer extra features or support.

13
.github/FUNDING.yml vendored Normal file
View File

@@ -0,0 +1,13 @@
# These are supported funding model platforms
github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
patreon: # Replace with a single Patreon username
open_collective: # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
custom: https://www.paypal.com/donate/?hosted_button_id=4HMSHS4EBQWTA

42
.github/ISSUE_TEMPLATE/bug_report.md vendored Normal file
View File

@@ -0,0 +1,42 @@
---
name: Bug report
about: Create a report to help us improve
---
## NOTE
Bug reports without clear information or scenario to reproduce and logs from ``%AppData%\GHelper`` will be closed without answer.
Please respect the time of the developer. Thanks.
**Describe the bug**
A clear and concise description of what the bug is.
**Clear scenario to Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. Explanation of an error or a bug
**Expected behavior**
A clear and concise description of what you expected to happen.
**App Logs**
Please include and attach log.txt from ``%AppData%\GHelper``
**Screenshots or screencasts**
If applicable, add screenshots to help explain your problem.
**Desktop (please complete the following information):**
- OS: [e.g. Windows 11]
- Laptop model
**Asus software**
- Armoury Crate (or it's services installed)
- MyASUS installed
- Other Asus services running in background
**Additional context**
Add any other context about the problem here.

View File

@@ -0,0 +1,20 @@
---
name: Feature request
about: Suggest an idea for this project
title: ''
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.

16
.github/SECURITY.md vendored Normal file
View File

@@ -0,0 +1,16 @@
# Security Policy
## Supported Versions
| Version | Supported |
| ------- | ------------------ |
| 0.89+ | :white_check_mark: |
| < 0.89 | :x: |
## Reporting a Vulnerability
Use this section to tell people how to report a vulnerability.
Tell them where to go, how often they can expect to get an update on a
reported vulnerability, what to expect if the vulnerability is accepted or
declined, etc.

25
.github/workflows/build.yml vendored Normal file
View File

@@ -0,0 +1,25 @@
name: Build
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
workflow_dispatch:
permissions:
contents: read
jobs:
build:
runs-on: windows-2022
steps:
- uses: actions/checkout@v3
- name: Setup dotnet
uses: actions/setup-dotnet@v3
with:
dotnet-version: |
7.0.x
- name: Build
run: |
dotnet build app/GHelper.sln

28
.github/workflows/codeql.yml vendored Normal file
View File

@@ -0,0 +1,28 @@
name: CodeQL
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
schedule:
- cron: '34 18 * * 3'
permissions:
actions: read
contents: read
security-events: write
jobs:
codeql:
runs-on: windows-2022
steps:
- uses: actions/checkout@v3
- name: Initialize CodeQL
uses: github/codeql-action/init@v2
with:
languages: c#
- name: Autobuild
uses: github/codeql-action/autobuild@v2
- name: Analyze
uses: github/codeql-action/analyze@v2

28
.github/workflows/release.yml vendored Normal file
View File

@@ -0,0 +1,28 @@
name: Release
on:
release:
types: [ published ]
permissions:
contents: write
jobs:
release:
runs-on: windows-2022
steps:
- uses: actions/checkout@v3
- name: Setup dotnet
uses: actions/setup-dotnet@v3
with:
dotnet-version: |
7.0.x
- name: Publish
run: |
dotnet publish app/GHelper.sln --configuration Release --runtime win-x64 -p:PublishSingleFile=true --no-self-contained
powershell Compress-Archive app/bin/x64/Release/net7.0-windows/win-x64/publish/* GHelper.zip
- name: Upload
env:
GH_TOKEN: ${{ github.token }}
run: |
gh release upload ${{ github.ref_name }} GHelper.zip

View File

@@ -1,200 +0,0 @@
using System.Management;
using System.Runtime.InteropServices;
using System.Diagnostics;
public class ASUSWmi
{
const string FILE_NAME = @"\\.\\ATKACPI";
const uint CONTROL_CODE = 0x0022240C;
const uint DSTS = 0x53545344;
const uint DEVS = 0x53564544;
public const uint CPU_Fan = 0x00110013;
public const uint GPU_Fan = 0x00110014;
public const uint PerformanceMode = 0x00120075; // Thermal Control
public const uint GPUEco = 0x00090020;
public const uint GPUMux = 0x00090016;
public const uint BatteryLimit = 0x00120057;
public const uint ScreenOverdrive = 0x00050019;
public const uint DevsCPUFanCurve = 0x00110024;
public const uint DevsGPUFanCurve = 0x00110025;
public const int PerformanceBalanced = 0;
public const int PerformanceTurbo = 1;
public const int PerformanceSilent = 2;
public const int GPUModeEco = 0;
public const int GPUModeStandard = 1;
public const int GPUModeUltimate = 2;
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
private static extern IntPtr CreateFile(
string lpFileName,
uint dwDesiredAccess,
uint dwShareMode,
IntPtr lpSecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr hTemplateFile
);
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool DeviceIoControl(
IntPtr hDevice,
uint dwIoControlCode,
byte[] lpInBuffer,
uint nInBufferSize,
byte[] lpOutBuffer,
uint nOutBufferSize,
ref uint lpBytesReturned,
IntPtr lpOverlapped
);
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool CloseHandle(IntPtr hObject);
private const uint GENERIC_READ = 0x80000000;
private const uint GENERIC_WRITE = 0x40000000;
private const uint OPEN_EXISTING = 3;
private const uint FILE_ATTRIBUTE_NORMAL = 0x80;
private const uint FILE_SHARE_READ = 1;
private const uint FILE_SHARE_WRITE = 2;
private IntPtr handle;
public ASUSWmi()
{
handle = CreateFile(
FILE_NAME,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
IntPtr.Zero,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
IntPtr.Zero
);
if (handle == new IntPtr(-1))
{
throw new Exception("Can't connect to ACPI");
}
}
public void Control(uint dwIoControlCode, byte[] lpInBuffer, byte[] lpOutBuffer)
{
uint lpBytesReturned = 0;
bool result = DeviceIoControl(
handle,
dwIoControlCode,
lpInBuffer,
(uint)lpInBuffer.Length,
lpOutBuffer,
(uint)lpOutBuffer.Length,
ref lpBytesReturned,
IntPtr.Zero
);
}
public void Close()
{
CloseHandle(handle);
}
protected byte[] CallMethod(uint MethodID, byte[] args)
{
byte[] acpiBuf = new byte[8 + args.Length];
byte[] outBuffer = new byte[20];
BitConverter.GetBytes((uint)MethodID).CopyTo(acpiBuf, 0);
BitConverter.GetBytes((uint)args.Length).CopyTo(acpiBuf, 4);
Array.Copy(args, 0, acpiBuf, 8, args.Length);
// if (MethodID == DEVS) Debug.WriteLine(BitConverter.ToString(acpiBuf, 0, acpiBuf.Length));
Control(CONTROL_CODE, acpiBuf, outBuffer);
return outBuffer;
}
public void DeviceSet(uint DeviceID, int Status)
{
byte[] args = new byte[8];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
CallMethod(DEVS, args);
}
public void DeviceSet(uint DeviceID, byte[] Params)
{
byte[] args = new byte[4 + Params.Length];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
Params.CopyTo(args, 4);
CallMethod(DEVS, args);
}
public int DeviceGet(uint DeviceID)
{
byte[] args = new byte[8];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
byte[] status = CallMethod(DSTS, args);
return BitConverter.ToInt32(status, 0) - 65536;
}
public byte[] DeviceGetBuffer(uint DeviceID, uint Status = 0)
{
byte[] args = new byte[8];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
return CallMethod(DSTS, args);
}
public void SetFanCurve(int device, byte[] curve)
{
if (device == 1)
DeviceSet(DevsGPUFanCurve, curve);
else
DeviceSet(DevsCPUFanCurve, curve);
}
public byte[] GetFanCurve(int device, int mode = 0)
{
uint fan_mode;
// because it's asus, and modes are swapped here
switch (mode)
{
case 1:fan_mode = 2; break;
case 2: fan_mode = 1; break;
default: fan_mode = 0; break;
}
if (device == 1)
return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
else
return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
}
public void SubscribeToEvents(Action<object, EventArrivedEventArgs> EventHandler)
{
ManagementEventWatcher watcher = new ManagementEventWatcher();
watcher.EventArrived += new EventArrivedEventHandler(EventHandler);
watcher.Scope = new ManagementScope("root\\wmi");
watcher.Query = new WqlEventQuery("SELECT * FROM AsusAtkWmiEvent");
watcher.Start();
}
}

68
Aura.cs
View File

@@ -1,68 +0,0 @@
using HidLibrary;
public class Aura
{
static byte[] MESSAGE_SET = { 0x5d, 0xb5 };
static byte[] MESSAGE_APPLY = { 0x5d, 0xb4 };
public const int Static = 0;
public const int Breathe = 1;
public const int Strobe = 2;
public const int Rainbow = 3;
public const int Dingding = 10;
public const int SpeedSlow = 0;
public const int SpeedMedium = 1;
public const int SpeedHigh = 2;
public static int Mode = Static;
public static Color Color1 = Color.White;
public static Color Color2 = Color.Black;
public static int Speed = SpeedSlow;
public static byte[] AuraMessage(int mode, Color color, Color color2, int speed)
{
byte[] msg = new byte[17];
msg[0] = 0x5d;
msg[1] = 0xb3;
msg[2] = 0x00; // Zone
msg[3] = (byte)mode; // Aura Mode
msg[4] = (byte)(color.R); // R
msg[5] = (byte)(color.G); // G
msg[6] = (byte)(color.B); // B
msg[7] = (byte)speed; // aura.speed as u8;
msg[8] = 0; // aura.direction as u8;
msg[10] = (byte)(color2.R); // R
msg[11] = (byte)(color2.G); // G
msg[12] = (byte)(color2.B); // B
return msg;
}
public static void ApplyAura()
{
HidDevice[] HidDeviceList;
int[] deviceIds = { 0x1854, 0x1869, 0x1866, 0x19b6 };
HidDeviceList = HidDevices.Enumerate(0x0b05, deviceIds).ToArray();
foreach (HidDevice device in HidDeviceList)
{
if (device.IsConnected)
{
if (device.Description.IndexOf("HID") >= 0)
{
device.OpenDevice();
byte[] msg = AuraMessage(Mode, Color1, Color2, Speed);
device.Write(msg);
device.Write(MESSAGE_SET);
device.Write(MESSAGE_APPLY);
device.CloseDevice();
}
}
}
}
}

109
Fans.Designer.cs generated
View File

@@ -1,109 +0,0 @@
namespace GHelper
{
partial class Fans
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea1 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
System.Windows.Forms.DataVisualization.Charting.ChartArea chartArea2 = new System.Windows.Forms.DataVisualization.Charting.ChartArea();
chartCPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
buttonApply = new Button();
buttonReset = new Button();
chartGPU = new System.Windows.Forms.DataVisualization.Charting.Chart();
((System.ComponentModel.ISupportInitialize)chartCPU).BeginInit();
((System.ComponentModel.ISupportInitialize)chartGPU).BeginInit();
SuspendLayout();
//
// chartCPU
//
chartArea1.Name = "ChartArea1";
chartCPU.ChartAreas.Add(chartArea1);
chartCPU.Location = new Point(16, 13);
chartCPU.Name = "chartCPU";
chartCPU.Size = new Size(900, 446);
chartCPU.TabIndex = 0;
chartCPU.Text = "chartCPU";
//
// buttonApply
//
buttonApply.Location = new Point(662, 944);
buttonApply.Name = "buttonApply";
buttonApply.Size = new Size(254, 46);
buttonApply.TabIndex = 1;
buttonApply.Text = "Apply Fan Curve";
buttonApply.UseVisualStyleBackColor = true;
//
// buttonReset
//
buttonReset.Location = new Point(402, 944);
buttonReset.Name = "buttonReset";
buttonReset.Size = new Size(254, 46);
buttonReset.TabIndex = 2;
buttonReset.Text = "Factory Defaults";
buttonReset.UseVisualStyleBackColor = true;
//
// chartGPU
//
chartArea2.Name = "ChartArea1";
chartGPU.ChartAreas.Add(chartArea2);
chartGPU.Location = new Point(16, 477);
chartGPU.Name = "chartGPU";
chartGPU.Size = new Size(900, 448);
chartGPU.TabIndex = 3;
chartGPU.Text = "chart1";
//
// Fans
//
AutoScaleDimensions = new SizeF(13F, 32F);
AutoScaleMode = AutoScaleMode.Font;
ClientSize = new Size(940, 1020);
Controls.Add(chartGPU);
Controls.Add(buttonReset);
Controls.Add(buttonApply);
Controls.Add(chartCPU);
FormBorderStyle = FormBorderStyle.FixedSingle;
MaximizeBox = false;
MdiChildrenMinimizedAnchorBottom = false;
MinimizeBox = false;
Name = "Fans";
ShowIcon = false;
ShowInTaskbar = false;
StartPosition = FormStartPosition.CenterScreen;
Text = "Fans";
((System.ComponentModel.ISupportInitialize)chartCPU).EndInit();
((System.ComponentModel.ISupportInitialize)chartGPU).EndInit();
ResumeLayout(false);
}
#endregion
private System.Windows.Forms.DataVisualization.Charting.Chart chartCPU;
private Button buttonApply;
private Button buttonReset;
private System.Windows.Forms.DataVisualization.Charting.Chart chartGPU;
}
}

214
Fans.cs
View File

@@ -1,214 +0,0 @@
using System;
using System.Diagnostics;
using System.Windows.Forms.DataVisualization.Charting;
namespace GHelper
{
public partial class Fans : Form
{
DataPoint curPoint = null;
Series seriesCPU;
Series seriesGPU;
void SetChart(Chart chart, int device)
{
string title;
if (device == 1)
title = "GPU Fan Profile";
else
title = "CPU Fan Profile";
if (Program.settingsForm.perfName.Length > 0)
title += ": " + Program.settingsForm.perfName;
if (chart.Titles.Count > 0)
chart.Titles[0].Text = title;
else
chart.Titles.Add(title);
chart.ChartAreas[0].AxisX.Minimum = 10;
chart.ChartAreas[0].AxisX.Maximum = 100;
chart.ChartAreas[0].AxisX.Interval = 10;
chart.ChartAreas[0].AxisY.Minimum = 0;
chart.ChartAreas[0].AxisY.Maximum = 100;
if (chart.Legends.Count > 0)
chart.Legends[0].Enabled = false;
}
private void Fans_Shown(object? sender, EventArgs e)
{
Top = Program.settingsForm.Top;
Left = Program.settingsForm.Left - Width - 10;
}
public Fans()
{
InitializeComponent();
seriesCPU = chartCPU.Series.Add("CPU");
seriesGPU = chartGPU.Series.Add("GPU");
seriesCPU.Color = Color.Blue;
seriesGPU.Color = Color.Red;
LoadFans();
chartCPU.MouseMove += ChartCPU_MouseMove;
chartCPU.MouseUp += ChartCPU_MouseUp;
chartGPU.MouseMove += ChartCPU_MouseMove;
chartGPU.MouseUp += ChartCPU_MouseUp;
buttonReset.Click += ButtonReset_Click;
buttonApply.Click += ButtonApply_Click;
Shown += Fans_Shown;
}
public void LoadFans()
{
SetChart(chartCPU, 0);
SetChart(chartGPU, 1);
LoadProfile(seriesCPU, 0);
LoadProfile(seriesGPU, 1);
}
byte[] StringToBytes(string str)
{
String[] arr = str.Split('-');
byte[] array = new byte[arr.Length];
for (int i = 0; i < arr.Length; i++) array[i] = Convert.ToByte(arr[i], 16);
return array;
}
string GetFanName(int device)
{
int mode = Program.config.getConfig("performance_mode");
string name;
if (device == 1)
name = "gpu";
else
name = "cpu";
return "fan_profile_" + name + "_" + mode;
}
void LoadProfile(Series series, int device, int def = 0)
{
series.ChartType = SeriesChartType.Line;
series.MarkerSize = 10;
series.MarkerStyle = MarkerStyle.Circle;
series.Points.Clear();
int mode = Program.config.getConfig("performance_mode");
string curveString = Program.config.getConfigString(GetFanName(device));
byte[] curve = { };
if (curveString is not null)
curve = StringToBytes(curveString);
if (def == 1 || curve.Length != 16)
curve = Program.wmi.GetFanCurve(device, mode);
//Debug.WriteLine(BitConverter.ToString(curve));
byte old = 0;
for (int i = 0; i < 8; i++)
{
if (curve[i] == old) curve[i]++; // preventing 2 points in same spot from default asus profiles
series.Points.AddXY(curve[i], curve[i + 8]);
old = curve[i];
}
}
void ApplyProfile(Series series, int device)
{
byte[] curve = new byte[16];
int i = 0;
foreach (DataPoint point in series.Points)
{
curve[i] = (byte)point.XValue;
curve[i + 8] = (byte)point.YValues.First();
i++;
}
string bitCurve = BitConverter.ToString(curve);
Debug.WriteLine(bitCurve);
Program.config.setConfig(GetFanName(device), bitCurve);
Program.wmi.SetFanCurve(device, curve);
}
private void ButtonApply_Click(object? sender, EventArgs e)
{
ApplyProfile(seriesCPU, 0);
ApplyProfile(seriesGPU, 1);
}
private void ButtonReset_Click(object? sender, EventArgs e)
{
LoadProfile(seriesCPU, 0, 1);
LoadProfile(seriesGPU, 1, 1);
Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, Program.config.getConfig("performance_mode"));
}
private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)
{
curPoint = null;
}
private void ChartCPU_MouseMove(object? sender, MouseEventArgs e)
{
if (sender is null) return;
Chart chart = (Chart)sender;
if (e.Button.HasFlag(MouseButtons.Left))
{
ChartArea ca = chart.ChartAreas[0];
Axis ax = ca.AxisX;
Axis ay = ca.AxisY;
HitTestResult hit = chart.HitTest(e.X, e.Y);
if (hit.Series is not null && hit.PointIndex >= 0)
curPoint = hit.Series.Points[hit.PointIndex];
if (curPoint != null)
{
Series s = hit.Series;
double dx = ax.PixelPositionToValue(e.X);
double dy = ay.PixelPositionToValue(e.Y);
if (dx < 0) dx = 0;
if (dx > 100) dx = 100;
if (dy < 0) dy = 0;
if (dy > 100) dy = 100;
curPoint.XValue = dx;
curPoint.YValues[0] = dy;
}
}
}
}
}

View File

@@ -1,60 +0,0 @@
<root>
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

21
LICENSE Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2023 Serge
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

View File

@@ -1,260 +0,0 @@
using System.Diagnostics;
using System.Runtime.InteropServices;
public class NativeMethods
{
[DllImport("user32.dll")]
public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
public const int SW_RESTORE = 9;
public static bool SwitchToCurrent()
{
IntPtr hWnd = IntPtr.Zero;
Process process = Process.GetCurrentProcess();
Process[] processes = Process.GetProcessesByName(process.ProcessName);
foreach (Process _process in processes)
{
if (_process.Id != process.Id)
{
if (_process.MainWindowHandle != IntPtr.Zero)
{
Debug.WriteLine(_process.Id);
Debug.WriteLine(process.Id);
hWnd = _process.MainWindowHandle;
ShowWindowAsync(hWnd, SW_RESTORE);
}
return true;
break;
}
}
return false;
}
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerWriteDCValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
int AcValueIndex);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerWriteACValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
int AcValueIndex);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerReadACValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
out IntPtr AcValueIndex
);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerReadDCValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
out IntPtr AcValueIndex
);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerSetActiveScheme(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerGetActiveScheme(IntPtr UserPowerKey, out IntPtr ActivePolicyGuid);
static readonly Guid GUID_CPU = new Guid("54533251-82be-4824-96c1-47b60b740d00");
static readonly Guid GUID_BOOST = new Guid("be337238-0d82-4146-a960-4f3749d470c7");
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct DEVMODE
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string dmDeviceName;
public short dmSpecVersion;
public short dmDriverVersion;
public short dmSize;
public short dmDriverExtra;
public int dmFields;
public int dmPositionX;
public int dmPositionY;
public int dmDisplayOrientation;
public int dmDisplayFixedOutput;
public short dmColor;
public short dmDuplex;
public short dmYResolution;
public short dmTTOption;
public short dmCollate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string dmFormName;
public short dmLogPixels;
public short dmBitsPerPel;
public int dmPelsWidth;
public int dmPelsHeight;
public int dmDisplayFlags;
public int dmDisplayFrequency;
public int dmICMMethod;
public int dmICMIntent;
public int dmMediaType;
public int dmDitherType;
public int dmReserved1;
public int dmReserved2;
public int dmPanningWidth;
public int dmPanningHeight;
};
[Flags()]
public enum DisplaySettingsFlags : int
{
CDS_UPDATEREGISTRY = 1,
CDS_TEST = 2,
CDS_FULLSCREEN = 4,
CDS_GLOBAL = 8,
CDS_SET_PRIMARY = 0x10,
CDS_RESET = 0x40000000,
CDS_NORESET = 0x10000000
}
// PInvoke declaration for EnumDisplaySettings Win32 API
[DllImport("user32.dll")]
public static extern int EnumDisplaySettingsEx(
string lpszDeviceName,
int iModeNum,
ref DEVMODE lpDevMode);
// PInvoke declaration for ChangeDisplaySettings Win32 API
[DllImport("user32.dll")]
public static extern int ChangeDisplaySettingsEx(
string lpszDeviceName, ref DEVMODE lpDevMode, IntPtr hwnd,
DisplaySettingsFlags dwflags, IntPtr lParam);
public const int ENUM_CURRENT_SETTINGS = -1;
public const string laptopScreenName = "\\\\.\\DISPLAY1";
public static DEVMODE CreateDevmode()
{
DEVMODE dm = new DEVMODE();
dm.dmDeviceName = new String(new char[32]);
dm.dmFormName = new String(new char[32]);
dm.dmSize = (short)Marshal.SizeOf(dm);
return dm;
}
public static Screen FindLaptopScreen()
{
var screens = Screen.AllScreens;
Screen laptopScreen = null;
foreach (var screen in screens)
{
if (screen.DeviceName == laptopScreenName)
{
laptopScreen = screen;
}
}
if (laptopScreen is null) return null;
else return laptopScreen;
}
public static int GetRefreshRate()
{
DEVMODE dm = CreateDevmode();
Screen laptopScreen = FindLaptopScreen();
int frequency = -1;
if (laptopScreen is null)
return -1;
if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen.DeviceName, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
{
frequency = dm.dmDisplayFrequency;
}
return frequency;
}
public static int SetRefreshRate(int frequency = 120)
{
DEVMODE dm = CreateDevmode();
Screen laptopScreen = FindLaptopScreen();
if (laptopScreen is null)
return -1;
if (0 != NativeMethods.EnumDisplaySettingsEx(laptopScreen.DeviceName, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
{
dm.dmDisplayFrequency = frequency;
int iRet = NativeMethods.ChangeDisplaySettingsEx(laptopScreen.DeviceName, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
return iRet;
}
return 0;
}
static Guid GetActiveScheme()
{
IntPtr pActiveSchemeGuid;
var hr = PowerGetActiveScheme(IntPtr.Zero, out pActiveSchemeGuid);
Guid activeSchemeGuid = (Guid)Marshal.PtrToStructure(pActiveSchemeGuid, typeof(Guid));
return activeSchemeGuid;
}
public static int GetCPUBoost()
{
IntPtr AcValueIndex;
Guid activeSchemeGuid = GetActiveScheme();
UInt32 value = PowerReadACValueIndex(IntPtr.Zero,
activeSchemeGuid,
GUID_CPU,
GUID_BOOST, out AcValueIndex);
return AcValueIndex.ToInt32();
}
public static void SetCPUBoost(int boost = 0)
{
Guid activeSchemeGuid = GetActiveScheme();
var hrAC = PowerWriteACValueIndex(
IntPtr.Zero,
activeSchemeGuid,
GUID_CPU,
GUID_BOOST,
boost);
PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
var hrDC = PowerWriteDCValueIndex(
IntPtr.Zero,
activeSchemeGuid,
GUID_CPU,
GUID_BOOST,
boost);
PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
}
}

View File

@@ -1,240 +0,0 @@
using Microsoft.Win32;
using System.Diagnostics;
using System.Management;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Text.Json;
public class AppConfig
{
string appPath;
string configFile;
public Dictionary<string, object> config = new Dictionary<string, object>();
public AppConfig()
{
appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
configFile = appPath + "\\config.json";
if (!System.IO.Directory.Exists(appPath))
System.IO.Directory.CreateDirectory(appPath);
if (File.Exists(configFile))
{
string text = File.ReadAllText(configFile);
try
{
config = JsonSerializer.Deserialize<Dictionary<string, object>>(text);
}
catch
{
initConfig();
}
}
else
{
initConfig();
}
}
private void initConfig()
{
config = new Dictionary<string, object>();
config["performance_mode"] = 0;
string jsonString = JsonSerializer.Serialize(config);
File.WriteAllText(configFile, jsonString);
}
public int getConfig(string name)
{
if (config.ContainsKey(name))
return int.Parse(config[name].ToString());
else return -1;
}
public string getConfigString(string name)
{
if (config.ContainsKey(name))
return config[name].ToString();
else return null;
}
public void setConfig(string name, int value)
{
config[name] = value;
string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText(configFile, jsonString);
}
public void setConfig(string name, string value)
{
config[name] = value;
string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText(configFile, jsonString);
}
}
public class HardwareMonitor
{
public static float? cpuTemp = -1;
public static float? batteryDischarge = -1;
public static void ReadSensors()
{
cpuTemp = -1;
batteryDischarge = -1;
try
{
var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true);
cpuTemp = ct.NextValue() - 273;
ct.Dispose();
var cb = new PerformanceCounter("Power Meter", "Power", "Power Meter (0)", true);
batteryDischarge = cb.NextValue() / 1000;
cb.Dispose();
}
catch
{
Debug.WriteLine("Failed reading sensors");
}
}
}
namespace GHelper
{
static class Program
{
public static NotifyIcon trayIcon = new NotifyIcon
{
Text = "G-Helper",
Icon = Properties.Resources.standard,
Visible = true
};
public static ASUSWmi wmi = new ASUSWmi();
public static AppConfig config = new AppConfig();
public static SettingsForm settingsForm = new SettingsForm();
public static ToastForm toast = new ToastForm();
// The main entry point for the application
public static void Main()
{
trayIcon.MouseClick += TrayIcon_MouseClick; ;
wmi.SubscribeToEvents(WatcherEventArrived);
settingsForm.InitGPUMode();
settingsForm.InitBoost();
settingsForm.InitAura();
settingsForm.SetPerformanceMode(config.getConfig("performance_mode"));
settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
settingsForm.VisualiseGPUAuto(config.getConfig("gpu_auto"));
settingsForm.VisualiseScreenAuto(config.getConfig("screen_auto"));
settingsForm.SetStartupCheck(Startup.IsScheduled());
bool isPlugged = (System.Windows.Forms.SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online);
settingsForm.AutoGPUMode(isPlugged ? 1 : 0);
settingsForm.AutoScreen(isPlugged ? 1 : 0);
SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
IntPtr ds = settingsForm.Handle;
Application.Run();
}
private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
{
settingsForm.SetBatteryChargeLimit(config.getConfig("charge_limit"));
}
static void WatcherEventArrived(object sender, EventArrivedEventArgs e)
{
var collection = (ManagementEventWatcher)sender;
if (e.NewEvent is null) return;
int EventID = int.Parse(e.NewEvent["EventID"].ToString());
Debug.WriteLine(EventID);
switch (EventID)
{
case 56: // Rog button
case 174: // FN+F5
settingsForm.BeginInvoke(delegate
{
settingsForm.CyclePerformanceMode();
});
return;
case 179: // FN+F4
settingsForm.BeginInvoke(delegate
{
settingsForm.CycleAuraMode();
});
return;
case 87: // Battery
settingsForm.BeginInvoke(delegate
{
settingsForm.AutoGPUMode(0);
settingsForm.AutoScreen(0);
});
return;
case 88: // Plugged
settingsForm.BeginInvoke(delegate
{
settingsForm.AutoScreen(1);
settingsForm.AutoGPUMode(1);
});
return;
}
}
static void TrayIcon_MouseClick(object? sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right)
{
if (settingsForm.Visible)
settingsForm.Hide();
else
{
settingsForm.Show();
settingsForm.Activate();
}
trayIcon.Icon = trayIcon.Icon; // refreshing icon as it get's blurred when screen resolution changes
}
}
static void OnExit(object sender, EventArgs e)
{
trayIcon.Visible = false;
Application.Exit();
}
}
}

View File

@@ -1,163 +0,0 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace GHelper.Properties {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("GHelper.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
/// </summary>
internal static System.Drawing.Icon eco {
get {
object obj = ResourceManager.GetObject("eco", resourceCulture);
return ((System.Drawing.Icon)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icons8_charging_battery_48 {
get {
object obj = ResourceManager.GetObject("icons8-charging-battery-48", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icons8_fan_head_96 {
get {
object obj = ResourceManager.GetObject("icons8-fan-head-96", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icons8_keyboard_48 {
get {
object obj = ResourceManager.GetObject("icons8-keyboard-48", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icons8_laptop_48 {
get {
object obj = ResourceManager.GetObject("icons8-laptop-48", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icons8_speed_48 {
get {
object obj = ResourceManager.GetObject("icons8-speed-48", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icons8_speed_96 {
get {
object obj = ResourceManager.GetObject("icons8-speed-96", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icons8_video_card_48 {
get {
object obj = ResourceManager.GetObject("icons8-video-card-48", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
/// </summary>
internal static System.Drawing.Icon standard {
get {
object obj = ResourceManager.GetObject("standard", resourceCulture);
return ((System.Drawing.Icon)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
/// </summary>
internal static System.Drawing.Icon ultimate {
get {
object obj = ResourceManager.GetObject("ultimate", resourceCulture);
return ((System.Drawing.Icon)(obj));
}
}
}
}

View File

@@ -1,8 +0,0 @@
{
"profiles": {
"GHelper": {
"commandName": "Project",
"workingDirectory": "C:\\Users\\serge\\source\\GHelper"
}
}
}

View File

@@ -1,68 +0,0 @@
# G-Helper (For G14, G15, ROG FLOW, and others)
A small utility that allows you do almost everyting you could do with Armory Crate but without extra bloat and unnecessary services.
1. Switch between default **Performance modes** - Silent / Balanced / Turbo and apply default fan curves
2. Switch between Eco / Standard or Ultimate **GPU modes**
3. Change laptop screen refresh rate - 60hz or your maximum (120hz, 144hz, etc depending on the model) with display overdrive (OD)
4. View default fan profiles for every mode and apply custom ones
5. Control keyboard backlit animation and colors
6. Set battery charge limit to preserve battery
7. Monitor CPU temperature, fan speeds and battery discharge rate
8. **Automatically switch to Eco(iGPU)/60hz on battery** and back to Standard(GPU)/120hz modes when plugged
9. Support for M4 key / FN+F5 to cycle through performance modes (with OSD notification) and FN+F4 to cycle through keeyboard animation modes
10. Turn cpu turbo boost on/off with one checkbox to keep temps cooler
Designed and developer for Asus Zephyrus G14 2022 (with AMD Radeon iGPU and dGPU). But could and should potentially work for G14 of 2021 and 2020, G15, X FLOW, and other ROG models for relevant and supported features.
To keep autoswitching and hotkeys work app needs to stay in running in tray. It doesn't consume any resources.
I also recommend to keep "Asus Optimization Service" running , as it keeps basic laptop hotkeys such as screen or keyboard brightness adjustment working. If you have (or had) MyASUS app installed, that service is most probably still up an running even after MyASUS uninstall.
### [Download latest release](https://github.com/seerge/g-helper/releases)
![Screenshot](https://github.com/seerge/g-helper/blob/main/screenshot.png)
## Performance Profile switching
Profiles are **same** as in Armory Crate, including default fan curves
1. Silent (minimal or no fans, 70W PPT total, up to 45W PPT to CPU)
2. Balanced (balanced fans, 100W PPT total, up to 45W PPT to CPU)
3. Turbo (intense fans, 125W PPT total, up to 80W PPT to CPU)
PPTs are shown for G14 2022, for other models PPTs will be different as they are set in bios.
## GPU Modes
1. Eco mode : only low power integrated GPU enabled, iGPU drives built in display
2. Standard mode (Windows Hybrid) : iGPU and dGPU enabled, iGPU drives built in display
3. Ultimate mode: iGPU and dGPU enabled, but dGPU drives built in display (supported only on G14 2022 model)
## Things still missing
1. Anime matrix control
2. Custom bindings for M1-M3 keys
## How to install
1. Download latest release from https://github.com/seerge/g-helper/releases
2. Unzip to a folder of your choice
3. Run **GHelper.exe**
Note: Uses low level ASUS ACPI commands to do switching and doens't require Armory Crate to be isntalled at all.
Doesn't require administrator privileges to run (anymore)!
I don`t have Microsoft certificate to sign app yet, so if you set a warning from Windows Defender on launch (Windows Protected your PC), click More Info -> Run anyway.
Alternatively you can comile and run project by yourself :)
Settings file is storer at %AppData%\GHelper
P.S.: It's not recommended to use app in combination with Armory Crate, cause they adjust same settings.
Please keep in mind, that if you also run MyASUS app periodically it will also try to adjust same battery charge settings
------------------
Debloating helps to save your battery and keep laptop a bit cooler
![Helps to save your battery](https://raw.githubusercontent.com/seerge/g-helper/main/screenshots/screen-5w.png)

Binary file not shown.

Before

Width:  |  Height:  |  Size: 421 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 515 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 260 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 885 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.7 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 400 B

603
Settings.Designer.cs generated
View File

@@ -1,603 +0,0 @@
namespace GHelper
{
partial class SettingsForm
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SettingsForm));
checkStartup = new CheckBox();
trackBattery = new TrackBar();
labelBatteryTitle = new Label();
pictureBattery = new PictureBox();
labelGPUFan = new Label();
tableGPU = new TableLayoutPanel();
buttonUltimate = new Button();
buttonStandard = new Button();
buttonEco = new Button();
labelGPU = new Label();
pictureGPU = new PictureBox();
labelCPUFan = new Label();
tablePerf = new TableLayoutPanel();
buttonTurbo = new Button();
buttonBalanced = new Button();
buttonSilent = new Button();
picturePerf = new PictureBox();
labelPerf = new Label();
checkGPU = new CheckBox();
buttonQuit = new Button();
pictureScreen = new PictureBox();
labelSreen = new Label();
tableScreen = new TableLayoutPanel();
button120Hz = new Button();
button60Hz = new Button();
checkScreen = new CheckBox();
checkBoost = new CheckBox();
pictureBox1 = new PictureBox();
label1 = new Label();
comboKeyboard = new ComboBox();
buttonKeyboardColor = new Button();
labelBattery = new Label();
buttonFans = new Button();
((System.ComponentModel.ISupportInitialize)trackBattery).BeginInit();
((System.ComponentModel.ISupportInitialize)pictureBattery).BeginInit();
tableGPU.SuspendLayout();
((System.ComponentModel.ISupportInitialize)pictureGPU).BeginInit();
tablePerf.SuspendLayout();
((System.ComponentModel.ISupportInitialize)picturePerf).BeginInit();
((System.ComponentModel.ISupportInitialize)pictureScreen).BeginInit();
tableScreen.SuspendLayout();
((System.ComponentModel.ISupportInitialize)pictureBox1).BeginInit();
SuspendLayout();
//
// checkStartup
//
checkStartup.AutoSize = true;
checkStartup.Location = new Point(40, 1016);
checkStartup.Margin = new Padding(4, 2, 4, 2);
checkStartup.Name = "checkStartup";
checkStartup.Size = new Size(206, 36);
checkStartup.TabIndex = 2;
checkStartup.Text = "Run on Startup";
checkStartup.UseVisualStyleBackColor = true;
checkStartup.CheckedChanged += checkStartup_CheckedChanged;
//
// trackBattery
//
trackBattery.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
trackBattery.LargeChange = 20;
trackBattery.Location = new Point(20, 908);
trackBattery.Margin = new Padding(4, 2, 4, 2);
trackBattery.Maximum = 100;
trackBattery.Minimum = 50;
trackBattery.Name = "trackBattery";
trackBattery.Size = new Size(676, 90);
trackBattery.SmallChange = 10;
trackBattery.TabIndex = 3;
trackBattery.TickFrequency = 10;
trackBattery.TickStyle = TickStyle.TopLeft;
trackBattery.Value = 100;
//
// labelBatteryTitle
//
labelBatteryTitle.AutoSize = true;
labelBatteryTitle.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
labelBatteryTitle.Location = new Point(76, 870);
labelBatteryTitle.Margin = new Padding(4, 0, 4, 0);
labelBatteryTitle.Name = "labelBatteryTitle";
labelBatteryTitle.Size = new Size(248, 32);
labelBatteryTitle.TabIndex = 4;
labelBatteryTitle.Text = "Battery Charge Limit";
//
// pictureBattery
//
pictureBattery.BackgroundImage = (Image)resources.GetObject("pictureBattery.BackgroundImage");
pictureBattery.BackgroundImageLayout = ImageLayout.Zoom;
pictureBattery.Location = new Point(32, 868);
pictureBattery.Margin = new Padding(4, 2, 4, 2);
pictureBattery.Name = "pictureBattery";
pictureBattery.Size = new Size(36, 38);
pictureBattery.TabIndex = 6;
pictureBattery.TabStop = false;
//
// labelGPUFan
//
labelGPUFan.Anchor = AnchorStyles.Top | AnchorStyles.Right;
labelGPUFan.Location = new Point(410, 262);
labelGPUFan.Margin = new Padding(4, 0, 4, 0);
labelGPUFan.Name = "labelGPUFan";
labelGPUFan.Size = new Size(276, 32);
labelGPUFan.TabIndex = 8;
labelGPUFan.Text = "GPU Fan : 0%";
labelGPUFan.TextAlign = ContentAlignment.TopRight;
//
// tableGPU
//
tableGPU.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
tableGPU.ColumnCount = 3;
tableGPU.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tableGPU.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tableGPU.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tableGPU.Controls.Add(buttonUltimate, 2, 0);
tableGPU.Controls.Add(buttonStandard, 1, 0);
tableGPU.Controls.Add(buttonEco, 0, 0);
tableGPU.Location = new Point(22, 304);
tableGPU.Margin = new Padding(4, 2, 4, 2);
tableGPU.Name = "tableGPU";
tableGPU.RowCount = 1;
tableGPU.RowStyles.Add(new RowStyle(SizeType.Absolute, 108F));
tableGPU.Size = new Size(676, 108);
tableGPU.TabIndex = 7;
//
// buttonUltimate
//
buttonUltimate.BackColor = SystemColors.ControlLightLight;
buttonUltimate.Dock = DockStyle.Fill;
buttonUltimate.FlatAppearance.BorderSize = 0;
buttonUltimate.FlatStyle = FlatStyle.Flat;
buttonUltimate.Location = new Point(458, 12);
buttonUltimate.Margin = new Padding(8, 12, 8, 12);
buttonUltimate.Name = "buttonUltimate";
buttonUltimate.Size = new Size(210, 84);
buttonUltimate.TabIndex = 2;
buttonUltimate.Text = "Ultimate";
buttonUltimate.UseVisualStyleBackColor = false;
//
// buttonStandard
//
buttonStandard.BackColor = SystemColors.ControlLightLight;
buttonStandard.Dock = DockStyle.Fill;
buttonStandard.FlatAppearance.BorderSize = 0;
buttonStandard.FlatStyle = FlatStyle.Flat;
buttonStandard.Location = new Point(233, 12);
buttonStandard.Margin = new Padding(8, 12, 8, 12);
buttonStandard.Name = "buttonStandard";
buttonStandard.Size = new Size(209, 84);
buttonStandard.TabIndex = 1;
buttonStandard.Text = "Standard";
buttonStandard.UseVisualStyleBackColor = false;
//
// buttonEco
//
buttonEco.BackColor = SystemColors.ControlLightLight;
buttonEco.CausesValidation = false;
buttonEco.Dock = DockStyle.Fill;
buttonEco.FlatAppearance.BorderSize = 0;
buttonEco.FlatStyle = FlatStyle.Flat;
buttonEco.Location = new Point(8, 12);
buttonEco.Margin = new Padding(8, 12, 8, 12);
buttonEco.Name = "buttonEco";
buttonEco.Size = new Size(209, 84);
buttonEco.TabIndex = 0;
buttonEco.Text = "Eco";
buttonEco.UseVisualStyleBackColor = false;
//
// labelGPU
//
labelGPU.AutoSize = true;
labelGPU.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
labelGPU.Location = new Point(76, 264);
labelGPU.Margin = new Padding(4, 0, 4, 0);
labelGPU.Name = "labelGPU";
labelGPU.Size = new Size(136, 32);
labelGPU.TabIndex = 9;
labelGPU.Text = "GPU Mode";
//
// pictureGPU
//
pictureGPU.BackgroundImage = (Image)resources.GetObject("pictureGPU.BackgroundImage");
pictureGPU.BackgroundImageLayout = ImageLayout.Zoom;
pictureGPU.Location = new Point(32, 262);
pictureGPU.Margin = new Padding(4, 2, 4, 2);
pictureGPU.Name = "pictureGPU";
pictureGPU.Size = new Size(36, 38);
pictureGPU.TabIndex = 10;
pictureGPU.TabStop = false;
//
// labelCPUFan
//
labelCPUFan.Anchor = AnchorStyles.Top | AnchorStyles.Right;
labelCPUFan.Location = new Point(410, 38);
labelCPUFan.Margin = new Padding(4, 0, 4, 0);
labelCPUFan.Name = "labelCPUFan";
labelCPUFan.Size = new Size(276, 32);
labelCPUFan.TabIndex = 12;
labelCPUFan.Text = "CPU Fan : 0%";
labelCPUFan.TextAlign = ContentAlignment.TopRight;
//
// tablePerf
//
tablePerf.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
tablePerf.ColumnCount = 3;
tablePerf.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tablePerf.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tablePerf.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tablePerf.Controls.Add(buttonTurbo, 2, 0);
tablePerf.Controls.Add(buttonBalanced, 1, 0);
tablePerf.Controls.Add(buttonSilent, 0, 0);
tablePerf.Location = new Point(22, 76);
tablePerf.Margin = new Padding(4, 2, 4, 2);
tablePerf.Name = "tablePerf";
tablePerf.RowCount = 1;
tablePerf.RowStyles.Add(new RowStyle(SizeType.Absolute, 108F));
tablePerf.Size = new Size(676, 108);
tablePerf.TabIndex = 11;
//
// buttonTurbo
//
buttonTurbo.BackColor = SystemColors.ControlLightLight;
buttonTurbo.Dock = DockStyle.Fill;
buttonTurbo.FlatAppearance.BorderColor = Color.FromArgb(192, 0, 0);
buttonTurbo.FlatAppearance.BorderSize = 0;
buttonTurbo.FlatStyle = FlatStyle.Flat;
buttonTurbo.Location = new Point(458, 12);
buttonTurbo.Margin = new Padding(8, 12, 8, 12);
buttonTurbo.Name = "buttonTurbo";
buttonTurbo.Size = new Size(210, 84);
buttonTurbo.TabIndex = 2;
buttonTurbo.Text = "Turbo";
buttonTurbo.UseVisualStyleBackColor = false;
//
// buttonBalanced
//
buttonBalanced.BackColor = SystemColors.ControlLightLight;
buttonBalanced.Dock = DockStyle.Fill;
buttonBalanced.FlatAppearance.BorderColor = Color.FromArgb(0, 0, 192);
buttonBalanced.FlatAppearance.BorderSize = 0;
buttonBalanced.FlatStyle = FlatStyle.Flat;
buttonBalanced.Location = new Point(233, 12);
buttonBalanced.Margin = new Padding(8, 12, 8, 12);
buttonBalanced.Name = "buttonBalanced";
buttonBalanced.Size = new Size(209, 84);
buttonBalanced.TabIndex = 1;
buttonBalanced.Text = "Balanced";
buttonBalanced.UseVisualStyleBackColor = false;
//
// buttonSilent
//
buttonSilent.BackColor = SystemColors.ControlLightLight;
buttonSilent.CausesValidation = false;
buttonSilent.Dock = DockStyle.Fill;
buttonSilent.FlatAppearance.BorderColor = Color.FromArgb(0, 192, 192);
buttonSilent.FlatAppearance.BorderSize = 0;
buttonSilent.FlatStyle = FlatStyle.Flat;
buttonSilent.Location = new Point(8, 12);
buttonSilent.Margin = new Padding(8, 12, 8, 12);
buttonSilent.Name = "buttonSilent";
buttonSilent.Size = new Size(209, 84);
buttonSilent.TabIndex = 0;
buttonSilent.Text = "Silent";
buttonSilent.UseVisualStyleBackColor = false;
//
// picturePerf
//
picturePerf.BackgroundImage = (Image)resources.GetObject("picturePerf.BackgroundImage");
picturePerf.BackgroundImageLayout = ImageLayout.Zoom;
picturePerf.InitialImage = null;
picturePerf.Location = new Point(32, 36);
picturePerf.Margin = new Padding(4, 2, 4, 2);
picturePerf.Name = "picturePerf";
picturePerf.Size = new Size(36, 38);
picturePerf.TabIndex = 14;
picturePerf.TabStop = false;
//
// labelPerf
//
labelPerf.AutoSize = true;
labelPerf.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
labelPerf.Location = new Point(76, 38);
labelPerf.Margin = new Padding(4, 0, 4, 0);
labelPerf.Name = "labelPerf";
labelPerf.Size = new Size(234, 32);
labelPerf.TabIndex = 13;
labelPerf.Text = "Performance Mode";
//
// checkGPU
//
checkGPU.AutoSize = true;
checkGPU.ForeColor = SystemColors.GrayText;
checkGPU.Location = new Point(32, 412);
checkGPU.Margin = new Padding(4, 2, 4, 2);
checkGPU.Name = "checkGPU";
checkGPU.Size = new Size(550, 36);
checkGPU.TabIndex = 15;
checkGPU.Text = "Set Eco on battery and Standard when plugged";
checkGPU.UseVisualStyleBackColor = true;
checkGPU.CheckedChanged += checkGPU_CheckedChanged;
//
// buttonQuit
//
buttonQuit.Anchor = AnchorStyles.Top | AnchorStyles.Right;
buttonQuit.BackColor = SystemColors.ButtonFace;
buttonQuit.Location = new Point(576, 1008);
buttonQuit.Margin = new Padding(4, 2, 4, 2);
buttonQuit.Name = "buttonQuit";
buttonQuit.Size = new Size(120, 48);
buttonQuit.TabIndex = 16;
buttonQuit.Text = "Quit";
buttonQuit.UseVisualStyleBackColor = false;
//
// pictureScreen
//
pictureScreen.BackgroundImage = (Image)resources.GetObject("pictureScreen.BackgroundImage");
pictureScreen.BackgroundImageLayout = ImageLayout.Zoom;
pictureScreen.Location = new Point(32, 496);
pictureScreen.Margin = new Padding(4, 2, 4, 2);
pictureScreen.Name = "pictureScreen";
pictureScreen.Size = new Size(36, 38);
pictureScreen.TabIndex = 18;
pictureScreen.TabStop = false;
//
// labelSreen
//
labelSreen.AutoSize = true;
labelSreen.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
labelSreen.Location = new Point(76, 496);
labelSreen.Margin = new Padding(4, 0, 4, 0);
labelSreen.Name = "labelSreen";
labelSreen.Size = new Size(176, 32);
labelSreen.TabIndex = 17;
labelSreen.Text = "Laptop Screen";
//
// tableScreen
//
tableScreen.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right;
tableScreen.ColumnCount = 3;
tableScreen.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tableScreen.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tableScreen.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33.33333F));
tableScreen.Controls.Add(button120Hz, 1, 0);
tableScreen.Controls.Add(button60Hz, 0, 0);
tableScreen.Location = new Point(22, 536);
tableScreen.Margin = new Padding(4, 2, 4, 2);
tableScreen.Name = "tableScreen";
tableScreen.RowCount = 1;
tableScreen.RowStyles.Add(new RowStyle(SizeType.Absolute, 108F));
tableScreen.Size = new Size(676, 108);
tableScreen.TabIndex = 19;
//
// button120Hz
//
button120Hz.BackColor = SystemColors.ControlLightLight;
button120Hz.Dock = DockStyle.Fill;
button120Hz.FlatAppearance.BorderColor = SystemColors.ActiveBorder;
button120Hz.FlatAppearance.BorderSize = 0;
button120Hz.FlatStyle = FlatStyle.Flat;
button120Hz.Location = new Point(233, 12);
button120Hz.Margin = new Padding(8, 12, 8, 12);
button120Hz.Name = "button120Hz";
button120Hz.Size = new Size(209, 84);
button120Hz.TabIndex = 1;
button120Hz.Text = "120Hz + OD";
button120Hz.UseVisualStyleBackColor = false;
//
// button60Hz
//
button60Hz.BackColor = SystemColors.ControlLightLight;
button60Hz.CausesValidation = false;
button60Hz.Dock = DockStyle.Fill;
button60Hz.FlatAppearance.BorderColor = SystemColors.ActiveBorder;
button60Hz.FlatAppearance.BorderSize = 0;
button60Hz.FlatStyle = FlatStyle.Flat;
button60Hz.ForeColor = SystemColors.ControlText;
button60Hz.Location = new Point(8, 12);
button60Hz.Margin = new Padding(8, 12, 8, 12);
button60Hz.Name = "button60Hz";
button60Hz.Size = new Size(209, 84);
button60Hz.TabIndex = 0;
button60Hz.Text = "60Hz";
button60Hz.UseVisualStyleBackColor = false;
//
// checkScreen
//
checkScreen.AutoSize = true;
checkScreen.ForeColor = SystemColors.GrayText;
checkScreen.Location = new Point(32, 644);
checkScreen.Margin = new Padding(4, 2, 4, 2);
checkScreen.Name = "checkScreen";
checkScreen.Size = new Size(527, 36);
checkScreen.TabIndex = 20;
checkScreen.Text = "Set 60Hz on battery, and back when plugged";
checkScreen.UseVisualStyleBackColor = true;
//
// checkBoost
//
checkBoost.AutoSize = true;
checkBoost.ForeColor = SystemColors.GrayText;
checkBoost.Location = new Point(32, 184);
checkBoost.Margin = new Padding(4, 2, 4, 2);
checkBoost.Name = "checkBoost";
checkBoost.Size = new Size(320, 36);
checkBoost.TabIndex = 21;
checkBoost.Text = "CPU Turbo Boost enabled";
checkBoost.UseVisualStyleBackColor = true;
//
// pictureBox1
//
pictureBox1.BackgroundImage = Properties.Resources.icons8_keyboard_48;
pictureBox1.BackgroundImageLayout = ImageLayout.Zoom;
pictureBox1.Location = new Point(32, 724);
pictureBox1.Margin = new Padding(4, 2, 4, 2);
pictureBox1.Name = "pictureBox1";
pictureBox1.Size = new Size(36, 36);
pictureBox1.TabIndex = 23;
pictureBox1.TabStop = false;
//
// label1
//
label1.AutoSize = true;
label1.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
label1.Location = new Point(76, 724);
label1.Margin = new Padding(4, 0, 4, 0);
label1.Name = "label1";
label1.Size = new Size(210, 32);
label1.TabIndex = 22;
label1.Text = "Laptop Keyboard";
//
// comboKeyboard
//
comboKeyboard.FlatStyle = FlatStyle.Flat;
comboKeyboard.Font = new Font("Segoe UI", 10F, FontStyle.Regular, GraphicsUnit.Point);
comboKeyboard.FormattingEnabled = true;
comboKeyboard.ItemHeight = 37;
comboKeyboard.Items.AddRange(new object[] { "Static", "Breathe", "Strobe", "Rainbow" });
comboKeyboard.Location = new Point(36, 777);
comboKeyboard.Margin = new Padding(0);
comboKeyboard.Name = "comboKeyboard";
comboKeyboard.Size = new Size(200, 45);
comboKeyboard.TabIndex = 24;
comboKeyboard.TabStop = false;
//
// buttonKeyboardColor
//
buttonKeyboardColor.AutoSize = true;
buttonKeyboardColor.BackColor = SystemColors.ButtonHighlight;
buttonKeyboardColor.FlatAppearance.BorderColor = Color.Red;
buttonKeyboardColor.FlatAppearance.BorderSize = 2;
buttonKeyboardColor.FlatStyle = FlatStyle.Flat;
buttonKeyboardColor.ForeColor = SystemColors.ControlText;
buttonKeyboardColor.Location = new Point(256, 775);
buttonKeyboardColor.Margin = new Padding(0);
buttonKeyboardColor.Name = "buttonKeyboardColor";
buttonKeyboardColor.Size = new Size(212, 50);
buttonKeyboardColor.TabIndex = 25;
buttonKeyboardColor.Text = "Color";
buttonKeyboardColor.UseVisualStyleBackColor = false;
//
// labelBattery
//
labelBattery.Anchor = AnchorStyles.Top | AnchorStyles.Right;
labelBattery.Location = new Point(410, 868);
labelBattery.Margin = new Padding(4, 0, 4, 0);
labelBattery.Name = "labelBattery";
labelBattery.Size = new Size(276, 32);
labelBattery.TabIndex = 27;
labelBattery.Text = " ";
labelBattery.TextAlign = ContentAlignment.TopRight;
//
// buttonFans
//
buttonFans.Anchor = AnchorStyles.Top | AnchorStyles.Right;
buttonFans.BackColor = SystemColors.ButtonFace;
buttonFans.FlatAppearance.BorderSize = 0;
buttonFans.Location = new Point(480, 186);
buttonFans.Margin = new Padding(4, 2, 4, 2);
buttonFans.Name = "buttonFans";
buttonFans.Size = new Size(210, 48);
buttonFans.TabIndex = 28;
buttonFans.Text = "Fan Profile";
buttonFans.UseVisualStyleBackColor = false;
//
// SettingsForm
//
AutoScaleDimensions = new SizeF(192F, 192F);
AutoScaleMode = AutoScaleMode.Dpi;
ClientSize = new Size(730, 1086);
Controls.Add(buttonFans);
Controls.Add(labelBattery);
Controls.Add(buttonKeyboardColor);
Controls.Add(comboKeyboard);
Controls.Add(pictureBox1);
Controls.Add(label1);
Controls.Add(checkBoost);
Controls.Add(checkScreen);
Controls.Add(tableScreen);
Controls.Add(pictureScreen);
Controls.Add(labelSreen);
Controls.Add(buttonQuit);
Controls.Add(checkGPU);
Controls.Add(picturePerf);
Controls.Add(labelPerf);
Controls.Add(labelCPUFan);
Controls.Add(tablePerf);
Controls.Add(pictureGPU);
Controls.Add(labelGPU);
Controls.Add(labelGPUFan);
Controls.Add(tableGPU);
Controls.Add(pictureBattery);
Controls.Add(labelBatteryTitle);
Controls.Add(trackBattery);
Controls.Add(checkStartup);
FormBorderStyle = FormBorderStyle.FixedSingle;
Margin = new Padding(4, 2, 4, 2);
MaximizeBox = false;
MdiChildrenMinimizedAnchorBottom = false;
MinimizeBox = false;
Name = "SettingsForm";
Padding = new Padding(8, 12, 8, 12);
ShowIcon = false;
StartPosition = FormStartPosition.CenterScreen;
Text = "G-Helper";
Load += Settings_Load;
((System.ComponentModel.ISupportInitialize)trackBattery).EndInit();
((System.ComponentModel.ISupportInitialize)pictureBattery).EndInit();
tableGPU.ResumeLayout(false);
((System.ComponentModel.ISupportInitialize)pictureGPU).EndInit();
tablePerf.ResumeLayout(false);
((System.ComponentModel.ISupportInitialize)picturePerf).EndInit();
((System.ComponentModel.ISupportInitialize)pictureScreen).EndInit();
tableScreen.ResumeLayout(false);
((System.ComponentModel.ISupportInitialize)pictureBox1).EndInit();
ResumeLayout(false);
PerformLayout();
}
#endregion
private CheckBox checkStartup;
private TrackBar trackBattery;
private Label labelBatteryTitle;
private PictureBox pictureBattery;
private Label labelGPUFan;
private TableLayoutPanel tableGPU;
private Button buttonUltimate;
private Button buttonStandard;
private Button buttonEco;
private Label labelGPU;
private PictureBox pictureGPU;
private Label labelCPUFan;
private TableLayoutPanel tablePerf;
private Button buttonTurbo;
private Button buttonBalanced;
private Button buttonSilent;
private PictureBox picturePerf;
private Label labelPerf;
private CheckBox checkGPU;
private Button buttonQuit;
private PictureBox pictureScreen;
private Label labelSreen;
private TableLayoutPanel tableScreen;
private Button button120Hz;
private Button button60Hz;
private CheckBox checkScreen;
private CheckBox checkBoost;
private PictureBox pictureBox1;
private Label label1;
private ComboBox comboKeyboard;
private Button buttonKeyboardColor;
private Label labelBattery;
private Button buttonFans;
}
}

View File

@@ -1,708 +0,0 @@
using System.Diagnostics;
using System.Timers;
namespace GHelper
{
public partial class SettingsForm : Form
{
static Color colorEco = Color.FromArgb(255, 6, 180, 138);
static Color colorStandard = Color.FromArgb(255, 58, 174, 239);
static Color colorTurbo = Color.FromArgb(255, 255, 32, 32);
static int buttonInactive = 0;
static int buttonActive = 5;
static System.Timers.Timer aTimer = default!;
public string perfName;
Fans fans;
public SettingsForm()
{
InitializeComponent();
FormClosing += SettingsForm_FormClosing;
buttonSilent.FlatAppearance.BorderColor = colorEco;
buttonBalanced.FlatAppearance.BorderColor = colorStandard;
buttonTurbo.FlatAppearance.BorderColor = colorTurbo;
buttonEco.FlatAppearance.BorderColor = colorEco;
buttonStandard.FlatAppearance.BorderColor = colorStandard;
buttonUltimate.FlatAppearance.BorderColor = colorTurbo;
buttonSilent.Click += ButtonSilent_Click;
buttonBalanced.Click += ButtonBalanced_Click;
buttonTurbo.Click += ButtonTurbo_Click;
buttonEco.Click += ButtonEco_Click;
buttonStandard.Click += ButtonStandard_Click;
buttonUltimate.Click += ButtonUltimate_Click;
VisibleChanged += SettingsForm_VisibleChanged;
trackBattery.Scroll += trackBatteryChange;
button60Hz.Click += Button60Hz_Click;
button120Hz.Click += Button120Hz_Click;
buttonQuit.Click += ButtonQuit_Click;
checkBoost.Click += CheckBoost_Click;
checkScreen.CheckedChanged += checkScreen_CheckedChanged;
comboKeyboard.DropDownStyle = ComboBoxStyle.DropDownList;
comboKeyboard.SelectedIndex = 0;
comboKeyboard.SelectedValueChanged += ComboKeyboard_SelectedValueChanged;
buttonKeyboardColor.Click += ButtonKeyboardColor_Click;
buttonFans.Click += ButtonFans_Click;
SetTimer();
}
private void ButtonFans_Click(object? sender, EventArgs e)
{
if (fans == null || fans.Text == "")
{
fans = new Fans();
fans.Show();
}
else
{
fans.Close();
}
}
private void ButtonKeyboardColor_Click(object? sender, EventArgs e)
{
if (sender is null)
return;
Button but = (Button)sender;
ColorDialog colorDlg = new ColorDialog();
colorDlg.AllowFullOpen = false;
colorDlg.Color = but.FlatAppearance.BorderColor;
if (colorDlg.ShowDialog() == DialogResult.OK)
{
SetAuraColor(colorDlg.Color);
}
}
public void InitAura()
{
int mode = Program.config.getConfig("aura_mode");
int colorCode = Program.config.getConfig("aura_color");
int speed = Program.config.getConfig("aura_speed");
Color color = Color.FromArgb(255, 255, 255);
if (mode == -1)
mode = 0;
if (colorCode != -1)
color = Color.FromArgb(colorCode);
SetAuraColor(color, false);
SetAuraMode(mode, false);
Aura.Mode = mode;
}
public void SetAuraColor(Color color, bool apply = true)
{
Aura.Color1 = color;
Program.config.setConfig("aura_color", color.ToArgb());
if (apply)
Aura.ApplyAura();
buttonKeyboardColor.FlatAppearance.BorderColor = color;
}
public void SetAuraMode(int mode = 0, bool apply = true)
{
//Debug.WriteLine(mode);
if (mode > 3) mode = 0;
if (Aura.Mode == mode) return; // same mode
Aura.Mode = mode;
Program.config.setConfig("aura_mode", mode);
comboKeyboard.SelectedValueChanged -= ComboKeyboard_SelectedValueChanged;
comboKeyboard.SelectedIndex = mode;
comboKeyboard.SelectedValueChanged += ComboKeyboard_SelectedValueChanged;
if (apply)
Aura.ApplyAura();
}
public void CycleAuraMode()
{
SetAuraMode(Program.config.getConfig("aura_mode") + 1);
}
private void ComboKeyboard_SelectedValueChanged(object? sender, EventArgs e)
{
if (sender is null)
return;
ComboBox cmb = (ComboBox)sender;
SetAuraMode(cmb.SelectedIndex);
}
private void CheckBoost_Click(object? sender, EventArgs e)
{
if (sender is null)
return;
CheckBox chk = (CheckBox)sender;
if (chk.Checked)
NativeMethods.SetCPUBoost(3);
else
NativeMethods.SetCPUBoost(0);
}
private void Button120Hz_Click(object? sender, EventArgs e)
{
SetScreen(1000, 1);
}
private void Button60Hz_Click(object? sender, EventArgs e)
{
SetScreen(60, 0);
}
public void SetScreen(int frequency = -1, int overdrive = -1)
{
int currentFrequency = NativeMethods.GetRefreshRate();
if (currentFrequency < 0) // Laptop screen not detected or has unknown refresh rate
return;
if (frequency >= 1000)
{
frequency = Program.config.getConfig("max_frequency");
if (frequency <= 60)
frequency = 120;
}
if (frequency > 0)
NativeMethods.SetRefreshRate(frequency);
try
{
if (overdrive > 0)
Program.wmi.DeviceSet(ASUSWmi.ScreenOverdrive, overdrive);
}
catch
{
Debug.WriteLine("Screen Overdrive not supported");
}
InitScreen();
}
public void InitBoost()
{
int boost = NativeMethods.GetCPUBoost();
checkBoost.Checked = (boost > 0);
}
public void InitScreen()
{
int frequency = NativeMethods.GetRefreshRate();
int maxFrequency = Program.config.getConfig("max_frequency");
if (frequency < 0)
{
button60Hz.Enabled = false;
button120Hz.Enabled = false;
labelSreen.Text = "Laptop Screen: Turned off";
button60Hz.BackColor = SystemColors.ControlLight;
button120Hz.BackColor = SystemColors.ControlLight;
}
else
{
button60Hz.Enabled = true;
button120Hz.Enabled = true;
button60Hz.BackColor = SystemColors.ControlLightLight;
button120Hz.BackColor = SystemColors.ControlLightLight;
labelSreen.Text = "Laptop Screen";
}
int overdrive = 0;
try
{
overdrive = Program.wmi.DeviceGet(ASUSWmi.ScreenOverdrive);
}
catch
{
Debug.WriteLine("Screen Overdrive not supported");
}
button60Hz.FlatAppearance.BorderSize = buttonInactive;
button120Hz.FlatAppearance.BorderSize = buttonInactive;
if (frequency == 60)
{
button60Hz.FlatAppearance.BorderSize = buttonActive;
}
else
{
if (frequency > 60)
maxFrequency = frequency;
Program.config.setConfig("max_frequency", maxFrequency);
button120Hz.FlatAppearance.BorderSize = buttonActive;
}
if (maxFrequency > 60)
{
button120Hz.Text = maxFrequency.ToString() + "Hz + OD";
}
Program.config.setConfig("frequency", frequency);
Program.config.setConfig("overdrive", overdrive);
}
private void ButtonQuit_Click(object? sender, EventArgs e)
{
Close();
Program.trayIcon.Visible = false;
Application.Exit();
}
private void SettingsForm_FormClosing(object? sender, FormClosingEventArgs e)
{
if (e.CloseReason == CloseReason.UserClosing)
{
e.Cancel = true;
Hide();
}
}
private void ButtonUltimate_Click(object? sender, EventArgs e)
{
SetGPUMode(ASUSWmi.GPUModeUltimate);
}
private void ButtonStandard_Click(object? sender, EventArgs e)
{
SetGPUMode(ASUSWmi.GPUModeStandard);
}
private void ButtonEco_Click(object? sender, EventArgs e)
{
SetGPUMode(ASUSWmi.GPUModeEco);
}
private static void SetTimer()
{
aTimer = new System.Timers.Timer(500);
aTimer.Elapsed += OnTimedEvent;
aTimer.AutoReset = true;
aTimer.Enabled = false;
}
private static void RefreshSensors()
{
string cpuFan = " Fan: " + Math.Round(Program.wmi.DeviceGet(ASUSWmi.CPU_Fan) / 0.6).ToString() + "%";
string gpuFan = " Fan: " + Math.Round(Program.wmi.DeviceGet(ASUSWmi.GPU_Fan) / 0.6).ToString() + "%";
string cpuTemp = "";
string gpuTemp = "";
string battery = "";
HardwareMonitor.ReadSensors();
if (HardwareMonitor.cpuTemp > 0)
cpuTemp = ": " + Math.Round((decimal)HardwareMonitor.cpuTemp).ToString() + "°C - ";
if (HardwareMonitor.batteryDischarge > 0)
battery = "Discharging: " + Math.Round((decimal)HardwareMonitor.batteryDischarge, 1).ToString() + "W";
Program.settingsForm.BeginInvoke(delegate
{
Program.settingsForm.labelCPUFan.Text = "CPU" + cpuTemp + cpuFan;
Program.settingsForm.labelGPUFan.Text = "GPU" + gpuTemp + gpuFan;
Program.settingsForm.labelBattery.Text = battery;
});
}
private static void OnTimedEvent(Object? source, ElapsedEventArgs? e)
{
RefreshSensors();
aTimer.Interval = 2000;
}
private void SettingsForm_VisibleChanged(object? sender, EventArgs e)
{
if (this.Visible)
{
InitScreen();
this.Left = Screen.FromControl(this).WorkingArea.Width - 10 - this.Width;
this.Top = Screen.FromControl(this).WorkingArea.Height - 10 - this.Height;
this.Activate();
aTimer.Interval = 500;
aTimer.Enabled = true;
}
else
{
aTimer.Enabled = false;
}
}
public void SetPerformanceMode(int PerformanceMode = ASUSWmi.PerformanceBalanced, bool notify = false)
{
buttonSilent.FlatAppearance.BorderSize = buttonInactive;
buttonBalanced.FlatAppearance.BorderSize = buttonInactive;
buttonTurbo.FlatAppearance.BorderSize = buttonInactive;
switch (PerformanceMode)
{
case ASUSWmi.PerformanceSilent:
buttonSilent.FlatAppearance.BorderSize = buttonActive;
perfName = "Silent";
break;
case ASUSWmi.PerformanceTurbo:
buttonTurbo.FlatAppearance.BorderSize = buttonActive;
perfName = "Turbo";
break;
default:
buttonBalanced.FlatAppearance.BorderSize = buttonActive;
PerformanceMode = ASUSWmi.PerformanceBalanced;
perfName = "Balanced";
break;
}
Program.config.setConfig("performance_mode", PerformanceMode);
try
{
Program.wmi.DeviceSet(ASUSWmi.PerformanceMode, PerformanceMode);
}
catch
{
labelPerf.Text = "Performance Mode: not supported";
}
if (fans != null && fans.Text != "")
fans.LoadFans();
if (notify) {
try
{
Program.toast.RunToast(perfName);
} catch
{
Debug.WriteLine("Toast error");
}
}
}
public void CyclePerformanceMode()
{
SetPerformanceMode(Program.config.getConfig("performance_mode") + 1, true);
}
public void AutoScreen(int Plugged = 1)
{
int ScreenAuto = Program.config.getConfig("screen_auto");
if (ScreenAuto != 1) return;
if (Plugged == 1)
SetScreen(1000, 1);
else
SetScreen(60, 0);
InitScreen();
}
public void AutoGPUMode(int Plugged = 1)
{
int GpuAuto = Program.config.getConfig("gpu_auto");
if (GpuAuto != 1) return;
int eco = Program.wmi.DeviceGet(ASUSWmi.GPUEco);
int mux = Program.wmi.DeviceGet(ASUSWmi.GPUMux);
if (mux == 0) // GPU in Ultimate, ignore
return;
else
{
if (eco == 1 && Plugged == 1) // Eco going Standard on plugged
{
Program.wmi.DeviceSet(ASUSWmi.GPUEco, 0);
InitGPUMode();
}
else if (eco == 0 && Plugged == 0) // Standard going Eco on plugged
{
Program.wmi.DeviceSet(ASUSWmi.GPUEco, 1);
InitGPUMode();
}
}
}
public int InitGPUMode()
{
int eco = Program.wmi.DeviceGet(ASUSWmi.GPUEco);
int mux = Program.wmi.DeviceGet(ASUSWmi.GPUMux);
int GpuMode;
if (mux == 0)
GpuMode = ASUSWmi.GPUModeUltimate;
else
{
if (eco == 1)
GpuMode = ASUSWmi.GPUModeEco;
else
GpuMode = ASUSWmi.GPUModeStandard;
if (mux != 1)
Disable_Ultimate();
}
Program.config.setConfig("gpu_mode", GpuMode);
VisualiseGPUMode(GpuMode);
return GpuMode;
}
public void SetGPUMode(int GPUMode = ASUSWmi.GPUModeStandard)
{
int CurrentGPU = Program.config.getConfig("gpu_mode");
if (CurrentGPU == GPUMode)
return;
var restart = false;
var changed = false;
if (CurrentGPU == ASUSWmi.GPUModeUltimate)
{
DialogResult dialogResult = MessageBox.Show("Switching off Ultimate Mode requires restart", "Reboot now?", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
Program.wmi.DeviceSet(ASUSWmi.GPUMux, 1);
restart = true;
changed = true;
}
}
else if (GPUMode == ASUSWmi.GPUModeUltimate)
{
DialogResult dialogResult = MessageBox.Show(" Ultimate Mode requires restart", "Reboot now?", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
Program.wmi.DeviceSet(ASUSWmi.GPUMux, 0);
restart = true;
changed = true;
}
}
else if (GPUMode == ASUSWmi.GPUModeEco)
{
VisualiseGPUMode(GPUMode);
Program.wmi.DeviceSet(ASUSWmi.GPUEco, 1);
changed = true;
}
else if (GPUMode == ASUSWmi.GPUModeStandard)
{
VisualiseGPUMode(GPUMode);
Program.wmi.DeviceSet(ASUSWmi.GPUEco, 0);
changed = true;
}
if (changed)
Program.config.setConfig("gpu_mode", GPUMode);
if (restart)
{
VisualiseGPUMode(GPUMode);
Process.Start("shutdown", "/r /t 1");
}
}
public void VisualiseGPUAuto(int GPUAuto)
{
checkGPU.Checked = (GPUAuto == 1);
}
public void VisualiseScreenAuto(int ScreenAuto)
{
checkScreen.Checked = (ScreenAuto == 1);
}
public void VisualiseGPUMode(int GPUMode)
{
buttonEco.FlatAppearance.BorderSize = buttonInactive;
buttonStandard.FlatAppearance.BorderSize = buttonInactive;
buttonUltimate.FlatAppearance.BorderSize = buttonInactive;
switch (GPUMode)
{
case ASUSWmi.GPUModeEco:
buttonEco.FlatAppearance.BorderSize = buttonActive;
labelGPU.Text = "GPU Mode: iGPU only";
Program.trayIcon.Icon = GHelper.Properties.Resources.eco;
break;
case ASUSWmi.GPUModeUltimate:
buttonUltimate.FlatAppearance.BorderSize = buttonActive;
labelGPU.Text = "GPU Mode: dGPU exclusive";
Program.trayIcon.Icon = GHelper.Properties.Resources.ultimate;
break;
default:
buttonStandard.FlatAppearance.BorderSize = buttonActive;
labelGPU.Text = "GPU Mode: iGPU and dGPU";
Program.trayIcon.Icon = GHelper.Properties.Resources.standard;
break;
}
}
private void ButtonSilent_Click(object? sender, EventArgs e)
{
SetPerformanceMode(ASUSWmi.PerformanceSilent);
}
private void ButtonBalanced_Click(object? sender, EventArgs e)
{
SetPerformanceMode(ASUSWmi.PerformanceBalanced);
}
private void ButtonTurbo_Click(object? sender, EventArgs e)
{
SetPerformanceMode(ASUSWmi.PerformanceTurbo);
}
private void Settings_Load(object sender, EventArgs e)
{
}
public void Disable_Ultimate()
{
buttonUltimate.Enabled = false;
buttonUltimate.BackColor = SystemColors.ControlLight;
}
public void SetStartupCheck(bool status)
{
checkStartup.Checked = status;
}
private void checkStartup_CheckedChanged(object sender, EventArgs e)
{
CheckBox chk = (CheckBox)sender;
if (chk.Checked)
{
Startup.Schedule();
}
else
{
Startup.UnSchedule();
}
}
public void SetBatteryChargeLimit(int limit = 100)
{
if (limit < 50 || limit > 100) limit = 100;
labelBatteryTitle.Text = "Battery Charge Limit: " + limit.ToString() + "%";
trackBattery.Value = limit;
try
{
Program.wmi.DeviceSet(ASUSWmi.BatteryLimit, limit);
}
catch
{
Debug.WriteLine("Can't set battery charge limit");
}
Program.config.setConfig("charge_limit", limit);
}
private void trackBatteryChange(object? sender, EventArgs e)
{
if (sender is null)
return;
TrackBar bar = (TrackBar)sender;
SetBatteryChargeLimit(bar.Value);
}
private void checkGPU_CheckedChanged(object? sender, EventArgs e)
{
if (sender is null)
return;
CheckBox chk = (CheckBox)sender;
if (chk.Checked)
Program.config.setConfig("gpu_auto", 1);
else
Program.config.setConfig("gpu_auto", 0);
}
private void checkScreen_CheckedChanged(object? sender, EventArgs e)
{
if (sender is null)
return;
CheckBox chk = (CheckBox)sender;
if (chk.Checked)
Program.config.setConfig("screen_auto", 1);
else
Program.config.setConfig("screen_auto", 0);
}
}
}

View File

@@ -1,118 +0,0 @@
<root>
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<data name="pictureBattery.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>
iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
DAAACwwBP0AiyAAAAY1JREFUaEPtlz1OAzEQhVdIFFyCH0EFDQ1wAhDcgxPACYCOA/BzGTo6aKGKFOAE
0FCABO9FsbSK3uI8J9kFMZ/0FdmMZ+xovLGrIAiCIAiCQLIMr+EL/IRfM5Y1WOsKsvZE7ME3qAq1IWvv
wiJWYJeTT77CJWjDtlEJu/AS2rAPVbIufII2bWzYceVcbFQix1V4CKe1j2xUEscEN+ANVDGONiqJY505
eATfoYp15N48gFnUYEfFOryDKt7xGWZRA0flhHbgOewNnyWbmIcn8APW412zqEGj8u9+ASY24Rl8GHz6
mS34CFXeccyiBik5iW2Yg4vi4rjIBBfPH0HlzZlFDWqS7XAK2R5N1OPZbmw7tt/G8JlrFjUo5z3khBQq
vtSpbWIlX5XHkK/OOiq2RE5+H2ZRgx1v4RpMqBhHG5XElccIHie4EPW9o82fP8yx11SyLuxDm9L38yy8
gDa8UP+WK+UiLIIXaiZQiduQtYsv9Qme53kn5bWujY3NGqzFtin+5YMgCIIgCP4PVfUNWXMTLz5Z0sYA
AAAASUVORK5CYII=
</value>
</data>
<data name="pictureGPU.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>
iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
DAAACwwBP0AiyAAAAZVJREFUaEPtmTtOxDAURYcGGtgAsCJo6PisACE2ALTAvvgVsB0KQBRwT2HJGl3y
EtloHPCRjiKNfJ/sOLGV8aLT6XSa4Fa+ya/MD3kjm2dNvsq888l3OQu408szkJwlfQCr5k8NoAVZEV/k
vhyFK9KKBzLEBVvxWYa4YCuO2ptcsCVDXKim9/JQbst1uSOP5IN07ZcNcaEafspTOcSZpJ3LJ0NcCC8k
d8zB75fS5ZJR5xMMwuWTIS6Em3KILelyeCen8ChdHQxxIeQOD83AlXQ55JmfwrF0dTDEhUrlhZ0CL7ar
gyEuVOpPM/cTG9LVwRAXKnXqDOxKVwdDXAhLViHW+SmcSFcHQ1wIS1YhNqmx8Jn7JF0dDHEhLFmFkPV9
DOfS5ZMhLlRDdthoEHT+13biWrJJsc7zojJzXHnmhx6b3BAXaskQF2rF2X8PzP6LbE+GuOAq5V8J7vyo
zkMeniX/ZgB5u5oWM7ZY3q6mxYwtxsuVt61hlTOJdFbAdQjOFWoOglrXshg6xqnNLI6YOp1OZ1UsFt/W
cWCm8IATjAAAAABJRU5ErkJggg==
</value>
</data>
<data name="picturePerf.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>
iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
DAAACwwBP0AiyAAAA31JREFUaEPt2NnrTkEcx/HHmj37hTWJP0BCSe5ESSnklivJUsiuXFiSIlsS98qW
CLmTP0FKUkqkrNn37f2p39T07fucmfM85/eQzqdexW/mzJlzzpyZeU6jTp06df6L9MQsbMdF3MVrfOui
f+tvF7ANM6Fj/nrGYT+e4HdJj7EPY9HxjMBJfIXXuTK+4ASGoyNZjpfwOtOOF1iGbktv6K57J6/Scehc
laY/rsI7YfADt7EReqFHow8GYCJmYzNu4ju8NoIr0Dkrie5GUec/4QDU4dzMh9dWTBdRyZMoGjbnMR5l
oxfWa886hraiF9Zr+Cc05/dAHF3MGtzAPXzARzzCNWzAAmit8Nr1LEFL0VTpzTbqvC4sjuby09B7YOsX
UVvrMBA7u/5mPccwlE6zoaM7H2cR3sGrW0SdX4mQIfDqSemhpBXWW6Q05uNhsxbqiK2XYjuvrIdXV7TY
jUF2tD2wjWi2iV9Y3fmqOq//p9rai6z0gre30VQZojFfxbBRcjovmgiyNoBahOzBejnjef4MbJ2UnM6f
w1BonfAWuxlIRi+pPVArbIiGUSuzTc6dn4cQrdhxmWxBMpdgD9T8HaIX15YX+YVViNNs2MTn2Qpbrkkk
Gf3wsAdqWIVchy23NINp36OZYxDiNOu8aMsSor2TLb+DZF7BHjgKIfdhy61mj7qo8/IQIZNgy7XlTsab
//siJGf28ebswSjqvGjrEaLV2ZZrPUhGleyB8TB4D1tueRegqderG9PNCdEF2/KsC9Dewx44BSEPYMst
bwh5L6Wl4RkyFbb8GZLxXuI5CNFO05ZbGoa6CD0J0b9zfj9rxxoyF7Y86yXWYmIP3ISQstNoGasRoou2
5WeRzA7YA28hZAJSPwlboTbjvZYWT1tH35SSmQ57oBofiRDt/W2ddp1CiLYt3mo/Dclow/QU9uB4M6ft
9lvYOq16g/gD10HYOvoQZn8BNs0e2AY+I37E2nCV3RN5tDYsRIguRFt3W283sqOO6pumbUTfNuO7oEZt
nbLijqltby+mGSx+Qlk5AtuQ6LdryGR4dcrQliFkF7w6h1E6emm9fZEe+QpopVTDtrysQ1BbzfZJ2v+0
/N10MWyDnbYUbUVfjr2GO+Eo2o5+I5f5EFWVyj4tKvrQehneibqDZqJ+qDR6EnrhcjZlrVLbOofOVadO
nTr/fBqNP4sju3bXhjy/AAAAAElFTkSuQmCC
</value>
</data>
<data name="pictureScreen.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>
iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAL
DAAACwwBP0AiyAAAANBJREFUaEPt2DESAUEUhOF1PQQuxd1wHAGi1U8galU9ktej+qv6M71myyZriYiI
+Fd7dEFPtDZV311n2KEhdXh2wc4OSHZF7CKdnZGs87H51gPJ2AUckrGxQzI2dkjGxg7J2NghGRs7JGNj
h2Rs7JCMjR2SsbFDMjZ2SMbGDsnY2CEZGzskY2OHZGzskIyNHZKxsUOy6V8pp3+pr/9h2EU626IhdRN1
191/bNUZhg8fMeiE7og9h47VWY/obYNuiH3QuTrzR93NtL9ARET8aFleMDJURjd/4/oAAAAASUVORK5C
YII=
</value>
</data>
</root>

View File

@@ -1,53 +0,0 @@
using Microsoft.Win32.TaskScheduler;
using System.Diagnostics;
using System.Security.Principal;
public class Startup
{
static string taskName = "GHelper";
public static bool IsScheduled()
{
TaskService taskService = new TaskService();
// cleanup of OLD autorun
try
{
taskService.RootFolder.DeleteTask("GSharpHelper");
} catch
{
Debug.WriteLine("Not running as admin");
}
return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
}
public static void Schedule()
{
string strExeFilePath = Application.ExecutablePath;
if (strExeFilePath is null) return;
var userId = WindowsIdentity.GetCurrent().Name;
//Debug.WriteLine(strExeFilePath);
TaskDefinition td = TaskService.Instance.NewTask();
td.RegistrationInfo.Description = "GHelper Auto Start";
td.Triggers.Add(new LogonTrigger { UserId = userId, });
td.Actions.Add(strExeFilePath);
td.Settings.StopIfGoingOnBatteries = false;
td.Settings.DisallowStartIfOnBatteries = false;
TaskService.Instance.RootFolder.RegisterTaskDefinition(taskName, td);
}
public static void UnSchedule()
{
TaskService taskService = new TaskService();
taskService.RootFolder.DeleteTask(taskName);
}
}

View File

@@ -1,94 +0,0 @@
using System.Drawing.Drawing2D;
using OSD;
namespace GHelper
{
static class Drawing
{
public static GraphicsPath RoundedRect(Rectangle bounds, int radius)
{
int diameter = radius * 2;
Size size = new Size(diameter, diameter);
Rectangle arc = new Rectangle(bounds.Location, size);
GraphicsPath path = new GraphicsPath();
if (radius == 0)
{
path.AddRectangle(bounds);
return path;
}
path.AddArc(arc, 180, 90);
arc.X = bounds.Right - diameter;
path.AddArc(arc, 270, 90);
arc.Y = bounds.Bottom - diameter;
path.AddArc(arc, 0, 90);
arc.X = bounds.Left;
path.AddArc(arc, 90, 90);
path.CloseFigure();
return path;
}
public static void FillRoundedRectangle(this Graphics graphics, Brush brush, Rectangle bounds, int cornerRadius)
{
using (GraphicsPath path = RoundedRect(bounds, cornerRadius))
{
graphics.FillPath(brush, path);
}
}
}
class ToastForm : OSDNativeForm
{
protected static string toastText = "Balanced";
protected static System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
protected override void PerformPaint(PaintEventArgs e)
{
Brush brush = new SolidBrush(Color.FromArgb(150,Color.Black));
Drawing.FillRoundedRectangle(e.Graphics, brush, this.Bound, 10);
StringFormat format = new StringFormat();
format.LineAlignment = StringAlignment.Center;
format.Alignment = StringAlignment.Center;
e.Graphics.DrawString(toastText,
new Font("Segoe UI", 16f, FontStyle.Bold),
new SolidBrush(Color.White),
new PointF(this.Bound.Width/2, this.Bound.Height / 2),
format);
}
public void RunToast(string text)
{
toastText = text;
Screen screen1 = Screen.FromHandle(base.Handle);
Width = 300;
Height = 100;
X = (screen1.Bounds.Width - this.Width)/2;
Y = screen1.Bounds.Height - 300 - this.Height;
Show();
timer.Stop();
timer.Tick -= timer_Tick;
timer.Tick += timer_Tick;
timer.Enabled = true;
timer.Interval = 2000;
timer.Start();
}
private void timer_Tick(object? sender, EventArgs e)
{
timer.Stop();
Hide();
}
}
}

View File

@@ -0,0 +1,388 @@
using NAudio.CoreAudioApi;
using NAudio.Wave;
using Starlight.AnimeMatrix;
using System.Diagnostics;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Timers;
namespace GHelper.AnimeMatrix
{
public class AniMatrixControl
{
SettingsForm settings;
System.Timers.Timer matrixTimer = default!;
public AnimeMatrixDevice? device;
double[]? AudioValues;
WasapiCapture? AudioDevice;
public bool IsValid => device != null;
private long lastPresent;
private List<double> maxes = new List<double>();
public AniMatrixControl(SettingsForm settingsForm)
{
settings = settingsForm;
try
{
device = new AnimeMatrixDevice();
Task.Run(device.WakeUp);
matrixTimer = new System.Timers.Timer(100);
matrixTimer.Elapsed += MatrixTimer_Elapsed;
}
catch
{
device = null;
}
}
public void SetMatrix(bool wakeUp = false)
{
if (!IsValid) return;
int brightness = AppConfig.Get("matrix_brightness");
int running = AppConfig.Get("matrix_running");
bool auto = AppConfig.Is("matrix_auto");
if (brightness < 0) brightness = 0;
if (running < 0) running = 0;
BuiltInAnimation animation = new BuiltInAnimation(
(BuiltInAnimation.Running)running,
BuiltInAnimation.Sleeping.Starfield,
BuiltInAnimation.Shutdown.SeeYa,
BuiltInAnimation.Startup.StaticEmergence
);
StopMatrixTimer();
StopMatrixAudio();
try
{
device.SetProvider();
}
catch (Exception ex)
{
Logger.WriteLine(ex.Message);
return;
}
if (wakeUp && AppConfig.ContainsModel("401")) device.WakeUp();
if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online))
{
device.SetDisplayState(false);
device.SetDisplayState(false); // some devices are dumb
Logger.WriteLine("Matrix Off");
}
else
{
device.SetDisplayState(true);
device.SetBrightness((BrightnessMode)brightness);
switch (running)
{
case 2:
SetMatrixPicture(AppConfig.GetString("matrix_picture"));
break;
case 3:
SetMatrixClock();
break;
case 4:
SetMatrixAudio();
break;
default:
device.SetBuiltInAnimation(true, animation);
Logger.WriteLine("Matrix builtin " + animation.AsByte);
break;
}
//mat.SetBrightness((BrightnessMode)brightness);
}
}
private void StartMatrixTimer(int interval = 100)
{
matrixTimer.Interval = interval;
matrixTimer.Start();
}
private void StopMatrixTimer()
{
matrixTimer.Stop();
}
private void MatrixTimer_Elapsed(object? sender, ElapsedEventArgs e)
{
//if (!IsValid) return;
switch (AppConfig.Get("matrix_running"))
{
case 2:
device.PresentNextFrame();
break;
case 3:
device.PresentClock();
break;
}
}
public void SetMatrixClock()
{
device.SetBuiltInAnimation(false);
StartMatrixTimer(1000);
Logger.WriteLine("Matrix Clock");
}
public void Dispose()
{
StopMatrixAudio();
}
void StopMatrixAudio()
{
if (AudioDevice is not null)
{
try
{
AudioDevice.StopRecording();
AudioDevice.Dispose();
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
}
}
void SetMatrixAudio()
{
if (!IsValid) return;
device.SetBuiltInAnimation(false);
StopMatrixTimer();
StopMatrixAudio();
try
{
using (var enumerator = new MMDeviceEnumerator())
using (MMDevice device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console))
{
AudioDevice = new WasapiLoopbackCapture(device);
WaveFormat fmt = AudioDevice.WaveFormat;
AudioValues = new double[fmt.SampleRate / 1000];
AudioDevice.DataAvailable += WaveIn_DataAvailable;
AudioDevice.StartRecording();
Logger.WriteLine("Matrix Audio");
}
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
}
private void WaveIn_DataAvailable(object? sender, WaveInEventArgs e)
{
int bytesPerSamplePerChannel = AudioDevice.WaveFormat.BitsPerSample / 8;
int bytesPerSample = bytesPerSamplePerChannel * AudioDevice.WaveFormat.Channels;
int bufferSampleCount = e.Buffer.Length / bytesPerSample;
if (bufferSampleCount >= AudioValues.Length)
{
bufferSampleCount = AudioValues.Length;
}
if (bytesPerSamplePerChannel == 2 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
{
for (int i = 0; i < bufferSampleCount; i++)
AudioValues[i] = BitConverter.ToInt16(e.Buffer, i * bytesPerSample);
}
else if (bytesPerSamplePerChannel == 4 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
{
for (int i = 0; i < bufferSampleCount; i++)
AudioValues[i] = BitConverter.ToInt32(e.Buffer, i * bytesPerSample);
}
else if (bytesPerSamplePerChannel == 4 && AudioDevice.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
for (int i = 0; i < bufferSampleCount; i++)
AudioValues[i] = BitConverter.ToSingle(e.Buffer, i * bytesPerSample);
}
double[] paddedAudio = FftSharp.Pad.ZeroPad(AudioValues);
double[] fftMag = FftSharp.Transform.FFTmagnitude(paddedAudio);
PresentAudio(fftMag);
}
private void DrawBar(int pos, double h)
{
int dx = pos * 2;
int dy = 20;
byte color;
for (int y = 0; y < h - (h % 2); y++)
for (int x = 0; x < 2 - (y % 2); x++)
{
//color = (byte)(Math.Min(1,(h - y - 2)*2) * 255);
device.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
device.SetLedPlanar(x + dx, dy - y, 255);
}
}
void PresentAudio(double[] audio)
{
if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastPresent) < 70) return;
lastPresent = DateTimeOffset.Now.ToUnixTimeMilliseconds();
device.Clear();
int size = 20;
double[] bars = new double[size];
double max = 2, maxAverage;
for (int i = 0; i < size; i++)
{
bars[i] = Math.Sqrt(audio[i] * 10000);
if (bars[i] > max) max = bars[i];
}
maxes.Add(max);
if (maxes.Count > 20) maxes.RemoveAt(0);
maxAverage = maxes.Average();
for (int i = 0; i < size; i++) DrawBar(20 - i, bars[i] * 20 / maxAverage);
device.Present();
}
public void OpenMatrixPicture()
{
string fileName = null;
Thread t = new Thread(() =>
{
OpenFileDialog of = new OpenFileDialog();
of.Filter = "Image Files (*.bmp;*.jpg;*.jpeg,*.png,*.gif)|*.BMP;*.JPG;*.JPEG;*.PNG;*.GIF";
if (of.ShowDialog() == DialogResult.OK)
{
fileName = of.FileName;
}
return;
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
if (fileName is not null)
{
AppConfig.Set("matrix_picture", fileName);
AppConfig.Set("matrix_running", 2);
SetMatrixPicture(fileName);
settings.SetMatrixRunning(2);
}
}
public void SetMatrixPicture(string fileName, bool visualise = true)
{
if (!IsValid) return;
StopMatrixTimer();
try
{
using (var fs = new FileStream(fileName, FileMode.Open))
//using (var ms = new MemoryStream())
{
/*
ms.SetLength(0);
fs.CopyTo(ms);
ms.Position = 0;
*/
using (Image image = Image.FromStream(fs))
{
ProcessPicture(image);
Logger.WriteLine("Matrix " + fileName);
}
fs.Close();
if (visualise) settings.VisualiseMatrix(fileName);
}
}
catch
{
Debug.WriteLine("Error loading picture");
return;
}
}
protected void ProcessPicture(Image image)
{
device.SetBuiltInAnimation(false);
device.ClearFrames();
int matrixX = AppConfig.Get("matrix_x", 0);
int matrixY = AppConfig.Get("matrix_y", 0);
int matrixZoom = AppConfig.Get("matrix_zoom", 100);
int matrixSpeed = AppConfig.Get("matrix_speed", 50);
InterpolationMode matrixQuality = (InterpolationMode)AppConfig.Get("matrix_quality", 0);
FrameDimension dimension = new FrameDimension(image.FrameDimensionsList[0]);
int frameCount = image.GetFrameCount(dimension);
if (frameCount > 1)
{
var delayPropertyBytes = image.GetPropertyItem(0x5100).Value;
var frameDelay = BitConverter.ToInt32(delayPropertyBytes) * 10;
for (int i = 0; i < frameCount; i++)
{
image.SelectActiveFrame(dimension, i);
device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality);
device.AddFrame();
}
Logger.WriteLine("GIF Delay:" + frameDelay);
StartMatrixTimer(Math.Max(matrixSpeed, frameDelay));
//image.SelectActiveFrame(dimension, 0);
}
else
{
device.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality);
device.Present();
}
}
}
}

View File

@@ -0,0 +1,537 @@
// Source thanks to https://github.com/vddCore/Starlight with some adjustments from me
using GHelper.AnimeMatrix.Communication;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Drawing.Text;
using System.Management;
using System.Text;
namespace Starlight.AnimeMatrix
{
public class BuiltInAnimation
{
public enum Startup
{
GlitchConstruction,
StaticEmergence
}
public enum Shutdown
{
GlitchOut,
SeeYa
}
public enum Sleeping
{
BannerSwipe,
Starfield
}
public enum Running
{
BinaryBannerScroll,
RogLogoGlitch
}
public byte AsByte { get; }
public BuiltInAnimation(
Running running,
Sleeping sleeping,
Shutdown shutdown,
Startup startup
)
{
AsByte |= (byte)(((int)running & 0x01) << 0);
AsByte |= (byte)(((int)sleeping & 0x01) << 1);
AsByte |= (byte)(((int)shutdown & 0x01) << 2);
AsByte |= (byte)(((int)startup & 0x01) << 3);
}
}
internal class AnimeMatrixPacket : Packet
{
public AnimeMatrixPacket(byte[] command)
: base(0x5E, 640, command)
{
}
}
public enum AnimeType
{
GA401,
GA402,
GU604
}
public enum BrightnessMode : byte
{
Off = 0,
Dim = 1,
Medium = 2,
Full = 3
}
public class AnimeMatrixDevice : Device
{
int UpdatePageLength = 490;
int LedCount = 1450;
byte[] _displayBuffer;
List<byte[]> frames = new List<byte[]>();
public int MaxRows = 61;
public int MaxColumns = 34;
public int LedStart = 0;
public int TextShift = 8;
private int frameIndex = 0;
private static AnimeType _model = AnimeType.GA402;
[System.Runtime.InteropServices.DllImport("gdi32.dll")]
private static extern IntPtr AddFontMemResourceEx(IntPtr pbFont, uint cbFont, IntPtr pdv, [System.Runtime.InteropServices.In] ref uint pcFonts);
private PrivateFontCollection fonts = new PrivateFontCollection();
public AnimeMatrixDevice() : base(0x0B05, 0x193B, 640)
{
string model = GetModel();
if (model.Contains("401"))
{
_model = AnimeType.GA401;
MaxColumns = 33;
MaxRows = 55;
LedCount = 1245;
UpdatePageLength = 410;
TextShift = 11;
LedStart = 1;
}
if (model.Contains("GU604"))
{
_model = AnimeType.GU604;
MaxColumns = 39;
MaxRows = 92;
LedCount = 1711;
UpdatePageLength = 630;
TextShift = 10;
}
_displayBuffer = new byte[LedCount];
/*
for (int i = 0; i < MaxRows; i++)
{
_model = AnimeType.GA401;
Logger.WriteLine(FirstX(i) + " " + Pitch(i));
}
*/
LoadMFont();
}
private void LoadMFont()
{
byte[] fontData = GHelper.Properties.Resources.MFont;
IntPtr fontPtr = System.Runtime.InteropServices.Marshal.AllocCoTaskMem(fontData.Length);
System.Runtime.InteropServices.Marshal.Copy(fontData, 0, fontPtr, fontData.Length);
uint dummy = 0;
fonts.AddMemoryFont(fontPtr, GHelper.Properties.Resources.MFont.Length);
AddFontMemResourceEx(fontPtr, (uint)GHelper.Properties.Resources.MFont.Length, IntPtr.Zero, ref dummy);
System.Runtime.InteropServices.Marshal.FreeCoTaskMem(fontPtr);
}
public string GetModel()
{
using (var searcher = new ManagementObjectSearcher(@"Select * from Win32_ComputerSystem"))
{
foreach (var process in searcher.Get())
return process["Model"].ToString();
}
return null;
}
public byte[] GetBuffer()
{
return _displayBuffer;
}
public void PresentNextFrame()
{
if (frameIndex >= frames.Count) frameIndex = 0;
_displayBuffer = frames[frameIndex];
Present();
frameIndex++;
}
public void ClearFrames()
{
frames.Clear();
frameIndex = 0;
}
public void AddFrame()
{
frames.Add(_displayBuffer.ToArray());
}
public void SendRaw(params byte[] data)
{
Set(Packet<AnimeMatrixPacket>(data));
}
public int Width()
{
switch (_model)
{
case AnimeType.GA401:
return 33;
case AnimeType.GU604:
return 39;
default:
return 34;
}
}
public int FirstX(int y)
{
switch (_model)
{
case AnimeType.GA401:
if (y < 5 && y % 2 == 0)
{
return 1;
}
return (int)Math.Ceiling(Math.Max(0, y - 5) / 2F);
case AnimeType.GU604:
if (y < 9 && y % 2 == 0)
{
return 1;
}
return (int)Math.Ceiling(Math.Max(0, y - 9) / 2F);
default:
return (int)Math.Ceiling(Math.Max(0, y - 11) / 2F);
}
}
public int Pitch(int y)
{
switch (_model)
{
case AnimeType.GA401:
switch (y)
{
case 0:
case 2:
case 4:
return 33;
case 1:
case 3:
return 35;
default:
return 36 - y / 2;
}
case AnimeType.GU604:
switch (y)
{
case 0:
case 2:
case 4:
case 6:
case 8:
return 38;
case 1:
case 3:
case 5:
case 7:
case 9:
return 39;
default:
return Width() - FirstX(y);
}
default:
return Width() - FirstX(y);
}
}
public int RowToLinearAddress(int y)
{
int ret = LedStart;
for (var i = 0; i < y; i++)
ret += Pitch(i);
return ret;
}
public void SetLedPlanar(int x, int y, byte value)
{
if (!IsRowInRange(y)) return;
if (x >= FirstX(y) && x < Width())
SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x, value);
}
public void WakeUp()
{
Set(Packet<AnimeMatrixPacket>(Encoding.ASCII.GetBytes("ASUS Tech.Inc.")));
}
public void SetLedLinear(int address, byte value)
{
if (!IsAddressableLed(address)) return;
_displayBuffer[address] = value;
}
public void SetLedLinearImmediate(int address, byte value)
{
if (!IsAddressableLed(address)) return;
_displayBuffer[address] = value;
Set(Packet<AnimeMatrixPacket>(0xC0, 0x02)
.AppendData(BitConverter.GetBytes((ushort)(address + 1)))
.AppendData(BitConverter.GetBytes((ushort)0x0001))
.AppendData(value)
);
Set(Packet<AnimeMatrixPacket>(0xC0, 0x03));
}
public void Clear(bool present = false)
{
for (var i = 0; i < _displayBuffer.Length; i++)
_displayBuffer[i] = 0;
if (present)
Present();
}
public void Present()
{
int page = 0;
int start, end;
while (page * UpdatePageLength < LedCount)
{
start = page * UpdatePageLength;
end = Math.Min(LedCount, (page + 1) * UpdatePageLength);
Set(Packet<AnimeMatrixPacket>(0xC0, 0x02)
.AppendData(BitConverter.GetBytes((ushort)(start + 1)))
.AppendData(BitConverter.GetBytes((ushort)(end - start)))
.AppendData(_displayBuffer[start..end])
);
page++;
}
Set(Packet<AnimeMatrixPacket>(0xC0, 0x03));
}
public void SetDisplayState(bool enable)
{
if (enable)
{
Set(Packet<AnimeMatrixPacket>(0xC3, 0x01)
.AppendData(0x00));
}
else
{
Set(Packet<AnimeMatrixPacket>(0xC3, 0x01)
.AppendData(0x80));
}
}
public void SetBrightness(BrightnessMode mode)
{
Set(Packet<AnimeMatrixPacket>(0xC0, 0x04)
.AppendData((byte)mode)
);
}
public void SetBuiltInAnimation(bool enable)
{
var enabled = enable ? (byte)0x00 : (byte)0x80;
Set(Packet<AnimeMatrixPacket>(0xC4, 0x01, enabled));
}
public void SetBuiltInAnimation(bool enable, BuiltInAnimation animation)
{
SetBuiltInAnimation(enable);
Set(Packet<AnimeMatrixPacket>(0xC5, animation.AsByte));
}
public void PresentClock()
{
string second = (DateTime.Now.Second % 2 == 0) ? ":" : " ";
string time = DateTime.Now.ToString("HH" + second + "mm");
Clear();
TextDiagonal(time, 15, 12, TextShift + 11);
TextDiagonal(DateTime.Now.ToString("yy'. 'MM'. 'dd"), 11.5F, 3, TextShift);
Present();
}
public void TextDiagonal(string text, float fontSize = 10, int deltaX = 0, int deltaY = 10)
{
int maxX = (int)Math.Sqrt(MaxRows * MaxRows + MaxColumns * MaxColumns);
int textHeight;
using (Bitmap bmp = new Bitmap(maxX, MaxRows))
{
using (Graphics g = Graphics.FromImage(bmp))
{
g.CompositingQuality = CompositingQuality.HighQuality;
g.SmoothingMode = SmoothingMode.AntiAlias;
g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
using (Font font = new Font(fonts.Families[0], fontSize, FontStyle.Regular, GraphicsUnit.Pixel))
{
SizeF textSize = g.MeasureString(text, font);
textHeight = (int)textSize.Height;
g.DrawString(text, font, Brushes.White, 0, 0);
}
}
for (int y = 0; y < bmp.Height; y++)
{
for (int x = 0; x < bmp.Width; x++)
{
var pixel = bmp.GetPixel(x, y);
var color = (pixel.R + pixel.G + pixel.B) / 3;
if (color > 100) SetLedDiagonal(x, y, (byte)color, deltaX, deltaY);
}
}
}
}
public void PresentText(string text1, string text2 = "")
{
using (Bitmap bmp = new Bitmap(MaxColumns * 3, MaxRows))
{
using (Graphics g = Graphics.FromImage(bmp))
{
g.CompositingQuality = CompositingQuality.HighQuality;
g.SmoothingMode = SmoothingMode.AntiAlias;
g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
using (Font font = new Font("Consolas", 22F, FontStyle.Regular, GraphicsUnit.Pixel))
{
SizeF textSize = g.MeasureString(text1, font);
g.DrawString(text1, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 3, -4);
}
if (text2.Length > 0)
using (Font font = new Font("Consolas", 18F, GraphicsUnit.Pixel))
{
SizeF textSize = g.MeasureString(text2, font);
g.DrawString(text2, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 1, 25);
}
}
bmp.Save("test.bmp", ImageFormat.Bmp);
GenerateFrame(bmp);
Present();
}
}
public void GenerateFrame(Image image, float zoom = 100, int panX = 0, int panY = 0, InterpolationMode quality = InterpolationMode.Default)
{
int width = MaxColumns / 2 * 6;
int height = MaxRows;
int targetWidth = MaxColumns * 2;
float scale;
using (Bitmap bmp = new Bitmap(targetWidth, height))
{
scale = Math.Min((float)width / (float)image.Width, (float)height / (float)image.Height) * zoom / 100;
using (var graph = Graphics.FromImage(bmp))
{
var scaleWidth = (float)(image.Width * scale);
var scaleHeight = (float)(image.Height * scale);
graph.InterpolationMode = quality;
graph.CompositingQuality = CompositingQuality.HighQuality;
graph.SmoothingMode = SmoothingMode.AntiAlias;
graph.DrawImage(image, (float)Math.Round(targetWidth - (scaleWidth + panX) * targetWidth / width), -panY, (float)Math.Round(scaleWidth * targetWidth / width), scaleHeight);
}
for (int y = 0; y < bmp.Height; y++)
{
for (int x = 0; x < bmp.Width; x++)
if (x % 2 == y % 2)
{
var pixel = bmp.GetPixel(x, y);
var color = (pixel.R + pixel.G + pixel.B) / 3;
if (color < 10) color = 0;
SetLedPlanar(x / 2, y, (byte)color);
}
}
}
}
public void SetLedDiagonal(int x, int y, byte color, int deltaX = 0, int deltaY = 10)
{
x += deltaX;
y -= deltaY;
int plX = (x - y) / 2;
int plY = x + y;
SetLedPlanar(plX, plY, color);
}
private bool IsRowInRange(int row)
{
return (row >= 0 && row < MaxRows);
}
private bool IsAddressableLed(int address)
{
return (address >= 0 && address < LedCount);
}
}
}

View File

@@ -0,0 +1,65 @@
// Source thanks to https://github.com/vddCore/Starlight :)
using GHelper.AnimeMatrix.Communication.Platform;
namespace GHelper.AnimeMatrix.Communication
{
public abstract class Device : IDisposable
{
protected UsbProvider? _usbProvider;
protected ushort _vendorId;
protected ushort _productId;
protected int _maxFeatureReportLength;
protected Device(ushort vendorId, ushort productId)
{
_vendorId = vendorId;
_productId = productId;
}
protected Device(ushort vendorId, ushort productId, int maxFeatureReportLength)
{
_vendorId = vendorId;
_productId = productId;
_maxFeatureReportLength = maxFeatureReportLength;
SetProvider();
}
public ushort VendorID()
{
return _vendorId;
}
public ushort ProductID()
{
return _productId;
}
public virtual void SetProvider()
{
_usbProvider = new WindowsUsbProvider(_vendorId, _productId, _maxFeatureReportLength);
}
protected T Packet<T>(params byte[] command) where T : Packet
{
return (T)Activator.CreateInstance(typeof(T), command)!;
}
public void Set(Packet packet)
=> _usbProvider?.Set(packet.Data);
public byte[] Get(Packet packet)
=> _usbProvider?.Get(packet.Data);
public void Read(byte[] data)
=> _usbProvider?.Read(data);
public void Write(byte[] data)
=> _usbProvider?.Write(data);
public virtual void Dispose()
{
_usbProvider?.Dispose();
}
}
}

View File

@@ -0,0 +1,58 @@
// Source thanks to https://github.com/vddCore/Starlight :)
namespace GHelper.AnimeMatrix.Communication
{
public abstract class Packet
{
private int _currentDataIndex = 1;
public byte[] Data { get; }
internal Packet(byte reportId, int packetLength, params byte[] data)
{
if (packetLength < 1)
{
throw new ArgumentOutOfRangeException(
nameof(packetLength),
"Packet length must be at least 1."
);
}
Data = new byte[packetLength];
Data[0] = reportId;
if (data.Length > 0)
{
if (_currentDataIndex >= Data.Length)
{
throw new ArgumentOutOfRangeException(
nameof(data),
"Your packet length does not allow for initial data to be appended."
);
}
AppendData(data);
}
}
public Packet AppendData(params byte[] data)
=> AppendData(out _, data);
public Packet AppendData(out int bytesWritten, params byte[] data)
{
bytesWritten = 0;
for (var i = 0;
i < data.Length && _currentDataIndex < Data.Length - 1;
i++, bytesWritten++, _currentDataIndex++)
{
if (_currentDataIndex > Data.Length - 1)
break;
Data[_currentDataIndex] = data[i];
}
return this;
}
}
}

View File

@@ -0,0 +1,21 @@
namespace GHelper.AnimeMatrix.Communication.Platform
{
public abstract class UsbProvider : IDisposable
{
protected ushort VendorID { get; }
protected ushort ProductID { get; }
protected UsbProvider(ushort vendorId, ushort productId)
{
VendorID = vendorId;
ProductID = productId;
}
public abstract void Set(byte[] data);
public abstract byte[] Get(byte[] data);
public abstract void Read(byte[] data);
public abstract void Write(byte[] data);
public abstract void Dispose();
}
}

View File

@@ -0,0 +1,117 @@
using System.ComponentModel;
using HidSharp;
namespace GHelper.AnimeMatrix.Communication.Platform
{
internal class WindowsUsbProvider : UsbProvider
{
protected HidDevice HidDevice { get; }
protected HidStream HidStream { get; }
public WindowsUsbProvider(ushort vendorId, ushort productId, string path, int timeout = 500) : base(vendorId, productId)
{
try
{
HidDevice = DeviceList.Local.GetHidDevices(vendorId, productId)
.First(x => x.DevicePath.Contains(path));
}
catch
{
throw new IOException("HID device was not found on your machine.");
}
var config = new OpenConfiguration();
config.SetOption(OpenOption.Interruptible, true);
config.SetOption(OpenOption.Exclusive, false);
config.SetOption(OpenOption.Priority, 10);
HidStream = HidDevice.Open(config);
HidStream.ReadTimeout = timeout;
HidStream.WriteTimeout = timeout;
}
public WindowsUsbProvider(ushort vendorId, ushort productId, int maxFeatureReportLength)
: base(vendorId, productId)
{
try
{
HidDevice = DeviceList.Local
.GetHidDevices(vendorId, productId)
.First(x => x.GetMaxFeatureReportLength() == maxFeatureReportLength);
}
catch
{
throw new IOException("AniMe Matrix control device was not found on your machine.");
}
var config = new OpenConfiguration();
config.SetOption(OpenOption.Interruptible, true);
config.SetOption(OpenOption.Exclusive, false);
config.SetOption(OpenOption.Priority, 10);
HidStream = HidDevice.Open(config);
}
public override void Set(byte[] data)
{
WrapException(() =>
{
HidStream.SetFeature(data);
HidStream.Flush();
});
}
public override byte[] Get(byte[] data)
{
var outData = new byte[data.Length];
Array.Copy(data, outData, data.Length);
WrapException(() =>
{
HidStream.GetFeature(outData);
HidStream.Flush();
});
return data;
}
public override void Read(byte[] data)
{
WrapException(() =>
{
HidStream.Read(data);
});
}
public override void Write(byte[] data)
{
WrapException(() =>
{
HidStream.Write(data);
HidStream.Flush();
});
}
public override void Dispose()
{
HidStream.Dispose();
}
private void WrapException(Action action)
{
try
{
action();
}
catch (IOException e)
{
if (e.InnerException is Win32Exception w32e)
{
if (w32e.NativeErrorCode != 0)
{
throw;
}
}
}
}
}
}

View File

@@ -3,4 +3,8 @@
<System.Windows.Forms.ApplicationConfigurationSection>
<add key="DpiAwareness" value="PerMonitorV2" />
</System.Windows.Forms.ApplicationConfigurationSection>
</configuration>
<appSettings>
<add key="EnableWindowsFormsHighDpiAutoResizing" value="true" />
</appSettings>
</configuration>

394
app/AppConfig.cs Normal file
View File

@@ -0,0 +1,394 @@
using GHelper.Mode;
using System.Diagnostics;
using System.Management;
using System.Text.Json;
public static class AppConfig
{
private static string configFile;
private static string? _model;
private static Dictionary<string, object> config = new Dictionary<string, object>();
static AppConfig()
{
string startupPath = Application.StartupPath.Trim('\\');
string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
string configName = "\\config.json";
if (File.Exists(startupPath + configName))
{
configFile = startupPath + configName;
} else
{
configFile = appPath + configName;
}
if (!System.IO.Directory.Exists(appPath))
System.IO.Directory.CreateDirectory(appPath);
if (File.Exists(configFile))
{
string text = File.ReadAllText(configFile);
try
{
config = JsonSerializer.Deserialize<Dictionary<string, object>>(text);
}
catch
{
Logger.WriteLine("Broken config: " + text);
Init();
}
}
else
{
Init();
}
}
public static string GetModel()
{
if (_model is null)
{
_model = "";
using (var searcher = new ManagementObjectSearcher(@"Select * from Win32_ComputerSystem"))
{
foreach (var process in searcher.Get())
{
_model = process["Model"].ToString();
break;
}
}
}
return _model;
}
public static string GetModelShort()
{
string model = GetModel();
int trim = model.LastIndexOf("_");
if (trim > 0) model = model.Substring(0, trim);
return model;
}
public static bool ContainsModel(string contains)
{
GetModel();
return (_model is not null && _model.ToLower().Contains(contains.ToLower()));
}
private static void Init()
{
config = new Dictionary<string, object>();
config["performance_mode"] = 0;
string jsonString = JsonSerializer.Serialize(config);
File.WriteAllText(configFile, jsonString);
}
public static int Get(string name, int empty = -1)
{
if (config.ContainsKey(name))
{
//Debug.WriteLine(name);
return int.Parse(config[name].ToString());
}
else
{
//Debug.WriteLine(name + "E");
return empty;
}
}
public static bool Is(string name)
{
return Get(name) == 1;
}
public static bool IsNotFalse(string name)
{
return Get(name) != 0;
}
public static string GetString(string name, string empty = null)
{
if (config.ContainsKey(name))
return config[name].ToString();
else return empty;
}
private static void Write()
{
string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
try
{
File.WriteAllText(configFile, jsonString);
}
catch (Exception e)
{
Debug.Write(e.ToString());
}
}
public static void Set(string name, int value)
{
config[name] = value;
Write();
}
public static void Set(string name, string value)
{
config[name] = value;
Write();
}
public static void Remove(string name)
{
config.Remove(name);
Write();
}
public static void RemoveMode(string name)
{
Remove(name + "_" + Modes.GetCurrent());
}
public static string GgetParamName(AsusFan device, string paramName = "fan_profile")
{
int mode = Modes.GetCurrent();
string name;
switch (device)
{
case AsusFan.GPU:
name = "gpu";
break;
case AsusFan.Mid:
name = "mid";
break;
case AsusFan.XGM:
name = "xgm";
break;
default:
name = "cpu";
break;
}
return paramName + "_" + name + "_" + mode;
}
public static byte[] GetFanConfig(AsusFan device)
{
string curveString = GetString(GgetParamName(device));
byte[] curve = { };
if (curveString is not null)
curve = StringToBytes(curveString);
return curve;
}
public static void SetFanConfig(AsusFan device, byte[] curve)
{
string bitCurve = BitConverter.ToString(curve);
Set(GgetParamName(device), bitCurve);
}
public static byte[] StringToBytes(string str)
{
String[] arr = str.Split('-');
byte[] array = new byte[arr.Length];
for (int i = 0; i < arr.Length; i++) array[i] = Convert.ToByte(arr[i], 16);
return array;
}
public static byte[] GetDefaultCurve(AsusFan device)
{
int mode = Modes.GetCurrentBase();
byte[] curve;
switch (mode)
{
case 1:
if (device == AsusFan.GPU)
curve = StringToBytes("14-3F-44-48-4C-50-54-62-16-1F-26-2D-39-47-55-5F");
else
curve = StringToBytes("14-3F-44-48-4C-50-54-62-11-1A-22-29-34-43-51-5A");
break;
case 2:
if (device == AsusFan.GPU)
curve = StringToBytes("3C-41-42-46-47-4B-4C-62-08-11-11-1D-1D-26-26-2D");
else
curve = StringToBytes("3C-41-42-46-47-4B-4C-62-03-0C-0C-16-16-22-22-29");
break;
default:
if (device == AsusFan.GPU)
curve = StringToBytes("3A-3D-40-44-48-4D-51-62-0C-16-1D-1F-26-2D-34-4A");
else
curve = StringToBytes("3A-3D-40-44-48-4D-51-62-08-11-16-1A-22-29-30-45");
break;
}
return curve;
}
public static string GetModeString(string name)
{
return GetString(name + "_" + Modes.GetCurrent());
}
public static int GetMode(string name, int empty = -1)
{
return Get(name + "_" + Modes.GetCurrent(), empty);
}
public static bool IsMode(string name)
{
return Get(name + "_" + Modes.GetCurrent()) == 1;
}
public static void SetMode(string name, int value)
{
Set(name + "_" + Modes.GetCurrent(), value);
}
public static void SetMode(string name, string value)
{
Set(name + "_" + Modes.GetCurrent(), value);
}
public static bool IsAlly()
{
return ContainsModel("RC71");
}
public static bool NoMKeys()
{
return ContainsModel("Z13") ||
ContainsModel("FX706") ||
ContainsModel("FA506") ||
ContainsModel("FX506") ||
ContainsModel("Duo") ||
ContainsModel("FX505");
}
public static bool IsTUF()
{
return ContainsModel("TUF");
}
public static bool IsVivobook()
{
return ContainsModel("Vivobook");
}
// Devices with bugged bios command to change brightness
public static bool SwappedBrightness()
{
return ContainsModel("FA506IH") || ContainsModel("FX506LU");
}
public static bool IsDUO()
{
return ContainsModel("Duo");
}
// G14 2020 has no aura, but media keys instead
public static bool NoAura()
{
return ContainsModel("GA401I") && !ContainsModel("GA401IHR");
}
public static bool IsSingleColor()
{
return ContainsModel("GA401");
}
public static bool IsStrix()
{
return ContainsModel("Strix") || ContainsModel("Scar");
}
public static bool IsZ13()
{
return ContainsModel("Z13");
}
public static bool HasTabletMode()
{
return ContainsModel("X16") || ContainsModel("X13");
}
public static bool IsX13()
{
return ContainsModel("X13");
}
public static bool IsAdvantageEdition()
{
return ContainsModel("13QY");
}
public static bool NoAutoUltimate()
{
return ContainsModel("G614") || ContainsModel("GU604") || ContainsModel("FX507") || ContainsModel("G513");
}
public static bool IsManualModeRequired()
{
if (!IsMode("auto_apply_power"))
return false;
return
Is("manual_mode") ||
ContainsModel("GU604") ||
ContainsModel("G733") ||
ContainsModel("FX507Z");
}
public static bool IsFanScale()
{
return ContainsModel("GU604");
}
public static bool IsFanRequired()
{
return ContainsModel("GA402X") || ContainsModel("G513") || ContainsModel("G713R");
}
public static bool IsPowerRequired()
{
return ContainsModel("FX507") || ContainsModel("FX517") || ContainsModel("FX707");
}
public static bool IsGPUFixNeeded()
{
return ContainsModel("GA402X") || ContainsModel("GV302") || ContainsModel("FX506") || ContainsModel("GU603V");
}
public static bool IsGPUFix()
{
return Is("gpu_fix") || (ContainsModel("GA402X") && IsNotFalse("gpu_fix"));
}
public static bool IsForceSetGPUMode()
{
return Is("gpu_mode_force_set") || ContainsModel("503");
}
public static bool IsNoGPUModes()
{
return ContainsModel("GV301RA") || ContainsModel("GV302XA") || IsAlly();
}
}

595
app/AsusACPI.cs Normal file
View File

@@ -0,0 +1,595 @@
using GHelper;
using System.Management;
using System.Runtime.InteropServices;
public enum AsusFan
{
CPU = 0,
GPU = 1,
Mid = 2,
XGM = 3
}
public enum AsusMode
{
Balanced = 0,
Turbo = 1,
Silent = 2
}
public enum AsusGPU
{
Eco = 0,
Standard = 1,
Ultimate = 2
}
public class AsusACPI
{
const string FILE_NAME = @"\\.\\ATKACPI";
const uint CONTROL_CODE = 0x0022240C;
const uint DSTS = 0x53545344;
const uint DEVS = 0x53564544;
const uint INIT = 0x54494E49;
public const uint UniversalControl = 0x00100021;
public const int KB_Light_Up = 0xc4;
public const int KB_Light_Down = 0xc5;
public const int Brightness_Down = 0x10;
public const int Brightness_Up = 0x20;
public const int KB_Sleep = 0x6c;
public const int KB_DUO_PgUpDn = 0x4B;
public const int KB_DUO_SecondDisplay = 0x6A;
public const int Touchpad_Toggle = 0x6B;
public const int ChargerMode = 0x0012006C;
public const int ChargerUSB = 2;
public const int ChargerBarrel = 1;
public const uint CPU_Fan = 0x00110013;
public const uint GPU_Fan = 0x00110014;
public const uint Mid_Fan = 0x00110031;
public const uint PerformanceMode = 0x00120075; // Performance modes
public const uint VivoBookMode = 0x00110019; // Vivobook performance modes
public const uint GPUEco = 0x00090020;
public const uint GPUXGConnected = 0x00090018;
public const uint GPUXG = 0x00090019;
public const uint GPUMux = 0x00090016;
public const uint GPUMuxVivo = 0x00090026;
public const uint BatteryLimit = 0x00120057;
public const uint ScreenOverdrive = 0x00050019;
public const uint ScreenMiniled = 0x0005001E;
public const uint DevsCPUFan = 0x00110022;
public const uint DevsGPUFan = 0x00110023;
public const uint DevsCPUFanCurve = 0x00110024;
public const uint DevsGPUFanCurve = 0x00110025;
public const uint DevsMidFanCurve = 0x00110032;
public const int Temp_CPU = 0x00120094;
public const int Temp_GPU = 0x00120097;
public const int PPT_TotalA0 = 0x001200A0; // SPL (Total limit for all-AMD models) / PL1
public const int PPT_EDCA1 = 0x001200A1; // CPU EDC
public const int PPT_TDCA2 = 0x001200A2; // CPU TDC
public const int PPT_APUA3 = 0x001200A3; // sPPT (long boost limit) / PL2
public const int PPT_CPUB0 = 0x001200B0; // CPU PPT on 2022 (PPT_LIMIT_APU)
public const int PPT_CPUB1 = 0x001200B1; // Total PPT on 2022 (PPT_LIMIT_SLOW)
public const int PPT_GPUC0 = 0x001200C0; // NVIDIA GPU Boost
public const int PPT_APUC1 = 0x001200C1; // fPPT (fast boost limit)
public const int PPT_GPUC2 = 0x001200C2; // NVIDIA GPU Temp Target (75.. 87 C)
public const int TUF_KB_BRIGHTNESS = 0x00050021;
public const int TUF_KB = 0x00100056;
public const int TUF_KB2 = 0x0010005a;
public const int TUF_KB_STATE = 0x00100057;
public const int MICMUTE_LED = 0x00040017;
public const int TabletState = 0x00060077;
public const int FnLock = 0x00100023;
public const int ScreenPadToggle = 0x00050031;
public const int ScreenPadBrightness = 0x00050032;
public const int BootSound = 0x00130022;
public const int Tablet_Notebook = 0;
public const int Tablet_Tablet = 1;
public const int Tablet_Tent = 2;
public const int Tablet_Rotated = 3;
public const int PerformanceBalanced = 0;
public const int PerformanceTurbo = 1;
public const int PerformanceSilent = 2;
public const int PerformanceManual = 4;
public const int GPUModeEco = 0;
public const int GPUModeStandard = 1;
public const int GPUModeUltimate = 2;
public const int MinTotal = 5;
public static int MaxTotal = 150;
public static int DefaultTotal = 125;
public const int MinCPU = 5;
public const int MaxCPU = 100;
public const int DefaultCPU = 80;
public const int MinGPUBoost = 5;
public const int MaxGPUBoost = 25;
public const int MinGPUTemp = 75;
public const int MaxGPUTemp = 87;
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
private static extern IntPtr CreateFile(
string lpFileName,
uint dwDesiredAccess,
uint dwShareMode,
IntPtr lpSecurityAttributes,
uint dwCreationDisposition,
uint dwFlagsAndAttributes,
IntPtr hTemplateFile
);
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool DeviceIoControl(
IntPtr hDevice,
uint dwIoControlCode,
byte[] lpInBuffer,
uint nInBufferSize,
byte[] lpOutBuffer,
uint nOutBufferSize,
ref uint lpBytesReturned,
IntPtr lpOverlapped
);
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool CloseHandle(IntPtr hObject);
private const uint GENERIC_READ = 0x80000000;
private const uint GENERIC_WRITE = 0x40000000;
private const uint OPEN_EXISTING = 3;
private const uint FILE_ATTRIBUTE_NORMAL = 0x80;
private const uint FILE_SHARE_READ = 1;
private const uint FILE_SHARE_WRITE = 2;
private IntPtr handle;
// Event handling attempt
[DllImport("kernel32.dll", SetLastError = true)]
private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
private IntPtr eventHandle;
// still works only with asus optimization service on , if someone knows how to get ACPI events from asus without that - let me know
public void RunListener()
{
eventHandle = CreateEvent(IntPtr.Zero, false, false, "ATK4001");
byte[] outBuffer = new byte[16];
byte[] data = new byte[8];
bool result;
data[0] = BitConverter.GetBytes(eventHandle.ToInt32())[0];
data[1] = BitConverter.GetBytes(eventHandle.ToInt32())[1];
Control(0x222400, data, outBuffer);
Logger.WriteLine("ACPI :" + BitConverter.ToString(data) + "|" + BitConverter.ToString(outBuffer));
while (true)
{
WaitForSingleObject(eventHandle, Timeout.Infinite);
Control(0x222408, new byte[0], outBuffer);
int code = BitConverter.ToInt32(outBuffer);
Logger.WriteLine("ACPI Code: " + code);
}
}
public AsusACPI()
{
handle = CreateFile(
FILE_NAME,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
IntPtr.Zero,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
IntPtr.Zero
);
if (handle == new IntPtr(-1))
{
throw new Exception("Can't connect to ACPI");
}
if (AppConfig.IsAdvantageEdition()) MaxTotal = 250;
if (AppConfig.IsX13())
{
MaxTotal = 75;
DefaultTotal = 50;
}
if (AppConfig.IsAlly())
{
MaxTotal = 50;
DefaultTotal = 30;
}
}
public void Control(uint dwIoControlCode, byte[] lpInBuffer, byte[] lpOutBuffer)
{
uint lpBytesReturned = 0;
DeviceIoControl(
handle,
dwIoControlCode,
lpInBuffer,
(uint)lpInBuffer.Length,
lpOutBuffer,
(uint)lpOutBuffer.Length,
ref lpBytesReturned,
IntPtr.Zero
);
}
public void Close()
{
CloseHandle(handle);
}
protected byte[] CallMethod(uint MethodID, byte[] args)
{
byte[] acpiBuf = new byte[8 + args.Length];
byte[] outBuffer = new byte[16];
BitConverter.GetBytes((uint)MethodID).CopyTo(acpiBuf, 0);
BitConverter.GetBytes((uint)args.Length).CopyTo(acpiBuf, 4);
Array.Copy(args, 0, acpiBuf, 8, args.Length);
// if (MethodID == DEVS) Debug.WriteLine(BitConverter.ToString(acpiBuf, 0, acpiBuf.Length));
Control(CONTROL_CODE, acpiBuf, outBuffer);
return outBuffer;
}
public byte[] DeviceInit()
{
byte[] args = new byte[8];
return CallMethod(INIT, args);
}
public int DeviceSet(uint DeviceID, int Status, string logName)
{
byte[] args = new byte[8];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
byte[] status = CallMethod(DEVS, args);
int result = BitConverter.ToInt32(status, 0);
Logger.WriteLine(logName + " = " + Status + " : " + (result == 1 ? "OK" : result));
return result;
}
public int DeviceSet(uint DeviceID, byte[] Params, string logName)
{
byte[] args = new byte[4 + Params.Length];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
Params.CopyTo(args, 4);
byte[] status = CallMethod(DEVS, args);
int result = BitConverter.ToInt32(status, 0);
Logger.WriteLine(logName + " = " + BitConverter.ToString(Params) + " : " + (result == 1 ? "OK" : result));
return BitConverter.ToInt32(status, 0);
}
public int DeviceGet(uint DeviceID)
{
byte[] args = new byte[8];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
byte[] status = CallMethod(DSTS, args);
return BitConverter.ToInt32(status, 0) - 65536;
}
public byte[] DeviceGetBuffer(uint DeviceID, uint Status = 0)
{
byte[] args = new byte[8];
BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
BitConverter.GetBytes((uint)Status).CopyTo(args, 4);
return CallMethod(DSTS, args);
}
public int SetGPUEco(int eco)
{
int ecoFlag = DeviceGet(GPUEco);
if (ecoFlag < 0) return -1;
if (ecoFlag == 1 && eco == 0)
return DeviceSet(GPUEco, eco, "GPUEco");
if (ecoFlag == 0 && eco == 1)
return DeviceSet(GPUEco, eco, "GPUEco");
return -1;
}
public int GetFan(AsusFan device)
{
int fan = -1;
switch (device)
{
case AsusFan.GPU:
fan = Program.acpi.DeviceGet(GPU_Fan);
break;
case AsusFan.Mid:
fan = Program.acpi.DeviceGet(Mid_Fan);
break;
default:
fan = Program.acpi.DeviceGet(CPU_Fan);
break;
}
if (fan < 0)
{
fan += 65536;
if (fan <= 0 || fan > 100) fan = -1;
}
return fan;
}
public int SetFanRange(AsusFan device, byte[] curve)
{
byte min = (byte)(curve[8] * 255 / 100);
byte max = (byte)(curve[15] * 255 / 100);
byte[] range = { min, max};
int result;
switch (device)
{
case AsusFan.GPU:
result = DeviceSet(DevsGPUFan, range, "FanRangeGPU");
break;
default:
result = DeviceSet(DevsCPUFan, range, "FanRangeCPU");
break;
}
return result;
}
public int SetFanCurve(AsusFan device, byte[] curve)
{
if (curve.Length != 16) return -1;
if (curve.All(singleByte => singleByte == 0)) return -1;
int result;
int defaultScale = (AppConfig.IsFanScale() && (device == AsusFan.CPU || device == AsusFan.GPU)) ? 130 : 100;
int fanScale = AppConfig.Get("fan_scale", defaultScale);
if (fanScale != 100 && device == AsusFan.CPU) Logger.WriteLine("Custom fan scale: " + fanScale);
// it seems to be a bug, when some old model's bios can go nuts if fan is set to 100%
for (int i = 8; i < curve.Length; i++) curve[i] = (byte)(Math.Max((byte)0, Math.Min((byte)100, curve[i])) * fanScale / 100);
switch (device)
{
case AsusFan.GPU:
result = DeviceSet(DevsGPUFanCurve, curve, "FanGPU");
break;
case AsusFan.Mid:
result = DeviceSet(DevsMidFanCurve, curve, "FanMid");
break;
default:
result = DeviceSet(DevsCPUFanCurve, curve, "FanCPU");
break;
}
return result;
}
public byte[] GetFanCurve(AsusFan device, int mode = 0)
{
uint fan_mode;
// because it's asus, and modes are swapped here
switch (mode)
{
case 1: fan_mode = 2; break;
case 2: fan_mode = 1; break;
default: fan_mode = 0; break;
}
switch (device)
{
case AsusFan.GPU:
return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
case AsusFan.Mid:
return DeviceGetBuffer(DevsMidFanCurve, fan_mode);
default:
return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
}
}
public static bool IsInvalidCurve(byte[] curve)
{
return curve.Length != 16 || IsEmptyCurve(curve);
}
public static bool IsEmptyCurve(byte[] curve)
{
return curve.All(singleByte => singleByte == 0);
}
public static byte[] FixFanCurve(byte[] curve)
{
if (curve.Length != 16) throw new Exception("Incorrect curve");
var points = new Dictionary<byte, byte>();
byte old = 0;
for (int i = 0; i < 8; i++)
{
if (curve[i] == old) curve[i]++; // preventing 2 points in same spot from default asus profiles
points[curve[i]] = curve[i + 8];
old = curve[i];
}
var pointsFixed = new Dictionary<byte, byte>();
bool fix = false;
int count = 0;
foreach (var pair in points.OrderBy(x => x.Key))
{
if (count == 0 && pair.Key >= 40)
{
fix = true;
pointsFixed.Add(30, 0);
}
if (count != 3 || !fix)
pointsFixed.Add(pair.Key, pair.Value);
count++;
}
count = 0;
foreach (var pair in pointsFixed.OrderBy(x => x.Key))
{
curve[count] = pair.Key;
curve[count + 8] = pair.Value;
count++;
}
return curve;
}
public bool IsXGConnected()
{
//return true;
return DeviceGet(GPUXGConnected) == 1;
}
public bool IsAllAmdPPT()
{
return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
}
public void ScanRange()
{
int value;
string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
string logFile = appPath + "\\scan.txt";
for (uint i = 0x00000000; i <= 0x00160000; i++)
{
value = DeviceGet(i);
if (value >= 0)
using (StreamWriter w = File.AppendText(logFile))
{
w.WriteLine(i.ToString("X8") + ": " + value.ToString("X4") + " (" + value + ")");
w.Close();
}
}
}
public void TUFKeyboardBrightness(int brightness)
{
int param = 0x80 | (brightness & 0x7F);
DeviceSet(TUF_KB_BRIGHTNESS, param, "TUF Brightness");
}
public void TUFKeyboardRGB(int mode, Color color, int speed)
{
byte[] setting = new byte[6];
setting[0] = (byte)0xb4;
setting[1] = (byte)mode;
setting[2] = color.R;
setting[3] = color.G;
setting[4] = color.B;
setting[5] = (byte)speed;
int result = DeviceSet(TUF_KB, setting, "TUF RGB");
if (result != 1) DeviceSet(TUF_KB2, setting, "TUF RGB");
}
const int ASUS_WMI_KEYBOARD_POWER_BOOT = 0x03 << 16;
const int ASUS_WMI_KEYBOARD_POWER_AWAKE = 0x0C << 16;
const int ASUS_WMI_KEYBOARD_POWER_SLEEP = 0x30 << 16;
const int ASUS_WMI_KEYBOARD_POWER_SHUTDOWN = 0xC0 << 16;
public void TUFKeyboardPower(bool awake = true, bool boot = false, bool sleep = false, bool shutdown = false)
{
int state = 0xbd;
if (boot) state = state | ASUS_WMI_KEYBOARD_POWER_BOOT;
if (awake) state = state | ASUS_WMI_KEYBOARD_POWER_AWAKE;
if (sleep) state = state | ASUS_WMI_KEYBOARD_POWER_SLEEP;
if (shutdown) state = state | ASUS_WMI_KEYBOARD_POWER_SHUTDOWN;
state = state | 0x01 << 8;
DeviceSet(TUF_KB_STATE, state, "TUF_KB");
}
public void SubscribeToEvents(Action<object, EventArrivedEventArgs> EventHandler)
{
try
{
ManagementEventWatcher watcher = new ManagementEventWatcher();
watcher.EventArrived += new EventArrivedEventHandler(EventHandler);
watcher.Scope = new ManagementScope("root\\wmi");
watcher.Query = new WqlEventQuery("SELECT * FROM AsusAtkWmiEvent");
watcher.Start();
}
catch
{
Logger.WriteLine("Can't connect to ASUS WMI events");
}
}
}

1499
app/AsusMouseSettings.Designer.cs generated Normal file

File diff suppressed because it is too large Load Diff

899
app/AsusMouseSettings.cs Normal file
View File

@@ -0,0 +1,899 @@
using GHelper.Peripherals.Mouse;
using GHelper.UI;
namespace GHelper
{
public partial class AsusMouseSettings : RForm
{
private static Dictionary<LightingMode, string> lightingModeNames = new Dictionary<LightingMode, string>()
{
{ LightingMode.Static,Properties.Strings.AuraStatic},
{ LightingMode.Breathing, Properties.Strings.AuraBreathe},
{ LightingMode.ColorCycle, Properties.Strings.AuraColorCycle},
{ LightingMode.Rainbow, Properties.Strings.AuraRainbow},
{ LightingMode.React, Properties.Strings.AuraReact},
{ LightingMode.Comet, Properties.Strings.AuraComet},
{ LightingMode.BatteryState, Properties.Strings.AuraBatteryState},
{ LightingMode.Off, Properties.Strings.MatrixOff},
};
private List<LightingMode> supportedLightingModes = new List<LightingMode>();
private readonly AsusMouse mouse;
private readonly RButton[] dpiButtons;
private LightingZone visibleZone = LightingZone.All;
private bool updateMouseDPI = true;
public AsusMouseSettings(AsusMouse mouse)
{
this.mouse = mouse;
InitializeComponent();
dpiButtons = new RButton[] { buttonDPI1, buttonDPI2, buttonDPI3, buttonDPI4 };
labelPollingRate.Text = Properties.Strings.PollingRate;
labelLighting.Text = Properties.Strings.Lighting;
labelLightingMode.Text = Properties.Strings.AuraLightingMode;
labelEnergy.Text = Properties.Strings.EnergySettings;
labelPerformance.Text = Properties.Strings.MousePerformance;
checkBoxRandomColor.Text = Properties.Strings.AuraRandomColor;
labelLowBatteryWarning.Text = Properties.Strings.MouseLowBatteryWarning;
labelAutoPowerOff.Text = Properties.Strings.MouseAutoPowerOff;
buttonSync.Text = Properties.Strings.MouseSynchronize;
checkBoxAngleSnapping.Text = Properties.Strings.MouseAngleSnapping;
labelLiftOffDistance.Text = Properties.Strings.MouseLiftOffDistance;
labelChargingState.Text = "(" + Properties.Strings.Charging + ")";
labelProfile.Text = Properties.Strings.Profile;
labelButtonDebounce.Text = Properties.Strings.MouseButtonResponse;
labelAcceleration.Text = Properties.Strings.Acceleration;
labelDeceleration.Text = Properties.Strings.Deceleration;
buttonLightingZoneLogo.Text = Properties.Strings.AuraZoneLogo;
buttonLightingZoneScroll.Text = Properties.Strings.AuraZoneScroll;
buttonLightingZoneUnderglow.Text = Properties.Strings.AuraZoneUnderglow;
buttonLightingZoneAll.Text = Properties.Strings.AuraZoneAll;
buttonLightingZoneDock.Text = Properties.Strings.AuraZoneDock;
InitTheme();
this.Text = mouse.GetDisplayName();
Shown += AsusMouseSettings_Shown;
FormClosing += AsusMouseSettings_FormClosing;
comboProfile.DropDownClosed += ComboProfile_DropDownClosed;
sliderDPI.ValueChanged += SliderDPI_ValueChanged;
numericUpDownCurrentDPI.ValueChanged += NumericUpDownCurrentDPI_ValueChanged;
sliderDPI.MouseUp += SliderDPI_MouseUp;
sliderDPI.MouseDown += SliderDPI_MouseDown;
buttonDPIColor.Click += ButtonDPIColor_Click;
buttonDPI1.Click += ButtonDPI_Click;
buttonDPI2.Click += ButtonDPI_Click;
buttonDPI3.Click += ButtonDPI_Click;
buttonDPI4.Click += ButtonDPI_Click;
comboBoxPollingRate.DropDownClosed += ComboBoxPollingRate_DropDownClosed;
checkBoxAngleSnapping.CheckedChanged += CheckAngleSnapping_CheckedChanged;
sliderAngleAdjustment.ValueChanged += SliderAngleAdjustment_ValueChanged;
sliderAngleAdjustment.MouseUp += SliderAngleAdjustment_MouseUp;
comboBoxLiftOffDistance.DropDownClosed += ComboBoxLiftOffDistance_DropDownClosed;
sliderButtonDebounce.ValueChanged += SliderButtonDebounce_ValueChanged;
sliderButtonDebounce.MouseUp += SliderButtonDebounce_MouseUp;
sliderAcceleration.MouseUp += SliderAcceleration_MouseUp;
sliderAcceleration.ValueChanged += SliderAcceleration_ValueChanged;
sliderDeceleration.MouseUp += SliderDeceleration_MouseUp;
sliderDeceleration.ValueChanged += SliderDeceleration_ValueChanged;
buttonLightingColor.Click += ButtonLightingColor_Click;
comboBoxLightingMode.DropDownClosed += ComboBoxLightingMode_DropDownClosed;
sliderBrightness.MouseUp += SliderBrightness_MouseUp;
comboBoxAnimationSpeed.DropDownClosed += ComboBoxAnimationSpeed_DropDownClosed;
comboBoxAnimationDirection.DropDownClosed += ComboBoxAnimationDirection_DropDownClosed;
checkBoxRandomColor.CheckedChanged += CheckBoxRandomColor_CheckedChanged;
sliderLowBatteryWarning.ValueChanged += SliderLowBatteryWarning_ValueChanged;
sliderLowBatteryWarning.MouseUp += SliderLowBatteryWarning_MouseUp;
comboBoxAutoPowerOff.DropDownClosed += ComboBoxAutoPowerOff_DropDownClosed;
buttonLightingZoneAll.Click += ButtonLightingZoneAll_Click;
buttonLightingZoneDock.Click += ButtonLightingZoneDock_Click;
buttonLightingZoneLogo.Click += ButtonLightingZoneLogo_Click;
buttonLightingZoneUnderglow.Click += ButtonLightingZoneUnderglow_Click;
buttonLightingZoneScroll.Click += ButtonLightingZoneScroll_Click;
InitMouseCapabilities();
Logger.WriteLine(mouse.GetDisplayName() + " (GUI): Initialized capabilities. Synchronizing mouse data");
RefreshMouseData();
}
private void SliderAcceleration_MouseUp(object? sender, MouseEventArgs e)
{
mouse.SetAcceleration(sliderAcceleration.Value);
}
private void SliderAcceleration_ValueChanged(object? sender, EventArgs e)
{
labelAccelerationValue.Text = sliderAcceleration.Value.ToString();
}
private void SliderDeceleration_MouseUp(object? sender, MouseEventArgs e)
{
mouse.SetDeceleration(sliderDeceleration.Value);
}
private void SliderDeceleration_ValueChanged(object? sender, EventArgs e)
{
labelDecelerationValue.Text = sliderDeceleration.Value.ToString();
}
private void SliderButtonDebounce_MouseUp(object? sender, MouseEventArgs e)
{
DebounceTime dbt = (DebounceTime)sliderButtonDebounce.Value;
mouse.SetDebounce(dbt);
}
private void SliderButtonDebounce_ValueChanged(object? sender, EventArgs e)
{
DebounceTime dbt = (DebounceTime)sliderButtonDebounce.Value;
int time = mouse.DebounceTimeInMS(dbt);
labelButtonDebounceValue.Text = time + "ms";
}
private void SwitchLightingZone(LightingZone zone)
{
if (!mouse.HasRGB())
{
return;
}
visibleZone = zone;
InitLightingModes();
VisusalizeLightingSettings();
}
private void ButtonLightingZoneScroll_Click(object? sender, EventArgs e)
{
SwitchLightingZone(LightingZone.Scrollwheel);
}
private void ButtonLightingZoneUnderglow_Click(object? sender, EventArgs e)
{
SwitchLightingZone(LightingZone.Underglow);
}
private void ButtonLightingZoneLogo_Click(object? sender, EventArgs e)
{
SwitchLightingZone(LightingZone.Logo);
}
private void ButtonLightingZoneDock_Click(object? sender, EventArgs e)
{
SwitchLightingZone(LightingZone.Dock);
}
private void ButtonLightingZoneAll_Click(object? sender, EventArgs e)
{
SwitchLightingZone(LightingZone.All);
}
private void AsusMouseSettings_FormClosing(object? sender, FormClosingEventArgs e)
{
mouse.BatteryUpdated -= Mouse_BatteryUpdated;
mouse.Disconnect -= Mouse_Disconnect;
mouse.MouseReadyChanged -= Mouse_MouseReadyChanged;
}
private void Mouse_MouseReadyChanged(object? sender, EventArgs e)
{
if (Disposing || IsDisposed)
{
return;
}
if (!mouse.IsDeviceReady)
{
this.Invoke(delegate
{
Close();
});
}
}
private void Mouse_BatteryUpdated(object? sender, EventArgs e)
{
if (Disposing || IsDisposed)
{
return;
}
this.Invoke(delegate
{
VisualizeBatteryState();
});
}
private void ComboProfile_DropDownClosed(object? sender, EventArgs e)
{
if (mouse.Profile == comboProfile.SelectedIndex)
{
return;
}
mouse.SetProfile(comboProfile.SelectedIndex);
RefreshMouseData();
}
private void ComboBoxPollingRate_DropDownClosed(object? sender, EventArgs e)
{
mouse.SetPollingRate(mouse.SupportedPollingrates()[comboBoxPollingRate.SelectedIndex]);
}
private void ButtonDPIColor_Click(object? sender, EventArgs e)
{
ColorDialog colorDlg = new ColorDialog
{
AllowFullOpen = true,
Color = pictureDPIColor.BackColor
};
if (colorDlg.ShowDialog() == DialogResult.OK)
{
AsusMouseDPI dpi = mouse.DpiSettings[mouse.DpiProfile - 1];
dpi.Color = colorDlg.Color;
mouse.SetDPIForProfile(dpi, mouse.DpiProfile);
VisualizeDPIButtons();
VisualizeCurrentDPIProfile();
}
}
private void ButtonDPI_Click(object? sender, EventArgs e)
{
int index = -1;
for (int i = 0; i < dpiButtons.Length; ++i)
{
if (sender == dpiButtons[i])
{
index = i;
break;
}
}
if (index == -1)
{
//huh?
return;
}
mouse.SetDPIProfile(index + 1);
VisualizeDPIButtons();
VisualizeCurrentDPIProfile();
}
private void UpdateLightingSettings(LightingSetting settings, LightingZone zone)
{
mouse.SetLightingSetting(settings, visibleZone);
VisusalizeLightingSettings();
}
private void CheckBoxRandomColor_CheckedChanged(object? sender, EventArgs e)
{
LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
ls.RandomColor = checkBoxRandomColor.Checked;
UpdateLightingSettings(ls, visibleZone);
}
private void ComboBoxAnimationDirection_DropDownClosed(object? sender, EventArgs e)
{
LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
ls.AnimationDirection = (AnimationDirection)comboBoxAnimationDirection.SelectedIndex;
UpdateLightingSettings(ls, visibleZone);
}
private void ComboBoxAnimationSpeed_DropDownClosed(object? sender, EventArgs e)
{
LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
// 0 => 0x9
// 1 => 0x7
// 2 => 0x5
ls.AnimationSpeed = (AnimationSpeed)(0x9 - (comboBoxAnimationSpeed.SelectedIndex * 0x2));
UpdateLightingSettings(ls, visibleZone);
}
private void SliderBrightness_MouseUp(object? sender, MouseEventArgs e)
{
LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
ls.Brightness = sliderBrightness.Value;
UpdateLightingSettings(ls, visibleZone);
}
private void ComboBoxLightingMode_DropDownClosed(object? sender, EventArgs e)
{
if (!mouse.HasRGB())
{
return;
}
LightingMode lm = supportedLightingModes[comboBoxLightingMode.SelectedIndex];
LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
if (ls.LightingMode == lm)
{
//Nothing to do here.
return;
}
ls.LightingMode = lm;
UpdateLightingSettings(ls, visibleZone);
}
private void ButtonLightingColor_Click(object? sender, EventArgs e)
{
ColorDialog colorDlg = new ColorDialog
{
AllowFullOpen = true,
Color = pictureBoxLightingColor.BackColor
};
if (colorDlg.ShowDialog() == DialogResult.OK)
{
LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
ls.RGBColor = colorDlg.Color;
UpdateLightingSettings(ls, visibleZone);
}
}
private void SliderLowBatteryWarning_ValueChanged(object? sender, EventArgs e)
{
labelLowBatteryWarningValue.Text = sliderLowBatteryWarning.Value.ToString() + "%";
}
private void SliderLowBatteryWarning_MouseUp(object? sender, MouseEventArgs e)
{
mouse.SetEnergySettings(sliderLowBatteryWarning.Value, mouse.PowerOffSetting);
}
private void ComboBoxAutoPowerOff_DropDownClosed(object? sender, EventArgs e)
{
object? obj = Enum.GetValues(typeof(PowerOffSetting)).GetValue(comboBoxAutoPowerOff.SelectedIndex);
if (obj is null)
{
return;
}
PowerOffSetting pos = (PowerOffSetting)obj;
mouse.SetEnergySettings(mouse.LowBatteryWarning, pos);
}
private void SliderAngleAdjustment_ValueChanged(object? sender, EventArgs e)
{
labelAngleAdjustmentValue.Text = sliderAngleAdjustment.Value.ToString() + "°";
}
private void SliderAngleAdjustment_MouseUp(object? sender, MouseEventArgs e)
{
mouse.SetAngleAdjustment((short)sliderAngleAdjustment.Value);
}
private void ComboBoxLiftOffDistance_DropDownClosed(object? sender, EventArgs e)
{
mouse.SetLiftOffDistance((LiftOffDistance)comboBoxLiftOffDistance.SelectedIndex);
}
private void CheckAngleSnapping_CheckedChanged(object? sender, EventArgs e)
{
mouse.SetAngleSnapping(checkBoxAngleSnapping.Checked);
mouse.SetAngleAdjustment((short)sliderAngleAdjustment.Value);
}
private void SliderDPI_ValueChanged(object? sender, EventArgs e)
{
numericUpDownCurrentDPI.Value = sliderDPI.Value;
UpdateMouseDPISettings();
}
private void NumericUpDownCurrentDPI_ValueChanged(object? sender, EventArgs e)
{
sliderDPI.Value = (int)numericUpDownCurrentDPI.Value;
}
private void SliderDPI_MouseDown(object? sender, MouseEventArgs e)
{
updateMouseDPI = false;
}
private void SliderDPI_MouseUp(object? sender, MouseEventArgs e)
{
updateMouseDPI = true;
UpdateMouseDPISettings();
}
private void UpdateMouseDPISettings()
{
if (!updateMouseDPI)
{
return;
}
AsusMouseDPI dpi = mouse.DpiSettings[mouse.DpiProfile - 1];
dpi.DPI = (uint)sliderDPI.Value;
mouse.SetDPIForProfile(dpi, mouse.DpiProfile);
VisualizeDPIButtons();
VisualizeCurrentDPIProfile();
}
private void Mouse_Disconnect(object? sender, EventArgs e)
{
if (Disposing || IsDisposed)
{
return;
}
//Mouse disconnected. Bye bye.
this.Invoke(delegate
{
this.Close();
});
}
private void RefreshMouseData()
{
mouse.SynchronizeDevice();
Logger.WriteLine(mouse.GetDisplayName() + " (GUI): Mouse data synchronized");
if (!mouse.IsDeviceReady)
{
Logger.WriteLine(mouse.GetDisplayName() + " (GUI): Mouse is not ready. Closing view.");
Mouse_Disconnect(this, EventArgs.Empty);
return;
}
if (Disposing || IsDisposed)
{
return;
}
VisualizeMouseSettings();
VisualizeBatteryState();
}
private void InitMouseCapabilities()
{
for (int i = 0; i < mouse.ProfileCount(); ++i)
{
String prf = Properties.Strings.Profile + " " + (i + 1);
comboProfile.Items.Add(prf);
}
labelMinDPI.Text = mouse.MinDPI().ToString();
labelMaxDPI.Text = mouse.MaxDPI().ToString();
sliderDPI.Max = mouse.MaxDPI();
sliderDPI.Min = mouse.MinDPI();
sliderDPI.Step = mouse.DPIIncrements();
numericUpDownCurrentDPI.Minimum = mouse.MinDPI();
numericUpDownCurrentDPI.Maximum = mouse.MaxDPI();
numericUpDownCurrentDPI.Increment = mouse.DPIIncrements();
if (!mouse.HasDebounceSetting())
{
panelDebounce.Visible = false;
}
if (!mouse.HasDPIColors())
{
buttonDPIColor.Visible = false;
pictureDPIColor.Visible = false;
buttonDPI1.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Red);
buttonDPI2.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Purple);
buttonDPI3.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Blue);
buttonDPI4.Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, Color.Green);
buttonDPI1.BorderColor = Color.Red;
buttonDPI2.BorderColor = Color.Purple;
buttonDPI3.BorderColor = Color.Blue;
buttonDPI4.BorderColor = Color.Green;
}
if (mouse.CanSetPollingRate())
{
foreach (PollingRate pr in mouse.SupportedPollingrates())
{
comboBoxPollingRate.Items.Add(mouse.PollingRateDisplayString(pr));
}
}
else
{
panelPollingRate.Visible = false;
}
if (!mouse.HasAngleSnapping())
{
checkBoxAngleSnapping.Visible = false;
}
if (!mouse.HasAngleTuning())
{
labelAngleAdjustmentValue.Visible = false;
sliderAngleAdjustment.Visible = false;
sliderAngleAdjustment.Max = mouse.AngleTuningMax();
sliderAngleAdjustment.Min = mouse.AngleTuningMin();
sliderAngleAdjustment.Step = mouse.AngleTuningStep();
}
if (!mouse.HasAngleTuning() && !mouse.HasAngleSnapping())
{
panelAngleSnapping.Visible = false;
}
if (mouse.HasAcceleration())
{
sliderAcceleration.Max = mouse.MaxAcceleration();
}
else
{
panelAcceleration.Visible = false;
}
if (mouse.HasDeceleration())
{
sliderDeceleration.Max = mouse.MaxDeceleration();
}
else
{
panelDeceleration.Visible = false;
}
if (mouse.HasLiftOffSetting())
{
comboBoxLiftOffDistance.Items.AddRange(new string[] {
Properties.Strings.Low,
Properties.Strings.High,
});
}
else
{
panelLiftOffDistance.Visible = false;
}
if (mouse.DPIProfileCount() < 4)
{
for (int i = 3; i > mouse.DPIProfileCount() - 1; --i)
{
dpiButtons[i].Visible = false;
}
}
if (!mouse.HasBattery())
{
panelBatteryState.Visible = false;
}
if (mouse.HasAutoPowerOff())
{
comboBoxAutoPowerOff.Items.AddRange(new string[]{
" 1 "+ Properties.Strings.Minute,
" 2 "+ Properties.Strings.Minutes,
" 3 "+ Properties.Strings.Minutes,
" 5 "+ Properties.Strings.Minutes,
"10 "+ Properties.Strings.Minutes,
Properties.Strings.Never,
});
}
if (!mouse.HasLowBatteryWarning())
{
labelLowBatteryWarning.Visible = false;
labelLowBatteryWarningValue.Visible = false;
sliderLowBatteryWarning.Visible = false;
}
else
{
sliderLowBatteryWarning.Min = 0;
sliderLowBatteryWarning.Step = mouse.LowBatteryWarningStep();
sliderLowBatteryWarning.Max = mouse.LowBatteryWarningMax();
}
if (!mouse.HasAutoPowerOff() && !mouse.HasLowBatteryWarning())
{
panelEnergy.Visible = false;
}
if (mouse.HasRGB())
{
if (mouse.SupportedLightingZones().Length > 1)
{
buttonLightingZoneLogo.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Logo);
buttonLightingZoneScroll.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Scrollwheel);
buttonLightingZoneUnderglow.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Underglow);
buttonLightingZoneDock.Visible = mouse.SupportedLightingZones().Contains(LightingZone.Dock);
}
else
{
buttonLightingZoneLogo.Visible = false;
buttonLightingZoneScroll.Visible = false;
buttonLightingZoneUnderglow.Visible = false;
buttonLightingZoneDock.Visible = false;
}
sliderBrightness.Max = mouse.MaxBrightness();
InitLightingModes();
comboBoxAnimationDirection.Items.AddRange(new string[] {
Properties.Strings.AuraClockwise,
Properties.Strings.AuraCounterClockwise,
});
comboBoxAnimationSpeed.Items.AddRange(new string[] {
Properties.Strings.AuraSlow,
Properties.Strings.AuraNormal,
Properties.Strings.AuraFast
});
}
else
{
panelLighting.Visible = false;
}
}
private void InitLightingModes()
{
comboBoxLightingMode.Items.Clear();
supportedLightingModes.Clear();
foreach (LightingMode lm in Enum.GetValues(typeof(LightingMode)))
{
if (mouse.IsLightingModeSupported(lm) && mouse.IsLightingModeSupportedForZone(lm, visibleZone))
{
comboBoxLightingMode.Items.Add(lightingModeNames.GetValueOrDefault(lm));
supportedLightingModes.Add(lm);
}
}
}
private void VisualizeMouseSettings()
{
comboProfile.SelectedIndex = mouse.Profile;
if (mouse.HasRGB())
{
//If current lighting mode is zoned, pre-select the first zone and not "All".
bool zoned = mouse.IsLightingZoned();
if (zoned)
{
visibleZone = mouse.SupportedLightingZones()[0];
InitLightingModes();
}
}
VisualizeDPIButtons();
VisualizeCurrentDPIProfile();
VisusalizeLightingSettings();
if (mouse.CanSetPollingRate())
{
int idx = mouse.PollingRateIndex(mouse.PollingRate);
if (idx == -1)
{
return;
}
comboBoxPollingRate.SelectedIndex = idx;
}
if (mouse.HasAngleSnapping())
{
checkBoxAngleSnapping.Checked = mouse.AngleSnapping;
}
if (mouse.HasAngleTuning())
{
sliderAngleAdjustment.Value = mouse.AngleAdjustmentDegrees;
}
if (mouse.HasAutoPowerOff())
{
if (mouse.PowerOffSetting == PowerOffSetting.Never)
{
comboBoxAutoPowerOff.SelectedIndex = comboBoxAutoPowerOff.Items.Count - 1;
}
else
{
comboBoxAutoPowerOff.SelectedIndex = (int)mouse.PowerOffSetting;
}
}
if (mouse.HasLowBatteryWarning())
{
sliderLowBatteryWarning.Value = mouse.LowBatteryWarning;
}
if (mouse.HasLiftOffSetting())
{
comboBoxLiftOffDistance.SelectedIndex = (int)mouse.LiftOffDistance;
}
if (mouse.HasDebounceSetting())
{
sliderButtonDebounce.Value = (int)mouse.Debounce;
}
if (mouse.HasAcceleration())
{
sliderAcceleration.Value = mouse.Acceleration;
}
if (mouse.HasDeceleration())
{
sliderDeceleration.Value = mouse.Deceleration;
}
}
private void VisualizeBatteryState()
{
if (!mouse.HasBattery())
{
return;
}
labelBatteryState.Text = mouse.Battery + "%";
labelChargingState.Visible = mouse.Charging;
if (mouse.Charging)
{
pictureBoxBatteryState.BackgroundImage = ControlHelper.TintImage(Properties.Resources.icons8_ladende_batterie_48, foreMain);
}
else
{
pictureBoxBatteryState.BackgroundImage = ControlHelper.TintImage(Properties.Resources.icons8_batterie_voll_geladen_48, foreMain);
}
}
public void VisusalizeLightingZones()
{
bool zoned = mouse.IsLightingZoned();
buttonLightingZoneAll.Activated = visibleZone == LightingZone.All;
buttonLightingZoneLogo.Activated = visibleZone == LightingZone.Logo;
buttonLightingZoneScroll.Activated = visibleZone == LightingZone.Scrollwheel;
buttonLightingZoneUnderglow.Activated = visibleZone == LightingZone.Underglow;
buttonLightingZoneDock.Activated = visibleZone == LightingZone.Dock;
buttonLightingZoneAll.Secondary = zoned;
buttonLightingZoneLogo.Secondary = !zoned;
buttonLightingZoneScroll.Secondary = !zoned;
buttonLightingZoneUnderglow.Secondary = !zoned;
buttonLightingZoneDock.Secondary = !zoned;
buttonLightingZoneAll.BackColor = buttonLightingZoneAll.Secondary ? RForm.buttonSecond : RForm.buttonMain;
buttonLightingZoneLogo.BackColor = buttonLightingZoneLogo.Secondary ? RForm.buttonSecond : RForm.buttonMain;
buttonLightingZoneScroll.BackColor = buttonLightingZoneScroll.Secondary ? RForm.buttonSecond : RForm.buttonMain;
buttonLightingZoneUnderglow.BackColor = buttonLightingZoneUnderglow.Secondary ? RForm.buttonSecond : RForm.buttonMain;
buttonLightingZoneDock.BackColor = buttonLightingZoneDock.Secondary ? RForm.buttonSecond : RForm.buttonMain;
}
private void VisusalizeLightingSettings()
{
if (!mouse.HasRGB())
{
return;
}
VisusalizeLightingZones();
LightingSetting? ls = mouse.LightingSettingForZone(visibleZone);
if (ls is null)
{
//Lighting settings not loaded?
return;
}
sliderBrightness.Value = ls.Brightness;
checkBoxRandomColor.Visible = mouse.SupportsRandomColor(ls.LightingMode);
pictureBoxLightingColor.Visible = mouse.SupportsColorSetting(ls.LightingMode);
buttonLightingColor.Visible = mouse.SupportsColorSetting(ls.LightingMode);
comboBoxAnimationSpeed.Visible = mouse.SupportsAnimationSpeed(ls.LightingMode);
labelAnimationSpeed.Visible = mouse.SupportsAnimationSpeed(ls.LightingMode);
comboBoxAnimationDirection.Visible = mouse.SupportsAnimationDirection(ls.LightingMode);
labelAnimationDirection.Visible = mouse.SupportsAnimationDirection(ls.LightingMode);
comboBoxLightingMode.SelectedIndex = supportedLightingModes.IndexOf(ls.LightingMode);
if (mouse.SupportsRandomColor(ls.LightingMode))
{
checkBoxRandomColor.Checked = ls.RandomColor;
buttonLightingColor.Visible = !ls.RandomColor;
}
if (ls.RandomColor && mouse.SupportsRandomColor(ls.LightingMode))
pictureBoxLightingColor.BackColor = Color.Transparent;
else
pictureBoxLightingColor.BackColor = ls.RGBColor;
//0x09 => 0
//0x07 => 1
//0x05 => 2
comboBoxAnimationSpeed.SelectedIndex = 2 - ((((int)ls.AnimationSpeed) - 5) / 2);
comboBoxAnimationDirection.SelectedIndex = (int)ls.AnimationDirection;
}
private void VisualizeDPIButtons()
{
for (int i = 0; i < mouse.DPIProfileCount() && i < 4; ++i)
{
AsusMouseDPI dpi = mouse.DpiSettings[i];
if (dpi is null)
{
continue;
}
if (mouse.HasDPIColors())
{
dpiButtons[i].Image = ControlHelper.TintImage(Properties.Resources.lighting_dot_24, dpi.Color);
dpiButtons[i].BorderColor = dpi.Color;
}
dpiButtons[i].Activated = (mouse.DpiProfile - 1) == i;
dpiButtons[i].Text = "DPI " + (i + 1) + "\n" + dpi.DPI;
}
}
private void VisualizeCurrentDPIProfile()
{
AsusMouseDPI dpi = mouse.DpiSettings[mouse.DpiProfile - 1];
if (dpi is null)
{
return;
}
sliderDPI.Value = (int)dpi.DPI;
pictureDPIColor.BackColor = dpi.Color;
}
private void AsusMouseSettings_Shown(object? sender, EventArgs e)
{
if (Height > Program.settingsForm.Height)
{
Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
}
else
{
Top = Program.settingsForm.Top;
}
Left = Program.settingsForm.Left - Width - 5;
mouse.Disconnect += Mouse_Disconnect;
mouse.BatteryUpdated += Mouse_BatteryUpdated;
mouse.MouseReadyChanged += Mouse_MouseReadyChanged;
}
private void ButtonSync_Click(object sender, EventArgs e)
{
RefreshMouseData();
}
}
}

120
app/AsusMouseSettings.resx Normal file
View File

@@ -0,0 +1,120 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing"">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

690
app/AsusUSB.cs Normal file
View File

@@ -0,0 +1,690 @@
using GHelper.Gpu;
using GHelper.Helpers;
using HidLibrary;
using NAudio.Gui;
using System.Diagnostics;
using System.Drawing;
using System.Text;
namespace GHelper
{
public class AuraPower
{
public bool BootLogo;
public bool BootKeyb;
public bool AwakeLogo;
public bool AwakeKeyb;
public bool SleepLogo;
public bool SleepKeyb;
public bool ShutdownLogo;
public bool ShutdownKeyb;
public bool BootBar;
public bool AwakeBar;
public bool SleepBar;
public bool ShutdownBar;
public bool BootLid;
public bool AwakeLid;
public bool SleepLid;
public bool ShutdownLid;
public bool BootRear;
public bool AwakeRear;
public bool SleepRear;
public bool ShutdownRear;
}
public static class AsusUSB
{
public const int HEATMAP = 20;
public const int GPUMODE = 21;
public const int ASUS_ID = 0x0b05;
public const byte INPUT_HID_ID = 0x5a;
public const byte AURA_HID_ID = 0x5d;
public static readonly byte[] LED_INIT1 = new byte[] { AURA_HID_ID, 0xb9 };
public static readonly byte[] LED_INIT2 = Encoding.ASCII.GetBytes("]ASUS Tech.Inc.");
public static readonly byte[] LED_INIT3 = new byte[] { AURA_HID_ID, 0x05, 0x20, 0x31, 0, 0x1a };
public static readonly byte[] LED_INIT4 = Encoding.ASCII.GetBytes("^ASUS Tech.Inc.");
public static readonly byte[] LED_INIT5 = new byte[] { 0x5e, 0x05, 0x20, 0x31, 0, 0x1a };
static byte[] MESSAGE_APPLY = { AURA_HID_ID, 0xb4 };
static byte[] MESSAGE_SET = { AURA_HID_ID, 0xb5, 0, 0, 0 };
static int[] deviceIds = { 0x1a30, 0x1854, 0x1869, 0x1866, 0x19b6, 0x1822, 0x1837, 0x1854, 0x184a, 0x183d, 0x8502, 0x1807, 0x17e0, 0x18c6, 0x1abe };
private static int mode = 0;
private static int speed = 1;
public static Color Color1 = Color.White;
public static Color Color2 = Color.Black;
static bool isTuf = AppConfig.IsTUF() || AppConfig.IsVivobook();
static bool isStrix = AppConfig.IsStrix();
static public bool isSingleColor = false;
static bool isOldHeatmap = AppConfig.Is("old_heatmap");
static System.Timers.Timer timer = new System.Timers.Timer(2000);
static HidDevice? auraDevice = null;
static byte[] AuraPowerMessage(AuraPower flags)
{
byte keyb = 0, bar = 0, lid = 0, rear = 0;
if (flags.BootLogo) keyb |= 1 << 0;
if (flags.BootKeyb) keyb |= 1 << 1;
if (flags.AwakeLogo) keyb |= 1 << 2;
if (flags.AwakeKeyb) keyb |= 1 << 3;
if (flags.SleepLogo) keyb |= 1 << 4;
if (flags.SleepKeyb) keyb |= 1 << 5;
if (flags.ShutdownLogo) keyb |= 1 << 6;
if (flags.ShutdownKeyb) keyb |= 1 << 7;
if (flags.BootBar) bar |= 1 << 1;
if (flags.AwakeBar) bar |= 1 << 2;
if (flags.SleepBar) bar |= 1 << 3;
if (flags.ShutdownBar) bar |= 1 << 4;
if (flags.BootLid) lid |= 1 << 0;
if (flags.AwakeLid) lid |= 1 << 1;
if (flags.SleepLid) lid |= 1 << 2;
if (flags.ShutdownLid) lid |= 1 << 3;
if (flags.BootLid) lid |= 1 << 4;
if (flags.AwakeLid) lid |= 1 << 5;
if (flags.SleepLid) lid |= 1 << 6;
if (flags.ShutdownLid) lid |= 1 << 7;
if (flags.BootRear) rear |= 1 << 0;
if (flags.AwakeRear) rear |= 1 << 1;
if (flags.SleepRear) rear |= 1 << 2;
if (flags.ShutdownRear) rear |= 1 << 3;
if (flags.BootRear) rear |= 1 << 4;
if (flags.AwakeRear) rear |= 1 << 5;
if (flags.SleepRear) rear |= 1 << 6;
if (flags.ShutdownRear) rear |= 1 << 7;
return new byte[] { 0x5d, 0xbd, 0x01, keyb, bar, lid, rear, 0xFF };
}
static AsusUSB()
{
timer.Elapsed += Timer_Elapsed;
isSingleColor = AppConfig.ContainsModel("GA401") || AppConfig.ContainsModel("X13"); // Mono Color
var device = GetDevice(AURA_HID_ID);
if (device is not null && (device.Attributes.Version == 22 || device.Attributes.Version == 23) && (AppConfig.ContainsModel("GA402X") || AppConfig.ContainsModel("GA402N"))) isSingleColor = true;
}
private static void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
{
SetHeatmap();
}
static void SetHeatmap(bool init = false)
{
float cpuTemp = (float)HardwareControl.GetCPUTemp();
int freeze = 20, cold = 40, warm = 65, hot = 90;
Color color;
//Debug.WriteLine(cpuTemp);
if (cpuTemp < cold) color = ColorUtilities.GetWeightedAverage(Color.Blue, Color.Green, ((float)cpuTemp - freeze) / (cold - freeze));
else if (cpuTemp < warm) color = ColorUtilities.GetWeightedAverage(Color.Green, Color.Yellow, ((float)cpuTemp - cold) / (warm - cold));
else if (cpuTemp < hot) color = ColorUtilities.GetWeightedAverage(Color.Yellow, Color.Red, ((float)cpuTemp - warm) / (hot - warm));
else color = Color.Red;
ApplyColor(color, init);
}
public static Dictionary<int, string> GetSpeeds()
{
return new Dictionary<int, string>
{
{ 0, Properties.Strings.AuraSlow },
{ 1, Properties.Strings.AuraNormal },
{ 2, Properties.Strings.AuraFast }
};
}
static Dictionary<int, string> _modesSingleColor = new Dictionary<int, string>
{
{ 0, Properties.Strings.AuraStatic },
{ 1, Properties.Strings.AuraBreathe },
{ 10, Properties.Strings.AuraStrobe },
};
static Dictionary<int, string> _modes = new Dictionary<int, string>
{
{ 0, Properties.Strings.AuraStatic },
{ 1, Properties.Strings.AuraBreathe },
{ 2, Properties.Strings.AuraColorCycle },
{ 3, Properties.Strings.AuraRainbow },
{ 10, Properties.Strings.AuraStrobe },
{ HEATMAP, "Heatmap"},
{ GPUMODE, "GPU Mode" }
};
static Dictionary<int, string> _modesStrix = new Dictionary<int, string>
{
{ 0, Properties.Strings.AuraStatic },
{ 1, Properties.Strings.AuraBreathe },
{ 2, Properties.Strings.AuraColorCycle },
{ 3, Properties.Strings.AuraRainbow },
{ 4, "Star" },
{ 5, "Rain" },
{ 6, "Highlight" },
{ 7, "Laser" },
{ 8, "Ripple" },
{ 10, Properties.Strings.AuraStrobe},
{ 11, "Comet" },
{ 12, "Flash" },
{ HEATMAP, "Heatmap"}
};
public static Dictionary<int, string> GetModes()
{
if (isTuf)
{
_modes.Remove(3);
}
if (isSingleColor)
{
return _modesSingleColor;
}
if (AppConfig.IsAdvantageEdition())
{
return _modes;
}
if (AppConfig.IsStrix())
{
return _modesStrix;
}
return _modes;
}
public static int Mode
{
get { return mode; }
set
{
if (GetModes().ContainsKey(value))
mode = value;
else
mode = 0;
}
}
public static bool HasSecondColor()
{
return (mode == 1 && !isTuf);
}
public static int Speed
{
get { return speed; }
set
{
if (GetSpeeds().ContainsKey(value))
speed = value;
else
speed = 1;
}
}
public static void SetColor(int colorCode)
{
Color1 = Color.FromArgb(colorCode);
}
public static void SetColor2(int colorCode)
{
Color2 = Color.FromArgb(colorCode);
}
private static IEnumerable<HidDevice> GetHidDevices(int[] deviceIds, int minFeatures = 1)
{
HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
foreach (HidDevice device in HidDeviceList)
if (device.IsConnected && device.Capabilities.FeatureReportByteLength >= minFeatures)
yield return device;
}
public static HidDevice? GetDevice(byte reportID = INPUT_HID_ID)
{
HidDevice[] HidDeviceList = HidDevices.Enumerate(ASUS_ID, deviceIds).ToArray();
HidDevice input = null;
foreach (HidDevice device in HidDeviceList)
if (device.ReadFeatureData(out byte[] data, reportID))
{
input = device;
//Logger.WriteLine("HID Device("+ reportID + ")" + + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.DevicePath);
}
return input;
}
public static bool TouchpadToggle()
{
HidDevice? input = GetDevice();
if (input != null) return input.WriteFeatureData(new byte[] { INPUT_HID_ID, 0xf4, 0x6b });
return false;
}
public static byte[] AuraMessage(int mode, Color color, Color color2, int speed, bool mono = false)
{
byte[] msg = new byte[17];
msg[0] = AURA_HID_ID;
msg[1] = 0xb3;
msg[2] = 0x00; // Zone
msg[3] = (byte)mode; // Aura Mode
msg[4] = color.R; // R
msg[5] = mono ? (byte)0 : color.G; // G
msg[6] = mono ? (byte)0 : color.B; // B
msg[7] = (byte)speed; // aura.speed as u8;
msg[8] = 0; // aura.direction as u8;
msg[9] = (mode == 1) ? (byte)1 : (byte)0;
msg[10] = color2.R; // R
msg[11] = mono ? (byte)0 : color2.G; // G
msg[12] = mono ? (byte)0 : color2.B; // B
return msg;
}
public static void Init()
{
Task.Run(async () =>
{
var devices = GetHidDevices(deviceIds);
foreach (HidDevice device in devices)
{
device.OpenDevice();
device.WriteFeatureData(LED_INIT1);
device.WriteFeatureData(LED_INIT2);
device.WriteFeatureData(LED_INIT3);
device.WriteFeatureData(LED_INIT4);
device.WriteFeatureData(LED_INIT5);
device.CloseDevice();
}
});
}
public static void ApplyBrightness(int brightness, string log = "Backlight", bool delay = false)
{
Task.Run(async () =>
{
if (delay) await Task.Delay(TimeSpan.FromSeconds(1));
if (isTuf) Program.acpi.TUFKeyboardBrightness(brightness);
byte[] msg = { AURA_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
var devices = GetHidDevices(deviceIds);
foreach (HidDevice device in devices)
{
device.OpenDevice();
if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
{
device.WriteFeatureData(msg);
Logger.WriteLine(log + ":" + BitConverter.ToString(msg));
}
if (AppConfig.ContainsModel("GA503") && device.ReadFeatureData(out byte[] dataBackkup, INPUT_HID_ID))
{
device.WriteFeatureData(msgBackup);
Logger.WriteLine(log + ":" + BitConverter.ToString(msgBackup));
}
device.CloseDevice();
}
// Backup payload for old models
/*
if (AppConfig.ContainsModel("GA503RW"))
{
byte[] msgBackup = { INPUT_HID_ID, 0xba, 0xc5, 0xc4, (byte)brightness };
var devicesBackup = GetHidDevices(deviceIds);
foreach (HidDevice device in devicesBackup)
{
device.OpenDevice();
device.WriteFeatureData(msgBackup);
device.CloseDevice();
}
}
*/
});
}
public static void ApplyAuraPower()
{
AuraPower flags = new();
// Keyboard
flags.AwakeKeyb = AppConfig.IsNotFalse("keyboard_awake");
flags.BootKeyb = AppConfig.IsNotFalse("keyboard_boot");
flags.SleepKeyb = AppConfig.IsNotFalse("keyboard_sleep");
flags.ShutdownKeyb = AppConfig.IsNotFalse("keyboard_shutdown");
// Logo
flags.AwakeLogo = AppConfig.IsNotFalse("keyboard_awake_logo");
flags.BootLogo = AppConfig.IsNotFalse("keyboard_boot_logo");
flags.SleepLogo = AppConfig.IsNotFalse("keyboard_sleep_logo");
flags.ShutdownLogo = AppConfig.IsNotFalse("keyboard_shutdown_logo");
// Lightbar
flags.AwakeBar = AppConfig.IsNotFalse("keyboard_awake_bar");
flags.BootBar = AppConfig.IsNotFalse("keyboard_boot_bar");
flags.SleepBar = AppConfig.IsNotFalse("keyboard_sleep_bar");
flags.ShutdownBar = AppConfig.IsNotFalse("keyboard_shutdown_bar");
// Lid
flags.AwakeLid = AppConfig.IsNotFalse("keyboard_awake_lid");
flags.BootLid = AppConfig.IsNotFalse("keyboard_boot_lid");
flags.SleepLid = AppConfig.IsNotFalse("keyboard_sleep_lid");
flags.ShutdownLid = AppConfig.IsNotFalse("keyboard_shutdown_lid");
// Rear Bar
flags.AwakeRear = AppConfig.IsNotFalse("keyboard_awake_lid");
flags.BootRear = AppConfig.IsNotFalse("keyboard_boot_lid");
flags.SleepRear = AppConfig.IsNotFalse("keyboard_sleep_lid");
flags.ShutdownRear = AppConfig.IsNotFalse("keyboard_shutdown_lid");
var devices = GetHidDevices(deviceIds);
byte[] msg = AuraPowerMessage(flags);
foreach (HidDevice device in devices)
{
device.OpenDevice();
if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
{
device.WriteFeatureData(msg);
Logger.WriteLine("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
}
device.CloseDevice();
}
if (isTuf)
Program.acpi.TUFKeyboardPower(
flags.AwakeKeyb,
flags.BootKeyb,
flags.SleepKeyb,
flags.ShutdownKeyb);
}
static void GetAuraDevice()
{
var devices = GetHidDevices(deviceIds);
foreach (HidDevice device in devices)
{
device.OpenDevice();
if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
{
Logger.WriteLine("Aura Device:" + device.DevicePath);
auraDevice = device;
return;
}
else
{
device.CloseDevice();
}
}
}
public static void ApplyColor(Color color, bool init = false)
{
if (isTuf)
{
Program.acpi.TUFKeyboardRGB(0, color, 0);
return;
}
if (auraDevice is null || !auraDevice.IsConnected) GetAuraDevice();
if (auraDevice is null || !auraDevice.IsConnected) return;
if (isStrix && !isOldHeatmap)
{
byte[] msg = new byte[0x40];
byte start = 9;
byte maxLeds = 0x93;
msg[0] = AURA_HID_ID;
msg[1] = 0xbc;
msg[2] = 0;
msg[3] = 1;
msg[4] = 1;
msg[5] = 1;
msg[6] = 0;
msg[7] = 0x10;
for (byte i = 0; i < 0x12; i++)
{
msg[start + i * 3] = color.R; // R
msg[start + 1 + i * 3] = color.G; // G
msg[start + 2 + i * 3] = color.B; // B
}
if (init)
{
auraDevice.Write(LED_INIT1);
auraDevice.Write(LED_INIT2);
auraDevice.Write(LED_INIT3);
auraDevice.Write(LED_INIT4);
auraDevice.Write(LED_INIT5);
auraDevice.Write(new byte[] { AURA_HID_ID, 0xbc });
}
for (byte b = 0; b < maxLeds; b += 0x10)
{
msg[6] = b;
auraDevice.Write(msg);
}
msg[6] = maxLeds;
auraDevice.Write(msg);
msg[4] = 4;
msg[5] = 0;
msg[6] = 0;
msg[7] = 0;
auraDevice.Write(msg);
}
else
{
Debug.WriteLine(color.ToString());
auraDevice.Write(AuraMessage(0, color, color, 0));
auraDevice.Write(MESSAGE_SET);
}
}
public static void ApplyGPUColor()
{
if (AppConfig.Get("aura_mode") != GPUMODE) return;
Logger.WriteLine(GPUModeControl.gpuMode.ToString());
switch (GPUModeControl.gpuMode)
{
case AsusACPI.GPUModeUltimate:
ApplyColor(Color.Red, true);
break;
case AsusACPI.GPUModeEco:
ApplyColor(Color.Green, true);
break;
default:
ApplyColor(Color.Yellow, true);
break;
}
}
public static void ApplyAura()
{
Mode = AppConfig.Get("aura_mode");
Speed = AppConfig.Get("aura_speed");
SetColor(AppConfig.Get("aura_color"));
SetColor2(AppConfig.Get("aura_color2"));
timer.Enabled = false;
if (Mode == HEATMAP)
{
SetHeatmap(true);
timer.Enabled = true;
return;
}
if (Mode == GPUMODE)
{
ApplyGPUColor();
return;
}
int _speed;
switch (Speed)
{
case 1:
_speed = 0xeb;
break;
case 2:
_speed = 0xf5;
break;
default:
_speed = 0xe1;
break;
}
byte[] msg;
var devices = GetHidDevices(deviceIds);
foreach (HidDevice device in devices)
{
device.OpenDevice();
if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
{
msg = AuraMessage(Mode, Color1, Color2, _speed, isSingleColor);
device.WriteFeatureData(msg);
device.WriteFeatureData(MESSAGE_APPLY);
device.WriteFeatureData(MESSAGE_SET);
Logger.WriteLine("USB-KB " + device.Attributes.Version + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
}
device.CloseDevice();
}
if (isTuf)
Program.acpi.TUFKeyboardRGB(Mode, Color1, _speed);
}
// Reference : thanks to https://github.com/RomanYazvinsky/ for initial discovery of XGM payloads
public static int SetXGM(byte[] msg)
{
//Logger.WriteLine("XGM Payload :" + BitConverter.ToString(msg));
var payload = new byte[300];
Array.Copy(msg, payload, msg.Length);
foreach (HidDevice device in GetHidDevices(new int[] { 0x1970 }, 300))
{
device.OpenDevice();
Logger.WriteLine("XGM " + device.Attributes.ProductHexId + "|" + device.Capabilities.FeatureReportByteLength + ":" + BitConverter.ToString(msg));
device.WriteFeatureData(payload);
device.CloseDevice();
//return 1;
}
return 0;
}
public static void InitXGM()
{
byte[] ASUS_INIT = Encoding.ASCII.GetBytes("^ASUS Tech.Inc.");
SetXGM(ASUS_INIT);
/*
SetXGM(new byte[] { 0x5e, 0xd0, 0x02 });
SetXGM(new byte[] { 0x5e, 0xd0, 0x03 });
SetXGM(ASUS_INIT);
SetXGM(new byte[] { 0x5e, 0xd1, 0x02 }); // reset fan
SetXGM(ASUS_INIT);
SetXGM(new byte[] { 0x5e, 0xce, 0x03 });
SetXGM(new byte[] { 0x5e, 0xd0, 0x04 });
SetXGM(new byte[] { 0x5e, 0xd0, 0x01 });
*/
}
public static void ApplyXGMLight(bool status)
{
SetXGM(new byte[] { 0x5e, 0xc5, status ? (byte)0x50 : (byte)0 });
}
public static int ResetXGM()
{
return SetXGM(new byte[] { 0x5e, 0xd1, 0x02 });
}
public static int SetXGMFan(byte[] curve)
{
if (AsusACPI.IsInvalidCurve(curve)) return -1;
//InitXGM();
byte[] msg = new byte[19];
Array.Copy(new byte[] { 0x5e, 0xd1, 0x01 }, msg, 3);
Array.Copy(curve, 0, msg, 3, curve.Length);
return SetXGM(msg);
}
}
}

View File

@@ -0,0 +1,133 @@
using System.Diagnostics;
using System.Net;
using System.Reflection;
using System.Text.Json;
namespace GHelper.AutoUpdate
{
public class AutoUpdateControl
{
SettingsForm settings;
public string versionUrl = "http://github.com/seerge/g-helper/releases";
static long lastUpdate;
public AutoUpdateControl(SettingsForm settingsForm)
{
settings = settingsForm;
var appVersion = new Version(Assembly.GetExecutingAssembly().GetName().Version.ToString());
settings.SetVersionLabel(Properties.Strings.VersionLabel + $": {appVersion.Major}.{appVersion.Minor}.{appVersion.Build}");
}
public void CheckForUpdates()
{
// Run update once per 12 hours
if (Math.Abs(DateTimeOffset.Now.ToUnixTimeSeconds() - lastUpdate) < 43200) return;
lastUpdate = DateTimeOffset.Now.ToUnixTimeSeconds();
Task.Run(async () =>
{
await Task.Delay(TimeSpan.FromSeconds(1));
CheckForUpdatesAsync();
});
}
public void LoadReleases()
{
Process.Start(new ProcessStartInfo(versionUrl) { UseShellExecute = true });
}
async void CheckForUpdatesAsync()
{
if (AppConfig.Is("skip_updates")) return;
try
{
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Add("User-Agent", "C# App");
var json = await httpClient.GetStringAsync("https://api.github.com/repos/seerge/g-helper/releases/latest");
var config = JsonSerializer.Deserialize<JsonElement>(json);
var tag = config.GetProperty("tag_name").ToString().Replace("v", "");
var assets = config.GetProperty("assets");
string url = null;
for (int i = 0; i < assets.GetArrayLength(); i++)
{
if (assets[i].GetProperty("browser_download_url").ToString().Contains(".zip"))
url = assets[i].GetProperty("browser_download_url").ToString();
}
if (url is null)
url = assets[0].GetProperty("browser_download_url").ToString();
var gitVersion = new Version(tag);
var appVersion = new Version(Assembly.GetExecutingAssembly().GetName().Version.ToString());
//appVersion = new Version("0.50.0.0");
if (gitVersion.CompareTo(appVersion) > 0)
{
versionUrl = url;
settings.SetVersionLabel(Properties.Strings.DownloadUpdate + ": " + tag, true);
if (AppConfig.GetString("skip_version") != tag)
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.DownloadUpdate + ": G-Helper " + tag + "?", "Update", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
AutoUpdate(url);
else
AppConfig.Set("skip_version", tag);
}
}
else
{
Logger.WriteLine($"Latest version {appVersion}");
}
}
}
catch (Exception ex)
{
Logger.WriteLine("Failed to check for updates:" + ex.Message);
}
}
async void AutoUpdate(string requestUri)
{
Uri uri = new Uri(requestUri);
string zipName = Path.GetFileName(uri.LocalPath);
string exeLocation = Application.ExecutablePath;
string exeDir = Path.GetDirectoryName(exeLocation);
string zipLocation = exeDir + "\\" + zipName;
using (WebClient client = new WebClient())
{
client.DownloadFile(uri, zipLocation);
Logger.WriteLine(requestUri);
Logger.WriteLine(zipLocation);
Logger.WriteLine(exeLocation);
var cmd = new Process();
cmd.StartInfo.UseShellExecute = false;
cmd.StartInfo.CreateNoWindow = true;
cmd.StartInfo.FileName = "powershell";
cmd.StartInfo.Arguments = $"Start-Sleep -Seconds 1; Expand-Archive {zipLocation} -DestinationPath {exeDir} -Force; Remove-Item {zipLocation} -Force; {exeLocation}";
cmd.Start();
Application.Exit();
}
}
}
}

View File

@@ -0,0 +1,20 @@
namespace GHelper.Battery
{
internal class BatteryControl
{
public static void SetBatteryChargeLimit(int limit = -1)
{
if (limit < 0) limit = AppConfig.Get("charge_limit");
if (limit < 40 || limit > 100) return;
Program.acpi.DeviceSet(AsusACPI.BatteryLimit, limit, "BatteryLimit");
Program.settingsForm.VisualiseBattery(limit);
AppConfig.Set("charge_limit", limit);
}
}
}

View File

@@ -0,0 +1,47 @@
namespace GHelper.Display
{
using System;
using System.Diagnostics;
using System.Management;
public static class ScreenBrightness
{
public static int Get()
{
using var mclass = new ManagementClass("WmiMonitorBrightness")
{
Scope = new ManagementScope(@"\\.\root\wmi")
};
using var instances = mclass.GetInstances();
foreach (ManagementObject instance in instances)
{
return (byte)instance.GetPropertyValue("CurrentBrightness");
}
return 0;
}
public static void Set(int brightness)
{
using var mclass = new ManagementClass("WmiMonitorBrightnessMethods")
{
Scope = new ManagementScope(@"\\.\root\wmi")
};
using var instances = mclass.GetInstances();
var args = new object[] { 1, brightness };
foreach (ManagementObject instance in instances)
{
instance.InvokeMethod("WmiSetBrightness", args);
}
}
public static int Adjust(int delta)
{
int brightness = Get();
Debug.WriteLine(brightness);
brightness = Math.Min(100, Math.Max(0, brightness + delta));
Set(brightness);
return brightness;
}
}
}

View File

@@ -0,0 +1,108 @@
using System.Diagnostics;
namespace GHelper.Display
{
public class ScreenControl
{
public const int MAX_REFRESH = 1000;
public void AutoScreen(bool force = false)
{
if (force || AppConfig.Is("screen_auto"))
{
if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
SetScreen(MAX_REFRESH, 1);
else
SetScreen(60, 0);
}
else
{
SetScreen(overdrive: AppConfig.Get("overdrive"));
}
}
public void SetScreen(int frequency = -1, int overdrive = -1, int miniled = -1)
{
var laptopScreen = ScreenNative.FindLaptopScreen(true);
if (laptopScreen is null) return;
if (ScreenNative.GetRefreshRate(laptopScreen) < 0) return;
if (frequency >= MAX_REFRESH)
{
frequency = ScreenNative.GetMaxRefreshRate(laptopScreen);
}
if (frequency > 0)
{
ScreenNative.SetRefreshRate(laptopScreen, frequency);
}
if (overdrive >= 0)
{
if (AppConfig.Get("no_overdrive") == 1) overdrive = 0;
Program.acpi.DeviceSet(AsusACPI.ScreenOverdrive, overdrive, "ScreenOverdrive");
}
if (miniled >= 0)
{
Program.acpi.DeviceSet(AsusACPI.ScreenMiniled, miniled, "Miniled");
Debug.WriteLine("Miniled " + miniled);
}
InitScreen();
}
public void ToogleMiniled()
{
int miniled = (Program.acpi.DeviceGet(AsusACPI.ScreenMiniled) == 1) ? 0 : 1;
AppConfig.Set("miniled", miniled);
SetScreen(-1, -1, miniled);
}
public void InitScreen()
{
var laptopScreen = ScreenNative.FindLaptopScreen();
int frequency = ScreenNative.GetRefreshRate(laptopScreen);
int maxFrequency = ScreenNative.GetMaxRefreshRate(laptopScreen);
bool screenAuto = AppConfig.Is("screen_auto");
bool overdriveSetting = !AppConfig.Is("no_overdrive");
int overdrive = Program.acpi.DeviceGet(AsusACPI.ScreenOverdrive);
int miniled = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled);
bool hdr = false;
if (miniled >= 0)
{
AppConfig.Set("miniled", miniled);
}
bool screenEnabled = (frequency >= 0);
AppConfig.Set("frequency", frequency);
AppConfig.Set("overdrive", overdrive);
Program.settingsForm.Invoke(delegate
{
Program.settingsForm.VisualiseScreen(
screenEnabled: screenEnabled,
screenAuto: screenAuto,
frequency: frequency,
maxFrequency: maxFrequency,
overdrive: overdrive,
overdriveSetting: overdriveSetting,
miniled: miniled,
hdr: hdr
);
});
}
}
}

View File

@@ -0,0 +1,375 @@
using GHelper.Helpers;
using NvAPIWrapper.Display;
using System.ComponentModel;
using System.Runtime.InteropServices;
namespace GHelper.Display
{
public static class ScreenInterrogatory
{
public const int ERROR_SUCCESS = 0;
#region enums
public enum QUERY_DEVICE_CONFIG_FLAGS : uint
{
QDC_ALL_PATHS = 0x00000001,
QDC_ONLY_ACTIVE_PATHS = 0x00000002,
QDC_DATABASE_CURRENT = 0x00000004
}
public enum DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY : uint
{
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = 0xFFFFFFFF,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HD15 = 0,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SVIDEO = 1,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPOSITE_VIDEO = 2,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_COMPONENT_VIDEO = 3,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DVI = 4,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_HDMI = 5,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_LVDS = 6,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_D_JPN = 8,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDI = 9,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EXTERNAL = 10,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED = 11,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EXTERNAL = 12,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_UDI_EMBEDDED = 13,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_SDTVDONGLE = 14,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_MIRACAST = 15,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = 0x80000000,
DISPLAYCONFIG_OUTPUT_TECHNOLOGY_FORCE_UINT32 = 0xFFFFFFFF
}
public enum DISPLAYCONFIG_SCANLINE_ORDERING : uint
{
DISPLAYCONFIG_SCANLINE_ORDERING_UNSPECIFIED = 0,
DISPLAYCONFIG_SCANLINE_ORDERING_PROGRESSIVE = 1,
DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED = 2,
DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_UPPERFIELDFIRST = DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED,
DISPLAYCONFIG_SCANLINE_ORDERING_INTERLACED_LOWERFIELDFIRST = 3,
DISPLAYCONFIG_SCANLINE_ORDERING_FORCE_UINT32 = 0xFFFFFFFF
}
public enum DISPLAYCONFIG_ROTATION : uint
{
DISPLAYCONFIG_ROTATION_IDENTITY = 1,
DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
DISPLAYCONFIG_ROTATION_ROTATE270 = 4,
DISPLAYCONFIG_ROTATION_FORCE_UINT32 = 0xFFFFFFFF
}
public enum DISPLAYCONFIG_SCALING : uint
{
DISPLAYCONFIG_SCALING_IDENTITY = 1,
DISPLAYCONFIG_SCALING_CENTERED = 2,
DISPLAYCONFIG_SCALING_STRETCHED = 3,
DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
DISPLAYCONFIG_SCALING_CUSTOM = 5,
DISPLAYCONFIG_SCALING_PREFERRED = 128,
DISPLAYCONFIG_SCALING_FORCE_UINT32 = 0xFFFFFFFF
}
public enum DISPLAYCONFIG_PIXELFORMAT : uint
{
DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
DISPLAYCONFIG_PIXELFORMAT_FORCE_UINT32 = 0xffffffff
}
public enum DISPLAYCONFIG_MODE_INFO_TYPE : uint
{
DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
DISPLAYCONFIG_MODE_INFO_TYPE_FORCE_UINT32 = 0xFFFFFFFF
}
public enum DISPLAYCONFIG_DEVICE_INFO_TYPE : uint
{
DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME = 1,
DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME = 2,
DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_PREFERRED_MODE = 3,
DISPLAYCONFIG_DEVICE_INFO_GET_ADAPTER_NAME = 4,
DISPLAYCONFIG_DEVICE_INFO_SET_TARGET_PERSISTENCE = 5,
DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_BASE_TYPE = 6,
DISPLAYCONFIG_DEVICE_INFO_FORCE_UINT32 = 0xFFFFFFFF
}
#endregion
#region structs
[StructLayout(LayoutKind.Sequential)]
public struct LUID
{
public uint LowPart;
public int HighPart;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_PATH_SOURCE_INFO
{
public LUID adapterId;
public uint id;
public uint modeInfoIdx;
public uint statusFlags;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_PATH_TARGET_INFO
{
public LUID adapterId;
public uint id;
public uint modeInfoIdx;
private DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
private DISPLAYCONFIG_ROTATION rotation;
private DISPLAYCONFIG_SCALING scaling;
private DISPLAYCONFIG_RATIONAL refreshRate;
private DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
public bool targetAvailable;
public uint statusFlags;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_RATIONAL
{
public uint Numerator;
public uint Denominator;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_PATH_INFO
{
public DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
public DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
public uint flags;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_2DREGION
{
public uint cx;
public uint cy;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_VIDEO_SIGNAL_INFO
{
public ulong pixelRate;
public DISPLAYCONFIG_RATIONAL hSyncFreq;
public DISPLAYCONFIG_RATIONAL vSyncFreq;
public DISPLAYCONFIG_2DREGION activeSize;
public DISPLAYCONFIG_2DREGION totalSize;
public uint videoStandard;
public DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_TARGET_MODE
{
public DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
}
[StructLayout(LayoutKind.Sequential)]
public struct POINTL
{
private int x;
private int y;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_SOURCE_MODE
{
public uint width;
public uint height;
public DISPLAYCONFIG_PIXELFORMAT pixelFormat;
public POINTL position;
}
[StructLayout(LayoutKind.Explicit)]
public struct DISPLAYCONFIG_MODE_INFO_UNION
{
[FieldOffset(0)]
public DISPLAYCONFIG_TARGET_MODE targetMode;
[FieldOffset(0)]
public DISPLAYCONFIG_SOURCE_MODE sourceMode;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_MODE_INFO
{
public DISPLAYCONFIG_MODE_INFO_TYPE infoType;
public uint id;
public LUID adapterId;
public DISPLAYCONFIG_MODE_INFO_UNION modeInfo;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
{
public uint value;
}
[StructLayout(LayoutKind.Sequential)]
public struct DISPLAYCONFIG_DEVICE_INFO_HEADER
{
public DISPLAYCONFIG_DEVICE_INFO_TYPE type;
public uint size;
public LUID adapterId;
public uint id;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DISPLAYCONFIG_TARGET_DEVICE_NAME
{
public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
public DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS flags;
public DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
public ushort edidManufactureId;
public ushort edidProductCodeId;
public uint connectorInstance;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
public string monitorFriendlyDeviceName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string monitorDevicePath;
}
#endregion
#region DLL-Imports
[DllImport("user32.dll")]
public static extern int GetDisplayConfigBufferSizes(
QUERY_DEVICE_CONFIG_FLAGS flags, out uint numPathArrayElements, out uint numModeInfoArrayElements);
[DllImport("user32.dll")]
public static extern int QueryDisplayConfig(
QUERY_DEVICE_CONFIG_FLAGS flags,
ref uint numPathArrayElements, [Out] DISPLAYCONFIG_PATH_INFO[] PathInfoArray,
ref uint numModeInfoArrayElements, [Out] DISPLAYCONFIG_MODE_INFO[] ModeInfoArray,
nint currentTopologyId
);
[DllImport("user32.dll")]
public static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_TARGET_DEVICE_NAME deviceName);
#endregion
[Flags]
public enum DisplayDeviceStates : int
{
ATTACHED_TO_DESKTOP = 0x01,
PRIMARY_DEVICE = 0x04,
MIRRORING_DRIVER = 0x08,
VGA_COMPATIBLE = 0x10,
REMOVABLE = 0x20,
DISCONNECTED = 0x2000000,
REMOTE = 0x4000000,
MODESPRUNED = 0x8000000
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct DISPLAY_DEVICE
{
public int cb;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string DeviceName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string DeviceString;
public DisplayDeviceStates StateFlags;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string DeviceID;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string DeviceKey;
}
[DllImport(nameof(User32), CharSet = CharSet.Unicode, SetLastError = true)]
public static extern bool EnumDisplayDevices(
string? lpDevice,
uint iDevNum,
ref DISPLAY_DEVICE lpDisplayDevice,
uint dwFlags);
private static DISPLAYCONFIG_TARGET_DEVICE_NAME DeviceName(LUID adapterId, uint targetId)
{
var deviceName = new DISPLAYCONFIG_TARGET_DEVICE_NAME
{
header =
{
size = (uint)Marshal.SizeOf(typeof (DISPLAYCONFIG_TARGET_DEVICE_NAME)),
adapterId = adapterId,
id = targetId,
type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME
}
};
var error = DisplayConfigGetDeviceInfo(ref deviceName);
if (error != ERROR_SUCCESS)
throw new Win32Exception(error);
return deviceName;
}
public static IEnumerable<DISPLAYCONFIG_TARGET_DEVICE_NAME> GetAllDevices()
{
uint pathCount, modeCount;
var error = GetDisplayConfigBufferSizes(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS, out pathCount, out modeCount);
if (error != ERROR_SUCCESS)
throw new Win32Exception(error);
var displayPaths = new DISPLAYCONFIG_PATH_INFO[pathCount];
var displayModes = new DISPLAYCONFIG_MODE_INFO[modeCount];
error = QueryDisplayConfig(QUERY_DEVICE_CONFIG_FLAGS.QDC_ONLY_ACTIVE_PATHS,
ref pathCount, displayPaths, ref modeCount, displayModes, nint.Zero);
if (error != ERROR_SUCCESS)
throw new Win32Exception(error);
for (var i = 0; i < modeCount; i++)
if (displayModes[i].infoType == DISPLAYCONFIG_MODE_INFO_TYPE.DISPLAYCONFIG_MODE_INFO_TYPE_TARGET)
yield return DeviceName(displayModes[i].adapterId, displayModes[i].id);
}
public static IEnumerable<DISPLAY_DEVICE> GetDisplayDevices()
{
var displayAdapter = new DISPLAY_DEVICE();
displayAdapter.cb = Marshal.SizeOf<DISPLAY_DEVICE>();
var displayAdapterNumber = default(uint);
while (EnumDisplayDevices(null, displayAdapterNumber, ref displayAdapter, 1))
{
var displayMonitor = new DISPLAY_DEVICE();
displayMonitor.cb = Marshal.SizeOf<DISPLAY_DEVICE>();
var displayMonitorNumber = default(uint);
while (EnumDisplayDevices(displayAdapter.DeviceName, displayMonitorNumber, ref displayMonitor, 1))
{
var isAttached = (displayMonitor.StateFlags & DisplayDeviceStates.ATTACHED_TO_DESKTOP) == DisplayDeviceStates.ATTACHED_TO_DESKTOP;
var isMirroring = (displayMonitor.StateFlags & DisplayDeviceStates.MIRRORING_DRIVER) == DisplayDeviceStates.MIRRORING_DRIVER;
if (isAttached && !isMirroring) yield return displayMonitor;
displayMonitorNumber++;
}
displayAdapterNumber++;
}
}
}
}

284
app/Display/ScreenNative.cs Normal file
View File

@@ -0,0 +1,284 @@
using System.Collections;
using System.Diagnostics;
using System.Runtime.InteropServices;
using static GHelper.Display.ScreenInterrogatory;
namespace GHelper.Display
{
class DeviceComparer : IComparer
{
public int Compare(object x, object y)
{
uint displayX = ((DISPLAYCONFIG_TARGET_DEVICE_NAME)x).connectorInstance;
uint displayY = ((DISPLAYCONFIG_TARGET_DEVICE_NAME)y).connectorInstance;
if (displayX > displayY)
return 1;
if (displayX < displayY)
return -1;
else
return 0;
}
}
class ScreenComparer : IComparer
{
public int Compare(object x, object y)
{
int displayX = Int32.Parse(((Screen)x).DeviceName.Replace(@"\\.\DISPLAY", ""));
int displayY = Int32.Parse(((Screen)y).DeviceName.Replace(@"\\.\DISPLAY", ""));
return (new CaseInsensitiveComparer()).Compare(displayX, displayY);
}
}
internal class ScreenNative
{
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct DEVMODE
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string dmDeviceName;
public short dmSpecVersion;
public short dmDriverVersion;
public short dmSize;
public short dmDriverExtra;
public int dmFields;
public int dmPositionX;
public int dmPositionY;
public int dmDisplayOrientation;
public int dmDisplayFixedOutput;
public short dmColor;
public short dmDuplex;
public short dmYResolution;
public short dmTTOption;
public short dmCollate;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string dmFormName;
public short dmLogPixels;
public short dmBitsPerPel;
public int dmPelsWidth;
public int dmPelsHeight;
public int dmDisplayFlags;
public int dmDisplayFrequency;
public int dmICMMethod;
public int dmICMIntent;
public int dmMediaType;
public int dmDitherType;
public int dmReserved1;
public int dmReserved2;
public int dmPanningWidth;
public int dmPanningHeight;
};
[Flags()]
public enum DisplaySettingsFlags : int
{
CDS_UPDATEREGISTRY = 1,
CDS_TEST = 2,
CDS_FULLSCREEN = 4,
CDS_GLOBAL = 8,
CDS_SET_PRIMARY = 0x10,
CDS_RESET = 0x40000000,
CDS_NORESET = 0x10000000
}
// PInvoke declaration for EnumDisplaySettings Win32 API
[DllImport("user32.dll")]
public static extern int EnumDisplaySettingsEx(
string lpszDeviceName,
int iModeNum,
ref DEVMODE lpDevMode);
// PInvoke declaration for ChangeDisplaySettings Win32 API
[DllImport("user32.dll")]
public static extern int ChangeDisplaySettingsEx(
string lpszDeviceName, ref DEVMODE lpDevMode, IntPtr hwnd,
DisplaySettingsFlags dwflags, IntPtr lParam);
public static DEVMODE CreateDevmode()
{
DEVMODE dm = new DEVMODE();
dm.dmDeviceName = new String(new char[32]);
dm.dmFormName = new String(new char[32]);
dm.dmSize = (short)Marshal.SizeOf(dm);
return dm;
}
public enum COLORPROFILETYPE
{
CPT_ICC,
CPT_DMP,
CPT_CAMP,
CPT_GMMP
}
public enum COLORPROFILESUBTYPE
{
CPST_PERCEPTUAL,
CPST_RELATIVE_COLORIMETRIC,
CPST_SATURATION,
CPST_ABSOLUTE_COLORIMETRIC,
CPST_NONE,
CPST_RGB_WORKING_SPACE,
CPST_CUSTOM_WORKING_SPACE,
CPST_STANDARD_DISPLAY_COLOR_MODE,
CPST_EXTENDED_DISPLAY_COLOR_MODE
}
public enum WCS_PROFILE_MANAGEMENT_SCOPE
{
WCS_PROFILE_MANAGEMENT_SCOPE_SYSTEM_WIDE,
WCS_PROFILE_MANAGEMENT_SCOPE_CURRENT_USER
}
[DllImport("mscms.dll", CharSet = CharSet.Unicode)]
public static extern bool WcsSetDefaultColorProfile(
WCS_PROFILE_MANAGEMENT_SCOPE scope,
string pDeviceName,
COLORPROFILETYPE cptColorProfileType,
COLORPROFILESUBTYPE cpstColorProfileSubType,
uint dwProfileID,
string pProfileName
);
public const int ENUM_CURRENT_SETTINGS = -1;
public const string defaultDevice = @"\\.\DISPLAY1";
private static string? FindInternalName(bool log = false)
{
try
{
var devices = GetAllDevices().ToArray();
string internalName = AppConfig.GetString("internal_display");
foreach (var device in devices)
{
if (device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL ||
device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED ||
device.monitorFriendlyDeviceName == internalName)
{
if (log) Logger.WriteLine(device.monitorDevicePath + " " + device.outputTechnology);
AppConfig.Set("internal_display", device.monitorFriendlyDeviceName);
var names = device.monitorDevicePath.Split("#");
return names[1];
}
}
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
return null;
}
static string ExtractDisplay(string input)
{
int index = input.IndexOf('\\', 4); // Start searching from index 4 to skip ""
if (index != -1)
{
string extracted = input.Substring(0, index);
return extracted;
}
return input;
}
public static string? FindLaptopScreen(bool log = false)
{
string? laptopScreen = null;
string? internalName = FindInternalName(log);
if (internalName == null)
{
Logger.WriteLine("Internal screen off");
return null;
}
try
{
var displays = GetDisplayDevices().ToArray();
foreach (var display in displays)
{
if (log) Logger.WriteLine(display.DeviceID + " " + display.DeviceName);
if (display.DeviceID.Contains(internalName))
{
laptopScreen = ExtractDisplay(display.DeviceName);
break;
}
}
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
if (laptopScreen is null)
{
Logger.WriteLine("Default internal screen");
laptopScreen = Screen.PrimaryScreen.DeviceName;
}
return laptopScreen;
}
public static int GetMaxRefreshRate(string? laptopScreen)
{
if (laptopScreen is null) return -1;
DEVMODE dm = CreateDevmode();
int frequency = -1;
int i = 0;
while (0 != EnumDisplaySettingsEx(laptopScreen, i, ref dm))
{
if (dm.dmDisplayFrequency > frequency) frequency = dm.dmDisplayFrequency;
i++;
}
if (frequency > 0) AppConfig.Set("screen_max", frequency);
else frequency = AppConfig.Get("screen_max");
return frequency;
}
public static int GetRefreshRate(string? laptopScreen)
{
if (laptopScreen is null) return -1;
DEVMODE dm = CreateDevmode();
int frequency = -1;
if (0 != EnumDisplaySettingsEx(laptopScreen, ENUM_CURRENT_SETTINGS, ref dm))
{
frequency = dm.dmDisplayFrequency;
}
return frequency;
}
public static int SetRefreshRate(string laptopScreen, int frequency = 120)
{
DEVMODE dm = CreateDevmode();
if (0 != EnumDisplaySettingsEx(laptopScreen, ENUM_CURRENT_SETTINGS, ref dm))
{
dm.dmDisplayFrequency = frequency;
int iRet = ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
Logger.WriteLine("Screen = " + frequency.ToString() + "Hz : " + (iRet == 0 ? "OK" : iRet));
return iRet;
}
return 0;
}
}
}

1376
app/Extra.Designer.cs generated Normal file

File diff suppressed because it is too large Load Diff

591
app/Extra.cs Normal file
View File

@@ -0,0 +1,591 @@
using GHelper.Display;
using GHelper.Gpu.AMD;
using GHelper.Helpers;
using GHelper.Input;
using GHelper.Mode;
using GHelper.UI;
using System.Diagnostics;
namespace GHelper
{
public partial class Extra : RForm
{
ScreenControl screenControl = new ScreenControl();
ClamshellModeControl clamshellControl = new ClamshellModeControl();
const string EMPTY = "--------------";
Dictionary<string, string> customActions = new Dictionary<string, string>
{
{"", EMPTY},
{"mute", Properties.Strings.VolumeMute},
{"screenshot", Properties.Strings.PrintScreen},
{"play", Properties.Strings.PlayPause},
{"aura", Properties.Strings.ToggleAura},
{"performance", Properties.Strings.PerformanceMode},
{"screen", Properties.Strings.ToggleScreen},
{"miniled", Properties.Strings.ToggleMiniled},
{"fnlock", Properties.Strings.ToggleFnLock},
{"brightness_down", Properties.Strings.BrightnessDown},
{"brightness_up", Properties.Strings.BrightnessUp},
{"custom", Properties.Strings.Custom}
};
private void SetKeyCombo(ComboBox combo, TextBox txbox, string name)
{
switch (name)
{
case "m1":
customActions[""] = Properties.Strings.VolumeDown;
break;
case "m2":
customActions[""] = Properties.Strings.VolumeUp;
break;
case "m3":
customActions[""] = Properties.Strings.MuteMic;
break;
case "m4":
customActions[""] = Properties.Strings.OpenGHelper;
break;
case "fnf4":
customActions[""] = Properties.Strings.ToggleAura;
customActions.Remove("aura");
break;
case "fnc":
customActions[""] = Properties.Strings.ToggleFnLock;
customActions.Remove("fnlock");
break;
case "fne":
customActions[""] = "Calculator";
customActions["ghelper"] = Properties.Strings.OpenGHelper;
break;
case "paddle":
customActions[""] = EMPTY;
break;
case "cc":
customActions[""] = EMPTY;
break;
}
combo.DropDownStyle = ComboBoxStyle.DropDownList;
combo.DataSource = new BindingSource(customActions, null);
combo.DisplayMember = "Value";
combo.ValueMember = "Key";
string action = AppConfig.GetString(name);
combo.SelectedValue = (action is not null) ? action : "";
if (combo.SelectedValue is null) combo.SelectedValue = "";
combo.SelectedValueChanged += delegate
{
if (combo.SelectedValue is not null)
AppConfig.Set(name, combo.SelectedValue.ToString());
if (name == "m1" || name == "m2")
Program.inputDispatcher.RegisterKeys();
};
txbox.Text = AppConfig.GetString(name + "_custom");
txbox.TextChanged += delegate
{
AppConfig.Set(name + "_custom", txbox.Text);
};
}
public Extra()
{
InitializeComponent();
labelBindings.Text = Properties.Strings.KeyBindings;
labelBacklightTitle.Text = Properties.Strings.LaptopBacklight;
labelSettings.Text = Properties.Strings.Other;
checkAwake.Text = Properties.Strings.Awake;
checkSleep.Text = Properties.Strings.Sleep;
checkBoot.Text = Properties.Strings.Boot;
checkShutdown.Text = Properties.Strings.Shutdown;
checkBootSound.Text = Properties.Strings.BootSound;
labelSpeed.Text = Properties.Strings.AnimationSpeed;
//labelBrightness.Text = Properties.Strings.Brightness;
labelBacklightTimeout.Text = Properties.Strings.BacklightTimeout;
//labelBacklightTimeoutPlugged.Text = Properties.Strings.BacklightTimeoutPlugged;
checkNoOverdrive.Text = Properties.Strings.DisableOverdrive;
checkTopmost.Text = Properties.Strings.WindowTop;
checkUSBC.Text = Properties.Strings.OptimizedUSBC;
checkAutoToggleClamshellMode.Text = Properties.Strings.ToggleClamshellMode;
labelBacklightKeyboard.Text = Properties.Strings.Keyboard;
labelBacklightBar.Text = Properties.Strings.Lightbar;
labelBacklightLid.Text = Properties.Strings.Lid;
labelBacklightLogo.Text = Properties.Strings.Logo;
checkGpuApps.Text = Properties.Strings.KillGpuApps;
labelHibernateAfter.Text = Properties.Strings.HibernateAfter;
Text = Properties.Strings.ExtraSettings;
if (AppConfig.IsDUO())
{
customActions.Add("screenpad_down", Properties.Strings.ScreenPadDown);
customActions.Add("screenpad_up", Properties.Strings.ScreenPadUp);
}
if (AppConfig.NoMKeys())
{
labelM1.Text = "FN+F2";
labelM2.Text = "FN+F3";
labelM3.Text = "FN+F4";
labelM4.Visible = comboM4.Visible = textM4.Visible = false;
labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
}
if (AppConfig.NoAura())
{
labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
}
if (!AppConfig.IsTUF())
{
labelFNE.Visible = comboFNE.Visible = textFNE.Visible = false;
}
if (Program.acpi.DeviceGet(AsusACPI.GPUEco) < 0)
{
checkGpuApps.Visible = false;
checkUSBC.Visible = false;
}
// Change text and hide irrelevant options on the ROG Ally,
// which is a bit of a special case piece of hardware.
if (AppConfig.IsAlly())
{
labelM1.Visible = comboM1.Visible = textM1.Visible = false;
labelM2.Visible = comboM2.Visible = textM2.Visible = false;
// Re-label M3 and M4 and FNF4 to match the front labels.
labelM3.Text = "Ctrl Center";
labelM4.Text = "ROG";
labelFNF4.Text = "Back Paddles";
// Hide all of the FN options, as the Ally has no special keyboard FN key.
labelFNC.Visible = false;
comboFNC.Visible = false;
textFNC.Visible = false;
SetKeyCombo(comboM3, textM3, "cc");
SetKeyCombo(comboM4, textM4, "m4");
SetKeyCombo(comboFNF4, textFNF4, "paddle");
}
else
{
SetKeyCombo(comboM1, textM1, "m1");
SetKeyCombo(comboM2, textM2, "m2");
SetKeyCombo(comboM3, textM3, "m3");
SetKeyCombo(comboM4, textM4, "m4");
SetKeyCombo(comboFNF4, textFNF4, "fnf4");
SetKeyCombo(comboFNC, textFNC, "fnc");
SetKeyCombo(comboFNE, textFNE, "fne");
}
if (AppConfig.IsStrix())
{
labelM4.Text = "M5/ROG";
}
InitTheme();
Shown += Keyboard_Shown;
comboKeyboardSpeed.DropDownStyle = ComboBoxStyle.DropDownList;
comboKeyboardSpeed.DataSource = new BindingSource(AsusUSB.GetSpeeds(), null);
comboKeyboardSpeed.DisplayMember = "Value";
comboKeyboardSpeed.ValueMember = "Key";
comboKeyboardSpeed.SelectedValue = AsusUSB.Speed;
comboKeyboardSpeed.SelectedValueChanged += ComboKeyboardSpeed_SelectedValueChanged;
// Keyboard
checkAwake.Checked = AppConfig.IsNotFalse("keyboard_awake");
checkBoot.Checked = AppConfig.IsNotFalse("keyboard_boot");
checkSleep.Checked = AppConfig.IsNotFalse("keyboard_sleep");
checkShutdown.Checked = AppConfig.IsNotFalse("keyboard_shutdown");
// Lightbar
checkAwakeBar.Checked = AppConfig.IsNotFalse("keyboard_awake_bar");
checkBootBar.Checked = AppConfig.IsNotFalse("keyboard_boot_bar");
checkSleepBar.Checked = AppConfig.IsNotFalse("keyboard_sleep_bar");
checkShutdownBar.Checked = AppConfig.IsNotFalse("keyboard_shutdown_bar");
// Lid
checkAwakeLid.Checked = AppConfig.IsNotFalse("keyboard_awake_lid");
checkBootLid.Checked = AppConfig.IsNotFalse("keyboard_boot_lid");
checkSleepLid.Checked = AppConfig.IsNotFalse("keyboard_sleep_lid");
checkShutdownLid.Checked = AppConfig.IsNotFalse("keyboard_shutdown_lid");
// Logo
checkAwakeLogo.Checked = AppConfig.IsNotFalse("keyboard_awake_logo");
checkBootLogo.Checked = AppConfig.IsNotFalse("keyboard_boot_logo");
checkSleepLogo.Checked = AppConfig.IsNotFalse("keyboard_sleep_logo");
checkShutdownLogo.Checked = AppConfig.IsNotFalse("keyboard_shutdown_logo");
checkAwake.CheckedChanged += CheckPower_CheckedChanged;
checkBoot.CheckedChanged += CheckPower_CheckedChanged;
checkSleep.CheckedChanged += CheckPower_CheckedChanged;
checkShutdown.CheckedChanged += CheckPower_CheckedChanged;
checkAwakeBar.CheckedChanged += CheckPower_CheckedChanged;
checkBootBar.CheckedChanged += CheckPower_CheckedChanged;
checkSleepBar.CheckedChanged += CheckPower_CheckedChanged;
checkShutdownBar.CheckedChanged += CheckPower_CheckedChanged;
checkAwakeLid.CheckedChanged += CheckPower_CheckedChanged;
checkBootLid.CheckedChanged += CheckPower_CheckedChanged;
checkSleepLid.CheckedChanged += CheckPower_CheckedChanged;
checkShutdownLid.CheckedChanged += CheckPower_CheckedChanged;
checkAwakeLogo.CheckedChanged += CheckPower_CheckedChanged;
checkBootLogo.CheckedChanged += CheckPower_CheckedChanged;
checkSleepLogo.CheckedChanged += CheckPower_CheckedChanged;
checkShutdownLogo.CheckedChanged += CheckPower_CheckedChanged;
if (!AppConfig.IsStrix())
{
labelBacklightBar.Visible = false;
checkAwakeBar.Visible = false;
checkBootBar.Visible = false;
checkSleepBar.Visible = false;
checkShutdownBar.Visible = false;
if (!AppConfig.IsZ13())
{
labelBacklightLid.Visible = false;
checkAwakeLid.Visible = false;
checkBootLid.Visible = false;
checkSleepLid.Visible = false;
checkShutdownLid.Visible = false;
labelBacklightLogo.Visible = false;
checkAwakeLogo.Visible = false;
checkBootLogo.Visible = false;
checkSleepLogo.Visible = false;
checkShutdownLogo.Visible = false;
labelBacklightKeyboard.Visible = false;
}
}
//checkAutoToggleClamshellMode.Visible = clamshellControl.IsExternalDisplayConnected();
checkAutoToggleClamshellMode.Checked = AppConfig.Is("toggle_clamshell_mode");
checkAutoToggleClamshellMode.CheckedChanged += checkAutoToggleClamshellMode_CheckedChanged;
checkTopmost.Checked = AppConfig.Is("topmost");
checkTopmost.CheckedChanged += CheckTopmost_CheckedChanged; ;
checkNoOverdrive.Checked = AppConfig.Is("no_overdrive");
checkNoOverdrive.CheckedChanged += CheckNoOverdrive_CheckedChanged;
checkUSBC.Checked = AppConfig.Is("optimized_usbc");
checkUSBC.CheckedChanged += CheckUSBC_CheckedChanged;
sliderBrightness.Value = InputDispatcher.GetBacklight();
sliderBrightness.ValueChanged += SliderBrightness_ValueChanged;
panelXMG.Visible = (Program.acpi.DeviceGet(AsusACPI.GPUXGConnected) == 1);
checkXMG.Checked = !(AppConfig.Get("xmg_light") == 0);
checkXMG.CheckedChanged += CheckXMG_CheckedChanged;
numericBacklightTime.Value = AppConfig.Get("keyboard_timeout", 60);
numericBacklightPluggedTime.Value = AppConfig.Get("keyboard_ac_timeout", 0);
numericBacklightTime.ValueChanged += NumericBacklightTime_ValueChanged;
numericBacklightPluggedTime.ValueChanged += NumericBacklightTime_ValueChanged;
checkGpuApps.Checked = AppConfig.Is("kill_gpu_apps");
checkGpuApps.CheckedChanged += CheckGpuApps_CheckedChanged;
checkBootSound.Checked = (Program.acpi.DeviceGet(AsusACPI.BootSound) == 1);
checkBootSound.CheckedChanged += CheckBootSound_CheckedChanged;
pictureHelp.Click += PictureHelp_Click;
buttonServices.Click += ButtonServices_Click;
pictureLog.Click += PictureLog_Click;
checkGPUFix.Visible = AppConfig.IsGPUFixNeeded();
checkGPUFix.Checked = AppConfig.IsGPUFix();
checkGPUFix.CheckedChanged += CheckGPUFix_CheckedChanged;
toolTip.SetToolTip(checkAutoToggleClamshellMode, "Disable sleep on lid close when plugged in and external monitor is connected");
InitVariBright();
InitServices();
InitHibernate();
}
private void CheckBootSound_CheckedChanged(object? sender, EventArgs e)
{
Program.acpi.DeviceSet(AsusACPI.BootSound, (checkBootSound.Checked ? 1 : 0), "BootSound");
}
private void CheckGPUFix_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("gpu_fix", (checkGPUFix.Checked ? 1 : 0));
}
private void InitHibernate()
{
try
{
int hibernate = PowerNative.GetHibernateAfter();
if (hibernate < 0 || hibernate > numericHibernateAfter.Maximum) hibernate = 0;
numericHibernateAfter.Value = hibernate;
numericHibernateAfter.ValueChanged += NumericHibernateAfter_ValueChanged;
}
catch (Exception ex)
{
panelPower.Visible = false;
Logger.WriteLine(ex.ToString());
}
}
private void NumericHibernateAfter_ValueChanged(object? sender, EventArgs e)
{
PowerNative.SetHibernateAfter((int)numericHibernateAfter.Value);
}
private void PictureLog_Click(object? sender, EventArgs e)
{
new Process
{
StartInfo = new ProcessStartInfo(Logger.logFile)
{
UseShellExecute = true
}
}.Start();
}
private void SliderBrightness_ValueChanged(object? sender, EventArgs e)
{
bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
if (onBattery)
AppConfig.Set("keyboard_brightness_ac", sliderBrightness.Value);
else
AppConfig.Set("keyboard_brightness", sliderBrightness.Value);
AsusUSB.ApplyBrightness(sliderBrightness.Value, "Slider");
}
private void InitServices()
{
int servicesCount = OptimizationService.GetRunningCount();
if (servicesCount > 0)
{
buttonServices.Text = Properties.Strings.Stop;
labelServices.ForeColor = colorTurbo;
}
else
{
buttonServices.Text = Properties.Strings.Start;
labelServices.ForeColor = colorStandard;
}
labelServices.Text = Properties.Strings.AsusServicesRunning + ": " + servicesCount;
buttonServices.Enabled = true;
}
public void ServiesToggle()
{
buttonServices.Enabled = false;
if (OptimizationService.GetRunningCount() > 0)
{
labelServices.Text = Properties.Strings.StoppingServices + " ...";
Task.Run(() =>
{
OptimizationService.StopAsusServices();
BeginInvoke(delegate
{
InitServices();
});
Program.inputDispatcher.Init();
});
}
else
{
labelServices.Text = Properties.Strings.StartingServices + " ...";
Task.Run(() =>
{
OptimizationService.StartAsusServices();
BeginInvoke(delegate
{
InitServices();
});
});
}
}
private void ButtonServices_Click(object? sender, EventArgs e)
{
if (ProcessHelper.IsUserAdministrator())
ServiesToggle();
else
ProcessHelper.RunAsAdmin("services");
}
private void InitVariBright()
{
try
{
using (var amdControl = new AmdGpuControl())
{
int variBrightSupported = 0, VariBrightEnabled;
if (amdControl.GetVariBright(out variBrightSupported, out VariBrightEnabled))
{
Logger.WriteLine("Varibright: " + variBrightSupported + "," + VariBrightEnabled);
checkVariBright.Checked = (VariBrightEnabled == 3);
}
checkVariBright.Visible = (variBrightSupported > 0);
checkVariBright.CheckedChanged += CheckVariBright_CheckedChanged;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
checkVariBright.Visible = false;
}
}
private void CheckVariBright_CheckedChanged(object? sender, EventArgs e)
{
using (var amdControl = new AmdGpuControl())
{
amdControl.SetVariBright(checkVariBright.Checked ? 1 : 0);
ProcessHelper.KillByName("RadeonSoftware");
}
}
private void CheckGpuApps_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("kill_gpu_apps", (checkGpuApps.Checked ? 1 : 0));
}
private void NumericBacklightTime_ValueChanged(object? sender, EventArgs e)
{
AppConfig.Set("keyboard_timeout", (int)numericBacklightTime.Value);
AppConfig.Set("keyboard_ac_timeout", (int)numericBacklightPluggedTime.Value);
Program.inputDispatcher.InitBacklightTimer();
}
private void CheckXMG_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("xmg_light", (checkXMG.Checked ? 1 : 0));
AsusUSB.ApplyXGMLight(checkXMG.Checked);
}
private void CheckUSBC_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("optimized_usbc", (checkUSBC.Checked ? 1 : 0));
}
private void PictureHelp_Click(object? sender, EventArgs e)
{
Process.Start(new ProcessStartInfo("https://github.com/seerge/g-helper#custom-hotkey-actions") { UseShellExecute = true });
}
private void CheckNoOverdrive_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("no_overdrive", (checkNoOverdrive.Checked ? 1 : 0));
screenControl.AutoScreen(true);
}
private void CheckTopmost_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("topmost", (checkTopmost.Checked ? 1 : 0));
Program.settingsForm.TopMost = checkTopmost.Checked;
}
private void CheckPower_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("keyboard_awake", (checkAwake.Checked ? 1 : 0));
AppConfig.Set("keyboard_boot", (checkBoot.Checked ? 1 : 0));
AppConfig.Set("keyboard_sleep", (checkSleep.Checked ? 1 : 0));
AppConfig.Set("keyboard_shutdown", (checkShutdown.Checked ? 1 : 0));
AppConfig.Set("keyboard_awake_bar", (checkAwakeBar.Checked ? 1 : 0));
AppConfig.Set("keyboard_boot_bar", (checkBootBar.Checked ? 1 : 0));
AppConfig.Set("keyboard_sleep_bar", (checkSleepBar.Checked ? 1 : 0));
AppConfig.Set("keyboard_shutdown_bar", (checkShutdownBar.Checked ? 1 : 0));
AppConfig.Set("keyboard_awake_lid", (checkAwakeLid.Checked ? 1 : 0));
AppConfig.Set("keyboard_boot_lid", (checkBootLid.Checked ? 1 : 0));
AppConfig.Set("keyboard_sleep_lid", (checkSleepLid.Checked ? 1 : 0));
AppConfig.Set("keyboard_shutdown_lid", (checkShutdownLid.Checked ? 1 : 0));
AppConfig.Set("keyboard_awake_logo", (checkAwakeLogo.Checked ? 1 : 0));
AppConfig.Set("keyboard_boot_logo", (checkBootLogo.Checked ? 1 : 0));
AppConfig.Set("keyboard_sleep_logo", (checkSleepLogo.Checked ? 1 : 0));
AppConfig.Set("keyboard_shutdown_logo", (checkShutdownLogo.Checked ? 1 : 0));
AsusUSB.ApplyAuraPower();
}
private void ComboKeyboardSpeed_SelectedValueChanged(object? sender, EventArgs e)
{
AppConfig.Set("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
AsusUSB.ApplyAura();
}
private void Keyboard_Shown(object? sender, EventArgs e)
{
if (Height > Program.settingsForm.Height)
{
Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
}
else
{
Top = Program.settingsForm.Top;
}
Left = Program.settingsForm.Left - Width - 5;
}
private void checkAutoToggleClamshellMode_CheckedChanged(object? sender, EventArgs e)
{
AppConfig.Set("toggle_clamshell_mode", checkAutoToggleClamshellMode.Checked ? 1 : 0);
if (checkAutoToggleClamshellMode.Checked)
{
clamshellControl.ToggleLidAction();
}
else
{
ClamshellModeControl.DisableClamshellMode();
}
}
}
}

123
app/Extra.resx Normal file
View File

@@ -0,0 +1,123 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<metadata name="toolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>17, 17</value>
</metadata>
</root>

185
app/Fan/FanSensorControl.cs Normal file
View File

@@ -0,0 +1,185 @@
using GHelper.Mode;
namespace GHelper.Fan
{
public class FanSensorControl
{
public const int DEFAULT_FAN_MIN = 18;
public const int DEFAULT_FAN_MAX = 58;
public const int XGM_FAN_MAX = 72;
public const int INADEQUATE_MAX = 92;
const int FAN_COUNT = 3;
Fans fansForm;
ModeControl modeControl = Program.modeControl;
static int[] measuredMax;
static int sameCount = 0;
static System.Timers.Timer timer = default!;
static int[] _fanMax = InitFanMax();
static bool _fanRpm = AppConfig.IsNotFalse("fan_rpm");
public FanSensorControl(Fans fansForm)
{
this.fansForm = fansForm;
timer = new System.Timers.Timer(1000);
timer.Elapsed += Timer_Elapsed;
}
static int[] InitFanMax()
{
int[] defaultMax = GetDefaultMax();
return new int[3] {
AppConfig.Get("fan_max_" + (int)AsusFan.CPU, defaultMax[(int)AsusFan.CPU]),
AppConfig.Get("fan_max_" + (int)AsusFan.GPU, defaultMax[(int)AsusFan.GPU]),
AppConfig.Get("fan_max_" + (int)AsusFan.Mid, defaultMax[(int)AsusFan.Mid])
};
}
static int[] GetDefaultMax()
{
if (AppConfig.ContainsModel("GA401I")) return new int[3] { 78, 76, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("GA401")) return new int[3] { 71, 73, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("GA402")) return new int[3] { 55, 56, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("G513R")) return new int[3] { 58, 60, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("G513Q")) return new int[3] { 69, 69, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("GA503")) return new int[3] { 64, 64, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("GU603")) return new int[3] { 62, 64, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("FA507R")) return new int[3] { 63, 57, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("FA507X")) return new int[3] { 63, 68, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("GX650")) return new int[3] { 62, 62, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("G732")) return new int[3] { 61, 60, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("G713")) return new int[3] { 56, 60, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("Z301")) return new int[3] { 72, 64, DEFAULT_FAN_MAX };
if (AppConfig.ContainsModel("GV601")) return new int[3] { 78, 59, 85 };
return new int[3] { DEFAULT_FAN_MAX, DEFAULT_FAN_MAX, DEFAULT_FAN_MAX };
}
public static int GetFanMax(AsusFan device)
{
if (device == AsusFan.XGM) return XGM_FAN_MAX;
if (_fanMax[(int)device] < 0 || _fanMax[(int)device] > INADEQUATE_MAX)
SetFanMax(device, DEFAULT_FAN_MAX);
return _fanMax[(int)device];
}
public static void SetFanMax(AsusFan device, int value)
{
_fanMax[(int)device] = value;
AppConfig.Set("fan_max_" + (int)device, value);
}
public static bool fanRpm
{
get
{
return _fanRpm;
}
set
{
AppConfig.Set("fan_rpm", value ? 1 : 0);
_fanRpm = value;
}
}
public static string FormatFan(AsusFan device, int value)
{
if (value < 0) return null;
if (value > GetFanMax(device) && value <= INADEQUATE_MAX) SetFanMax(device, value);
if (fanRpm)
return Properties.Strings.FanSpeed + ": " + (value * 100).ToString() + "RPM";
else
return Properties.Strings.FanSpeed + ": " + Math.Min(Math.Round((float)value / GetFanMax(device) * 100), 100).ToString() + "%"; // relatively to max RPM
}
public void StartCalibration()
{
measuredMax = new int[] { 0, 0, 0 };
timer.Enabled = true;
for (int i = 0; i < FAN_COUNT; i++)
AppConfig.Remove("fan_max_" + i);
Program.acpi.DeviceSet(AsusACPI.PerformanceMode, AsusACPI.PerformanceTurbo, "ModeCalibration");
for (int i = 0; i < FAN_COUNT; i++)
Program.acpi.SetFanCurve((AsusFan)i, new byte[] { 20, 30, 40, 50, 60, 70, 80, 90, 100, 100, 100, 100, 100, 100, 100, 100 });
}
private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
{
int fan;
bool same = true;
for (int i = 0; i < FAN_COUNT; i++)
{
fan = Program.acpi.GetFan((AsusFan)i);
if (fan > measuredMax[i])
{
measuredMax[i] = fan;
same = false;
}
}
if (same) sameCount++;
else sameCount = 0;
string label = "Measuring Max Speed - CPU: " + measuredMax[(int)AsusFan.CPU] * 100 + ", GPU: " + measuredMax[(int)AsusFan.GPU] * 100;
if (measuredMax[(int)AsusFan.Mid] > 10) label = label + ", Mid: " + measuredMax[(int)AsusFan.Mid] * 100;
label = label + " (" + sameCount + "s)";
fansForm.LabelFansResult(label);
if (sameCount >= 15)
{
for (int i = 0; i < FAN_COUNT; i++)
{
if (measuredMax[i] > 30 && measuredMax[i] < INADEQUATE_MAX) SetFanMax((AsusFan)i, measuredMax[i]);
}
sameCount = 0;
FinishCalibration();
}
}
private void FinishCalibration()
{
timer.Enabled = false;
modeControl.SetPerformanceMode();
string label = "Measured - CPU: " + AppConfig.Get("fan_max_" + (int)AsusFan.CPU) * 100;
if (AppConfig.Get("fan_max_" + (int)AsusFan.GPU) > 0)
label = label + ", GPU: " + AppConfig.Get("fan_max_" + (int)AsusFan.GPU) * 100;
if (AppConfig.Get("fan_max_" + (int)AsusFan.Mid) > 0)
label = label + ", Mid: " + AppConfig.Get("fan_max_" + (int)AsusFan.Mid) * 100;
fansForm.LabelFansResult(label);
fansForm.InitAxis();
}
}
}

1734
app/Fans.Designer.cs generated Normal file

File diff suppressed because it is too large Load Diff

1224
app/Fans.cs Normal file

File diff suppressed because it is too large Load Diff

123
app/Fans.resx Normal file
View File

@@ -0,0 +1,123 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="labelRisky.Text" xml:space="preserve">
<value>Undervolting is experimental and risky feature. If applied values are too low for your hardware, it can become unstable or shut down. Try small negative values first, click Apply and test what works for you.</value>
</data>
</root>

View File

@@ -2,7 +2,7 @@
<PropertyGroup>
<OutputType>WinExe</OutputType>
<TargetFramework>net7.0-windows8.0</TargetFramework>
<TargetFramework>net7.0-windows</TargetFramework>
<Nullable>enable</Nullable>
<UseWindowsForms>True</UseWindowsForms>
<ImplicitUsings>enable</ImplicitUsings>
@@ -11,11 +11,35 @@
<StartupObject>GHelper.Program</StartupObject>
<ApplicationIcon>favicon.ico</ApplicationIcon>
<Platforms>AnyCPU;x64</Platforms>
<SupportedOSPlatformVersion>8.0</SupportedOSPlatformVersion>
<AssemblyName>GHelper</AssemblyName>
<PlatformTarget>AnyCPU</PlatformTarget>
<ProduceReferenceAssembly>False</ProduceReferenceAssembly>
<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
<AssemblyVersion>0.124</AssemblyVersion>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<ItemGroup>
<Compile Remove="screenshots\**" />
<EmbeddedResource Remove="screenshots\**" />
<None Remove="screenshots\**" />
</ItemGroup>
<ItemGroup>
<None Remove="Resources\eco.ico" />
<None Remove="Resources\icons8-charging-battery-48.png" />
@@ -29,24 +53,19 @@
<ItemGroup>
<Content Include="favicon.ico">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
</Content>
</ItemGroup>
<ItemGroup>
<PackageReference Include="FftSharp" Version="2.0.0" />
<PackageReference Include="hidlibrary" Version="3.3.40" />
<PackageReference Include="System.Management" Version="7.0.0" />
<PackageReference Include="HidSharpCore" Version="1.2.1.1" />
<PackageReference Include="NAudio" Version="2.1.0" />
<PackageReference Include="NvAPIWrapper.Net" Version="0.8.1.101" />
<PackageReference Include="System.Management" Version="7.0.1" />
<PackageReference Include="TaskScheduler" Version="2.10.1" />
<PackageReference Include="WinForms.DataVisualization" Version="1.7.0" />
</ItemGroup>
<ItemGroup>
<Reference Include="Microsoft.Management.Infrastructure">
<HintPath>..\..\.nuget\packages\microsoft.management.infrastructure\2.0.0\ref\net451\Microsoft.Management.Infrastructure.dll</HintPath>
</Reference>
<Reference Include="Microsoft.Management.Infrastructure.Native">
<HintPath>..\..\.nuget\packages\microsoft.management.infrastructure.runtime.win\2.0.0\runtimes\win10-x64\lib\netstandard1.6\Microsoft.Management.Infrastructure.Native.dll</HintPath>
</Reference>
<PackageReference Include="WinForms.DataVisualization" Version="1.8.0" />
</ItemGroup>
<ItemGroup>
@@ -76,6 +95,11 @@
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
<Compile Update="Properties\Strings.Designer.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>Strings.resx</DependentUpon>
</Compile>
<Compile Update="Properties\Settings.Designer.cs">
<DesignTimeSharedInput>True</DesignTimeSharedInput>
<AutoGen>True</AutoGen>
@@ -84,6 +108,20 @@
</ItemGroup>
<ItemGroup>
<EmbeddedResource Update="Properties\Resources.uk.resx">
<Generator>ResXFileCodeGenerator</Generator>
</EmbeddedResource>
<EmbeddedResource Update="Properties\Resources.uk.resx">
<Generator>ResXFileCodeGenerator</Generator>
</EmbeddedResource>
<EmbeddedResource Update="Properties\Strings.uk.resx">
<LastGenOutput>Strings.uk.Designer.cs</LastGenOutput>
<Generator>ResXFileCodeGenerator</Generator>
</EmbeddedResource>
<EmbeddedResource Update="Properties\Strings.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Strings.Designer.cs</LastGenOutput>
</EmbeddedResource>
<EmbeddedResource Update="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
@@ -95,10 +133,12 @@
<Generator>SettingsSingleFileGenerator</Generator>
<LastGenOutput>Settings.Designer.cs</LastGenOutput>
</None>
</ItemGroup>
<ItemGroup>
<Folder Include="screenshots\" />
<None Update="WinRing0x64.dll">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</None>
<None Update="WinRing0x64.sys">
<CopyToOutputDirectory>Always</CopyToOutputDirectory>
</None>
</ItemGroup>
</Project>

View File

@@ -18,12 +18,12 @@ Global
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.Build.0 = Debug|Any CPU
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.ActiveCfg = Release|x64
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.Build.0 = Release|x64
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.ActiveCfg = Release|Any CPU
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.Build.0 = Release|Any CPU
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.ActiveCfg = Debug|x64
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|Any CPU.Build.0 = Debug|x64
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.ActiveCfg = Debug|Any CPU
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Debug|x64.Build.0 = Debug|Any CPU
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.ActiveCfg = Release|x64
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|Any CPU.Build.0 = Release|x64
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|x64.ActiveCfg = Release|x64
{D6138BB1-8FDB-4835-87EF-2FE41A3DD604}.Release|x64.Build.0 = Release|x64
EndGlobalSection

599
app/Gpu/AMD/AmdAdl2.cs Normal file
View File

@@ -0,0 +1,599 @@
using System.Diagnostics;
using System.Runtime.InteropServices;
using static GHelper.Gpu.AMD.Adl2.NativeMethods;
namespace GHelper.Gpu.AMD;
#region Export Struct
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ADLSGApplicationInfo
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string strFileName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string strFilePath;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
public string strVersion;
public long timeStamp;
public uint iProfileExists;
public uint iGPUAffinity;
public ADLBdf GPUBdf;
}
[StructLayout(LayoutKind.Sequential)]
public struct ADLBdf
{
public int iBus;
public int iDevice;
public int iFunction;
}
[StructLayout(LayoutKind.Sequential)]
public struct ADLSingleSensorData
{
public int Supported;
public int Value;
}
[StructLayout(LayoutKind.Sequential)]
public struct ADLPMLogDataOutput
{
int Size;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_PMLOG_MAX_SENSORS)]
public ADLSingleSensorData[] Sensors;
}
[StructLayout(LayoutKind.Sequential)]
public struct ADLGcnInfo
{
public int CuCount; //Number of compute units on the ASIC.
public int TexCount; //Number of texture mapping units.
public int RopCount; //Number of Render backend Units.
public int ASICFamilyId; //Such SI, VI. See /inc/asic_reg/atiid.h for family ids
public int ASICRevisionId; //Such as Ellesmere, Fiji. For example - VI family revision ids are stored in /inc/asic_reg/vi_id.h
}
[Flags]
public enum ADLAsicFamilyType
{
Undefined = 0,
Discrete = 1 << 0,
Integrated = 1 << 1,
Workstation = 1 << 2,
FireMV = 1 << 3,
Xgp = 1 << 4,
Fusion = 1 << 5,
Firestream = 1 << 6,
Embedded = 1 << 7,
}
public enum ADLSensorType
{
SENSOR_MAXTYPES = 0,
PMLOG_CLK_GFXCLK = 1, // Current graphic clock value in MHz
PMLOG_CLK_MEMCLK = 2, // Current memory clock value in MHz
PMLOG_CLK_SOCCLK = 3,
PMLOG_CLK_UVDCLK1 = 4,
PMLOG_CLK_UVDCLK2 = 5,
PMLOG_CLK_VCECLK = 6,
PMLOG_CLK_VCNCLK = 7,
PMLOG_TEMPERATURE_EDGE = 8, // Current edge of the die temperature value in C
PMLOG_TEMPERATURE_MEM = 9,
PMLOG_TEMPERATURE_VRVDDC = 10,
PMLOG_TEMPERATURE_VRMVDD = 11,
PMLOG_TEMPERATURE_LIQUID = 12,
PMLOG_TEMPERATURE_PLX = 13,
PMLOG_FAN_RPM = 14, // Current fan RPM value
PMLOG_FAN_PERCENTAGE = 15, // Current ratio of fan RPM and max RPM
PMLOG_SOC_VOLTAGE = 16,
PMLOG_SOC_POWER = 17,
PMLOG_SOC_CURRENT = 18,
PMLOG_INFO_ACTIVITY_GFX = 19, // Current graphic activity level in percentage
PMLOG_INFO_ACTIVITY_MEM = 20, // Current memory activity level in percentage
PMLOG_GFX_VOLTAGE = 21, // Current graphic voltage in mV
PMLOG_MEM_VOLTAGE = 22,
PMLOG_ASIC_POWER = 23, // Current ASIC power draw in Watt
PMLOG_TEMPERATURE_VRSOC = 24,
PMLOG_TEMPERATURE_VRMVDD0 = 25,
PMLOG_TEMPERATURE_VRMVDD1 = 26,
PMLOG_TEMPERATURE_HOTSPOT = 27, // Current center of the die temperature value in C
PMLOG_TEMPERATURE_GFX = 28,
PMLOG_TEMPERATURE_SOC = 29,
PMLOG_GFX_POWER = 30,
PMLOG_GFX_CURRENT = 31,
PMLOG_TEMPERATURE_CPU = 32,
PMLOG_CPU_POWER = 33,
PMLOG_CLK_CPUCLK = 34,
PMLOG_THROTTLER_STATUS = 35, // A bit map of GPU throttle information. If a bit is set, the bit represented type of thorttling occurred in the last metrics sampling period
PMLOG_CLK_VCN1CLK1 = 36,
PMLOG_CLK_VCN1CLK2 = 37,
PMLOG_SMART_POWERSHIFT_CPU = 38,
PMLOG_SMART_POWERSHIFT_DGPU = 39,
PMLOG_BUS_SPEED = 40, // Current PCIE bus speed running
PMLOG_BUS_LANES = 41, // Current PCIE bus lanes using
PMLOG_TEMPERATURE_LIQUID0 = 42,
PMLOG_TEMPERATURE_LIQUID1 = 43,
PMLOG_CLK_FCLK = 44,
PMLOG_THROTTLER_STATUS_CPU = 45,
PMLOG_SSPAIRED_ASICPOWER = 46, // apuPower
PMLOG_SSTOTAL_POWERLIMIT = 47, // Total Power limit
PMLOG_SSAPU_POWERLIMIT = 48, // APU Power limit
PMLOG_SSDGPU_POWERLIMIT = 49, // DGPU Power limit
PMLOG_TEMPERATURE_HOTSPOT_GCD = 50,
PMLOG_TEMPERATURE_HOTSPOT_MCD = 51,
PMLOG_THROTTLER_TEMP_EDGE_PERCENTAGE = 52,
PMLOG_THROTTLER_TEMP_HOTSPOT_PERCENTAGE = 53,
PMLOG_THROTTLER_TEMP_HOTSPOT_GCD_PERCENTAGE = 54,
PMLOG_THROTTLER_TEMP_HOTSPOT_MCD_PERCENTAGE = 55,
PMLOG_THROTTLER_TEMP_MEM_PERCENTAGE = 56,
PMLOG_THROTTLER_TEMP_VR_GFX_PERCENTAGE = 57,
PMLOG_THROTTLER_TEMP_VR_MEM0_PERCENTAGE = 58,
PMLOG_THROTTLER_TEMP_VR_MEM1_PERCENTAGE = 59,
PMLOG_THROTTLER_TEMP_VR_SOC_PERCENTAGE = 60,
PMLOG_THROTTLER_TEMP_LIQUID0_PERCENTAGE = 61,
PMLOG_THROTTLER_TEMP_LIQUID1_PERCENTAGE = 62,
PMLOG_THROTTLER_TEMP_PLX_PERCENTAGE = 63,
PMLOG_THROTTLER_TDC_GFX_PERCENTAGE = 64,
PMLOG_THROTTLER_TDC_SOC_PERCENTAGE = 65,
PMLOG_THROTTLER_TDC_USR_PERCENTAGE = 66,
PMLOG_THROTTLER_PPT0_PERCENTAGE = 67,
PMLOG_THROTTLER_PPT1_PERCENTAGE = 68,
PMLOG_THROTTLER_PPT2_PERCENTAGE = 69,
PMLOG_THROTTLER_PPT3_PERCENTAGE = 70,
PMLOG_THROTTLER_FIT_PERCENTAGE = 71,
PMLOG_THROTTLER_GFX_APCC_PLUS_PERCENTAGE = 72,
PMLOG_BOARD_POWER = 73,
PMLOG_MAX_SENSORS_REAL
};
//Throttle Status
[Flags]
public enum ADL_THROTTLE_NOTIFICATION
{
ADL_PMLOG_THROTTLE_POWER = 1 << 0,
ADL_PMLOG_THROTTLE_THERMAL = 1 << 1,
ADL_PMLOG_THROTTLE_CURRENT = 1 << 2,
};
public enum ADL_PMLOG_SENSORS
{
ADL_SENSOR_MAXTYPES = 0,
ADL_PMLOG_CLK_GFXCLK = 1,
ADL_PMLOG_CLK_MEMCLK = 2,
ADL_PMLOG_CLK_SOCCLK = 3,
ADL_PMLOG_CLK_UVDCLK1 = 4,
ADL_PMLOG_CLK_UVDCLK2 = 5,
ADL_PMLOG_CLK_VCECLK = 6,
ADL_PMLOG_CLK_VCNCLK = 7,
ADL_PMLOG_TEMPERATURE_EDGE = 8,
ADL_PMLOG_TEMPERATURE_MEM = 9,
ADL_PMLOG_TEMPERATURE_VRVDDC = 10,
ADL_PMLOG_TEMPERATURE_VRMVDD = 11,
ADL_PMLOG_TEMPERATURE_LIQUID = 12,
ADL_PMLOG_TEMPERATURE_PLX = 13,
ADL_PMLOG_FAN_RPM = 14,
ADL_PMLOG_FAN_PERCENTAGE = 15,
ADL_PMLOG_SOC_VOLTAGE = 16,
ADL_PMLOG_SOC_POWER = 17,
ADL_PMLOG_SOC_CURRENT = 18,
ADL_PMLOG_INFO_ACTIVITY_GFX = 19,
ADL_PMLOG_INFO_ACTIVITY_MEM = 20,
ADL_PMLOG_GFX_VOLTAGE = 21,
ADL_PMLOG_MEM_VOLTAGE = 22,
ADL_PMLOG_ASIC_POWER = 23,
ADL_PMLOG_TEMPERATURE_VRSOC = 24,
ADL_PMLOG_TEMPERATURE_VRMVDD0 = 25,
ADL_PMLOG_TEMPERATURE_VRMVDD1 = 26,
ADL_PMLOG_TEMPERATURE_HOTSPOT = 27,
ADL_PMLOG_TEMPERATURE_GFX = 28,
ADL_PMLOG_TEMPERATURE_SOC = 29,
ADL_PMLOG_GFX_POWER = 30,
ADL_PMLOG_GFX_CURRENT = 31,
ADL_PMLOG_TEMPERATURE_CPU = 32,
ADL_PMLOG_CPU_POWER = 33,
ADL_PMLOG_CLK_CPUCLK = 34,
ADL_PMLOG_THROTTLER_STATUS = 35, // GFX
ADL_PMLOG_CLK_VCN1CLK1 = 36,
ADL_PMLOG_CLK_VCN1CLK2 = 37,
ADL_PMLOG_SMART_POWERSHIFT_CPU = 38,
ADL_PMLOG_SMART_POWERSHIFT_DGPU = 39,
ADL_PMLOG_BUS_SPEED = 40,
ADL_PMLOG_BUS_LANES = 41,
ADL_PMLOG_TEMPERATURE_LIQUID0 = 42,
ADL_PMLOG_TEMPERATURE_LIQUID1 = 43,
ADL_PMLOG_CLK_FCLK = 44,
ADL_PMLOG_THROTTLER_STATUS_CPU = 45,
ADL_PMLOG_SSPAIRED_ASICPOWER = 46, // apuPower
ADL_PMLOG_SSTOTAL_POWERLIMIT = 47, // Total Power limit
ADL_PMLOG_SSAPU_POWERLIMIT = 48, // APU Power limit
ADL_PMLOG_SSDGPU_POWERLIMIT = 49, // DGPU Power limit
ADL_PMLOG_TEMPERATURE_HOTSPOT_GCD = 50,
ADL_PMLOG_TEMPERATURE_HOTSPOT_MCD = 51,
ADL_PMLOG_THROTTLER_TEMP_EDGE_PERCENTAGE = 52,
ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_PERCENTAGE = 53,
ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_GCD_PERCENTAGE = 54,
ADL_PMLOG_THROTTLER_TEMP_HOTSPOT_MCD_PERCENTAGE = 55,
ADL_PMLOG_THROTTLER_TEMP_MEM_PERCENTAGE = 56,
ADL_PMLOG_THROTTLER_TEMP_VR_GFX_PERCENTAGE = 57,
ADL_PMLOG_THROTTLER_TEMP_VR_MEM0_PERCENTAGE = 58,
ADL_PMLOG_THROTTLER_TEMP_VR_MEM1_PERCENTAGE = 59,
ADL_PMLOG_THROTTLER_TEMP_VR_SOC_PERCENTAGE = 60,
ADL_PMLOG_THROTTLER_TEMP_LIQUID0_PERCENTAGE = 61,
ADL_PMLOG_THROTTLER_TEMP_LIQUID1_PERCENTAGE = 62,
ADL_PMLOG_THROTTLER_TEMP_PLX_PERCENTAGE = 63,
ADL_PMLOG_THROTTLER_TDC_GFX_PERCENTAGE = 64,
ADL_PMLOG_THROTTLER_TDC_SOC_PERCENTAGE = 65,
ADL_PMLOG_THROTTLER_TDC_USR_PERCENTAGE = 66,
ADL_PMLOG_THROTTLER_PPT0_PERCENTAGE = 67,
ADL_PMLOG_THROTTLER_PPT1_PERCENTAGE = 68,
ADL_PMLOG_THROTTLER_PPT2_PERCENTAGE = 69,
ADL_PMLOG_THROTTLER_PPT3_PERCENTAGE = 70,
ADL_PMLOG_THROTTLER_FIT_PERCENTAGE = 71,
ADL_PMLOG_THROTTLER_GFX_APCC_PLUS_PERCENTAGE = 72,
ADL_PMLOG_BOARD_POWER = 73,
ADL_PMLOG_MAX_SENSORS_REAL
}
#region ADLAdapterInfo
/// <summary> ADLAdapterInfo Structure</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLAdapterInfo
{
/// <summary>The size of the structure</summary>
int Size;
/// <summary> Adapter Index</summary>
public int AdapterIndex;
/// <summary> Adapter UDID</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string UDID;
/// <summary> Adapter Bus Number</summary>
public int BusNumber;
/// <summary> Adapter Driver Number</summary>
public int DriverNumber;
/// <summary> Adapter Function Number</summary>
public int FunctionNumber;
/// <summary> Adapter Vendor ID</summary>
public int VendorID;
/// <summary> Adapter Adapter name</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string AdapterName;
/// <summary> Adapter Display name</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string DisplayName;
/// <summary> Adapter Present status</summary>
public int Present;
/// <summary> Adapter Exist status</summary>
public int Exist;
/// <summary> Adapter Driver Path</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string DriverPath;
/// <summary> Adapter Driver Ext Path</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string DriverPathExt;
/// <summary> Adapter PNP String</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string PNPString;
/// <summary> OS Display Index</summary>
public int OSDisplayIndex;
}
/// <summary> ADLAdapterInfo Array</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLAdapterInfoArray
{
/// <summary> ADLAdapterInfo Array </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = Adl2.ADL_MAX_ADAPTERS)]
public ADLAdapterInfo[] ADLAdapterInfo;
}
#endregion ADLAdapterInfo
#region ADLDisplayInfo
/// <summary> ADLDisplayID Structure</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLDisplayID
{
/// <summary> Display Logical Index </summary>
public int DisplayLogicalIndex;
/// <summary> Display Physical Index </summary>
public int DisplayPhysicalIndex;
/// <summary> Adapter Logical Index </summary>
public int DisplayLogicalAdapterIndex;
/// <summary> Adapter Physical Index </summary>
public int DisplayPhysicalAdapterIndex;
}
/// <summary> ADLDisplayInfo Structure</summary>
[StructLayout(LayoutKind.Sequential)]
public struct ADLDisplayInfo
{
/// <summary> Display Index </summary>
public ADLDisplayID DisplayID;
/// <summary> Display Controller Index </summary>
public int DisplayControllerIndex;
/// <summary> Display Name </summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string DisplayName;
/// <summary> Display Manufacturer Name </summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = Adl2.ADL_MAX_PATH)]
public string DisplayManufacturerName;
/// <summary> Display Type : < The Display type. CRT, TV,CV,DFP are some of display types,</summary>
public int DisplayType;
/// <summary> Display output type </summary>
public int DisplayOutputType;
/// <summary> Connector type</summary>
public int DisplayConnector;
///<summary> Indicating the display info bits' mask.<summary>
public int DisplayInfoMask;
///<summary> Indicating the display info value.<summary>
public int DisplayInfoValue;
}
#endregion ADLDisplayInfo
#endregion Export Struct
public class Adl2
{
public const string Atiadlxx_FileName = "atiadlxx.dll";
#region Internal Constant
/// <summary> Define the maximum path</summary>
public const int ADL_MAX_PATH = 256;
/// <summary> Define the maximum adapters</summary>
public const int ADL_MAX_ADAPTERS = 40 /* 150 */;
/// <summary> Define the maximum displays</summary>
public const int ADL_MAX_DISPLAYS = 40 /* 150 */;
/// <summary> Define the maximum device name length</summary>
public const int ADL_MAX_DEVICENAME = 32;
/// <summary> Define the successful</summary>
public const int ADL_SUCCESS = 0;
/// <summary> Define the failure</summary>
public const int ADL_FAIL = -1;
/// <summary> Define the driver ok</summary>
public const int ADL_DRIVER_OK = 0;
/// <summary> Maximum number of GL-Sync ports on the GL-Sync module </summary>
public const int ADL_MAX_GLSYNC_PORTS = 8;
/// <summary> Maximum number of GL-Sync ports on the GL-Sync module </summary>
public const int ADL_MAX_GLSYNC_PORT_LEDS = 8;
/// <summary> Maximum number of ADLMOdes for the adapter </summary>
public const int ADL_MAX_NUM_DISPLAYMODES = 1024;
/// <summary> Performance Metrics Log max sensors number </summary>
public const int ADL_PMLOG_MAX_SENSORS = 256;
#endregion Internal Constant
// ///// <summary> ADL Create Function to create ADL Data</summary>
/// <param name="enumConnectedAdapters">If it is 1, then ADL will only return the physical exist adapters </param>
///// <returns> retrun ADL Error Code</returns>
public static int ADL2_Main_Control_Create(int enumConnectedAdapters, out nint adlContextHandle)
{
return NativeMethods.ADL2_Main_Control_Create(ADL_Main_Memory_Alloc_Impl_Reference, enumConnectedAdapters, out adlContextHandle);
}
public static void FreeMemory(nint buffer)
{
Memory_Free_Impl(buffer);
}
private static bool? isDllLoaded;
public static bool Load()
{
if (isDllLoaded != null)
return isDllLoaded.Value;
try
{
Marshal.PrelinkAll(typeof(Adl2));
isDllLoaded = true;
}
catch (Exception e) when (e is DllNotFoundException or EntryPointNotFoundException)
{
Debug.WriteLine(e);
isDllLoaded = false;
}
return isDllLoaded.Value;
}
private static ADL_Main_Memory_Alloc ADL_Main_Memory_Alloc_Impl_Reference = Memory_Alloc_Impl;
/// <summary> Build in memory allocation function</summary>
/// <param name="size">input size</param>
/// <returns>return the memory buffer</returns>
private static nint Memory_Alloc_Impl(int size)
{
return Marshal.AllocCoTaskMem(size);
}
/// <summary> Build in memory free function</summary>
/// <param name="buffer">input buffer</param>
private static void Memory_Free_Impl(nint buffer)
{
if (nint.Zero != buffer)
{
Marshal.FreeCoTaskMem(buffer);
}
}
public static class NativeMethods
{
/// <summary> ADL Memory allocation function allows ADL to callback for memory allocation</summary>
/// <param name="size">input size</param>
/// <returns> retrun ADL Error Code</returns>
public delegate nint ADL_Main_Memory_Alloc(int size);
// ///// <summary> ADL Create Function to create ADL Data</summary>
/// <param name="callback">Call back functin pointer which is ised to allocate memeory </param>
/// <param name="enumConnectedAdapters">If it is 1, then ADL will only retuen the physical exist adapters </param>
///// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Main_Control_Create(ADL_Main_Memory_Alloc callback, int enumConnectedAdapters, out nint adlContextHandle);
/// <summary> ADL Destroy Function to free up ADL Data</summary>
/// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Main_Control_Destroy(nint adlContextHandle);
/// <summary> ADL Function to get the number of adapters</summary>
/// <param name="numAdapters">return number of adapters</param>
/// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_NumberOfAdapters_Get(nint adlContextHandle, out int numAdapters);
/// <summary> ADL Function to get the GPU adapter information</summary>
/// <param name="info">return GPU adapter information</param>
/// <param name="inputSize">the size of the GPU adapter struct</param>
/// <returns> retrun ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_AdapterInfo_Get(nint adlContextHandle, nint info, int inputSize);
/// <summary> Function to determine if the adapter is active or not.</summary>
/// <remarks>The function is used to check if the adapter associated with iAdapterIndex is active</remarks>
/// <param name="adapterIndex"> Adapter Index.</param>
/// <param name="status"> Status of the adapter. True: Active; False: Dsiabled</param>
/// <returns>Non zero is successfull</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_Active_Get(nint adlContextHandle, int adapterIndex, out int status);
/// <summary>Get display information based on adapter index</summary>
/// <param name="adapterIndex">Adapter Index</param>
/// <param name="numDisplays">return the total number of supported displays</param>
/// <param name="displayInfoArray">return ADLDisplayInfo Array for supported displays' information</param>
/// <param name="forceDetect">force detect or not</param>
/// <returns>return ADL Error Code</returns>
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Display_DisplayInfo_Get(
nint adlContextHandle,
int adapterIndex,
out int numDisplays,
out nint displayInfoArray,
int forceDetect
);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Overdrive_Caps(
nint adlContextHandle,
int adapterIndex,
out int supported,
out int enabled,
out int version
);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_New_QueryPMLogData_Get(nint adlContextHandle, int adapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_ASICFamilyType_Get(nint adlContextHandle, int adapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_SwitchableGraphics_Applications_Get(
nint context,
int iListType,
out int lpNumApps,
out nint lppAppList);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_VariBright_Caps(
nint context,
int iAdapterIndex,
out int iSupported,
out int iEnabled,
out int iVersion);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_Adapter_VariBrightEnable_Set(
nint context,
int iAdapterIndex,
int iEnabled);
// Clocks
[StructLayout(LayoutKind.Sequential)]
public struct ADLODNPerformanceLevel
{
public int iClock;
public int iVddc;
public int iEnabled;
}
[StructLayout(LayoutKind.Sequential)]
public struct ADLODNPerformanceLevels
{
public int iSize;
public int iMode;
public int iNumberOfPerformanceLevels;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public ADLODNPerformanceLevel[] aLevels;
}
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_SystemClocks_Get(
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_SystemClocks_Set(
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_MemoryClocks_Get(
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
[DllImport(Atiadlxx_FileName)]
public static extern int ADL2_OverdriveN_MemoryClocks_Set(
nint context,
int adapterIndex,
ref ADLODNPerformanceLevels performanceLevels);
}
}

View File

@@ -0,0 +1,234 @@
using GHelper.Helpers;
using System.Runtime.InteropServices;
using static GHelper.Gpu.AMD.Adl2.NativeMethods;
namespace GHelper.Gpu.AMD;
// Reference: https://github.com/GPUOpen-LibrariesAndSDKs/display-library/blob/master/Sample-Managed/Program.cs
public class AmdGpuControl : IGpuControl
{
private bool _isReady;
private nint _adlContextHandle;
private readonly ADLAdapterInfo _internalDiscreteAdapter;
public bool IsNvidia => false;
public string FullName => _internalDiscreteAdapter!.AdapterName;
private ADLAdapterInfo? FindByType(ADLAsicFamilyType type = ADLAsicFamilyType.Discrete)
{
ADL2_Adapter_NumberOfAdapters_Get(_adlContextHandle, out int numberOfAdapters);
if (numberOfAdapters <= 0)
return null;
ADLAdapterInfoArray osAdapterInfoData = new();
int osAdapterInfoDataSize = Marshal.SizeOf(osAdapterInfoData);
nint AdapterBuffer = Marshal.AllocCoTaskMem(osAdapterInfoDataSize);
Marshal.StructureToPtr(osAdapterInfoData, AdapterBuffer, false);
if (ADL2_Adapter_AdapterInfo_Get(_adlContextHandle, AdapterBuffer, osAdapterInfoDataSize) != Adl2.ADL_SUCCESS)
return null;
osAdapterInfoData = (ADLAdapterInfoArray)Marshal.PtrToStructure(AdapterBuffer, osAdapterInfoData.GetType())!;
const int amdVendorId = 1002;
// Determine which GPU is internal discrete AMD GPU
ADLAdapterInfo internalDiscreteAdapter =
osAdapterInfoData.ADLAdapterInfo
.FirstOrDefault(adapter =>
{
if (adapter.Exist == 0 || adapter.Present == 0)
return false;
if (adapter.VendorID != amdVendorId)
return false;
if (ADL2_Adapter_ASICFamilyType_Get(_adlContextHandle, adapter.AdapterIndex, out ADLAsicFamilyType asicFamilyType, out int asicFamilyTypeValids) != Adl2.ADL_SUCCESS)
return false;
asicFamilyType = (ADLAsicFamilyType)((int)asicFamilyType & asicFamilyTypeValids);
return (asicFamilyType & type) != 0;
});
if (internalDiscreteAdapter.Exist == 0)
return null;
return internalDiscreteAdapter;
}
public AmdGpuControl()
{
if (!Adl2.Load())
return;
if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS)
return;
ADLAdapterInfo? internalDiscreteAdapter = FindByType(ADLAsicFamilyType.Discrete);
if (internalDiscreteAdapter is not null)
{
_internalDiscreteAdapter = (ADLAdapterInfo)internalDiscreteAdapter;
_isReady = true;
}
}
public bool IsValid => _isReady && _adlContextHandle != nint.Zero;
public int? GetCurrentTemperature()
{
if (!IsValid)
return null;
if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
return null;
ADLSingleSensorData temperatureSensor = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_TEMPERATURE_EDGE];
if (temperatureSensor.Supported == 0)
return null;
return temperatureSensor.Value;
}
public int? GetGpuUse()
{
if (!IsValid) return null;
if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS)
return null;
ADLSingleSensorData gpuUsage = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_INFO_ACTIVITY_GFX];
if (gpuUsage.Supported == 0)
return null;
return gpuUsage.Value;
}
public bool SetVariBright(int enabled)
{
if (_adlContextHandle == nint.Zero) return false;
ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
if (iGPU is null) return false;
return ADL2_Adapter_VariBrightEnable_Set(_adlContextHandle, ((ADLAdapterInfo)iGPU).AdapterIndex, enabled) == Adl2.ADL_SUCCESS;
}
public bool GetVariBright(out int supported, out int enabled)
{
supported = enabled = -1;
if (_adlContextHandle == nint.Zero) return false;
ADLAdapterInfo? iGPU = FindByType(ADLAsicFamilyType.Integrated);
if (iGPU is null) return false;
if (ADL2_Adapter_VariBright_Caps(_adlContextHandle, ((ADLAdapterInfo)iGPU).AdapterIndex, out int supportedOut, out int enabledOut, out int version) != Adl2.ADL_SUCCESS)
return false;
supported = supportedOut;
enabled = enabledOut;
return true;
}
public ADLODNPerformanceLevels? GetGPUClocks()
{
if (!IsValid) return null;
ADLODNPerformanceLevels performanceLevels = new();
ADL2_OverdriveN_SystemClocks_Get(_adlContextHandle, _internalDiscreteAdapter.AdapterIndex, ref performanceLevels);
return performanceLevels;
}
public void KillGPUApps()
{
if (!IsValid) return;
nint appInfoPtr = nint.Zero;
int appCount = 0;
try
{
// Get switchable graphics applications information
var result = ADL2_SwitchableGraphics_Applications_Get(_adlContextHandle, 2, out appCount, out appInfoPtr);
if (result != 0)
{
throw new Exception("Failed to get switchable graphics applications. Error code: " + result);
}
// Convert the application data pointers to an array of structs
var appInfoArray = new ADLSGApplicationInfo[appCount];
nint currentPtr = appInfoPtr;
for (int i = 0; i < appCount; i++)
{
appInfoArray[i] = Marshal.PtrToStructure<ADLSGApplicationInfo>(currentPtr);
currentPtr = nint.Add(currentPtr, Marshal.SizeOf<ADLSGApplicationInfo>());
}
var appNames = new List<string>();
for (int i = 0; i < appCount; i++)
{
if (appInfoArray[i].iGPUAffinity == 1)
{
Logger.WriteLine(appInfoArray[i].strFileName + ":" + appInfoArray[i].iGPUAffinity + "(" + appInfoArray[i].timeStamp + ")");
appNames.Add(Path.GetFileNameWithoutExtension(appInfoArray[i].strFileName));
}
}
List<string> immune = new() { "svchost", "system", "ntoskrnl", "csrss", "winlogon", "wininit", "smss" };
foreach (string kill in appNames)
if (!immune.Contains(kill.ToLower()))
ProcessHelper.KillByName(kill);
}
catch (Exception ex)
{
Logger.WriteLine(ex.Message);
}
finally
{
// Clean up resources
if (appInfoPtr != nint.Zero)
{
Marshal.FreeCoTaskMem(appInfoPtr);
}
}
}
private void ReleaseUnmanagedResources()
{
if (_adlContextHandle != nint.Zero)
{
ADL2_Main_Control_Destroy(_adlContextHandle);
_adlContextHandle = nint.Zero;
_isReady = false;
}
}
public void Dispose()
{
ReleaseUnmanagedResources();
GC.SuppressFinalize(this);
}
~AmdGpuControl()
{
ReleaseUnmanagedResources();
}
}

359
app/Gpu/GPUModeControl.cs Normal file
View File

@@ -0,0 +1,359 @@
using GHelper.Display;
using GHelper.Gpu.NVidia;
using GHelper.Helpers;
using System.Diagnostics;
namespace GHelper.Gpu
{
public class GPUModeControl
{
SettingsForm settings;
ScreenControl screenControl = new ScreenControl();
public static int gpuMode;
public static bool? gpuExists = null;
public GPUModeControl(SettingsForm settingsForm)
{
settings = settingsForm;
}
public void InitGPUMode()
{
int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
if (mux < 0) mux = Program.acpi.DeviceGet(AsusACPI.GPUMuxVivo);
Logger.WriteLine("Eco flag : " + eco);
Logger.WriteLine("Mux flag : " + mux);
settings.VisualiseGPUButtons(eco >= 0, mux >= 0);
if (mux == 0)
{
gpuMode = AsusACPI.GPUModeUltimate;
}
else
{
if (eco == 1)
gpuMode = AsusACPI.GPUModeEco;
else
gpuMode = AsusACPI.GPUModeStandard;
// GPU mode not supported
if (eco < 0 && mux < 0)
{
if (gpuExists is null) gpuExists = Program.acpi.GetFan(AsusFan.GPU) >= 0;
settings.HideGPUModes((bool)gpuExists);
}
}
AppConfig.Set("gpu_mode", gpuMode);
settings.VisualiseGPUMode(gpuMode);
AsusUSB.ApplyGPUColor();
}
public void SetGPUMode(int GPUMode, int auto = 0)
{
int CurrentGPU = AppConfig.Get("gpu_mode");
AppConfig.Set("gpu_auto", auto);
if (CurrentGPU == GPUMode)
{
settings.VisualiseGPUMode();
return;
}
var restart = false;
var changed = false;
int status;
if (CurrentGPU == AsusACPI.GPUModeUltimate)
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOff, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
status = Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
if (status != 1) Program.acpi.DeviceSet(AsusACPI.GPUMuxVivo, 1, "GPUMuxVivo");
restart = true;
changed = true;
}
}
else if (GPUMode == AsusACPI.GPUModeUltimate)
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOn, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
if (AppConfig.NoAutoUltimate())
{
Program.acpi.SetGPUEco(0);
Thread.Sleep(100);
}
status = Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
if (status != 1) Program.acpi.DeviceSet(AsusACPI.GPUMuxVivo, 0, "GPUMuxVivo");
restart = true;
changed = true;
}
}
else if (GPUMode == AsusACPI.GPUModeEco)
{
settings.VisualiseGPUMode(GPUMode);
SetGPUEco(1, true);
changed = true;
}
else if (GPUMode == AsusACPI.GPUModeStandard)
{
settings.VisualiseGPUMode(GPUMode);
SetGPUEco(0);
changed = true;
}
if (changed)
{
AppConfig.Set("gpu_mode", GPUMode);
}
if (restart)
{
settings.VisualiseGPUMode();
Process.Start("shutdown", "/r /t 1");
}
}
public void SetGPUEco(int eco, bool hardWay = false)
{
settings.LockGPUModes();
Task.Run(async () =>
{
int status = 1;
if (eco == 1)
{
/*
if (NvidiaSmi.GetDisplayActiveStatus())
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.EnableOptimusText, Properties.Strings.EnableOptimusTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.No)
{
InitGPUMode();
return;
}
}
*/
HardwareControl.KillGPUApps();
}
Logger.WriteLine($"Running eco command {eco}");
status = Program.acpi.SetGPUEco(eco);
if (status == 0 && eco == 1 && hardWay) RestartGPU();
await Task.Delay(TimeSpan.FromMilliseconds(100));
settings.Invoke(delegate
{
InitGPUMode();
screenControl.AutoScreen();
});
if (eco == 0)
{
await Task.Delay(TimeSpan.FromMilliseconds(3000));
HardwareControl.RecreateGpuControl();
Program.modeControl.SetGPUClocks(false);
}
});
}
public static bool IsPlugged()
{
if (SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online) return false;
if (!AppConfig.Is("optimized_usbc")) return true;
int chargerMode = Program.acpi.DeviceGet(AsusACPI.ChargerMode);
Logger.WriteLine("ChargerStatus: " + chargerMode);
if (chargerMode < 0) return true;
return (chargerMode & AsusACPI.ChargerBarrel) > 0;
}
public bool AutoGPUMode(bool optimized = false)
{
bool GpuAuto = AppConfig.Is("gpu_auto");
bool ForceGPU = AppConfig.IsForceSetGPUMode();
int GpuMode = AppConfig.Get("gpu_mode");
if (!GpuAuto && !ForceGPU) return false;
int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
if (mux == 0)
{
if (optimized) SetGPUMode(AsusACPI.GPUModeStandard, 1);
return false;
}
else
{
if (eco == 1)
if ((GpuAuto && IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeStandard))
{
SetGPUEco(0);
return true;
}
if (eco == 0)
if ((GpuAuto && !IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeEco))
{
if (HardwareControl.IsUsedGPU())
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertDGPU, Properties.Strings.AlertDGPUTitle, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.No) return false;
}
SetGPUEco(1);
return true;
}
}
return false;
}
public void RestartGPU(bool confirm = true)
{
if (HardwareControl.GpuControl is null) return;
if (!HardwareControl.GpuControl!.IsNvidia) return;
if (confirm)
{
DialogResult dialogResult = MessageBox.Show(Properties.Strings.RestartGPU, Properties.Strings.EcoMode, MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.No) return;
}
ProcessHelper.RunAsAdmin("gpurestart");
if (!ProcessHelper.IsUserAdministrator()) return;
Logger.WriteLine("Trying to restart dGPU");
Task.Run(async () =>
{
settings.LockGPUModes("Restarting GPU ...");
var nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
bool status = nvControl.RestartGPU();
settings.Invoke(delegate
{
//labelTipGPU.Text = status ? "GPU Restarted, you can try Eco mode again" : "Failed to restart GPU"; TODO
InitGPUMode();
});
});
}
public void InitXGM()
{
if (Program.acpi.IsXGConnected())
{
//Program.acpi.DeviceSet(AsusACPI.GPUXGInit, 1, "XG Init");
AsusUSB.InitXGM();
}
}
public void ToggleXGM()
{
Task.Run(async () =>
{
settings.LockGPUModes();
if (Program.acpi.DeviceGet(AsusACPI.GPUXG) == 1)
{
AsusUSB.ResetXGM();
HardwareControl.KillGPUApps();
DialogResult dialogResult = MessageBox.Show("Did you close all applications running on XG Mobile?", "Disabling XG Mobile", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
Program.acpi.DeviceSet(AsusACPI.GPUXG, 0, "GPU XGM");
await Task.Delay(TimeSpan.FromSeconds(15));
}
}
else
{
if (AppConfig.Is("xgm_special"))
Program.acpi.DeviceSet(AsusACPI.GPUXG, 0x101, "GPU XGM");
else
Program.acpi.DeviceSet(AsusACPI.GPUXG, 1, "GPU XGM");
InitXGM();
AsusUSB.ApplyXGMLight(AppConfig.Is("xmg_light"));
await Task.Delay(TimeSpan.FromSeconds(15));
if (AppConfig.IsMode("auto_apply"))
AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
HardwareControl.RecreateGpuControl();
}
settings.Invoke(delegate
{
InitGPUMode();
});
});
}
public void KillGPUApps()
{
if (HardwareControl.GpuControl is not null)
{
HardwareControl.GpuControl.KillGPUApps();
}
}
// Manually forcing standard mode on shutdown/hibernate for some exotic cases
// https://github.com/seerge/g-helper/pull/855
public void StandardModeFix()
{
if (!AppConfig.IsGPUFix()) return; // No config entry
if (Program.acpi.DeviceGet(AsusACPI.GPUMux) == 0) return; // Ultimate mode
Logger.WriteLine("Forcing Standard Mode on shutdown / hibernation");
Program.acpi.SetGPUEco(0);
}
}
}

11
app/Gpu/IGpuControl.cs Normal file
View File

@@ -0,0 +1,11 @@
namespace GHelper.Gpu;
public interface IGpuControl : IDisposable {
bool IsNvidia { get; }
bool IsValid { get; }
public string FullName { get; }
int? GetCurrentTemperature();
int? GetGpuUse();
void KillGPUApps();
}

View File

@@ -0,0 +1,241 @@
using GHelper.Helpers;
using NvAPIWrapper.GPU;
using NvAPIWrapper.Native;
using NvAPIWrapper.Native.GPU;
using NvAPIWrapper.Native.GPU.Structures;
using NvAPIWrapper.Native.Interfaces.GPU;
using System.Diagnostics;
using static NvAPIWrapper.Native.GPU.Structures.PerformanceStates20InfoV1;
namespace GHelper.Gpu.NVidia;
public class NvidiaGpuControl : IGpuControl
{
public static int MaxCoreOffset => AppConfig.Get("max_gpu_core", 250);
public static int MaxMemoryOffset => AppConfig.Get("max_gpu_memory", 250);
public const int MinCoreOffset = -250;
public const int MinMemoryOffset = -250;
public const int MinClockLimit = 1000;
public const int MaxClockLimit = 3000;
private static PhysicalGPU? _internalGpu;
public NvidiaGpuControl()
{
_internalGpu = GetInternalDiscreteGpu();
}
public bool IsValid => _internalGpu != null;
public bool IsNvidia => IsValid;
public string FullName => _internalGpu!.FullName;
public int? GetCurrentTemperature()
{
if (!IsValid) return null;
PhysicalGPU internalGpu = _internalGpu!;
IThermalSensor? gpuSensor =
GPUApi.GetThermalSettings(internalGpu.Handle).Sensors
.FirstOrDefault(s => s.Target == ThermalSettingsTarget.GPU);
return gpuSensor?.CurrentTemperature;
}
public void Dispose()
{
}
public void KillGPUApps()
{
if (!IsValid) return;
PhysicalGPU internalGpu = _internalGpu!;
try
{
Process[] processes = internalGpu.GetActiveApplications();
foreach (Process process in processes)
try
{
Logger.WriteLine("Kill:" + process.ProcessName);
ProcessHelper.KillByProcess(process);
}
catch (Exception ex)
{
Logger.WriteLine(ex.Message);
}
}
catch (Exception ex)
{
Logger.WriteLine(ex.Message);
}
//GeneralApi.RestartDisplayDriver();
}
public bool GetClocks(out int core, out int memory)
{
PhysicalGPU internalGpu = _internalGpu!;
//Logger.WriteLine(internalGpu.FullName);
//Logger.WriteLine(internalGpu.ArchitectInformation.ToString());
try
{
IPerformanceStates20Info states = GPUApi.GetPerformanceStates20(internalGpu.Handle);
core = states.Clocks[PerformanceStateId.P0_3DPerformance][0].FrequencyDeltaInkHz.DeltaValue / 1000;
memory = states.Clocks[PerformanceStateId.P0_3DPerformance][1].FrequencyDeltaInkHz.DeltaValue / 1000;
Logger.WriteLine($"GET GPU CLOCKS: {core}, {memory}");
foreach (var delta in states.Voltages[PerformanceStateId.P0_3DPerformance])
{
Logger.WriteLine("GPU VOLT:" + delta.IsEditable + " - " + delta.ValueDeltaInMicroVolt.DeltaValue);
}
return true;
}
catch (Exception ex)
{
Logger.WriteLine("GET GPU CLOCKS:" + ex.Message);
core = memory = 0;
return false;
}
}
private bool RunPowershellCommand(string script)
{
try
{
ProcessHelper.RunCMD("powershell", script);
return true;
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
return false;
}
}
public int GetMaxGPUCLock()
{
PhysicalGPU internalGpu = _internalGpu!;
try
{
PrivateClockBoostLockV2 data = GPUApi.GetClockBoostLock(internalGpu.Handle);
int limit = (int)data.ClockBoostLocks[0].VoltageInMicroV / 1000;
Logger.WriteLine("GET CLOCK LIMIT: " + limit);
return limit;
}
catch (Exception ex)
{
Logger.WriteLine("GET CLOCK LIMIT: " + ex.Message);
return -1;
}
}
public int SetMaxGPUClock(int clock)
{
if (clock < MinClockLimit || clock >= MaxClockLimit) clock = 0;
int _clockLimit = GetMaxGPUCLock();
if (_clockLimit != clock)
{
if (clock > 0) RunPowershellCommand($"nvidia-smi -lgc 0,{clock}");
else RunPowershellCommand($"nvidia-smi -rgc");
return 1;
}
else
{
return 0;
}
}
public bool RestartGPU()
{
return RunPowershellCommand(@"$device = Get-PnpDevice | Where-Object { $_.FriendlyName -imatch 'NVIDIA' -and $_.Class -eq 'Display' }; Disable-PnpDevice $device.InstanceId -Confirm:$false; Start-Sleep -Seconds 5; Enable-PnpDevice $device.InstanceId -Confirm:$false");
}
public int SetClocks(int core, int memory)
{
if (core < MinCoreOffset || core > MaxCoreOffset) return 0;
if (memory < MinMemoryOffset || memory > MaxMemoryOffset) return 0;
if (GetClocks(out int currentCore, out int currentMemory))
{
if (Math.Abs(core - currentCore) < 5 && Math.Abs(memory - currentMemory) < 5) return 0;
}
PhysicalGPU internalGpu = _internalGpu!;
var coreClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Graphics, new PerformanceStates20ParameterDelta(core * 1000));
var memoryClock = new PerformanceStates20ClockEntryV1(PublicClockDomain.Memory, new PerformanceStates20ParameterDelta(memory * 1000));
//var voltageEntry = new PerformanceStates20BaseVoltageEntryV1(PerformanceVoltageDomain.Core, new PerformanceStates20ParameterDelta(voltage));
PerformanceStates20ClockEntryV1[] clocks = { coreClock, memoryClock };
PerformanceStates20BaseVoltageEntryV1[] voltages = { };
PerformanceState20[] performanceStates = { new PerformanceState20(PerformanceStateId.P0_3DPerformance, clocks, voltages) };
var overclock = new PerformanceStates20InfoV1(performanceStates, 2, 0);
try
{
Logger.WriteLine($"SET GPU CLOCKS: {core}, {memory}");
GPUApi.SetPerformanceStates20(internalGpu.Handle, overclock);
}
catch (Exception ex)
{
Logger.WriteLine("SET GPU CLOCKS: " + ex.Message);
return -1;
}
return 1;
}
private static PhysicalGPU? GetInternalDiscreteGpu()
{
try
{
return PhysicalGPU
.GetPhysicalGPUs()
.FirstOrDefault(gpu => gpu.SystemType == SystemType.Laptop);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return null;
}
}
public int? GetGpuUse()
{
if (!IsValid)
return null;
PhysicalGPU internalGpu = _internalGpu!;
IUtilizationDomainInfo? gpuUsage = GPUApi.GetUsages(internalGpu.Handle).GPU;
return (int?)gpuUsage?.Percentage;
}
}

View File

@@ -0,0 +1,65 @@
using Ryzen;
using System.Diagnostics;
using System.Text.RegularExpressions;
public static class NvidiaSmi
{
public static bool GetDisplayActiveStatus()
{
// Non AMD devices doesn't seem to be affected
if (!RyzenControl.IsAMD()) return false;
string commandOutput = RunNvidiaSmiCommand();
Logger.WriteLine(commandOutput);
if (commandOutput.Length == 0) return false;
if (!commandOutput.Contains("RTX 40")) return false;
// Extract the "Display Active" status using regular expressions
string displayActivePattern = @"Display Active\s+:\s+(\w+)";
Match match = Regex.Match(commandOutput, displayActivePattern, RegexOptions.IgnoreCase);
if (match.Success)
{
string status = match.Groups[1].Value.ToLower().Trim(' ');
return status == "enabled";
}
return false; // Return false if the "Display Active" status is not found
}
private static string RunNvidiaSmiCommand(string arguments = "-i 0 -q")
{
ProcessStartInfo startInfo = new ProcessStartInfo
{
FileName = "nvidia-smi",
Arguments = arguments,
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true
};
Process process = new Process
{
StartInfo = startInfo
};
try
{
process.Start();
string output = process.StandardOutput.ReadToEnd();
process.WaitForExit();
return output;
}
catch (Exception ex)
{
//return File.ReadAllText(@"smi.txt");
Debug.WriteLine(ex.Message);
}
return "";
}
}

299
app/HardwareControl.cs Normal file
View File

@@ -0,0 +1,299 @@
using GHelper;
using GHelper.Fan;
using GHelper.Gpu;
using GHelper.Gpu.NVidia;
using GHelper.Gpu.AMD;
using GHelper.Helpers;
using System.Diagnostics;
using System.Management;
public static class HardwareControl
{
public static IGpuControl? GpuControl;
public static float? cpuTemp = -1;
public static decimal? batteryRate = 0;
public static decimal batteryHealth = -1;
public static decimal batteryCapacity = -1;
public static decimal? designCapacity;
public static decimal? fullCapacity;
public static decimal? chargeCapacity;
public static int? gpuTemp = null;
public static string? cpuFan;
public static string? gpuFan;
public static string? midFan;
public static int? gpuUse;
static long lastUpdate;
private static int GetGpuUse()
{
try
{
int? gpuUse = GpuControl?.GetGpuUse();
Logger.WriteLine("GPU usage: " + GpuControl?.FullName + " " + gpuUse + "%");
if (gpuUse is not null) return (int)gpuUse;
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
return 0;
}
public static void GetBatteryStatus()
{
batteryRate = 0;
chargeCapacity = 0;
try
{
ManagementScope scope = new ManagementScope("root\\WMI");
ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryStatus");
using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
{
chargeCapacity = Convert.ToDecimal(obj["RemainingCapacity"]);
decimal chargeRate = Convert.ToDecimal(obj["ChargeRate"]);
decimal dischargeRate = Convert.ToDecimal(obj["DischargeRate"]);
if (chargeRate > 0)
batteryRate = chargeRate / 1000;
else
batteryRate = -dischargeRate / 1000;
}
}
catch (Exception ex)
{
Logger.WriteLine("Discharge Reading: " + ex.Message);
}
}
public static void ReadFullChargeCapacity()
{
if (fullCapacity > 0) return;
try
{
ManagementScope scope = new ManagementScope("root\\WMI");
ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryFullChargedCapacity");
using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
{
fullCapacity = Convert.ToDecimal(obj["FullChargedCapacity"]);
}
}
catch (Exception ex)
{
Logger.WriteLine("Full Charge Reading: " + ex.Message);
}
}
public static void ReadDesignCapacity()
{
if (designCapacity > 0) return;
try
{
ManagementScope scope = new ManagementScope("root\\WMI");
ObjectQuery query = new ObjectQuery("SELECT * FROM BatteryStaticData");
using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
{
designCapacity = Convert.ToDecimal(obj["DesignedCapacity"]);
}
}
catch (Exception ex)
{
Logger.WriteLine("Design Capacity Reading: " + ex.Message);
}
}
public static void RefreshBatteryHealth()
{
batteryHealth = GetBatteryHealth() * 100;
}
public static decimal GetBatteryHealth()
{
if (designCapacity is null)
{
ReadDesignCapacity();
}
ReadFullChargeCapacity();
if (designCapacity is null || fullCapacity is null || designCapacity == 0 || fullCapacity == 0)
{
return -1;
}
decimal health = (decimal)fullCapacity / (decimal)designCapacity;
Logger.WriteLine("Design Capacity: " + designCapacity + "mWh, Full Charge Capacity: " + fullCapacity + "mWh, Health: " + health + "%");
return health;
}
public static float? GetCPUTemp() {
var last = DateTimeOffset.Now.ToUnixTimeSeconds();
if (Math.Abs(last - lastUpdate) < 2) return cpuTemp;
lastUpdate = last;
cpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_CPU);
if (cpuTemp < 0) try
{
using (var ct = new PerformanceCounter("Thermal Zone Information", "Temperature", @"\_TZ.THRM", true))
{
cpuTemp = ct.NextValue() - 273;
}
}
catch (Exception ex)
{
Debug.WriteLine("Failed reading CPU temp :" + ex.Message);
}
return cpuTemp;
}
public static void ReadSensors()
{
batteryRate = 0;
gpuTemp = -1;
gpuUse = -1;
cpuFan = FanSensorControl.FormatFan(AsusFan.CPU, Program.acpi.GetFan(AsusFan.CPU));
gpuFan = FanSensorControl.FormatFan(AsusFan.GPU, Program.acpi.GetFan(AsusFan.GPU));
midFan = FanSensorControl.FormatFan(AsusFan.Mid, Program.acpi.GetFan(AsusFan.Mid));
cpuTemp = GetCPUTemp();
try
{
gpuTemp = GpuControl?.GetCurrentTemperature();
}
catch (Exception ex)
{
gpuTemp = -1;
Debug.WriteLine("Failed reading GPU temp :" + ex.Message);
}
if (gpuTemp is null || gpuTemp < 0)
gpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_GPU);
ReadFullChargeCapacity();
GetBatteryStatus();
if (fullCapacity > 0 && chargeCapacity > 0)
{
batteryCapacity = Math.Min(100, ((decimal)chargeCapacity / (decimal)fullCapacity) * 100);
}
}
public static bool IsUsedGPU(int threshold = 10)
{
if (GetGpuUse() > threshold)
{
Thread.Sleep(1000);
return (GetGpuUse() > threshold);
}
return false;
}
public static NvidiaGpuControl? GetNvidiaGpuControl()
{
if ((bool)GpuControl?.IsNvidia)
return (NvidiaGpuControl)GpuControl;
else
return null;
}
public static void RecreateGpuControlWithDelay(int delay = 5)
{
// Re-enabling the discrete GPU takes a bit of time,
// so a simple workaround is to refresh again after that happens
Task.Run(async () =>
{
await Task.Delay(TimeSpan.FromSeconds(delay));
RecreateGpuControl();
});
}
public static void RecreateGpuControl()
{
try
{
GpuControl?.Dispose();
IGpuControl _gpuControl = new NvidiaGpuControl();
if (_gpuControl.IsValid)
{
GpuControl = _gpuControl;
Logger.WriteLine(GpuControl.FullName);
return;
}
_gpuControl.Dispose();
_gpuControl = new AmdGpuControl();
if (_gpuControl.IsValid)
{
GpuControl = _gpuControl;
if (GpuControl.FullName.Contains("6850M")) AppConfig.Set("xgm_special", 1);
Logger.WriteLine(GpuControl.FullName);
return;
}
_gpuControl.Dispose();
Logger.WriteLine("dGPU not found");
GpuControl = null;
}
catch (Exception ex)
{
Debug.WriteLine("Can't connect to GPU " + ex.ToString());
}
}
public static void KillGPUApps()
{
List<string> tokill = new() { "EADesktop", "RadeonSoftware", "epicgameslauncher", "ASUSSmartDisplayControl" };
foreach (string kill in tokill) ProcessHelper.KillByName(kill);
if (AppConfig.Is("kill_gpu_apps") && GpuControl is not null)
{
GpuControl.KillGPUApps();
}
}
}

29
app/Helpers/Audio.cs Normal file
View File

@@ -0,0 +1,29 @@
using NAudio.CoreAudioApi;
namespace GHelper.Helpers
{
internal class Audio
{
public static bool ToggleMute()
{
using (var enumerator = new MMDeviceEnumerator())
{
var commDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Communications);
var consoleDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Console);
var mmDevice = enumerator.GetDefaultAudioEndpoint(DataFlow.Capture, Role.Multimedia);
bool status = !commDevice.AudioEndpointVolume.Mute;
commDevice.AudioEndpointVolume.Mute = status;
consoleDevice.AudioEndpointVolume.Mute = status;
mmDevice.AudioEndpointVolume.Mute = status;
Logger.WriteLine(commDevice.ToString() + ":" + status);
Logger.WriteLine(consoleDevice.ToString() + ":" + status);
Logger.WriteLine(mmDevice.ToString() + ":" + status);
return status;
}
}
}
}

View File

@@ -0,0 +1,138 @@
using GHelper.Display;
using GHelper.Mode;
using Microsoft.Win32;
namespace GHelper.Helpers
{
internal class ClamshellModeControl
{
public ClamshellModeControl()
{
//Save current setting if hibernate or shutdown to prevent reverting the user set option.
CheckAndSaveLidAction();
}
public bool IsExternalDisplayConnected()
{
var devices = ScreenInterrogatory.GetAllDevices().ToArray();
string internalName = AppConfig.GetString("internal_display");
foreach (var device in devices)
{
if (device.outputTechnology != ScreenInterrogatory.DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL &&
device.outputTechnology != ScreenInterrogatory.DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED
&& device.monitorFriendlyDeviceName != internalName)
{
Logger.WriteLine("Found external screen: " + device.monitorFriendlyDeviceName + ":" + device.outputTechnology.ToString());
//Already found one, we do not have to check whether there are more
return true;
}
}
return false;
}
public bool IsClamshellEnabled()
{
return AppConfig.Is("toggle_clamshell_mode");
}
public bool IsChargerConnected()
{
return SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online;
}
public bool IsClamshellReady()
{
return IsExternalDisplayConnected() && IsChargerConnected();
}
public void ToggleLidAction()
{
if (!IsClamshellEnabled())
{
return;
}
if (IsClamshellReady())
{
EnableClamshellMode();
}
else
{
DisableClamshellMode();
}
}
public static void DisableClamshellMode()
{
PowerNative.SetLidAction(GetDefaultLidAction(), true);
Logger.WriteLine("Disengaging Clamshell Mode");
}
public static void EnableClamshellMode()
{
PowerNative.SetLidAction(0, true);
Logger.WriteLine("Engaging Clamshell Mode");
}
public void UnregisterDisplayEvents()
{
SystemEvents.DisplaySettingsChanged -= SystemEvents_DisplaySettingsChanged;
}
public void RegisterDisplayEvents()
{
SystemEvents.DisplaySettingsChanged += SystemEvents_DisplaySettingsChanged;
}
private void SystemEvents_DisplaySettingsChanged(object? sender, EventArgs e)
{
Logger.WriteLine("Display configuration changed.");
if (IsClamshellEnabled())
ToggleLidAction();
}
private static int CheckAndSaveLidAction()
{
if (AppConfig.Get("clamshell_default_lid_action", -1) != -1)
{
//Seting was alredy set. Do not touch it
return AppConfig.Get("clamshell_default_lid_action", -1);
}
int val = PowerNative.GetLidAction(true);
//If it is 0 then it is likely already set by clamshell mdoe
//If 0 was set by the user, then why do they even use clamshell mode?
//We only care about hibernate or shutdown setting here
if (val == 2 || val == 3)
{
AppConfig.Set("clamshell_default_lid_action", val);
return val;
}
return 1;
}
//Power users can change that setting.
//0 = Do nothing
//1 = Sleep (default)
//2 = Hibernate
//3 = Shutdown
private static int GetDefaultLidAction()
{
int val = AppConfig.Get("clamshell_default_lid_action", 1);
if (val < 0 || val > 3)
{
val = 1;
}
return val;
}
}
}

View File

@@ -0,0 +1,21 @@
namespace GHelper.Helpers
{
public class ColorUtilities
{
// Method to get the weighted average between two colors
public static Color GetWeightedAverage(Color color1, Color color2, float weight)
{
int red = (int)Math.Round(color1.R * (1 - weight) + color2.R * weight);
int green = (int)Math.Round(color1.G * (1 - weight) + color2.G * weight);
int blue = (int)Math.Round(color1.B * (1 - weight) + color2.B * weight);
red = Math.Min(255, Math.Max(0, red));
green = Math.Min(255, Math.Max(0, green));
blue = Math.Min(255, Math.Max(0, blue));
return Color.FromArgb(red, green, blue);
}
}
}

39
app/Helpers/Logger.cs Normal file
View File

@@ -0,0 +1,39 @@
using System.Diagnostics;
public static class Logger
{
public static string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
public static string logFile = appPath + "\\log.txt";
public static void WriteLine(string logMessage)
{
Debug.WriteLine(logMessage);
if (!Directory.Exists(appPath)) Directory.CreateDirectory(appPath);
try
{
using (StreamWriter w = File.AppendText(logFile))
{
w.WriteLine($"{DateTime.Now}: {logMessage}");
w.Close();
}
}
catch { }
if (new Random().Next(100) == 1) Cleanup();
}
public static void Cleanup()
{
try
{
var file = File.ReadAllLines(logFile);
int skip = Math.Max(0, file.Count() - 1000);
File.WriteAllLines(logFile, file.Skip(skip).ToArray());
}
catch { }
}
}

View File

@@ -1,10 +1,10 @@
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
namespace OSD
namespace GHelper.Helpers
{
class OSDNativeForm : NativeWindow, IDisposable
public class OSDNativeForm : NativeWindow, IDisposable
{
private bool _disposed = false;
@@ -19,11 +19,11 @@ namespace OSD
protected internal void Invalidate()
{
this.UpdateLayeredWindow();
UpdateLayeredWindow();
}
private void UpdateLayeredWindow()
{
Bitmap bitmap1 = new Bitmap(this.Size.Width, this.Size.Height, PixelFormat.Format32bppArgb);
Bitmap bitmap1 = new Bitmap(Size.Width, Size.Height, PixelFormat.Format32bppArgb);
using (Graphics graphics1 = Graphics.FromImage(bitmap1))
{
Rectangle rectangle1;
@@ -31,27 +31,27 @@ namespace OSD
POINT point1;
POINT point2;
BLENDFUNCTION blendfunction1;
rectangle1 = new Rectangle(0, 0, this.Size.Width, this.Size.Height);
rectangle1 = new Rectangle(0, 0, Size.Width, Size.Height);
PerformPaint(new PaintEventArgs(graphics1, rectangle1));
IntPtr ptr1 = User32.GetDC(IntPtr.Zero);
IntPtr ptr2 = Gdi32.CreateCompatibleDC(ptr1);
IntPtr ptr3 = bitmap1.GetHbitmap(Color.FromArgb(0));
IntPtr ptr4 = Gdi32.SelectObject(ptr2, ptr3);
size1.cx = this.Size.Width;
size1.cy = this.Size.Height;
point1.x = this.Location.X;
point1.x = this.Location.X;
point1.y = this.Location.Y;
nint ptr1 = User32.GetDC(nint.Zero);
nint ptr2 = Gdi32.CreateCompatibleDC(ptr1);
nint ptr3 = bitmap1.GetHbitmap(Color.FromArgb(0));
nint ptr4 = Gdi32.SelectObject(ptr2, ptr3);
size1.cx = Size.Width;
size1.cy = Size.Height;
point1.x = Location.X;
point1.x = Location.X;
point1.y = Location.Y;
point2.x = 0;
point2.y = 0;
blendfunction1 = new BLENDFUNCTION();
blendfunction1.BlendOp = 0;
blendfunction1.BlendFlags = 0;
blendfunction1.SourceConstantAlpha = this._alpha;
blendfunction1.SourceConstantAlpha = _alpha;
blendfunction1.AlphaFormat = 1;
User32.UpdateLayeredWindow(base.Handle, ptr1, ref point1, ref size1, ptr2, ref point2, 0, ref blendfunction1, 2); //2=ULW_ALPHA
User32.UpdateLayeredWindow(Handle, ptr1, ref point1, ref size1, ptr2, ref point2, 0, ref blendfunction1, 2); //2=ULW_ALPHA
Gdi32.SelectObject(ptr2, ptr4);
User32.ReleaseDC(IntPtr.Zero, ptr1);
User32.ReleaseDC(nint.Zero, ptr1);
Gdi32.DeleteObject(ptr3);
Gdi32.DeleteDC(ptr2);
}
@@ -59,25 +59,25 @@ namespace OSD
public virtual void Show()
{
if (base.Handle == IntPtr.Zero) //if handle don't equal to zero - window was created and just hided
this.CreateWindowOnly();
User32.ShowWindow(base.Handle, User32.SW_SHOWNOACTIVATE);
if (Handle == nint.Zero) //if handle don't equal to zero - window was created and just hided
CreateWindowOnly();
User32.ShowWindow(Handle, User32.SW_SHOWNOACTIVATE);
}
public virtual void Hide()
{
if (base.Handle == IntPtr.Zero)
if (Handle == nint.Zero)
return;
User32.ShowWindow(base.Handle, User32.SW_HIDE);
this.DestroyHandle();
User32.ShowWindow(Handle, User32.SW_HIDE);
DestroyHandle();
}
public virtual void Close()
{
this.Hide();
this.Dispose();
Hide();
Dispose();
}
private void CreateWindowOnly()
@@ -85,55 +85,55 @@ namespace OSD
CreateParams params1 = new CreateParams();
params1.Caption = "FloatingNativeWindow";
int nX = this._location.X;
int nY = this._location.Y;
Screen screen1 = Screen.FromHandle(base.Handle);
if ((nX + this._size.Width) > screen1.Bounds.Width)
int nX = _location.X;
int nY = _location.Y;
Screen screen1 = Screen.FromHandle(Handle);
if (nX + _size.Width > screen1.Bounds.Width)
{
nX = screen1.Bounds.Width - this._size.Width;
nX = screen1.Bounds.Width - _size.Width;
}
if ((nY + this._size.Height) > screen1.Bounds.Height)
if (nY + _size.Height > screen1.Bounds.Height)
{
nY = screen1.Bounds.Height - this._size.Height;
nY = screen1.Bounds.Height - _size.Height;
}
this._location = new Point(nX, nY);
Size size1 = this._size;
Point point1 = this._location;
_location = new Point(nX, nY);
Size size1 = _size;
Point point1 = _location;
params1.X = nX;
params1.Y = nY;
params1.Height = size1.Height;
params1.Width = size1.Width;
params1.Parent = IntPtr.Zero;
params1.Parent = nint.Zero;
uint ui = User32.WS_POPUP;
params1.Style = (int)ui;
params1.ExStyle = User32.WS_EX_TOPMOST | User32.WS_EX_TOOLWINDOW | User32.WS_EX_LAYERED | User32.WS_EX_NOACTIVATE | User32.WS_EX_TRANSPARENT;
this.CreateHandle(params1);
this.UpdateLayeredWindow();
CreateHandle(params1);
UpdateLayeredWindow();
}
protected virtual void SetBoundsCore(int x, int y, int width, int height)
{
if (((this.X != x) || (this.Y != y)) || ((this.Width != width) || (this.Height != height)))
if (X != x || Y != y || Width != width || Height != height)
{
if (base.Handle != IntPtr.Zero)
if (Handle != nint.Zero)
{
int num1 = 20;
if ((this.X == x) && (this.Y == y))
if (X == x && Y == y)
{
num1 |= 2;
}
if ((this.Width == width) && (this.Height == height))
if (Width == width && Height == height)
{
num1 |= 1;
}
User32.SetWindowPos(base.Handle, IntPtr.Zero, x, y, width, height, (uint)num1);
User32.SetWindowPos(Handle, nint.Zero, x, y, width, height, (uint)num1);
}
else
{
this.Location = new Point(x, y);
this.Size = new Size(width, height);
Location = new Point(x, y);
Size = new Size(width, height);
}
}
}
@@ -147,20 +147,20 @@ namespace OSD
/// </summary>
public virtual Point Location
{
get { return this._location; }
get { return _location; }
set
{
if (base.Handle != IntPtr.Zero)
if (Handle != nint.Zero)
{
this.SetBoundsCore(value.X, value.Y, this._size.Width, this._size.Height);
SetBoundsCore(value.X, value.Y, _size.Width, _size.Height);
RECT rect = new RECT();
User32.GetWindowRect(base.Handle, ref rect);
this._location = new Point(rect.left, rect.top);
this.UpdateLayeredWindow();
User32.GetWindowRect(Handle, ref rect);
_location = new Point(rect.left, rect.top);
UpdateLayeredWindow();
}
else
{
this._location = value;
_location = value;
}
}
}
@@ -169,20 +169,20 @@ namespace OSD
/// </summary>
public virtual Size Size
{
get { return this._size; }
get { return _size; }
set
{
if (base.Handle != IntPtr.Zero)
if (Handle != nint.Zero)
{
this.SetBoundsCore(this._location.X, this._location.Y, value.Width, value.Height);
SetBoundsCore(_location.X, _location.Y, value.Width, value.Height);
RECT rect = new RECT();
User32.GetWindowRect(base.Handle, ref rect);
this._size = new Size(rect.right - rect.left, rect.bottom - rect.top);
this.UpdateLayeredWindow();
User32.GetWindowRect(Handle, ref rect);
_size = new Size(rect.right - rect.left, rect.bottom - rect.top);
UpdateLayeredWindow();
}
else
{
this._size = value;
_size = value;
}
}
}
@@ -191,10 +191,10 @@ namespace OSD
/// </summary>
public int Height
{
get { return this._size.Height; }
get { return _size.Height; }
set
{
this._size = new Size(this._size.Width, value);
_size = new Size(_size.Width, value);
}
}
/// <summary>
@@ -202,10 +202,10 @@ namespace OSD
/// </summary>
public int Width
{
get { return this._size.Width; }
get { return _size.Width; }
set
{
this._size = new Size(value, this._size.Height);
_size = new Size(value, _size.Height);
}
}
/// <summary>
@@ -213,10 +213,10 @@ namespace OSD
/// </summary>
public int X
{
get { return this._location.X; }
get { return _location.X; }
set
{
this.Location = new Point(value, this.Location.Y);
Location = new Point(value, Location.Y);
}
}
/// <summary>
@@ -224,10 +224,10 @@ namespace OSD
/// </summary>
public int Y
{
get { return this._location.Y; }
get { return _location.Y; }
set
{
this.Location = new Point(this.Location.X, value);
Location = new Point(Location.X, value);
}
}
/// <summary>
@@ -237,7 +237,7 @@ namespace OSD
{
get
{
return new Rectangle(new Point(0, 0), this._size);
return new Rectangle(new Point(0, 0), _size);
}
}
/// <summary>
@@ -245,12 +245,12 @@ namespace OSD
/// </summary>
public byte Alpha
{
get { return this._alpha; }
get { return _alpha; }
set
{
if (this._alpha == value) return;
this._alpha = value;
this.UpdateLayeredWindow();
if (_alpha == value) return;
_alpha = value;
UpdateLayeredWindow();
}
}
#endregion
@@ -258,37 +258,22 @@ namespace OSD
#region IDisposable Members
public void Dispose()
{
this.Dispose(true);
Dispose(true);
GC.SuppressFinalize(this);
}
private void Dispose(bool disposing)
{
if (!this._disposed)
if (!_disposed)
{
this.DestroyHandle();
this._disposed = true;
DestroyHandle();
_disposed = true;
}
}
#endregion
}
#region # Win32 #
internal struct PAINTSTRUCT
{
public IntPtr hdc;
public int fErase;
public Rectangle rcPaint;
public int fRestore;
public int fIncUpdate;
public int Reserved1;
public int Reserved2;
public int Reserved3;
public int Reserved4;
public int Reserved5;
public int Reserved6;
public int Reserved7;
public int Reserved8;
}
[StructLayout(LayoutKind.Sequential)]
internal struct POINT
{
@@ -314,16 +299,16 @@ namespace OSD
{
public uint cbSize;
public uint dwFlags;
public IntPtr hWnd;
public nint hWnd;
public uint dwHoverTime;
}
[StructLayout(LayoutKind.Sequential)]
internal struct MSG
{
public IntPtr hwnd;
public nint hwnd;
public int message;
public IntPtr wParam;
public IntPtr lParam;
public nint wParam;
public nint lParam;
public int time;
public int pt_x;
public int pt_y;
@@ -360,73 +345,69 @@ namespace OSD
{
}
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool AnimateWindow(IntPtr hWnd, uint dwTime, uint dwFlags);
internal static extern bool AnimateWindow(nint hWnd, uint dwTime, uint dwFlags);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr BeginPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool ClientToScreen(IntPtr hWnd, ref POINT pt);
internal static extern bool ClientToScreen(nint hWnd, ref POINT pt);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool DispatchMessage(ref MSG msg);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool DrawFocusRect(IntPtr hWnd, ref RECT rect);
internal static extern bool DrawFocusRect(nint hWnd, ref RECT rect);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool EndPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
internal static extern nint GetDC(nint hWnd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr GetDC(IntPtr hWnd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr GetFocus();
internal static extern nint GetFocus();
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern ushort GetKeyState(int virtKey);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool GetMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr GetParent(IntPtr hWnd);
internal static extern nint GetParent(nint hWnd);
[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern bool GetClientRect(IntPtr hWnd, [In, Out] ref RECT rect);
public static extern bool GetClientRect(nint hWnd, [In, Out] ref RECT rect);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern int GetWindowLong(IntPtr hWnd, int nIndex);
internal static extern int GetWindowLong(nint hWnd, int nIndex);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr GetWindow(IntPtr hWnd, int cmd);
internal static extern nint GetWindow(nint hWnd, int cmd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool GetWindowRect(IntPtr hWnd, ref RECT rect);
internal static extern bool GetWindowRect(nint hWnd, ref RECT rect);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool HideCaret(IntPtr hWnd);
internal static extern bool HideCaret(nint hWnd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool InvalidateRect(IntPtr hWnd, ref RECT rect, bool erase);
internal static extern bool InvalidateRect(nint hWnd, ref RECT rect, bool erase);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr LoadCursor(IntPtr hInstance, uint cursor);
internal static extern nint LoadCursor(nint hInstance, uint cursor);
[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern int MapWindowPoints(IntPtr hWndFrom, IntPtr hWndTo, [In, Out] ref RECT rect, int cPoints);
public static extern int MapWindowPoints(nint hWndFrom, nint hWndTo, [In, Out] ref RECT rect, int cPoints);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool MoveWindow(IntPtr hWnd, int x, int y, int width, int height, bool repaint);
internal static extern bool MoveWindow(nint hWnd, int x, int y, int width, int height, bool repaint);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool PeekMessage(ref MSG msg, int hWnd, uint wFilterMin, uint wFilterMax, uint wFlag);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool PostMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
internal static extern bool PostMessage(nint hWnd, int Msg, uint wParam, uint lParam);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool ReleaseCapture();
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
internal static extern int ReleaseDC(nint hWnd, nint hDC);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool ScreenToClient(IntPtr hWnd, ref POINT pt);
internal static extern bool ScreenToClient(nint hWnd, ref POINT pt);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern uint SendMessage(IntPtr hWnd, int Msg, uint wParam, uint lParam);
internal static extern uint SendMessage(nint hWnd, int Msg, uint wParam, uint lParam);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr SetCursor(IntPtr hCursor);
internal static extern nint SetCursor(nint hCursor);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr SetFocus(IntPtr hWnd);
internal static extern nint SetFocus(nint hWnd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern int SetWindowLong(IntPtr hWnd, int nIndex, int newLong);
internal static extern int SetWindowLong(nint hWnd, int nIndex, int newLong);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern int SetWindowPos(IntPtr hWnd, IntPtr hWndAfter, int X, int Y, int Width, int Height, uint flags);
internal static extern int SetWindowPos(nint hWnd, nint hWndAfter, int X, int Y, int Width, int Height, uint flags);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool redraw);
internal static extern bool SetWindowRgn(nint hWnd, nint hRgn, bool redraw);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool ShowCaret(IntPtr hWnd);
internal static extern bool ShowCaret(nint hWnd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool SetCapture(IntPtr hWnd);
internal static extern bool SetCapture(nint hWnd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern int ShowWindow(IntPtr hWnd, short cmdShow);
internal static extern int ShowWindow(nint hWnd, short cmdShow);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool SystemParametersInfo(uint uiAction, uint uiParam, ref int bRetValue, uint fWinINI);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
@@ -434,9 +415,9 @@ namespace OSD
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool TranslateMessage(ref MSG msg);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref POINT pptDst, ref SIZE psize, IntPtr hdcSrc, ref POINT pprSrc, int crKey, ref BLENDFUNCTION pblend, int dwFlags);
internal static extern bool UpdateLayeredWindow(nint hwnd, nint hdcDst, ref POINT pptDst, ref SIZE psize, nint hdcSrc, ref POINT pprSrc, int crKey, ref BLENDFUNCTION pblend, int dwFlags);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool UpdateWindow(IntPtr hwnd);
internal static extern bool UpdateWindow(nint hwnd);
[DllImport("User32.dll", CharSet = CharSet.Auto)]
internal static extern bool WaitMessage();
[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
@@ -450,25 +431,25 @@ namespace OSD
{
}
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern int CombineRgn(IntPtr dest, IntPtr src1, IntPtr src2, int flags);
internal static extern int CombineRgn(nint dest, nint src1, nint src2, int flags);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr CreateBrushIndirect(ref LOGBRUSH brush);
internal static extern nint CreateBrushIndirect(ref LOGBRUSH brush);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr CreateCompatibleDC(IntPtr hDC);
internal static extern nint CreateCompatibleDC(nint hDC);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr CreateRectRgnIndirect(ref RECT rect);
internal static extern nint CreateRectRgnIndirect(ref RECT rect);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern bool DeleteDC(IntPtr hDC);
internal static extern bool DeleteDC(nint hDC);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr DeleteObject(IntPtr hObject);
internal static extern nint DeleteObject(nint hObject);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern int GetClipBox(IntPtr hDC, ref RECT rectBox);
internal static extern int GetClipBox(nint hDC, ref RECT rectBox);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern bool PatBlt(IntPtr hDC, int x, int y, int width, int height, uint flags);
internal static extern bool PatBlt(nint hDC, int x, int y, int width, int height, uint flags);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern int SelectClipRgn(IntPtr hDC, IntPtr hRgn);
internal static extern int SelectClipRgn(nint hDC, nint hRgn);
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
internal static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
internal static extern nint SelectObject(nint hDC, nint hObject);
}
[StructLayout(LayoutKind.Sequential)]
public struct LOGBRUSH

View File

@@ -0,0 +1,112 @@
using Microsoft.Win32;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
namespace GHelper.Helpers
{
public static class OptimizationService
{
static List<string> services = new() {
"ArmouryCrateControlInterface",
"ASUSOptimization",
"AsusAppService",
"ASUSLinkNear",
"ASUSLinkRemote",
"ASUSSoftwareManager",
"ASUSSwitch",
"ASUSSystemAnalysis",
"ASUSSystemDiagnosis",
"AsusCertService"
};
public static void SetChargeLimit(int newValue)
{
// Set the path to the .ini file
string path = @"C:\ProgramData\ASUS\ASUS System Control Interface\ASUSOptimization\Customization.ini";
// Make a backup copy of the INI file
string backupPath = path + ".bak";
File.Copy(path, backupPath, true);
string fileContents = File.ReadAllText(path, Encoding.Unicode);
// Find the section [BatteryHealthCharging]
string sectionPattern = @"\[BatteryHealthCharging\]\s*(version=\d+)?\s+value=(\d+)";
Match sectionMatch = Regex.Match(fileContents, sectionPattern);
if (sectionMatch.Success)
{
// Replace the value with the new value
string oldValueString = sectionMatch.Groups[2].Value;
int oldValue = int.Parse(oldValueString);
string newSection = sectionMatch.Value.Replace($"value={oldValue}", $"value={newValue}");
// Replace the section in the file contents
fileContents = fileContents.Replace(sectionMatch.Value, newSection);
File.WriteAllText(path, fileContents, Encoding.Unicode);
}
}
public static bool IsRunning()
{
return Process.GetProcessesByName("AsusOptimization").Count() > 0;
}
public static bool IsOSDRunning()
{
return Process.GetProcessesByName("AsusOSD").Count() > 0;
}
public static int GetRunningCount()
{
int count = 0;
foreach (string service in services)
{
if (Process.GetProcessesByName(service).Count() > 0) count++;
}
return count;
}
public static void SetBacklightOffDelay(int value = 60)
{
try
{
RegistryKey myKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\ASUS\ASUS System Control Interface\AsusOptimization\ASUS Keyboard Hotkeys", true);
if (myKey != null)
{
myKey.SetValue("TurnOffKeybdLight", value, RegistryValueKind.DWord);
myKey.Close();
}
}
catch (Exception ex)
{
Logger.WriteLine(ex.Message);
}
}
public static void StopAsusServices()
{
foreach (string service in services)
{
ProcessHelper.StopDisableService(service);
}
}
public static void StartAsusServices()
{
foreach (string service in services)
{
ProcessHelper.StartEnableService(service);
}
}
}
}

View File

@@ -0,0 +1,146 @@
using System.Diagnostics;
using System.Security.Principal;
namespace GHelper.Helpers
{
public static class ProcessHelper
{
private static long lastAdmin;
public static void CheckAlreadyRunning()
{
Process currentProcess = Process.GetCurrentProcess();
Process[] processes = Process.GetProcessesByName(currentProcess.ProcessName);
if (processes.Length > 1)
{
foreach (Process process in processes)
if (process.Id != currentProcess.Id)
try
{
process.Kill();
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
MessageBox.Show(Properties.Strings.AppAlreadyRunningText, Properties.Strings.AppAlreadyRunning, MessageBoxButtons.OK);
Application.Exit();
return;
}
}
}
public static bool IsUserAdministrator()
{
WindowsIdentity identity = WindowsIdentity.GetCurrent();
WindowsPrincipal principal = new WindowsPrincipal(identity);
return principal.IsInRole(WindowsBuiltInRole.Administrator);
}
public static void RunAsAdmin(string? param = null)
{
if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAdmin) < 2000) return;
lastAdmin = DateTimeOffset.Now.ToUnixTimeMilliseconds();
// Check if the current user is an administrator
if (!IsUserAdministrator())
{
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.UseShellExecute = true;
startInfo.WorkingDirectory = Environment.CurrentDirectory;
startInfo.FileName = Application.ExecutablePath;
startInfo.Arguments = param;
startInfo.Verb = "runas";
try
{
Process.Start(startInfo);
Application.Exit();
}
catch (Exception ex)
{
Logger.WriteLine(ex.Message);
}
}
}
public static void KillByName(string name)
{
foreach (var process in Process.GetProcessesByName(name))
{
try
{
process.Kill();
Logger.WriteLine($"Stopped: {process.ProcessName}");
}
catch (Exception ex)
{
Logger.WriteLine($"Failed to stop: {process.ProcessName} {ex.Message}");
}
}
}
public static void KillByProcess(Process process)
{
try
{
process.Kill();
Logger.WriteLine($"Stopped: {process.ProcessName}");
}
catch (Exception ex)
{
Logger.WriteLine($"Failed to stop: {process.ProcessName} {ex.Message}");
}
}
public static void StopDisableService(string serviceName)
{
try
{
string script = $"Get-Service -Name \"{serviceName}\" | Stop-Service -Force -PassThru | Set-Service -StartupType Disabled";
Logger.WriteLine(script);
RunCMD("powershell", script);
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
}
public static void StartEnableService(string serviceName)
{
try
{
string script = $"Set-Service -Name \"{serviceName}\" -Status running -StartupType Automatic";
Logger.WriteLine(script);
RunCMD("powershell", script);
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
}
public static void RunCMD(string name, string args)
{
var cmd = new Process();
cmd.StartInfo.UseShellExecute = false;
cmd.StartInfo.CreateNoWindow = true;
cmd.StartInfo.RedirectStandardOutput = true;
cmd.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
cmd.StartInfo.FileName = name;
cmd.StartInfo.Arguments = args;
cmd.Start();
string result = cmd.StandardOutput.ReadToEnd().Replace(Environment.NewLine, " ").Trim(' ');
Logger.WriteLine(args);
Logger.WriteLine(result);
cmd.WaitForExit();
}
}
}

84
app/Helpers/Startup.cs Normal file
View File

@@ -0,0 +1,84 @@
using GHelper.Helpers;
using Microsoft.Win32.TaskScheduler;
using System.Diagnostics;
using System.Security.Principal;
public class Startup
{
static string taskName = "GHelper";
public static bool IsScheduled()
{
TaskService taskService = new TaskService();
return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
}
public static void ReScheduleAdmin()
{
if (ProcessHelper.IsUserAdministrator() && IsScheduled())
{
UnSchedule();
Schedule();
}
}
public static void Schedule()
{
string strExeFilePath = Application.ExecutablePath;
if (strExeFilePath is null) return;
var userId = WindowsIdentity.GetCurrent().Name;
using (TaskDefinition td = TaskService.Instance.NewTask())
{
td.RegistrationInfo.Description = "G-Helper Auto Start";
td.Triggers.Add(new LogonTrigger { UserId = userId, Delay = TimeSpan.FromSeconds(1) });
td.Actions.Add(strExeFilePath);
if (ProcessHelper.IsUserAdministrator())
td.Principal.RunLevel = TaskRunLevel.Highest;
td.Settings.StopIfGoingOnBatteries = false;
td.Settings.DisallowStartIfOnBatteries = false;
td.Settings.ExecutionTimeLimit = TimeSpan.Zero;
Debug.WriteLine(strExeFilePath);
Debug.WriteLine(userId);
try
{
TaskService.Instance.RootFolder.RegisterTaskDefinition(taskName, td);
}
catch (Exception e)
{
if (ProcessHelper.IsUserAdministrator())
MessageBox.Show("Can't create a start up task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
else
ProcessHelper.RunAsAdmin();
}
}
}
public static void UnSchedule()
{
using (TaskService taskService = new TaskService())
{
try
{
taskService.RootFolder.DeleteTask(taskName);
}
catch (Exception e)
{
if (ProcessHelper.IsUserAdministrator())
MessageBox.Show("Can't remove task. Try running Task Scheduler by hand and manually deleting GHelper task if it exists there.", "Scheduler Error", MessageBoxButtons.OK);
else
ProcessHelper.RunAsAdmin();
}
}
}
}

166
app/Helpers/ToastForm.cs Normal file
View File

@@ -0,0 +1,166 @@
using System.Drawing.Drawing2D;
namespace GHelper.Helpers
{
static class Drawing
{
public static GraphicsPath RoundedRect(Rectangle bounds, int radius)
{
int diameter = radius * 2;
Size size = new Size(diameter, diameter);
Rectangle arc = new Rectangle(bounds.Location, size);
GraphicsPath path = new GraphicsPath();
if (radius == 0)
{
path.AddRectangle(bounds);
return path;
}
path.AddArc(arc, 180, 90);
arc.X = bounds.Right - diameter;
path.AddArc(arc, 270, 90);
arc.Y = bounds.Bottom - diameter;
path.AddArc(arc, 0, 90);
arc.X = bounds.Left;
path.AddArc(arc, 90, 90);
path.CloseFigure();
return path;
}
public static void FillRoundedRectangle(this Graphics graphics, Brush brush, Rectangle bounds, int cornerRadius)
{
using (GraphicsPath path = RoundedRect(bounds, cornerRadius))
{
graphics.FillPath(brush, path);
}
}
}
public enum ToastIcon
{
BrightnessUp,
BrightnessDown,
BacklightUp,
BacklightDown,
Touchpad,
Microphone,
MicrophoneMute,
FnLock,
Battery,
Charger
}
public class ToastForm : OSDNativeForm
{
protected static string toastText = "Balanced";
protected static ToastIcon? toastIcon = null;
protected static System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();
public ToastForm()
{
timer.Tick += timer_Tick;
timer.Enabled = false;
timer.Interval = 2000;
}
protected override void PerformPaint(PaintEventArgs e)
{
Brush brush = new SolidBrush(Color.FromArgb(150, Color.Black));
e.Graphics.FillRoundedRectangle(brush, Bound, 10);
StringFormat format = new StringFormat();
format.LineAlignment = StringAlignment.Center;
format.Alignment = StringAlignment.Center;
Bitmap? icon = null;
switch (toastIcon)
{
case ToastIcon.BrightnessUp:
icon = Properties.Resources.brightness_up;
break;
case ToastIcon.BrightnessDown:
icon = Properties.Resources.brightness_down;
break;
case ToastIcon.BacklightUp:
icon = Properties.Resources.backlight_up;
break;
case ToastIcon.BacklightDown:
icon = Properties.Resources.backlight_down;
break;
case ToastIcon.Microphone:
icon = Properties.Resources.icons8_microphone_96;
break;
case ToastIcon.MicrophoneMute:
icon = Properties.Resources.icons8_mute_unmute_96;
break;
case ToastIcon.Touchpad:
icon = Properties.Resources.icons8_touchpad_96;
break;
case ToastIcon.FnLock:
icon = Properties.Resources.icons8_function;
break;
case ToastIcon.Battery:
icon = Properties.Resources.icons8_charged_battery_96;
break;
case ToastIcon.Charger:
icon = Properties.Resources.icons8_charging_battery_96;
break;
}
int shiftX = 0;
if (icon is not null)
{
e.Graphics.DrawImage(icon, 18, 18, 64, 64);
shiftX = 40;
}
e.Graphics.DrawString(toastText,
new Font("Segoe UI", 36f, FontStyle.Bold, GraphicsUnit.Pixel),
new SolidBrush(Color.White),
new PointF(Bound.Width / 2 + shiftX, Bound.Height / 2),
format);
}
public void RunToast(string text, ToastIcon? icon = null)
{
if (AppConfig.Is("disable_osd")) return;
Program.settingsForm.Invoke(delegate
{
//Hide();
timer.Stop();
toastText = text;
toastIcon = icon;
Screen screen1 = Screen.FromHandle(Handle);
Width = Math.Max(300, 100 + toastText.Length * 22);
Height = 100;
X = (screen1.Bounds.Width - Width) / 2;
Y = screen1.Bounds.Height - 300 - Height;
Show();
timer.Start();
});
}
private void timer_Tick(object? sender, EventArgs e)
{
//Debug.WriteLine("Toast end");
Hide();
timer.Stop();
}
}
}

View File

@@ -0,0 +1,720 @@
using GHelper.Display;
using GHelper.Helpers;
using GHelper.Mode;
using Microsoft.Win32;
using System.Diagnostics;
using System.Management;
namespace GHelper.Input
{
public class InputDispatcher
{
System.Timers.Timer timer = new System.Timers.Timer(1000);
public static bool backlightActivity = true;
public static Keys keyProfile = Keys.F5;
public static Keys keyApp = Keys.F12;
static ModeControl modeControl = Program.modeControl;
static ScreenControl screenControl = new ScreenControl();
static bool isTUF = AppConfig.IsTUF();
KeyboardListener listener;
KeyboardHook hook = new KeyboardHook();
public InputDispatcher()
{
byte[] result = Program.acpi.DeviceInit();
Debug.WriteLine($"Init: {BitConverter.ToString(result)}");
Program.acpi.SubscribeToEvents(WatcherEventArrived);
//Task.Run(Program.acpi.RunListener);
hook.KeyPressed += new EventHandler<KeyPressedEventArgs>(KeyPressed);
RegisterKeys();
timer.Elapsed += Timer_Elapsed;
}
private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
{
if (GetBacklight() == 0) return;
TimeSpan iddle = NativeMethods.GetIdleTime();
int kb_timeout;
if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
kb_timeout = AppConfig.Get("keyboard_ac_timeout", 0);
else
kb_timeout = AppConfig.Get("keyboard_timeout", 60);
if (kb_timeout == 0) return;
if (backlightActivity && iddle.TotalSeconds > kb_timeout)
{
backlightActivity = false;
AsusUSB.ApplyBrightness(0, "Timeout");
}
if (!backlightActivity && iddle.TotalSeconds < kb_timeout)
{
backlightActivity = true;
SetBacklightAuto();
}
//Debug.WriteLine(iddle.TotalSeconds);
}
public void Init()
{
if (listener is not null) listener.Dispose();
Program.acpi.DeviceInit();
if (!OptimizationService.IsRunning())
listener = new KeyboardListener(HandleEvent);
else
Logger.WriteLine("Optimization service is running");
InitBacklightTimer();
}
public void InitBacklightTimer()
{
timer.Enabled = AppConfig.Get("keyboard_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online ||
AppConfig.Get("keyboard_ac_timeout") > 0 && SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online;
}
public void RegisterKeys()
{
hook.UnregisterAll();
// CTRL + SHIFT + F5 to cycle profiles
if (AppConfig.Get("keybind_profile") != -1) keyProfile = (Keys)AppConfig.Get("keybind_profile");
if (AppConfig.Get("keybind_app") != -1) keyApp = (Keys)AppConfig.Get("keybind_app");
string actionM1 = AppConfig.GetString("m1");
string actionM2 = AppConfig.GetString("m2");
if (keyProfile != Keys.None)
{
hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyProfile);
hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control | ModifierKeys.Alt, keyProfile);
}
if (keyApp != Keys.None) hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, keyApp);
if (!AppConfig.Is("skip_hotkeys"))
{
hook.RegisterHotKey(ModifierKeys.Control, Keys.VolumeDown);
hook.RegisterHotKey(ModifierKeys.Control, Keys.VolumeUp);
hook.RegisterHotKey(ModifierKeys.Shift, Keys.VolumeDown);
hook.RegisterHotKey(ModifierKeys.Shift, Keys.VolumeUp);
hook.RegisterHotKey(ModifierKeys.Shift | ModifierKeys.Control, Keys.F20);
}
if (!AppConfig.IsZ13() && !AppConfig.IsAlly())
{
if (actionM1 is not null && actionM1.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeDown);
if (actionM2 is not null && actionM2.Length > 0) hook.RegisterHotKey(ModifierKeys.None, Keys.VolumeUp);
}
// FN-Lock group
if (AppConfig.Is("fn_lock") && !AppConfig.ContainsModel("VivoBook"))
for (Keys i = Keys.F1; i <= Keys.F11; i++) hook.RegisterHotKey(ModifierKeys.None, i);
// Arrow-lock group
if (AppConfig.Is("arrow_lock") && AppConfig.IsDUO())
{
hook.RegisterHotKey(ModifierKeys.None, Keys.Left);
hook.RegisterHotKey(ModifierKeys.None, Keys.Right);
hook.RegisterHotKey(ModifierKeys.None, Keys.Up);
hook.RegisterHotKey(ModifierKeys.None, Keys.Down);
}
}
static void CustomKey(string configKey = "m3")
{
string command = AppConfig.GetString(configKey + "_custom");
int intKey;
try
{
intKey = Convert.ToInt32(command, 16);
}
catch
{
intKey = -1;
}
if (intKey > 0)
KeyboardHook.KeyPress((Keys)intKey);
else
LaunchProcess(command);
}
static void SetBrightness(int delta)
{
int brightness = -1;
if (isTUF) brightness = ScreenBrightness.Get();
if (AppConfig.SwappedBrightness()) delta = -delta;
Program.acpi.DeviceSet(AsusACPI.UniversalControl, delta > 0 ? AsusACPI.Brightness_Up : AsusACPI.Brightness_Down, "Brightness");
if (isTUF)
{
if (AppConfig.SwappedBrightness()) return;
if (delta < 0 && brightness <= 0) return;
if (delta > 0 && brightness >= 100) return;
Thread.Sleep(100);
if (brightness == ScreenBrightness.Get())
Program.toast.RunToast(ScreenBrightness.Adjust(delta) + "%", (delta < 0) ? ToastIcon.BrightnessDown : ToastIcon.BrightnessUp);
}
}
public void KeyPressed(object sender, KeyPressedEventArgs e)
{
if (e.Modifier == ModifierKeys.None)
{
Logger.WriteLine(e.Key.ToString());
if (AppConfig.NoMKeys())
{
switch (e.Key)
{
case Keys.F2:
KeyboardHook.KeyPress(Keys.VolumeDown);
return;
case Keys.F3:
KeyboardHook.KeyPress(Keys.VolumeUp);
return;
case Keys.F4:
KeyProcess("m3");
return;
}
}
if (AppConfig.IsZ13() || AppConfig.IsDUO())
{
switch (e.Key)
{
case Keys.F11:
HandleEvent(199);
return;
}
}
if (AppConfig.NoAura())
{
switch (e.Key)
{
case Keys.F2:
KeyboardHook.KeyPress(Keys.MediaPreviousTrack);
return;
case Keys.F3:
KeyboardHook.KeyPress(Keys.MediaPlayPause);
return;
case Keys.F4:
KeyboardHook.KeyPress(Keys.MediaNextTrack);
return;
}
}
switch (e.Key)
{
case Keys.F1:
KeyboardHook.KeyPress(Keys.VolumeMute);
break;
case Keys.F2:
SetBacklight(-1, true);
break;
case Keys.F3:
SetBacklight(1, true);
break;
case Keys.F4:
KeyProcess("fnf4");
break;
case Keys.F5:
KeyProcess("fnf5");
break;
case Keys.F6:
KeyboardHook.KeyPress(Keys.Snapshot);
break;
case Keys.F7:
SetBrightness(-10);
break;
case Keys.F8:
SetBrightness(+10);
break;
case Keys.F9:
KeyboardHook.KeyWinPress(Keys.P);
break;
case Keys.F10:
HandleOptimizationEvent(107);
break;
case Keys.F11:
HandleOptimizationEvent(108);
break;
case Keys.F12:
KeyboardHook.KeyWinPress(Keys.A);
break;
case Keys.VolumeDown:
KeyProcess("m1");
break;
case Keys.VolumeUp:
KeyProcess("m2");
break;
case Keys.Left:
KeyboardHook.KeyPress(Keys.Home);
break;
case Keys.Right:
KeyboardHook.KeyPress(Keys.End);
break;
case Keys.Up:
KeyboardHook.KeyPress(Keys.PageUp);
break;
case Keys.Down:
KeyboardHook.KeyPress(Keys.PageDown);
break;
default:
break;
}
}
if (e.Modifier == (ModifierKeys.Control | ModifierKeys.Shift))
{
if (e.Key == keyProfile) modeControl.CyclePerformanceMode();
if (e.Key == keyApp) Program.SettingsToggle();
if (e.Key == Keys.F20) KeyProcess("m3");
}
if (e.Modifier == (ModifierKeys.Control | ModifierKeys.Shift | ModifierKeys.Alt))
{
if (e.Key == keyProfile) modeControl.CyclePerformanceMode(true);
}
if (e.Modifier == (ModifierKeys.Control))
{
switch (e.Key)
{
case Keys.VolumeDown:
// Screen brightness down on CTRL+VolDown
SetBrightness(-10);
break;
case Keys.VolumeUp:
// Screen brightness up on CTRL+VolUp
SetBrightness(+10);
break;
}
}
if (e.Modifier == (ModifierKeys.Shift))
{
switch (e.Key)
{
case Keys.VolumeDown:
// Keyboard backlight down on SHIFT+VolDown
SetBacklight(-1);
break;
case Keys.VolumeUp:
// Keyboard backlight up on SHIFT+VolUp
SetBacklight(1);
break;
}
}
}
public static void KeyProcess(string name = "m3")
{
string action = AppConfig.GetString(name);
if (action is null || action.Length <= 1)
{
if (name == "m4")
action = "ghelper";
if (name == "fnf4")
action = "aura";
if (name == "fnf5")
action = "performance";
if (name == "m3" && !OptimizationService.IsRunning())
action = "micmute";
if (name == "fnc")
action = "fnlock";
if (name == "fne")
action = "calculator";
}
switch (action)
{
case "mute":
KeyboardHook.KeyPress(Keys.VolumeMute);
break;
case "play":
KeyboardHook.KeyPress(Keys.MediaPlayPause);
break;
case "screenshot":
KeyboardHook.KeyPress(Keys.Snapshot);
break;
case "screen":
Logger.WriteLine("Screen off toggle");
NativeMethods.TurnOffScreen();
break;
case "miniled":
screenControl.ToogleMiniled();
break;
case "aura":
Program.settingsForm.BeginInvoke(Program.settingsForm.CycleAuraMode);
break;
case "performance":
modeControl.CyclePerformanceMode(Control.ModifierKeys == Keys.Shift);
break;
case "ghelper":
try
{
Program.settingsForm.BeginInvoke(delegate
{
Program.SettingsToggle();
});
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
break;
case "fnlock":
ToggleFnLock();
break;
case "micmute":
bool muteStatus = Audio.ToggleMute();
Program.toast.RunToast(muteStatus ? "Muted" : "Unmuted", muteStatus ? ToastIcon.MicrophoneMute : ToastIcon.Microphone);
if (AppConfig.IsVivobook()) Program.acpi.DeviceSet(AsusACPI.MICMUTE_LED, muteStatus ? 1 : 0, "MicmuteLed");
break;
case "brightness_up":
SetBrightness(+10);
break;
case "brightness_down":
SetBrightness(-10);
break;
case "screenpad_up":
SetScreenpad(10);
break;
case "screenpad_down":
SetScreenpad(-10);
break;
case "custom":
CustomKey(name);
break;
case "calculator":
LaunchProcess("calc");
break;
default:
break;
}
}
static bool GetTouchpadState()
{
using (var key = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\PrecisionTouchPad\Status", false))
{
Logger.WriteLine("Touchpad status:" + key?.GetValue("Enabled")?.ToString());
return key?.GetValue("Enabled")?.ToString() == "1";
}
}
static void ToggleTouchpad()
{
KeyboardHook.KeyCtrlWinPress(Keys.F24);
}
public static void ToggleArrowLock()
{
int arLock = AppConfig.Is("arrow_lock") ? 0 : 1;
AppConfig.Set("arrow_lock", arLock);
Program.settingsForm.BeginInvoke(Program.inputDispatcher.RegisterKeys);
Program.toast.RunToast("Arrow-Lock " + (arLock == 1 ? "On" : "Off"), ToastIcon.FnLock);
}
public static void ToggleFnLock()
{
int fnLock = AppConfig.Is("fn_lock") ? 0 : 1;
AppConfig.Set("fn_lock", fnLock);
if (AppConfig.ContainsModel("VivoBook"))
Program.acpi.DeviceSet(AsusACPI.FnLock, fnLock == 1 ? 0 : 1, "FnLock");
else
Program.settingsForm.BeginInvoke(Program.inputDispatcher.RegisterKeys);
Program.settingsForm.BeginInvoke(Program.settingsForm.VisualiseFnLock);
Program.toast.RunToast("Fn-Lock " + (fnLock == 1 ? "On" : "Off"), ToastIcon.FnLock);
}
public static void TabletMode()
{
if (AppConfig.Is("disable_tablet")) return;
bool touchpadState = GetTouchpadState();
bool tabletState = Program.acpi.DeviceGet(AsusACPI.TabletState) > 0;
Logger.WriteLine("Tablet: " + tabletState + " Touchpad: " + touchpadState);
if (tabletState && touchpadState || !tabletState && !touchpadState) AsusUSB.TouchpadToggle();
}
static void HandleEvent(int EventID)
{
// The ROG Ally uses different M-key codes.
// We'll special-case the translation of those.
if (AppConfig.IsAlly())
{
switch (EventID)
{
// This is both the M1 and M2 keys.
// There's a way to differentiate, apparently, but it isn't over USB or any other obvious protocol.
case 165:
KeyProcess("paddle");
return;
// The Command Center ("play-looking") button below the select key.
case 166:
KeyProcess("cc");
return;
// The M4/ROG key.
case 56:
KeyProcess("m4");
return;
}
}
// All other devices seem to use the same HID key-codes,
// so we can process them all the same.
else
{
switch (EventID)
{
case 124: // M3
KeyProcess("m3");
return;
case 56: // M4 / Rog button
KeyProcess("m4");
return;
case 55: // Arconym
KeyProcess("m6");
return;
case 181: // FN + Numpad Enter
KeyProcess("fne");
return;
case 174: // FN+F5
modeControl.CyclePerformanceMode(Control.ModifierKeys == Keys.Shift);
return;
case 179: // FN+F4
case 178: // FN+F4
KeyProcess("fnf4");
return;
case 158: // Fn + C
KeyProcess("fnc");
return;
case 78: // Fn + ESC
ToggleFnLock();
return;
case 75: // Fn + ESC
ToggleArrowLock();
return;
case 189: // Tablet mode
TabletMode();
return;
case 197: // FN+F2
SetBacklight(-1);
return;
case 196: // FN+F3
SetBacklight(1);
return;
case 199: // ON Z13 - FN+F11 - cycles backlight
SetBacklight(4);
return;
case 53: // FN+F6 on GA-502DU model
NativeMethods.TurnOffScreen();
return;
}
}
if (!OptimizationService.IsRunning())
HandleOptimizationEvent(EventID);
}
// Asus Optimization service Events
static void HandleOptimizationEvent(int EventID)
{
switch (EventID)
{
case 16: // FN+F7
//ScreenBrightness.Adjust(-10);
Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Down, "Brightness");
break;
case 32: // FN+F8
//ScreenBrightness.Adjust(+10);
Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.Brightness_Up, "Brightness");
break;
case 107: // FN+F10
ToggleTouchpad();
Thread.Sleep(200);
Program.toast.RunToast(GetTouchpadState() ? "On" : "Off", ToastIcon.Touchpad);
break;
case 108: // FN+F11
Program.acpi.DeviceSet(AsusACPI.UniversalControl, AsusACPI.KB_Sleep, "Sleep");
break;
case 106: // Screenpad button on DUO
SetScreenpad(100);
break;
}
}
public static int GetBacklight()
{
int backlight_power = AppConfig.Get("keyboard_brightness", 1);
int backlight_battery = AppConfig.Get("keyboard_brightness_ac", 1);
bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
int backlight;
//backlight = onBattery ? Math.Min(backlight_battery, backlight_power) : Math.Max(backlight_battery, backlight_power);
backlight = onBattery ? backlight_battery : backlight_power;
return Math.Max(Math.Min(3, backlight), 0);
}
public static void SetBacklightAuto(bool init = false)
{
if (init) AsusUSB.Init();
AsusUSB.ApplyBrightness(GetBacklight(), "Auto", init);
}
public static void SetBacklight(int delta, bool force = false)
{
int backlight_power = AppConfig.Get("keyboard_brightness", 1);
int backlight_battery = AppConfig.Get("keyboard_brightness_ac", 1);
bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
int backlight = onBattery ? backlight_battery : backlight_power;
if (delta >= 4)
backlight = ++backlight % 4;
else
backlight = Math.Max(Math.Min(3, backlight + delta), 0);
if (onBattery)
AppConfig.Set("keyboard_brightness_ac", backlight);
else
AppConfig.Set("keyboard_brightness", backlight);
if (force || !OptimizationService.IsRunning())
{
AsusUSB.ApplyBrightness(backlight, "HotKey");
}
if (!OptimizationService.IsOSDRunning())
{
string[] backlightNames = new string[] { "Off", "Low", "Mid", "Max" };
Program.toast.RunToast(backlightNames[backlight], delta > 0 ? ToastIcon.BacklightUp : ToastIcon.BacklightDown);
}
}
public static void SetScreenpad(int delta)
{
int brightness = AppConfig.Get("screenpad", 100);
if (delta == 100)
{
if (brightness < 0) brightness = 100;
else if (brightness >= 100) brightness = 0;
else brightness = -10;
}
else
{
brightness = Math.Max(Math.Min(100, brightness + delta), -10);
}
AppConfig.Set("screenpad", brightness);
if (brightness >= 0) Program.acpi.DeviceSet(AsusACPI.ScreenPadToggle, 1, "ScreenpadOn");
Program.acpi.DeviceSet(AsusACPI.ScreenPadBrightness, Math.Max(brightness * 255 / 100, 0), "Screenpad");
if (brightness < 0) Program.acpi.DeviceSet(AsusACPI.ScreenPadToggle, 0, "ScreenpadOff");
string toast;
if (brightness < 0) toast = "Off";
else if (brightness == 0) toast = "Hidden";
else toast = brightness.ToString() + "%";
Program.toast.RunToast($"Screen Pad {toast}", delta > 0 ? ToastIcon.BrightnessUp : ToastIcon.BrightnessDown);
}
static void LaunchProcess(string command = "")
{
try
{
//string executable = command.Split(' ')[0];
//string arguments = command.Substring(executable.Length).Trim();
ProcessStartInfo startInfo = new ProcessStartInfo("cmd", "/C " + command);
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardError = true;
startInfo.UseShellExecute = false;
startInfo.CreateNoWindow = true;
startInfo.WorkingDirectory = Environment.CurrentDirectory;
//startInfo.Arguments = arguments;
Process proc = Process.Start(startInfo);
}
catch
{
Logger.WriteLine("Failed to run " + command);
}
}
static void WatcherEventArrived(object sender, EventArrivedEventArgs e)
{
if (e.NewEvent is null) return;
int EventID = int.Parse(e.NewEvent["EventID"].ToString());
Logger.WriteLine("WMI event " + EventID);
HandleEvent(EventID);
}
}
}

185
app/Input/KeyboardHook.cs Normal file
View File

@@ -0,0 +1,185 @@
using System.Runtime.InteropServices;
public sealed class KeyboardHook : IDisposable
{
// Registers a hot key with Windows.
[DllImport("user32.dll")]
private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
// Unregisters the hot key with Windows.
[DllImport("user32.dll")]
private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
[DllImport("user32.dll")]
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll", SetLastError = true)]
public static extern void keybd_event(byte virtualKey, byte scanCode, uint flags, IntPtr extraInfo);
public const int KEYEVENTF_EXTENDEDKEY = 1;
public const int KEYEVENTF_KEYUP = 2;
private const byte VK_LWIN = 0x5B;
private const byte VK_LCONTROL = 0xA2;
public static void KeyPress(Keys key)
{
keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
}
public static void KeyWinPress(Keys key)
{
keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
}
public static void KeyCtrlWinPress(Keys key)
{
keybd_event(VK_LCONTROL, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
keybd_event(VK_LCONTROL, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
}
/// <summary>
/// Represents the window that is used internally to get the messages.
/// </summary>
private class Window : NativeWindow, IDisposable
{
private static int WM_HOTKEY = 0x0312;
public static Keys? fakeKey;
public Window()
{
// create the handle for the window.
this.CreateHandle(new CreateParams());
}
/// <summary>
/// Overridden to get the notifications.
/// </summary>
/// <param name="m"></param>
protected override void WndProc(ref Message m)
{
base.WndProc(ref m);
// check if we got a hot key pressed.
if (m.Msg == WM_HOTKEY)
{
// get the keys.
Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);
// invoke the event to notify the parent.
if (KeyPressed != null)
KeyPressed(this, new KeyPressedEventArgs(modifier, key));
}
}
public event EventHandler<KeyPressedEventArgs> KeyPressed;
#region IDisposable Members
public void Dispose()
{
this.DestroyHandle();
}
#endregion
}
private Window _window = new Window();
private int _currentId;
public KeyboardHook()
{
// register the event of the inner native window.
_window.KeyPressed += delegate (object sender, KeyPressedEventArgs args)
{
if (KeyPressed != null)
KeyPressed(this, args);
};
}
/// <summary>
/// Registers a hot key in the system.
/// </summary>
/// <param name="modifier">The modifiers that are associated with the hot key.</param>
/// <param name="key">The key itself that is associated with the hot key.</param>
public void RegisterHotKey(ModifierKeys modifier, Keys key)
{
// increment the counter.
_currentId = _currentId + 1;
// register the hot key.
if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
Logger.WriteLine("Couldnt register " + key);
}
/// <summary>
/// A hot key has been pressed.
/// </summary>
public event EventHandler<KeyPressedEventArgs> KeyPressed;
#region IDisposable Members
public void UnregisterAll()
{
// unregister all the registered hot keys.
for (int i = _currentId; i > 0; i--)
{
UnregisterHotKey(_window.Handle, i);
}
}
public void Dispose()
{
UnregisterAll();
// dispose the inner native window.
_window.Dispose();
}
#endregion
}
/// <summary>
/// Event Args for the event that is fired after the hot key has been pressed.
/// </summary>
public class KeyPressedEventArgs : EventArgs
{
private ModifierKeys _modifier;
private Keys _key;
internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
{
_modifier = modifier;
_key = key;
}
public ModifierKeys Modifier
{
get { return _modifier; }
}
public Keys Key
{
get { return _key; }
}
}
/// <summary>
/// The enumeration of possible modifiers.
/// </summary>
[Flags]
public enum ModifierKeys : uint
{
None = 0,
Alt = 1,
Control = 2,
Shift = 4,
Win = 8
}

View File

@@ -0,0 +1,69 @@
using HidLibrary;
namespace GHelper.Input
{
public class KeyboardListener
{
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
public KeyboardListener(Action<int> KeyHandler)
{
HidDevice? input = AsusUSB.GetDevice();
// Fallback
if (input == null)
{
AsusUSB.Init();
Thread.Sleep(1000);
input = AsusUSB.GetDevice();
}
if (input == null)
{
Logger.WriteLine($"Input device not found");
return;
}
Logger.WriteLine($"Input: {input.DevicePath}");
var task = Task.Run(() =>
{
try
{
while (!cancellationTokenSource.Token.IsCancellationRequested)
{
// Emergency break
if (input == null || !input.IsConnected)
{
Logger.WriteLine("Listener terminated");
break;
}
var data = input.Read().Data;
if (data.Length > 1 && data[0] == AsusUSB.INPUT_HID_ID && data[1] > 0 && data[1] != 236)
{
Logger.WriteLine($"Key: {data[1]}");
KeyHandler(data[1]);
}
}
Logger.WriteLine("Listener stopped");
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
});
}
public void Dispose()
{
cancellationTokenSource?.Cancel();
}
}
}

258
app/Matrix.Designer.cs generated Normal file
View File

@@ -0,0 +1,258 @@
namespace GHelper
{
partial class Matrix
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
pictureMatrix = new PictureBox();
trackZoom = new TrackBar();
buttonPicture = new UI.RButton();
panelPicture = new Panel();
panelMain = new Panel();
panelButtons = new Panel();
buttonReset = new UI.RButton();
panelScaling = new Panel();
comboScaling = new UI.RComboBox();
labelScaling = new Label();
panelZoom = new Panel();
labelZoom = new Label();
labelZoomTitle = new Label();
((System.ComponentModel.ISupportInitialize)pictureMatrix).BeginInit();
((System.ComponentModel.ISupportInitialize)trackZoom).BeginInit();
panelPicture.SuspendLayout();
panelMain.SuspendLayout();
panelButtons.SuspendLayout();
panelScaling.SuspendLayout();
panelZoom.SuspendLayout();
SuspendLayout();
//
// pictureMatrix
//
pictureMatrix.BackColor = Color.Black;
pictureMatrix.Cursor = Cursors.SizeAll;
pictureMatrix.Location = new Point(731, 27);
pictureMatrix.Name = "pictureMatrix";
pictureMatrix.Size = new Size(81, 73);
pictureMatrix.TabIndex = 0;
pictureMatrix.TabStop = false;
//
// trackZoom
//
trackZoom.LargeChange = 50;
trackZoom.Location = new Point(16, 52);
trackZoom.Maximum = 200;
trackZoom.Minimum = 10;
trackZoom.Name = "trackZoom";
trackZoom.Size = new Size(782, 90);
trackZoom.SmallChange = 10;
trackZoom.TabIndex = 2;
trackZoom.TickFrequency = 20;
trackZoom.TickStyle = TickStyle.TopLeft;
trackZoom.Value = 100;
//
// buttonPicture
//
buttonPicture.Activated = false;
buttonPicture.BackColor = SystemColors.ControlLight;
buttonPicture.BorderColor = Color.Transparent;
buttonPicture.BorderRadius = 5;
buttonPicture.FlatAppearance.BorderSize = 0;
buttonPicture.FlatStyle = FlatStyle.Flat;
buttonPicture.Image = Properties.Resources.icons8_matrix_32;
buttonPicture.Location = new Point(16, 19);
buttonPicture.Name = "buttonPicture";
buttonPicture.Secondary = true;
buttonPicture.Size = new Size(258, 56);
buttonPicture.TabIndex = 3;
buttonPicture.Text = "Picture / Gif";
buttonPicture.TextAlign = ContentAlignment.MiddleRight;
buttonPicture.TextImageRelation = TextImageRelation.ImageBeforeText;
buttonPicture.UseVisualStyleBackColor = false;
//
// panelPicture
//
panelPicture.BackColor = Color.Black;
panelPicture.Controls.Add(pictureMatrix);
panelPicture.Dock = DockStyle.Top;
panelPicture.Location = new Point(0, 0);
panelPicture.Name = "panelPicture";
panelPicture.Size = new Size(834, 419);
panelPicture.TabIndex = 4;
//
// panelMain
//
panelMain.Controls.Add(panelButtons);
panelMain.Controls.Add(panelScaling);
panelMain.Controls.Add(panelZoom);
panelMain.Controls.Add(panelPicture);
panelMain.Dock = DockStyle.Top;
panelMain.Location = new Point(20, 20);
panelMain.Name = "panelMain";
panelMain.Size = new Size(834, 924);
panelMain.TabIndex = 5;
//
// panelButtons
//
panelButtons.Controls.Add(buttonReset);
panelButtons.Controls.Add(buttonPicture);
panelButtons.Dock = DockStyle.Top;
panelButtons.Location = new Point(0, 642);
panelButtons.Name = "panelButtons";
panelButtons.Size = new Size(834, 94);
panelButtons.TabIndex = 6;
//
// buttonReset
//
buttonReset.Activated = false;
buttonReset.BackColor = SystemColors.ControlLight;
buttonReset.BorderColor = Color.Transparent;
buttonReset.BorderRadius = 5;
buttonReset.FlatAppearance.BorderSize = 0;
buttonReset.FlatStyle = FlatStyle.Flat;
buttonReset.Image = Properties.Resources.icons8_refresh_32;
buttonReset.Location = new Point(290, 19);
buttonReset.Name = "buttonReset";
buttonReset.Secondary = true;
buttonReset.Size = new Size(258, 56);
buttonReset.TabIndex = 4;
buttonReset.Text = "Reset";
buttonReset.TextAlign = ContentAlignment.MiddleRight;
buttonReset.TextImageRelation = TextImageRelation.ImageBeforeText;
buttonReset.UseVisualStyleBackColor = false;
//
// panelScaling
//
panelScaling.Controls.Add(comboScaling);
panelScaling.Controls.Add(labelScaling);
panelScaling.Dock = DockStyle.Top;
panelScaling.Location = new Point(0, 564);
panelScaling.Name = "panelScaling";
panelScaling.Size = new Size(834, 78);
panelScaling.TabIndex = 7;
//
// comboScaling
//
comboScaling.BorderColor = Color.White;
comboScaling.ButtonColor = Color.FromArgb(255, 255, 255);
comboScaling.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
comboScaling.FormattingEnabled = true;
comboScaling.ItemHeight = 32;
comboScaling.Items.AddRange(new object[] { "Default", "Low", "High", "Bilinear", "Bicubic", "NearestNeighbor", "HighQualityBilinear", "HighQualityBicubic" });
comboScaling.Location = new Point(229, 17);
comboScaling.Margin = new Padding(4, 11, 4, 8);
comboScaling.Name = "comboScaling";
comboScaling.Size = new Size(322, 40);
comboScaling.TabIndex = 17;
//
// labelScaling
//
labelScaling.AutoSize = true;
labelScaling.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
labelScaling.Location = new Point(16, 20);
labelScaling.Name = "labelScaling";
labelScaling.Size = new Size(185, 32);
labelScaling.TabIndex = 4;
labelScaling.Text = "Scaling Quality";
//
// panelZoom
//
panelZoom.AutoSize = true;
panelZoom.Controls.Add(labelZoom);
panelZoom.Controls.Add(labelZoomTitle);
panelZoom.Controls.Add(trackZoom);
panelZoom.Dock = DockStyle.Top;
panelZoom.Location = new Point(0, 419);
panelZoom.Name = "panelZoom";
panelZoom.Size = new Size(834, 145);
panelZoom.TabIndex = 5;
//
// labelZoom
//
labelZoom.Anchor = AnchorStyles.Top | AnchorStyles.Right;
labelZoom.AutoSize = true;
labelZoom.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
labelZoom.Location = new Point(731, 17);
labelZoom.Name = "labelZoom";
labelZoom.Size = new Size(77, 32);
labelZoom.TabIndex = 4;
labelZoom.Text = "Zoom";
//
// labelZoomTitle
//
labelZoomTitle.AutoSize = true;
labelZoomTitle.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
labelZoomTitle.Location = new Point(16, 17);
labelZoomTitle.Name = "labelZoomTitle";
labelZoomTitle.Size = new Size(81, 32);
labelZoomTitle.TabIndex = 3;
labelZoomTitle.Text = "Zoom";
//
// Matrix
//
AutoScaleDimensions = new SizeF(192F, 192F);
AutoScaleMode = AutoScaleMode.Dpi;
AutoSize = true;
ClientSize = new Size(874, 978);
Controls.Add(panelMain);
MaximizeBox = false;
MinimizeBox = false;
MinimumSize = new Size(900, 0);
Name = "Matrix";
Padding = new Padding(20);
ShowIcon = false;
ShowInTaskbar = false;
Text = "Matrix";
((System.ComponentModel.ISupportInitialize)pictureMatrix).EndInit();
((System.ComponentModel.ISupportInitialize)trackZoom).EndInit();
panelPicture.ResumeLayout(false);
panelMain.ResumeLayout(false);
panelMain.PerformLayout();
panelButtons.ResumeLayout(false);
panelScaling.ResumeLayout(false);
panelScaling.PerformLayout();
panelZoom.ResumeLayout(false);
panelZoom.PerformLayout();
ResumeLayout(false);
}
#endregion
private PictureBox pictureMatrix;
private TrackBar trackZoom;
private UI.RButton buttonPicture;
private Panel panelPicture;
private Panel panelMain;
private Panel panelZoom;
private Label labelZoom;
private Label labelZoomTitle;
private Panel panelButtons;
private UI.RButton buttonReset;
private Panel panelScaling;
private Label labelScaling;
private UI.RComboBox comboScaling;
}
}

211
app/Matrix.cs Normal file
View File

@@ -0,0 +1,211 @@
using GHelper.AnimeMatrix;
using GHelper.UI;
namespace GHelper
{
public partial class Matrix : RForm
{
public AniMatrixControl matrixControl = Program.settingsForm.matrixControl;
private bool Dragging;
private int xPos;
private int yPos;
private int baseX;
private int baseY;
private float uiScale;
Image picture;
MemoryStream ms = new MemoryStream();
public Matrix()
{
InitializeComponent();
InitTheme(true);
Shown += Matrix_Shown;
FormClosing += Matrix_FormClosed;
buttonPicture.Click += ButtonPicture_Click;
buttonReset.Click += ButtonReset_Click;
pictureMatrix.MouseUp += PictureMatrix_MouseUp;
pictureMatrix.MouseMove += PictureMatrix_MouseMove;
pictureMatrix.MouseDown += PictureMatrix_MouseDown;
trackZoom.MouseUp += TrackZoom_MouseUp;
trackZoom.ValueChanged += TrackZoom_Changed;
trackZoom.Value = Math.Min(trackZoom.Maximum, AppConfig.Get("matrix_zoom", 100));
VisualiseZoom();
comboScaling.DropDownStyle = ComboBoxStyle.DropDownList;
comboScaling.SelectedIndex = AppConfig.Get("matrix_quality", 0);
comboScaling.SelectedValueChanged += ComboScaling_SelectedValueChanged;
uiScale = panelPicture.Width / matrixControl.device.MaxColumns / 3;
panelPicture.Height = (int)(matrixControl.device.MaxRows * uiScale);
}
private void ComboScaling_SelectedValueChanged(object? sender, EventArgs e)
{
AppConfig.Set("matrix_quality", comboScaling.SelectedIndex);
SetMatrixPicture(false);
}
private void Matrix_FormClosed(object? sender, FormClosingEventArgs e)
{
if (picture is not null) picture.Dispose();
if (ms is not null) ms.Dispose();
pictureMatrix.Dispose();
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
}
private void VisualiseZoom()
{
labelZoom.Text = trackZoom.Value + "%";
}
private void ButtonReset_Click(object? sender, EventArgs e)
{
AppConfig.Set("matrix_zoom", 100);
AppConfig.Set("matrix_x", 0);
AppConfig.Set("matrix_y", 0);
trackZoom.Value = 100;
SetMatrixPicture();
}
private void TrackZoom_MouseUp(object? sender, EventArgs e)
{
AppConfig.Set("matrix_zoom", trackZoom.Value);
SetMatrixPicture();
}
private void TrackZoom_Changed(object? sender, EventArgs e)
{
VisualiseZoom();
}
private void PictureMatrix_MouseDown(object? sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
Dragging = true;
xPos = e.X;
yPos = e.Y;
}
}
private void PictureMatrix_MouseMove(object? sender, MouseEventArgs e)
{
Control c = sender as Control;
if (Dragging && c != null)
{
c.Top = e.Y + c.Top - yPos;
c.Left = e.X + c.Left - xPos;
}
}
private void PictureMatrix_MouseUp(object? sender, MouseEventArgs e)
{
Dragging = false;
Control c = sender as Control;
int matrixX = (int)((baseX - c.Left) / uiScale);
int matrixY = (int)((baseY - c.Top) / uiScale);
AppConfig.Set("matrix_x", matrixX);
AppConfig.Set("matrix_y", matrixY);
SetMatrixPicture(false);
}
private void Matrix_Shown(object? sender, EventArgs e)
{
FormPosition();
SetMatrixPicture();
}
private void SetMatrixPicture(bool visualise = true)
{
matrixControl.SetMatrixPicture(AppConfig.GetString("matrix_picture"), visualise);
}
private void ButtonPicture_Click(object? sender, EventArgs e)
{
matrixControl.OpenMatrixPicture();
}
public void FormPosition()
{
if (Height > Program.settingsForm.Height)
{
Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
}
else
{
Height = Program.settingsForm.Height;
Top = Program.settingsForm.Top;
}
Left = Program.settingsForm.Left - Width - 5;
}
public void VisualiseMatrix(string fileName)
{
if (picture is not null) picture.Dispose();
using (var fs = new FileStream(fileName, FileMode.Open))
{
ms.SetLength(0);
fs.CopyTo(ms);
ms.Position = 0;
fs.Close();
picture = Image.FromStream(ms);
int width = picture.Width;
int height = picture.Height;
int matrixX = AppConfig.Get("matrix_x", 0);
int matrixY = AppConfig.Get("matrix_y", 0);
int matrixZoom = AppConfig.Get("matrix_zoom", 100);
float scale = Math.Min((float)panelPicture.Width / (float)width, (float)panelPicture.Height / (float)height) * matrixZoom / 100;
pictureMatrix.Width = (int)(width * scale);
pictureMatrix.Height = (int)(height * scale);
baseX = panelPicture.Width - pictureMatrix.Width;
baseY = 0;
pictureMatrix.Left = baseX - (int)(matrixX * uiScale);
pictureMatrix.Top = baseY - (int)(matrixY * uiScale);
pictureMatrix.SizeMode = PictureBoxSizeMode.Zoom;
pictureMatrix.Image = picture;
}
}
}
}

120
app/Matrix.resx Normal file
View File

@@ -0,0 +1,120 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

435
app/Mode/ModeControl.cs Normal file
View File

@@ -0,0 +1,435 @@
using GHelper.Battery;
using GHelper.Gpu.NVidia;
using GHelper.Helpers;
using Ryzen;
namespace GHelper.Mode
{
public class ModeControl
{
static SettingsForm settings = Program.settingsForm;
private static bool customFans = false;
private static int customPower = 0;
private int _cpuUV = 0;
private int _igpuUV = 0;
static System.Timers.Timer reapplyTimer = default!;
public ModeControl()
{
reapplyTimer = new System.Timers.Timer(AppConfig.GetMode("reapply_time", 30) * 1000);
reapplyTimer.Elapsed += ReapplyTimer_Elapsed;
reapplyTimer.Enabled = false;
}
private void ReapplyTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
{
SetCPUTemp(AppConfig.GetMode("cpu_temp"), false);
}
public void AutoPerformance(bool powerChanged = false)
{
var Plugged = SystemInformation.PowerStatus.PowerLineStatus;
int mode = AppConfig.Get("performance_" + (int)Plugged);
if (mode != -1)
SetPerformanceMode(mode, powerChanged);
else
SetPerformanceMode(Modes.GetCurrent());
}
public void ResetPerformanceMode()
{
ResetRyzen();
Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Mode");
// Default power mode
AppConfig.RemoveMode("powermode");
PowerNative.SetPowerMode(Modes.GetCurrentBase());
}
public void SetPerformanceMode(int mode = -1, bool notify = false)
{
int oldMode = Modes.GetCurrent();
if (mode < 0) mode = oldMode;
if (!Modes.Exists(mode)) mode = 0;
customFans = false;
customPower = 0;
settings.ShowMode(mode);
SetModeLabel();
Modes.SetCurrent(mode);
int status = Program.acpi.DeviceSet(AsusACPI.PerformanceMode, AppConfig.IsManualModeRequired() ? AsusACPI.PerformanceManual : Modes.GetBase(mode), "Mode");
// Vivobook fallback
if (status != 1)
{
int vivoMode = Modes.GetBase(mode);
if (vivoMode == 1) vivoMode = 2;
else if (vivoMode == 2) vivoMode = 1;
Program.acpi.DeviceSet(AsusACPI.VivoBookMode, vivoMode, "VivoMode");
}
if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected()) AsusUSB.ResetXGM();
if (notify)
Program.toast.RunToast(Modes.GetCurrentName(), SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online ? ToastIcon.Charger : ToastIcon.Battery);
SetGPUClocks();
AutoFans();
AutoPower(1000);
// Power plan from config or defaulting to balanced
if (AppConfig.GetModeString("scheme") is not null)
PowerNative.SetPowerPlan(AppConfig.GetModeString("scheme"));
else
PowerNative.SetBalancedPowerPlan();
// Windows power mode
if (AppConfig.GetModeString("powermode") is not null)
PowerNative.SetPowerMode(AppConfig.GetModeString("powermode"));
else
PowerNative.SetPowerMode(Modes.GetBase(mode));
// CPU Boost setting override
if (AppConfig.GetMode("auto_boost") != -1)
PowerNative.SetCPUBoost(AppConfig.GetMode("auto_boost"));
//BatteryControl.SetBatteryChargeLimit();
/*
if (NativeMethods.PowerGetEffectiveOverlayScheme(out Guid activeScheme) == 0)
{
Debug.WriteLine("Effective :" + activeScheme);
}
*/
settings.FansInit();
}
public void CyclePerformanceMode(bool back = false)
{
SetPerformanceMode(Modes.GetNext(back), true);
}
public void AutoFans(bool force = false)
{
customFans = false;
if (AppConfig.IsMode("auto_apply") || force)
{
bool xgmFan = false;
if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected())
{
//AsusUSB.InitXGM();
AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
xgmFan = true;
}
int cpuResult = Program.acpi.SetFanCurve(AsusFan.CPU, AppConfig.GetFanConfig(AsusFan.CPU));
int gpuResult = Program.acpi.SetFanCurve(AsusFan.GPU, AppConfig.GetFanConfig(AsusFan.GPU));
if (AppConfig.Is("mid_fan"))
Program.acpi.SetFanCurve(AsusFan.Mid, AppConfig.GetFanConfig(AsusFan.Mid));
// something went wrong, resetting to default profile
if (cpuResult != 1 || gpuResult != 1)
{
cpuResult = Program.acpi.SetFanRange(AsusFan.CPU, AppConfig.GetFanConfig(AsusFan.CPU));
gpuResult = Program.acpi.SetFanRange(AsusFan.GPU, AppConfig.GetFanConfig(AsusFan.GPU));
if (cpuResult != 1 || gpuResult != 1)
{
int mode = Modes.GetCurrentBase();
Logger.WriteLine("ASUS BIOS rejected fan curve, resetting mode to " + mode);
Program.acpi.DeviceSet(AsusACPI.PerformanceMode, mode, "Reset Mode");
settings.LabelFansResult("ASUS BIOS rejected fan curve");
}
}
else
{
settings.LabelFansResult("");
customFans = true;
}
// force set PPTs for missbehaving bios on FX507/517 series
if ((AppConfig.IsPowerRequired() || xgmFan) && !AppConfig.IsMode("auto_apply_power"))
{
Task.Run(async () =>
{
await Task.Delay(TimeSpan.FromSeconds(1));
Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, 80, "PowerLimit Fix A0");
Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, 80, "PowerLimit Fix A3");
});
}
}
SetModeLabel();
}
public void AutoPower(int delay = 0)
{
customPower = 0;
bool applyPower = AppConfig.IsMode("auto_apply_power");
bool applyFans = AppConfig.IsMode("auto_apply");
//bool applyGPU = true;
if (applyPower && !applyFans)
{
// force fan curve for misbehaving bios PPTs on some models
if (AppConfig.IsFanRequired())
{
delay = 500;
AutoFans(true);
}
// Fix for models that don't support PPT settings in all modes, setting a "manual" mode for them
if (AppConfig.IsManualModeRequired())
{
AutoFans(true);
}
}
if (delay > 0)
{
var timer = new System.Timers.Timer(delay);
timer.Elapsed += delegate
{
timer.Stop();
timer.Dispose();
if (applyPower) SetPower();
Thread.Sleep(500);
SetGPUPower();
AutoRyzen();
};
timer.Start();
}
else
{
if (applyPower) SetPower(true);
SetGPUPower();
AutoRyzen();
}
}
public void SetModeLabel()
{
settings.SetModeLabel(Properties.Strings.PerformanceMode + ": " + Modes.GetCurrentName() + (customFans ? "+" : "") + ((customPower > 0) ? " " + customPower + "W" : ""));
}
public void SetPower(bool launchAsAdmin = false)
{
int limit_total = AppConfig.GetMode("limit_total");
int limit_cpu = AppConfig.GetMode("limit_cpu");
int limit_fast = AppConfig.GetMode("limit_fast");
if (limit_total > AsusACPI.MaxTotal) return;
if (limit_total < AsusACPI.MinTotal) return;
if (limit_cpu > AsusACPI.MaxCPU) return;
if (limit_cpu < AsusACPI.MinCPU) return;
if (limit_fast > AsusACPI.MaxTotal) return;
if (limit_fast < AsusACPI.MinTotal) return;
// SPL + SPPT togeher in one slider
if (Program.acpi.DeviceGet(AsusACPI.PPT_TotalA0) >= 0)
{
Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, limit_total, "PowerLimit A0");
Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, limit_total, "PowerLimit A3");
customPower = limit_total;
}
else if (RyzenControl.IsAMD())
{
if (ProcessHelper.IsUserAdministrator())
{
var stapmResult = SendCommand.set_stapm_limit((uint)limit_total * 1000);
Logger.WriteLine($"STAPM: {limit_total} {stapmResult}");
var stapmResult2 = SendCommand.set_stapm2_limit((uint)limit_total * 1000);
Logger.WriteLine($"STAPM2: {limit_total} {stapmResult2}");
var slowResult = SendCommand.set_slow_limit((uint)limit_total * 1000);
Logger.WriteLine($"SLOW: {limit_total} {slowResult}");
var fastResult = SendCommand.set_fast_limit((uint)limit_total * 1000);
Logger.WriteLine($"FAST: {limit_total} {fastResult}");
customPower = limit_total;
}
else if (launchAsAdmin)
{
ProcessHelper.RunAsAdmin("cpu");
return;
}
}
if (Program.acpi.IsAllAmdPPT()) // CPU limit all amd models
{
Program.acpi.DeviceSet(AsusACPI.PPT_CPUB0, limit_cpu, "PowerLimit B0");
customPower = limit_cpu;
}
else if (Program.acpi.DeviceGet(AsusACPI.PPT_APUC1) >= 0) // FPPT boost for non all-amd models
{
Program.acpi.DeviceSet(AsusACPI.PPT_APUC1, limit_fast, "PowerLimit C1");
customPower = limit_fast;
}
SetModeLabel();
}
public void SetGPUClocks(bool launchAsAdmin = true)
{
Task.Run(() =>
{
int core = AppConfig.GetMode("gpu_core");
int memory = AppConfig.GetMode("gpu_memory");
int clock_limit = AppConfig.GetMode("gpu_clock_limit");
if (core == -1 && memory == -1) return;
//if ((gpu_core > -5 && gpu_core < 5) && (gpu_memory > -5 && gpu_memory < 5)) launchAsAdmin = false;
if (Program.acpi.DeviceGet(AsusACPI.GPUEco) == 1) return;
if (HardwareControl.GpuControl is null) return;
if (!HardwareControl.GpuControl!.IsNvidia) return;
using NvidiaGpuControl nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
try
{
int statusLimit = nvControl.SetMaxGPUClock(clock_limit);
int statusClocks = nvControl.SetClocks(core, memory);
if ((statusLimit != 0 || statusClocks != 0) && launchAsAdmin) ProcessHelper.RunAsAdmin("gpu");
}
catch (Exception ex)
{
Logger.WriteLine(ex.ToString());
}
settings.GPUInit();
});
}
public void SetGPUPower()
{
int gpu_boost = AppConfig.GetMode("gpu_boost");
int gpu_temp = AppConfig.GetMode("gpu_temp");
if (gpu_boost < AsusACPI.MinGPUBoost || gpu_boost > AsusACPI.MaxGPUBoost) return;
if (gpu_temp < AsusACPI.MinGPUTemp || gpu_temp > AsusACPI.MaxGPUTemp) return;
if (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC0) >= 0)
Program.acpi.DeviceSet(AsusACPI.PPT_GPUC0, gpu_boost, "PowerLimit C0");
if (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC2) >= 0)
Program.acpi.DeviceSet(AsusACPI.PPT_GPUC2, gpu_temp, "PowerLimit C2");
}
public void SetCPUTemp(int? cpuTemp, bool log = true)
{
if (cpuTemp >= RyzenControl.MinTemp && cpuTemp < RyzenControl.MaxTemp)
{
var resultCPU = SendCommand.set_tctl_temp((uint)cpuTemp);
if (log) Logger.WriteLine($"CPU Temp: {cpuTemp} {resultCPU}");
var restultAPU = SendCommand.set_apu_skin_temp_limit((uint)cpuTemp);
if (log) Logger.WriteLine($"APU Temp: {cpuTemp} {restultAPU}");
reapplyTimer.Enabled = AppConfig.IsMode("auto_uv");
}
else
{
reapplyTimer.Enabled = false;
}
}
public void SetUV(int cpuUV)
{
if (!RyzenControl.IsSupportedUV()) return;
if (cpuUV >= RyzenControl.MinCPUUV && cpuUV <= RyzenControl.MaxCPUUV)
{
var uvResult = SendCommand.set_coall(cpuUV);
Logger.WriteLine($"UV: {cpuUV} {uvResult}");
if (uvResult == Smu.Status.OK) _cpuUV = cpuUV;
}
}
public void SetUViGPU(int igpuUV)
{
if (!RyzenControl.IsSupportedUViGPU()) return;
if (igpuUV >= RyzenControl.MinIGPUUV && igpuUV <= RyzenControl.MaxIGPUUV)
{
var iGPUResult = SendCommand.set_cogfx(igpuUV);
Logger.WriteLine($"iGPU UV: {igpuUV} {iGPUResult}");
if (iGPUResult == Smu.Status.OK) _igpuUV = igpuUV;
}
}
public void SetRyzen(bool launchAsAdmin = false)
{
if (!ProcessHelper.IsUserAdministrator())
{
if (launchAsAdmin) ProcessHelper.RunAsAdmin("uv");
return;
}
try
{
SetUV(AppConfig.GetMode("cpu_uv", 0));
SetUViGPU(AppConfig.GetMode("igpu_uv", 0));
SetCPUTemp(AppConfig.GetMode("cpu_temp"));
}
catch (Exception ex)
{
Logger.WriteLine("UV Error: " + ex.ToString());
}
}
public void ResetRyzen()
{
if (_cpuUV != 0) SetUV(0);
if (_igpuUV != 0) SetUViGPU(0);
}
public void AutoRyzen()
{
if (!RyzenControl.IsAMD()) return;
if (AppConfig.IsMode("auto_uv")) SetRyzen();
else ResetRyzen();
}
}
}

155
app/Mode/Modes.cs Normal file
View File

@@ -0,0 +1,155 @@
namespace GHelper.Mode
{
internal class Modes
{
const int maxModes = 20;
public static Dictionary<int, string> GetDictonary()
{
Dictionary<int, string> modes = new Dictionary<int, string>
{
{2, Properties.Strings.Silent},
{0, Properties.Strings.Balanced},
{1, Properties.Strings.Turbo}
};
for (int i = 3; i < maxModes; i++)
{
if (Exists(i)) modes.Add(i, GetName(i));
}
return modes;
}
public static List<int> GetList()
{
List<int> modes = new() { 2, 0, 1 };
for (int i = 3; i < maxModes; i++)
{
if (Exists(i)) modes.Add(i);
}
return modes;
}
public static void Remove(int mode)
{
List<string> cleanup = new() {
"mode_base",
"mode_name",
"limit_total",
"limit_fast",
"limit_cpu",
"limit_total",
"fan_profile_cpu",
"fan_profile_gpu",
"fan_profile_mid",
"gpu_boost",
"gpu_temp",
"gpu_core",
"gpu_memory",
"auto_boost",
"auto_apply",
"auto_apply_power",
"powermode"
};
foreach (string clean in cleanup)
{
AppConfig.Remove(clean + "_" + mode);
}
}
public static int Add()
{
for (int i = 3; i < maxModes; i++)
{
if (!Exists(i))
{
int modeBase = GetCurrentBase();
string nameName = "Custom " + (i - 2);
AppConfig.Set("mode_base_" + i, modeBase);
AppConfig.Set("mode_name_" + i, nameName);
return i;
}
}
return -1;
}
public static int GetCurrent()
{
return AppConfig.Get("performance_mode");
}
public static bool IsCurrentCustom()
{
return GetCurrent() > 2;
}
public static void SetCurrent(int mode)
{
AppConfig.Set("performance_" + (int)SystemInformation.PowerStatus.PowerLineStatus, mode);
AppConfig.Set("performance_mode", mode);
}
public static int GetCurrentBase()
{
return GetBase(GetCurrent());
}
public static string GetCurrentName()
{
return GetName(GetCurrent());
}
public static bool Exists(int mode)
{
return GetBase(mode) >= 0;
}
public static int GetBase(int mode)
{
if (mode >= 0 && mode <= 2)
return mode;
else
return AppConfig.Get("mode_base_" + mode);
}
public static string GetName(int mode)
{
switch (mode)
{
case 0:
return Properties.Strings.Balanced;
case 1:
return Properties.Strings.Turbo;
case 2:
return Properties.Strings.Silent;
default:
return AppConfig.GetString("mode_name_" + mode);
}
}
public static int GetNext(bool back = false)
{
var modes = GetList();
int index = modes.IndexOf(GetCurrent());
if (back)
{
index--;
if (index < 0) index = modes.Count - 1;
return modes[index];
}
else
{
index++;
if (index > modes.Count - 1) index = 0;
return modes[index];
}
}
}
}

342
app/Mode/PowerNative.cs Normal file
View File

@@ -0,0 +1,342 @@
using System.Runtime.InteropServices;
namespace GHelper.Mode
{
internal class PowerNative
{
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerWriteDCValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
int AcValueIndex);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerWriteACValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
int AcValueIndex);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerReadACValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
out IntPtr AcValueIndex
);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerReadDCValueIndex(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid SubGroupOfPowerSettingsGuid,
[MarshalAs(UnmanagedType.LPStruct)] Guid PowerSettingGuid,
out IntPtr AcValueIndex
);
[DllImport("powrprof.dll")]
static extern uint PowerReadACValue(
IntPtr RootPowerKey,
Guid SchemeGuid,
Guid SubGroupOfPowerSettingGuid,
Guid PowerSettingGuid,
ref int Type,
ref IntPtr Buffer,
ref uint BufferSize
);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerSetActiveScheme(IntPtr RootPowerKey,
[MarshalAs(UnmanagedType.LPStruct)] Guid SchemeGuid);
[DllImport("PowrProf.dll", CharSet = CharSet.Unicode)]
static extern UInt32 PowerGetActiveScheme(IntPtr UserPowerKey, out IntPtr ActivePolicyGuid);
static readonly Guid GUID_CPU = new Guid("54533251-82be-4824-96c1-47b60b740d00");
static readonly Guid GUID_BOOST = new Guid("be337238-0d82-4146-a960-4f3749d470c7");
private static Guid GUID_SLEEP_SUBGROUP = new Guid("238c9fa8-0aad-41ed-83f4-97be242c8f20");
private static Guid GUID_HIBERNATEIDLE = new Guid("9d7815a6-7ee4-497e-8888-515a05f02364");
private static Guid GUID_SYSTEM_BUTTON_SUBGROUP = new Guid("4f971e89-eebd-4455-a8de-9e59040e7347");
private static Guid GUID_LIDACTION = new Guid("5CA83367-6E45-459F-A27B-476B1D01C936");
[DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetActualOverlayScheme")]
public static extern uint PowerGetActualOverlayScheme(out Guid ActualOverlayGuid);
[DllImportAttribute("powrprof.dll", EntryPoint = "PowerGetEffectiveOverlayScheme")]
public static extern uint PowerGetEffectiveOverlayScheme(out Guid EffectiveOverlayGuid);
[DllImportAttribute("powrprof.dll", EntryPoint = "PowerSetActiveOverlayScheme")]
public static extern uint PowerSetActiveOverlayScheme(Guid OverlaySchemeGuid);
const string POWER_SILENT = "961cc777-2547-4f9d-8174-7d86181b8a7a";
const string POWER_BALANCED = "00000000-0000-0000-0000-000000000000";
const string POWER_TURBO = "ded574b5-45a0-4f42-8737-46345c09c238";
const string POWER_BETTERPERFORMANCE = "ded574b5-45a0-4f42-8737-46345c09c238";
static List<string> overlays = new() {
POWER_BALANCED,
POWER_TURBO,
POWER_SILENT,
POWER_BETTERPERFORMANCE
};
public static Dictionary<string, string> powerModes = new Dictionary<string, string>
{
{ POWER_SILENT, "Best Power Efficiency" },
{ POWER_BALANCED, "Balanced" },
{ POWER_TURBO, "Best Performance" },
};
static Guid GetActiveScheme()
{
IntPtr pActiveSchemeGuid;
var hr = PowerGetActiveScheme(IntPtr.Zero, out pActiveSchemeGuid);
Guid activeSchemeGuid = (Guid)Marshal.PtrToStructure(pActiveSchemeGuid, typeof(Guid));
return activeSchemeGuid;
}
public static int GetCPUBoost()
{
IntPtr AcValueIndex;
Guid activeSchemeGuid = GetActiveScheme();
UInt32 value = PowerReadACValueIndex(IntPtr.Zero,
activeSchemeGuid,
GUID_CPU,
GUID_BOOST, out AcValueIndex);
return AcValueIndex.ToInt32();
}
public static void SetCPUBoost(int boost = 0)
{
Guid activeSchemeGuid = GetActiveScheme();
if (boost == GetCPUBoost()) return;
var hrAC = PowerWriteACValueIndex(
IntPtr.Zero,
activeSchemeGuid,
GUID_CPU,
GUID_BOOST,
boost);
PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
var hrDC = PowerWriteDCValueIndex(
IntPtr.Zero,
activeSchemeGuid,
GUID_CPU,
GUID_BOOST,
boost);
PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
Logger.WriteLine("Boost " + boost);
}
public static string GetPowerMode()
{
PowerGetEffectiveOverlayScheme(out Guid activeScheme);
return activeScheme.ToString();
}
public static void SetPowerMode(string scheme)
{
if (!overlays.Contains(scheme)) return;
Guid guidScheme = new Guid(scheme);
uint status = PowerGetEffectiveOverlayScheme(out Guid activeScheme);
if (GetBatterySaverStatus())
{
Logger.WriteLine("Battery Saver detected");
return;
}
if (status != 0 || activeScheme != guidScheme)
{
status = PowerSetActiveOverlayScheme(guidScheme);
Logger.WriteLine("Power Mode " + scheme + ":" + (status == 0 ? "OK" : status));
}
}
public static void SetBalancedPowerPlan()
{
Guid activeSchemeGuid = GetActiveScheme();
string balanced = "381b4222-f694-41f0-9685-ff5bb260df2e";
if (activeSchemeGuid.ToString() != balanced && !AppConfig.Is("skip_power_plan"))
{
SetPowerPlan(balanced);
}
}
public static void SetPowerPlan(string scheme)
{
// Skipping power modes
if (overlays.Contains(scheme)) return;
Guid guidScheme = new Guid(scheme);
uint status = PowerSetActiveScheme(IntPtr.Zero, guidScheme);
Logger.WriteLine("Power Plan " + scheme + ":" + (status == 0 ? "OK" : status));
}
public static string GetDefaultPowerMode(int mode)
{
switch (mode)
{
case 1: // turbo
return POWER_TURBO;
case 2: //silent
return POWER_SILENT;
default: // balanced
return POWER_BALANCED;
}
}
public static void SetPowerMode(int mode)
{
SetPowerMode(GetDefaultPowerMode(mode));
}
public static int GetLidAction(bool ac)
{
Guid activeSchemeGuid = GetActiveScheme();
IntPtr activeIndex;
if (ac)
PowerReadACValueIndex(IntPtr.Zero,
activeSchemeGuid,
GUID_SYSTEM_BUTTON_SUBGROUP,
GUID_LIDACTION, out activeIndex);
else
PowerReadDCValueIndex(IntPtr.Zero,
activeSchemeGuid,
GUID_SYSTEM_BUTTON_SUBGROUP,
GUID_LIDACTION, out activeIndex);
return activeIndex.ToInt32();
}
public static void SetLidAction(int action, bool acOnly = false)
{
/**
* 1: Do nothing
* 2: Seelp
* 3: Hibernate
* 4: Shutdown
*/
Guid activeSchemeGuid = GetActiveScheme();
var hrAC = PowerWriteACValueIndex(
IntPtr.Zero,
activeSchemeGuid,
GUID_SYSTEM_BUTTON_SUBGROUP,
GUID_LIDACTION,
action);
PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
if (!acOnly)
{
var hrDC = PowerWriteDCValueIndex(
IntPtr.Zero,
activeSchemeGuid,
GUID_SYSTEM_BUTTON_SUBGROUP,
GUID_LIDACTION,
action);
PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
}
Logger.WriteLine("Changed Lid Action to " + action);
}
public static int GetHibernateAfter()
{
Guid activeSchemeGuid = GetActiveScheme();
IntPtr seconds;
PowerReadDCValueIndex(IntPtr.Zero,
activeSchemeGuid,
GUID_SLEEP_SUBGROUP,
GUID_HIBERNATEIDLE, out seconds);
Logger.WriteLine("Hibernate after " + seconds);
return (seconds.ToInt32() / 60);
}
public static void SetHibernateAfter(int minutes)
{
int seconds = minutes * 60;
Guid activeSchemeGuid = GetActiveScheme();
var hrAC = PowerWriteDCValueIndex(
IntPtr.Zero,
activeSchemeGuid,
GUID_SLEEP_SUBGROUP,
GUID_HIBERNATEIDLE,
seconds);
PowerSetActiveScheme(IntPtr.Zero, activeSchemeGuid);
Logger.WriteLine("Setting Hibernate after " + seconds + ": " + (hrAC == 0 ? "OK" : hrAC));
}
[DllImport("Kernel32")]
private static extern bool GetSystemPowerStatus(SystemPowerStatus sps);
public enum ACLineStatus : byte
{
Offline = 0, Online = 1, Unknown = 255
}
public enum BatteryFlag : byte
{
High = 1,
Low = 2,
Critical = 4,
Charging = 8,
NoSystemBattery = 128,
Unknown = 255
}
// Fields must mirror their unmanaged counterparts, in order
[StructLayout(LayoutKind.Sequential)]
public class SystemPowerStatus
{
public ACLineStatus ACLineStatus;
public BatteryFlag BatteryFlag;
public Byte BatteryLifePercent;
public Byte SystemStatusFlag;
public Int32 BatteryLifeTime;
public Int32 BatteryFullLifeTime;
}
public static bool GetBatterySaverStatus()
{
SystemPowerStatus sps = new SystemPowerStatus();
try
{
GetSystemPowerStatus(sps);
return (sps.SystemStatusFlag > 0);
} catch (Exception ex)
{
return false;
}
}
}
}

110
app/NativeMethods.cs Normal file
View File

@@ -0,0 +1,110 @@
using System.Runtime.InteropServices;
public class NativeMethods
{
internal struct LASTINPUTINFO
{
public uint cbSize;
public uint dwTime;
}
[DllImport("User32.dll")]
private static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);
public static TimeSpan GetIdleTime()
{
LASTINPUTINFO lastInPut = new LASTINPUTINFO();
lastInPut.cbSize = (uint)Marshal.SizeOf(lastInPut);
GetLastInputInfo(ref lastInPut);
return TimeSpan.FromMilliseconds((uint)Environment.TickCount - lastInPut.dwTime);
}
private const int WM_SYSCOMMAND = 0x0112;
private const int SC_MONITORPOWER = 0xF170;
private const int MONITOR_OFF = 2;
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern uint FormatMessage(uint dwFlags, IntPtr lpSource, uint dwMessageId, uint dwLanguageId, out string lpBuffer, uint nSize, IntPtr Arguments);
public static void TurnOffScreen()
{
IntPtr result = SendMessage(-1, WM_SYSCOMMAND, (IntPtr)SC_MONITORPOWER, (IntPtr)MONITOR_OFF);
if (result == IntPtr.Zero)
{
int error = Marshal.GetLastWin32Error();
string message = "";
uint formatFlags = 0x00001000 | 0x00000200 | 0x00000100 | 0x00000080;
uint formatResult = FormatMessage(formatFlags, IntPtr.Zero, (uint)error, 0, out message, 0, IntPtr.Zero);
if (formatResult == 0)
{
message = "Unknown error.";
}
Logger.WriteLine($"Failed to turn off screen. Error code: {error}. {message}");
}
}
// Monitor Power detection
internal const uint DEVICE_NOTIFY_WINDOW_HANDLE = 0x0;
internal const uint DEVICE_NOTIFY_SERVICE_HANDLE = 0x1;
internal const int WM_POWERBROADCAST = 0x0218;
internal const int PBT_POWERSETTINGCHANGE = 0x8013;
[DllImport("User32.dll", SetLastError = true)]
internal static extern IntPtr RegisterPowerSettingNotification(IntPtr hWnd, [In] Guid PowerSettingGuid, uint Flags);
[DllImport("User32.dll", SetLastError = true)]
internal static extern bool UnregisterPowerSettingNotification(IntPtr hWnd);
[StructLayout(LayoutKind.Sequential, Pack = 4)]
internal struct POWERBROADCAST_SETTING
{
public Guid PowerSetting;
public uint DataLength;
public byte Data;
}
public class PowerSettingGuid
{
// 0=Powered by AC, 1=Powered by Battery, 2=Powered by short-term source (UPC)
public Guid AcdcPowerSource { get; } = new Guid("5d3e9a59-e9D5-4b00-a6bd-ff34ff516548");
// POWERBROADCAST_SETTING.Data = 1-100
public Guid BatteryPercentageRemaining { get; } = new Guid("a7ad8041-b45a-4cae-87a3-eecbb468a9e1");
// Windows 8+: 0=Monitor Off, 1=Monitor On, 2=Monitor Dimmed
public Guid ConsoleDisplayState { get; } = new Guid("6fe69556-704a-47a0-8f24-c28d936fda47");
// Windows 8+, Session 0 enabled: 0=User providing Input, 2=User Idle
public Guid GlobalUserPresence { get; } = new Guid("786E8A1D-B427-4344-9207-09E70BDCBEA9");
// 0=Monitor Off, 1=Monitor On.
public Guid MonitorPowerGuid { get; } = new Guid("02731015-4510-4526-99e6-e5a17ebd1aea");
// 0=Battery Saver Off, 1=Battery Saver On.
public Guid PowerSavingStatus { get; } = new Guid("E00958C0-C213-4ACE-AC77-FECCED2EEEA5");
// Windows 8+: 0=Off, 1=On, 2=Dimmed
public Guid SessionDisplayStatus { get; } = new Guid("2B84C20E-AD23-4ddf-93DB-05FFBD7EFCA5");
// Windows 8+, no Session 0: 0=User providing Input, 2=User Idle
public Guid SessionUserPresence { get; } = new Guid("3C0F4548-C03F-4c4d-B9F2-237EDE686376");
// 0=Exiting away mode 1=Entering away mode
public Guid SystemAwaymode { get; } = new Guid("98a7f580-01f7-48aa-9c0f-44352c29e5C0");
/* Windows 8+ */
// POWERBROADCAST_SETTING.Data not used
public Guid IdleBackgroundTask { get; } = new Guid(0x515C31D8, 0xF734, 0x163D, 0xA0, 0xFD, 0x11, 0xA0, 0x8C, 0x91, 0xE8, 0xF1);
public Guid PowerSchemePersonality { get; } = new Guid(0x245D8541, 0x3943, 0x4422, 0xB0, 0x25, 0x13, 0xA7, 0x84, 0xF6, 0x79, 0xB7);
// The Following 3 Guids are the POWERBROADCAST_SETTING.Data result of PowerSchemePersonality
public Guid MinPowerSavings { get; } = new Guid("8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c");
public Guid MaxPowerSavings { get; } = new Guid("a1841308-3541-4fab-bc81-f71556f20b4a");
public Guid TypicalPowerSavings { get; } = new Guid("381b4222-f694-41f0-9685-ff5bb260df2e");
}
}

View File

@@ -0,0 +1,32 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace GHelper.Peripherals
{
public enum PeripheralType
{
Mouse,
Keyboard
}
public interface IPeripheral
{
public bool IsDeviceReady { get; }
public bool Wireless { get; }
public int Battery { get; }
public bool Charging { get; }
public PeripheralType DeviceType();
public string GetDisplayName();
public bool HasBattery();
public void SynchronizeDevice();
public void ReadBattery();
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,117 @@
namespace GHelper.Peripherals.Mouse.Models
{
public class ChakramX : AsusMouse
{
public ChakramX() : base(0x0B05, 0x1A1A, "mi_00", true)
{
}
protected ChakramX(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
{
}
public override string GetDisplayName()
{
return "ROG Chakram X (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override bool HasAngleSnapping()
{
return true;
}
public override int ProfileCount()
{
return 5;
}
public override int DPIProfileCount()
{
return 4;
}
public override int MaxDPI()
{
return 36_000;
}
public override bool HasXYDPI()
{
return true;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override bool HasRGB()
{
return true;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleTuning()
{
return true;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override bool HasDPIColors()
{
return true;
}
}
public class ChakramXWired : ChakramX
{
public ChakramXWired() : base(0x1A18, false)
{
}
public override string GetDisplayName()
{
return "ROG Chakram X (Wired)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz,
PollingRate.PR2000Hz,
PollingRate.PR4000Hz,
PollingRate.PR8000Hz
};
}
}
}

View File

@@ -0,0 +1,91 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P706_Wireless
public class GladiusIII : AsusMouse
{
public GladiusIII() : base(0x0B05, 0x197F, "mi_00", true)
{
}
protected GladiusIII(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "ROG Gladius III (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 5;
}
public override int MaxDPI()
{
return 26_000;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override bool HasRGB()
{
return true;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasLowBatteryWarning()
{
return true;
}
}
public class GladiusIIIWired : GladiusIII
{
public GladiusIIIWired() : base(0x197d, false)
{
}
public override string GetDisplayName()
{
return "ROG Gladius III (Wired)";
}
}
}

View File

@@ -0,0 +1,106 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P711
public class GladiusIIIAimpoint : AsusMouse
{
public GladiusIIIAimpoint() : base(0x0B05, 0x1A70, "mi_00", true)
{
}
protected GladiusIIIAimpoint(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "ROG Gladius III Aimpoint (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 5;
}
public override int MaxDPI()
{
return 36_000;
}
public override bool HasXYDPI()
{
return true;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override bool HasRGB()
{
return true;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasAngleTuning()
{
return true;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override bool HasDPIColors()
{
return true;
}
}
public class GladiusIIIAimpointWired : GladiusIIIAimpoint
{
public GladiusIIIAimpointWired() : base(0x1A72, false)
{
}
public override string GetDisplayName()
{
return "ROG Gladius III Aimpoint (Wired)";
}
}
}

View File

@@ -0,0 +1,174 @@
using System.Runtime.CompilerServices;
namespace GHelper.Peripherals.Mouse.Models
{
//P713_Wireless
public class HarpeAceAimLabEdition : AsusMouse
{
public HarpeAceAimLabEdition() : base(0x0B05, 0x1A94, "mi_00", true)
{
}
protected HarpeAceAimLabEdition(ushort productId, bool wireless, string endpoint, byte reportId) : base(0x0B05, productId, endpoint, wireless, reportId)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "ROG Harpe Ace Aim Lab Edition (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 5;
}
public override int MaxDPI()
{
return 36_000;
}
public override int MinDPI()
{
return 50;
}
public override bool HasXYDPI()
{
return true;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override bool HasRGB()
{
return true;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Scrollwheel };
}
public override bool IsLightingModeSupported(LightingMode lightingMode)
{
return lightingMode == LightingMode.Static
|| lightingMode == LightingMode.Breathing
|| lightingMode == LightingMode.ColorCycle
|| lightingMode == LightingMode.React
|| lightingMode == LightingMode.BatteryState
|| lightingMode == LightingMode.Off;
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasAngleTuning()
{
return true;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override bool HasDPIColors()
{
return true;
}
public override int AngleTuningStep()
{
return 1;
}
public override int AngleTuningMin()
{
return -30;
}
public override int AngleTuningMax()
{
return 30;
}
public override bool HasAcceleration()
{
return true;
}
public override bool HasDeceleration()
{
return true;
}
public override int MaxAcceleration()
{
return 9;
}
public override int MaxDeceleration()
{
return 9;
}
}
public class HarpeAceAimLabEditionWired : HarpeAceAimLabEdition
{
public HarpeAceAimLabEditionWired() : base(0x1A92, false, "mi_00", 0x00)
{
}
public override string GetDisplayName()
{
return "ROG Harpe Ace Aim Lab Edition (Wired)";
}
}
public class HarpeAceAimLabEditionOmni : HarpeAceAimLabEdition
{
public HarpeAceAimLabEditionOmni() : base(0x1ACE, true, "mi_02&col03", 0x03)
{
}
public override string GetDisplayName()
{
return "ROG Harpe Ace Aim Lab Edition (OMNI)";
}
public override int USBPacketSize()
{
return 64;
}
}
}

View File

@@ -0,0 +1,106 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P709_Wireless
public class KerisWirelssAimpoint : AsusMouse
{
public KerisWirelssAimpoint() : base(0x0B05, 0x1A68, "mi_00", true)
{
}
protected KerisWirelssAimpoint(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "ROG Keris Wireless Aimpoint (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 5;
}
public override int MaxDPI()
{
return 36_000;
}
public override bool HasXYDPI()
{
return true;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override bool HasRGB()
{
return true;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo };
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasAngleTuning()
{
return true;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override bool HasDPIColors()
{
return true;
}
}
public class KerisWirelssAimpointWired : KerisWirelssAimpoint
{
public KerisWirelssAimpointWired() : base(0x1A66, false)
{
}
public override string GetDisplayName()
{
return "ROG Keris Wireless Aimpoint (Wired)";
}
}
}

View File

@@ -0,0 +1,209 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P705
public class PugioII : AsusMouse
{
public PugioII() : base(0x0B05, 0x1908, "mi_00", true)
{
}
protected PugioII(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "ROG Pugio II (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 3;
}
public override int MaxDPI()
{
return 16_000;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override int DPIIncrements()
{
return 100;
}
public override bool HasRGB()
{
return true;
}
public override int MaxBrightness()
{
return 4;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasAngleTuning()
{
return false;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override int LowBatteryWarningStep()
{
return 25;
}
public override int LowBatteryWarningMax()
{
return 100;
}
protected override int ParseBattery(byte[] packet)
{
return base.ParseBattery(packet) * 25;
}
protected override int ParseLowBatteryWarning(byte[] packet)
{
return base.ParseLowBatteryWarning(packet) * 25;
}
protected override byte[] GetUpdateEnergySettingsPacket(int lowBatteryWarning, PowerOffSetting powerOff)
{
return base.GetUpdateEnergySettingsPacket(lowBatteryWarning / 25, powerOff);
}
protected override byte[] GetReadLightingModePacket(LightingZone zone)
{
return new byte[] { 0x00, 0x12, 0x03, 0x00 };
}
protected LightingSetting? ParseLightingSetting(byte[] packet, LightingZone zone)
{
if (packet[1] != 0x12 || packet[2] != 0x03)
{
return null;
}
int offset = 5 + (((int)zone) * 5);
LightingSetting setting = new LightingSetting();
setting.LightingMode = LightingModeForIndex(packet[offset + 0]);
setting.Brightness = packet[offset + 1];
setting.RGBColor = Color.FromArgb(packet[offset + 2], packet[offset + 3], packet[offset + 4]);
setting.AnimationDirection = SupportsAnimationDirection(setting.LightingMode)
? (AnimationDirection)packet[21]
: AnimationDirection.Clockwise;
if (setting.AnimationDirection != AnimationDirection.Clockwise
&& setting.AnimationDirection != AnimationDirection.CounterClockwise)
{
setting.AnimationDirection = AnimationDirection.Clockwise;
}
setting.RandomColor = SupportsRandomColor(setting.LightingMode) && packet[22] == 0x01;
setting.AnimationSpeed = SupportsAnimationSpeed(setting.LightingMode)
? (AnimationSpeed)packet[23]
: AnimationSpeed.Medium;
//If the mouse reports an out of range value, which it does when the current setting has no speed option, chose medium as default
if (setting.AnimationSpeed != AnimationSpeed.Fast
&& setting.AnimationSpeed != AnimationSpeed.Medium
&& setting.AnimationSpeed != AnimationSpeed.Slow)
{
setting.AnimationSpeed = AnimationSpeed.Medium;
}
return setting;
}
public override void ReadLightingSetting()
{
if (!HasRGB())
{
return;
}
//Mouse sends all lighting zones in one response
//21: Direction
//22: Random
//23: Speed
// 20 21 22 23
//00 12 03 00 00 [03 04 00 00 ff] [03 04 00 00 ff] [03 04 00 00 ff] 00 04 00 00
//00 12 03 00 00 [05 02 ff 00 ff] [05 02 ff 00 ff] [05 02 ff 00 ff] 00 01 01 00
//00 12 03 00 00 [03 01 00 00 ff] [03 01 00 00 ff] [03 01 00 00 ff] 00 01 00 01
byte[]? response = WriteForResponse(GetReadLightingModePacket(LightingZone.All));
if (response is null) return;
LightingZone[] lz = SupportedLightingZones();
for (int i = 0; i < lz.Length; ++i)
{
LightingSetting? ls = ParseLightingSetting(response, lz[i]);
if (ls is null)
{
Logger.WriteLine(GetDisplayName() + ": Failed to read RGB Setting for Zone " + lz[i].ToString());
continue;
}
Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
LightingSetting[i] = ls;
}
}
public override bool CanChangeDPIProfile()
{
return false;
}
}
public class PugioIIWired : PugioII
{
public PugioIIWired() : base(0x1906, false)
{
}
public override string GetDisplayName()
{
return "ROG Pugio II (Wired)";
}
}
}

View File

@@ -0,0 +1,197 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P513
public class ROGKerisWireless : AsusMouse
{
public ROGKerisWireless() : base(0x0B05, 0x1960, "mi_00", true)
{
}
protected ROGKerisWireless(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "ROG Keris (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 3;
}
public override int MaxDPI()
{
return 16_000;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override bool HasRGB()
{
return true;
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasAngleTuning()
{
return false;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override bool HasDPIColors()
{
return false;
}
public override bool IsLightingModeSupported(LightingMode lightingMode)
{
return lightingMode == LightingMode.Static
|| lightingMode == LightingMode.Breathing
|| lightingMode == LightingMode.ColorCycle
|| lightingMode == LightingMode.React
|| lightingMode == LightingMode.BatteryState
|| lightingMode == LightingMode.Off;
}
//Has 25% increments
protected override int ParseBattery(byte[] packet)
{
if (packet[1] == 0x12 && packet[2] == 0x07)
{
return packet[5] * 25;
}
return -1;
}
public override int DPIIncrements()
{
return 100;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool CanChangeDPIProfile()
{
return false;
}
protected override byte[] GetUpdateEnergySettingsPacket(int lowBatteryWarning, PowerOffSetting powerOff)
{
return base.GetUpdateEnergySettingsPacket(lowBatteryWarning / 25, powerOff);
}
protected override int ParseLowBatteryWarning(byte[] packet)
{
int lowBat = base.ParseLowBatteryWarning(packet);
return lowBat * 25;
}
protected override LiftOffDistance ParseLiftOffDistance(byte[] packet)
{
if (packet[1] != 0x12 || packet[2] != 0x06)
{
return LiftOffDistance.Low;
}
return (LiftOffDistance)packet[5];
}
protected override byte[] GetUpdateLiftOffDistancePacket(LiftOffDistance liftOffDistance)
{
return new byte[] { 0x00, 0x51, 0x35, 0x00, 0x00, ((byte)liftOffDistance) };
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel };
}
public override int MaxBrightness()
{
return 4;
}
protected override byte IndexForLightingMode(LightingMode lightingMode)
{
if (lightingMode == LightingMode.Off)
{
return 0xFF;
}
return ((byte)lightingMode);
}
}
public class ROGKerisWirelessWired : ROGKerisWireless
{
public ROGKerisWirelessWired() : base(0x195E, false)
{
}
public override string GetDisplayName()
{
return "ROG Keris (Wired)";
}
}
public class ROGKerisWirelessEvaEdition : ROGKerisWireless
{
public ROGKerisWirelessEvaEdition() : base(0x1A59, true)
{
}
public override string GetDisplayName()
{
return "ROG Keris EVA Edition";
}
}
public class ROGKerisWirelessEvaEditionWired : ROGKerisWireless
{
public ROGKerisWirelessEvaEditionWired() : base(0x1A57, false)
{
}
public override string GetDisplayName()
{
return "ROG Keris EVA Edition (Wired)";
}
}
}

View File

@@ -0,0 +1,226 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P513
public class StrixImpactIIWireless : AsusMouse
{
public StrixImpactIIWireless() : base(0x0B05, 0x1949, "mi_00", true)
{
}
protected StrixImpactIIWireless(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "ROG Strix Impact II (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 3;
}
public override int MaxDPI()
{
return 16_000;
}
public override bool HasLiftOffSetting()
{
return true;
}
public override bool HasRGB()
{
return true;
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasAngleTuning()
{
return false;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override bool HasDPIColors()
{
return false;
}
public override bool IsLightingModeSupported(LightingMode lightingMode)
{
return lightingMode == LightingMode.Static
|| lightingMode == LightingMode.Breathing
|| lightingMode == LightingMode.ColorCycle
|| lightingMode == LightingMode.React
|| lightingMode == LightingMode.BatteryState
|| lightingMode == LightingMode.Off;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel };
}
//Has 25% increments
protected override int ParseBattery(byte[] packet)
{
if (packet[1] == 0x12 && packet[2] == 0x07)
{
return packet[5] * 25;
}
return -1;
}
public override int DPIIncrements()
{
return 100;
}
public override bool CanChangeDPIProfile()
{
return false;
}
protected override byte[] GetUpdateEnergySettingsPacket(int lowBatteryWarning, PowerOffSetting powerOff)
{
return base.GetUpdateEnergySettingsPacket(lowBatteryWarning / 25, powerOff);
}
protected override int ParseLowBatteryWarning(byte[] packet)
{
int lowBat = base.ParseLowBatteryWarning(packet);
return lowBat * 25;
}
protected override LiftOffDistance ParseLiftOffDistance(byte[] packet)
{
if (packet[1] != 0x12 || packet[2] != 0x06)
{
return LiftOffDistance.Low;
}
return (LiftOffDistance)packet[5];
}
protected override byte[] GetUpdateLiftOffDistancePacket(LiftOffDistance liftOffDistance)
{
return new byte[] { 0x00, 0x51, 0x35, 0x00, 0x00, ((byte)liftOffDistance) };
}
public override int MaxBrightness()
{
return 4;
}
public override bool HasDebounceSetting()
{
return true;
}
protected override byte IndexForLightingMode(LightingMode lightingMode)
{
if (lightingMode == LightingMode.Off)
{
return 0xFF;
}
return ((byte)lightingMode);
}
protected override byte[] GetReadLightingModePacket(LightingZone zone)
{
return new byte[] { 0x00, 0x12, 0x03, 0x00 };
}
protected LightingSetting? ParseLightingSetting(byte[] packet, LightingZone zone)
{
if (packet[1] != 0x12 || packet[2] != 0x03)
{
return null;
}
int offset = 5 + (((int)zone) * 5);
LightingSetting setting = new LightingSetting();
setting.LightingMode = LightingModeForIndex(packet[offset + 0]);
setting.Brightness = packet[offset + 1];
setting.RGBColor = Color.FromArgb(packet[offset + 2], packet[offset + 3], packet[offset + 4]);
return setting;
}
public override void ReadLightingSetting()
{
if (!HasRGB())
{
return;
}
//Mouse sends all lighting zones in one response
//00 12 03 00 00 [00 04 ff 00 80] [00 04 00 ff ff] [00 04 ff ff ff] 00 00 00 00 00 00 00 00 00 00 00 00 00 0
//No idea what the 3rd zone is as the mouse only has 2
byte[]? response = WriteForResponse(GetReadLightingModePacket(LightingZone.All));
if (response is null) return;
LightingZone[] lz = SupportedLightingZones();
for (int i = 0; i < lz.Length; ++i)
{
LightingSetting? ls = ParseLightingSetting(response, lz[i]);
if (ls is null)
{
Logger.WriteLine(GetDisplayName() + ": Failed to read RGB Setting for Zone " + lz[i].ToString());
continue;
}
Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
LightingSetting[i] = ls;
}
}
}
public class StrixImpactIIWirelessWired : StrixImpactIIWireless
{
public StrixImpactIIWirelessWired() : base(0x1947, false)
{
}
public override string GetDisplayName()
{
return "ROG Strix Impact II (Wired)";
}
}
}

View File

@@ -0,0 +1,112 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P306_Wireless
public class TUFM3 : AsusMouse
{
public TUFM3() : base(0x0B05, 0x1910, "mi_01", false)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "TUF GAMING M3";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
//Mouse has React mapped to 0x03 instead of 0x04 like other mice
protected override byte IndexForLightingMode(LightingMode lightingMode)
{
if (lightingMode == LightingMode.React)
{
return 0x03;
}
return ((byte)lightingMode);
}
//Mouse has React mapped to 0x03 instead of 0x04 like other mice
protected override LightingMode LightingModeForIndex(byte lightingMode)
{
if (lightingMode == 0x03)
{
return LightingMode.React;
}
return base.LightingModeForIndex(lightingMode);
}
public override int ProfileCount()
{
return 1;
}
public override int MaxDPI()
{
return 7_000;
}
public override bool HasBattery()
{
return false;
}
public override bool HasLiftOffSetting()
{
return false;
}
public override LightingZone[] SupportedLightingZones()
{
return new LightingZone[] { LightingZone.Logo };
}
public override bool HasRGB()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override int DPIIncrements()
{
return 100;
}
public override bool CanChangeDPIProfile()
{
return true;
}
public override bool HasDebounceSetting()
{
return true;
}
public override int MaxBrightness()
{
return 4;
}
public override bool IsLightingModeSupported(LightingMode lightingMode)
{
return lightingMode == LightingMode.Static
|| lightingMode == LightingMode.Breathing
|| lightingMode == LightingMode.ColorCycle
|| lightingMode == LightingMode.React;
}
}
}

View File

@@ -0,0 +1,85 @@
namespace GHelper.Peripherals.Mouse.Models
{
//P306_Wireless
public class TUFM4Wirelss : AsusMouse
{
public TUFM4Wirelss() : base(0x0B05, 0x19F4, "mi_00", true)
{
}
public override int DPIProfileCount()
{
return 4;
}
public override string GetDisplayName()
{
return "TUF GAMING M4 (Wireless)";
}
public override PollingRate[] SupportedPollingrates()
{
return new PollingRate[] {
PollingRate.PR125Hz,
PollingRate.PR250Hz,
PollingRate.PR500Hz,
PollingRate.PR1000Hz
};
}
public override int ProfileCount()
{
return 3;
}
public override int MaxDPI()
{
return 12_000;
}
public override bool HasLiftOffSetting()
{
return false;
}
public override bool HasDebounceSetting()
{
return true;
}
public override bool HasAutoPowerOff()
{
return true;
}
public override bool HasAngleSnapping()
{
return true;
}
public override bool HasAngleTuning()
{
return false;
}
public override bool HasLowBatteryWarning()
{
return true;
}
public override bool HasDPIColors()
{
return false;
}
public override int DPIIncrements()
{
return 100;
}
public override bool CanChangeDPIProfile()
{
return true;
}
}
}

View File

@@ -0,0 +1,240 @@
using GHelper.Peripherals.Mouse;
using GHelper.Peripherals.Mouse.Models;
using System.Runtime.CompilerServices;
namespace GHelper.Peripherals
{
public class PeripheralsProvider
{
private static readonly object _LOCK = new object();
public static List<AsusMouse> ConnectedMice = new List<AsusMouse>();
public static event EventHandler? DeviceChanged;
private static System.Timers.Timer timer = new System.Timers.Timer(1000);
static PeripheralsProvider()
{
timer.Elapsed += DeviceTimer_Elapsed;
}
private static long lastRefresh;
public static bool IsMouseConnected()
{
lock (_LOCK)
{
return ConnectedMice.Count > 0;
}
}
public static bool IsDeviceConnected(IPeripheral peripheral)
{
return AllPeripherals().Contains(peripheral);
}
//Expand if keyboards or other device get supported later.
public static bool IsAnyPeripheralConnect()
{
return IsMouseConnected();
}
public static List<IPeripheral> AllPeripherals()
{
List<IPeripheral> l = new List<IPeripheral>();
lock (_LOCK)
{
l.AddRange(ConnectedMice);
}
return l;
}
public static void RefreshBatteryForAllDevices()
{
RefreshBatteryForAllDevices(false);
}
public static void RefreshBatteryForAllDevices(bool force)
{
//Polling the battery every 20s should be enough
if (!force && Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastRefresh) < 20_000) return;
lastRefresh = DateTimeOffset.Now.ToUnixTimeMilliseconds();
List<IPeripheral> l = AllPeripherals();
foreach (IPeripheral m in l)
{
if (!m.IsDeviceReady)
{
//Try to sync the device if that hasn't been done yet
m.SynchronizeDevice();
}
else
{
m.ReadBattery();
}
}
}
public static void Disconnect(AsusMouse am)
{
lock (_LOCK)
{
am.Disconnect -= Mouse_Disconnect;
am.MouseReadyChanged -= MouseReadyChanged;
am.BatteryUpdated -= BatteryUpdated;
ConnectedMice.Remove(am);
}
if (DeviceChanged is not null)
{
DeviceChanged(am, EventArgs.Empty);
}
}
public static void Connect(AsusMouse am)
{
if (IsDeviceConnected(am))
{
//Mouse already connected;
return;
}
try
{
am.Connect();
}
catch (IOException e)
{
Logger.WriteLine(am.GetDisplayName() + " failed to connect to device: " + e);
return;
}
//The Mouse might needs a few ms to register all its subdevices or the sync will fail.
//Retry 3 times. Do not call this on main thread! It would block the UI
int tries = 0;
while (!am.IsDeviceReady && tries < 3)
{
Thread.Sleep(250);
Logger.WriteLine(am.GetDisplayName() + " synchronising. Try " + (tries + 1));
am.SynchronizeDevice();
++tries;
}
lock (_LOCK)
{
ConnectedMice.Add(am);
}
Logger.WriteLine(am.GetDisplayName() + " added to the list: " + ConnectedMice.Count + " device are conneted.");
am.Disconnect += Mouse_Disconnect;
am.MouseReadyChanged += MouseReadyChanged;
am.BatteryUpdated += BatteryUpdated;
if (DeviceChanged is not null)
{
DeviceChanged(am, EventArgs.Empty);
}
UpdateSettingsView();
}
private static void BatteryUpdated(object? sender, EventArgs e)
{
UpdateSettingsView();
}
private static void MouseReadyChanged(object? sender, EventArgs e)
{
UpdateSettingsView();
}
private static void Mouse_Disconnect(object? sender, EventArgs e)
{
if (sender is null)
{
return;
}
AsusMouse am = (AsusMouse)sender;
lock (_LOCK)
{
ConnectedMice.Remove(am);
}
Logger.WriteLine(am.GetDisplayName() + " reported disconnect. " + ConnectedMice.Count + " device are conneted.");
am.Dispose();
UpdateSettingsView();
}
private static void UpdateSettingsView()
{
Program.settingsForm.Invoke(delegate
{
Program.settingsForm.VisualizePeripherals();
});
}
[MethodImpl(MethodImplOptions.Synchronized)]
public static void DetectAllAsusMice()
{
//Add one line for every supported mouse class here to support them.
DetectMouse(new ChakramX());
DetectMouse(new ChakramXWired());
DetectMouse(new GladiusIIIAimpoint());
DetectMouse(new GladiusIIIAimpointWired());
DetectMouse(new ROGKerisWireless());
DetectMouse(new ROGKerisWirelessWired());
DetectMouse(new ROGKerisWirelessEvaEdition());
DetectMouse(new ROGKerisWirelessEvaEditionWired());
DetectMouse(new TUFM4Wirelss());
DetectMouse(new StrixImpactIIWireless());
DetectMouse(new StrixImpactIIWirelessWired());
DetectMouse(new GladiusIII());
DetectMouse(new GladiusIIIWired());
DetectMouse(new HarpeAceAimLabEdition());
DetectMouse(new HarpeAceAimLabEditionWired());
DetectMouse(new HarpeAceAimLabEditionOmni());
DetectMouse(new TUFM3());
DetectMouse(new KerisWirelssAimpoint());
DetectMouse(new KerisWirelssAimpointWired());
DetectMouse(new PugioII());
DetectMouse(new PugioIIWired());
}
public static void DetectMouse(AsusMouse am)
{
if (am.IsDeviceConnected() && !IsDeviceConnected(am))
{
Logger.WriteLine("Detected a new" + am.GetDisplayName() + " . Connecting...");
Connect(am);
}
}
public static void RegisterForDeviceEvents()
{
HidSharp.DeviceList.Local.Changed += Device_Changed;
}
public static void UnregisterForDeviceEvents()
{
HidSharp.DeviceList.Local.Changed -= Device_Changed;
}
private static void Device_Changed(object? sender, HidSharp.DeviceListChangedEventArgs e)
{
timer.Start();
}
private static void DeviceTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
{
timer.Stop();
Logger.WriteLine("HID Device Event: Checking for new ASUS Mice");
DetectAllAsusMice();
}
}
}

Some files were not shown because too many files have changed in this diff Show More