Update InputDispatcher.cs

Added shortcut for activating XGM (ctrl+alt+shift+F21) and deactivating XGM  (ctrl+alt+shift+F22)

.github/FUNDING.yml

@@ -1,13 +1,2 @@
 # 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
+custom: https://g-helper.com/support

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,42 +0,0 @@
----
-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 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.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,88 @@
+name: Bug Report
+description: Something isn't working correctly
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report. The more information you provide, the easier it will be for me to fix it!
+  - type: checkboxes
+    id: rules
+    attributes:
+      label: Rules
+      options:
+        - label: I made myself familiar with the <a href='https://github.com/seerge/g-helper?tab=readme-ov-file'>Readme</a>, <a href='https://github.com/seerge/g-helper/wiki/FAQ'>FAQ</a> and <a href='https://github.com/seerge/g-helper/wiki/Troubleshooting'>Troubleshooting</a>.
+          required: true
+        - label: I understand that, if insufficient information or no app logs will be provided, my issue will be closed without an answer.
+          required: true
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: What's wrong?
+      description: Provide detailed description of what is wrong or does not work as expected.
+      placeholder: Provide detailed description of what is wrong or does not work as expected.
+    validations:
+      required: true
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: How to reproduce the bug?
+      description: Describe how to reproduce the behavior. Be as specific as possible and provide as many details as possible.
+      placeholder: |
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. See error
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs
+      placeholder: Please drag and drop complete log file from ``%APPDATA%\GHelper\log.txt``
+      description: Please drag and drop complete log file from ``%APPDATA%\GHelper\log.txt``
+    validations:
+      required: true
+  - type: input
+    id: device
+    attributes:
+      label: Device and Model
+      description: Which laptop do you use?
+      placeholder: e.g. Asus Zephyrus G14 GA404RK
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional information. 
+      description: If applicable, add screenshots or other relevant information to help explain your problem.
+  - type: dropdown
+    id: armoury
+    attributes:
+      label: Armoury Crate
+      description: Do you have Armoury Crate installed?
+      options:
+        - Uninstalled
+        - Installed
+        - Never installed
+      default: 0   
+  - type: input
+    id: asus
+    attributes:
+      label: Asus Services
+      description: How many Asus services do you have running (check ``Extra`` section in G-Helper)?
+      placeholder: e.g. None
+  - type: input
+    id: version
+    attributes:
+      label: Version
+      description: G-Helper version?
+      placeholder: e.g. 0.146
+  - type: input
+    id: os
+    attributes:
+      label: OS
+      description: Which operating system do you use?
+      placeholder: e.g. Windows 11 21H2     
+          

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-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.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,46 @@
+name: Feature request
+description: Suggest an idea for this project
+body:
+  - type: checkboxes
+    id: rules
+    attributes:
+      label: Rules
+      options:
+        - label: I made myself familiar with the <a href='https://github.com/seerge/g-helper?tab=readme-ov-file'>Readme</a>, <a href='https://github.com/seerge/g-helper/wiki/FAQ'>FAQ</a> and <a href='https://github.com/seerge/g-helper/wiki/Troubleshooting'>Troubleshooting</a>.
+          required: true
+        - label: I understand that, if insufficient information will be provided, my issue will be closed without an answer.
+          required: true
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: Is your feature request related to a problem? Please describe
+      placeholder: A clear and concise description of what the problem is.
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: Describe the solution you'd like
+      placeholder: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Describe alternatives you've considered
+      placeholder: A clear and concise description of any alternative solutions or features you've considered.
+  - type: input
+    id: device
+    attributes:
+      label: Device and Model
+      description: Which laptop do you use?
+      placeholder: e.g. Asus Zephyrus G14 GA404RK
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional information. 
+      placeholder: If applicable, add screenshots or other relevant information          

.github/ISSUE_TEMPLATE/peripherals_request.yml

@@ -0,0 +1,31 @@
+name: Mouse and other peripherals support request
+description: Request support for a new device
+body:
+  - type: input
+    id: device
+    attributes:
+      label: Mouse / peripheral model and version
+      placeholder: e.g. Asus TUF M4 Wireless
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: Armoury Crate Screenshots
+      description: Connect your mouse to Armoury Crate (maybe in a VM if you do not want to install it on your PC) and upload here screenshots of all the pages for your mouse for settings.
+      placeholder: Drag and drop screenshots here
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: USB Details
+      description: Also, please use <a href=https://www.uwe-sieber.de/usbtreeview.html>USB Tree View</a> and send the text (especially the block with all the child devices) of the mouse. <img width="1168" alt="image" src="https://github.com/seerge/g-helper/assets/12786283/8b51dd4d-c9fe-444e-b1b1-415175e10555">
+      placeholder: USB Tree View details
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional information. 
+      placeholder: If applicable, add screenshots or other relevant information          

.github/SECURITY.md

@@ -4,8 +4,8 @@
 
 | Version | Supported          |
 | ------- | ------------------ |
-| 0.89+   | :white_check_mark: |
-| < 0.89  | :x:                |
+| 0.170+   | :white_check_mark: |
+| < 0.170  | :x:                |
 
 ## Reporting a Vulnerability
 

.github/workflows/build.yml

@@ -19,7 +19,7 @@ jobs:
       uses: actions/setup-dotnet@v3
       with:
         dotnet-version: |
-          7.0.x
+          8.0.x
     - name: Build
       run: |
         dotnet build app/GHelper.sln

.github/workflows/release.yml

@@ -3,6 +3,8 @@ name: Release
 on:
   release:
     types: [ published ]
+  workflow_dispatch:
+  
 
 permissions:
   contents: write
@@ -16,13 +18,13 @@ jobs:
       uses: actions/setup-dotnet@v3
       with:
         dotnet-version: |
-          7.0.x
+          8.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-windows8.0/win-x64/publish/* GHelper.zip
+        powershell Compress-Archive app/bin/x64/Release/net8.0-windows/win-x64/publish/GHelper.exe GHelper.zip
     - name: Upload
       env:
         GH_TOKEN: ${{ github.token }}
       run: |
-        gh release upload ${{ github.ref_name }} GHelper.zip
+        gh release upload ${{ github.ref_name }} app/bin/x64/Release/net8.0-windows/win-x64/publish/GHelper.exe GHelper.zip

LICENSE

@@ -1,21 +1,674 @@
-MIT License
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
 
-Copyright (c) 2023 Serge
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-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:
+                            Preamble
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
 
-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.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

app/Ally/AllyControl.cs

@@ -0,0 +1,731 @@
+using GHelper.Gpu.AMD;
+using GHelper.Helpers;
+using GHelper.Input;
+using GHelper.Mode;
+using GHelper.USB;
+using HidSharp;
+using System.Text;
+
+
+
+namespace GHelper.Ally
+{
+
+    public enum ControllerMode : int
+    {
+        Auto = 0,
+        Gamepad = 1,
+        WASD = 2,
+        Mouse = 3,
+        Skip = -1,
+    }
+
+    public enum BindingZone : byte
+    {
+        DPadUpDown = 1,
+        DPadLeftRight = 2,
+        StickClick = 3,
+        Bumper = 4,
+        AB = 5,
+        XY = 6,
+        ViewMenu = 7,
+        M1M2 = 8,
+        Trigger = 9
+    }
+
+    public class AllyControl
+    {
+        static System.Timers.Timer timer = default!;
+        static AmdGpuControl amdControl = new AmdGpuControl();
+
+        SettingsForm settings;
+
+        static ControllerMode _mode = ControllerMode.Auto;
+        static ControllerMode _applyMode = ControllerMode.Mouse;
+
+        static int _autoCount = 0;
+
+        static int _upCount = 0;
+        static int _downCount = 0;
+
+        static int tdpMin = 6;
+        static int tdpStable = tdpMin;
+        static int tdpCurrent = -1;
+
+        static bool autoTDP = false;
+
+        static int fpsLimit = -1;
+
+
+        public const string BindA = "01-01";
+        public const string BindB = "01-02";
+        public const string BindX = "01-03";
+        public const string BindY = "01-04";
+        public const string BindLB = "01-05";
+        public const string BindRB = "01-06";
+        public const string BindLS = "01-07";
+        public const string BindRS = "01-08";
+        public const string BindDU = "01-09";
+        public const string BindDD = "01-0A";
+        public const string BindDL = "01-0B";
+        public const string BindDR = "01-0C";
+        public const string BindVB = "01-11";
+        public const string BindMB = "01-12";
+        public const string BindM1 = "02-8F";
+        public const string BindM2 = "02-8E";
+        public const string BindLT = "01-0D";
+        public const string BindRT = "01-0E";
+        public const string BindXB = "01-13";
+
+        public const string BindMouseL = "03-01";
+        public const string BindMouseR = "03-02";
+
+        public const string BindKBU = "02-98";
+        public const string BindKBD = "02-99";
+        public const string BindKBL = "02-9A";
+        public const string BindKBR = "02-9B";
+
+        public const string BindTab = "02-0D";
+        public const string BindEnter = "02-5A";
+        public const string BindBack = "02-66";
+        public const string BindEsc = "02-76";
+
+        public const string BindPgU = "02-96";
+        public const string BindPgD = "02-97";
+
+        public const string BindShift = "02-88";
+        public const string BindCtrl = "02-8C";
+        public const string BindAlt = "02-8A";
+        public const string BindWin = "02-82";
+
+        public const string BindTaskManager = "04-03-8C-88-76";
+        public const string BindCloseWindow = "04-02-8A-0C";
+
+        public const string BindBrightnessDown = "04-04-8C-88-8A-05";
+        public const string BindBrightnessUp = "04-04-8C-88-8A-06";
+        public const string BindXGM = "04-04-8C-88-8A-04";
+        public const string BindToggleMode = "04-04-8C-88-8A-0C";
+
+        public const string BindOverlay = "04-03-8C-88-44";
+
+        public const string BindShiftTab = "04-02-88-0D";
+        public const string BindAltTab = "04-02-8A-0D";
+
+        public const string BindVolUp = "05-03";
+        public const string BindVolDown = "05-02";
+
+        public const string BindPrintScrn = "02-C3";
+
+        public const string BindScreenshot = "04-03-82-88-1B";
+        public const string BindShowDesktop = "04-02-82-23";
+
+        public const string BindShowKeyboard = "05-19";
+
+        static byte[] CommandReady = new byte[] { AsusHid.INPUT_ID, 0xD1, 0x0A, 0x01 };
+        static byte[] CommandSave = new byte[] { AsusHid.INPUT_ID, 0xD1, 0x0F, 0x20 };
+
+        public static Dictionary<string, string> BindCodes = new Dictionary<string, string>
+        {
+            { "", "--------" },
+            { "00-00", "[ Disabled ]" },
+
+            { BindM1, "M1" },
+            { BindM2, "M2" },
+
+            { BindA, "A" },
+            { BindB, "B" },
+
+            { BindX, "X" },
+            { BindY, "Y" },
+
+            { BindLB, "Left Bumper" },
+            { BindRB, "Right Bumper" },
+
+            { BindLS, "Left Stick Click" },
+            { BindRS, "Right Stick Click" },
+
+            { BindDU, "DPad Up" },
+            { BindDD, "DPad Down" },
+
+            { BindDL, "DPad Left" },
+            { BindDR, "DPad Right" },
+
+            { BindVB, "View Button" },
+            { BindMB, "Menu Button" },
+
+            { BindXB, "XBox/Steam" },
+
+            { BindToggleMode, "Controller Mode" },
+
+            { BindVolUp, "Vol Up" },
+            { BindVolDown, "Vol Down" },
+            { BindBrightnessUp, "Bright Up" },
+            { BindBrightnessDown, "Bright Down" },
+
+            { BindShowKeyboard, "Show Keyboard" },
+            { BindShowDesktop, "Show Desktop" },
+            { BindScreenshot, "Screenshot" },
+
+            { BindOverlay, "AMD Overlay" },
+            { BindTaskManager, "Task Manager" },
+            { BindCloseWindow, "Close Window" },
+            { BindShiftTab, "Shift-Tab" },
+            { BindAltTab, "Alt-Tab" },
+            { BindXGM, "XGM Toggle" },
+
+
+            { BindEsc, "Esc" },
+            { BindBack, "Backspace" },
+            { BindTab, "Tab" },
+            { BindEnter, "Enter" },
+            { BindShift, "LShift" },
+            { BindAlt, "LAlt" },
+            { BindCtrl, "LCtl" },
+            { BindWin, "WIN" },
+            { BindPrintScrn, "PrntScn" },
+
+            { BindPgU, "PgUp" },
+            { BindPgD, "PgDwn" },
+            { BindKBU, "UpArrow" },
+            { BindKBD, "DownArrow" },
+            { BindKBL, "LeftArrow" },
+            { BindKBR, "RightArrow" },
+
+            { "02-05", "F1" },
+            { "02-06", "F2" },
+            { "02-04", "F3" },
+            { "02-0C", "F4" },
+            { "02-03", "F5" },
+            { "02-0B", "F6" },
+            { "02-80", "F7" },
+            { "02-0A", "F8" },
+            { "02-01", "F9" },
+            { "02-09", "F10" },
+            { "02-78", "F11" },
+            { "02-07", "F12" },
+            { "02-0E", "`" },
+            { "02-16", "1" },
+            { "02-1E", "2" },
+            { "02-26", "3" },
+            { "02-25", "4" },
+            { "02-2E", "5" },
+            { "02-36", "6" },
+            { "02-3D", "7" },
+            { "02-3E", "8" },
+            { "02-46", "9" },
+            { "02-45", "0" },
+            { "02-4E", "-" },
+            { "02-55", "=" },
+            { "02-15", "Q" },
+            { "02-1D", "W" },
+            { "02-24", "E" },
+            { "02-2D", "R" },
+            { "02-2C", "T" },
+            { "02-35", "Y" },
+            { "02-3C", "U" },
+            { "02-44", "O" },
+            { "02-4D", "P" },
+            { "02-54", "[" },
+            { "02-5B", "]" },
+            { "02-5D", "|" },
+            { "02-58", "Caps" },
+            { "02-1C", "A" },
+            { "02-1B", "S" },
+            { "02-23", "D" },
+            { "02-2B", "F" },
+            { "02-34", "G" },
+            { "02-33", "H" },
+            { "02-3B", "J" },
+            { "02-42", "k" },
+            { "02-4B", "l" },
+            { "02-4C", ";" },
+            { "02-52", "'" },
+            { "02-22", "X" },
+            { "02-1A", "Z" },
+            { "02-21", "C" },
+            { "02-2A", "V" },
+            { "02-32", "B" },
+            { "02-31", "N" },
+            { "02-3A", "M" },
+            { "02-41", "," },
+            { "02-49", "." },
+            { "02-89", "RShift" },
+            { "02-29", "Space" },
+            { "02-8B", "RAlt" },
+            { "02-84", "App menu" },
+            { "02-8D", "RCtl" },
+            { "02-7E", "ScrLk" },
+            { "02-C2", "Insert" },
+            { "02-C0", "Delete" },
+            { "02-94", "Home" },
+            { "02-95", "End" },
+            { "02-77", "NumLock" },
+            { "02-90", "NumSlash" },
+            { "02-7C", "NumStar" },
+            { "02-7B", "NumHyphen" },
+            { "02-70", "Num0" },
+            { "02-69", "Num1" },
+            { "02-72", "Num2" },
+            { "02-7A", "Num3" },
+            { "02-6B", "Num4" },
+            { "02-73", "Num5" },
+            { "02-74", "Num6" },
+            { "02-6C", "Num7" },
+            { "02-75", "Num8" },
+            { "02-7D", "Num9" },
+            { "02-79", "NumPlus" },
+            { "02-81", "NumEnter" },
+            { "02-71", "NumPeriod" },
+
+            { BindMouseL, "Mouse left click" },
+            { BindMouseR, "Mouse right click" },
+            { "03-03", "Mouse middle click" },
+            { "03-04", "Mouse scroll up" },
+            { "03-05", "Mouse scroll down" },
+
+            //{ "05-16", "Screenshot" },
+            //{ "05-1C", "Show desktop" },
+
+            { "05-1E", "Begin recording" },
+            { "05-01", "Mic off" },
+
+        };
+
+        public AllyControl(SettingsForm settingsForm)
+        {
+            if (!AppConfig.IsAlly()) return;
+            settings = settingsForm;
+
+            if (timer is null)
+            {
+                timer = new System.Timers.Timer(300);
+                timer.Elapsed += Timer_Elapsed;
+                Logger.WriteLine("Ally timer");
+            }
+        }
+
+        private int GetMaxTDP()
+        {
+            int tdp = AppConfig.GetMode("limit_total");
+            if (tdp > 0) return tdp;
+            switch (Modes.GetCurrentBase())
+            {
+                case 1:
+                    return 25;
+                case 2:
+                    return 10;
+                default:
+                    return 15;
+            }
+        }
+
+        private int GetTDP()
+        {
+            if (tdpCurrent < 0) tdpCurrent = GetMaxTDP();
+            return tdpCurrent;
+        }
+
+        private void SetTDP(int tdp, string log)
+        {
+            if (tdp < tdpStable) tdp = tdpStable;
+
+            int max = GetMaxTDP();
+            if (tdp > max) tdp = max;
+
+            if (tdp == tdpCurrent) return;
+            if (!autoTDP) return;
+
+            Program.acpi.DeviceSet(AsusACPI.PPT_APUA0, tdp, log);
+            Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, tdp, null);
+            Program.acpi.DeviceSet(AsusACPI.PPT_APUC1, tdp, null);
+
+            tdpCurrent = tdp;
+        }
+
+        private void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            if (!autoTDP && _mode != ControllerMode.Auto) return;
+
+            float fps = amdControl.GetFPS();
+            int? usage = 0;
+
+            if (autoTDP && fpsLimit > 0 && fpsLimit <= 120)
+            {
+                int power = (int)amdControl.GetGpuPower();
+                //Debug.WriteLine($"{power}: {fps}");
+
+                if (fps <= Math.Min(fpsLimit * 0.9, fpsLimit - 4)) _upCount++;
+                else _upCount = 0;
+
+                if (fps >= Math.Min(fpsLimit * 0.95, fpsLimit - 2)) _downCount++;
+                else _downCount = 0;
+
+                var tdp = GetTDP();
+                if (_upCount >= 1)
+                {
+                    _downCount = 0;
+                    _upCount = 0;
+                    SetTDP(tdp + 1, $"AutoTDP+ [{power}]{fps}");
+                }
+
+                if (_downCount >= 8 && power < tdp)
+                {
+                    _upCount = 0;
+                    _downCount--;
+                    SetTDP(tdp - 1, $"AutoTDP- [{power}]{fps}");
+                }
+            }
+
+            if (_mode == ControllerMode.Auto)
+            {
+                if (fps > 0) usage = amdControl.GetiGpuUse();
+                ControllerMode newMode = (fps > 0 && usage > 15) ? ControllerMode.Gamepad : ControllerMode.Mouse;
+
+                if (_applyMode != newMode) _autoCount++;
+                else _autoCount = 0;
+
+                if (_autoCount == 3)
+                {
+                    _autoCount = 0;
+                    ApplyMode(newMode);
+                    Logger.WriteLine($"Controller Mode (FPS={fps}, USAGE={usage}%): {newMode}");
+                }
+            }
+
+        }
+
+        public void ToggleAutoTDP()
+        {
+            autoTDP = !autoTDP;
+            tdpCurrent = -1;
+
+            if (!autoTDP)
+            {
+                Program.modeControl.SetPerformanceMode();
+            }
+
+            settings.VisualiseAutoTDP(autoTDP);
+
+        }
+
+        public void Init()
+        {
+            if (AppConfig.IsAlly()) settings.VisualiseAlly(true);
+            else return;
+
+            SetMode((ControllerMode)AppConfig.Get("controller_mode", (int)ControllerMode.Auto), true);
+
+            settings.VisualiseBacklight(InputDispatcher.GetBacklight());
+
+            fpsLimit = amdControl.GetFPSLimit();
+            settings.VisualiseFPSLimit(fpsLimit);
+        }
+
+        public void ToggleFPSLimit()
+        {
+            switch (fpsLimit)
+            {
+                case 30:
+                    fpsLimit = 40;
+                    break;
+                case 40:
+                    fpsLimit = 45;
+                    break;
+                case 45:
+                    fpsLimit = 50;
+                    break;
+                case 50:
+                    fpsLimit = 60;
+                    break;
+                case 60:
+                    fpsLimit = 90;
+                    break;
+                case 90:
+                    fpsLimit = 120;
+                    break;
+                case 120:
+                    fpsLimit = 240;
+                    break;
+                default:
+                    fpsLimit = 30;
+                    break;
+            }
+
+            int result = amdControl.SetFPSLimit(fpsLimit);
+            Logger.WriteLine($"FPS Limit {fpsLimit}: {result}");
+
+            settings.VisualiseFPSLimit(fpsLimit);
+
+        }
+
+
+        public void ToggleBacklight()
+        {
+            InputDispatcher.SetBacklight(4, true);
+            settings.VisualiseBacklight(InputDispatcher.GetBacklight());
+        }
+
+        static private byte[] DecodeBinding(string binding = "")
+        {
+            byte[] bytes;
+
+            if (binding == "" || binding is null) return new byte[2];
+
+            try
+            {
+                bytes = AppConfig.StringToBytes(binding);
+            }
+            catch
+            {
+                return new byte[2];
+            }
+
+            byte[] code = new byte[10];
+            code[0] = bytes[0];
+
+            switch (bytes[0])
+            {
+                case 0x02:
+                    code[2] = bytes[1];
+                    break;
+                case 0x03:
+                    code[4] = bytes[1];
+                    break;
+                case 0x04:
+                    bytes.Skip(1).ToArray().CopyTo(code, 5);
+                    break;
+                case 0x05:
+                    code[3] = bytes[1];
+                    break;
+                default:
+                    code[1] = bytes[1];
+                    break;
+            }
+
+            return code;
+        }
+
+        static private void BindZone(BindingZone zone)
+        {
+            string KeyL1, KeyR1;
+            string KeyL2, KeyR2;
+
+            bool desktop = (_applyMode == ControllerMode.Mouse);
+
+            switch (zone)
+            {
+                case BindingZone.DPadUpDown:
+                    KeyL1 = AppConfig.GetString("bind_du", desktop ? BindKBU : BindDU);
+                    KeyR1 = AppConfig.GetString("bind_dd", desktop ? BindKBD : BindDD);
+                    KeyL2 = AppConfig.GetString("bind2_du", BindShowKeyboard);
+                    KeyR2 = AppConfig.GetString("bind2_dd", BindShowDesktop);
+                    break;
+                case BindingZone.DPadLeftRight:
+                    KeyL1 = AppConfig.GetString("bind_dl", desktop ? BindKBL : BindDL);
+                    KeyR1 = AppConfig.GetString("bind_dr", desktop ? BindKBR : BindDR);
+                    KeyL2 = AppConfig.GetString("bind2_dl", BindBrightnessDown);
+                    KeyR2 = AppConfig.GetString("bind2_dr", BindBrightnessUp);
+                    break;
+                case BindingZone.StickClick:
+                    KeyL1 = AppConfig.GetString("bind_ls", desktop ? BindShift : BindLS);
+                    KeyR1 = AppConfig.GetString("bind_rs", desktop ? BindMouseL : BindRS);
+                    KeyL2 = AppConfig.GetString("bind2_ls");
+                    KeyR2 = AppConfig.GetString("bind2_rs", BindToggleMode);
+                    break;
+                case BindingZone.Bumper:
+                    KeyL1 = AppConfig.GetString("bind_lb", desktop ? BindTab : BindLB);
+                    KeyR1 = AppConfig.GetString("bind_rb", desktop ? BindMouseL : BindRB);
+                    KeyL2 = AppConfig.GetString("bind2_lb");
+                    KeyR2 = AppConfig.GetString("bind2_rb");
+                    break;
+                case BindingZone.AB:
+                    KeyL1 = AppConfig.GetString("bind_a", desktop ? BindEnter : BindA);
+                    KeyR1 = AppConfig.GetString("bind_b", desktop ? BindEsc : BindB);
+                    KeyL2 = AppConfig.GetString("bind2_a");
+                    KeyR2 = AppConfig.GetString("bind2_b");
+                    break;
+                case BindingZone.XY:
+                    KeyL1 = AppConfig.GetString("bind_x", desktop ? BindPgD : BindX);
+                    KeyR1 = AppConfig.GetString("bind_y", desktop ? BindPgU : BindY);
+                    KeyL2 = AppConfig.GetString("bind2_x", BindScreenshot);
+                    KeyR2 = AppConfig.GetString("bind2_y", BindOverlay);
+                    break;
+                case BindingZone.ViewMenu:
+                    KeyL1 = AppConfig.GetString("bind_vb", BindVB);
+                    KeyR1 = AppConfig.GetString("bind_mb", BindMB);
+                    KeyL2 = AppConfig.GetString("bind2_vb");
+                    KeyR2 = AppConfig.GetString("bind2_mb");
+                    break;
+                case BindingZone.M1M2:
+                    KeyL1 = AppConfig.GetString("bind_m2", BindM2);
+                    KeyR1 = AppConfig.GetString("bind_m1", BindM1);
+                    KeyL2 = AppConfig.GetString("bind2_m2", BindM2);
+                    KeyR2 = AppConfig.GetString("bind2_m1", BindM1);
+                    break;
+                default:
+                    KeyL1 = AppConfig.GetString("bind_trl", desktop ? BindShiftTab : BindLT);
+                    KeyR1 = AppConfig.GetString("bind_trr", desktop ? BindMouseR : BindRT);
+                    KeyL2 = AppConfig.GetString("bind2_trl");
+                    KeyR2 = AppConfig.GetString("bind2_trr");
+                    break;
+            }
+
+            if (KeyL1 == "" && KeyR1 == "") return;
+
+            byte[] bindings = new byte[50];
+            byte[] init = new byte[] { AsusHid.INPUT_ID, 0xd1, 0x02, (byte)zone, 0x2c };
+
+            init.CopyTo(bindings, 0);
+
+            DecodeBinding(KeyL1).CopyTo(bindings, 5);
+            DecodeBinding(KeyL2).CopyTo(bindings, 16);
+
+            DecodeBinding(KeyR1).CopyTo(bindings, 27);
+            DecodeBinding(KeyR2).CopyTo(bindings, 38);
+
+            //AsusHid.WriteInput(CommandReady, null);
+            AsusHid.WriteInput(bindings, null);
+
+        }
+
+        static void WakeUp()
+        {
+            AsusHid.WriteInput(Encoding.ASCII.GetBytes("ZASUS Tech.Inc."), "Init");
+        }
+
+        static public void SetDeadzones()
+        {
+            AsusHid.WriteInput(new byte[] { AsusHid.INPUT_ID, 0xd1, 4, 4,
+                (byte)AppConfig.Get("ls_min", 0),
+                (byte)AppConfig.Get("ls_max", 100),
+                (byte)AppConfig.Get("rs_min", 0),
+                (byte)AppConfig.Get("rs_max", 100)
+            }, null);
+
+            AsusHid.WriteInput(new byte[] { AsusHid.INPUT_ID, 0xd1, 5, 4,
+                (byte)AppConfig.Get("lt_min", 0),
+                (byte)AppConfig.Get("lt_max", 100),
+                (byte)AppConfig.Get("rt_min", 0),
+                (byte)AppConfig.Get("rt_max", 100)
+            }, null);
+
+            AsusHid.WriteInput(new byte[] { AsusHid.INPUT_ID, 0xd1, 6, 2,
+                (byte)AppConfig.Get("vibra", 100),
+                (byte)AppConfig.Get("vibra", 100)
+            }, null);
+
+        }
+
+        public static void DisableXBoxController(bool disabled)
+        {
+            AsusHid.WriteInput([AsusHid.INPUT_ID, 0xD1, 0x0B, 0x01, disabled ? (byte)0x02 : (byte)0x01], $"ControllerDisabled: {disabled}");
+        }
+
+        public static void ApplyMode(ControllerMode applyMode = ControllerMode.Auto, bool init = false)
+        {
+            Task.Run(() =>
+            {
+
+                if (applyMode == ControllerMode.Skip) return;
+
+                HidStream? input = AsusHid.FindHidStream(AsusHid.INPUT_ID);
+                int count = 0;
+
+                while (input == null && count++ < 10)
+                {
+                    input = AsusHid.FindHidStream(AsusHid.INPUT_ID);
+                    Thread.Sleep(500);
+                }
+
+                if (input == null)
+                {
+                    Logger.WriteLine($"Controller not found");
+                    return;
+                }
+
+                if (applyMode != ControllerMode.Auto) _applyMode = applyMode;
+
+                if (init)
+                {
+                    WakeUp();
+                    InputDispatcher.SetBacklightAuto();
+                }
+
+                AsusHid.WriteInput([AsusHid.INPUT_ID, 0xD1, 0x01, 0x01, (byte)_applyMode], "Controller");
+                //AsusHid.WriteInput(CommandSave, null);
+
+                BindZone(BindingZone.M1M2);
+                BindZone(BindingZone.DPadUpDown);
+                BindZone(BindingZone.DPadLeftRight);
+                BindZone(BindingZone.StickClick);
+                BindZone(BindingZone.Bumper);
+                BindZone(BindingZone.AB);
+                BindZone(BindingZone.XY);
+                BindZone(BindingZone.ViewMenu);
+                BindZone(BindingZone.Trigger);
+
+                AsusHid.WriteInput(CommandSave, null);
+
+                SetDeadzones();
+
+                if (init && AppConfig.Is("controller_disabled"))
+                {
+                    Thread.Sleep(500);
+                    DisableXBoxController(false);
+                    DisableXBoxController(true);
+                }
+
+            });
+        }
+
+        private void SetMode(ControllerMode mode, bool init = false)
+        {
+
+            _mode = mode;
+            AppConfig.Set("controller_mode", (int)mode);
+
+            amdControl.StopFPS();
+            ApplyMode(mode, init);
+
+            amdControl.StartFPS();
+            timer.Start();
+
+            settings.VisualiseController(mode);
+        }
+
+
+        public void ToggleModeHotkey()
+        {
+            if (_applyMode == ControllerMode.Gamepad)
+            {
+                SetMode(ControllerMode.Mouse);
+                Program.toast.RunToast("Mouse", ToastIcon.Controller);
+            }
+            else
+            {
+                SetMode(ControllerMode.Gamepad);
+                Program.toast.RunToast("Gamepad", ToastIcon.Controller);
+            }
+        }
+
+        public void ToggleMode()
+        {
+            switch (_mode)
+            {
+                case ControllerMode.Auto:
+                    SetMode(ControllerMode.Gamepad);
+                    break;
+                case ControllerMode.Gamepad:
+                    SetMode(ControllerMode.Mouse);
+                    break;
+                case ControllerMode.Mouse:
+                    SetMode(ControllerMode.Skip);
+                    break;
+                case ControllerMode.Skip:
+                    SetMode(ControllerMode.Auto);
+                    break;
+            }
+        }
+
+    }
+}

app/AnimeMatrix/AniMatrixControl.cs

@@ -1,25 +1,34 @@
 using NAudio.CoreAudioApi;
 using NAudio.Wave;
-using Starlight.AnimeMatrix;
 using System.Diagnostics;
+using System.Drawing.Drawing2D;
 using System.Drawing.Imaging;
 using System.Timers;
 
 namespace GHelper.AnimeMatrix
 {
 
-    public class AniMatrixControl
+    public class AniMatrixControl : NAudio.CoreAudioApi.Interfaces.IMMNotificationClient
     {
 
         SettingsForm settings;
 
         System.Timers.Timer matrixTimer = default!;
-        AnimeMatrixDevice? mat;
+        System.Timers.Timer slashTimer = default!;
+
+        public AnimeMatrixDevice? deviceMatrix;
+        public SlashDevice? deviceSlash;
+
+        public static bool lidClose = false;
+        private static bool _wakeUp = false;
 
         double[]? AudioValues;
         WasapiCapture? AudioDevice;
+        string? AudioDeviceId;
+        private MMDeviceEnumerator? AudioDeviceEnum;
 
-        public bool IsValid => mat != null;
+        public bool IsValid => deviceMatrix != null || deviceSlash != null;
+        public bool IsSlash => deviceSlash != null;
 
         private long lastPresent;
         private List<double> maxes = new List<double>();
@@ -27,78 +36,215 @@ namespace GHelper.AnimeMatrix
         public AniMatrixControl(SettingsForm settingsForm)
         {
             settings = settingsForm;
-
+            if (!AppConfig.IsSlash() && !AppConfig.IsAnimeMatrix()) return;
+            
             try
             {
-                mat = new AnimeMatrixDevice();
-                Task.Run(mat.WakeUp);
+                if (AppConfig.IsSlash())
+                {
+                    if (AppConfig.IsSlashAura())
+                        deviceSlash = new SlashDeviceAura();
+                    else
+                        deviceSlash = new SlashDevice();
+                }
+                else
+                {
+                    deviceMatrix = new AnimeMatrixDevice();
+                }
+
                 matrixTimer = new System.Timers.Timer(100);
                 matrixTimer.Elapsed += MatrixTimer_Elapsed;
+
             }
-            catch
+            catch (Exception ex)
             {
-                mat = null;
+                Logger.WriteLine(ex.Message);
             }
 
         }
 
-        public void SetMatrix()
+        public void SetDevice(bool wakeUp = false)
         {
+            if (deviceMatrix is not null) SetMatrix(wakeUp);
+            if (deviceSlash is not null) SetSlash(wakeUp);
+        }
 
-            if (!IsValid) return;
+        public void SetSlash(bool wakeUp = false)
+        {
+            if (deviceSlash is null) return;
 
-            int brightness = AppConfig.Get("matrix_brightness");
-            int running = AppConfig.Get("matrix_running");
+            int brightness = AppConfig.Get("matrix_brightness", 0);
+            int running = AppConfig.Get("matrix_running", 0);
+            int inteval = AppConfig.Get("matrix_interval", 0);
 
             bool auto = AppConfig.Is("matrix_auto");
+            bool lid = AppConfig.Is("matrix_lid");
 
-            if (brightness < 0) brightness = 0;
-            if (running < 0) running = 0;
+            Task.Run(() =>
+            {
+                try
+                {
+                    deviceSlash.SetProvider();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                    return;
+                }
 
-            BuiltInAnimation animation = new BuiltInAnimation(
-                (BuiltInAnimation.Running)running,
-                BuiltInAnimation.Sleeping.Starfield,
-                BuiltInAnimation.Shutdown.SeeYa,
-                BuiltInAnimation.Startup.StaticEmergence
-            );
+                if (wakeUp) _wakeUp = true;
+
+                if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online) || (lid && lidClose))
+                {
+                    deviceSlash.SetEnabled(false);
+                    //deviceSlash.Init();
+                    //deviceSlash.SetOptions(false, 0, 0);
+                    deviceSlash.SetSleepActive(false);
+                }
+                else
+                {
+                    if (_wakeUp)
+                    {
+                        deviceSlash.WakeUp();
+                        _wakeUp = false;
+                    }
+
+                    deviceSlash.SetEnabled(true);
+                    deviceSlash.Init();
+
+                    switch ((SlashMode)running)
+                    {
+                        case SlashMode.Static:
+                            Logger.WriteLine("Slash: Static");
+                            var custom = AppConfig.GetString("slash_custom");
+                            if (custom is not null && custom.Length > 0)
+                            {
+                                deviceSlash.SetCustom(AppConfig.StringToBytes(custom));
+                            }
+                            else
+                            {
+                                deviceSlash.SetStatic(brightness);
+                            }
+                            break;
+                        case SlashMode.BatteryLevel:
+                            // call tick to immediately update the pattern
+                            Logger.WriteLine("Slash: Battery Level");
+                            SlashTimer_start();
+                            SlashTimer_tick();
+                            break;
+                        default:
+                            deviceSlash.SetMode((SlashMode)running);
+                            deviceSlash.SetOptions(true, brightness, inteval);
+                            deviceSlash.Save();
+                            break;
+                    }
+                    // kill the timer if we are not displaying battery pattern
+
+                    deviceSlash.SetSleepActive(true);
+                }
+            });
+        }
+
+        public void SetLidMode(bool force = false)
+        {
+            bool matrixLid = AppConfig.Is("matrix_lid");
+
+            if (deviceSlash is not null)
+            {
+                deviceSlash.SetLidMode(!matrixLid && AppConfig.Is("slash_sleep"));
+            }
+
+            if (matrixLid || force)
+            {
+                Logger.WriteLine($"Matrix LidClosed: {lidClose}");
+                SetDevice(true);
+            }
+        }
+
+        public void SetBatteryAuto()
+        {
+            if (deviceSlash is not null)
+            {
+                bool auto = AppConfig.Is("matrix_auto");
+                deviceSlash.SetBatterySaver(auto);
+                if (!auto) SetSlash();
+            }
+
+            if (deviceMatrix is not null) SetMatrix();
+        }
+
+        public void SetMatrix(bool wakeUp = false)
+        {
+
+            if (deviceMatrix is null) return;
+
+            int brightness = AppConfig.Get("matrix_brightness", 0);
+            int running = AppConfig.Get("matrix_running", 0);
+            bool auto = AppConfig.Is("matrix_auto");
+            bool lid = AppConfig.Is("matrix_lid");
 
             StopMatrixTimer();
             StopMatrixAudio();
 
-            mat.SetProvider();
-
-            if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online))
+            Task.Run(() =>
             {
-                mat.SetDisplayState(false);
-                Logger.WriteLine("Matrix Off");
-            }
-            else
-            {
-                mat.SetDisplayState(true);
-                mat.SetBrightness((BrightnessMode)brightness);
-
-                switch (running)
+                try
                 {
-                    case 2:
-                        SetMatrixPicture(AppConfig.GetString("matrix_picture"));
-                        break;
-                    case 3:
-                        SetMatrixClock();
-                        break;
-                    case 4:
-                        SetMatrixAudio();
-                        break;
-                    default:
-                        mat.SetBuiltInAnimation(true, animation);
-                        Logger.WriteLine("Matrix builtin " + animation.AsByte);
-                        break;
-
+                    deviceMatrix.SetProvider();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                    return;
                 }
 
-                //mat.SetBrightness((BrightnessMode)brightness);
-            }
+                if (wakeUp) deviceMatrix.WakeUp();
+
+                if (brightness == 0 || (auto && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online) || (lid && lidClose))
+                {
+                    deviceMatrix.SetDisplayState(false);
+                    deviceMatrix.SetDisplayState(false); // some devices are dumb
+                    Logger.WriteLine("Matrix Off");
+                }
+                else
+                {
+                    deviceMatrix.SetDisplayState(true);
+                    deviceMatrix.SetBrightness((BrightnessMode)brightness);
+
+                    switch (running)
+                    {
+                        case 2:
+                            SetMatrixPicture(AppConfig.GetString("matrix_picture"), false);
+                            break;
+                        case 3:
+                            SetMatrixClock();
+                            break;
+                        case 4:
+                            SetMatrixAudio();
+                            break;
+                        default:
+                            SetBuiltIn(running);
+                            break;
+                    }
+
+                }
+            });
+
 
         }
+
+        private void SetBuiltIn(int running)
+        {
+            BuiltInAnimation animation = new BuiltInAnimation(
+                (BuiltInAnimation.Running)running,
+                (BuiltInAnimation.Sleeping)AppConfig.Get("matrix_sleep", (int)BuiltInAnimation.Sleeping.Starfield),
+                (BuiltInAnimation.Shutdown)AppConfig.Get("matrix_shutdown", (int)BuiltInAnimation.Shutdown.SeeYa),
+                (BuiltInAnimation.Startup)AppConfig.Get("matrix_startup", (int)BuiltInAnimation.Startup.StaticEmergence)
+            );
+            deviceMatrix.SetBuiltInAnimation(true, animation);
+            Logger.WriteLine("Matrix builtin: " + animation.AsByte);
+        }
+
         private void StartMatrixTimer(int interval = 100)
         {
             matrixTimer.Interval = interval;
@@ -110,31 +256,76 @@ namespace GHelper.AnimeMatrix
             matrixTimer.Stop();
         }
 
-
         private void MatrixTimer_Elapsed(object? sender, ElapsedEventArgs e)
         {
-            //if (!IsValid) return;
+
+            if (deviceMatrix is null) return;
 
             switch (AppConfig.Get("matrix_running"))
             {
                 case 2:
-                    mat.PresentNextFrame();
+                    deviceMatrix.PresentNextFrame();
                     break;
                 case 3:
-                    mat.PresentClock();
+                    deviceMatrix.PresentClock();
                     break;
             }
 
         }
 
-
         public void SetMatrixClock()
         {
-            mat.SetBuiltInAnimation(false);
+            deviceMatrix.SetBuiltInAnimation(false);
             StartMatrixTimer(1000);
             Logger.WriteLine("Matrix Clock");
         }
 
+
+        private void SlashTimer_start(int interval = 180000)
+        {
+            // 100% to 0% in 1hr = 1% every 36 seconds
+            // 1 bracket every 14.2857 * 36s = 514s ~ 8m 30s
+            // only ~5 actually distinguishable levels, so refresh every <= 514/5 ~ 100s
+            // default is 60s
+
+            // create the timer if first call
+            // this way, the timer only spawns if user tries to use battery pattern
+            if (slashTimer == default(System.Timers.Timer))
+            {
+                slashTimer = new System.Timers.Timer(interval);
+                slashTimer.Elapsed += SlashTimer_elapsed;
+                slashTimer.AutoReset = true;
+            }
+            // only write if interval changed
+            if (slashTimer.Interval != interval)
+            {
+                slashTimer.Interval = interval;
+            }
+
+            slashTimer.Start();
+        }
+
+        private void SlashTimer_elapsed(object? sender, ElapsedEventArgs e)
+        {
+            SlashTimer_tick();
+        }
+
+        private void SlashTimer_tick()
+        {
+            if (deviceSlash is null) return;
+
+            //kill timer if called but not in battery pattern mode
+            if ((SlashMode)AppConfig.Get("matrix_running", 0) != SlashMode.BatteryLevel)
+            {
+                slashTimer.Stop();
+                slashTimer.Dispose();
+                return;
+            }
+
+            deviceSlash.SetBatteryPattern(AppConfig.Get("matrix_brightness", 0));
+        }
+
+
         public void Dispose()
         {
             StopMatrixAudio();
@@ -154,22 +345,28 @@ namespace GHelper.AnimeMatrix
                     Logger.WriteLine(ex.ToString());
                 }
             }
+
+            AudioDeviceId = null;
+            AudioDeviceEnum?.Dispose();
         }
 
         void SetMatrixAudio()
         {
-            if (!IsValid) return;
+            if (deviceMatrix is null) return;
 
-            mat.SetBuiltInAnimation(false);
+            deviceMatrix.SetBuiltInAnimation(false);
             StopMatrixTimer();
             StopMatrixAudio();
 
             try
             {
-                using (var enumerator = new MMDeviceEnumerator())
-                using (MMDevice device = enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console))
+                AudioDeviceEnum = new MMDeviceEnumerator();
+                AudioDeviceEnum.RegisterEndpointNotificationCallback(this);
+
+                using (MMDevice device = AudioDeviceEnum.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console))
                 {
                     AudioDevice = new WasapiLoopbackCapture(device);
+                    AudioDeviceId = device.ID;
                     WaveFormat fmt = AudioDevice.WaveFormat;
 
                     AudioValues = new double[fmt.SampleRate / 1000];
@@ -229,18 +426,20 @@ namespace GHelper.AnimeMatrix
                 for (int x = 0; x < 2 - (y % 2); x++)
                 {
                     //color = (byte)(Math.Min(1,(h - y - 2)*2) * 255);
-                    mat.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
-                    mat.SetLedPlanar(x + dx, dy - y, 255);
+                    deviceMatrix.SetLedPlanar(x + dx, dy + y, (byte)(h * 255 / 30));
+                    deviceMatrix.SetLedPlanar(x + dx, dy - y, 255);
                 }
         }
 
         void PresentAudio(double[] audio)
         {
 
+            if (deviceMatrix is null) return;
+
             if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastPresent) < 70) return;
             lastPresent = DateTimeOffset.Now.ToUnixTimeMilliseconds();
 
-            mat.Clear();
+            deviceMatrix.Clear();
 
             int size = 20;
             double[] bars = new double[size];
@@ -258,10 +457,9 @@ namespace GHelper.AnimeMatrix
 
             for (int i = 0; i < size; i++) DrawBar(20 - i, bars[i] * 20 / maxAverage);
 
-            mat.Present();
+            deviceMatrix.Present();
         }
 
-
         public void OpenMatrixPicture()
         {
             string fileName = null;
@@ -287,28 +485,37 @@ namespace GHelper.AnimeMatrix
                 AppConfig.Set("matrix_running", 2);
 
                 SetMatrixPicture(fileName);
-                settings.SetMatrixRunning(2);
+                settings.VisualiseMatrixRunning(2);
 
             }
 
         }
 
-        public void SetMatrixPicture(string fileName)
+        public void SetMatrixPicture(string fileName, bool visualise = true)
         {
 
-            if (!IsValid) return;
-            StopMatrixTimer();
+            if (deviceMatrix is null) return;
 
-            Image image;
+            StopMatrixTimer();
 
             try
             {
                 using (var fs = new FileStream(fileName, FileMode.Open))
+                //using (var ms = new MemoryStream())
                 {
-                    var ms = new MemoryStream();
+                    /*
+                    ms.SetLength(0);
                     fs.CopyTo(ms);
                     ms.Position = 0;
-                    image = Image.FromStream(ms);
+                    */
+                    using (Image image = Image.FromStream(fs))
+                    {
+                        ProcessPicture(image);
+                        Logger.WriteLine("Matrix " + fileName);
+                    }
+
+                    fs.Close();
+                    if (visualise) settings.VisualiseMatrixPicture(fileName);
                 }
             }
             catch
@@ -317,32 +524,108 @@ namespace GHelper.AnimeMatrix
                 return;
             }
 
-            mat.SetBuiltInAnimation(false);
-            mat.ClearFrames();
+        }
+
+        protected void ProcessPicture(Image image)
+        {
+            deviceMatrix.SetBuiltInAnimation(false);
+            deviceMatrix.ClearFrames();
+
+            int matrixX = AppConfig.Get("matrix_x", 0);
+            int matrixY = AppConfig.Get("matrix_y", 0);
+
+            int matrixZoom = AppConfig.Get("matrix_zoom", 100);
+            int matrixContrast = AppConfig.Get("matrix_contrast", 100);
+            int matrixGamma = AppConfig.Get("matrix_gamma", 0);
+
+            int matrixSpeed = AppConfig.Get("matrix_speed", 50);
+
+            MatrixRotation rotation = (MatrixRotation)AppConfig.Get("matrix_rotation", 0);
+
+            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);
-                    mat.GenerateFrame(image);
-                    mat.AddFrame();
+
+                    if (rotation == MatrixRotation.Planar)
+                        deviceMatrix.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast, matrixGamma);
+                    else
+                        deviceMatrix.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast, matrixGamma);
+
+                    deviceMatrix.AddFrame();
                 }
 
-                StartMatrixTimer();
-                Logger.WriteLine("Matrix GIF " + fileName);
+
+                Logger.WriteLine("GIF Delay:" + frameDelay);
+                StartMatrixTimer(Math.Max(matrixSpeed, frameDelay));
+
+                //image.SelectActiveFrame(dimension, 0);
+
             }
             else
             {
-                mat.GenerateFrame(image);
-                mat.Present();
-                Logger.WriteLine("Matrix " + fileName);
+                if (rotation == MatrixRotation.Planar)
+                    deviceMatrix.GenerateFrame(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast, matrixGamma);
+                else
+                    deviceMatrix.GenerateFrameDiagonal(image, matrixZoom, matrixX, matrixY, matrixQuality, matrixContrast, matrixGamma);
+
+                deviceMatrix.Present();
             }
+
         }
 
+        public void OnDeviceStateChanged(string deviceId, DeviceState newState)
+        {
 
+        }
+
+        public void OnDeviceAdded(string pwstrDeviceId)
+        {
+
+        }
+
+        public void OnDeviceRemoved(string deviceId)
+        {
+
+        }
+
+        public void OnDefaultDeviceChanged(DataFlow flow, Role role, string defaultDeviceId)
+        {
+            if (AudioDeviceId == defaultDeviceId)
+            {
+                //We already caputre this device. No need to re-initialize
+                return;
+            }
+
+            int running = AppConfig.Get("matrix_running");
+            if (flow != DataFlow.Render || role != Role.Console || running != 4)
+            {
+                return;
+            }
+
+            //Restart audio if default audio changed
+            Logger.WriteLine("Matrix Audio: Default Output changed to " + defaultDeviceId);
+
+            //Already set the device here. Otherwise this will be called multiple times in a short succession and causes a crash due to dispose during initalization.
+            AudioDeviceId = defaultDeviceId;
+
+            //Delay is required or it will deadlock on dispose.
+            Task.Delay(50).ContinueWith(t => SetMatrixAudio());
+        }
+
+        public void OnPropertyValueChanged(string pwstrDeviceId, PropertyKey key)
+        {
+
+        }
     }
 }

app/AnimeMatrix/AnimeMatrixDevice.cs

@@ -3,11 +3,9 @@
 using GHelper.AnimeMatrix.Communication;
 using System.Drawing.Drawing2D;
 using System.Drawing.Text;
-using System.Globalization;
-using System.Management;
 using System.Text;
 
-namespace Starlight.AnimeMatrix
+namespace GHelper.AnimeMatrix
 {
     public class BuiltInAnimation
     {
@@ -51,6 +49,12 @@ namespace Starlight.AnimeMatrix
         }
     }
 
+    public enum MatrixRotation
+    {
+        Planar,
+        Diagonal
+    }
+
     internal class AnimeMatrixPacket : Packet
     {
         public AnimeMatrixPacket(byte[] command)
@@ -67,7 +71,6 @@ namespace Starlight.AnimeMatrix
     }
 
 
-
     public enum BrightnessMode : byte
     {
         Off = 0,
@@ -86,167 +89,51 @@ namespace Starlight.AnimeMatrix
         List<byte[]> frames = new List<byte[]>();
 
         public int MaxRows = 61;
-        //public int FullRows = 11;
-        //public int FullEvenRows = -1;
-
-        public int dx = 0;
-        //Shifts the whole frame to the left or right to align with the diagonal cut
-        public int frameShiftX = 0;
         public int MaxColumns = 34;
+        public int LedStart = 0;
+        public int FullRows = 11;
 
         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)
+        public AnimeMatrixDevice() : base(0x0B05, 0x193B, 640)
         {
-            string model = GetModel();
-            if (model.Contains("401"))
+            if (AppConfig.ContainsModel("401"))
             {
-
                 _model = AnimeType.GA401;
 
                 MaxColumns = 33;
-                dx = 1;
-
                 MaxRows = 55;
                 LedCount = 1245;
 
                 UpdatePageLength = 410;
+
+                FullRows = 5;
+
+                LedStart = 1;
             }
 
-            if (model.Contains("GU604"))
+            if (AppConfig.ContainsModel("GU604"))
             {
                 _model = AnimeType.GU604;
 
                 MaxColumns = 39;
                 MaxRows = 92;
                 LedCount = 1711;
-                frameShiftX = -5;
                 UpdatePageLength = 630;
+
+                FullRows = 9;
             }
 
             _displayBuffer = new byte[LedCount];
 
-        }
+            LoadMFont();
 
-
-        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 static int FirstX(int y)
-        {
-            switch (_model)
-            {
-                case AnimeType.GA401:
-                    if (y < 5)
-                    {
-                        return 0;
-                    }
-                    else
-                    {
-                        return (y + 1) / 2 - 3;
-                    }
-                case AnimeType.GU604:
-                    return (int)Math.Ceiling(Math.Max(0, y - 9) / 2F);
-
-                default:
-                    return (int)Math.Ceiling(Math.Max(0, y - 11) / 2F);
-            }
-        }
-
-        public static int Width(int y)
-        {
-            switch (_model)
-            {
-                case AnimeType.GA401:
-                    return 33;
-                case AnimeType.GU604:
-                    return 39;
-                default:
-                    return 34;
-            }
-        }
-
-        public static 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;
-                    }
-                default:
-                    return Width(y) - FirstX(y);
-            }
-        }
-
-
-        public int RowToLinearAddress(int y)
-        {
-            int ret = 0;
-            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(y))
-                SetLedLinear(RowToLinearAddress(y) - FirstX(y) + x + dx + frameShiftX, value);
         }
 
         public void WakeUp()
@@ -254,35 +141,25 @@ namespace Starlight.AnimeMatrix
             Set(Packet<AnimeMatrixPacket>(Encoding.ASCII.GetBytes("ASUS Tech.Inc.")));
         }
 
-        public void SetLedLinear(int address, byte value)
+        public void SetBrightness(BrightnessMode mode)
         {
-            if (!IsAddressableLed(address)) return;
-            _displayBuffer[address] = value;
+            Set(Packet<AnimeMatrixPacket>(0xC0, 0x04, (byte)mode));
         }
 
-        public void SetLedLinearImmediate(int address, byte value)
+        public void SetDisplayState(bool enable)
         {
-            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));
+            Set(Packet<AnimeMatrixPacket>(0xC3, 0x01, enable ? (byte)0x00 : (byte)0x80));
         }
 
-
-
-        public void Clear(bool present = false)
+        public void SetBuiltInAnimation(bool enable)
         {
-            for (var i = 0; i < _displayBuffer.Length; i++)
-                _displayBuffer[i] = 0;
+            Set(Packet<AnimeMatrixPacket>(0xC4, 0x01, enable ? (byte)0x00 : (byte)0x80));
+        }
 
-            if (present)
-                Present();
+        public void SetBuiltInAnimation(bool enable, BuiltInAnimation animation)
+        {
+            SetBuiltInAnimation(enable);
+            Set(Packet<AnimeMatrixPacket>(0xC5, animation.AsByte));
         }
 
         public void Present()
@@ -308,91 +185,238 @@ namespace Starlight.AnimeMatrix
             Set(Packet<AnimeMatrixPacket>(0xC0, 0x03));
         }
 
-        public void SetDisplayState(bool enable)
+
+        private void LoadMFont()
         {
-            if (enable)
+            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 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 int Width()
+        {
+            switch (_model)
             {
-                Set(Packet<AnimeMatrixPacket>(0xC3, 0x01)
-                    .AppendData(0x00));
-            }
-            else
-            {
-                Set(Packet<AnimeMatrixPacket>(0xC3, 0x01)
-                    .AppendData(0x80));
+                case AnimeType.GA401:
+                    return 33;
+                case AnimeType.GU604:
+                    return 39;
+                default:
+                    return 34;
             }
         }
 
-        public void SetBrightness(BrightnessMode mode)
+        public int FirstX(int y)
         {
-            Set(Packet<AnimeMatrixPacket>(0xC0, 0x04)
-                .AppendData((byte)mode)
-            );
-        }
+            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);
 
-        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));
+                default:
+                    return (int)Math.Ceiling(Math.Max(0, y - 11) / 2F);
+            }
         }
 
 
-        public void PresentClock()
+        public int Pitch(int y)
         {
-            int second = DateTime.Now.Second;
-            string time;
+            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;
+                    }
 
-            if (CultureInfo.CurrentCulture.DateTimeFormat.ShortTimePattern.Contains("H"))
-                time = DateTime.Now.ToString("H" + ((second % 2 == 0) ? ":" : " ") + "mm");
-            else
-                time = DateTime.Now.ToString("h" + ((second % 2 == 0) ? ":" : " ") + "mmtt");
+                case AnimeType.GU604:
+                    switch (y)
+                    {
+                        case 0:
+                        case 2:
+                        case 4:
+                        case 6:
+                        case 8:
+                            return 38;
 
-            if (_model == AnimeType.GA401)
-                PresentText(time);
-            else
-                PresentTextDiagonal(time);
+                        case 1:
+                        case 3:
+                        case 5:
+                        case 7:
+                        case 9:
+                            return 39;
+
+                        default:
+                            return Width() - FirstX(y);
+                    }
+
+
+                default:
+                    return Width() - FirstX(y);
+            }
         }
 
 
-
-        public void PresentText(string text1, string text2 = "")
+        public int RowToLinearAddress(int y)
         {
-            using (Bitmap bmp = new Bitmap(MaxColumns * 3, MaxRows))
+            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 SetLedDiagonal(int x, int y, byte color, int deltaX = 0, int deltaY = 0)
+        {
+            x += deltaX;
+            y -= deltaY;
+
+            int plX = (x - y) / 2;
+            int plY = x + y;
+
+            if (x - y == -1) plX = -1;
+
+            SetLedPlanar(plX, plY, color);
+        }
+
+
+        public void SetLedLinear(int address, byte value)
+        {
+            if (!IsAddressableLed(address)) return;
+            _displayBuffer[address] = value;
+        }
+
+
+        public void Clear(bool present = false)
+        {
+            for (var i = 0; i < _displayBuffer.Length; i++) _displayBuffer[i] = 0;
+            if (present) Present();
+        }
+
+        private void SetBitmapDiagonal(Bitmap bmp, int deltaX = 0, int deltaY = 0, int contrast = 100, int gamma = 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 = Math.Min((pixel.R + pixel.G + pixel.B + gamma) * contrast / 300, 255);
+                    if (color > 20)
+                        SetLedDiagonal(x, y, (byte)color, deltaX, deltaY - (FullRows / 2) - 1);
+                }
+            }
+        }
+
+        private void SetBitmapLinear(Bitmap bmp, int contrast = 100, int gamma = 0)
+        {
+            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 = Math.Min((pixel.R + pixel.G + pixel.B + gamma) * contrast / 300, 255);
+                        if (color > 20)
+                            SetLedPlanar(x / 2, y, (byte)color);
+                    }
+            }
+        }
+
+        public void Text(string text, float fontSize = 10, int x = 0, int y = 0)
+        {
+
+            int width = MaxRows;
+            int height = MaxRows - FullRows;
+            int textHeight, textWidth;
+
+            using (Bitmap bmp = new Bitmap(width, height))
             {
                 using (Graphics g = Graphics.FromImage(bmp))
                 {
                     g.CompositingQuality = CompositingQuality.HighQuality;
                     g.SmoothingMode = SmoothingMode.AntiAlias;
+                    g.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
 
-                    using (Font font = new Font("Consolas", 21F, FontStyle.Regular, GraphicsUnit.Pixel))
+                    using (Font font = new Font(fonts.Families[0], fontSize, FontStyle.Regular, GraphicsUnit.Pixel))
                     {
-                        SizeF textSize = g.MeasureString(text1, font);
-                        g.DrawString(text1, font, Brushes.White, (MaxColumns * 3 - textSize.Width) + 3, -4);
+                        SizeF textSize = g.MeasureString(text, font);
+                        textHeight = (int)textSize.Height;
+                        textWidth = (int)textSize.Width;
+                        g.DrawString(text, font, Brushes.White, x, height - y);
                     }
-
-                    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);
-                        }
-
                 }
 
-                GenerateFrame(bmp, InterpolationMode.Bicubic);
-                Present();
-            }
+                SetBitmapDiagonal(bmp, 5, height);
 
+            }
         }
 
-        public void GenerateFrame(Image image, InterpolationMode interpolation = InterpolationMode.High)
+        public void PresentClock()
         {
+            string timeFormat = AppConfig.GetString("matrix_time", "HH:mm");
+            string dateFormat = AppConfig.GetString("matrix_date", "yy.MM.dd");
 
+            if (DateTime.Now.Second % 2 != 0) timeFormat = timeFormat.Replace(":", "  ");
+
+            Clear();
+            Text(DateTime.Now.ToString(timeFormat), 15, 7 - FullRows / 2, 25);
+            Text(DateTime.Now.ToString(dateFormat), 11.5F, 0, 14);
+            Present();
+
+        }
+        public void GenerateFrame(Image image, float zoom = 100, int panX = 0, int panY = 0, InterpolationMode quality = InterpolationMode.Default, int contrast = 100, int gamma = 0)
+        {
             int width = MaxColumns / 2 * 6;
             int height = MaxRows;
 
@@ -402,99 +426,58 @@ namespace Starlight.AnimeMatrix
 
             using (Bitmap bmp = new Bitmap(targetWidth, height))
             {
-                scale = Math.Min((float)width / (float)image.Width, (float)height / (float)image.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 = interpolation;
+                    graph.InterpolationMode = quality;
                     graph.CompositingQuality = CompositingQuality.HighQuality;
                     graph.SmoothingMode = SmoothingMode.AntiAlias;
 
-                    graph.DrawImage(image, (float)Math.Round(targetWidth - scaleWidth * targetWidth / width), 0, (float)Math.Round(scaleWidth * targetWidth / width), scaleHeight);
+                    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 + dx) % 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);
-                        }
-                }
+                Clear();
+                SetBitmapLinear(bmp, contrast, gamma);
             }
         }
 
-
-        public void SetLedDiagonal(int x, int y, byte color, int delta = 10)
+        public void GenerateFrameDiagonal(Image image, float zoom = 100, int panX = 0, int panY = 0, InterpolationMode quality = InterpolationMode.Default, int contrast = 100, int gamma = 0)
         {
-            //x+=delta;
-            y -= delta;
+            int width = MaxRows + FullRows;
+            int height = MaxColumns + FullRows;
 
-            int dx = (x - y) / 2;
-            int dy = x + y;
-            SetLedPlanar(dx, dy, color);
-        }
+            if ((image.Height / image.Width) > (height / width)) height = MaxColumns;
 
-        public void PresentTextDiagonal(string text)
-        {
+            float scale;
 
-            Clear();
-
-
-            InstalledFontCollection installedFontCollection = new InstalledFontCollection();
-
-
-            string familyName;
-            string familyList = "";
-            FontFamily[] fontFamilies;
-            // Get the array of FontFamily objects.
-            fontFamilies = installedFontCollection.Families;
-
-            int count = fontFamilies.Length;
-            for (int j = 0; j < count; ++j)
+            using (Bitmap bmp = new Bitmap(width, height))
             {
-                familyName = fontFamilies[j].Name;
-                familyList = familyList + familyName;
-                familyList = familyList + ",  ";
-            }
+                scale = Math.Min((float)width / (float)image.Width, (float)height / (float)image.Height) * zoom / 100;
 
-            int maxX = (int)Math.Sqrt(MaxRows * MaxRows + MaxColumns * MaxColumns);
-
-            using (Bitmap bmp = new Bitmap(maxX, MaxRows))
-            {
-                using (Graphics g = Graphics.FromImage(bmp))
+                using (var graph = Graphics.FromImage(bmp))
                 {
-                    g.CompositingQuality = CompositingQuality.HighQuality;
-                    g.SmoothingMode = SmoothingMode.AntiAlias;
+                    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, (width - scaleWidth) / 2, height - scaleHeight, scaleWidth, scaleHeight);
 
-                    using (Font font = new Font("Consolas", 13F, FontStyle.Regular, GraphicsUnit.Pixel))
-                    {
-                        SizeF textSize = g.MeasureString(text, font);
-                        g.DrawString(text, font, Brushes.White, 4, 1);
-                    }
                 }
 
-                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;
-                        SetLedDiagonal(x, y, (byte)color);
-                    }
-                }
+                Clear();
+                SetBitmapDiagonal(bmp, -panX, height + panY, contrast, gamma);
             }
-
-            Present();
         }
 
+
         private bool IsRowInRange(int row)
         {
             return (row >= 0 && row < MaxRows);

app/AnimeMatrix/Communication/Device.cs

@@ -6,11 +6,17 @@ namespace GHelper.AnimeMatrix.Communication
 {
     public abstract class Device : IDisposable
     {
-        private static UsbProvider _usbProvider;
+        protected UsbProvider? _usbProvider;
 
-        private static ushort _vendorId;
-        private static ushort _productId;
-        private static int _maxFeatureReportLength;
+        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)
         {
@@ -20,7 +26,17 @@ namespace GHelper.AnimeMatrix.Communication
             SetProvider();
         }
 
-        public void SetProvider()
+        public ushort VendorID()
+        {
+            return _vendorId;
+        }
+
+        public ushort ProductID()
+        {
+            return _productId;
+        }
+
+        public virtual void SetProvider()
         {
             _usbProvider = new WindowsUsbProvider(_vendorId, _productId, _maxFeatureReportLength);
         }
@@ -36,7 +52,12 @@ namespace GHelper.AnimeMatrix.Communication
         public byte[] Get(Packet packet)
             => _usbProvider?.Get(packet.Data);
 
-        public void Dispose()
+        public void Read(byte[] data)
+            => _usbProvider?.Read(data);
+        public void Write(byte[] data)
+            => _usbProvider?.Write(data);
+
+        public virtual void Dispose()
         {
             _usbProvider?.Dispose();
         }

app/AnimeMatrix/Communication/Platform/UsbProvider.cs

@@ -1,6 +1,6 @@
 namespace GHelper.AnimeMatrix.Communication.Platform
 {
-    internal abstract class UsbProvider : IDisposable
+    public abstract class UsbProvider : IDisposable
     {
         protected ushort VendorID { get; }
         protected ushort ProductID { get; }
@@ -13,6 +13,8 @@ namespace GHelper.AnimeMatrix.Communication.Platform
 
         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();
     }

app/AnimeMatrix/Communication/Platform/WindowsUsbProvider.cs

@@ -8,6 +8,27 @@ namespace GHelper.AnimeMatrix.Communication.Platform
         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)
         {
@@ -15,11 +36,12 @@ namespace GHelper.AnimeMatrix.Communication.Platform
             {
                 HidDevice = DeviceList.Local
                     .GetHidDevices(vendorId, productId)
-                    .First(x => x.GetMaxFeatureReportLength() == maxFeatureReportLength);
+                    .First(x => x.GetMaxFeatureReportLength() >= maxFeatureReportLength);
+                Logger.WriteLine("Matrix Device: " + HidDevice.DevicePath + " " + HidDevice.GetMaxFeatureReportLength());
             }
             catch
             {
-                throw new IOException("AniMe Matrix control device was not found on your machine.");
+                throw new IOException("Matrix control device was not found on your machine.");
             }
 
             var config = new OpenConfiguration();
@@ -53,6 +75,23 @@ namespace GHelper.AnimeMatrix.Communication.Platform
             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();

app/AnimeMatrix/SlashDevice.cs

@@ -0,0 +1,242 @@
+using GHelper.AnimeMatrix.Communication;
+using System.Management;
+using System.Text;
+
+namespace GHelper.AnimeMatrix
+{
+    public enum SlashMode
+    {
+        Bounce,
+        Slash,
+        Loading,
+        BitStream,
+        Transmission,
+        Flow,
+        Flux,
+        Phantom,
+        Spectrum,
+        Hazard,
+        Interfacing,
+        Ramp,
+        GameOver,
+        Start,
+        Buzzer,
+        Static,
+        BatteryLevel,
+    }
+
+    public class SlashPacket : Packet
+    {
+        public SlashPacket(byte[] command, byte reportID = 0x5E) : base(reportID, 128, command)
+        {
+        }
+    }
+
+
+    public class SlashDevice : Device
+    {
+
+        protected virtual byte reportID => 0x5E;
+
+        protected virtual SlashPacket CreatePacket(byte[] command)
+        {
+            return new SlashPacket(command, reportID);
+        }
+
+        public static Dictionary<SlashMode, string> Modes = new Dictionary<SlashMode, string>
+        {
+            { SlashMode.Bounce, "Bounce"},
+            { SlashMode.Slash, "Slash"},
+            { SlashMode.Loading, "Loading"},
+
+            { SlashMode.BitStream, "Bit Stream"},
+            { SlashMode.Transmission, "Transmission"},
+
+            { SlashMode.Flow, "Flow"},
+            { SlashMode.Flux, "Flux"},
+            { SlashMode.Phantom, "Phantom"},
+            { SlashMode.Spectrum, "Spectrum"},
+
+            { SlashMode.Hazard, "Hazard"},
+            { SlashMode.Interfacing, "Interfacing"},
+            { SlashMode.Ramp, "Ramp"},
+
+            { SlashMode.GameOver, "Game Over"},
+            { SlashMode.Start, "Start"},
+            { SlashMode.Buzzer, "Buzzer"},
+
+            { SlashMode.Static, "Static"},
+            { SlashMode.BatteryLevel, "Battery Level"}
+        };
+
+        private static Dictionary<SlashMode, byte> modeCodes = new Dictionary<SlashMode, byte>
+        {
+            { SlashMode.Bounce, 0x10},
+            { SlashMode.Slash, 0x12},
+            { SlashMode.Loading, 0x13},
+
+            { SlashMode.BitStream, 0x1D},
+            { SlashMode.Transmission, 0x1A},
+
+            { SlashMode.Flow, 0x19},
+            { SlashMode.Flux, 0x25},
+            { SlashMode.Phantom, 0x24},
+            { SlashMode.Spectrum, 0x26},
+
+            { SlashMode.Hazard, 0x32},
+            { SlashMode.Interfacing, 0x33},
+            { SlashMode.Ramp, 0x34},
+
+            { SlashMode.GameOver, 0x42},
+            { SlashMode.Start, 0x43},
+            { SlashMode.Buzzer, 0x44},
+        };
+
+        public SlashDevice(ushort productId = 0x193B) : base(0x0B05, productId, 128)
+        {
+        }
+
+        public void WakeUp()
+        {
+            Set(CreatePacket(Encoding.ASCII.GetBytes("ASUS Tech.Inc.")), "SlashWakeUp");
+            Set(CreatePacket([0xC2]), "SlashWakeUp");
+            Set(CreatePacket([0xD1, 0x01, 0x00, 0x01 ]), "SlashWakeUp");
+        }
+
+        public void Init()
+        {
+            Set(CreatePacket([0xD7, 0x00, 0x00, 0x01, 0xAC]), "SlashInit");
+            Set(CreatePacket([0xD2, 0x02, 0x01, 0x08, 0xAB]), "SlashInit");
+        }
+
+        public void SetEnabled(bool status = true)
+        {
+            Set(CreatePacket([0xD8, 0x02, 0x00, 0x01, status ? (byte)0x00 : (byte)0x80]), $"SlashEnable {status}");
+        }
+
+        public void Save()
+        {
+            Set(CreatePacket([0xD4, 0x00, 0x00, 0x01, 0xAB]), "SlashSave");
+        }
+
+        public void SetMode(SlashMode mode)
+        {
+            byte modeByte;
+
+            try
+            {
+                modeByte = modeCodes[mode];
+            }
+            catch (Exception)
+            {
+                modeByte = 0x00;
+            }
+
+            Set(CreatePacket([0xD2, 0x03, 0x00, 0x0C]), "SlashMode");
+            Set(CreatePacket([0xD3, 0x04, 0x00, 0x0C, 0x01, modeByte, 0x02, 0x19, 0x03, 0x13, 0x04, 0x11, 0x05, 0x12, 0x06, 0x13]), "SlashMode");
+        }
+
+        public void SetStatic(int brightness = 0)
+        {
+            SetCustom(Enumerable.Repeat((byte)(brightness * 85.333), 7).ToArray());
+        }
+
+        public static double GetBatteryChargePercentage()
+        {
+            double batteryCharge = 0;
+            try
+            {
+                ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Battery");
+                foreach (ManagementObject battery in searcher.Get())
+                {
+                    batteryCharge = Convert.ToDouble(battery["EstimatedChargeRemaining"]);
+                    break; // Assuming only one battery
+                }
+            }
+            catch (ManagementException e)
+            {
+                Console.WriteLine("An error occurred while querying for WMI data: " + e.Message);
+            }
+            return batteryCharge;
+        }
+
+        private byte[] GetBatteryPattern(int brightness, double percentage)
+        {
+            // because 7 segments, within each led segment represents a percentage bracket of (100/7 = 14.2857%)
+            // set brightness to reflect battery's percentage within that range
+
+            int bracket = (int)Math.Floor(percentage / 14.2857);
+            if (bracket >= 7) return Enumerable.Repeat((byte)(brightness * 85.333), 7).ToArray();
+
+            byte[] batteryPattern = Enumerable.Repeat((byte)(0x00), 7).ToArray();
+            for (int i = 6; i > 6 - bracket; i--)
+            {
+                batteryPattern[i] = (byte)(brightness * 85.333);
+            }
+
+            //set the "selected" bracket to the percentage of that bracket filled from 0 to 255 as a hex
+            batteryPattern[6 - bracket] = (byte)(((percentage % 14.2857) * brightness * 85.333) / 14.2857);
+
+            return batteryPattern;
+        }
+
+        public void SetBatteryPattern(int brightness)
+        {
+            SetCustom(GetBatteryPattern(brightness, 100 * (GetBatteryChargePercentage() / AppConfig.Get("charge_limit", 100))), null);
+        }
+
+        public void SetCustom(byte[] data, string? log = "Static Data")
+        {
+            Set(CreatePacket([0xD2, 0x02, 0x01, 0x08, 0xAC]), null);
+            Set(CreatePacket([0xD3, 0x03, 0x01, 0x08, 0xAC, 0xFF, 0xFF, 0x01, 0x05, 0xFF, 0xFF]), null);
+            Set(CreatePacket([0xD4, 0x00, 0x00, 0x01, 0xAC]), null);
+
+            byte[] payload = new byte[] { 0xD3, 0x00, 0x00, 0x07 };
+            Set(CreatePacket(payload.Concat(data.Take(7)).ToArray()), log);
+        }
+
+        public void SetOptions(bool status, int brightness = 0, int interval = 0)
+        {
+            byte brightnessByte = (byte)(brightness * 85.333);
+
+            Set(CreatePacket([0xD3, 0x03, 0x01, 0x08, 0xAB, 0xFF, 0x01, status ? (byte)0x01 : (byte)0x00, 0x06, brightnessByte, 0xFF, (byte)interval]), "SlashOptions");
+        }
+
+        public void SetBatterySaver(bool status)
+        {
+            Set(CreatePacket([0xD8, 0x01, 0x00, 0x01, status ? (byte)0x80 : (byte)0x00]), $"SlashBatterySaver {status}");
+        }
+
+        public void SetLidMode(bool status)
+        {
+            Set(CreatePacket([0xD8, 0x00, 0x00, 0x02, 0xA5, status ? (byte)0x80 : (byte)0x00]), $"SlashLidCloseAnimation {status}");
+        }
+
+        public void SetSleepActive(bool status)
+        {
+            Set(CreatePacket([0xD2, 0x02, 0x01, 0x08, 0xA1]), "SleepInit");
+            Set(CreatePacket([0xD3, 0x03, 0x01, 0x08, 0xA1, 0x00, 0xFF, status ? (byte)0x01 : (byte)0x00, 0x02, 0xFF, 0xFF]), $"Sleep {status}");
+        }
+
+        public void Set(Packet packet, string? log = null)
+        {
+            _usbProvider?.Set(packet.Data);
+            if (log is not null) Logger.WriteLine($"{log}:" + BitConverter.ToString(packet.Data).Substring(0, 48));
+        }
+    }
+
+    public class SlashDeviceAura : SlashDevice
+    {
+        protected override byte reportID => 0x5D;
+
+        public SlashDeviceAura() : base(0x19B6)
+        {
+        }
+
+        protected override SlashPacket CreatePacket(byte[] command)
+        {
+            return new SlashPacket(command, reportID);
+        }
+
+    }
+}

app/AppConfig.cs

@@ -1,5 +1,4 @@
-using GHelper.Mode;
-using System.Diagnostics;
+using GHelper.Mode;
 using System.Management;
 using System.Text.Json;
 
@@ -7,9 +6,13 @@ public static class AppConfig
 {
 
     private static string configFile;
+
     private static string? _model;
+    private static string? _modelShort;
+    private static string? _bios;
 
     private static Dictionary<string, object> config = new Dictionary<string, object>();
+    private static System.Timers.Timer timer = new System.Timers.Timer(2000);
 
     static AppConfig()
     {
@@ -21,7 +24,8 @@ public static class AppConfig
         if (File.Exists(startupPath + configName))
         {
             configFile = startupPath + configName;
-        } else
+        }
+        else
         {
             configFile = appPath + configName;
         }
@@ -37,10 +41,19 @@ public static class AppConfig
             {
                 config = JsonSerializer.Deserialize<Dictionary<string, object>>(text);
             }
-            catch
+            catch (Exception ex)
             {
-                Logger.WriteLine("Broken config: " + text);
-                Init();
+                Logger.WriteLine($"Broken config: {ex.Message} {text}");
+                try
+                {
+                    text = File.ReadAllText(configFile + ".bak");
+                    config = JsonSerializer.Deserialize<Dictionary<string, object>>(text);
+                }
+                catch (Exception exb)
+                {
+                    Logger.WriteLine($"Broken backup config: {exb.Message} {text}");
+                    Init();
+                }
             }
         }
         else
@@ -48,27 +61,105 @@ public static class AppConfig
             Init();
         }
 
+        timer.Elapsed += Timer_Elapsed;
+
     }
 
+    private static void Timer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+    {
+
+        timer.Stop();
+        string jsonString = JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true });
+        var backup = configFile + ".bak";
+
+        try
+        {
+            File.WriteAllText(backup, jsonString);
+        }
+        catch (Exception)
+        {
+            Thread.Sleep(100);
+            try
+            {
+                File.WriteAllText(backup, jsonString);
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
+            return;
+        }
+
+        Thread.Sleep(500);
+
+        var backupText = File.ReadAllText(backup);
+
+        if (backupText.Contains("{") && backupText.Contains("}"))
+        {
+            File.Copy(backup, configFile, true);
+        }
+        else
+        {
+            Logger.WriteLine("Error writing config");
+        }
+
+    }
 
     public static string GetModel()
     {
         if (_model is null)
         {
             _model = "";
-            using (var searcher = new ManagementObjectSearcher(@"Select * from Win32_ComputerSystem"))
+            try
             {
-                foreach (var process in searcher.Get())
+                using (var searcher = new ManagementObjectSearcher(@"Select * from Win32_ComputerSystem"))
                 {
-                    _model = process["Model"].ToString();
-                    break;
+                    foreach (var process in searcher.Get())
+                    {
+                        _model = process["Model"].ToString();
+                        break;
+                    }
                 }
             }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
         }
 
+        //if (_model.Contains("GA402RK")) _model = "ROG Zephyrus G14 GA403UI"; // Debug Purposes
+
         return _model;
     }
 
+    public static (string, string) GetBiosAndModel()
+    {
+        if (_bios is not null && _modelShort is not null) return (_bios, _modelShort);
+
+        using (ManagementObjectSearcher objSearcher = new ManagementObjectSearcher(@"SELECT * FROM Win32_BIOS"))
+        {
+            using (ManagementObjectCollection objCollection = objSearcher.Get())
+            {
+                foreach (ManagementObject obj in objCollection)
+                    if (obj["SMBIOSBIOSVersion"] is not null)
+                    {
+                        string[] results = obj["SMBIOSBIOSVersion"].ToString().Split(".");
+                        if (results.Length > 1)
+                        {
+                            _modelShort = results[0];
+                            _bios = results[1];
+                        }
+                        else
+                        {
+                            _modelShort = obj["SMBIOSBIOSVersion"].ToString();
+                        }
+                    }
+
+                return (_bios, _modelShort);
+            }
+        }
+    }
+
     public static string GetModelShort()
     {
         string model = GetModel();
@@ -79,7 +170,6 @@ public static class AppConfig
 
     public static bool ContainsModel(string contains)
     {
-
         GetModel();
         return (_model is not null && _model.ToLower().Contains(contains.ToLower()));
     }
@@ -96,8 +186,15 @@ public static class AppConfig
     public static int Get(string name, int empty = -1)
     {
         if (config.ContainsKey(name))
+        {
+            //Debug.WriteLine(name);
             return int.Parse(config[name].ToString());
-        else return empty;
+        }
+        else
+        {
+            //Debug.WriteLine(name + "E");
+            return empty;
+        }
     }
 
     public static bool Is(string name)
@@ -110,6 +207,11 @@ public static class AppConfig
         return Get(name) != 0;
     }
 
+    public static bool IsOnBattery(string zone)
+    {
+        return Get(zone + "_bat", Get(zone)) != 0;
+    }
+
     public static string GetString(string name, string empty = null)
     {
         if (config.ContainsKey(name))
@@ -119,15 +221,8 @@ public static class AppConfig
 
     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());
-        }
+        timer.Stop();
+        timer.Start();
     }
 
     public static void Set(string name, int value)
@@ -147,6 +242,11 @@ public static class AppConfig
         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();
@@ -205,27 +305,32 @@ public static class AppConfig
 
         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;
+            case AsusACPI.PerformanceTurbo:
+                switch (device)
+                {
+                    case AsusFan.GPU:
+                        return StringToBytes("14-3F-44-48-4C-50-54-62-16-1F-26-2D-39-47-55-5F");
+                    default:
+                        return StringToBytes("14-3F-44-48-4C-50-54-62-11-1A-22-29-34-43-51-5A");
+                }
+            case AsusACPI.PerformanceSilent:
+                switch (device)
+                {
+                    case AsusFan.GPU:
+                        return StringToBytes("3C-41-42-46-47-4B-4C-62-08-11-11-1D-1D-26-26-2D");
+                    default:
+                        return StringToBytes("3C-41-42-46-47-4B-4C-62-03-0C-0C-16-16-22-22-29");
+                }
             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;
+                switch (device)
+                {
+                    case AsusFan.GPU:
+                        return StringToBytes("3A-3D-40-44-48-4D-51-62-0C-16-1D-1F-26-2D-34-4A");
+                    default:
+                        return StringToBytes("3A-3D-40-44-48-4D-51-62-08-11-16-1A-22-29-30-45");
+                }
         }
 
-        return curve;
     }
 
     public static string GetModeString(string name)
@@ -253,4 +358,365 @@ public static class AppConfig
         Set(name + "_" + Modes.GetCurrent(), value);
     }
 
+    public static bool IsAlly()
+    {
+        return ContainsModel("RC71") || ContainsModel("RC72");
+    }
+
+    public static bool NoMKeys()
+    {
+        return (ContainsModel("Z13") && !IsARCNM()) ||
+               ContainsModel("FX706") ||
+               ContainsModel("FA706") ||
+               ContainsModel("FA506") ||
+               ContainsModel("FX506") ||
+               ContainsModel("Duo") ||
+               ContainsModel("FX505");
+    }
+
+    public static bool IsARCNM()
+    {
+        return ContainsModel("GZ301VIC");
+    }
+
+    public static bool IsTUF()
+    {
+        return ContainsModel("TUF");
+    }
+
+    public static bool IsProArt()
+    {
+        return ContainsModel("ProArt");
+    }
+
+    public static bool IsVivoZenbook()
+    {
+        return ContainsModel("Vivobook") || ContainsModel("Zenbook");
+    }
+
+    public static bool IsVivoZenPro()
+    {
+        return ContainsModel("Vivobook") || ContainsModel("Zenbook") || ContainsModel("ProArt");
+    }
+
+    public static bool IsHardwareFnLock()
+    {
+        return IsVivoZenPro();
+    }
+
+    // Devices with bugged bios command to change brightness
+    public static bool SwappedBrightness()
+    {
+        return ContainsModel("FA506IH") || ContainsModel("FA506IC") || ContainsModel("FX506LU") || ContainsModel("FX506IC") || ContainsModel("FX506LH") || ContainsModel("FA506IV") || ContainsModel("FA706IC") || ContainsModel("FA706IH");
+    }
+
+
+    public static bool IsDUO()
+    {
+        return ContainsModel("Duo") || ContainsModel("GX550") || ContainsModel("GX650") || ContainsModel("UX840");
+    }
+
+    // G14 2020 has no aura, but media keys instead
+    public static bool NoAura()
+    {
+        return (ContainsModel("GA401I") && !ContainsModel("GA401IHR")) || ContainsModel("GA502IU") || ContainsModel("HN7306");
+    }
+
+    public static bool MediaKeys()
+    {
+        return (ContainsModel("GA401I") && !ContainsModel("GA401IHR")) || ContainsModel("G712L");
+    }
+
+    public static bool IsSingleColor()
+    {
+        return ContainsModel("GA401") || ContainsModel("FX517Z") || ContainsModel("FX516P") || ContainsModel("X13") || IsARCNM() || ContainsModel("FA617N") || ContainsModel("FA617X") || NoAura();
+    }
+
+    public static bool IsAnimeMatrix()
+    {
+        return ContainsModel("GA401") || ContainsModel("GA402") || ContainsModel("GU604V");
+    }
+    
+    public static bool IsSlash()
+    {
+        return ContainsModel("GA403") || ContainsModel("GU605") || ContainsModel("GA605");
+    }
+
+    public static bool IsSlashAura()
+    {
+        return ContainsModel("GA605");
+    }
+
+    public static bool IsInputBacklight()
+    {
+        return ContainsModel("GA503") || IsSlash() || IsVivoZenPro();
+    }
+
+    public static bool IsInvertedFNLock()
+    {
+        return ContainsModel("M140");
+    }
+
+    public static bool IsOLED()
+    {
+        return ContainsModel("OLED") || IsSlash() || ContainsModel("M7600") || ContainsModel("UX64") || ContainsModel("UX34") || ContainsModel("UX53") || ContainsModel("K360") || ContainsModel("X150") || ContainsModel("M350") || ContainsModel("K650") || ContainsModel("UM53") || ContainsModel("K660") || ContainsModel("UX84") || ContainsModel("M650") || ContainsModel("M550") || ContainsModel("K340") || ContainsModel("K350") || ContainsModel("M140") || ContainsModel("UM340") || ContainsModel("S540") || ContainsModel("M7400") || ContainsModel("N650") || ContainsModel("HN7306") || ContainsModel("H7606") || ContainsModel("UX5406") || ContainsModel("M5606");
+    }
+
+    public static bool IsNoOverdrive()
+    {
+        return Is("no_overdrive");
+    }
+
+    public static bool IsNoSleepEvent()
+    {
+        return ContainsModel("FX505");
+    }
+
+    public static bool IsStrix()
+    {
+        return ContainsModel("Strix") || ContainsModel("Scar") || ContainsModel("G703G");
+    }
+
+    public static bool IsAdvancedRGB()
+    {
+        return IsStrix() || ContainsModel("GX650");
+    }
+
+    public static bool IsBacklightZones()
+    {
+        return IsStrix() || IsZ13();
+    }
+
+    public static bool IsStrixLimitedRGB()
+    {
+        return ContainsModel("G512LI") || ContainsModel("G513R") || ContainsModel("G713PV") || ContainsModel("G513IE") || ContainsModel("G713RC") || ContainsModel("G513QM") || ContainsModel("G531G");
+    }
+
+    public static bool IsPossible4ZoneRGB()
+    {
+        return ContainsModel("G614JI_") || ContainsModel("G614JV_") || ContainsModel("G614JZ") || IsStrixLimitedRGB();
+    }
+
+    public static bool Is4ZoneRGB()
+    {
+        return IsPossible4ZoneRGB() && !Is("per_key_rgb");
+    }
+
+    public static bool IsNoAirplaneMode()
+    {
+        return ContainsModel("FX506");
+    }
+
+    public static bool NoWMI()
+    {
+        return ContainsModel("GL704G") || ContainsModel("GM501G") || ContainsModel("GX501G");
+    }
+
+    public static bool IsNoDirectRGB()
+    {
+        return ContainsModel("GA503") || ContainsModel("G533Q") || ContainsModel("GU502") || ContainsModel("GU603") || IsSlash();
+    }
+
+    public static bool IsStrixNumpad()
+    {
+        return ContainsModel("G713R");
+    }
+
+    public static bool IsZ13()
+    {
+        return ContainsModel("Z13");
+    }
+
+    public static bool IsS17()
+    {
+        return ContainsModel("S17");
+    }
+
+    public static bool HasTabletMode()
+    {
+        return ContainsModel("X16") || ContainsModel("X13");
+    }
+
+    public static bool IsX13()
+    {
+        return ContainsModel("X13");
+    }
+
+    public static bool IsG14AMD()
+    {
+        return ContainsModel("GA402R");
+    }
+
+    public static bool DynamicBoost5()
+    {
+        return ContainsModel("GZ301ZE");
+    }
+
+    public static bool DynamicBoost15()
+    {
+        return ContainsModel("FX507ZC4");
+    }
+
+    public static bool DynamicBoost20()
+    {
+        return ContainsModel("GU605") || ContainsModel("GA605");
+    }
+
+    public static bool IsAdvantageEdition()
+    {
+        return ContainsModel("13QY");
+    }
+
+    public static bool NoAutoUltimate()
+    {
+        return ContainsModel("G614") || ContainsModel("GU604") || ContainsModel("FX507") || ContainsModel("G513") || ContainsModel("FA617") || ContainsModel("G834") || ContainsModel("GA403") || ContainsModel("GU605") || ContainsModel("GA605") || ContainsModel("GU603VV");
+    }
+
+
+    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()
+    {
+        if (!ContainsModel("GU604")) return false;
+
+        try
+        {
+            var (bios, model) = GetBiosAndModel();
+            return (Int32.Parse(bios) < 312);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsSwappedFans()
+    {
+        if (!ContainsModel("GA503R")) return false;
+
+        try
+        {
+            var (bios, model) = GetBiosAndModel();
+            var biosVersion = Int32.Parse(bios);
+            if (ContainsModel("GA503RM") && biosVersion == 317) return true;
+            if ((ContainsModel("GA503RS") || ContainsModel("GA503RW")) && biosVersion == 316) return true;
+            return false;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsResetRequired()
+    {
+        return ContainsModel("GA403");
+    }
+
+    public static bool IsFanRequired()
+    {
+        return ContainsModel("GA402X") || ContainsModel("G513") || ContainsModel("G713R") || ContainsModel("G713P") || ContainsModel("GU605") || ContainsModel("GA605") || ContainsModel("GA403") || ContainsModel("G634J") || ContainsModel("G834J") || ContainsModel("G614J") || ContainsModel("G814J") || ContainsModel("FX507V");
+    }
+
+    public static bool IsAMDLight()
+    {
+        return ContainsModel("GA402X") || ContainsModel("GA605") || ContainsModel("GA403") || ContainsModel("FA507N") || ContainsModel("FA507X") || ContainsModel("FA707N") || ContainsModel("FA707X");
+    }
+
+    public static bool IsPowerRequired()
+    {
+        return ContainsModel("FX507") || ContainsModel("FX517") || ContainsModel("FX707");
+    }
+
+    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") && IsNotFalse("gpu_mode_force_set"));
+    }
+
+    public static bool IsNoGPUModes()
+    {
+        return ContainsModel("GV301RA") || ContainsModel("GV302XA") || IsAlly();
+    }
+
+    public static bool NoGpu()
+    {
+        return Is("no_gpu") || ContainsModel("UX540");
+    }
+
+    public static bool IsHardwareTouchpadToggle()
+    {
+        return ContainsModel("FA507");
+    }
+
+    public static bool IsIntelHX()
+    {
+        return ContainsModel("G814") || ContainsModel("G614") || ContainsModel("G834") || ContainsModel("G634");
+    }
+
+    public static bool IsNoFNV()
+    {
+        return ContainsModel("FX507") || ContainsModel("FX707");
+    }
+
+    public static bool IsROG()
+    {
+        return ContainsModel("ROG");
+    }
+    public static bool IsASUS()
+    {
+        return ContainsModel("ROG") || ContainsModel("TUF") || ContainsModel("Vivobook") || ContainsModel("Zenbook");
+    }
+
+    public static bool IsBWIcon()
+    {
+        return Is("bw_icon");
+    }
+
+    public static bool IsStopAC()
+    {
+        return IsAlly() || Is("stop_ac");
+    }
+
+    public static bool IsChargeLimit6080()
+    {
+        return ContainsModel("GA403U") || ContainsModel("GU605") || ContainsModel("GA605") || ContainsModel("GA503R") || (IsTUF() && !(ContainsModel("FX507Z") || ContainsModel("FA617")));
+
+    }
+
+    // 2024 Models support Dynamic Lighting
+    public static bool IsDynamicLighting()
+    {
+        return IsSlash() || IsIntelHX() || IsTUF();
+    }
+
+    public static bool IsForceMiniled()
+    {
+        return ContainsModel("G834JYR") || ContainsModel("G834JZR") || Is("force_miniled");
+    }
+    public static bool SaveDimming()
+    {
+        return Is("save_dimming");
+    }
+
+    public static bool IsAutoStatusLed()
+    {
+        return Is("auto_status_led");
+    }
+
+
 }

app/AsusACPI.cs

@@ -1,4 +1,6 @@
-using System.Management;
+using GHelper;
+using GHelper.USB;
+using System.Management;
 using System.Runtime.InteropServices;
 
 public enum AsusFan
@@ -34,16 +36,21 @@ public class AsusACPI
     const uint INIT = 0x54494E49;
 
     public const uint UniversalControl = 0x00100021;
-    
+
+    public const int Airplane = 0x88;
     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_TouchpadToggle = 0x6b;
+    public const int KB_MuteToggle = 0x7c;
+    public const int KB_FNlockToggle = 0x4e;
+
     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;
@@ -55,16 +62,29 @@ public class AsusACPI
     public const uint GPU_Fan = 0x00110014;
     public const uint Mid_Fan = 0x00110031;
 
-    public const uint PerformanceMode = 0x00120075; // Thermal Control
+    public const uint BatteryDischarge = 0x0012005A;
+
+    public const uint PerformanceMode = 0x00120075; // Performance modes
+    public const uint VivoBookMode = 0x00110019; // Vivobook performance modes
+
+    public const uint GPUEcoROG = 0x00090020;
+    public const uint GPUEcoVivo = 0x00090120;
 
-    public const uint GPUEco = 0x00090020;
     public const uint GPUXGConnected = 0x00090018;
     public const uint GPUXG = 0x00090019;
-    public const uint GPUMux = 0x00090016;
+
+    public const uint GPUMuxROG = 0x00090016;
+    public const uint GPUMuxVivo = 0x00090026;
 
     public const uint BatteryLimit = 0x00120057;
+
     public const uint ScreenOverdrive = 0x00050019;
-    public const uint ScreenMiniled = 0x0005001E;
+    public const uint ScreenMiniled1 = 0x0005001E;
+    public const uint ScreenMiniled2 = 0x0005002E;
+    public const uint ScreenFHD = 0x0005001C;
+
+    public const uint DevsCPUFan = 0x00110022;
+    public const uint DevsGPUFan = 0x00110023;
 
     public const uint DevsCPUFanCurve = 0x00110024;
     public const uint DevsGPUFanCurve = 0x00110025;
@@ -73,10 +93,10 @@ public class AsusACPI
     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_APUA0 = 0x001200A0;  // sPPT (slow boost limit) / PL2
     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_APUA3 = 0x001200A3;  // SPL (sustained limit) / PL1
 
     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)
@@ -85,16 +105,36 @@ public class AsusACPI
     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 uint CORES_CPU = 0x001200D2; // Intel E-core and P-core configuration in a format 0x0[E]0[P]
+    public const uint CORES_MAX = 0x001200D3; // Maximum Intel E-core and P-core availability
+
+    public const uint GPU_BASE  = 0x00120099;  // Base part GPU TGP
+    public const uint GPU_POWER = 0x00120098;  // Additonal part of GPU TGP
+
+    public const int APU_MEM = 0x000600C1;
+
     public const int TUF_KB_BRIGHTNESS = 0x00050021;
+    public const int KBD_BACKLIGHT_OOBE = 0x0005002F;
+
     public const int TUF_KB = 0x00100056;
+    public const int TUF_KB2 = 0x0010005a;
+
     public const int TUF_KB_STATE = 0x00100057;
 
+    public const int MicMuteLed = 0x00040017;
+
     public const int TabletState = 0x00060077;
     public const int FnLock = 0x00100023;
 
     public const int ScreenPadToggle = 0x00050031;
     public const int ScreenPadBrightness = 0x00050032;
 
+    public const int CameraShutter = 0x00060078;
+    public const int CameraLed = 0x00060079;
+    public const int StatusLed = 0x000600C2;
+
+    public const int BootSound = 0x00130022;
+
     public const int Tablet_Notebook = 0;
     public const int Tablet_Tablet = 1;
     public const int Tablet_Tent = 2;
@@ -109,20 +149,35 @@ public class AsusACPI
     public const int GPUModeStandard = 1;
     public const int GPUModeUltimate = 2;
 
-    public static int MaxTotal => AppConfig.ContainsModel("13QY") ? 250 : 150;
     public const int MinTotal = 5;
-    public const int DefaultTotal = 125;
 
-    public const int MaxCPU = 100;
+    public static int MaxTotal = 150;
+    public static int DefaultTotal = 80;
+
     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 static int MaxGPUBoost = 25;
+
+    public static int MinGPUPower = 0;
+    public static int MaxGPUPower = 70;
 
     public const int MinGPUTemp = 75;
     public const int MaxGPUTemp = 87;
 
+    public const int PCoreMin = 4;
+    public const int ECoreMin = 0;
+
+    public const int PCoreMax = 16;
+    public const int ECoreMax = 16;
+
+    private bool? _allAMD = null;
+    private bool? _overdrive = null;
+
+    public static uint GPUEco => AppConfig.IsVivoZenPro() ? GPUEcoVivo : GPUEcoROG;
+    public static uint GPUMux => AppConfig.IsVivoZenPro() ? GPUMuxVivo : GPUMuxROG;
 
     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
     private static extern IntPtr CreateFile(
@@ -168,6 +223,7 @@ public class AsusACPI
     private static extern bool WaitForSingleObject(IntPtr hHandle, int dwMilliseconds);
 
     private IntPtr eventHandle;
+    private bool _connected = false;
 
     // 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()
@@ -194,23 +250,83 @@ public class AsusACPI
         }
     }
 
+    public bool IsConnected()
+    {
+        return _connected;
+    }
 
     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))
+        try
         {
-            throw new Exception("Can't connect to ACPI");
+            handle = CreateFile(
+                FILE_NAME,
+                GENERIC_READ | GENERIC_WRITE,
+                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                IntPtr.Zero,
+                OPEN_EXISTING,
+                FILE_ATTRIBUTE_NORMAL,
+                IntPtr.Zero
+            );
+
+            //handle = new IntPtr(-1);
+            //throw new Exception("ERROR");
+            _connected = true;
+
         }
+        catch (Exception ex)
+        {
+            Logger.WriteLine($"Can't connect to ACPI: {ex.Message}");
+        }
+
+        if (AppConfig.IsAdvantageEdition())
+        {
+            MaxTotal = 250;
+        }
+
+        if (AppConfig.IsG14AMD())
+        {
+            DefaultTotal = 125;
+        }
+
+        if (AppConfig.IsX13())
+        {
+            MaxTotal = 75;
+            DefaultTotal = 50;
+        }
+
+        if (AppConfig.IsAlly())
+        {
+            MaxTotal = 50;
+            DefaultTotal = 30;
+        }
+
+        if (AppConfig.IsIntelHX())
+        {
+            MaxTotal = 175;
+        }
+
+        if (AppConfig.DynamicBoost5())
+        {
+            MaxGPUBoost = 5;
+        }
+
+        if (AppConfig.DynamicBoost15())
+        {
+            MaxGPUBoost = 15;
+        }
+
+        if (AppConfig.DynamicBoost20())
+        {
+            MaxGPUBoost = 20;
+        }
+
+        if (AppConfig.IsAMDLight())
+        {
+            MaxTotal = 90;
+        }
+
+
 
     }
 
@@ -239,7 +355,7 @@ public class AsusACPI
     protected byte[] CallMethod(uint MethodID, byte[] args)
     {
         byte[] acpiBuf = new byte[8 + args.Length];
-        byte[] outBuffer = new byte[20];
+        byte[] outBuffer = new byte[16];
 
         BitConverter.GetBytes((uint)MethodID).CopyTo(acpiBuf, 0);
         BitConverter.GetBytes((uint)args.Length).CopyTo(acpiBuf, 4);
@@ -260,7 +376,7 @@ public class AsusACPI
 
     }
 
-    public int DeviceSet(uint DeviceID, int Status, string logName)
+    public int DeviceSet(uint DeviceID, int Status, string? logName)
     {
         byte[] args = new byte[8];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
@@ -269,12 +385,14 @@ public class AsusACPI
         byte[] status = CallMethod(DEVS, args);
         int result = BitConverter.ToInt32(status, 0);
 
-        Logger.WriteLine(logName + " = " + Status + " : " + (result == 1 ? "OK" : result));
+        if (logName is not null)
+            Logger.WriteLine(logName + " = " + Status + " : " + (result == 1 ? "OK" : result));
+
         return result;
     }
 
 
-    public int DeviceSet(uint DeviceID, byte[] Params, string logName)
+    public int DeviceSet(uint DeviceID, byte[] Params, string? logName)
     {
         byte[] args = new byte[4 + Params.Length];
         BitConverter.GetBytes((uint)DeviceID).CopyTo(args, 0);
@@ -283,7 +401,9 @@ public class AsusACPI
         byte[] status = CallMethod(DEVS, args);
         int result = BitConverter.ToInt32(status, 0);
 
-        Logger.WriteLine(logName + " = " + BitConverter.ToString(Params) + " : " + (result == 1 ? "OK" : result));
+        if (logName is not null)
+            Logger.WriteLine(logName + " = " + BitConverter.ToString(Params) + " : " + (result == 1 ? "OK" : result));
+
         return BitConverter.ToInt32(status, 0);
     }
 
@@ -307,20 +427,97 @@ public class AsusACPI
         return CallMethod(DSTS, args);
     }
 
+
+    public decimal? GetBatteryDischarge()
+    {
+        var buffer = DeviceGetBuffer(BatteryDischarge);
+
+        if (buffer[2] > 0)
+        {
+            buffer[2] = 0;
+            return (decimal)BitConverter.ToInt16(buffer, 0) / 100;
+        }
+        else
+        {
+            return null;
+        }
+    }
+
+
+    public int SetVivoMode(int mode)
+    {
+        if (mode == 1) mode = 2;
+        else if (mode == 2) mode = 1;
+        return Program.acpi.DeviceSet(VivoBookMode, mode, "VivoMode");
+    }
+
     public int SetGPUEco(int eco)
     {
-        int ecoFlag = DeviceGet(GPUEco);
+        uint ecoEndpoint = GPUEco;
+
+        int ecoFlag = DeviceGet(ecoEndpoint);
         if (ecoFlag < 0) return -1;
 
         if (ecoFlag == 1 && eco == 0)
-            return DeviceSet(GPUEco, eco, "GPUEco");
+            return DeviceSet(ecoEndpoint, eco, "GPUEco");
 
         if (ecoFlag == 0 && eco == 1)
-            return DeviceSet(GPUEco, eco, "GPUEco");
+            return DeviceSet(ecoEndpoint, 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)
+    {
+
+        if (curve.Length != 16) return -1;
+        if (curve.All(singleByte => singleByte == 0)) return -1;
+
+        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)
     {
@@ -329,13 +526,19 @@ public class AsusACPI
         if (curve.All(singleByte => singleByte == 0)) return -1;
 
         int result;
-        int fanScale = AppConfig.Get("fan_scale", 100);
+
+        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% 
+        if (AppConfig.IsSwappedFans())
+        {
+            device = (device == AsusFan.CPU) ? AsusFan.GPU : AsusFan.CPU;
+            Logger.WriteLine("Swapped fan fix");
+        }
 
-        for (int i = 8; i < curve.Length; i++) curve[i] = (byte)(Math.Max((byte)0, Math.Min((byte)99, curve[i])) * fanScale / 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)
         {
@@ -365,16 +568,25 @@ public class AsusACPI
             default: fan_mode = 0; break;
         }
 
+        byte[] result;
+
         switch (device)
         {
             case AsusFan.GPU:
-                return DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
+                result = DeviceGetBuffer(DevsGPUFanCurve, fan_mode);
+                break;
             case AsusFan.Mid:
-                return DeviceGetBuffer(DevsMidFanCurve, fan_mode);
+                result = DeviceGetBuffer(DevsMidFanCurve, fan_mode);
+                break;
             default:
-                return DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
+                result = DeviceGetBuffer(DevsCPUFanCurve, fan_mode);
+                break;
         }
 
+        //Logger.WriteLine($"GetFan {device} :" + BitConverter.ToString(result));
+
+        return result;
+
     }
 
     public static bool IsInvalidCurve(byte[] curve)
@@ -392,7 +604,14 @@ public class AsusACPI
         if (curve.Length != 16) throw new Exception("Incorrect curve");
 
         var points = new Dictionary<byte, byte>();
-        for (int i = 0; i < 8; i++) points[curve[i]] = curve[i + 8];
+        byte old = 0;
+
+        for (int i = 0; i < 8; i++)
+        {
+            if (curve[i] <= old) curve[i] = (byte)Math.Min(100, old + 6); // 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;
@@ -425,53 +644,174 @@ public class AsusACPI
 
     public bool IsXGConnected()
     {
-        //return true;
         return DeviceGet(GPUXGConnected) == 1;
     }
 
     public bool IsAllAmdPPT()
     {
-        return DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0;
+        if (_allAMD is null) _allAMD = DeviceGet(PPT_CPUB0) >= 0 && DeviceGet(PPT_GPUC0) < 0 && !AppConfig.IsAlly();
+        return (bool)_allAMD;
     }
 
+    public bool IsOverdriveSupported()
+    {
+        if (_overdrive is null) _overdrive = DeviceGet(ScreenOverdrive) >= 0;
+        return (bool)_overdrive;
+    }
 
-    public void ScanRange()
+    public bool IsNVidiaGPU()
+    {
+        return (!IsAllAmdPPT() && Program.acpi.DeviceGet(GPUEco) >= 0 && !AppConfig.IsAlly());
+    }
+
+    public void SetAPUMem(int memory = 4)
+    {
+        if (memory < 0 || memory > 8) return;
+
+        int mem = 0;
+
+        switch (memory)
+        {
+            case 0:
+                mem = 0;
+                break;
+            case 1:
+                mem = 258;
+                break;
+            case 2:
+                mem = 259;
+                break;
+            case 3:
+                mem = 260;
+                break;
+            case 4:
+                mem = 261;
+                break;
+            case 5:
+                mem = 263;
+                break;
+            case 6:
+                mem = 264;
+                break;
+            case 7:
+                mem = 265;
+                break;
+            case 8:
+                mem = 262;
+                break;
+        }
+
+        Program.acpi.DeviceSet(APU_MEM, mem, "APU Mem");
+    }
+
+    public int GetAPUMem()
+    {
+        int memory = Program.acpi.DeviceGet(APU_MEM);
+        if (memory < 0) return -1;
+
+        switch (memory)
+        {
+            case 256:
+                return 0;
+            case 258:
+                return 1;
+            case 259:
+                return 2;
+            case 260:
+                return 3;
+            case 261:
+                return 4;
+            case 262:
+                return 8;
+            case 263:
+                return 5;
+            case 264:
+                return 6;
+            case 265:
+                return 7;
+            default:
+                return 4;
+        }
+    }
+
+    public (int, int) GetCores(bool max = false)
+    {
+        int value = Program.acpi.DeviceGet(max ? CORES_MAX : CORES_CPU);
+        //value = max ? 0x406 : 0x605;
+
+        if (value < 0) return (-1, -1);
+        Logger.WriteLine("Cores" + (max ? "Max" : "") + ": 0x" + value.ToString("X4"));
+
+        return ((value >> 8) & 0xFF, (value) & 0xFF);
+    }
+
+    public void SetCores(int eCores, int pCores)
+    {
+        if (eCores < ECoreMin || eCores > ECoreMax || pCores < PCoreMin || pCores > PCoreMax)
+        {
+            Logger.WriteLine($"Incorrect Core config ({eCores}, {pCores})");
+            return;
+        };
+
+        int value = (eCores << 8) | pCores;
+        Program.acpi.DeviceSet(CORES_CPU, value, "Cores (0x" + value.ToString("X4") + ")");
+    }
+
+    public string ScanRange()
     {
         int value;
         string appPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\GHelper";
         string logFile = appPath + "\\scan.txt";
-        for (uint i = 0x00000000; i <= 0x00160000; i++)
+        using (StreamWriter w = File.AppendText(logFile))
         {
-            value = DeviceGet(i);
-            if (value >= 0)
-                using (StreamWriter w = File.AppendText(logFile))
+            w.WriteLine($"Scan started {DateTime.Now}");
+            for (uint i = 0x00000000; i <= 0x00160000; i += 0x10000)
+            {
+                for (uint j = 0x00; j <= 0xFF; j++)
                 {
-                    w.WriteLine(i.ToString("X8") + ": " + value.ToString("X4") + " (" + value + ")");
-                    w.Close();
+                    uint id = i + j;
+                    value = DeviceGet(id);
+                    if (value >= 0)
+                    {
+                        w.WriteLine(id.ToString("X8") + ": " + value.ToString("X4") + " (" + value + ")");
+                    }
                 }
+            }
+            w.WriteLine($"---------------------");
+            w.Close();
         }
 
+        return logFile;
+
     }
 
     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)
+    public void TUFKeyboardRGB(AuraMode mode, Color color, int speed, string? log = "TUF RGB")
     {
 
-        byte[] setting = new byte[12];
-        setting[0] = (byte)0xB4;
+        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;
 
-        DeviceSet(TUF_KB, setting, "TUF RGB");
-        //Debug.WriteLine(BitConverter.ToString(setting));
+        int result = DeviceSet(TUF_KB, setting, log);
+        if (result != 1)
+        {
+            setting[0] = (byte)0xb3;
+            DeviceSet(TUF_KB2, setting, log);
+            setting[0] = (byte)0xb4;
+            DeviceSet(TUF_KB2, setting, log);
+        }
 
     }
 
@@ -491,6 +831,7 @@ public class AsusACPI
         state = state | 0x01 << 8;
 
         DeviceSet(TUF_KB_STATE, state, "TUF_KB");
+        if (AppConfig.IsVivoZenPro() && DeviceGet(KBD_BACKLIGHT_OOBE) >= 0) DeviceSet(KBD_BACKLIGHT_OOBE, 1, "VIVO OOBE");
     }
 
     public void SubscribeToEvents(Action<object, EventArrivedEventArgs> EventHandler)

app/AsusMouseSettings.cs

@@ -0,0 +1,979 @@
+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;
+
+            buttonExport.Text = Properties.Strings.Export;
+            buttonImport.Text = Properties.Strings.Import;
+
+            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;
+            }
+
+            var index = comboBoxLightingMode.SelectedIndex;
+            LightingMode lm = supportedLightingModes[index < supportedLightingModes.Count ? index : 0 ];
+
+            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()
+        {
+            if (mouse.Profile < comboProfile.Items.Count)
+                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()
+        {
+            if (mouse.DpiProfile > mouse.DpiSettings.Length)
+            {
+                Logger.WriteLine($"Wrong mouse DPI: {mouse.DpiProfile}");
+                return;
+            }
+
+            AsusMouseDPI dpi;
+
+            try
+            {
+                dpi = mouse.DpiSettings[mouse.DpiProfile - 1];
+            } catch (Exception ex)
+            {
+                Logger.WriteLine($"Wrong mouse DPI: {mouse.DpiProfile} {mouse.DpiSettings.Length} {ex.Message}");
+                return;
+            }
+
+            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();
+        }
+
+        private void buttonImport_Click(object sender, EventArgs e)
+        {
+            byte[] data = null;
+
+            Thread t = new Thread(() =>
+            {
+                OpenFileDialog ofd = new OpenFileDialog();
+                ofd.Filter = "G-Helper Mouse Profile V1 (*.gmp1)|*.gmp1";
+
+                if (ofd.ShowDialog() == DialogResult.OK)
+                {
+                    data = File.ReadAllBytes(ofd.FileName);
+                }
+            });
+
+            t.SetApartmentState(ApartmentState.STA);
+            t.Start();
+            t.Join();
+
+            if (data == null)
+            {
+                //User aborted loading
+                return;
+            }
+
+            if (!mouse.Import(data))
+            {
+                Logger.WriteLine("Failed to import mouse profile");
+                MessageBox.Show(Properties.Strings.MouseImportFailed);
+            }
+            else
+            {
+                if (!mouse.IsLightingZoned())
+                {
+                    visibleZone = LightingZone.All;
+                }
+
+                RefreshMouseData();
+            }
+        }
+
+        private void buttonExport_Click(object sender, EventArgs e)
+        {
+            Thread t = new Thread(() =>
+            {
+                SaveFileDialog sfd = new SaveFileDialog();
+                sfd.Filter = "G-Helper Mouse Profile V1 (*.gmp1)|*.gmp1";
+
+                if (sfd.ShowDialog() == DialogResult.OK)
+                {
+                    File.WriteAllBytes(sfd.FileName, mouse.Export());
+                }
+            });
+
+            t.SetApartmentState(ApartmentState.STA);
+            t.Start();
+            t.Join();
+        }
+    }
+}

app/AsusMouseSettings.resx

@@ -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>

app/AsusUSB.cs

@@ -1,459 +0,0 @@
-using HidLibrary;
-using System.Text;
-
-namespace GHelper
-{
-
-    [Flags]
-    public enum AuraDev19b6 : uint
-    {
-        BootLogo = 1,
-        BootKeyb = 1 << 1,
-        AwakeLogo = 1 << 2,
-        AwakeKeyb = 1 << 3,
-        SleepLogo = 1 << 4,
-        SleepKeyb = 1 << 5,
-        ShutdownLogo = 1 << 6,
-        ShutdownKeyb = 1 << 7,
-        BootBar = 1u << (7 + 2),
-        AwakeBar = 1u << (7 + 3),
-        SleepBar = 1u << (7 + 4),
-        ShutdownBar = 1u << (7 + 5),
-        BootLid = 1u << (15 + 1),
-        AwakeLid = 1u << (15 + 2),
-        SleepLid = 1u << (15 + 3),
-        ShutdownLid = 1u << (15 + 4)
-    }
-
-    public static class AuraDev19b6Extensions
-    {
-        public static byte[] ToBytes(this AuraDev19b6[] controls)
-        {
-            uint a = 0;
-            foreach (var n in controls)
-            {
-                a |= (uint)n;
-            }
-            return new byte[] { 0x5d, 0xbd, 0x01, (byte)(a & 0xff), (byte)((a & 0xff00) >> 8), (byte)((a & 0xff0000) >> 16) };
-        }
-
-        public static ushort BitOr(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self | rhs);
-        }
-
-        public static ushort BitAnd(this AuraDev19b6 self, AuraDev19b6 rhs)
-        {
-            return (ushort)(self & rhs);
-        }
-    }
-
-
-    public static class AsusUSB
-    {
-
-        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, 0x08 };
-        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, 0x08 };
-
-        static byte[] MESSAGE_SET = { AURA_HID_ID, 0xb5, 0, 0, 0 };
-        static byte[] MESSAGE_APPLY = { AURA_HID_ID, 0xb4 };
-
-        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;
-
-
-        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> _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 },
-            };
-
-        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" },
-            };
-
-
-        public static Dictionary<int, string> GetModes()
-        {
-            if (AppConfig.ContainsModel("TUF"))
-            {
-                _modes.Remove(3);
-            }
-
-            if (AppConfig.ContainsModel("401") || AppConfig.ContainsModel("X13"))
-            {
-                _modes.Remove(2);
-                _modes.Remove(3);
-            }
-
-            if (AppConfig.ContainsModel("G513QY"))
-            {
-                return _modes;
-            }
-
-            if (AppConfig.ContainsModel("Strix") || AppConfig.ContainsModel("Scar"))
-            {
-                return _modesStrix;
-            }
-
-            return _modes;
-        }
-
-
-        public static int Mode
-        {
-            get { return mode; }
-            set
-            {
-                if (GetModes().ContainsKey(value))
-                    mode = value;
-                else
-                    mode = 0;
-            }
-        }
-
-        public static bool HasColor()
-        {
-            return AppConfig.ContainsModel("GA401") || AppConfig.ContainsModel("X13");
-        }
-
-        public static bool HasSecondColor()
-        {
-            return (mode == 1 && !AppConfig.ContainsModel("TUF"));
-        }
-
-        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)
-        {
-
-            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] = (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 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")
-        {
-
-            if (AppConfig.ContainsModel("TUF"))
-                Program.acpi.TUFKeyboardBrightness(brightness);
-
-
-            Task.Run(async () =>
-            {
-
-                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()
-        {
-
-            List<AuraDev19b6> flags = new();
-
-            // Keyboard
-            if (AppConfig.IsNotFalse("keyboard_awake")) flags.Add(AuraDev19b6.AwakeKeyb);
-            if (AppConfig.IsNotFalse("keyboard_boot")) flags.Add(AuraDev19b6.BootKeyb);
-            if (AppConfig.IsNotFalse("keyboard_sleep")) flags.Add(AuraDev19b6.SleepKeyb);
-            if (AppConfig.IsNotFalse("keyboard_shutdown")) flags.Add(AuraDev19b6.ShutdownKeyb);
-
-            // Lightbar
-            if (AppConfig.IsNotFalse("keyboard_awake_bar")) flags.Add(AuraDev19b6.AwakeBar);
-            if (AppConfig.IsNotFalse("keyboard_boot_bar")) flags.Add(AuraDev19b6.BootBar);
-            if (AppConfig.IsNotFalse("keyboard_sleep_bar")) flags.Add(AuraDev19b6.SleepBar);
-            if (AppConfig.IsNotFalse("keyboard_shutdown_bar")) flags.Add(AuraDev19b6.ShutdownBar);
-
-            // Lid
-            if (AppConfig.IsNotFalse("keyboard_awake_lid")) flags.Add(AuraDev19b6.AwakeLid);
-            if (AppConfig.IsNotFalse("keyboard_boot_lid")) flags.Add(AuraDev19b6.BootLid);
-            if (AppConfig.IsNotFalse("keyboard_sleep_lid")) flags.Add(AuraDev19b6.SleepLid);
-            if (AppConfig.IsNotFalse("keyboard_shutdown_lid")) flags.Add(AuraDev19b6.ShutdownLid);
-
-            // Logo
-            if (AppConfig.IsNotFalse("keyboard_awake_logo")) flags.Add(AuraDev19b6.AwakeLogo);
-            if (AppConfig.IsNotFalse("keyboard_boot_logo")) flags.Add(AuraDev19b6.BootLogo);
-            if (AppConfig.IsNotFalse("keyboard_sleep_logo")) flags.Add(AuraDev19b6.SleepLogo);
-            if (AppConfig.IsNotFalse("keyboard_shutdown_logo")) flags.Add(AuraDev19b6.ShutdownLogo);
-
-
-            byte[] msg = AuraDev19b6Extensions.ToBytes(flags.ToArray());
-
-
-            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("USB-KB " + device.Attributes.ProductHexId + ":" + BitConverter.ToString(msg));
-                }
-                device.CloseDevice();
-            }
-
-            if (AppConfig.ContainsModel("TUF"))
-                Program.acpi.TUFKeyboardPower(
-                    flags.Contains(AuraDev19b6.AwakeKeyb),
-                    flags.Contains(AuraDev19b6.BootKeyb),
-                    flags.Contains(AuraDev19b6.SleepKeyb),
-                    flags.Contains(AuraDev19b6.ShutdownKeyb));
-
-        }
-
-
-        public static void ApplyAura()
-        {
-
-            Mode = AppConfig.Get("aura_mode");
-            Speed = AppConfig.Get("aura_speed");
-            SetColor(AppConfig.Get("aura_color"));
-            SetColor2(AppConfig.Get("aura_color2"));
-
-            int _speed;
-
-            switch (Speed)
-            {
-                case 1:
-                    _speed = 0xeb;
-                    break;
-                case 2:
-                    _speed = 0xf5;
-                    break;
-                default:
-                    _speed = 0xe1;
-                    break;
-            }
-
-            byte[] msg = AuraMessage(Mode, Color1, Color2, _speed);
-            var devices = GetHidDevices(deviceIds);
-
-            foreach (HidDevice device in devices)
-            {
-                device.OpenDevice();
-                if (device.ReadFeatureData(out byte[] data, AURA_HID_ID))
-                {
-                    device.WriteFeatureData(msg);
-                    device.WriteFeatureData(MESSAGE_SET);
-                    device.WriteFeatureData(MESSAGE_APPLY);
-                    Logger.WriteLine("USB-KB " + device.Capabilities.FeatureReportByteLength + "|" + device.Capabilities.InputReportByteLength + device.Description + device.DevicePath + ":" + BitConverter.ToString(msg));
-                }
-                device.CloseDevice();
-            }
-
-            if (AppConfig.ContainsModel("TUF"))
-                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 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;
-
-            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);
-        }
-
-
-    }
-
-}

app/AutoUpdate/AutoUpdateControl.cs

@@ -1,4 +1,5 @@
-using System.Diagnostics;
+using GHelper.Helpers;
+using System.Diagnostics;
 using System.Net;
 using System.Reflection;
 using System.Text.Json;
@@ -16,7 +17,8 @@ namespace GHelper.AutoUpdate
         public AutoUpdateControl(SettingsForm settingsForm)
         {
             settings = settingsForm;
-            settings.SetVersionLabel(Properties.Strings.VersionLabel + ": " + Assembly.GetExecutingAssembly().GetName().Version);
+            var appVersion = new Version(Assembly.GetExecutingAssembly().GetName().Version.ToString());
+            settings.SetVersionLabel(Properties.Strings.VersionLabel + $": {appVersion.Major}.{appVersion.Minor}.{appVersion.Build}");
         }
 
         public void CheckForUpdates()
@@ -34,12 +36,20 @@ namespace GHelper.AutoUpdate
 
         public void LoadReleases()
         {
-            Process.Start(new ProcessStartInfo(versionUrl) { UseShellExecute = true });
+            try
+            {
+                Process.Start(new ProcessStartInfo(versionUrl) { UseShellExecute = true });
+            } catch (Exception ex)
+            {
+                Logger.WriteLine("Failed to open releases page:" + ex.Message);
+            }
         }
 
         async void CheckForUpdatesAsync()
         {
 
+            if (AppConfig.Is("skip_updates")) return;
+
             try
             {
 
@@ -104,6 +114,7 @@ namespace GHelper.AutoUpdate
 
             string exeLocation = Application.ExecutablePath;
             string exeDir = Path.GetDirectoryName(exeLocation);
+            string exeName = Path.GetFileName(exeLocation);
             string zipLocation = exeDir + "\\" + zipName;
 
             using (WebClient client = new WebClient())
@@ -111,15 +122,28 @@ namespace GHelper.AutoUpdate
                 client.DownloadFile(uri, zipLocation);
 
                 Logger.WriteLine(requestUri);
-                Logger.WriteLine(zipLocation);
-                Logger.WriteLine(exeLocation);
+                Logger.WriteLine(exeDir);
+                Logger.WriteLine(zipName);
+                Logger.WriteLine(exeName);
 
-                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();
+                string command = $"$ErrorActionPreference = \"Stop\"; Wait-Process -Name \"GHelper\"; Expand-Archive \"{zipName}\" -DestinationPath . -Force; Remove-Item \"{zipName}\" -Force; \".\\{exeName}\"; "; 
+                Logger.WriteLine(command);
+
+                try
+                {
+                    var cmd = new Process();
+                    cmd.StartInfo.WorkingDirectory = exeDir;
+                    cmd.StartInfo.UseShellExecute = false;
+                    cmd.StartInfo.CreateNoWindow = true;
+                    cmd.StartInfo.FileName = "powershell";
+                    cmd.StartInfo.Arguments = command;
+                    if (ProcessHelper.IsUserAdministrator()) cmd.StartInfo.Verb = "runas";
+                    cmd.Start();
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                }
 
                 Application.Exit();
             }

app/Battery/BatteryControl.cs

@@ -1,19 +1,89 @@
-namespace GHelper.Battery
+using System.Diagnostics;
+
+namespace GHelper.Battery
 {
-    internal class BatteryControl
+    public static class BatteryControl
     {
 
+        static bool _chargeFull = AppConfig.Is("charge_full");
+        public static bool chargeFull
+        {
+            get
+            {
+                return _chargeFull;
+            }
+            set
+            {
+                AppConfig.Set("charge_full", value ? 1 : 0);
+                _chargeFull = value;
+            }
+        }
+
+        public static void ToggleBatteryLimitFull()
+        {
+            if (chargeFull) SetBatteryChargeLimit();
+            else SetBatteryLimitFull();
+        }
+
+        public static void SetBatteryLimitFull()
+        {
+            chargeFull = true;
+            Program.acpi.DeviceSet(AsusACPI.BatteryLimit, 100, "BatteryLimit");
+            Program.settingsForm.VisualiseBatteryFull();
+        }
+
+        public static void UnSetBatteryLimitFull()
+        {
+            chargeFull = false;
+            Logger.WriteLine("Battery fully charged");
+            Program.settingsForm.Invoke(Program.settingsForm.VisualiseBatteryFull);
+        }
+
+        public static void AutoBattery(bool init = false)
+        {
+            if (chargeFull && !init) SetBatteryLimitFull();
+            else SetBatteryChargeLimit();
+        }
+
         public static void SetBatteryChargeLimit(int limit = -1)
         {
 
             if (limit < 0) limit = AppConfig.Get("charge_limit");
             if (limit < 40 || limit > 100) return;
 
-            Program.settingsForm.VisualiseBattery(limit);
+            if (AppConfig.IsChargeLimit6080())
+            {
+                if (limit > 85) limit = 100;
+                else if (limit >= 80) limit = 80;
+                else if (limit < 60) limit = 60;
+            }
+
             Program.acpi.DeviceSet(AsusACPI.BatteryLimit, limit, "BatteryLimit");
 
             AppConfig.Set("charge_limit", limit);
+            chargeFull = false;
 
+            Program.settingsForm.VisualiseBattery(limit);
+        }
+
+        public static void BatteryReport()
+        {
+            var reportDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+
+            try
+            {
+                var cmd = new Process();
+                cmd.StartInfo.WorkingDirectory = reportDir;
+                cmd.StartInfo.UseShellExecute = false;
+                cmd.StartInfo.CreateNoWindow = true;
+                cmd.StartInfo.FileName = "powershell";
+                cmd.StartInfo.Arguments = "powercfg /batteryreport; explorer battery-report.html";
+                cmd.Start();
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
         }
 
     }

app/Display/ColorProfileHelper.cs

@@ -0,0 +1,578 @@
+using GHelper.Helpers;
+using System.IO.Compression;
+
+namespace GHelper.Display
+{
+    public static class ColorProfileHelper
+    {
+        public static string? GetProfileUrl(string model)
+        {
+            byte[] data = Convert.FromBase64String("aHR0cHM6Ly9kbGNkbi1yb2dib3hidTEuYXN1cy5jb20vcHViL0FTVVMvQVBTZXJ2aWNlL0dhbWluZy9TWVMvUk9HUy8=");
+            string baseUrl = System.Text.Encoding.UTF8.GetString(data);
+
+            var profiles = new Dictionary<string, string>()
+            {
+                {"FA_Series", "2177-APOR41-de476ec68578c865e886ef6872aa56ee.zip"},
+                {"FA401UI", "19767-N39QWK-05990dae2bf601e9db8b998bfad49f57.zip"},
+                {"FA401UU", "19768-K9LFCV-5224d6f68051d884a3adaa588e6300c3.zip"},
+                {"FA401UV", "19769-8MSQD6-d06ff0a176407b4eaeed468a3bff2bc1.zip"},
+                {"FA401WI", "19937-J3GRCD-e37d8c1557b9f11d8fb493a78b50fe2d.zip"},
+                {"FA401WU", "19938-5PIL7F-a3c8522c89e03fc25e2f7290ee5c5f22.zip"},
+                {"FA401WV", "19939-KIX4CK-3462e49f2c6388228b427b85332538b7.zip"},
+                {"FA506IC", "7822-ZGQ1KC-bc80be3be7ca585bef60f526b6461c86.zip"},
+                {"FA506ICB", "13914-2HYCD7-95fabfe5669a204620517f0158c0cea1.zip"},
+                {"FA506IE", "7828-57N8GH-9fe07a7e4ebde12a8d4682d3ffa66fe4.zip"},
+                {"FA506IEB", "14661-ZYWH5T-3b45ebeb7fca81d98796d5960e11226c.zip"},
+                {"FA506IH", "3407-VZBOUN-8a12385fa46e077010677d330e9320d5.zip"},
+                {"FA506IHR", "7823-15HGA0-44d621a3c0f0dd2c407f67d262871be0.zip"},
+                {"FA506IHRB", "19343-MBMUPH-190cdb28402ba8efd3e11561c9b2eeb9.zip"},
+                {"FA506II", "3410-9ZXQO2-aa08794537699c5dbfcca49b63fb7f8d.zip"},
+                {"FA506IM", "7824-EKKW9A-21c7e073a81fc868b78e605b17290839.zip"},
+                {"FA506IR", "7825-G6XND9-c16ea7e98b58e878c61d1071b100ee60.zip"},
+                {"FA506IU", "3413-AMCR39-2a8b889a8810da4e8692f87e1ae3ea2c.zip"},
+                {"FA506IV", "3415-VA0CJ6-266febe84bcecc5ed89fdc286f444ce2.zip"},
+                {"FA506NC", "18359-BM2XCN-3ca9de427310b05afa92dcbe1babf947.zip"},
+                {"FA506NCR", "19230-KJ866Z-1980e6f6a843b6b31111e38973fa1cda.zip"},
+                {"FA506NF", "18361-CU7H6I-55beba8445b9aa0fe9cbeb8ec9a47ccf.zip"},
+                {"FA506NFR", "19231-GARR16-f7052f6be62ddce2048ebcd6ba808563.zip"},
+                {"FA506QC", "7829-LBYY5U-b14343c260b738563b69ad0e4f4b88d1.zip"},
+                {"FA506QE", "7827-75P3DP-b664f4da04e77ed1faa722bf0c781d82.zip"},
+                {"FA506QM", "9440-87VQKP-48357026f1f3099cfed1161a320587f0.zip"},
+                {"FA506QR", "7830-KO7FQ6-618480f72c2e68bafc594b5323a5d13c.zip"},
+                {"FA507NI", "14451-N6AX9R-0bc8e15be5cf889c755aaa7052f6fee8.zip"},
+                {"FA507NJ", "14454-QXKHOE-d28f2eb001f9b7ce0582cbe33961a6ad.zip"},
+                {"FA507NU", "14452-EZXLVF-c64dd3d7efede78df653b029888d9d04.zip"},
+                {"FA507NUR", "19358-JYO79G-f8bc53beeadfdfef80dc6a4eb85c69e2.zip"},
+                {"FA507NV", "14453-VC333P-41549f64788d59c9711eccec892fa8c1.zip"},
+                {"FA507NVR", "19359-YWEAES-37feeb146db89c3549bac528d67ae209.zip"},
+                {"FA507RC", "11448-0TRT8V-7712eb9302300dd82815027efbbe4787.zip"},
+                {"FA507RE", "11449-ONC7VG-a7ac70468292336f63532c21204d69d4.zip"},
+                {"FA507RF", "14311-X72FIU-66bf16069a82bdf2cc09f8b92cb25c67.zip"},
+                {"FA507RH", "11453-W4B8H4-e1645d3ce1e0216a30246ad6a84c3819.zip"},
+                {"FA507RM", "11452-ZGHOOO-f3bddf2fddd3c027568646bc5afe3c7d.zip"},
+                {"FA507RR", "11450-UU8KFV-2c718d16687fa3b038e625f504ccd13f.zip"},
+                {"FA507RW", "11451-XHL0SH-c2702d2047b7b93636cc1372caf25a75.zip"},
+                {"FA507UI", "17850-4J1GCV-c30e3d47aa82df4e3f0754888903c5dd.zip"},
+                {"FA507UU", "17851-PIGBD6-45227ab485302ec2cca63f0bbb71d473.zip"},
+                {"FA507UV", "17852-T32MPT-a2fd989758365b8a04e4dc5bbb146af1.zip"},
+                {"FA507XI", "14817-A522MM-fad14cb28f00b94735eb55c2b3b7b892.zip"},
+                {"FA507XJ", "14820-8RT0TF-9d341fae2a290494206deb5fcf1fd427.zip"},
+                {"FA507XU", "14818-3PA2GD-2d1e2d035309ec7282a1c47e27f7c7fd.zip"},
+                {"FA507XV", "14819-ET4L73-daf905274776ae9c92a7b74e687dc63d.zip"},
+                {"FA607NU", "20567-VB45RR-ceeec88490fec992f2f8948ece38952e.zip"},
+                {"FA607NUR", "20570-XEDISK-5e1220f6a19492a3e6319697497deaa3.zip"},
+                {"FA607PI", "19157-PL5PW6-2fde4880a46a6b7357d96eaa7a4ec946.zip"},
+                {"FA607PU", "19158-AWQ1FA-f1ed2d008bef71741a9b09b35730b9e7.zip"},
+                {"FA607PV", "19159-V6UKPP-92f56a3aa89b834d1ab12f229a8ae1a7.zip"},
+                {"FA607RC", "10190-XHDRTQ-0e6c248e3dab6bb07e052edd963c5218.zip"},
+                {"FA607RE", "10194-AF495K-23a4d74be5132e4babc64bb13237a12b.zip"},
+                {"FA607RH", "10191-9BS333-c6deb5f9fd5a37d446d2722da54c0ec3.zip"},
+                {"FA607RM", "10195-4U5EEF-cf98d168cacdd5a60782e881a9c143be.zip"},
+                {"FA607RR", "10193-FYX2N7-730c76e49ef71a6164804eafd2621dab.zip"},
+                {"FA607RW", "10192-UFOOP3-f52a50dac189ffa96560f73e04c53a6c.zip"},
+                {"FA608WI", "20103-UE0O65-d6707b2a2f666d671d728661c981883a.zip"},
+                {"FA608WU", "20102-IQVJL2-edc900ffe25635856729d26dbeac272f.zip"},
+                {"FA608WV", "20104-EE3Q5U-a7695b4d1668b1a8dda2576f64bffad2.zip"},
+                {"FA617NS", "20225-0J8FEF-cb6ef3732560ed38542d5047e78596f0.zip"},
+                {"FA617NSR", "20226-B5TAVP-f153443e85ccad055fa12d58eec69c5c.zip"},
+                {"FA617NT", "20224-YN6NKP-1d0e927ae5c1bb7d15e36b63176460e2.zip"},
+                {"FA617NTR", "20227-KL8UNI-2b4063b7a52b142fb75e9136570afbf9.zip"},
+                {"FA617XS", "15968-Y9NFXN-cb420fe6e177fc1cf675e9d42a6fd0ea.zip"},
+                {"FA617XT", "15969-UKYP5L-ad54051ebbad4b17693b65f5bceda799.zip"},
+                {"FA706IC", "5215-5J3H5Y-d2cdc2f5e03d68e5e5e562581a77c8e6.zip"},
+                {"FA706IE", "8827-43DTPG-ba6be621f7d0dda88e5391164cbc7a74.zip"},
+                {"FA706IH", "2610-2EJ0EQ-245d43d7bd14bb3e664fa96e9f5a690e.zip"},
+                {"FA706IHR", "8828-XBJAQU-5d8064b0fb63ca7866ee4cf821ece676.zip"},
+                {"FA706II", "2611-HO3IK9-2fb972a395137c940151723b01e9b9cb.zip"},
+                {"FA706IM", "8829-GWFKN5-5ab773eb09bfb3099137fae3c7d547c1.zip"},
+                {"FA706IR", "8825-63J2NY-2496ecf21b5fa71e65671531b670cdac.zip"},
+                {"FA706IU", "2608-EI64MF-64c35bda7789e6e71298e22d793b78d4.zip"},
+                {"FA706NF", "18362-1V7Z1Z-0bc79f01bdfadc5b39342fba622a5b8d.zip"},
+                {"FA706NFR", "19232-FE6TXN-d062445db610ce901453145ebc518efe.zip"},
+                {"FA706QC", "8826-032S4E-868933565b1a7d762bda8cafc1e77458.zip"},
+                {"FA706QE", "8824-KZNJL9-9d827f4973d4c9787ff050dc1bf35eef.zip"},
+                {"FA706QM", "8830-6NX7U4-b7bbfe663aa954534d33d2f822181728.zip"},
+                {"FA706QR", "8823-RXSLAC-a2720365e842af1dd826920fb447fba5.zip"},
+                {"FA707NI", "14455-19J6WZ-10282c6083ee018a614e75bc809ecf1f.zip"},
+                {"FA707NJ", "14457-BGJD0K-d963ff94009c9a2a5b99606eac711a95.zip"},
+                {"FA707NU", "14456-VAZ4LS-1d798d3873c55e9d10b43a3f2b12cd15.zip"},
+                {"FA707NUR", "20568-IPF4CY-f7bd11b80ffa20b77b75e6a89213db48.zip"},
+                {"FA707NV", "14458-7G8B40-08117ddb45ed3c6978aa4ad60e3d2c96.zip"},
+                {"FA707NVR", "20569-1MFNC4-e41979f29c26628eacf1e9067dd3544d.zip"},
+                {"FA707RC", "10196-81D3O0-94ccf4d908c9bcb44f8f9092ef9fa2e2.zip"},
+                {"FA707RE", "10200-AUS9AW-7f366055be2ae2b4c659aa9590bb4d5e.zip"},
+                {"FA707RF", "14312-6KGU80-09ba6d3e3b490c3d1dce3d16df62cd8a.zip"},
+                {"FA707RH", "10197-BB5746-a958ff2eeedcfd1753c2e7151c0a3f96.zip"},
+                {"FA707RM", "10198-TBWO12-e35e49d79fcc03c5cc84b5b40c222e80.zip"},
+                {"FA707RR", "10199-LILM59-05448f5e429c6c4be7b531d0b6aa2319.zip"},
+                {"FA707RW", "10201-0KXC4K-3dca8e95a9e676a1010efc79becde228.zip"},
+                {"FA707XI", "14821-JO8WIQ-77921f1a7a523fe5674f39f10e66f4a3.zip"},
+                {"FA707XIN", "14822-7W7Q8W-e2e50358e878b092fc888e8e70575985.zip"},
+                {"FA707XJ", "14823-MX6CGK-0d0862cd441f96a72b1c8baeaa8aa3b4.zip"},
+                {"FA707XU", "14824-O2LZZA-f0ea2bf54bbc4fd4e7391048f4a083e4.zip"},
+                {"FA707XV", "14825-DUSKD1-7d0a055d869a7366105380c44788724b.zip"},
+                {"FA808WI", "19512-TZ3G4D-60c6849ce49cca1d2177f31ead77df5a.zip"},
+                {"FA808WU", "19510-ASGCD8-0558641c1b976b901c52d1d72f0bddd7.zip"},
+                {"FA808WV", "19511-QDVPAJ-f3990996e7a9c0d472b46af286d529f1.zip"},
+                {"FX_Series", "2174-J1XJKV-bd932ade5eebb0b2f1a36eac85bc5c7d.zip"},
+                {"FX505DD", "3439-CJLCNE-3df3a90619c571de2917a35a402fe6cb.zip"},
+                {"FX505DT", "3427-H77L9I-2f3f50fbbb1dc4ac6e703b2820acb491.zip"},
+                {"FX505DU", "3426-9P4PXL-7e640e1e38c6395bc5455bdf838ea83d.zip"},
+                {"FX505DV", "3425-31OQ2O-3ab11acfb17dca8f339fe0b8a4efa33d.zip"},
+                {"FX505DY", "162-H1YFBE-1e5c82e28fa35559e5f7a6aa934d7405.zip"},
+                {"FX505GT", "3423-8CCGEQ-a72ef69d8d5aab7bfd3eb34e2a55cd48.zip"},
+                {"FX505GU", "3424-9J0I5H-1c209ee72d9f7ba2caa559fddd9f5fdc.zip"},
+                {"FX506HC", "7821-BDCXZM-23e718ce9f58cbef286e77c7d97752d0.zip"},
+                {"FX506HCB", "8452-QZYXAU-9385f6b96812173b12dcf23934d2729d.zip"},
+                {"FX506HE", "7831-C0XU6K-16e393308545bf5fa327997b33edeba9.zip"},
+                {"FX506HEB", "8453-42FVNT-a7c6b122bb1f2e16340c016d09b43c13.zip"},
+                {"FX506HF", "14511-KKQA1F-9129e79baf1215ce451e791b51fee304.zip"},
+                {"FX506HHR", "7832-KJD4ZK-d6e5fcf84caf94be5b312d6233876322.zip"},
+                {"FX506HM", "7833-2EVLVM-3082377bce59838bf06bd09c3c9911fe.zip"},
+                {"FX506HMB", "8454-32DRJH-818506f55eef4d13839ea8e8d8765534.zip"},
+                {"FX506LH", "10917-Y6JJC7-4596433cf10a71242d9a9255c2b31458.zip"},
+                {"FX506LHB", "16838-WYAR19-d3f87642f6cf12ec77e231b7d405fa61.zip"},
+                {"FX506LI", "4428-Y7KRBX-df2c328780c4506a2cb2279ddf84ca58.zip"},
+                {"FX506LU", "4429-34SZ6D-2df0b447ff1dcf6d887cad5c679331de.zip"},
+                {"FX507VI", "14064-MTRMKH-169de48f4b0b3035315106bde1a1020f.zip"},
+                {"FX507VI4", "14065-9VTCNA-b5e0ac043ffd3e3ffab879f6401b2e07.zip"},
+                {"FX507VJ", "14066-W5FPY3-89180f515ba2c785b1f87c895e09cee9.zip"},
+                {"FX507VJ4", "14067-DKVRHI-bc0fa5ec61259e31536356ec67d27cb5.zip"},
+                {"FX507VU", "14071-EEJKDG-95e42e7c6ebaea33206a1de566588ae8.zip"},
+                {"FX507VU4", "14069-1JAF2A-4d328ede6adf0796924734da3e04a18f.zip"},
+                {"FX507VV", "14068-QO62TU-b6aadf3d84f816a42f111649bb1381ae.zip"},
+                {"FX507VV4", "14070-WHB99Q-57b4d0c8f9405038db3e298f72474505.zip"},
+                {"FX507ZC", "11454-8DEVNS-3503e698cf0b56b387bf65ebd0169786.zip"},
+                {"FX507ZC4", "13785-D9YTVH-2fb9db83c6f04518f230d1d453373e5d.zip"},
+                {"FX507ZE", "11459-DKP456-c8d8862da76207dc0a3bf2642b98632d.zip"},
+                {"FX507ZE4", "13786-3YM16F-fa4c0a13c74e6c1253d464bbb035cbc3.zip"},
+                {"FX507ZH", "11455-OQI6ZD-866eb458d7ab9ac51cb88966b2c4acf1.zip"},
+                {"FX507ZI4", "14056-D01K4S-bb2cfa4d564b8a6834c78d675aebdd1c.zip"},
+                {"FX507ZJ4", "14057-YY0XRG-4f7570dee1902f2012b812d50b0d2334.zip"},
+                {"FX507ZM", "11456-OM12KU-7c91b2d14b093dc2eef17a555e14ada3.zip"},
+                {"FX507ZR", "11458-P8RTC8-2b3802527c98749fb68397f35c6bb86b.zip"},
+                {"FX507ZU4", "14058-9ZYS4E-7e244d3e7dc3641d602130563c1c84b7.zip"},
+                {"FX507ZV4", "14059-VBGCNK-0314facaf02290da1a75d1b00455cb3a.zip"},
+                {"FX507ZW", "11457-4F1FOO-5f24a98f90735cedf1ad9fb5ac90adbf.zip"},
+                {"FX516PC", "7788-GJYPET-06cf200d5b8fb92c807de03796535e80.zip"},
+                {"FX516PE", "7789-WIT1BW-b32fd9546ac9ac5b6878a3f46c30247c.zip"},
+                {"FX516PH", "7237-G94WZH-30c10f820dcdf03cc661fd9b73c2927a.zip"},
+                {"FX516PM", "7790-OG0DVJ-e7ad44e2fa38eb4256e09a62a744659a.zip"},
+                {"FX516PR", "7791-LJ7RQ7-36c58a0b55aeb5c3782302fd58139815.zip"},
+                {"FX517ZC", "13757-QJDW9D-ab71bd2ecf24d182bf32fbd931b24e58.zip"},
+                {"FX517ZE", "13758-75WLCE-fac3186e372a6e0e422d3d78de1addb3.zip"},
+                {"FX517ZH", "11461-A4BH34-2464f8a583b064ab2bdb336dc13d8b2e.zip"},
+                {"FX517ZM", "13759-694BOG-7b8f61a1d8a387715721fd2b8e0bd766.zip"},
+                {"FX517ZR", "11463-MCHEWS-7a732705aea49eb663fe1e8930c463de.zip"},
+                {"FX517ZW", "11464-S41ORA-d99633ecf421ba4ab73800bc9ebf2e5b.zip"},
+                {"FX607JI", "19085-6NMHTY-9137eab4a853f284c0ac1f8890735c7b.zip"},
+                {"FX607JIR", "19088-H9SUHL-c75a1547f17e7c69e0a870425d3592b8.zip"},
+                {"FX607JU", "19086-N1S5J4-c4fc8458bcbefa107fc1c2e1dbe44255.zip"},
+                {"FX607JUR", "19087-ZBS95F-bc3055487fdc07870c12341042a37222.zip"},
+                {"FX607JV", "19089-LLP8ZE-c52cc4765390eba2eae3c798a367df25.zip"},
+                {"FX607JVR", "19090-XQYJEH-a5aaa078def637077c4d1d3a619ae198.zip"},
+                {"FX607VB", "20704-FGKI8R-ac8a18cb35a009bcdb6d18ec7537879a.zip"},
+                {"FX607VF", "20706-OMC7L2-e66289430eb7decd16fe4c6353edb8c4.zip"},
+                {"FX607VI", "14072-0Z0LX5-c3145816b5c9b045a3e829e194425624.zip"},
+                {"FX607VJ", "14073-H1KA78-95472184994955393ebf635af4a55c71.zip"},
+                {"FX607VU", "20707-N1HJ0V-31f1da0a565763c625714c39b7bb5bae.zip"},
+                {"FX607VUR", "20705-ON83H2-dd9e78d43fb57f06d0e8ef0d9d1e849e.zip"},
+                {"FX607VV", "14075-BX4NJX-a9e24be091f08e6cc3885397f143bdc5.zip"},
+                {"FX607ZC", "9267-SQXQMT-edf1ee77d7f276d9b2f14fbe80e86459.zip"},
+                {"FX607ZE", "9268-MI06A0-5f60b76f497adb2c80dc5d34e7ca00ef.zip"},
+                {"FX607ZH", "9266-75PO51-12f649be993639c1ff986129977bc516.zip"},
+                {"FX607ZM", "9269-MEPP17-baf25a9abae3ae712da40dc6c4f2de22.zip"},
+                {"FX607ZR", "9285-7B20C5-9a0ee909d954eda9fd9f334a6b76bdda.zip"},
+                {"FX607ZW", "9265-9H05OM-5b2735efc15db9c49302451b728338a8.zip"},
+                {"FX617ZC", "9263-3PLDC1-74d554f08fac5b1689c7dbb581fc97c4.zip"},
+                {"FX617ZE", "9264-9L5V7F-203b8f8a48d47470aef80dd42bbef60b.zip"},
+                {"FX617ZH", "9261-DIXTFE-b20887acff77b59a80e62088caf695f3.zip"},
+                {"FX617ZM", "9262-OXO77E-8476443cfd885a718b915731b9807bc0.zip"},
+                {"FX617ZR", "9286-VA9VXJ-8c69c08b5812b00656142d93cb5a5013.zip"},
+                {"FX617ZW", "9260-O8UGYN-9678cab288d9b85ec59961647ca94ff7.zip"},
+                {"FX705DY", "163-N6IM0Z-3bee0b29abd2d6b419ba322661d64a6a.zip"},
+                {"FX706HC", "8834-3HMY7W-fb49a16bc9cda208a3acf5f2ea32fc63.zip"},
+                {"FX706HCB", "8835-FHPH4O-319d35ab96a1eef3b5ae7fefde106cf2.zip"},
+                {"FX706HE", "8833-SW8GIL-71ae2ebbdb18ec3380cf682be0ca32a3.zip"},
+                {"FX706HEB", "8836-SUE4HH-55876358bbe39f53ea2010c8f66e9093.zip"},
+                {"FX706HF", "17052-8B8C18-0c762fb15cd6367d08c954ce5e01f497.zip"},
+                {"FX706HHR", "7837-S711RT-ed9d8a61e80895a6403dda19ac873f62.zip"},
+                {"FX706HM", "8832-O7W1D2-853dd8eb62665c369cd2c3b716a53b80.zip"},
+                {"FX706HMB", "8831-NKXZ56-437ac6d56280dd0734f9f56db3ba6a6f.zip"},
+                {"FX707VI", "14076-C4CQ2E-0771f0ec46072ac38a7dbb8829783298.zip"},
+                {"FX707VI4", "14078-UXPPY2-ffe538cd58da15c780e6263c2818f995.zip"},
+                {"FX707VJ", "14077-6KB0BJ-af4fae81000b0143477091deaca569da.zip"},
+                {"FX707VJ4", "14080-YBM0VD-bef842b5fcc1b49cb054cfb1eb3d2258.zip"},
+                {"FX707VU", "14081-I8JRY3-2ab8a5dcab2033a19de169e424da1530.zip"},
+                {"FX707VU4", "14079-TALDGM-c7d6c6820a223967463a76152e178af4.zip"},
+                {"FX707VV", "14082-2UYJNX-a21d4e4e856e8a4fe52b30593705d818.zip"},
+                {"FX707VV4", "14083-79JC8K-74d96cb066ded2d86255755fdc1f3167.zip"},
+                {"FX707ZC", "9278-7TRFVL-9a0693a78d8d69a265cb7101314dd055.zip"},
+                {"FX707ZC4", "13358-EPBJ9S-035eca4acee4db9814f693f4aeef0147.zip"},
+                {"FX707ZE", "9279-QYJXB7-17ff65bda614791358426882d48be6fe.zip"},
+                {"FX707ZE4", "13357-V3LZL7-64a1ecac6b4657e98a422cd5657cc89b.zip"},
+                {"FX707ZH", "9280-62FAFQ-3193a4215440ecbe7fece9091fad6205.zip"},
+                {"FX707ZI4", "14060-EEB7IW-e716f0f9a1f8f91e5ae93d902de96385.zip"},
+                {"FX707ZJ4", "14061-T7UBPM-91f62b48749f5ed42e3c3d1f2b8bb645.zip"},
+                {"FX707ZM", "9281-YKO83G-ff6a896b4e055cc6500470636cf9e1ad.zip"},
+                {"FX707ZR", "9284-GYDQK8-bfdc718699fb7030b0f133402933e12f.zip"},
+                {"FX707ZU4", "14062-52EB12-8a85d0170af52dfbaf216b98085015d0.zip"},
+                {"FX707ZV4", "14063-R6EM57-62ad692f855e33bb05aaae1823207415.zip"},
+                {"FX707ZW", "9282-E6GYQU-5f673e25b2ef5e57c78e36668e9c5e9f.zip"},
+                {"G_Series", "2176-RS8S2K-e815e5e0be51e1bd76674cd3826cbfec.zip"},
+                {"G512LH", "3312-AM98EE-e9a32238fa66ffe8683ff0a34019f216.zip"},
+                {"G512LI", "3310-9MDL49-daee5dd162a699f60f2bb68a3cba7ef7.zip"},
+                {"G512LU", "4150-SX012C-b6e7d21b645495f57b2fb7bd9734e839.zip"},
+                {"G512LV", "4151-LUEHCJ-f145d1dd67079a3739a564cb04eaa6ff.zip"},
+                {"G512LW", "4152-4IMGHN-f0a946d2f21860039a9181b17ca1f1be.zip"},
+                {"G512LWS", "4153-IZDAY7-3cc48027800d6d123db4f584a5a2e4a4.zip"},
+                {"G513IC", "7233-I1XU1L-57f580817efeb347c2e64b467b569d48.zip"},
+                {"G513IE", "7232-7C4QK2-effb8e534fc4639d7fd72e957e1a13fc.zip"},
+                {"G513IH", "7231-YGY2HL-ef7e448a0e3b2502219c74c2f8a26a72.zip"},
+                {"G513IM", "7883-JSH1ET-04fb928a7fe54481b8156627d30451ce.zip"},
+                {"G513IR", "7884-DB01TN-5bdc2457c9a42ad9c0b1ab82139beeac.zip"},
+                {"G513QC", "7228-I73APA-79e1e7f9582bdc44f510d651e909250b.zip"},
+                {"G513QE", "7227-9J3H2Y-d222e0119fef169bbe0f20f754743ca7.zip"},
+                {"G513QH", "7226-MUU2SQ-05a65cada4f1c986b7b2c5e2cf7ea796.zip"},
+                {"G513QM", "7882-2FWOWK-ca956a4c309edb8cd9d9c24178ec3912.zip"},
+                {"G513QR", "7885-4VL6WK-6a21c044bb2d69f55febdb6ffcd5b7d8.zip"},
+                {"G513QY", "7881-S6R4GZ-5832d1de6fc107509803927e4a52ebf7.zip"},
+                {"G513RC", "14513-WMQ0GS-4018fc7459d96efec72f15f724c33062.zip"},
+                {"G513RE", "14516-VXJYUR-fbaadee0ba8dea2a24282b2be882d571.zip"},
+                {"G513RH", "11732-8ODACG-845738811f5dcaee76c7ba113ed0c8bd.zip"},
+                {"G513RM", "11735-UXEJT9-03457f6d6350f0a860fe6386de27a659.zip"},
+                {"G513RS", "11733-9SABRD-3a4c8dee5ff96668dc9ff509d626e17e.zip"},
+                {"G513RW", "11737-VS9IFQ-b9c6657578263ac3ab1062b32ab599bb.zip"},
+                {"G513RX", "11736-CHOX6M-ca19a5d6e7153102c3825f8b3371b4d7.zip"},
+                {"G531GD", "3698-YSDO31-352980933199182c587573ecf056711b.zip"},
+                {"G531GT", "3697-OYLYLQ-4916a89afb3a6964cb2b0ddd8dc45fe1.zip"},
+                {"G531GU", "744-S7QQP3-8572157fa95e0eb235f29df0227d5064.zip"},
+                {"G532LU", "4146-NF3MBY-79c262fe416eb469fdff811d501233c9.zip"},
+                {"G532LV", "4147-F6P59K-328b1796ee854653a1470be865e06d0e.zip"},
+                {"G532LW", "4148-KUJ0SA-affcc286138b433b9b051dffc8158672.zip"},
+                {"G532LWS", "4149-RDJKG0-c5f4470225e184cdbc34b9b41c9e2666.zip"},
+                {"G533QM", "7880-VL41LZ-ea6868a4918e7a2571a169b0b20d53de.zip"},
+                {"G533QR", "7879-3915UU-cec5ce6e895bc9acf0367b1ae69d7d01.zip"},
+                {"G533QS", "7878-SLEHTN-4844d16bf258768105873010c17398ea.zip"},
+                {"G533ZC", "11725-BVSBSP-1f91feb49662e4f4257a27ea081db4ac.zip"},
+                {"G533ZE", "11730-DEG4Q9-3d77f3901752747e449fdaa5467a250b.zip"},
+                {"G533ZM", "11726-01FCGK-180459312539e4c38def3c7323a60494.zip"},
+                {"G533ZS", "11728-KGTOE8-4fe0474fc6e8944dbdcf726bad1a7db1.zip"},
+                {"G533ZW", "11727-98BKOJ-93e373e64e92c21ff018ba6c66a9de9d.zip"},
+                {"G533ZX", "11729-XNFMPR-e0aad4e4d4956dba8629f419b1f86026.zip"},
+                {"G614JF", "14496-NAATJZ-a3847e890e57aa749645b854b28ead79.zip"},
+                {"G614JI", "14168-4VTU0U-37decb2df809672eccf1156769eda929.zip"},
+                {"G614JIR", "19126-IMXGO5-4cce9f45ad28fa60d016f8d212c50b10.zip"},
+                {"G614JJ", "14497-P0D5PL-abe178509e0316da9ee56b24e15d0384.zip"},
+                {"G614JU", "14498-5D71EB-2300be03087494ee34356470ca022b7c.zip"},
+                {"G614JV", "14500-SPJCAL-a8e2e223857c334ba4c20c8122151bb7.zip"},
+                {"G614JVR", "19129-EA1WB4-4666564ee013c4df53be44bcdd20bec0.zip"},
+                {"G614JZ", "18199-P9WWOH-093d361358629a2bddd5bff7b5fb7a5f.zip"},
+                {"G634JY", "14163-JLRBOO-8ea519425efe56cc144e38d22cebd3f0.zip"},
+                {"G634JYR", "19130-MUAT65-0eced7ca55a61cc41341faa3a48d34f3.zip"},
+                {"G634JZ", "15827-MSW5I1-0f39e92313e54afe3e35f5636dc37fd5.zip"},
+                {"G634JZR", "17891-O7PAGL-5c6e6d059ff7bc1b9245fdf8a8066263.zip"},
+                {"G703GX", "105-NMT9XG-76a0810ddf16ee376fa049bd179377fc.zip"},
+                {"G712LU", "3364-3GYELH-a0f545d6a2f5ca2516e91f0495f98110.zip"},
+                {"G712LV", "3365-UYDEWV-6675727e4e0588b95d9faa2df69b1972.zip"},
+                {"G712LW", "3366-OK41IE-fc01da1e3d6217e6bce24f3237b5631e.zip"},
+                {"G712LWS", "3367-N1B9F6-72dd79495de9b660a8b120579c708623.zip"},
+                {"G713IC", "14187-GKTF5N-c602fb66b48f86aa2ab7b14367dba7b0.zip"},
+                {"G713IE", "11023-PVEVI5-bfa9a58633213b87629c5117030d54f2.zip"},
+                {"G713IH", "6317-I3AGUT-a0a1e3b68265d7bd3a2a1657afa0cfb6.zip"},
+                {"G713IM", "7890-IC1UIL-85b242f2f61aef5cd16166178b6a1adc.zip"},
+                {"G713IR", "7891-832AOR-104e408922a3f0c4e8d97d03dd000083.zip"},
+                {"G713PI", "14527-XK0JY1-ffe9b04acfd36ebcf3b1331577515b8c.zip"},
+                {"G713PU", "14528-AC10R7-ee30e2f76e16c16db44758ac911e9d61.zip"},
+                {"G713PV", "14530-3ONUVM-abf27eca2271dcdfd150acdf6cc26800.zip"},
+                {"G713PVN", "14529-YMPI29-b958f3ae6ad8118997c16c87d9840fb9.zip"},
+                {"G713QC", "5496-KAW7ZL-7a45d99d71ba375d79d047a015c27c2a.zip"},
+                {"G713QE", "5497-T7QUN2-f5c00e128ed96b9727dcdfb4d857dbb7.zip"},
+                {"G713QH", "6316-ANOUE8-9b18e7d3aeaeb5cc4520be09df860617.zip"},
+                {"G713QM", "7892-JCIYF7-acf05d6b34e417efed385e84dc079677.zip"},
+                {"G713QR", "7888-XIBCC9-d2e608529ce49f0daf90bf3d81cbd69e.zip"},
+                {"G713QY", "7889-FH9X9W-5c4d00f5506924fc9f29e1c190b1bf51.zip"},
+                {"G713RC", "14514-8R6TFS-eb95e08804622256fc5be85a1f14301c.zip"},
+                {"G713RE", "14515-LTB9LQ-a6a522a9d63083e0366d13f40af54ebf.zip"},
+                {"G713RH", "11305-VO5JTS-7cb1b763f054da29ce2ba1e08c897a60.zip"},
+                {"G713RM", "11309-GX2AYR-5b172b743c185242080b08dd7e2b7fc7.zip"},
+                {"G713RS", "11306-E1A3OM-37679d1dfc144d892325420d784f5d8e.zip"},
+                {"G713RW", "11308-IPZSAB-6c8827c63a27cee6257c755bf0bd9c41.zip"},
+                {"G713RX", "11307-JGFO1D-cff83a2f34e3c0ed755ed63c20d2905d.zip"},
+                {"G732LU", "3368-C89MVD-1ecb4a036b697bd4bd027d2bd160d219.zip"},
+                {"G732LV", "3369-TI19K6-56ca5eb37397117c97e0bae42e82b2b4.zip"},
+                {"G732LW", "3370-HLPSUS-9c7615d0220bde50de5ecd4c7e51182c.zip"},
+                {"G732LWS", "3371-B4CG89-c22a9f4deb49d6e1e921ebd5a0cab685.zip"},
+                {"G732LXS", "3372-OJEP07-c0e21f578660bec502aec19a3645b067.zip"},
+                {"G733CM", "11332-V8B7E9-2a7f61f88106051be62b57250ed33eaf.zip"},
+                {"G733CW", "11334-MQ3PJE-f03f2950247ac635dda1b30245d220aa.zip"},
+                {"G733CX", "11333-XS984I-d48bb5ee3416d47fa203090bc8bce04d.zip"},
+                {"G733PY", "14531-B4NFUU-4ec97a54081ea4b713975fd1ab7c1b80.zip"},
+                {"G733PYV", "15178-1CIVEB-5a9d09a4d22d6361992c7cd6ca27fb41.zip"},
+                {"G733PZ", "14532-4UUM5E-296ee92ca5416a8c59bffd6f101feaa5.zip"},
+                {"G733PZV", "15179-EDHNHX-ce69d260b1e8077d8d522d3b4326322c.zip"},
+                {"G733QM", "7893-OW1O2I-a2dcb8ff88cae20c7086bac8d9312dbc.zip"},
+                {"G733QR", "7887-OA7Z12-bc86110ff0d1f359d9230fca8bbabe51.zip"},
+                {"G733QS", "7886-V9PIMC-27ca6272c2b093264d88a32f1093a4fe.zip"},
+                {"G733QSA", "5501-LX7POZ-9289c2079bdb48e2fdd76d7981fb0e5d.zip"},
+                {"G733ZC", "10077-J3XTHP-525deb09f2ada7dc36dc82772f7a9cce.zip"},
+                {"G733ZE", "10079-KAW34P-16c4b5e812e10019f21b4d7f879acfaf.zip"},
+                {"G733ZM", "10078-K6B3CR-63dd00f6ecc3eb61e92439ef5caaea17.zip"},
+                {"G733ZS", "10081-VM2AN1-517b1e41388f12048ec3a88c780f1d65.zip"},
+                {"G733ZW", "10080-HY42QH-aa285046069cfe113953b91f1a28d101.zip"},
+                {"G733ZX", "10082-JS5F1Y-41bccc831aec7bf1c0a59a309bc607c7.zip"},
+                {"G814JI", "18243-BAU912-671afb033d3b1c44f9852ff608910f42.zip"},
+                {"G814JIR", "19802-1CGBPH-f1d31bab157b36d109e1e10591d49f4b.zip"},
+                {"G814JU", "18193-Y5GMF0-843cee9ed982a3d5aba21e99efbc396c.zip"},
+                {"G814JV", "18194-9Q537I-c5c2ca782d26dcd5346c110767347903.zip"},
+                {"G814JVR", "19801-JK7M4V-617e0c975bf6e2a6f67802d825fa6aa4.zip"},
+                {"G814JZ", "18195-V98WBX-19d4c2e52916bf9c96fcaed6f1d9bdda.zip"},
+                {"G834JY", "15954-HAV3KR-d219c43750d485279e12cf76f5b2569b.zip"},
+                {"G834JYR", "19121-GX7FZU-7c449cf7db0033db75da0f4a464ee4d9.zip"},
+                {"G834JZ", "15953-C7XC62-a987058c0a26fa3c929b300d099296a5.zip"},
+                {"G834JZR", "19122-CAYURL-f71108b839d923ae92f3f83451ddfa69.zip"},
+                {"GA401IC", "5864-KC8TTP-082f9a62dda322ccaed82ff3e3466bf8.zip"},
+                {"GA401IE", "5866-JO8504-dde5402bdecafc1cef55a7dc3d6167ec.zip"},
+                {"GA401IHR", "5865-7DV6TB-9833a54c7334dc3aef1b9e99f56b9e95.zip"},
+                {"GA401QC", "5129-PY283Y-ac372208c57a7f558db6c169cd50d091.zip"},
+                {"GA401QE", "5130-C2G5CO-8ea0eb1ca537d77d19bad13dee55294c.zip"},
+                {"GA401QH", "5124-QQ97GA-bbde59c5235d8b72b78059b95e8a23a2.zip"},
+                {"GA401QM", "4922-222SBA-340a82b955a5f57ff39f6d2d08af365b.zip"},
+                {"GA402NF", "14160-ORONGT-ca84f0561683e1a07548d0cb7e42c275.zip"},
+                {"GA402NI", "14159-SDCMA5-300bd29af08b0f5d1527a375f8c326f2.zip"},
+                {"GA402NJ", "14158-O7H0GR-10db546f9901ac02d3ce8d5a28cb4772.zip"},
+                {"GA402NU", "14157-QJ4W59-69222faad499f94b4d96f7d85504930d.zip"},
+                {"GA402NV", "14156-ZKGYBE-ae1ac3947eb8684cabc0cd45f8d4c67e.zip"},
+                {"GA402NY", "14155-AL3KZU-17ac9e4b88c03ebaf983134f76f9a4b2.zip"},
+                {"GA402NZ", "14154-SY6J4X-7d8416a09b51e32f856f3353173ccc70.zip"},
+                {"GA402RI", "10145-9W1623-272e082c57c6e41074b2cace72adc92e.zip"},
+                {"GA402RJ", "10146-IY7ENY-f6d2d25b5b6b21616ceddc4e9aefa656.zip"},
+                {"GA402RK", "10151-7RPIER-2588aa83188168f8375ed9bab7bb67d2.zip"},
+                {"GA402RQ", "10147-9NQMQH-7ff3944c376e91b26c0a1c18122a4262.zip"},
+                {"GA402RU", "10149-3F10IX-43c96d30b6702261c3cf85467857eec9.zip"},
+                {"GA402RW", "10150-5H5ISD-1badfa856f0ec8d15d9d5832a8d54fc9.zip"},
+                {"GA402RX", "10148-QFCU8O-704d371255ae8a72737f5f8eca75eb9d.zip"},
+                {"GA402XI", "14899-86ZX57-5940ed56b182781334ca2856f6ba0b9e.zip"},
+                {"GA402XJ", "14901-MDIR3C-5022331539bb187bf041a7e3ab0a46bf.zip"},
+                {"GA402XU", "14900-KYCOC7-361bb364d26ff834d6bd716d14f70006.zip"},
+                {"GA402XV", "14902-EL34M9-731ba1cc0d27d2db9a79d872673e7958.zip"},
+                {"GA402XY", "14903-ICC56W-0456739d8ba5ee543dfba99eb6ad217a.zip"},
+                {"GA402XZ", "14904-B3K2NR-928b7272790e7da0079c549cd4885d5d.zip"},
+                {"GA403UI", "19112-NB8TJ1-e1de0121e30431cc5520ea6eccb6e46f.zip"},
+                {"GA403UU", "19113-C86SAH-4338dac48ad593c4079515b7599b8943.zip"},
+                {"GA403UV", "19114-6KR0FP-4740ed98a2ca06bc26c363de380a037d.zip"},
+                {"GA502II", "3554-REAPZQ-5f94c7ecd52ae2cad50aaac4341bec7b.zip"},
+                {"GA502IU", "3555-15UWZ4-d1cd040265773efd61bdfd146140a990.zip"},
+                {"GA502IV", "3556-ULLH3K-1f56134e43e1ffa353256fbeb9840d3f.zip"},
+                {"GA503IC", "7457-RENJRP-5b833a2bd8e1e13ec41f0acf7ef04fd0.zip"},
+                {"GA503IE", "7465-QO1Q0F-663f0c9501e649bcb0069413f3081a49.zip"},
+                {"GA503IH", "7458-D6CHF3-4c6b83cb3efc11713fddd9c41cfd127c.zip"},
+                {"GA503IM", "7741-F8GHPK-63e17aca55a11e838b1079eb0c6bea16.zip"},
+                {"GA503QC", "7459-308BEA-bcf2604511112df5fa810faa9cdece89.zip"},
+                {"GA503QE", "7464-4T2J1D-3920997d2f44d3b40dffd6ba9f028075.zip"},
+                {"GA503QM", "7739-BSD39S-f9858fd4a68ff8ef60b8abf2cda92dd7.zip"},
+                {"GA503QN", "7740-QT19P2-33054dbe06ae3baa435a44ce529eddb5.zip"},
+                {"GA503QR", "7738-QVCIRY-4e612ff997f11448c77068e39ee0681e.zip"},
+                {"GA503QS", "7737-B5L4LD-4400a4ddc94eebefb0678fb281b63fa0.zip"},
+                {"GA503RJ", "10630-MSC4Q2-f16f1ef2847069e50aad62083836b220.zip"},
+                {"GA503RK", "10631-VXWRAN-b2a1aa499bf33f1f9bd3d80e31dd9d69.zip"},
+                {"GA503RM", "12054-38JGOX-35e7b1afb150daea1eab90ae97f0da7b.zip"},
+                {"GA503RR", "10632-IOY3C0-bf16d1028f572ede9dd8e1a2fd632ae5.zip"},
+                {"GA503RS", "11745-689QTC-6c441a7161a34b871918fce5997c4e2e.zip"},
+                {"GA503RW", "12055-SG6VTH-91cc5782da63cf3dcc16804a47db25a2.zip"},
+                {"GA503RX", "12056-MR9J0D-b7dad63f751d2e53aeee479524986bdd.zip"},
+                {"GA605WI", "20014-K4K912-2a2e5a66fac3cc97fb13394a189bd75e.zip"},
+                {"GA605WU", "20015-HJM11B-a724c1fe216b73c0b3b24475047f4615.zip"},
+                {"GA605WV", "20016-BWVQPK-01624c1cdd5a3c05252bad472fab1240.zip"},
+                {"GL_Series", "2167-P7ELNB-44d357ee720a0c48c2eb37eee785316c.zip"},
+                {"GL503GE", "57-YI7HPS-9ed36ba45ff6398f3648a44ced4e5e61.zip"},
+                {"GL504GM", "58-JOZ3S5-998677afd41375cb8fd60ace8d11a788.zip"},
+                {"GL504GS", "59-KS4SJK-b1c9807c7d7dc847fa895516b3b9a8cb.zip"},
+                {"GL504GV", "167-OX51EF-b8b5c713bff267d315e0255370956e75.zip"},
+                {"GL504GW", "168-NMGNB6-1f6d79b87d077c235c57d4505ce802e7.zip"},
+                {"GL703GE", "60-M0UOZ3-1474ef8209bf010de4c6e6ae94ce351d.zip"},
+                {"GL703GM", "61-WJGLV3-b8005e077aa4825799459412849e346c.zip"},
+                {"GL703GS", "62-HU12J1-a88023229e3a2dbc5fc1aca1b07e4d76.zip"},
+                {"GL704GV", "106-3IHGVF-5d15db39c04a44e3503d3536d4f0c132.zip"},
+                {"GL704GW", "107-NZ7VZL-cae8497c2eb8479f4808d2b61e7c8e70.zip"},
+                {"GM_Series", "2169-K05CUW-841a5508c96649de28d613e32dfb7fcf.zip"},
+                {"GM501GM", "63-3CL0UZ-eee6728dd2517d6e3af581f1caef0114.zip"},
+                {"GM501GS", "64-GH66XC-5e69efa00bbe486efd897414ed329545.zip"},
+                {"GU_Series", "2170-FYLCER-f45e5d5e38121b7bfe275b780e739a8e.zip"},
+                {"GU501GM", "65-LSRZXK-658dc6e1c89a7787201ec7c74eebf2d5.zip"},
+                {"GU502DU", "4004-T40IY1-74f962c9d9d27544c964bdb347074472.zip"},
+                {"GU603HE", "11674-VGXXML-41035c5f9dbf4e0b64a74eb3f89d95e4.zip"},
+                {"GU603HM", "11676-GO5KVF-581b4f49e0e12d9d6654ab2c1db9ab11.zip"},
+                {"GU603HR", "11675-AZPXHF-48a9979ce428acfcc57c4e295f8a9840.zip"},
+                {"GU603VI", "14579-CUHZFU-ea9e6cf216e1359b0f3e300e137720f7.zip"},
+                {"GU603VJ", "14580-18G1FP-4456270d80c37a0597b3bfc559222f64.zip"},
+                {"GU603VQ", "14581-8YY8TX-e7aa10a20a41245500f40841b2298a42.zip"},
+                {"GU603VU", "14582-9I3GQS-564dd1ba9ee37dc03bef022bd2e29049.zip"},
+                {"GU603VV", "14583-XH4I69-879293a1a305dc952afb15b481722e09.zip"},
+                {"GU603ZE", "9817-3EENL9-3187794df7ec8ddef2fe04d0787eff63.zip"},
+                {"GU603ZEB", "9818-KOP3C1-11ab717fddedafb9066b362d8da5af85.zip"},
+                {"GU603ZI", "14431-H4XZCU-1c907d4e22bbd5000a6c81cfc2e1dae4.zip"},
+                {"GU603ZJ", "14432-Y5HC6R-b50edb7a5ad9469b89c35e5cd9fc114f.zip"},
+                {"GU603ZM", "9819-718DH0-30bf094253e5178aba765436bb8b150f.zip"},
+                {"GU603ZQ", "14434-3KPJU7-211e518352b0660babc4816fa5dd80bd.zip"},
+                {"GU603ZR", "9820-LIQ8FP-6a60aee97d7028e7ea63bd2ab6c2b099.zip"},
+                {"GU603ZU", "14435-2ZW8FL-65ab99a80fe08d8d088d8fdc998076f4.zip"},
+                {"GU603ZV", "14433-FEY59U-cd0508e779a6b3874a61668f39ff78e0.zip"},
+                {"GU603ZW", "9822-3R2PGP-f2d24c6931e733a5e0e41dc8560b80cc.zip"},
+                {"GU603ZX", "9821-AQYG62-f42f167ec7b4f4fe003f05b1c1c61d58.zip"},
+                {"GU604VI", "14284-R38BM3-e2591bfa2582ce68b2c8aba63beac5e3.zip"},
+                {"GU604VY", "14282-78N7V4-25e76896744c53317fa41a80788a2241.zip"},
+                {"GU604VZ", "14283-U4JX5C-f31dff75d52f48ceca0102fd1bc76e31.zip"},
+                {"GU605MI", "19271-93QRMU-eab4115ee09fb9bbd86facec08a822a1.zip"},
+                {"GU605MU", "19272-RDZDEJ-4380e52eab6a3742613c2f694a19da1e.zip"},
+                {"GU605MV", "19274-1T9PKS-d05273f430d255ad1779cf6a7eb57db3.zip"},
+                {"GU605MY", "19273-F4A493-2bc9083d99e7827b4580311d34f8998b.zip"},
+                {"GU605MZ", "19275-52DG5X-1072d6f4fdc5b9cbb304da7146f05a79.zip"},
+                {"GV301QC", "5128-RN42GR-9a6049e7adabd1ff2aeed24293fe03a8.zip"},
+                {"GV301QCZ", "6778-152PHS-7a9ad124aef1059471542dfc8912ed7b.zip"},
+                {"GV301QE", "5125-PD15GR-9a7f72cbf5bd97d283464d8e407f0231.zip"},
+                {"GV301QEZ", "6780-N3Y08B-222db095847d99663a575be36fbcf410.zip"},
+                {"GV301QH", "5077-0BEYRT-ff8e30857ab4af017381f5703b39abed.zip"},
+                {"GV301QHZ", "6779-9XZE32-329974b938dff4baf3097e3d745839eb.zip"},
+                {"GV301RA", "10272-1B7YAA-45e3697377ff2e7dd68c57f5919eecd2.zip"},
+                {"GV301RC", "10273-UJ0Q76-53bdfe00929ccf3f594f813ba235438b.zip"},
+                {"GV301RE", "10274-1J3P7N-42dabc435e4daa40d4be2fa482624321.zip"},
+                {"GV302NA", "14663-N4C4U4-1654950fbc1fad0e37a016c4a1e8a934.zip"},
+                {"GV302NF", "14668-GMKBGC-1bd7957eb1a688f8eb0e6fb85395b839.zip"},
+                {"GV302NI", "14664-ZQXAM8-1dec6b07c9589698c8cccdbc3a3211a6.zip"},
+                {"GV302NJ", "14667-OFKJGT-60db594b4af90c481212ee31ffa96d38.zip"},
+                {"GV302NU", "14666-6M0N3K-3d08325f6c4b3fcacf53a2f863a0e6c5.zip"},
+                {"GV302NV", "14665-DWLIIQ-9b3b8b0aaca3a071f82cbb30fbbe2fd1.zip"},
+                {"GV302XA", "14934-AU5P0J-1873c4e95dadcf72b1fad550108a0eb5.zip"},
+                {"GV302XF", "14935-D5PHI6-aa9715b2328c499c8cd72b4958ba6641.zip"},
+                {"GV302XI", "14936-CHYX8S-f5fe72833a34f1f002dae6789f2760fe.zip"},
+                {"GV302XJ", "14937-LMH57E-651161fb27c3ef9904e15fc42e5d8352.zip"},
+                {"GV302XU", "14938-4DXJJV-82feb9f0156bb914ccbde2de6d59ad14.zip"},
+                {"GV302XV", "14939-KLW56G-32ffda0b7ee35bbe4ca5789da7210cc9.zip"},
+                {"GV601RA", "11078-109U4J-33e9d7342819b8a7a534632df659e509.zip"},
+                {"GV601RE", "11079-U5MUWC-8c22738f13a798376733fead5f091a4b.zip"},
+                {"GV601RM", "11082-XN5PLH-5c405808680f6bfc36c5069bcd5dc366.zip"},
+                {"GV601RW", "11081-FK9JFY-b82e25b8f9bcd2ad1d3ae23c7cb327d0.zip"},
+                {"GV601RX", "11080-45B7E2-b64fdbf32877dc996b4efe274ff51f41.zip"},
+                {"GV601VI", "14446-JS3QXL-72327a76c47c2ffdeaad392197a4b2ce.zip"},
+                {"GV601VJ", "14448-TIX8CU-ed84b2ee1d92d2f38a891ed1c684eddf.zip"},
+                {"GV601VQ", "14447-7C8UIX-13cc4d4632406ca5976358a4080f26af.zip"},
+                {"GV601VU", "14450-0SP39K-8071216d3c679d013fffe57eca9f790c.zip"},
+                {"GV601VV", "14449-QZS5FH-6a7771cbbf9bcc641a5418f250ef3b43.zip"},
+                {"GX_Series", "2171-LHV7R6-bf1d918fd26714f10c3f3de990e30a1b.zip"},
+                {"GX501GI", "66-U9BQN2-9a12abd42e07169ec6ebf4d4a6d2c148.zip"},
+                {"GX502LWS", "3552-YRITSK-6f08012703e7718be25477f20ccd4d7e.zip"},
+                {"GX502LXS", "3553-3ACO9T-20757861512ff920da316c949249b62d.zip"},
+                {"GX531GM", "67-ER25S2-71ec74e4e8d14fc9c6cc8608d1616e5f.zip"},
+                {"GX531GS", "68-V9PHXL-3cabb33363337795287458e3b10114f8.zip"},
+                {"GX531GV", "108-VCV90K-00cec46bd49df326109c060367eaa57c.zip"},
+                {"GX531GW", "109-0GH5PV-ce1ff55527d5da0b547df776af887276.zip"},
+                {"GX531GX", "110-A0TZ36-4cf1c1cdeee6e0e27567e317444c62cb.zip"},
+                {"GX550LWS", "3671-DEEX56-d93255f509e16f740c71e8c358e8ff36.zip"},
+                {"GX550LXS", "3672-O3V2FT-6572c1aa661e3f406ce6e840075d81ab.zip"},
+                {"GX551QM", "8108-47QAG6-7d57f542a91fca797f6bad910af5b864.zip"},
+                {"GX551QR", "8109-ADSI6K-87224022e84f6a6c0ed2820cc4642a66.zip"},
+                {"GX551QS", "8110-NLPALF-6ec9938f67229be071cdb8c436303734.zip"},
+                {"GX650PI", "14591-ODJA1G-23aaf98034a279ae87f93f67db9b3b95.zip"},
+                {"GX650PU", "14592-A6IJIM-e847943987f3cf4f1d0278fe1d5ee984.zip"},
+                {"GX650PV", "14595-XKP10A-e14bb5df924255dc965bb975e1d64434.zip"},
+                {"GX650PY", "14593-KC9ZMM-6e519dbcdd0139ed1d8e7649e407d8a8.zip"},
+                {"GX650PZ", "14594-AETGOJ-4ba96caa5ae0ee68d8b457e0fbc03a17.zip"},
+                {"GX650RM", "11320-E8SQ6M-5673cb197e000111c0d406b1156d44af.zip"},
+                {"GX650RS", "11321-UEO888-cbff96301261591d9130980fcc5950e5.zip"},
+                {"GX650RW", "11322-YIN6KH-2a804a1dd4da59662e6746f83d636452.zip"},
+                {"GX650RX", "11323-64AK0P-9929933ff3fda3dcabfef096d7242a7c.zip"},
+                {"GX701GV", "166-EI8VY0-1568b74c5bbf22297720b548ce6bcefa.zip"},
+                {"GX701GW", "165-C6KON3-9b95db9f024e457420793b4915749fbd.zip"},
+                {"GX701GX", "164-I4CRXM-b5e8ddc68c884eda5cf4676dd2683624.zip"},
+                {"GX701LV", "3309-DPFMBZ-ffda0b00117a5f1c69a091158b631bbe.zip"},
+                {"GX701LWS", "3308-PQVG48-ad364af358f946382f840c969c73d49b.zip"},
+                {"GX701LXS", "3307-AY5DMD-681ac8295b6f98fda4c66b891f19be4d.zip"},
+                {"GX703HM", "7962-KBDQY2-ff82594ee47f5c1058bc2115b6a74841.zip"},
+                {"GX703HMD", "7963-A3TM3L-5f39a856e3f694e9db1ed5a5410baa39.zip"},
+                {"GX703HR", "7967-5LQ4FV-7b6af6e1dc3a6c0786bec0ec084ee5c2.zip"},
+                {"GX703HRD", "7964-TFYJ6L-4bec23647da2f9bc8403d060635dbdda.zip"},
+                {"GX703HS", "7965-3HSRRO-c1869c30564e2db44a97c1e8953093b9.zip"},
+                {"GX703HSD", "7966-9CCDGL-96f0c0f9e1e50ee66894e7b168e59cc3.zip"},
+                {"GZ_Series", "2172-Z8OHBD-393c5060aaa27883e2fcbebc7e53997e.zip"},
+                {"GZ301VF", "13604-50UADT-4df87ac6eab6ac261647875d727db9d4.zip"},
+                {"GZ301VFC", "13787-WB73LI-b148b7cf3c90bc90fca4938bfc6fbbe5.zip"},
+                {"GZ301VI", "13601-DPC6YI-17ac748ec814ec3152ad973f3a0cff4b.zip"},
+                {"GZ301VIC", "13790-Z6V8RW-7a4f735f65c545158c7ba715694aa3c7.zip"},
+                {"GZ301VJ", "13600-UNQHZ7-e7d0cbf757eeed28dba9295b517ef835.zip"},
+                {"GZ301VJC", "13788-QVWJWQ-a13027f81094f94eea1d86152fe69ba9.zip"},
+                {"GZ301VQ", "13789-K6I7SO-4a8594363610c383e39940ff135c0d7e.zip"},
+                {"GZ301VQC", "13791-DBRKCU-a10ec3e290c5dc93bbb45f52c714a9b8.zip"},
+                {"GZ301VU", "13602-6JQ2BK-4353d6c0b83589477ff4570b49258217.zip"},
+                {"GZ301VUC", "13792-009F1L-4ee6b0014eca72c7d0217219ebe9e365.zip"},
+                {"GZ301VV", "13603-OOLT27-8788c068fdad2a64da9925a5411b30af.zip"},
+                {"GZ301VVC", "13793-8DIIWY-72aca4ea0f1db6c991b3e24da5a7907c.zip"},
+                {"GZ301ZA", "10139-YXT5A7-521746c1b4991657abc37999a318219e.zip"},
+                {"GZ301ZC", "10140-QA59M0-be0cf751aba85c98832f4a0f16456330.zip"},
+                {"GZ301ZE", "10141-P1OXLB-318b5c3601e0d5c55d3b4307eba08ab2.zip"},
+                {"GZ301ZH", "10142-ELMX6M-f9c50110ca0a763bf4b6d1e9dd9e3afa.zip"},
+                {"NR2301L", "14736-3DM4T5-41c1b0b5c2d726da7c66e0c39ea08017.zip"},
+                {"RC71L", "17126-IIDPFS-718c077a118724bb0045b35e30d5ac4e.zip"},
+                {"RC71X", "15182-KWVC62-c754d9ea39f9160df7e21e4538ce60df.zip"},
+                {"RC72LA", "19770-DOSUSI-85f700513af330af6e20fcfdabaeb87f.zip"},
+            };
+
+            if (profiles.ContainsKey(model))
+            {
+                return baseUrl + profiles[model];
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public static bool ProfileExists()
+        {
+            (string bios, string model) = AppConfig.GetBiosAndModel();
+            return (GetProfileUrl(model) is not null);
+        }
+
+        public static async Task InstallProfile()
+        {
+            ProcessHelper.RunAsAdmin();
+
+            (string bios, string model) = AppConfig.GetBiosAndModel();
+            string? profileUrl = GetProfileUrl(model);
+
+            if (profileUrl == null)
+            {
+                Logger.WriteLine($"No ICC Profile found for {model}");
+                return;
+            }
+
+            await DownloadAndExtractZip(profileUrl, VisualControl.GetGameVisualPath());
+        }
+
+        static async Task DownloadAndExtractZip(string zipUrl, string extractPath)
+        {
+            using (HttpClient client = new HttpClient())
+            {
+                try
+                {
+                    Logger.WriteLine($"Getting: {zipUrl}");
+                    byte[] zipData = await client.GetByteArrayAsync(zipUrl);
+
+                    Directory.CreateDirectory(extractPath);
+
+                    string tempZipPath = Path.Combine(extractPath, "temp.zip");
+                    await File.WriteAllBytesAsync(tempZipPath, zipData);
+
+                    ZipFile.ExtractToDirectory(tempZipPath, extractPath, true);
+
+                    File.Delete(tempZipPath);
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine($"Error: {ex.Message}");
+                }
+            }
+        }
+
+    }
+}

app/Display/DisplayGammaRamp.cs

@@ -0,0 +1,112 @@
+namespace GHelper.Display
+{
+
+    public class DisplayGammaRamp
+    {
+
+        public DisplayGammaRamp(ushort[] red, ushort[] green, ushort[] blue)
+        {
+            if (red?.Length != GammaRamp.DataPoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(red));
+            }
+
+            if (green?.Length != GammaRamp.DataPoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(green));
+            }
+
+            if (blue?.Length != GammaRamp.DataPoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(blue));
+            }
+
+            Red = red;
+            Green = green;
+            Blue = blue;
+        }
+
+        public DisplayGammaRamp(double brightness = 1, double contrast = 1, double gamma = 1)
+            : this(
+                CalculateLUT(brightness, contrast, gamma),
+                CalculateLUT(brightness, contrast, gamma),
+                CalculateLUT(brightness, contrast, gamma)
+            )
+        {
+        }
+
+        public DisplayGammaRamp(
+            double redBrightness,
+            double redContrast,
+            double redGamma,
+            double greenBrightness,
+            double greenContrast,
+            double greenGamma,
+            double blueBrightness,
+            double blueContrast,
+            double blueGamma
+        )
+            : this(
+                CalculateLUT(redBrightness, redContrast, redGamma),
+                CalculateLUT(greenBrightness, greenContrast, greenGamma),
+                CalculateLUT(blueBrightness, blueContrast, blueGamma)
+            )
+        {
+        }
+
+        internal DisplayGammaRamp(GammaRamp ramp) :
+            this(ramp.Red, ramp.Green, ramp.Blue)
+        {
+        }
+        public ushort[] Blue { get; }
+        public ushort[] Green { get; }
+        public ushort[] Red { get; }
+        private static ushort[] CalculateLUT(double brightness, double contrast, double gamma)
+        {
+            brightness = 0.5 + brightness / 2;
+            var result = new ushort[GammaRamp.DataPoints];
+            for (var i = 0; i < result.Length; i++)
+            {
+                result[i] = (ushort)(brightness * ushort.MaxValue * i / (float)(result.Length - 1));
+            }
+            return result;
+        }
+
+        public bool IsOriginal()
+        {
+            int MaxRed = Red[Red.Length - 1];
+            int MaxGreen = Green[Green.Length - 1];
+            int MaxBlue = Blue[Blue.Length - 1];
+            return (Math.Abs((MaxRed + MaxGreen + MaxBlue) / 3 - ushort.MaxValue) < 256);
+        }
+
+        private static ushort[] Brightness(ushort[] data, double brightness)
+        {
+            var result = new ushort[GammaRamp.DataPoints];
+            for (var i = 0; i < result.Length; i++)
+            {
+                if (brightness < 0.5)
+                    result[i] = (ushort)(0.5 * ushort.MaxValue * Math.Pow((float)i/(result.Length - 1),  2 - brightness*2));
+                else
+                    result[i] = (ushort)(data[i] * brightness);
+            }
+            return result;
+        }
+
+        internal GammaRamp AsBrightnessRamp(double brightness)
+        {
+            return new GammaRamp(
+                Brightness(Red, brightness),
+                Brightness(Green, brightness),
+                Brightness(Blue, brightness)
+            );
+        }
+
+        internal GammaRamp AsRamp()
+        {
+            return new GammaRamp(Red, Green, Blue);
+        }
+
+
+    }
+}

app/Display/GammaRamp.cs

@@ -0,0 +1,56 @@
+using System.Runtime.InteropServices;
+
+namespace GHelper.Display
+{
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct GammaRamp
+    {
+        public const int DataPoints = 256;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = DataPoints)]
+        public readonly ushort[] Red;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = DataPoints)]
+        public readonly ushort[] Green;
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = DataPoints)]
+        public readonly ushort[] Blue;
+
+        public GammaRamp(ushort[] red, ushort[] green, ushort[] blue)
+        {
+            if (red == null)
+            {
+                throw new ArgumentNullException(nameof(red));
+            }
+
+            if (green == null)
+            {
+                throw new ArgumentNullException(nameof(green));
+            }
+
+            if (blue == null)
+            {
+                throw new ArgumentNullException(nameof(blue));
+            }
+
+            if (red.Length != DataPoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(red));
+            }
+
+            if (green.Length != DataPoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(green));
+            }
+
+            if (blue.Length != DataPoints)
+            {
+                throw new ArgumentOutOfRangeException(nameof(blue));
+            }
+
+            Red = red;
+            Green = green;
+            Blue = blue;
+        }
+    }
+
+}

app/Display/ScreenCCD.cs

@@ -0,0 +1,391 @@
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace GHelper.Display
+{
+    public class ScreenCCD
+    {
+
+        public static bool GetHDRStatus(bool log = true)
+        {
+            var err = GetDisplayConfigBufferSizes(QDC.QDC_ONLY_ACTIVE_PATHS, out var pathCount, out var modeCount);
+            if (err != 0)
+                throw new Win32Exception(err);
+
+            var paths = new DISPLAYCONFIG_PATH_INFO[pathCount];
+            var modes = new DISPLAYCONFIG_MODE_INFO[modeCount];
+            err = QueryDisplayConfig(QDC.QDC_ONLY_ACTIVE_PATHS, ref pathCount, paths, ref modeCount, modes, IntPtr.Zero);
+            if (err != 0)
+            {
+                Logger.WriteLine("HDR Detection Error: " + new Win32Exception(err).Message);
+                return false;
+            }
+
+            string internalName = AppConfig.GetString("internal_display");
+
+            foreach (var path in paths)
+            {
+                // get display name
+                var info = new DISPLAYCONFIG_TARGET_DEVICE_NAME();
+                info.header.type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_TARGET_NAME;
+                info.header.size = Marshal.SizeOf<DISPLAYCONFIG_TARGET_DEVICE_NAME>();
+                info.header.adapterId = path.targetInfo.adapterId;
+                info.header.id = path.targetInfo.id;
+                err = DisplayConfigGetDeviceInfo(ref info);
+                if (err != 0)
+                    throw new Win32Exception(err);
+
+                var colorInfo = new DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO();
+                colorInfo.header.type = DISPLAYCONFIG_DEVICE_INFO_TYPE.DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO;
+                colorInfo.header.size = Marshal.SizeOf<DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO>();
+                colorInfo.header.adapterId = path.targetInfo.adapterId;
+                colorInfo.header.id = path.targetInfo.id;
+                err = DisplayConfigGetDeviceInfo(ref colorInfo);
+                if (err != 0)
+                    throw new Win32Exception(err);
+
+
+                if (info.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL ||
+                    info.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED ||
+                    info.monitorFriendlyDeviceName == internalName)
+                {
+                    if (log) Logger.WriteLine(info.monitorFriendlyDeviceName + " HDR: " + colorInfo.advancedColorEnabled + " " + colorInfo.bitsPerColorChannel + " " + colorInfo.value + " " + colorInfo.wideColorEnforced);
+                    return colorInfo.advancedColorEnabled && (colorInfo.bitsPerColorChannel > 8 || !colorInfo.wideColorEnforced);
+                }
+
+            }
+
+            return false;
+
+        }
+
+        private enum DISPLAYCONFIG_DEVICE_INFO_TYPE
+        {
+            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_GET_SUPPORT_VIRTUAL_RESOLUTION = 7,
+            DISPLAYCONFIG_DEVICE_INFO_SET_SUPPORT_VIRTUAL_RESOLUTION = 8,
+            DISPLAYCONFIG_DEVICE_INFO_GET_ADVANCED_COLOR_INFO = 9,
+            DISPLAYCONFIG_DEVICE_INFO_SET_ADVANCED_COLOR_STATE = 10,
+            DISPLAYCONFIG_DEVICE_INFO_GET_SDR_WHITE_LEVEL = 11,
+        }
+
+        private enum DISPLAYCONFIG_COLOR_ENCODING
+        {
+            DISPLAYCONFIG_COLOR_ENCODING_RGB = 0,
+            DISPLAYCONFIG_COLOR_ENCODING_YCBCR444 = 1,
+            DISPLAYCONFIG_COLOR_ENCODING_YCBCR422 = 2,
+            DISPLAYCONFIG_COLOR_ENCODING_YCBCR420 = 3,
+            DISPLAYCONFIG_COLOR_ENCODING_INTENSITY = 4,
+        }
+
+        private enum DISPLAYCONFIG_SCALING
+        {
+            DISPLAYCONFIG_SCALING_IDENTITY = 1,
+            DISPLAYCONFIG_SCALING_CENTERED = 2,
+            DISPLAYCONFIG_SCALING_STRETCHED = 3,
+            DISPLAYCONFIG_SCALING_ASPECTRATIOCENTEREDMAX = 4,
+            DISPLAYCONFIG_SCALING_CUSTOM = 5,
+            DISPLAYCONFIG_SCALING_PREFERRED = 128,
+        }
+
+        private enum DISPLAYCONFIG_ROTATION
+        {
+            DISPLAYCONFIG_ROTATION_IDENTITY = 1,
+            DISPLAYCONFIG_ROTATION_ROTATE90 = 2,
+            DISPLAYCONFIG_ROTATION_ROTATE180 = 3,
+        }
+
+        private enum DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY
+        {
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_OTHER = -1,
+            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_INDIRECT_WIRED = 16,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INDIRECT_VIRTUAL = 17,
+            DISPLAYCONFIG_OUTPUT_TECHNOLOGY_INTERNAL = unchecked((int)0x80000000),
+        }
+
+        private enum DISPLAYCONFIG_TOPOLOGY_ID
+        {
+            DISPLAYCONFIG_TOPOLOGY_INTERNAL = 0x00000001,
+            DISPLAYCONFIG_TOPOLOGY_CLONE = 0x00000002,
+            DISPLAYCONFIG_TOPOLOGY_EXTEND = 0x00000004,
+            DISPLAYCONFIG_TOPOLOGY_EXTERNAL = 0x00000008,
+        }
+
+        private enum DISPLAYCONFIG_PATH
+        {
+            DISPLAYCONFIG_PATH_ACTIVE = 0x00000001,
+            DISPLAYCONFIG_PATH_PREFERRED_UNSCALED = 0x00000004,
+            DISPLAYCONFIG_PATH_SUPPORT_VIRTUAL_MODE = 0x00000008,
+        }
+
+        private enum DISPLAYCONFIG_SOURCE_FLAGS
+        {
+            DISPLAYCONFIG_SOURCE_IN_USE = 0x00000001,
+        }
+
+        private enum DISPLAYCONFIG_TARGET_FLAGS
+        {
+            DISPLAYCONFIG_TARGET_IN_USE = 0x00000001,
+            DISPLAYCONFIG_TARGET_FORCIBLE = 0x00000002,
+            DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_BOOT = 0x00000004,
+            DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_PATH = 0x00000008,
+            DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_SYSTEM = 0x00000010,
+            DISPLAYCONFIG_TARGET_IS_HMD = 0x00000020,
+        }
+
+        private enum QDC
+        {
+            QDC_ALL_PATHS = 0x00000001,
+            QDC_ONLY_ACTIVE_PATHS = 0x00000002,
+            QDC_DATABASE_CURRENT = 0x00000004,
+            QDC_VIRTUAL_MODE_AWARE = 0x00000010,
+            QDC_INCLUDE_HMD = 0x00000020,
+        }
+
+        private enum DISPLAYCONFIG_SCANLINE_ORDERING
+        {
+            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,
+        }
+
+        private enum DISPLAYCONFIG_PIXELFORMAT
+        {
+            DISPLAYCONFIG_PIXELFORMAT_8BPP = 1,
+            DISPLAYCONFIG_PIXELFORMAT_16BPP = 2,
+            DISPLAYCONFIG_PIXELFORMAT_24BPP = 3,
+            DISPLAYCONFIG_PIXELFORMAT_32BPP = 4,
+            DISPLAYCONFIG_PIXELFORMAT_NONGDI = 5,
+        }
+
+        private enum DISPLAYCONFIG_MODE_INFO_TYPE
+        {
+            DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE = 1,
+            DISPLAYCONFIG_MODE_INFO_TYPE_TARGET = 2,
+            DISPLAYCONFIG_MODE_INFO_TYPE_DESKTOP_IMAGE = 3,
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_DEVICE_INFO_HEADER
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_TYPE type;
+            public int size;
+            public LUID adapterId;
+            public uint id;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
+            public uint value;
+            public DISPLAYCONFIG_COLOR_ENCODING colorEncoding;
+            public int bitsPerColorChannel;
+
+            public bool advancedColorSupported => (value & 0x1) == 0x1;
+            public bool advancedColorEnabled => (value & 0x2) == 0x2;
+            public bool wideColorEnforced => (value & 0x4) == 0x4;
+            public bool advancedColorForceDisabled => (value & 0x8) == 0x8;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct POINTL
+        {
+            public int x;
+            public int y;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct LUID
+        {
+            public uint LowPart;
+            public int HighPart;
+
+            public long Value => ((long)HighPart << 32) | LowPart;
+            public override string ToString() => Value.ToString();
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_SOURCE_MODE
+        {
+            public uint width;
+            public uint height;
+            public DISPLAYCONFIG_PIXELFORMAT pixelFormat;
+            public POINTL position;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_RATIONAL
+        {
+            public uint Numerator;
+            public uint Denominator;
+
+            public override string ToString() => Numerator + " / " + Denominator;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_2DREGION
+        {
+            public uint cx;
+            public uint cy;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_DESKTOP_IMAGE_INFO
+        {
+            public POINTL PathSourceSize;
+            public RECT DesktopImageRegion;
+            public RECT DesktopImageClip;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private 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)]
+        private struct DISPLAYCONFIG_TARGET_MODE
+        {
+            public DISPLAYCONFIG_VIDEO_SIGNAL_INFO targetVideoSignalInfo;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        private struct DISPLAYCONFIG_MODE_INFO_union
+        {
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_TARGET_MODE targetMode;
+
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_SOURCE_MODE sourceMode;
+
+            [FieldOffset(0)]
+            public DISPLAYCONFIG_DESKTOP_IMAGE_INFO desktopImageInfo;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_PATH_SOURCE_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            public DISPLAYCONFIG_SOURCE_FLAGS statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_PATH_TARGET_INFO
+        {
+            public LUID adapterId;
+            public uint id;
+            public uint modeInfoIdx;
+            public DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY outputTechnology;
+            public DISPLAYCONFIG_ROTATION rotation;
+            public DISPLAYCONFIG_SCALING scaling;
+            public DISPLAYCONFIG_RATIONAL refreshRate;
+            public DISPLAYCONFIG_SCANLINE_ORDERING scanLineOrdering;
+            public bool targetAvailable;
+            public DISPLAYCONFIG_TARGET_FLAGS statusFlags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_PATH_INFO
+        {
+            public DISPLAYCONFIG_PATH_SOURCE_INFO sourceInfo;
+            public DISPLAYCONFIG_PATH_TARGET_INFO targetInfo;
+            public DISPLAYCONFIG_PATH flags;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct DISPLAYCONFIG_MODE_INFO
+        {
+            public DISPLAYCONFIG_MODE_INFO_TYPE infoType;
+            public uint id;
+            public LUID adapterId;
+            public DISPLAYCONFIG_MODE_INFO_union info;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct DISPLAYCONFIG_SOURCE_DEVICE_NAME
+        {
+            public DISPLAYCONFIG_DEVICE_INFO_HEADER header;
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+            public string viewGdiDeviceName;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct DISPLAYCONFIG_TARGET_DEVICE_NAME_FLAGS
+        {
+            public uint value;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private 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 monitorDevicePat;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct RECT
+        {
+            public int left;
+            public int top;
+            public int right;
+            public int bottom;
+        }
+
+        [DllImport("user32")]
+        private static extern int GetDisplayConfigBufferSizes(QDC flags, out int numPathArrayElements, out int numModeInfoArrayElements);
+
+        [DllImport("user32")]
+        private static extern int QueryDisplayConfig(QDC flags, ref int numPathArrayElements, [In, Out] DISPLAYCONFIG_PATH_INFO[] pathArray, ref int numModeInfoArrayElements, [In, Out] DISPLAYCONFIG_MODE_INFO[] modeInfoArray, out DISPLAYCONFIG_TOPOLOGY_ID currentTopologyId);
+
+        [DllImport("user32")]
+        private static extern int QueryDisplayConfig(QDC flags, ref int numPathArrayElements, [In, Out] DISPLAYCONFIG_PATH_INFO[] pathArray, ref int numModeInfoArrayElements, [In, Out] DISPLAYCONFIG_MODE_INFO[] modeInfoArray, IntPtr currentTopologyId);
+
+        [DllImport("user32")]
+        private static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_GET_ADVANCED_COLOR_INFO requestPacket);
+
+        [DllImport("user32")]
+        private static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_SOURCE_DEVICE_NAME requestPacket);
+
+        [DllImport("user32")]
+        private static extern int DisplayConfigGetDeviceInfo(ref DISPLAYCONFIG_TARGET_DEVICE_NAME requestPacket);
+    }
+}

app/Display/ScreenControl.cs

@@ -6,6 +6,14 @@ namespace GHelper.Display
     {
 
         public const int MAX_REFRESH = 1000;
+        public static int MIN_RATE = AppConfig.Get("min_rate", 60);
+        public static int MAX_RATE = AppConfig.Get("max_rate");
+
+        public static int GetMaxRate(string? laptopScreen)
+        {
+            if (MAX_RATE > 0) return MAX_RATE;
+            else return ScreenNative.GetMaxRefreshRate(laptopScreen);
+        }
 
         public void AutoScreen(bool force = false)
         {
@@ -14,7 +22,7 @@ namespace GHelper.Display
                 if (SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online)
                     SetScreen(MAX_REFRESH, 1);
                 else
-                    SetScreen(60, 0);
+                    SetScreen(MIN_RATE, 0);
             }
             else
             {
@@ -22,66 +30,172 @@ namespace GHelper.Display
             }
         }
 
-        public void SetScreen(int frequency = -1, int overdrive = -1, int miniled = -1)
+        public void ToggleScreenRate()
         {
             var laptopScreen = ScreenNative.FindLaptopScreen(true);
+            var refreshRate = ScreenNative.GetRefreshRate(laptopScreen);
+            if (refreshRate < 0) return;
 
-            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);
-            }
-
+            ScreenNative.SetRefreshRate(laptopScreen, refreshRate > MIN_RATE ? MIN_RATE : GetMaxRate(laptopScreen));
             InitScreen();
         }
 
 
-        public void ToogleMiniled()
+        public void SetScreen(int frequency = -1, int overdrive = -1, int miniled = -1)
         {
-            int miniled = (AppConfig.Get("miniled") == 1) ? 0 : 1;
+            var laptopScreen = ScreenNative.FindLaptopScreen(true);
+            var refreshRate = ScreenNative.GetRefreshRate(laptopScreen);
+
+            if (refreshRate < 0) return;
+
+            if (frequency >= MAX_REFRESH)
+            {
+                frequency = GetMaxRate(laptopScreen);
+            }
+
+            if (frequency > 0 && frequency != refreshRate)
+            {
+                ScreenNative.SetRefreshRate(laptopScreen, frequency);
+            }
+
+            if (Program.acpi.IsOverdriveSupported() && overdrive >= 0)
+            {
+                if (AppConfig.IsNoOverdrive()) overdrive = 0;
+                if (overdrive != Program.acpi.DeviceGet(AsusACPI.ScreenOverdrive))
+                {
+                    Program.acpi.DeviceSet(AsusACPI.ScreenOverdrive, overdrive, "ScreenOverdrive");
+                }
+            }
+
+            SetMiniled(miniled);
+
+            InitScreen();
+        }
+
+        public void SetMiniled(int miniled = -1)
+        {
+            if (miniled >= 0)
+            {
+                if (Program.acpi.DeviceGet(AsusACPI.ScreenMiniled1) >= 0)
+                    Program.acpi.DeviceSet(AsusACPI.ScreenMiniled1, miniled, "Miniled1");
+                else
+                {
+                    Program.acpi.DeviceSet(AsusACPI.ScreenMiniled2, miniled, "Miniled2");
+                    Thread.Sleep(100);
+                }
+            }
+        }
+
+        public void InitMiniled()
+        {
+            if (AppConfig.IsForceMiniled())
+                SetMiniled(AppConfig.Get("miniled"));
+        }
+
+        public void ToogleFHD()
+        {
+            int fhd = Program.acpi.DeviceGet(AsusACPI.ScreenFHD);
+            Logger.WriteLine($"FHD Toggle: {fhd}");
+
+            DialogResult dialogResult = MessageBox.Show("Changing display mode requires reboot", Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
+            if (dialogResult == DialogResult.Yes)
+            {
+                Program.acpi.DeviceSet(AsusACPI.ScreenFHD, (fhd == 1) ? 0 : 1, "FHD");
+                Process.Start("shutdown", "/r /t 1");
+            }
+        }
+
+        public string ToogleMiniled()
+        {
+            int miniled1 = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled1);
+            int miniled2 = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled2);
+
+            Logger.WriteLine($"MiniledToggle: {miniled1} {miniled2}");
+
+            int miniled;
+            string name;
+
+            if (miniled1 >= 0)
+            {
+                switch (miniled1)
+                {
+                    case 1: 
+                        miniled = 0;
+                        name = Properties.Strings.OneZone;
+                        break;
+                    default:
+                        miniled = 1;
+                        name = Properties.Strings.Multizone;
+                        break;
+                }
+            }
+            else
+            {
+                switch (miniled2)
+                {
+                    case 1: 
+                        miniled = 2;
+                        name = Properties.Strings.OneZone;
+                        break;
+                    case 2: 
+                        miniled = 0;
+                        name = Properties.Strings.Multizone;
+                        break;
+                    default: 
+                        miniled = 1;
+                        name = Properties.Strings.MultizoneStrong;
+                        break;
+                }
+            }
+
             AppConfig.Set("miniled", miniled);
-            SetScreen(-1, -1, miniled);
+            SetScreen(miniled: miniled);
+            
+            return name;
         }
 
         public void InitScreen()
         {
             var laptopScreen = ScreenNative.FindLaptopScreen();
-
             int frequency = ScreenNative.GetRefreshRate(laptopScreen);
-            int maxFrequency = ScreenNative.GetMaxRefreshRate(laptopScreen);
+            int maxFrequency = GetMaxRate(laptopScreen);
+
+            if (maxFrequency > 0) AppConfig.Set("max_frequency", maxFrequency);
+            else maxFrequency = AppConfig.Get("max_frequency");
 
             bool screenAuto = AppConfig.Is("screen_auto");
-            bool overdriveSetting = !AppConfig.Is("no_overdrive");
+            bool overdriveSetting = Program.acpi.IsOverdriveSupported() && !AppConfig.IsNoOverdrive();
 
-            int overdrive = Program.acpi.DeviceGet(AsusACPI.ScreenOverdrive);
-            int miniled = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled);
+            int overdrive = AppConfig.IsNoOverdrive() ? 0 : Program.acpi.DeviceGet(AsusACPI.ScreenOverdrive);
+
+            int miniled1 = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled1);
+            int miniled2 = Program.acpi.DeviceGet(AsusACPI.ScreenMiniled2);
+
+            int miniled = (miniled1 >= 0) ? miniled1 : miniled2;
+            bool hdr = false;
 
             if (miniled >= 0)
+            {
+                Logger.WriteLine($"Miniled: {miniled1} {miniled2}");
                 AppConfig.Set("miniled", miniled);
+            }
+
+            try
+            {
+                hdr = ScreenCCD.GetHDRStatus();
+            } catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
 
             bool screenEnabled = (frequency >= 0);
 
+            int fhd = -1;
+            if (AppConfig.IsDUO())
+            {
+                fhd = Program.acpi.DeviceGet(AsusACPI.ScreenFHD);
+            }
+
             AppConfig.Set("frequency", frequency);
             AppConfig.Set("overdrive", overdrive);
 
@@ -94,7 +208,10 @@ namespace GHelper.Display
                     maxFrequency: maxFrequency,
                     overdrive: overdrive,
                     overdriveSetting: overdriveSetting,
-                    miniled: miniled
+                    miniled1: miniled1,
+                    miniled2: miniled2,
+                    hdr: hdr,
+                    fhd: fhd
                 );
             });
 

app/Display/ScreenInterrogatory.cs

@@ -1,4 +1,6 @@
-using System.ComponentModel;
+using GHelper.Helpers;
+using NvAPIWrapper.Display;
+using System.ComponentModel;
 using System.Runtime.InteropServices;
 
 namespace GHelper.Display
@@ -259,6 +261,49 @@ namespace GHelper.Display
 
         #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
@@ -294,7 +339,47 @@ namespace GHelper.Display
 
             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);
+                {
+                    DISPLAYCONFIG_TARGET_DEVICE_NAME? displayName = null;
+                    try
+                    {
+                        displayName = DeviceName(displayModes[i].adapterId, displayModes[i].id);
+                        
+                    } catch (Exception e)
+                    {
+                        Logger.WriteLine(e.Message);
+                    }
+
+                    if (displayName is not null) yield return (DISPLAYCONFIG_TARGET_DEVICE_NAME)displayName;
+                }
+                    
+        }
+
+
+        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++;
+            }
         }
 
 

app/Display/ScreenNative.cs

@@ -1,10 +1,53 @@
-using System.Runtime.InteropServices;
+using System.Collections;
+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
     {
+
+        [DllImport("gdi32", CharSet = CharSet.Unicode)]
+        internal static extern IntPtr CreateDC(string driver, string device, string port, IntPtr deviceMode);
+
+        [DllImport("gdi32")]
+        internal static extern bool SetDeviceGammaRamp(IntPtr dcHandle, ref GammaRamp ramp);
+
+        [DllImport("gdi32")]
+        internal static extern bool GetDeviceGammaRamp(IntPtr dcHandle, ref GammaRamp ramp);
+
+        [DllImport("gdi32", CharSet = CharSet.Unicode)]
+        internal static extern bool SetICMProfileW(IntPtr dcHandle, string lpFileName);
+
+        [DllImport("gdi32", CharSet = CharSet.Unicode)]
+        internal static extern bool SetICMMode(IntPtr dcHandle, int mode);
+
         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
         public struct DEVMODE
         {
@@ -118,39 +161,13 @@ namespace GHelper.Display
         public const int ENUM_CURRENT_SETTINGS = -1;
         public const string defaultDevice = @"\\.\DISPLAY1";
 
-        static bool? _ultimate = null;
 
-        static bool isUltimate
+        public static string? FindInternalName(bool log = false)
         {
-            get
-            {
-                if (_ultimate is null) _ultimate = (Program.acpi.DeviceGet(AsusACPI.GPUMux) == 0);
-                return (bool)_ultimate;
-            }
-        }
-
-        public static string? FindLaptopScreen(bool log = false)
-        {
-            string? laptopScreen = null;
-            var screens = Screen.AllScreens;
-
-            /*
-            if (!isUltimate)
-            {
-                foreach (var screen in screens )
-                {
-                    if (log) Logger.WriteLine(screen.DeviceName);
-                    if (screen.DeviceName == defaultDevice) return defaultDevice;
-                }
-            }
-            */
-
             try
             {
-                var devices = GetAllDevices().ToArray();
-
-                int count = 0, displayNum = -1;
-
+                var devicesList = GetAllDevices();
+                var devices = devicesList.ToArray();
                 string internalName = AppConfig.GetString("internal_display");
 
                 foreach (var device in devices)
@@ -159,29 +176,71 @@ namespace GHelper.Display
                         device.outputTechnology == DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY.DISPLAYCONFIG_OUTPUT_TECHNOLOGY_DISPLAYPORT_EMBEDDED ||
                         device.monitorFriendlyDeviceName == internalName)
                     {
-                        displayNum = count;
+                        if (log) Logger.WriteLine(device.monitorDevicePath + " " + device.outputTechnology);
+
                         AppConfig.Set("internal_display", device.monitorFriendlyDeviceName);
+                        var names = device.monitorDevicePath.Split("#");
+                        
+                        if (names.Length > 1) return names[1];
+                        else return "";
                     }
-                    if (log) Logger.WriteLine(device.monitorFriendlyDeviceName + ":" + device.outputTechnology.ToString() + ": " + ((count < screens.Length) ? screens[count].DeviceName : ""));
-                    count++;
                 }
-
-                count = 0;
-                foreach (var screen in screens)
-                {
-                    if (count == displayNum) laptopScreen = screen.DeviceName;
-                    count++;
-                }
-
-                if (displayNum > 0 && count == 0) laptopScreen = defaultDevice;
             }
             catch (Exception ex)
             {
                 Logger.WriteLine(ex.ToString());
-                Logger.WriteLine("Can't detect internal screen");
-                laptopScreen = Screen.PrimaryScreen.DeviceName;
             }
 
+            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;
         }
@@ -234,15 +293,6 @@ namespace GHelper.Display
                 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));
-
-                //Fallback scenario
-                if (iRet != 0)
-                {
-                    Thread.Sleep(1000);
-                    iRet = ChangeDisplaySettingsEx(laptopScreen, ref dm, IntPtr.Zero, DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
-                    Logger.WriteLine("Screen = " + frequency.ToString() + "Hz : " + (iRet == 0 ? "OK" : iRet));
-                }
-
                 return iRet;
             }
 

app/Display/VisualControl.cs

@@ -0,0 +1,466 @@
+using GHelper.Helpers;
+using Microsoft.Win32;
+using System.Management;
+
+namespace GHelper.Display
+{
+    public enum SplendidGamut : int
+    {
+        VivoNative = 0,
+        VivoSRGB = 1,
+        VivoDCIP3 = 3,
+        ViviDisplayP3 = 4,
+        Native = 50,
+        sRGB = 51,
+        DCIP3 = 53,
+        DisplayP3 = 54
+    }
+
+    public enum SplendidCommand : int
+    {
+        None = -1,
+
+        VivoNormal = 1,
+        VivoVivid = 2,
+        VivoManual = 6,
+        VivoEycare = 7,
+
+        Init = 10,
+        DimmingVivo = 9,
+        DimmingVisual = 19,
+        GamutMode = 200,
+
+        Default = 11,
+        Racing = 21,
+        Scenery = 22,
+        RTS = 23,
+        FPS = 24,
+        Cinema = 25,
+        Vivid = 13,
+        Eyecare = 17,
+        Disabled = 18,
+    }
+    public static class VisualControl
+    {
+        public static DisplayGammaRamp? gammaRamp;
+
+        private static int _brightness = 100;
+        private static bool _init = true;
+        private static bool _download = true;
+        private static string? _splendidPath = null;
+
+        private static System.Timers.Timer brightnessTimer = new System.Timers.Timer(200);
+
+        public const int DefaultColorTemp = 50;
+
+        public static bool forceVisual = false;
+        public static bool skipGamut = false;
+
+        static VisualControl()
+        {
+            brightnessTimer.Elapsed += BrightnessTimerTimer_Elapsed;
+        }
+
+        public static string GetGameVisualPath()
+        {
+            return Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\ASUS\\GameVisual";
+        }
+
+        public static string GetVivobookPath()
+        {
+            return Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\ASUS\\ASUS System Control Interface\\ASUSOptimization\\Splendid";
+        }
+
+        public static SplendidGamut GetDefaultGamut()
+        {
+            return AppConfig.IsVivoZenPro() ? SplendidGamut.VivoNative : SplendidGamut.Native;
+        }
+
+        public static Dictionary<SplendidGamut, string> GetGamutModes()
+        {
+
+            bool isVivo = AppConfig.IsVivoZenPro();
+
+            Dictionary<SplendidGamut, string> _modes = new Dictionary<SplendidGamut, string>();
+
+            string iccPath = isVivo ? GetVivobookPath() : GetGameVisualPath();
+
+            if (!Directory.Exists(iccPath))
+            {
+                Logger.WriteLine(iccPath + " doesn't exit");
+                return _modes;
+            }
+
+            try
+            {
+                DirectoryInfo d = new DirectoryInfo(iccPath);
+                FileInfo[] icms = d.GetFiles("*.icm");
+                if (icms.Length == 0) return _modes;
+
+                _modes.Add(isVivo ? SplendidGamut.VivoNative : SplendidGamut.Native, "Gamut: Native");
+                foreach (FileInfo icm in icms)
+                {
+                    //Logger.WriteLine(icm.FullName);
+
+                    if (icm.Name.Contains("sRGB"))
+                    {
+                        try
+                        {
+                            _modes.Add(isVivo ? SplendidGamut.VivoSRGB : SplendidGamut.sRGB, "Gamut: sRGB");
+                            Logger.WriteLine(icm.FullName + " sRGB");
+                        }
+                        catch
+                        {
+                        }
+                    }
+
+                    if (icm.Name.Contains("DCIP3"))
+                    {
+                        try
+                        {
+                            _modes.Add(isVivo ? SplendidGamut.VivoDCIP3 : SplendidGamut.DCIP3, "Gamut: DCIP3");
+                            Logger.WriteLine(icm.FullName + " DCIP3");
+                        }
+                        catch
+                        {
+                        }
+                    }
+
+                    if (icm.Name.Contains("DisplayP3"))
+                    {
+                        try
+                        {
+                            _modes.Add(isVivo ? SplendidGamut.ViviDisplayP3 : SplendidGamut.DisplayP3, "Gamut: DisplayP3");
+                            Logger.WriteLine(icm.FullName + " DisplayP3");
+                        }
+                        catch
+                        {
+                        }
+                    }
+                }
+                return _modes;
+            }
+            catch (Exception ex)
+            {
+                //Logger.WriteLine(ex.Message);
+                Logger.WriteLine(ex.ToString());
+                return _modes;
+            }
+
+        }
+
+        public static SplendidCommand GetDefaultVisualMode()
+        {
+            return AppConfig.IsVivoZenPro() ? SplendidCommand.VivoNormal : SplendidCommand.Default;
+        }
+
+        public static Dictionary<SplendidCommand, string> GetVisualModes()
+        {
+
+            if (AppConfig.IsVivoZenPro())
+            {
+                return new Dictionary<SplendidCommand, string>
+                {
+                    { SplendidCommand.VivoNormal, "Default" },
+                    { SplendidCommand.VivoVivid, "Vivid" },
+                    { SplendidCommand.VivoManual, "Manual" },
+                    { SplendidCommand.VivoEycare, "Eyecare" },
+                };
+            }
+
+            return new Dictionary<SplendidCommand, string>
+            {
+                { SplendidCommand.Default, "Default"},
+                { SplendidCommand.Racing, "Racing"},
+                { SplendidCommand.Scenery, "Scenery"},
+                { SplendidCommand.RTS, "RTS/RPG"},
+                { SplendidCommand.FPS, "FPS"},
+                { SplendidCommand.Cinema, "Cinema"},
+                { SplendidCommand.Vivid, "Vivid" },
+                { SplendidCommand.Eyecare, "Eyecare"},
+                { SplendidCommand.Disabled, "Disabled"}
+            };
+        }
+
+        public static Dictionary<int, string> GetTemperatures()
+        {
+            return new Dictionary<int, string>
+            {
+                { 0, "Warmest"},
+                { 15, "Warmer"},
+                { 30, "Warm"},
+                { 50, "Neutral"},
+                { 70, "Cold"},
+                { 85, "Colder"},
+                { 100, "Coldest"},
+            };
+        }
+
+        public static Dictionary<int, string> GetEyeCares()
+        {
+            return new Dictionary<int, string>
+            {
+                { 0, "0"},
+                { 1, "1"},
+                { 2, "2"},
+                { 3, "3"},
+                { 4, "4"},
+            };
+        }
+
+        const string GameVisualKey = @"HKEY_CURRENT_USER\Software\ASUS\ARMOURY CRATE Service\GameVisual";
+        const string GameVisualValue = "ActiveGVStatus";
+
+        public static bool IsEnabled()
+        {
+            var status = (int?)Registry.GetValue(GameVisualKey, GameVisualValue, 1);
+            return status > 0;
+        }
+
+        public static void SetRegStatus(int status = 1)
+        {
+            Registry.SetValue(GameVisualKey, GameVisualValue, status, RegistryValueKind.DWord);
+        }
+
+        public static void SetGamut(int mode = -1)
+        {
+            if (skipGamut) return;
+            if (mode < 0) mode = (int)GetDefaultGamut();
+
+            AppConfig.Set("gamut", mode);
+
+            var result = RunSplendid(SplendidCommand.GamutMode, 0, mode);
+            if (result == 0) return;
+            if (result == -1)
+            {
+                Logger.WriteLine("Gamut setting refused, reverting.");
+                RunSplendid(SplendidCommand.GamutMode, 0, (int)GetDefaultGamut());
+                if (ProcessHelper.IsUserAdministrator() && _download)
+                {
+                    _download = false;
+                    ColorProfileHelper.InstallProfile();
+                }
+            }
+            if (result == 1 && _init)
+            {
+                _init = false;
+                RunSplendid(SplendidCommand.Init);
+                RunSplendid(SplendidCommand.GamutMode, 0, mode);
+            }
+        }
+
+        public static void SetVisual(SplendidCommand mode = SplendidCommand.Default, int whiteBalance = DefaultColorTemp, bool init = false)
+        {
+            if (mode == SplendidCommand.None) return;
+            if ((mode == SplendidCommand.Disabled || mode == SplendidCommand.Default || mode == SplendidCommand.VivoNormal) && init) return; // Skip default setting on init
+
+            if (!forceVisual && ScreenCCD.GetHDRStatus(true)) return;
+            if (!forceVisual && ScreenNative.GetRefreshRate(ScreenNative.FindLaptopScreen(true)) < 0) return;
+
+            AppConfig.Set("visual", (int)mode);
+            AppConfig.Set("color_temp", whiteBalance);
+
+            if (whiteBalance != DefaultColorTemp && !init) ProcessHelper.RunAsAdmin();
+
+            int? balance = null;
+            int command = 0;
+
+            switch (mode)
+            {
+                case SplendidCommand.Disabled:
+                    command = 2;
+                    break;
+                case SplendidCommand.Eyecare:
+                    balance = 4;
+                    break;
+                case SplendidCommand.VivoNormal:
+                case SplendidCommand.VivoVivid:
+                    balance = null;
+                    break;
+                case SplendidCommand.VivoEycare:
+                    balance = Math.Abs(whiteBalance - 50) * 4 / 50;
+                    break;
+                default:
+                    balance = whiteBalance;
+                    break;
+            }
+
+            int result = RunSplendid(mode, command, balance);
+            if (result == 0) return;
+            if (result == -1)
+            {
+                Logger.WriteLine("Visual mode setting refused, reverting.");
+                RunSplendid(SplendidCommand.Default, 0, DefaultColorTemp);
+                if (ProcessHelper.IsUserAdministrator() && _download)
+                {
+                    _download = false;
+                    ColorProfileHelper.InstallProfile();
+                }
+            }
+            if (result == 1 && _init)
+            {
+                _init = false;
+                RunSplendid(SplendidCommand.Init);
+                RunSplendid(mode, 0, balance);
+            }
+        }
+
+        private static string GetSplendidPath()
+        {
+            if (_splendidPath == null)
+            {
+                try
+                {
+                    using (var searcher = new ManagementObjectSearcher(@"Select * from Win32_SystemDriver WHERE Name='ATKWMIACPIIO'"))
+                    {
+                        foreach (var driver in searcher.Get())
+                        {
+                            string path = driver["PathName"].ToString();
+                            _splendidPath = Path.GetDirectoryName(path) + "\\AsusSplendid.exe";
+                            break;
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine(ex.Message);
+                }
+            }
+
+            return _splendidPath;
+        }
+
+        private static int RunSplendid(SplendidCommand command, int? param1 = null, int? param2 = null)
+        {
+            var splendid = GetSplendidPath();
+            bool isVivo = AppConfig.IsVivoZenPro();
+            bool isSplenddid = File.Exists(splendid);
+
+            if (isSplenddid)
+            {
+                if (command == SplendidCommand.DimmingVisual && isVivo) command = SplendidCommand.DimmingVivo;
+                var result = ProcessHelper.RunCMD(splendid, (int)command + " " + param1 + " " + param2);
+                if (result.Contains("file not exist") || (result.Length == 0 && !isVivo)) return 1;
+                if (result.Contains("return code: -1")) return -1;
+                if (result.Contains("Visual is disabled"))
+                {
+                    SetRegStatus(1);
+                    return 1;
+                }
+            }
+
+            return 0;
+        }
+
+        private static void BrightnessTimerTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
+        {
+            brightnessTimer.Stop();
+
+
+            if (RunSplendid(SplendidCommand.DimmingVisual, 0, (int)(40 + _brightness * 0.6)) == 0) return;
+
+            if (_init)
+            {
+                _init = false;
+                RunSplendid(SplendidCommand.Init);
+                RunSplendid(SplendidCommand.Init, 4);
+                if (RunSplendid(SplendidCommand.DimmingVisual, 0, (int)(40 + _brightness * 0.6)) == 0) return;
+            }
+
+            // GammaRamp Fallback
+            SetGamma(_brightness);
+        }
+
+        public static void InitBrightness()
+        {
+            if (!AppConfig.IsOLED()) return;
+            if (!AppConfig.SaveDimming()) return;
+
+            int brightness = GetBrightness();
+            if (brightness >= 0) SetBrightness(brightness);
+        }
+
+        private static bool IsOnBattery()
+        {
+            return AppConfig.SaveDimming() && SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
+        }
+
+        public static int GetBrightness()
+        {
+            return AppConfig.Get(IsOnBattery() ? "brightness_battery" : "brightness", 100);
+        }
+
+        public static int SetBrightness(int brightness = -1, int delta = 0)
+        {
+            if (!AppConfig.IsOLED()) return -1;
+            if (brightness < 0) brightness = GetBrightness();
+
+            _brightness = Math.Max(0, Math.Min(100, brightness + delta));
+            AppConfig.Set(IsOnBattery() ? "brightness_battery" : "brightness", _brightness);
+
+            brightnessTimer.Start();
+
+            Program.settingsForm.VisualiseBrightness();
+            //if (brightness < 100) ResetGamut();
+
+            return _brightness;
+        }
+
+        public static void ResetGamut()
+        {
+            int defaultGamut = (int)GetDefaultGamut();
+
+            if (AppConfig.Get("gamut") != defaultGamut)
+            {
+                skipGamut = true;
+                AppConfig.Set("gamut", defaultGamut);
+                Program.settingsForm.VisualiseGamut();
+                skipGamut = false;
+            }
+        }
+
+
+        public static void SetGamma(int brightness = 100)
+        {
+            var bright = Math.Round((float)brightness / 200 + 0.5, 2);
+
+            var screenName = ScreenNative.FindLaptopScreen();
+            if (screenName is null) return;
+
+            try
+            {
+                var handle = ScreenNative.CreateDC(screenName, screenName, null, IntPtr.Zero);
+                if (gammaRamp is null)
+                {
+                    var gammaDump = new GammaRamp();
+                    if (ScreenNative.GetDeviceGammaRamp(handle, ref gammaDump))
+                    {
+                        gammaRamp = new DisplayGammaRamp(gammaDump);
+                        //Logger.WriteLine("Gamma R: " + string.Join("-", gammaRamp.Red));
+                        //Logger.WriteLine("Gamma G: " + string.Join("-", gammaRamp.Green));
+                        //Logger.WriteLine("Gamma B: " + string.Join("-", gammaRamp.Blue));
+                    }
+                }
+
+                if (gammaRamp is null || !gammaRamp.IsOriginal())
+                {
+                    Logger.WriteLine("Not default Gamma");
+                    gammaRamp = new DisplayGammaRamp();
+                }
+
+                var ramp = gammaRamp.AsBrightnessRamp(bright);
+                bool result = ScreenNative.SetDeviceGammaRamp(handle, ref ramp);
+
+                Logger.WriteLine("Gamma " + bright.ToString() + ": " + result);
+
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
+            }
+
+            //ScreenBrightness.Set(60 + (int)(40 * bright));
+        }
+
+    }
+}

app/Extra.cs

@@ -2,7 +2,9 @@
 using GHelper.Gpu.AMD;
 using GHelper.Helpers;
 using GHelper.Input;
+using GHelper.Mode;
 using GHelper.UI;
+using GHelper.USB;
 using System.Diagnostics;
 
 namespace GHelper
@@ -11,26 +13,46 @@ namespace GHelper
     {
 
         ScreenControl screenControl = new ScreenControl();
+        ClamshellModeControl clamshellControl = new ClamshellModeControl();
+
+        const string EMPTY = "--------------";
 
-        Dictionary<string, string> customActions = new Dictionary<string, string>
-        {
-          {"","--------------" },
-          {"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)
         {
 
+            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},
+              {"lock", Properties.Strings.LockScreen},
+              {"miniled", Properties.Strings.ToggleMiniled},
+              {"fnlock", Properties.Strings.ToggleFnLock},
+              {"brightness_down", Properties.Strings.BrightnessDown},
+              {"brightness_up", Properties.Strings.BrightnessUp},
+              {"visual", Properties.Strings.VisualMode},
+              {"touchscreen", Properties.Strings.ToggleTouchscreen },
+              {"micmute", Properties.Strings.MuteMic},
+              {"ghelper", Properties.Strings.OpenGHelper},
+              {"custom", Properties.Strings.Custom}
+            };
+
+            if (AppConfig.IsDUO())
+            {
+                customActions.Add("screenpad_down", Properties.Strings.ScreenPadDown);
+                customActions.Add("screenpad_up", Properties.Strings.ScreenPadUp);
+            }
+
+            if (AppConfig.IsAlly())
+            {
+                customActions.Add("controller", "Controller Mode");
+            }
+
             switch (name)
             {
                 case "m1":
@@ -41,9 +63,11 @@ namespace GHelper
                     break;
                 case "m3":
                     customActions[""] = Properties.Strings.MuteMic;
+                    customActions.Remove("micmute");
                     break;
                 case "m4":
                     customActions[""] = Properties.Strings.OpenGHelper;
+                    customActions.Remove("ghelper");
                     break;
                 case "fnf4":
                     customActions[""] = Properties.Strings.ToggleAura;
@@ -53,6 +77,19 @@ namespace GHelper
                     customActions[""] = Properties.Strings.ToggleFnLock;
                     customActions.Remove("fnlock");
                     break;
+                case "fnv":
+                    customActions[""] = Properties.Strings.VisualMode;
+                    customActions.Remove("visual");
+                    break;
+                case "fne":
+                    customActions[""] = "Calculator";
+                    break;
+                case "paddle":
+                    customActions[""] = EMPTY;
+                    break;
+                case "cc":
+                    customActions[""] = EMPTY;
+                    break;
             }
 
             combo.DropDownStyle = ComboBoxStyle.DropDownList;
@@ -94,6 +131,8 @@ namespace GHelper
             checkSleep.Text = Properties.Strings.Sleep;
             checkBoot.Text = Properties.Strings.Boot;
             checkShutdown.Text = Properties.Strings.Shutdown;
+            checkBootSound.Text = Properties.Strings.BootSound;
+            checkStatusLed.Text = Properties.Strings.LEDStatusIndicators;
 
             labelSpeed.Text = Properties.Strings.AnimationSpeed;
             //labelBrightness.Text = Properties.Strings.Brightness;
@@ -101,11 +140,10 @@ namespace GHelper
             labelBacklightTimeout.Text = Properties.Strings.BacklightTimeout;
             //labelBacklightTimeoutPlugged.Text = Properties.Strings.BacklightTimeoutPlugged;
 
+            checkGPUFix.Text = Properties.Strings.EnableGPUOnShutdown;
             checkNoOverdrive.Text = Properties.Strings.DisableOverdrive;
             checkTopmost.Text = Properties.Strings.WindowTop;
             checkUSBC.Text = Properties.Strings.OptimizedUSBC;
-            checkAutoApplyWindowsPowerMode.Text = Properties.Strings.ApplyWindowsPowerPlan;
-            checkFnLock.Text = Properties.Strings.FnLock;
             checkAutoToggleClamshellMode.Text = Properties.Strings.ToggleClamshellMode;
 
             labelBacklightKeyboard.Text = Properties.Strings.Keyboard;
@@ -114,118 +152,252 @@ namespace GHelper
             labelBacklightLogo.Text = Properties.Strings.Logo;
 
             checkGpuApps.Text = Properties.Strings.KillGpuApps;
+            checkBWIcon.Text = Properties.Strings.BWTrayIcon;
+            labelHibernateAfter.Text = Properties.Strings.HibernateAfter;
+
+            labelAPUMem.Text = Properties.Strings.APUMemory;
 
             Text = Properties.Strings.ExtraSettings;
 
-            if (AppConfig.ContainsModel("Duo"))
+            // Accessible Labels
+
+            panelServices.AccessibleName = Properties.Strings.AsusServicesRunning;
+            panelBindings.AccessibleName = Properties.Strings.KeyBindings;
+            tableBindings.AccessibleName = Properties.Strings.KeyBindings;
+
+            comboM1.AccessibleName = "M1 Action";
+            comboM2.AccessibleName = "M2 Action";
+            comboM3.AccessibleName = "M3 Action";
+            comboM4.AccessibleName = "M4 Action";
+            comboFNF4.AccessibleName = "Fn+F4 Action";
+            comboFNC.AccessibleName = "Fn+C Action";
+            comboFNV.AccessibleName = "Fn+V Action";
+            comboFNE.AccessibleName = "Fn+Numpad Action";
+
+            numericBacklightPluggedTime.AccessibleName = Properties.Strings.BacklightTimeoutPlugged;
+            numericBacklightTime.AccessibleName = Properties.Strings.BacklightTimeoutBattery;
+
+            comboKeyboardSpeed.AccessibleName = Properties.Strings.LaptopBacklight + " " +Properties.Strings.AnimationSpeed;
+            comboAPU.AccessibleName = Properties.Strings.LaptopBacklight + " " + Properties.Strings.AnimationSpeed;
+
+            checkBoot.AccessibleName = Properties.Strings.Boot + " " + Properties.Strings.LaptopBacklight;
+            checkAwake.AccessibleName = Properties.Strings.Awake + " " + Properties.Strings.LaptopBacklight;
+            checkSleep.AccessibleName = Properties.Strings.Sleep + " " + Properties.Strings.LaptopBacklight;
+            checkShutdown.AccessibleName = Properties.Strings.Shutdown + " " + Properties.Strings.LaptopBacklight;
+
+            panelSettings.AccessibleName = Properties.Strings.ExtraSettings;
+            numericHibernateAfter.AccessibleName = Properties.Strings.HibernateAfter;
+
+            if (AppConfig.IsARCNM())
             {
-                customActions.Add("screenpad_down", Properties.Strings.ScreenPadDown);
-                customActions.Add("screenpad_up", Properties.Strings.ScreenPadUp);
+                labelM3.Text = "FN+F6";
+                labelM1.Visible = comboM1.Visible = textM1.Visible = false;
+                labelM2.Visible = comboM2.Visible = textM2.Visible = false;
+                labelM4.Visible = comboM4.Visible = textM4.Visible = false;
+                labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
             }
 
+            if (AppConfig.NoMKeys())
+            {
+                labelM1.Text = "FN+F2";
+                labelM2.Text = "FN+F3";
+                labelM3.Text = "FN+F4";
+                labelM4.Visible = comboM4.Visible = textM4.Visible = AppConfig.IsDUO();
+                labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
+            }
+
+            if (AppConfig.MediaKeys())
+            {
+                labelFNF4.Visible = comboFNF4.Visible = textFNF4.Visible = false;
+            }
+
+            if (!AppConfig.IsTUF())
+            {
+                labelFNE.Visible = comboFNE.Visible = textFNE.Visible = false;
+            }
+
+            if (AppConfig.IsNoFNV())
+            {
+                labelFNV.Visible = comboFNV.Visible = textFNV.Visible = false;
+            }
+
+            if (Program.acpi.DeviceGet(AsusACPI.GPUEco) < 0)
+            {
+                checkGpuApps.Visible = false;
+                checkUSBC.Visible = false;
+            }
+
+            checkNoOverdrive.Visible = Program.acpi.IsOverdriveSupported();
+
+            // 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 = "Cmd 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;
+
+                labelFNV.Visible = false;
+                comboFNV.Visible = false;
+                textFNV.Visible = false;
+
+                SetKeyCombo(comboM3, textM3, "cc");
+                SetKeyCombo(comboM4, textM4, "m4");
+                SetKeyCombo(comboFNF4, textFNF4, "paddle");
+
+                checkGpuApps.Visible = false;
+                checkUSBC.Visible = false;
+                checkAutoToggleClamshellMode.Visible = false;
+
+                int apuMem = Program.acpi.GetAPUMem();
+                if (apuMem >= 0)
+                {
+                    panelAPU.Visible = true;
+                    comboAPU.DropDownStyle = ComboBoxStyle.DropDownList;
+                    comboAPU.SelectedIndex = apuMem;
+                }
+
+                comboAPU.SelectedIndexChanged += ComboAPU_SelectedIndexChanged;
+
+            }
+            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(comboFNV, textFNV, "fnv");
+                SetKeyCombo(comboFNE, textFNE, "fne");
+            }
+
+            if (AppConfig.IsStrix())
+            {
+                labelM4.Text = "M5/ROG";
+            }
+
+
             InitTheme();
-
-            SetKeyCombo(comboM1, textM1, "m1");
-            SetKeyCombo(comboM2, textM2, "m2");
-            SetKeyCombo(comboM3, textM3, "m3");
-            SetKeyCombo(comboM4, textM4, "m4");
-            SetKeyCombo(comboFNF4, textFNF4, "fnf4");
-            SetKeyCombo(comboFNC, textFNC, "fnc");
-
             Shown += Keyboard_Shown;
 
             comboKeyboardSpeed.DropDownStyle = ComboBoxStyle.DropDownList;
-            comboKeyboardSpeed.DataSource = new BindingSource(AsusUSB.GetSpeeds(), null);
+            comboKeyboardSpeed.DataSource = new BindingSource(Aura.GetSpeeds(), null);
             comboKeyboardSpeed.DisplayMember = "Value";
             comboKeyboardSpeed.ValueMember = "Key";
-            comboKeyboardSpeed.SelectedValue = AsusUSB.Speed;
+            comboKeyboardSpeed.SelectedValue = Aura.Speed;
             comboKeyboardSpeed.SelectedValueChanged += ComboKeyboardSpeed_SelectedValueChanged;
 
             // Keyboard
             checkAwake.Checked = AppConfig.IsNotFalse("keyboard_awake");
+            checkBattery.Checked = AppConfig.IsOnBattery("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");
+            checkBatteryBar.Checked = AppConfig.IsOnBattery("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");
+            checkBatteryLid.Checked = AppConfig.IsOnBattery("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");
+            checkBatteryLogo.Checked = AppConfig.IsOnBattery("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;
+            checkBattery.CheckedChanged += CheckPower_CheckedChanged;
             checkBoot.CheckedChanged += CheckPower_CheckedChanged;
             checkSleep.CheckedChanged += CheckPower_CheckedChanged;
             checkShutdown.CheckedChanged += CheckPower_CheckedChanged;
 
             checkAwakeBar.CheckedChanged += CheckPower_CheckedChanged;
+            checkBatteryBar.CheckedChanged += CheckPower_CheckedChanged;
             checkBootBar.CheckedChanged += CheckPower_CheckedChanged;
             checkSleepBar.CheckedChanged += CheckPower_CheckedChanged;
             checkShutdownBar.CheckedChanged += CheckPower_CheckedChanged;
 
             checkAwakeLid.CheckedChanged += CheckPower_CheckedChanged;
+            checkBatteryLid.CheckedChanged += CheckPower_CheckedChanged;
             checkBootLid.CheckedChanged += CheckPower_CheckedChanged;
             checkSleepLid.CheckedChanged += CheckPower_CheckedChanged;
             checkShutdownLid.CheckedChanged += CheckPower_CheckedChanged;
 
             checkAwakeLogo.CheckedChanged += CheckPower_CheckedChanged;
+            checkBatteryLogo.CheckedChanged += CheckPower_CheckedChanged;
             checkBootLogo.CheckedChanged += CheckPower_CheckedChanged;
             checkSleepLogo.CheckedChanged += CheckPower_CheckedChanged;
             checkShutdownLogo.CheckedChanged += CheckPower_CheckedChanged;
 
-            if (!AppConfig.ContainsModel("Strix"))
+            if (!AppConfig.IsBacklightZones() || AppConfig.IsStrixLimitedRGB() || AppConfig.IsARCNM())
             {
-                labelBacklightBar.Visible = false;
-                checkAwakeBar.Visible = false;
-                checkBootBar.Visible = false;
-                checkSleepBar.Visible = false;
-                checkShutdownBar.Visible = false;
 
-                if (!AppConfig.ContainsModel("Z13"))
+                if (!AppConfig.IsStrixLimitedRGB())
                 {
-                    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;
+                    labelBacklightBar.Visible = false;
+                    checkAwakeBar.Visible = false;
+                    checkBatteryBar.Visible = false;
+                    checkBootBar.Visible = false;
+                    checkSleepBar.Visible = false;
+                    checkShutdownBar.Visible = false;
                 }
+
+                labelBacklightLid.Visible = false;
+                checkAwakeLid.Visible = false;
+                checkBatteryLid.Visible = false;
+                checkBootLid.Visible = false;
+                checkSleepLid.Visible = false;
+                checkShutdownLid.Visible = false;
+
+                labelBacklightLogo.Visible = false;
+                checkAwakeLogo.Visible = false;
+                checkBatteryLogo.Visible = false;
+                checkBootLogo.Visible = false;
+                checkSleepLogo.Visible = false;
+                checkShutdownLogo.Visible = false;
             }
 
+            if (!AppConfig.IsBacklightZones())
+            {
+                labelBacklightKeyboard.Visible = false;
+                checkBattery.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.Checked = AppConfig.IsNoOverdrive();
             checkNoOverdrive.CheckedChanged += CheckNoOverdrive_CheckedChanged;
 
             checkUSBC.Checked = AppConfig.Is("optimized_usbc");
             checkUSBC.CheckedChanged += CheckUSBC_CheckedChanged;
 
-            checkAutoApplyWindowsPowerMode.Checked = (AppConfig.Get("auto_apply_power_plan") != 0);
-            checkAutoApplyWindowsPowerMode.CheckedChanged += checkAutoApplyWindowsPowerMode_CheckedChanged;
-
             sliderBrightness.Value = InputDispatcher.GetBacklight();
             sliderBrightness.ValueChanged += SliderBrightness_ValueChanged;
 
@@ -242,17 +414,190 @@ namespace GHelper
             checkGpuApps.Checked = AppConfig.Is("kill_gpu_apps");
             checkGpuApps.CheckedChanged += CheckGpuApps_CheckedChanged;
 
-            checkFnLock.Checked = AppConfig.Is("fn_lock");
-            checkFnLock.CheckedChanged += CheckFnLock_CheckedChanged; ;
+            int bootSound = Program.acpi.DeviceGet(AsusACPI.BootSound);
+            if (bootSound < 0 || bootSound > UInt16.MaxValue) bootSound = AppConfig.Get("boot_sound", 0);
+
+            checkBootSound.Checked = (bootSound == 1);
+            checkBootSound.CheckedChanged += CheckBootSound_CheckedChanged;
+
+            var statusLed = Program.acpi.DeviceGet(AsusACPI.StatusLed);
+            checkStatusLed.Visible = statusLed >= 0;
+            checkStatusLed.Checked = (statusLed > 0);
+            checkStatusLed.CheckedChanged += CheckLEDStatus_CheckedChanged;
+
+
+            checkBWIcon.Checked = AppConfig.IsBWIcon();
+            checkBWIcon.CheckedChanged += CheckBWIcon_CheckedChanged;
 
             pictureHelp.Click += PictureHelp_Click;
-
             buttonServices.Click += ButtonServices_Click;
 
             pictureLog.Click += PictureLog_Click;
 
+            checkGPUFix.Visible = Program.acpi.IsNVidiaGPU();
+            checkGPUFix.Checked = AppConfig.IsGPUFix();
+            checkGPUFix.CheckedChanged += CheckGPUFix_CheckedChanged;
+
+            checkPerKeyRGB.Visible = AppConfig.IsPossible4ZoneRGB();
+            checkPerKeyRGB.Checked = AppConfig.Is("per_key_rgb");
+            checkPerKeyRGB.CheckedChanged += CheckPerKeyRGB_CheckedChanged;
+
+            toolTip.SetToolTip(checkAutoToggleClamshellMode, "Disable sleep on lid close when plugged in and external monitor is connected");
+
+            InitCores();
             InitVariBright();
             InitServices();
+            InitHibernate();
+
+            InitACPITesting();
+
+        }
+
+        private void CheckPerKeyRGB_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("per_key_rgb", (checkPerKeyRGB.Checked ? 1 : 0));
+        }
+
+        private void CheckLEDStatus_CheckedChanged(object? sender, EventArgs e)
+        {
+            InputDispatcher.SetStatusLED(checkStatusLed.Checked);
+        }
+
+        private void CheckBWIcon_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("bw_icon", (checkBWIcon.Checked ? 1 : 0));
+            Program.settingsForm.VisualiseIcon();
+        }
+
+        private void InitACPITesting()
+        {
+            if (!AppConfig.Is("debug")) return;
+
+            pictureScan.Visible = true;
+            panelACPI.Visible = true;
+
+            textACPICommand.Text = "120098";
+            textACPIParam.Text = "25";
+
+            buttonACPISend.Click += ButtonACPISend_Click;
+            pictureScan.Click += PictureScan_Click;
+        }
+
+        private void ButtonACPISend_Click(object? sender, EventArgs e)
+        {
+            try {
+                int deviceID = Convert.ToInt32(textACPICommand.Text, 16);
+                int status = Convert.ToInt32(textACPIParam.Text, textACPIParam.Text.Contains("x") ? 16 : 10);
+                int result = Program.acpi.DeviceSet((uint)deviceID, status, "TestACPI " + deviceID.ToString("X8") + " " + status.ToString("X4"));
+                labelACPITitle.Text = "ACPI DEVS Test : " + result.ToString();
+            } catch (Exception ex)
+            {
+                Logger.WriteLine(ex.Message);
+            }
+        }
+
+        private void InitCores()
+        {
+            (int eCores, int pCores) = Program.acpi.GetCores();
+            (int eCoresMax, int pCoresMax) = Program.acpi.GetCores(true);
+
+            if (eCores < 0 || pCores < 0 || eCoresMax < 0 || pCoresMax < 0)
+            {
+                panelCores.Visible = false;
+                return;
+            }
+
+            if (eCoresMax == 0) eCoresMax = 8;
+            if (pCoresMax == 0) pCoresMax = 6;
+
+            eCoresMax = Math.Max(4, eCoresMax);
+            pCoresMax = Math.Max(6, pCoresMax);
+
+            panelCores.Visible = true;
+
+            comboCoresE.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboCoresP.DropDownStyle = ComboBoxStyle.DropDownList;
+
+            for (int i = AsusACPI.PCoreMin; i <= pCoresMax; i++) comboCoresP.Items.Add(i.ToString() + " Pcores");
+            for (int i = AsusACPI.ECoreMin; i <= eCoresMax; i++) comboCoresE.Items.Add(i.ToString() + " Ecores");
+
+            comboCoresP.SelectedIndex = Math.Max(Math.Min(pCores - AsusACPI.PCoreMin, comboCoresP.Items.Count - 1), 0);
+            comboCoresE.SelectedIndex = Math.Max(Math.Min(eCores - AsusACPI.ECoreMin, comboCoresE.Items.Count - 1), 0);
+
+            buttonCores.Click += ButtonCores_Click;
+
+        }
+
+        private void ButtonCores_Click(object? sender, EventArgs e)
+        {
+            DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertAPUMemoryRestart, Properties.Strings.AlertAPUMemoryRestartTitle, MessageBoxButtons.YesNo);
+
+            if (dialogResult == DialogResult.Yes)
+            {
+                Program.acpi.SetCores(AsusACPI.ECoreMin + comboCoresE.SelectedIndex, AsusACPI.PCoreMin + comboCoresP.SelectedIndex);
+                Process.Start("shutdown", "/r /t 1");
+            }
+        }
+
+
+        private void PictureScan_Click(object? sender, EventArgs e)
+        {
+            string logFile = Program.acpi.ScanRange();
+            new Process
+            {
+                StartInfo = new ProcessStartInfo(logFile)
+                {
+                    UseShellExecute = true
+                }
+            }.Start();
+        }
+
+        private void ComboAPU_SelectedIndexChanged(object? sender, EventArgs e)
+        {
+            int mem = comboAPU.SelectedIndex;
+            Program.acpi.SetAPUMem(mem);
+
+            DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertAPUMemoryRestart, Properties.Strings.AlertAPUMemoryRestartTitle, MessageBoxButtons.YesNo);
+            if (dialogResult == DialogResult.Yes)
+            {
+                Process.Start("shutdown", "/r /t 1");
+            }
+
+        }
+
+        private void CheckBootSound_CheckedChanged(object? sender, EventArgs e)
+        {
+            int bootSound = checkBootSound.Checked ? 1 : 0;
+            Program.acpi.DeviceSet(AsusACPI.BootSound, bootSound, "BootSound");
+            AppConfig.Set("boot_sound", 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)
@@ -268,9 +613,14 @@ namespace GHelper
 
         private void SliderBrightness_ValueChanged(object? sender, EventArgs e)
         {
-            AppConfig.Set("keyboard_brightness", sliderBrightness.Value);
-            AppConfig.Set("keyboard_brightness_ac", sliderBrightness.Value);
-            AsusUSB.ApplyBrightness(sliderBrightness.Value, "Slider");
+            bool onBattery = SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online;
+
+            if (onBattery)
+                AppConfig.Set("keyboard_brightness_ac", sliderBrightness.Value);
+            else
+                AppConfig.Set("keyboard_brightness", sliderBrightness.Value);
+
+            Aura.ApplyBrightness(sliderBrightness.Value, "Slider");
         }
 
         private void InitServices()
@@ -298,7 +648,7 @@ namespace GHelper
         {
             buttonServices.Enabled = false;
 
-            if (OptimizationService.IsRunning())
+            if (OptimizationService.GetRunningCount() > 0)
             {
                 labelServices.Text = Properties.Strings.StoppingServices + " ...";
                 Task.Run(() =>
@@ -337,6 +687,7 @@ namespace GHelper
         {
             try
             {
+
                 using (var amdControl = new AmdGpuControl())
                 {
                     int variBrightSupported = 0, VariBrightEnabled;
@@ -364,20 +715,14 @@ namespace GHelper
         {
             using (var amdControl = new AmdGpuControl())
             {
-                amdControl.SetVariBright(checkVariBright.Checked ? 1 : 0);
+                if (NvidiaSmi.GetDisplayActiveStatus()) return; // Skip if Nvidia GPU is active
+                var status = checkVariBright.Checked ? 1 : 0;
+                var result = amdControl.SetVariBright(status);
+                Logger.WriteLine($"VariBright {status}: {result}");
                 ProcessHelper.KillByName("RadeonSoftware");
             }
         }
 
-        private void CheckFnLock_CheckedChanged(object? sender, EventArgs e)
-        {
-            int fnLock = checkFnLock.Checked ? 1 : 0;
-            AppConfig.Set("fn_lock", fnLock);
-            Program.acpi.DeviceSet(AsusACPI.FnLock, (fnLock == 1) ? 0 : 1, "FnLock");
-
-            Program.inputDispatcher.RegisterKeys();
-        }
-
         private void CheckGpuApps_CheckedChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("kill_gpu_apps", (checkGpuApps.Checked ? 1 : 0));
@@ -393,7 +738,7 @@ namespace GHelper
         private void CheckXMG_CheckedChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("xmg_light", (checkXMG.Checked ? 1 : 0));
-            AsusUSB.ApplyXGMLight(checkXMG.Checked);
+            XGM.Light(checkXMG.Checked);
         }
 
         private void CheckUSBC_CheckedChanged(object? sender, EventArgs e)
@@ -403,7 +748,7 @@ namespace GHelper
 
         private void PictureHelp_Click(object? sender, EventArgs e)
         {
-            Process.Start(new ProcessStartInfo("https://github.com/seerge/g-helper#custom-hotkey-actions") { UseShellExecute = true });
+            Process.Start(new ProcessStartInfo("https://github.com/seerge/g-helper/wiki/Power-user-settings#custom-hotkey-actions") { UseShellExecute = true });
         }
 
         private void CheckNoOverdrive_CheckedChanged(object? sender, EventArgs e)
@@ -441,14 +786,22 @@ namespace GHelper
             AppConfig.Set("keyboard_sleep_logo", (checkSleepLogo.Checked ? 1 : 0));
             AppConfig.Set("keyboard_shutdown_logo", (checkShutdownLogo.Checked ? 1 : 0));
 
-            AsusUSB.ApplyAuraPower();
+            if (AppConfig.IsBacklightZones())
+            {
+                AppConfig.Set("keyboard_awake_bat", (checkBattery.Checked ? 1 : 0));
+                AppConfig.Set("keyboard_awake_bar_bat", (checkBatteryBar.Checked ? 1 : 0));
+                AppConfig.Set("keyboard_awake_lid_bat", (checkBatteryLid.Checked ? 1 : 0));
+                AppConfig.Set("keyboard_awake_logo_bat", (checkBatteryLogo.Checked ? 1 : 0));
+            } 
+
+            Aura.ApplyPower();
 
         }
 
         private void ComboKeyboardSpeed_SelectedValueChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("aura_speed", (int)comboKeyboardSpeed.SelectedValue);
-            AsusUSB.ApplyAura();
+            Aura.ApplyAura();
         }
 
 
@@ -456,7 +809,17 @@ namespace GHelper
         {
             if (Height > Program.settingsForm.Height)
             {
-                Top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
+                var top = Program.settingsForm.Top + Program.settingsForm.Height - Height;
+
+                if (top < 0)
+                {
+                    MaximumSize = new Size(Width, Program.settingsForm.Height);
+                    Top = Program.settingsForm.Top;
+                } else
+                {
+                    Top = top;
+                }
+
             }
             else
             {
@@ -466,16 +829,25 @@ namespace GHelper
             Left = Program.settingsForm.Left - Width - 5;
         }
 
-        private void checkAutoApplyWindowsPowerMode_CheckedChanged(object? sender, EventArgs e)
-        {
-            AppConfig.Set("auto_apply_power_plan", checkAutoApplyWindowsPowerMode.Checked ? 1 : 0);
-        }
 
-        private void checkAutoToggleClamshellMode_CheckedChanged(object sender, EventArgs e)
+        private void checkAutoToggleClamshellMode_CheckedChanged(object? sender, EventArgs e)
         {
             AppConfig.Set("toggle_clamshell_mode", checkAutoToggleClamshellMode.Checked ? 1 : 0);
-            ClamshellModeControl ctrl = new ClamshellModeControl();
-            ctrl.ToggleLidAction();
+
+            if (checkAutoToggleClamshellMode.Checked)
+            {
+                clamshellControl.ToggleLidAction();
+            }
+            else
+            {
+                ClamshellModeControl.DisableClamshellMode();
+            }
+
+        }
+
+        private void panelAPU_Paint(object sender, PaintEventArgs e)
+        {
+
         }
     }
 }

app/Extra.resx

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
   <!--
-    Microsoft ResX Schema 
+    Microsoft ResX Schema
 
     Version 2.0
 
@@ -18,7 +18,7 @@
     <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="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>
@@ -48,7 +48,7 @@
     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
@@ -117,4 +117,7 @@
   <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>

app/Fan/FanSensorControl.cs

@@ -0,0 +1,190 @@
+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 = 104;
+
+        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("FX607J")) return new int[3] { 74, 72, 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 };
+
+            if (AppConfig.ContainsModel("GA403")) return new int[3] { 68, 68, 80 };
+            if (AppConfig.ContainsModel("GU605")) return new int[3] { 62, 62, 92 };
+
+            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();
+        }
+    }
+}

app/Fans.cs

@@ -1,8 +1,11 @@
-using GHelper.Gpu.NVidia;
+using GHelper.Fan;
+using GHelper.Gpu.NVidia;
 using GHelper.Mode;
 using GHelper.UI;
+using GHelper.USB;
 using Ryzen;
 using System.Diagnostics;
+using System.Management;
 using System.Windows.Forms.DataVisualization.Charting;
 
 namespace GHelper
@@ -18,20 +21,26 @@ namespace GHelper
         Series seriesMid;
         Series seriesXGM;
 
-        static int MinRPM, MaxRPM;
-
         static bool gpuVisible = true;
+        static bool fanRpm = true;
 
         const int fansMax = 100;
 
         NvidiaGpuControl? nvControl = null;
         ModeControl modeControl = Program.modeControl;
 
+        FanSensorControl fanSensorControl;
+
+        static int gpuPowerBase = 0;
+        static bool isGPUPower => gpuPowerBase > 0;
+
         public Fans()
         {
 
             InitializeComponent();
 
+            fanSensorControl = new FanSensorControl(this);
+
             //float dpi = ControlHelper.GetDpiScale(this).Value;
             //comboModes.Size = new Size(comboModes.Width, (int)dpi * 18);
             comboModes.ClientSize = new Size(comboModes.Width, comboModes.Height - 4);
@@ -40,7 +49,7 @@ namespace GHelper
             labelPowerLimits.Text = Properties.Strings.PowerLimits;
             checkApplyPower.Text = Properties.Strings.ApplyPowerLimits;
 
-            labelFans.Text = Properties.Strings.FanCurves;
+            labelFans.Text = "BIOS " + Properties.Strings.FanCurves;
             labelBoost.Text = Properties.Strings.CPUBoost;
             buttonReset.Text = Properties.Strings.FactoryDefaults;
             checkApplyFans.Text = Properties.Strings.ApplyFanCurve;
@@ -51,20 +60,19 @@ namespace GHelper
             labelGPUMemoryTitle.Text = Properties.Strings.GPUMemoryClockOffset;
             labelGPUBoostTitle.Text = Properties.Strings.GPUBoost;
             labelGPUTempTitle.Text = Properties.Strings.GPUTempTarget;
+            labelGPUPowerTitle.Text = Properties.Strings.GPUPower;
 
             labelRisky.Text = Properties.Strings.UndervoltingRisky;
             buttonApplyAdvanced.Text = Properties.Strings.Apply;
             checkApplyUV.Text = Properties.Strings.AutoApply;
 
+            buttonCalibrate.Text = Properties.Strings.Calibrate;
+
             InitTheme(true);
 
-            MinRPM = 18;
-            MaxRPM = HardwareControl.GetFanMax();
             labelTip.Visible = false;
             labelTip.BackColor = Color.Transparent;
 
-            FormClosing += Fans_FormClosing;
-
             seriesCPU = chartCPU.Series.Add("CPU");
             seriesGPU = chartGPU.Series.Add("GPU");
             seriesMid = chartMid.Series.Add("Mid");
@@ -75,40 +83,62 @@ namespace GHelper
             seriesMid.Color = colorEco;
             seriesXGM.Color = Color.Orange;
 
-            chartCPU.MouseMove += ChartCPU_MouseMove;
+            chartCPU.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.CPU);
             chartCPU.MouseUp += ChartCPU_MouseUp;
+            chartCPU.MouseLeave += ChartCPU_MouseLeave;
 
-            chartGPU.MouseMove += ChartCPU_MouseMove;
+            chartGPU.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.GPU);
             chartGPU.MouseUp += ChartCPU_MouseUp;
+            chartGPU.MouseLeave += ChartCPU_MouseLeave;
 
-            chartMid.MouseMove += ChartCPU_MouseMove;
+            chartMid.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.Mid);
             chartMid.MouseUp += ChartCPU_MouseUp;
+            chartMid.MouseLeave += ChartCPU_MouseLeave;
 
-            chartXGM.MouseMove += ChartCPU_MouseMove;
+            chartXGM.MouseMove += (sender, e) => ChartCPU_MouseMove(sender, e, AsusFan.XGM);
             chartXGM.MouseUp += ChartCPU_MouseUp;
+            chartXGM.MouseLeave += ChartCPU_MouseLeave;
+
+            chartCPU.MouseClick += ChartCPU_MouseClick;
+            chartGPU.MouseClick += ChartCPU_MouseClick;
+            chartMid.MouseClick += ChartCPU_MouseClick;
+            chartXGM.MouseClick += ChartCPU_MouseClick;
 
             buttonReset.Click += ButtonReset_Click;
 
-            trackA0.Maximum = AsusACPI.MaxTotal;
-            trackA0.Minimum = AsusACPI.MinTotal;
+            trackTotal.Maximum = AsusACPI.MaxTotal;
+            trackTotal.Minimum = AsusACPI.MinTotal;
 
-            trackB0.Maximum = AsusACPI.MaxCPU;
-            trackB0.Minimum = AsusACPI.MinCPU;
+            trackSlow.Maximum = AsusACPI.MaxTotal;
+            trackSlow.Minimum = AsusACPI.MinTotal;
 
-            trackC1.Maximum = AsusACPI.MaxTotal;
-            trackC1.Minimum = AsusACPI.MinTotal;
+            trackCPU.Maximum = AsusACPI.MaxCPU;
+            trackCPU.Minimum = AsusACPI.MinCPU;
 
-            trackC1.Scroll += TrackPower_Scroll;
-            trackB0.Scroll += TrackPower_Scroll;
-            trackA0.Scroll += TrackPower_Scroll;
+            trackFast.Maximum = AsusACPI.MaxTotal;
+            trackFast.Minimum = AsusACPI.MinTotal;
 
-            trackC1.MouseUp += TrackPower_MouseUp;
-            trackB0.MouseUp += TrackPower_MouseUp;
-            trackA0.MouseUp += TrackPower_MouseUp;
+            trackTotal.Scroll += TrackTotal_Scroll;
+            trackSlow.Scroll += TrackSlow_Scroll;
+            trackFast.Scroll += TrackFast_Scroll;
+            trackCPU.Scroll += TrackCPU_Scroll;
+
+            trackFast.MouseUp += TrackPower_MouseUp;
+            trackCPU.MouseUp += TrackPower_MouseUp;
+            trackTotal.MouseUp += TrackPower_MouseUp;
+            trackSlow.MouseUp += TrackPower_MouseUp;
+
+            trackFast.KeyUp += TrackPower_KeyUp;
+            trackCPU.KeyUp += TrackPower_KeyUp;
+            trackTotal.KeyUp += TrackPower_KeyUp;
+            trackSlow.KeyUp += TrackPower_KeyUp;
 
             checkApplyFans.Click += CheckApplyFans_Click;
             checkApplyPower.Click += CheckApplyPower_Click;
 
+            trackGPUClockLimit.Minimum = NvidiaGpuControl.MinClockLimit;
+            trackGPUClockLimit.Maximum = NvidiaGpuControl.MaxClockLimit;
+
             trackGPUCore.Minimum = NvidiaGpuControl.MinCoreOffset;
             trackGPUCore.Maximum = NvidiaGpuControl.MaxCoreOffset;
 
@@ -121,16 +151,25 @@ namespace GHelper
             trackGPUTemp.Minimum = AsusACPI.MinGPUTemp;
             trackGPUTemp.Maximum = AsusACPI.MaxGPUTemp;
 
+            trackGPUPower.Minimum = AsusACPI.MinGPUPower;
+            trackGPUPower.Maximum = AsusACPI.MaxGPUPower;
+
+            trackGPUClockLimit.Scroll += trackGPUClockLimit_Scroll;
             trackGPUCore.Scroll += trackGPU_Scroll;
             trackGPUMemory.Scroll += trackGPU_Scroll;
 
             trackGPUBoost.Scroll += trackGPUPower_Scroll;
             trackGPUTemp.Scroll += trackGPUPower_Scroll;
+            trackGPUPower.Scroll += trackGPUPower_Scroll;
+
+            trackGPUCore.MouseUp += TrackGPUClocks_MouseUp;
+            trackGPUMemory.MouseUp += TrackGPUClocks_MouseUp;
+            trackGPUClockLimit.MouseUp += TrackGPUClocks_MouseUp;
 
-            trackGPUCore.MouseUp += TrackGPU_MouseUp;
-            trackGPUMemory.MouseUp += TrackGPU_MouseUp;
             trackGPUBoost.MouseUp += TrackGPU_MouseUp;
             trackGPUTemp.MouseUp += TrackGPU_MouseUp;
+            trackGPUPower.MouseUp += TrackGPU_MouseUp;
+
 
             //labelInfo.MaximumSize = new Size(280, 0);
             labelFansResult.Visible = false;
@@ -145,11 +184,18 @@ namespace GHelper
             trackTemp.Minimum = RyzenControl.MinTemp;
             trackTemp.Maximum = RyzenControl.MaxTemp;
 
+            comboPowerMode.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboPowerMode.DataSource = new BindingSource(PowerNative.powerModes, null);
+            comboPowerMode.DisplayMember = "Value";
+            comboPowerMode.ValueMember = "Key";
 
             FillModes();
             InitAll();
+            InitCPU();
 
             comboBoost.SelectedValueChanged += ComboBoost_Changed;
+            comboPowerMode.SelectedValueChanged += ComboPowerMode_Changed;
+
 
             comboModes.SelectionChangeCommitted += ComboModes_SelectedValueChanged;
             comboModes.TextChanged += ComboModes_TextChanged;
@@ -178,12 +224,59 @@ namespace GHelper
 
             checkApplyUV.Click += CheckApplyUV_Click;
 
+            buttonCalibrate.Click += ButtonCalibrate_Click;
+
+            buttonDownload.Click += ButtonDownload_Click;
+
             ToggleNavigation(0);
 
+            if (Program.acpi.DeviceGet(AsusACPI.DevsCPUFanCurve) < 0) buttonCalibrate.Visible = false;
+
             FormClosed += Fans_FormClosed;
 
         }
 
+
+        private void ButtonDownload_Click(object? sender, EventArgs e)
+        {
+            RyzenControl.DownloadRing();
+
+            panelAdvancedAlways.Visible = true;
+            panelAdvancedApply.Visible = true;
+            labelRisky.Visible = true;
+            panelUViGPU.Visible = true;
+            panelUV.Visible = true;
+            panelTitleAdvanced.Visible = true;
+            panelTemperature.Visible = true;
+            panelTitleTemp.Visible = true;
+
+            VisualiseAdvanced();
+        }
+
+        private void ButtonCalibrate_Click(object? sender, EventArgs e)
+        {
+            buttonCalibrate.Enabled = false;
+            fanSensorControl.StartCalibration();
+        }
+
+        private void ChartCPU_MouseClick(object? sender, MouseEventArgs e)
+        {
+            if (sender is null) return;
+            Chart chart = (Chart)sender;
+
+            HitTestResult result = chart.HitTest(e.X, e.Y);
+
+            if ((result.ChartElementType == ChartElementType.AxisLabels || result.ChartElementType == ChartElementType.Axis) && result.Axis == chart.ChartAreas[0].AxisY)
+            {
+                fanRpm = !fanRpm;
+                SetAxis(chartCPU, AsusFan.CPU);
+                SetAxis(chartGPU, AsusFan.GPU);
+                if (chartMid.Visible) SetAxis(chartMid, AsusFan.Mid);
+                if (chartXGM.Visible) SetAxis(chartXGM, AsusFan.XGM);
+            }
+
+        }
+
         private void Fans_FormClosed(object? sender, FormClosedEventArgs e)
         {
             //Because windows charts seem to eat a lot of memory :(
@@ -201,11 +294,28 @@ namespace GHelper
             InitMode();
             InitFans();
             InitPower();
-            InitBoost();
+            InitPowerPlan();
             InitUV();
             InitGPU();
         }
 
+        public void InitCPU()
+        {
+            Task.Run(async () =>
+            {
+                string CPUName;
+                using (ManagementObjectSearcher myProcessorObject = new ManagementObjectSearcher("select * from Win32_Processor"))
+                    foreach (ManagementObject obj in myProcessorObject.Get())
+                    {
+                        CPUName = obj["Name"].ToString();
+                        Invoke(delegate
+                        {
+                            Text = Properties.Strings.FansAndPower + " - " + CPUName;
+                        });
+                    }
+            });
+        }
+
         public void ToggleNavigation(int index = 0)
         {
 
@@ -285,6 +395,24 @@ namespace GHelper
 
         private void VisualiseAdvanced()
         {
+
+            if (!RyzenControl.IsRingExsists())
+            {
+                panelTitleAdvanced.Visible = false;
+                labelRisky.Visible = false;
+                panelUV.Visible = false;
+                panelUViGPU.Visible = false;
+                panelTitleTemp.Visible = false;
+                panelTemperature.Visible = false;
+                panelAdvancedAlways.Visible = false;
+                panelAdvancedApply.Visible = false;
+                panelDownload.Visible = true;
+
+            } else
+            {
+                panelDownload.Visible = false;
+            }
+
             if (!RyzenControl.IsSupportedUV())
             {
                 panelTitleAdvanced.Visible = false;
@@ -293,13 +421,14 @@ namespace GHelper
                 panelUViGPU.Visible = false;
             }
 
-            if (!RyzenControl.IsSupportedUV())
+            if (!RyzenControl.IsSupportedUViGPU())
             {
                 panelUViGPU.Visible = false;
             }
 
             labelUV.Text = trackUV.Value.ToString();
             labelUViGPU.Text = trackUViGPU.Value.ToString();
+
             labelTemp.Text = (trackTemp.Value < RyzenControl.MaxTemp) ? trackTemp.Value.ToString() + "°C" : "Default";
         }
 
@@ -399,9 +528,46 @@ namespace GHelper
         private void TrackGPU_MouseUp(object? sender, MouseEventArgs e)
         {
             modeControl.SetGPUPower();
+        }
+
+        private void TrackGPUClocks_MouseUp(object? sender, MouseEventArgs e)
+        {
             modeControl.SetGPUClocks(true);
         }
 
+        private void InitGPUPower()
+        {
+            gpuPowerBase = Program.acpi.DeviceGet(AsusACPI.GPU_BASE);
+            if (gpuPowerBase >= 0) Logger.WriteLine($"ReadGPUPowerBase: {gpuPowerBase}");
+
+            panelGPUPower.Visible = isGPUPower;
+            if (!isGPUPower) return;
+
+            int maxGPUPower = NvidiaSmi.GetMaxGPUPower();
+            if (maxGPUPower > 0)
+            {
+                AsusACPI.MaxGPUPower = maxGPUPower - gpuPowerBase - AsusACPI.MaxGPUBoost;
+                trackGPUPower.Minimum = AsusACPI.MinGPUPower;
+                trackGPUPower.Maximum = AsusACPI.MaxGPUPower;
+            }
+
+            Task.Run(async () =>
+            {
+                await Task.Delay(TimeSpan.FromMilliseconds(200));
+                int gpuPowerVar = Program.acpi.DeviceGet(AsusACPI.GPU_POWER);
+                Logger.WriteLine($"ReadGPUPower ({Modes.GetCurrentBase()}): {gpuPowerVar}");
+
+                int gpu_power = AppConfig.GetMode("gpu_power");
+                if (gpu_power < 0) gpu_power = (gpuPowerVar >= 0) ? gpuPowerVar : AsusACPI.MaxGPUPower;
+
+                Invoke(delegate
+                {
+                    trackGPUPower.Value = Math.Max(Math.Min(gpu_power, AsusACPI.MaxGPUPower), AsusACPI.MinGPUPower);
+                    VisualiseGPUSettings();
+                });
+            });
+        }
+
         public void InitGPU()
         {
 
@@ -429,34 +595,42 @@ namespace GHelper
 
                 int gpu_boost = AppConfig.GetMode("gpu_boost");
                 int gpu_temp = AppConfig.GetMode("gpu_temp");
+
                 int core = AppConfig.GetMode("gpu_core");
                 int memory = AppConfig.GetMode("gpu_memory");
+                int clock_limit = AppConfig.GetMode("gpu_clock_limit");
 
                 if (gpu_boost < 0) gpu_boost = AsusACPI.MaxGPUBoost;
                 if (gpu_temp < 0) gpu_temp = AsusACPI.MaxGPUTemp;
 
                 if (core == -1) core = 0;
                 if (memory == -1) memory = 0;
+                if (clock_limit == -1) clock_limit = NvidiaGpuControl.MaxClockLimit;
 
-                //if (readClocks)
-                //{
-                int status = nvControl.GetClocks(out int current_core, out int current_memory);
-                if (status != -1)
+                if (nvControl is not null)
                 {
-                    core = current_core;
-                    memory = current_memory;
+                    if (nvControl.GetClocks(out int current_core, out int current_memory))
+                    {
+                        core = current_core;
+                        memory = current_memory;
+                    }
+
+                    int _clockLimit = nvControl.GetMaxGPUCLock();
+
+                    if (_clockLimit == 0) clock_limit = NvidiaGpuControl.MaxClockLimit;
+                    else if (_clockLimit > 0) clock_limit = _clockLimit;
+
+                    try
+                    {
+                        labelGPU.Text = nvControl.FullName;
+                    }
+                    catch
+                    {
+
+                    }
                 }
 
-                try
-                {
-                    labelGPU.Text = nvControl.FullName;
-                }
-                catch
-                {
-
-                }
-
-                //}
+                trackGPUClockLimit.Value = Math.Max(Math.Min(clock_limit, NvidiaGpuControl.MaxClockLimit), NvidiaGpuControl.MinClockLimit);
 
                 trackGPUCore.Value = Math.Max(Math.Min(core, NvidiaGpuControl.MaxCoreOffset), NvidiaGpuControl.MinCoreOffset);
                 trackGPUMemory.Value = Math.Max(Math.Min(memory, NvidiaGpuControl.MaxMemoryOffset), NvidiaGpuControl.MinMemoryOffset);
@@ -464,11 +638,14 @@ namespace GHelper
                 trackGPUBoost.Value = Math.Max(Math.Min(gpu_boost, AsusACPI.MaxGPUBoost), AsusACPI.MinGPUBoost);
                 trackGPUTemp.Value = Math.Max(Math.Min(gpu_temp, AsusACPI.MaxGPUTemp), AsusACPI.MinGPUTemp);
 
+
                 panelGPUBoost.Visible = (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC0) >= 0);
                 panelGPUTemp.Visible = (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC2) >= 0);
 
                 VisualiseGPUSettings();
 
+                InitGPUPower();
+
             }
             catch (Exception ex)
             {
@@ -482,8 +659,27 @@ namespace GHelper
         {
             labelGPUCore.Text = $"{trackGPUCore.Value} MHz";
             labelGPUMemory.Text = $"{trackGPUMemory.Value} MHz";
+
             labelGPUBoost.Text = $"{trackGPUBoost.Value}W";
             labelGPUTemp.Text = $"{trackGPUTemp.Value}°C";
+
+            if (trackGPUClockLimit.Value >= NvidiaGpuControl.MaxClockLimit)
+                labelGPUClockLimit.Text = "Default";
+            else
+                labelGPUClockLimit.Text = $"{trackGPUClockLimit.Value} MHz";
+
+            labelGPUPower.Text = (gpuPowerBase + trackGPUPower.Value) + "W";
+
+        }
+
+        private void trackGPUClockLimit_Scroll(object? sender, EventArgs e)
+        {
+
+            int maxClock = (int)Math.Round((float)trackGPUClockLimit.Value / 5) * 5;
+
+            trackGPUClockLimit.Value = maxClock;
+            AppConfig.SetMode("gpu_clock_limit", maxClock);
+            VisualiseGPUSettings();
         }
 
         private void trackGPU_Scroll(object? sender, EventArgs e)
@@ -495,6 +691,7 @@ namespace GHelper
             AppConfig.SetMode("gpu_core", trackGPUCore.Value);
             AppConfig.SetMode("gpu_memory", trackGPUMemory.Value);
 
+
             VisualiseGPUSettings();
 
         }
@@ -504,34 +701,57 @@ namespace GHelper
             AppConfig.SetMode("gpu_boost", trackGPUBoost.Value);
             AppConfig.SetMode("gpu_temp", trackGPUTemp.Value);
 
+            if (isGPUPower) AppConfig.SetMode("gpu_power", trackGPUPower.Value);
+
             VisualiseGPUSettings();
         }
 
-        static string ChartPercToRPM(int percentage, string unit = "")
+        static string ChartYLabel(int percentage, AsusFan device, string unit = "")
         {
             if (percentage == 0) return "OFF";
 
-            return (200 * Math.Round((float)(MinRPM * 100 + (MaxRPM - MinRPM) * percentage) / 200)).ToString() + unit;
+            int Min = FanSensorControl.DEFAULT_FAN_MIN;
+            int Max = FanSensorControl.GetFanMax(device);
+
+            if (fanRpm)
+                return (200 * Math.Floor((float)(Min * 100 + (Max - Min) * percentage) / 200)).ToString() + unit;
+            else
+                return percentage + "%";
+        }
+
+        void SetAxis(Chart chart, AsusFan device)
+        {
+
+            chart.ChartAreas[0].AxisY.CustomLabels.Clear();
+
+            for (int i = 0; i <= fansMax; i += 10)
+            {
+                chart.ChartAreas[0].AxisY.CustomLabels.Add(i - 2, i + 2, ChartYLabel(i, device));
+            }
+
+            //chart.ChartAreas[0].AxisY.CustomLabels.Add(fansMax -2, fansMax + 2, Properties.Strings.RPM);
+            chart.ChartAreas[0].AxisY.Interval = 10;
         }
 
         void SetChart(Chart chart, AsusFan device)
         {
 
             string title = "";
+            string scale = ", RPM/°C";
 
             switch (device)
             {
                 case AsusFan.CPU:
-                    title = Properties.Strings.FanProfileCPU;
+                    title = Properties.Strings.FanProfileCPU + scale;
                     break;
                 case AsusFan.GPU:
-                    title = Properties.Strings.FanProfileGPU;
+                    title = Properties.Strings.FanProfileGPU + scale;
                     break;
                 case AsusFan.Mid:
-                    title = Properties.Strings.FanProfileMid;
+                    title = Properties.Strings.FanProfileMid + scale;
                     break;
                 case AsusFan.XGM:
-                    title = "XG Mobile";
+                    title = "XG Mobile" + scale;
                     break;
             }
 
@@ -551,12 +771,7 @@ namespace GHelper
             chart.ChartAreas[0].AxisX.LineColor = chartGrid;
             chart.ChartAreas[0].AxisY.LineColor = chartGrid;
 
-            for (int i = 0; i <= fansMax - 10; i += 10)
-                chart.ChartAreas[0].AxisY.CustomLabels.Add(i - 2, i + 2, ChartPercToRPM(i));
-
-            chart.ChartAreas[0].AxisY.CustomLabels.Add(fansMax - 2, fansMax + 2, Properties.Strings.RPM);
-
-            chart.ChartAreas[0].AxisY.Interval = 10;
+            SetAxis(chart, device);
 
             if (chart.Legends.Count > 0)
                 chart.Legends[0].Enabled = false;
@@ -587,15 +802,48 @@ namespace GHelper
 
         private void TrackPower_MouseUp(object? sender, MouseEventArgs e)
         {
-            modeControl.AutoPower();
+            Task.Run(() =>
+            {
+                modeControl.AutoPower(true);
+            });
         }
 
 
-        public void InitBoost()
+        private void TrackPower_KeyUp(object? sender, KeyEventArgs e)
+        {
+            Task.Run(() =>
+            {
+                modeControl.AutoPower(true);
+            });
+        }
+
+        public void InitPowerPlan()
         {
             int boost = PowerNative.GetCPUBoost();
             if (boost >= 0)
                 comboBoost.SelectedIndex = Math.Min(boost, comboBoost.Items.Count - 1);
+
+            string powerMode = PowerNative.GetPowerMode();
+            bool batterySaver = PowerNative.GetBatterySaverStatus();
+
+            comboPowerMode.Enabled = !batterySaver;
+
+            if (batterySaver) 
+                comboPowerMode.SelectedIndex = 0;
+            else
+                comboPowerMode.SelectedValue = powerMode;
+
+        }
+
+        private void ComboPowerMode_Changed(object? sender, EventArgs e)
+        {
+            string powerMode = (string)comboPowerMode.SelectedValue;
+            PowerNative.SetPowerMode(powerMode);
+
+            if (PowerNative.GetDefaultPowerMode(Modes.GetCurrentBase()) != powerMode)
+                AppConfig.SetMode("powermode", powerMode);
+            else
+                AppConfig.RemoveMode("powermode");
         }
 
         private void ComboBoost_Changed(object? sender, EventArgs e)
@@ -627,111 +875,143 @@ namespace GHelper
 
         }
 
+        public void InitAxis()
+        {
+            if (this == null || this.Text == "") return;
+
+            Invoke(delegate
+            {
+                buttonCalibrate.Enabled = true;
+                SetAxis(chartCPU, AsusFan.CPU);
+                SetAxis(chartGPU, AsusFan.GPU);
+                if (chartMid.Visible) SetAxis(chartMid, AsusFan.Mid);
+            });
+        }
 
         public void LabelFansResult(string text)
         {
-            labelFansResult.Text = text;
-            labelFansResult.Visible = (text.Length > 0);
-        }
+            if (text.Length > 0) Logger.WriteLine(text);
 
-        private void Fans_FormClosing(object? sender, FormClosingEventArgs e)
-        {
+            if (this == null || this.Text == "") return;
 
-            /*
-            if (e.CloseReason == CloseReason.UserClosing)
+            Invoke(delegate
             {
-                e.Cancel = true;
-                Hide();
-            }*/
+                labelFansResult.Text = text;
+                labelFansResult.Visible = (text.Length > 0);
+            });
         }
 
 
-        public void InitPower(bool changed = false)
+        public void InitPower()
         {
 
-            bool modeA0 = (Program.acpi.DeviceGet(AsusACPI.PPT_TotalA0) >= 0 || RyzenControl.IsAMD());
+            bool modeA = Program.acpi.DeviceGet(AsusACPI.PPT_APUA0) >= 0 || RyzenControl.IsAMD();
             bool modeB0 = Program.acpi.IsAllAmdPPT();
             bool modeC1 = Program.acpi.DeviceGet(AsusACPI.PPT_APUC1) >= 0;
 
-            panelA0.Visible = modeA0;
-            panelB0.Visible = modeB0;
+            panelTotal.Visible = modeA;
+            panelCPU.Visible = modeB0;
 
-            panelApplyPower.Visible = panelTitleCPU.Visible = modeA0 || modeB0 || modeC1;
+            panelApplyPower.Visible = panelTitleCPU.Visible = modeA || modeB0 || modeC1;
 
 
             // All AMD version has B0 but doesn't have C0 (Nvidia GPU) settings
             if (modeB0)
             {
-                labelLeftA0.Text = "Platform (CPU + GPU)";
-                labelLeftB0.Text = "CPU";
-                panelC1.Visible = false;
+                labelLeftTotal.Text = "Platform (CPU + GPU)";
+                labelLeftCPU.Text = "CPU";
+                panelFast.Visible = false;
+                panelSlow.Visible = false;
             }
             else
             {
+                panelSlow.Visible = modeA;
+
                 if (RyzenControl.IsAMD())
-                    labelLeftA0.Text = "CPU Slow (SPL + sPPT)";
+                {
+                    labelLeftTotal.Text = "SPL (CPU sustained)";
+                    labelLeftSlow.Text = "sPPT (CPU 2 min boost)";
+                    labelLeftFast.Text = "fPPT (CPU 2 sec boost)";
+                    panelFast.Visible = modeC1;
+                    
+                }
                 else
-                    labelLeftA0.Text = "CPU (PL1 + PL2)";
+                {
+                    labelLeftTotal.Text = "PL1 (CPU sustained)";
+                    labelLeftSlow.Text = "PL2 (CPU 2 min boost)";
+                    panelFast.Visible = false;
+                }
 
-                labelLeftC1.Text = "CPU Fast (fPPT)";
-                panelC1.Visible = modeC1;
             }
 
-            int limit_total;
-            int limit_cpu;
-            int limit_fast;
+            checkApplyPower.Checked = AppConfig.IsMode("auto_apply_power");
 
-            bool apply = AppConfig.IsMode("auto_apply_power");
+            int limit_total = AppConfig.GetMode("limit_total", AsusACPI.DefaultTotal);
+            int limit_slow = AppConfig.GetMode("limit_slow", limit_total);
+            int limit_fast = AppConfig.GetMode("limit_fast", limit_total);
+            int limit_cpu = AppConfig.GetMode("limit_cpu", AsusACPI.DefaultCPU);
 
-            if (changed)
-            {
-                limit_total = trackA0.Value;
-                limit_cpu = trackB0.Value;
-                limit_fast = trackC1.Value;
-            }
-            else
-            {
-                limit_total = AppConfig.GetMode("limit_total");
-                limit_cpu = AppConfig.GetMode("limit_cpu");
-                limit_fast = AppConfig.GetMode("limit_fast");
-            }
-
-            if (limit_total < 0) limit_total = AsusACPI.DefaultTotal;
             if (limit_total > AsusACPI.MaxTotal) limit_total = AsusACPI.MaxTotal;
             if (limit_total < AsusACPI.MinTotal) limit_total = AsusACPI.MinTotal;
 
-            if (limit_cpu < 0) limit_cpu = AsusACPI.DefaultCPU;
             if (limit_cpu > AsusACPI.MaxCPU) limit_cpu = AsusACPI.MaxCPU;
             if (limit_cpu < AsusACPI.MinCPU) limit_cpu = AsusACPI.MinCPU;
-            if (limit_cpu > limit_total) limit_cpu = limit_total;
+            
+            if (limit_slow > AsusACPI.MaxTotal) limit_slow = AsusACPI.MaxTotal;
+            if (limit_slow < AsusACPI.MinTotal) limit_slow = AsusACPI.MinTotal;
 
-            if (limit_fast < 0) limit_fast = AsusACPI.DefaultTotal;
             if (limit_fast > AsusACPI.MaxTotal) limit_fast = AsusACPI.MaxTotal;
             if (limit_fast < AsusACPI.MinTotal) limit_fast = AsusACPI.MinTotal;
 
-            trackA0.Value = limit_total;
-            trackB0.Value = limit_cpu;
-            trackC1.Value = limit_fast;
-
-            checkApplyPower.Checked = apply;
-
-            labelA0.Text = trackA0.Value.ToString() + "W";
-            labelB0.Text = trackB0.Value.ToString() + "W";
-            labelC1.Text = trackC1.Value.ToString() + "W";
-
-            AppConfig.SetMode("limit_total", limit_total);
-            AppConfig.SetMode("limit_cpu", limit_cpu);
-            AppConfig.SetMode("limit_fast", limit_fast);
+            trackTotal.Value = limit_total;
+            trackSlow.Value = limit_slow;
+            trackCPU.Value = limit_cpu;
+            trackFast.Value = limit_fast;
 
+            SavePower();
 
         }
 
-
-        private void TrackPower_Scroll(object? sender, EventArgs e)
+        private void SavePower()
         {
-            InitPower(true);
+            labelTotal.Text = trackTotal.Value.ToString() + "W";
+            labelSlow.Text = trackSlow.Value.ToString() + "W";
+            labelCPU.Text = trackCPU.Value.ToString() + "W";
+            labelFast.Text = trackFast.Value.ToString() + "W";
+
+            AppConfig.SetMode("limit_total", trackTotal.Value);
+            AppConfig.SetMode("limit_slow", trackSlow.Value);
+            AppConfig.SetMode("limit_cpu", trackCPU.Value);
+            AppConfig.SetMode("limit_fast", trackFast.Value);
         }
 
+        private void TrackTotal_Scroll(object? sender, EventArgs e)
+        {
+            if (trackTotal.Value > trackSlow.Value) trackSlow.Value = trackTotal.Value;
+            if (trackTotal.Value > trackFast.Value) trackFast.Value = trackTotal.Value;
+            if (trackTotal.Value < trackCPU.Value) trackCPU.Value = trackTotal.Value;
+            SavePower();
+        }
+
+        private void TrackSlow_Scroll(object? sender, EventArgs e)
+        {
+            if (trackSlow.Value < trackTotal.Value) trackTotal.Value = trackSlow.Value;
+            if (trackSlow.Value > trackFast.Value) trackFast.Value = trackSlow.Value;
+            SavePower();
+        }
+
+        private void TrackFast_Scroll(object? sender, EventArgs e)
+        {
+            if (trackFast.Value < trackSlow.Value) trackSlow.Value = trackFast.Value;
+            if (trackFast.Value < trackTotal.Value) trackTotal.Value = trackFast.Value;
+            SavePower();
+        }
+
+        private void TrackCPU_Scroll(object? sender, EventArgs e)
+        {
+            if (trackCPU.Value > trackTotal.Value) trackTotal.Value = trackCPU.Value;
+            SavePower();
+        }
 
         public void InitFans()
         {
@@ -739,7 +1019,7 @@ namespace GHelper
             int chartCount = 2;
 
             // Middle / system fan check
-            if (!AsusACPI.IsEmptyCurve(Program.acpi.GetFanCurve(AsusFan.Mid)))
+            if (!AsusACPI.IsEmptyCurve(Program.acpi.GetFanCurve(AsusFan.Mid)) || Program.acpi.GetFan(AsusFan.Mid) >= 0)
             {
                 AppConfig.Set("mid_fan", 1);
                 chartCount++;
@@ -769,7 +1049,7 @@ namespace GHelper
             try
             {
                 if (chartCount > 2)
-                    Size = MinimumSize = new Size(Size.Width, (int)(ControlHelper.GetDpiScale(this).Value * (chartCount * 200 + 100)));
+                    Size = MinimumSize = new Size(Size.Width, Math.Max(MinimumSize.Height, (int)(ControlHelper.GetDpiScale(this).Value * (chartCount * 200 + 100))));
             }
             catch (Exception ex)
             {
@@ -840,7 +1120,6 @@ namespace GHelper
 
         }
 
-
         private void ButtonReset_Click(object? sender, EventArgs e)
         {
 
@@ -864,37 +1143,48 @@ namespace GHelper
             trackTemp.Value = RyzenControl.MaxTemp;
 
             AdvancedScroll();
-            AppConfig.SetMode("cpu_temp", -1);
+            AppConfig.RemoveMode("cpu_temp");
 
             modeControl.ResetPerformanceMode();
 
-            if (Program.acpi.IsXGConnected()) AsusUSB.ResetXGM();
+            InitPowerPlan();
+
+            if (Program.acpi.IsXGConnected()) XGM.Reset();
 
 
             if (gpuVisible)
             {
+                trackGPUClockLimit.Value = NvidiaGpuControl.MaxClockLimit;
                 trackGPUCore.Value = 0;
                 trackGPUMemory.Value = 0;
+                
                 trackGPUBoost.Value = AsusACPI.MaxGPUBoost;
                 trackGPUTemp.Value = AsusACPI.MaxGPUTemp;
 
-                AppConfig.SetMode("gpu_boost", trackGPUBoost.Value);
-                AppConfig.SetMode("gpu_temp", trackGPUTemp.Value);
-                AppConfig.SetMode("gpu_core", trackGPUCore.Value);
-                AppConfig.SetMode("gpu_memory", trackGPUMemory.Value);
+                //AppConfig.SetMode("gpu_boost", trackGPUBoost.Value);
+                //AppConfig.SetMode("gpu_temp", trackGPUTemp.Value);
+                
+                AppConfig.RemoveMode("gpu_boost");
+                AppConfig.RemoveMode("gpu_temp");
+
+                AppConfig.RemoveMode("gpu_power");
+                AppConfig.RemoveMode("gpu_clock_limit");
+                AppConfig.RemoveMode("gpu_core");
+                AppConfig.RemoveMode("gpu_memory");
+
+                InitGPUPower();
 
                 VisualiseGPUSettings();
-                modeControl.SetGPUClocks(true);
+                modeControl.SetGPUClocks(true, true);
                 modeControl.SetGPUPower();
             }
 
         }
 
-        private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)
+        private void Chart_Save()
         {
             curPoint = null;
             curIndex = -1;
-
             labelTip.Visible = false;
 
             SaveProfile(seriesCPU, AsusFan.CPU);
@@ -907,11 +1197,22 @@ namespace GHelper
                 SaveProfile(seriesXGM, AsusFan.XGM);
 
             modeControl.AutoFans();
-
-
         }
 
-        private void ChartCPU_MouseMove(object? sender, MouseEventArgs e)
+        private void ChartCPU_MouseUp(object? sender, MouseEventArgs e)
+        {
+            Chart_Save();
+        }
+
+
+        private void ChartCPU_MouseLeave(object? sender, EventArgs e)
+        {
+            curPoint = null;
+            curIndex = -1;
+            labelTip.Visible = false;
+        }
+
+        private void ChartCPU_MouseMove(object? sender, MouseEventArgs e, AsusFan device)
         {
 
             if (sender is null) return;
@@ -972,9 +1273,9 @@ namespace GHelper
                         tip = true;
                     }
 
-                    labelTip.Text = Math.Round(curPoint.XValue) + "C, " + ChartPercToRPM((int)curPoint.YValues[0], " " + Properties.Strings.RPM);
+                    labelTip.Text = Math.Floor(curPoint.XValue) + "C, " + ChartYLabel((int)curPoint.YValues[0], device, " " + Properties.Strings.RPM);
                     labelTip.Top = e.Y + ((Control)sender).Top;
-                    labelTip.Left = e.X - 50;
+                    labelTip.Left = Math.Min(chart.Width - labelTip.Width - 20, e.X - 50);
 
                 }
                 catch

app/Fans.resx

@@ -18,7 +18,7 @@
     <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="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>

app/GHelper.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
-    <TargetFramework>net7.0-windows</TargetFramework>
+    <TargetFramework>net8.0-windows</TargetFramework>
     <Nullable>enable</Nullable>
     <UseWindowsForms>True</UseWindowsForms>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -15,7 +15,7 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <ProduceReferenceAssembly>False</ProduceReferenceAssembly>
     <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-    <AssemblyVersion>0.100</AssemblyVersion>
+    <AssemblyVersion>0.199</AssemblyVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
@@ -59,31 +59,18 @@
 
   <ItemGroup>
     <PackageReference Include="FftSharp" Version="2.0.0" />
-    <PackageReference Include="hidlibrary" Version="3.3.40" />
     <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.8.0" />
+    <PackageReference Include="System.Management" Version="8.0.0" />
+    <PackageReference Include="TaskScheduler" Version="2.11.0" />
+    <PackageReference Include="WinForms.DataVisualization" Version="1.9.2" />
   </ItemGroup>
 
   <ItemGroup>
     <Content Include="Resources\eco.ico">
       <CopyToOutputDirectory>Never</CopyToOutputDirectory>
     </Content>
-    <Content Include="Resources\icons8-charging-battery-48.png">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Resources\icons8-laptop-48.png">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Resources\icons8-speed-48.png">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </Content>
-    <Content Include="Resources\icons8-video-card-48.png">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </Content>
     <Content Include="Resources\ultimate.ico">
       <CopyToOutputDirectory>Never</CopyToOutputDirectory>
     </Content>
@@ -141,4 +128,4 @@
     </None>
   </ItemGroup>
 
-</Project>
+</Project>

app/Gpu/AMD/AmdAdl2.cs

@@ -551,6 +551,65 @@ public class Adl2
             int iAdapterIndex,
             int iEnabled);
 
+        // FPS
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_FrameMetrics_Start(
+            IntPtr context,
+            int iAdapterIndex,
+            int VidPnSourceId
+        );
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_FrameMetrics_Stop(
+            IntPtr context,
+            int iAdapterIndex,
+            int VidPnSourceId
+        );
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_Adapter_FrameMetrics_Get(
+              IntPtr context,
+              int iAdapterIndex,
+              int VidPnSourceId,
+              out float iFramesPerSecond
+          );
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_FPS_Settings_Get(IntPtr context, int iAdapterIndex, out ADLFPSSettingsOutput lpFPSSettings);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_FPS_Settings_Set(IntPtr context, int iAdapterIndex, ADLFPSSettingsInput lpFPSSettings);
+
+        [DllImport(Atiadlxx_FileName)]
+        public static extern int ADL2_FPS_Settings_Reset(IntPtr context, int iAdapterIndex);
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ADLFPSSettingsOutput
+        {
+            public int ulSize;
+            public int bACFPSEnabled;
+            public int bDCFPSEnabled;
+            public int ulACFPSCurrent;
+            public int ulDCFPSCurrent;
+            public int ulACFPSMaximum;
+            public int ulACFPSMinimum;
+            public int ulDCFPSMaximum;
+            public int ulDCFPSMinimum;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ADLFPSSettingsInput
+        {
+            public int ulSize;
+            public int bGlobalSettings;
+            public int ulACFPSCurrent;
+            public int ulDCFPSCurrent;
+
+            // Assuming ulReserved is an array of 6 integers
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
+            public int[] ulReserved;
+        }
         // Clocks
 
         [StructLayout(LayoutKind.Sequential)]

app/Gpu/AMD/AmdGpuControl.cs

@@ -9,7 +9,9 @@ public class AmdGpuControl : IGpuControl
 {
     private bool _isReady;
     private nint _adlContextHandle;
+
     private readonly ADLAdapterInfo _internalDiscreteAdapter;
+    private readonly ADLAdapterInfo? _iGPU;
 
     public bool IsNvidia => false;
 
@@ -60,11 +62,16 @@ public class AmdGpuControl : IGpuControl
 
     public AmdGpuControl()
     {
-        if (!Adl2.Load())
-            return;
+        if (AppConfig.NoGpu() || !Adl2.Load()) return;
 
-        if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS)
+        try
+        {
+            if (Adl2.ADL2_Main_Control_Create(1, out _adlContextHandle) != Adl2.ADL_SUCCESS) return;
+        } catch (Exception ex)
+        {
+            Logger.WriteLine(ex.Message);
             return;
+        }
 
         ADLAdapterInfo? internalDiscreteAdapter = FindByType(ADLAsicFamilyType.Discrete);
 
@@ -74,6 +81,8 @@ public class AmdGpuControl : IGpuControl
             _isReady = true;
         }
 
+        _iGPU = FindByType(ADLAsicFamilyType.Integrated);
+
     }
 
     public bool IsValid => _isReady && _adlContextHandle != nint.Zero;
@@ -109,6 +118,30 @@ public class AmdGpuControl : IGpuControl
 
     }
 
+    public int? GetiGpuUse()
+    {
+        if (_adlContextHandle == nint.Zero || _iGPU == null) return null;
+        if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, ((ADLAdapterInfo)_iGPU).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 int? GetGpuPower()
+    {
+        if (_adlContextHandle == nint.Zero || _iGPU == null) return null;
+        if (ADL2_New_QueryPMLogData_Get(_adlContextHandle, ((ADLAdapterInfo)_iGPU).AdapterIndex, out ADLPMLogDataOutput adlpmLogDataOutput) != Adl2.ADL_SUCCESS) return null;
+
+        ADLSingleSensorData gpuUsage = adlpmLogDataOutput.Sensors[(int)ADLSensorType.PMLOG_ASIC_POWER];
+        if (gpuUsage.Supported == 0) return null;
+
+        return gpuUsage.Value;
+
+    }
+
 
     public bool SetVariBright(int enabled)
     {
@@ -139,6 +172,52 @@ public class AmdGpuControl : IGpuControl
         return true;
     }
 
+    public void StartFPS()
+    {
+        if (_adlContextHandle == nint.Zero || _iGPU == null) return;
+        ADL2_Adapter_FrameMetrics_Start(_adlContextHandle, ((ADLAdapterInfo)_iGPU).AdapterIndex, 0);
+    }
+
+    public void StopFPS()
+    {
+        if (_adlContextHandle == nint.Zero || _iGPU == null) return;
+        ADL2_Adapter_FrameMetrics_Stop(_adlContextHandle, ((ADLAdapterInfo)_iGPU).AdapterIndex, 0);
+    }
+
+    public float GetFPS()
+    {
+        if (_adlContextHandle == nint.Zero || _iGPU == null) return 0;
+        float fps;
+        if (ADL2_Adapter_FrameMetrics_Get(_adlContextHandle, ((ADLAdapterInfo)_iGPU).AdapterIndex, 0, out fps) != Adl2.ADL_SUCCESS) return 0;
+        return fps;
+    }
+
+    public int GetFPSLimit()
+    {
+        if (_adlContextHandle == nint.Zero || _iGPU == null) return -1;
+        ADLFPSSettingsOutput settings;
+        if (ADL2_FPS_Settings_Get(_adlContextHandle, ((ADLAdapterInfo)_iGPU).AdapterIndex, out settings) != Adl2.ADL_SUCCESS) return -1;
+
+        Logger.WriteLine($"FPS Limit: {settings.ulACFPSCurrent}");
+
+        return settings.ulACFPSCurrent;
+    }
+
+    public int SetFPSLimit(int limit)
+    {
+        if (_adlContextHandle == nint.Zero || _iGPU == null) return -1;
+
+        ADLFPSSettingsInput settings = new ADLFPSSettingsInput();
+
+        settings.ulACFPSCurrent = limit;
+        settings.ulDCFPSCurrent = limit;
+        settings.bGlobalSettings = 1;
+
+        if (ADL2_FPS_Settings_Set(_adlContextHandle, ((ADLAdapterInfo)_iGPU).AdapterIndex, settings) != Adl2.ADL_SUCCESS) return 0;
+
+        return 1;
+    }
+
     public ADLODNPerformanceLevels? GetGPUClocks()
     {
         if (!IsValid) return null;

app/Gpu/GPUModeControl.cs

@@ -1,6 +1,7 @@
 using GHelper.Display;
 using GHelper.Gpu.NVidia;
 using GHelper.Helpers;
+using GHelper.USB;
 using System.Diagnostics;
 
 namespace GHelper.Gpu
@@ -10,6 +11,10 @@ namespace GHelper.Gpu
         SettingsForm settings;
         ScreenControl screenControl = new ScreenControl();
 
+        public static int gpuMode;
+        public static bool? gpuExists = null;
+
+
         public GPUModeControl(SettingsForm settingsForm)
         {
             settings = settingsForm;
@@ -17,43 +22,53 @@ namespace GHelper.Gpu
 
         public void InitGPUMode()
         {
+            if (AppConfig.NoGpu())
+            {
+                settings.HideGPUModes(false); 
+                return;
+            }
+
             int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
             int mux = Program.acpi.DeviceGet(AsusACPI.GPUMux);
 
             Logger.WriteLine("Eco flag : " + eco);
             Logger.WriteLine("Mux flag : " + mux);
 
-            int GpuMode;
+            settings.VisualiseGPUButtons(eco >= 0, mux >= 0);
 
             if (mux == 0)
             {
-                GpuMode = AsusACPI.GPUModeUltimate;
+                gpuMode = AsusACPI.GPUModeUltimate;
             }
             else
             {
                 if (eco == 1)
-                    GpuMode = AsusACPI.GPUModeEco;
+                    gpuMode = AsusACPI.GPUModeEco;
                 else
-                    GpuMode = AsusACPI.GPUModeStandard;
+                    gpuMode = AsusACPI.GPUModeStandard;
 
-                // Ultimate mode not supported
-                if (mux != 1) settings.HideUltimateMode();
                 // GPU mode not supported
-                if (eco < 0 && mux < 0) settings.HideGPUModes();
+                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);
+            AppConfig.Set("gpu_mode", gpuMode);
+            settings.VisualiseGPUMode(gpuMode);
+
+            Aura.CustomRGB.ApplyGPUColor();
 
-            InitXGM();
-            settings.VisualiseGPUMode(GpuMode);
         }
 
 
-        public void SetGPUMode(int GPUMode)
+
+        public void SetGPUMode(int GPUMode, int auto = 0)
         {
 
             int CurrentGPU = AppConfig.Get("gpu_mode");
-            AppConfig.Set("gpu_auto", 0);
+            AppConfig.Set("gpu_auto", auto);
 
             if (CurrentGPU == GPUMode)
             {
@@ -64,12 +79,14 @@ namespace GHelper.Gpu
             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)
                 {
-                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
+                    status = Program.acpi.DeviceSet(AsusACPI.GPUMux, 1, "GPUMux");
                     restart = true;
                     changed = true;
                 }
@@ -79,7 +96,20 @@ namespace GHelper.Gpu
                 DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertUltimateOn, Properties.Strings.AlertUltimateTitle, MessageBoxButtons.YesNo);
                 if (dialogResult == DialogResult.Yes)
                 {
-                    Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
+                    if (AppConfig.NoAutoUltimate())
+                    {
+                        Program.acpi.SetGPUEco(0);
+                        Thread.Sleep(500);
+
+                        int eco = Program.acpi.DeviceGet(AsusACPI.GPUEco);
+                        Logger.WriteLine("Eco flag : " + eco);
+                        if (eco == 1)
+                        {
+                            settings.VisualiseGPUMode();
+                            return;
+                        }
+                    }
+                    status = Program.acpi.DeviceSet(AsusACPI.GPUMux, 0, "GPUMux");
                     restart = true;
                     changed = true;
                 }
@@ -125,16 +155,6 @@ namespace GHelper.Gpu
 
                 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();
                 }
 
@@ -144,7 +164,7 @@ namespace GHelper.Gpu
 
                 if (status == 0 && eco == 1 && hardWay) RestartGPU();
 
-                await Task.Delay(TimeSpan.FromMilliseconds(100));
+                await Task.Delay(TimeSpan.FromMilliseconds(AppConfig.Get("refresh_delay", 500)));
 
                 settings.Invoke(delegate
                 {
@@ -159,6 +179,12 @@ namespace GHelper.Gpu
                     Program.modeControl.SetGPUClocks(false);
                 }
 
+                if (AppConfig.Is("mode_reapply"))
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(3000));
+                    Program.modeControl.AutoPerformance();
+                }
+
             });
 
 
@@ -166,10 +192,16 @@ namespace GHelper.Gpu
 
         public static bool IsPlugged()
         {
-            bool optimizedUSBC = AppConfig.Get("optimized_usbc") != 1;
+            if (SystemInformation.PowerStatus.PowerLineStatus != PowerLineStatus.Online) return false;
+            if (!AppConfig.Is("optimized_usbc")) return true;
 
-            return SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online &&
-                   (optimizedUSBC || Program.acpi.DeviceGet(AsusACPI.ChargerMode) < AsusACPI.ChargerUSB);
+            if (AppConfig.ContainsModel("FA507")) Thread.Sleep(1000);
+
+            int chargerMode = Program.acpi.DeviceGet(AsusACPI.ChargerMode);
+            Logger.WriteLine("ChargerStatus: " + chargerMode);
+
+            if (chargerMode <= 0) return true;
+            return (chargerMode & AsusACPI.ChargerBarrel) > 0;
 
         }
 
@@ -177,7 +209,7 @@ namespace GHelper.Gpu
         {
 
             bool GpuAuto = AppConfig.Is("gpu_auto");
-            bool ForceGPU = AppConfig.ContainsModel("503");
+            bool ForceGPU = AppConfig.IsForceSetGPUMode();
 
             int GpuMode = AppConfig.Get("gpu_mode");
 
@@ -188,14 +220,12 @@ namespace GHelper.Gpu
 
             if (mux == 0)
             {
-                if (optimized) SetGPUMode(AsusACPI.GPUModeStandard);
+                if (optimized) SetGPUMode(AsusACPI.GPUModeStandard, 1);
                 return false;
             }
             else
             {
 
-                if (ReEnableGPU()) return true;
-
                 if (eco == 1)
                     if ((GpuAuto && IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeStandard))
                     {
@@ -206,6 +236,7 @@ namespace GHelper.Gpu
                     if ((GpuAuto && !IsPlugged()) || (ForceGPU && GpuMode == AsusACPI.GPUModeEco))
                     {
 
+                        if (Program.acpi.IsXGConnected()) return false;
                         if (HardwareControl.IsUsedGPU())
                         {
                             DialogResult dialogResult = MessageBox.Show(Properties.Strings.AlertDGPU, Properties.Strings.AlertDGPUTitle, MessageBoxButtons.YesNo);
@@ -256,29 +287,17 @@ namespace GHelper.Gpu
         }
 
 
-        public bool ReEnableGPU()
-        {
-
-            if (AppConfig.Get("gpu_reenable") != 1) return false;
-            if (Screen.AllScreens.Length <= 1) return false;
-
-            Logger.WriteLine("Re-enabling gpu for 503 model");
-
-            Thread.Sleep(1000);
-            SetGPUEco(1);
-            Thread.Sleep(1000);
-            SetGPUEco(0);
-            return true;
-        }
-
         public void InitXGM()
         {
-            bool connected = Program.acpi.IsXGConnected();
-            int activated = Program.acpi.DeviceGet(AsusACPI.GPUXG);
-            settings.VisualizeXGM(connected, activated == 1);
+            if (Program.acpi.IsXGConnected())
+            {
+                //Program.acpi.DeviceSet(AsusACPI.GPUXGInit, 1, "XG Init");
+                XGM.Init();
+            }
+
         }
 
-        public void ToggleXGM()
+        public void ToggleXGM(bool silent = false)
         {
 
             Task.Run(async () =>
@@ -287,23 +306,42 @@ namespace GHelper.Gpu
 
                 if (Program.acpi.DeviceGet(AsusACPI.GPUXG) == 1)
                 {
+                    XGM.Reset();
                     HardwareControl.KillGPUApps();
-                    DialogResult dialogResult = MessageBox.Show("Did you close all applications running on XG Mobile?", "Disabling XG Mobile", MessageBoxButtons.YesNo);
-                    if (dialogResult == DialogResult.Yes)
+
+                    if (silent)
                     {
                         Program.acpi.DeviceSet(AsusACPI.GPUXG, 0, "GPU XGM");
                         await Task.Delay(TimeSpan.FromSeconds(15));
                     }
+                    else
+                    {
+                        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
                 {
-                    Program.acpi.DeviceSet(AsusACPI.GPUXG, 1, "GPU XGM");
-                    AsusUSB.ApplyXGMLight(AppConfig.Is("xmg_light"));
+
+                    if (AppConfig.Is("xgm_special"))
+                        Program.acpi.DeviceSet(AsusACPI.GPUXG, 0x101, "GPU XGM");
+                    else
+                        Program.acpi.DeviceSet(AsusACPI.GPUXG, 1, "GPU XGM");
+
+                    InitXGM();
+                    XGM.Light(AppConfig.Is("xmg_light"));
 
                     await Task.Delay(TimeSpan.FromSeconds(15));
 
                     if (AppConfig.IsMode("auto_apply"))
-                        AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+                        XGM.SetFan(AppConfig.GetFanConfig(AsusFan.XGM));
+
+                    HardwareControl.RecreateGpuControl();
+
                 }
 
                 settings.Invoke(delegate
@@ -321,5 +359,16 @@ namespace GHelper.Gpu
             }
         }
 
+        // 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);
+        }
+
     }
 }

app/Gpu/NVidia/NvidiaGpuControl.cs

@@ -13,10 +13,13 @@ 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 static int MaxMemoryOffset => AppConfig.Get("max_gpu_memory", 500);
 
-    public const int MinCoreOffset = -250;
-    public const int MinMemoryOffset = -250;
+    public static int MinCoreOffset = AppConfig.Get("min_gpu_core", -250);
+    public static int MinMemoryOffset = AppConfig.Get("min_gpu_memory", -500);
+
+    public static int MinClockLimit = AppConfig.Get("min_gpu_clock", 400);
+    public const int MaxClockLimit = 3000;
 
     private static PhysicalGPU? _internalGpu;
 
@@ -72,11 +75,11 @@ public class NvidiaGpuControl : IGpuControl
             Logger.WriteLine(ex.Message);
         }
 
-        //NVIDIA.RestartDisplayDriver();
+        //GeneralApi.RestartDisplayDriver();
     }
 
 
-    public int GetClocks(out int core, out int memory)
+    public bool GetClocks(out int core, out int memory)
     {
         PhysicalGPU internalGpu = _internalGpu!;
 
@@ -95,27 +98,24 @@ public class NvidiaGpuControl : IGpuControl
                 Logger.WriteLine("GPU VOLT:" + delta.IsEditable + " - " + delta.ValueDeltaInMicroVolt.DeltaValue);
             }
 
-            return 0;
+            return true;
 
         }
         catch (Exception ex)
         {
             Logger.WriteLine("GET GPU CLOCKS:" + ex.Message);
             core = memory = 0;
-            return -1;
+            return false;
         }
 
     }
 
 
-    public bool RestartGPU()
+    private bool RunPowershellCommand(string script)
     {
         try
         {
-            string script = @"$device = Get-PnpDevice | Where-Object { $_.FriendlyName -imatch 'NVIDIA' -and $_.Class -eq 'Display' }; Disable-PnpDevice $device.InstanceId -Confirm:$false; Start-Sleep -Seconds 3; Enable-PnpDevice $device.InstanceId -Confirm:$false";
-            Logger.WriteLine(script);
             ProcessHelper.RunCMD("powershell", script);
-            //Thread.Sleep(2000);
             return true;
         }
         catch (Exception ex)
@@ -123,27 +123,73 @@ public class NvidiaGpuControl : IGpuControl
             Logger.WriteLine(ex.ToString());
             return false;
         }
+
     }
 
-    public int SetClocksFromConfig()
+    public int GetMaxGPUCLock()
     {
-        int core = AppConfig.Get("gpu_core", 0);
-        int memory = AppConfig.Get("gpu_memory", 0);
-        int status = SetClocks(core, memory);
-        return status;
+        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 SetClocks(int core, int memory, int voltage = 0)
+
+    public int SetMaxGPUClock(int clock)
+    {
+
+        if (clock < MinClockLimit || clock >= MaxClockLimit) clock = 0;
+
+        int _clockLimit = GetMaxGPUCLock();
+
+        if (_clockLimit < 0 && clock == 0) return 0;
+
+        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;
 
+        GetClocks(out int currentCore, out int currentMemory);
+
+        // Nothing to set
+        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));
+        //var voltageEntry = new PerformanceStates20BaseVoltageEntryV1(PerformanceVoltageDomain.Core, new PerformanceStates20ParameterDelta(voltage));
 
         PerformanceStates20ClockEntryV1[] clocks = { coreClock, memoryClock };
         PerformanceStates20BaseVoltageEntryV1[] voltages = { };
@@ -163,8 +209,6 @@ public class NvidiaGpuControl : IGpuControl
             return -1;
         }
 
-
-
         return 1;
     }
 

app/Gpu/NVidia/NvidiaSmi.cs

@@ -30,6 +30,28 @@ public static class NvidiaSmi
         return false; // Return false if the "Display Active" status is not found
     }
 
+    public static int GetDefaultMaxGPUPower()
+    {
+        if (AppConfig.ContainsModel("GU605") || AppConfig.ContainsModel("GA605")) return 125;
+        if (AppConfig.ContainsModel("GA403")) return 90;
+        if (AppConfig.ContainsModel("FA607")) return 140;
+        else return 175;
+    }
+
+    public static int GetMaxGPUPower()
+    {
+        string output = RunNvidiaSmiCommand("--query-gpu=power.max_limit --format csv,noheader,nounits");
+        output = output.Trim().Trim('\n', '\r').Replace(".00","").Replace(",00", "");
+
+        if (float.TryParse(output, out float floatValue))
+        {
+            int intValue = (int)floatValue;
+            if (intValue >= 50 && intValue <= 175) return intValue;
+        }
+
+        return GetDefaultMaxGPUPower();
+    }
+
     private static string RunNvidiaSmiCommand(string arguments = "-i 0 -q")
     {
         ProcessStartInfo startInfo = new ProcessStartInfo

app/Handheld.cs

@@ -0,0 +1,273 @@
+using GHelper.Ally;
+using GHelper.UI;
+
+namespace GHelper
+{
+    public partial class Handheld : RForm
+    {
+
+        static string activeBinding = "";
+        static RButton? activeButton;
+
+        public Handheld()
+        {
+            InitializeComponent();
+            InitTheme(true);
+
+            Text = Properties.Strings.Controller;
+
+            labelLSTitle.Text = Properties.Strings.LSDeadzones;
+            labelRSTitle.Text = Properties.Strings.RSDeadzones;
+            labelLTTitle.Text = Properties.Strings.LTDeadzones;
+            labelRTTitle.Text = Properties.Strings.RTDeadzones;
+            labelVibraTitle.Text = Properties.Strings.VibrationStrength;
+            checkController.Text = Properties.Strings.DisableController;
+            buttonReset.Text = Properties.Strings.Reset;
+
+            labelPrimary.Text = Properties.Strings.BindingPrimary;
+            labelSecondary.Text = Properties.Strings.BindingSecondary;
+
+            Shown += Handheld_Shown;
+
+            Init();
+
+            trackLSMin.Scroll += Controller_Scroll;
+            trackLSMax.Scroll += Controller_Scroll;
+            trackRSMin.Scroll += Controller_Scroll;
+            trackRSMax.Scroll += Controller_Scroll;
+
+            trackLTMin.Scroll += Controller_Scroll;
+            trackLTMax.Scroll += Controller_Scroll;
+            trackRTMin.Scroll += Controller_Scroll;
+            trackRTMax.Scroll += Controller_Scroll;
+
+            trackVibra.Scroll += Controller_Scroll;
+
+            buttonReset.Click += ButtonReset_Click;
+
+            trackLSMin.ValueChanged += Controller_Complete;
+            trackLSMax.ValueChanged += Controller_Complete;
+            trackRSMin.ValueChanged += Controller_Complete;
+            trackRSMax.ValueChanged += Controller_Complete;
+
+            trackLTMin.ValueChanged += Controller_Complete;
+            trackLTMax.ValueChanged += Controller_Complete;
+            trackRTMin.ValueChanged += Controller_Complete;
+            trackRTMax.ValueChanged += Controller_Complete;
+
+            trackVibra.ValueChanged += Controller_Complete;
+
+            ButtonBinding("m1", "M1", buttonM1);
+            ButtonBinding("m2", "M2", buttonM2);
+
+            ButtonBinding("a", "A", buttonA);
+            ButtonBinding("b", "B", buttonB);
+            ButtonBinding("x", "X", buttonX);
+            ButtonBinding("y", "Y", buttonY);
+
+            ButtonBinding("du", "DPad Up", buttonDPU);
+            ButtonBinding("dd", "DPad Down", buttonDPD);
+
+            ButtonBinding("dl", "DPad Left", buttonDPL);
+            ButtonBinding("dr", "DPad Right", buttonDPR);
+
+            ButtonBinding("rt", "Right Trigger", buttonRT);
+            ButtonBinding("lt", "Left Trigger", buttonLT);
+
+            ButtonBinding("rb", "Right Bumper", buttonRB);
+            ButtonBinding("lb", "Left Bumper", buttonLB);
+
+            ButtonBinding("rs", "Right Stick", buttonRS);
+            ButtonBinding("ll", "Left Stick", buttonLS);
+
+            ButtonBinding("vb", "View", buttonView);
+            ButtonBinding("mb", "Menu", buttonMenu);
+
+            ComboBinding(comboPrimary);
+            ComboBinding(comboSecondary);
+
+            checkController.Checked = AppConfig.Is("controller_disabled");
+            checkController.CheckedChanged += CheckController_CheckedChanged;
+
+        }
+
+        private void CheckController_CheckedChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("controller_disabled", checkController.Checked ? 1 : 0);
+            AllyControl.DisableXBoxController(checkController.Checked);
+        }
+
+        private void ComboBinding(RComboBox combo)
+        {
+
+            combo.DropDownStyle = ComboBoxStyle.DropDownList;
+            combo.DisplayMember = "Value";
+            combo.ValueMember = "Key";
+            foreach (var item in AllyControl.BindCodes)
+                combo.Items.Add(new KeyValuePair<string, string>(item.Key, item.Value));
+
+            combo.SelectedValueChanged += Binding_SelectedValueChanged;
+
+        }
+
+        private void Binding_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            if (sender is null) return;
+            RComboBox combo = (RComboBox)sender;
+
+            string value = ((KeyValuePair<string, string>)combo.SelectedItem).Key;
+            string binding = "bind" + (combo.Name == "comboPrimary" ? "" : "2") + "_" + activeBinding;
+
+            if (value != "") AppConfig.Set(binding, value);
+            else AppConfig.Remove(binding);
+
+            VisualiseButton(activeButton, activeBinding);
+
+            AllyControl.ApplyMode();
+        }
+
+        private void SetComboValue(RComboBox combo, string value)
+        {
+            foreach (var item in AllyControl.BindCodes)
+                if (item.Key == value)
+                {
+                    combo.SelectedItem = item;
+                    return;
+                }
+
+            combo.SelectedIndex = 0;
+        }
+
+        private void VisualiseButton(RButton button, string binding)
+        {
+            if (button == null) return;
+
+            string primary = AppConfig.GetString("bind_" + binding, "");
+            string secondary = AppConfig.GetString("bind2_" + binding, "");
+
+            if (primary != "" || secondary != "")
+            {
+                button.BorderColor = colorStandard;
+                button.Activated = true;
+            }
+            else
+            {
+                button.Activated = false;
+            }
+        }
+
+        private void ButtonBinding(string binding, string label, RButton button)
+        {
+            button.Click += (sender, EventArgs) => { buttonBinding_Click(sender, EventArgs, binding, label); };
+            VisualiseButton(button, binding);
+        }
+
+        void buttonBinding_Click(object sender, EventArgs e, string binding, string label)
+        {
+
+            if (sender is null) return;
+            RButton button = (RButton)sender;
+
+            panelBinding.Visible = true;
+
+            activeButton = button;
+            activeBinding = binding;
+
+            labelBinding.Text = Properties.Strings.Binding + ": " + label;
+
+            SetComboValue(comboPrimary, AppConfig.GetString("bind_" + binding, ""));
+            SetComboValue(comboSecondary, AppConfig.GetString("bind2_" + binding, ""));
+
+        }
+
+
+
+        private void Controller_Complete(object? sender, EventArgs e)
+        {
+            AllyControl.SetDeadzones();
+        }
+
+        private void ButtonReset_Click(object? sender, EventArgs e)
+        {
+            trackLSMin.Value = 0;
+            trackLSMax.Value = 100;
+            trackRSMin.Value = 0;
+            trackRSMax.Value = 100;
+
+            trackLTMin.Value = 0;
+            trackLTMax.Value = 100;
+            trackRTMin.Value = 0;
+            trackRTMax.Value = 100;
+
+            trackVibra.Value = 100;
+
+            AppConfig.Remove("ls_min");
+            AppConfig.Remove("ls_max");
+            AppConfig.Remove("rs_min");
+            AppConfig.Remove("rs_max");
+
+            AppConfig.Remove("lt_min");
+            AppConfig.Remove("lt_max");
+            AppConfig.Remove("rt_min");
+            AppConfig.Remove("rt_max");
+            AppConfig.Remove("vibra");
+
+            VisualiseController();
+
+        }
+
+        private void Init()
+        {
+            trackLSMin.Value = AppConfig.Get("ls_min", 0);
+            trackLSMax.Value = AppConfig.Get("ls_max", 100);
+            trackRSMin.Value = AppConfig.Get("rs_min", 0);
+            trackRSMax.Value = AppConfig.Get("rs_max", 100);
+
+            trackLTMin.Value = AppConfig.Get("lt_min", 0);
+            trackLTMax.Value = AppConfig.Get("lt_max", 100);
+            trackRTMin.Value = AppConfig.Get("rt_min", 0);
+            trackRTMax.Value = AppConfig.Get("rt_max", 100);
+
+            trackVibra.Value = AppConfig.Get("vibra", 100);
+
+            VisualiseController();
+        }
+
+        private void VisualiseController()
+        {
+            labelLS.Text = $"{trackLSMin.Value} - {trackLSMax.Value}%";
+            labelRS.Text = $"{trackRSMin.Value} - {trackRSMax.Value}%";
+
+            labelLT.Text = $"{trackLTMin.Value} - {trackLTMax.Value}%";
+            labelRT.Text = $"{trackRTMin.Value} - {trackRTMax.Value}%";
+
+            labelVibra.Text = $"{trackVibra.Value}%";
+        }
+
+        private void Controller_Scroll(object? sender, EventArgs e)
+        {
+            AppConfig.Set("ls_min", trackLSMin.Value);
+            AppConfig.Set("ls_max", trackLSMax.Value);
+            AppConfig.Set("rs_min", trackRSMin.Value);
+            AppConfig.Set("rs_max", trackRSMax.Value);
+
+            AppConfig.Set("lt_min", trackLTMin.Value);
+            AppConfig.Set("lt_max", trackLTMax.Value);
+            AppConfig.Set("rt_min", trackRTMin.Value);
+            AppConfig.Set("rt_max", trackRTMax.Value);
+
+            AppConfig.Set("vibra", trackVibra.Value);
+
+            VisualiseController();
+
+        }
+
+        private void Handheld_Shown(object? sender, EventArgs e)
+        {
+            Height = Program.settingsForm.Height;
+            Top = Program.settingsForm.Top;
+            Left = Program.settingsForm.Left - Width - 5;
+        }
+
+    }
+}

app/Handheld.resx

@@ -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>

app/HardwareControl.cs

@@ -1,22 +1,30 @@
 using GHelper;
+using GHelper.Battery;
+using GHelper.Fan;
 using GHelper.Gpu;
-using GHelper.Gpu.NVidia;
 using GHelper.Gpu.AMD;
-
+using GHelper.Gpu.NVidia;
 using GHelper.Helpers;
 using System.Diagnostics;
 using System.Management;
 
 public static class HardwareControl
 {
+
     public static IGpuControl? GpuControl;
 
     public static float? cpuTemp = -1;
+    public static float? gpuTemp = -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 int? gpuTemp = null;
+    public static decimal? chargeCapacity;
+
+    public static string? batteryCharge;
 
     public static string? cpuFan;
     public static string? gpuFan;
@@ -24,37 +32,20 @@ public static class HardwareControl
 
     public static int? gpuUse;
 
-    public static int GetFanMax()
-    {
-        int max = 58;
-        int configMax = AppConfig.Get("fan_max");
-        if (configMax > 80) configMax = 0; // skipping inadvequate settings
+    static long lastUpdate;
 
-        if (AppConfig.ContainsModel("401")) max = 72;
-        else if (AppConfig.ContainsModel("503")) max = 68;
-        return Math.Max(max, configMax);
-    }
-
-    public static void SetFanMax(int fan)
+    static bool _chargeWatt = AppConfig.Is("charge_watt");
+    public static bool chargeWatt
     {
-        AppConfig.Set("fan_max", fan);
-    }
-    public static string FormatFan(int fan)
-    {
-        // fix for old models 
-        if (fan < 0)
+        get
         {
-            fan += 65536;
-            if (fan <= 0 || fan > 100) return null; //nothing reasonable
+            return _chargeWatt;
+        }
+        set
+        {
+            AppConfig.Set("charge_watt", value ? 1 : 0);
+            _chargeWatt = value;
         }
-
-        int fanMax = GetFanMax();
-        if (fan > fanMax && fan < 80) SetFanMax(fan);
-
-        if (AppConfig.Is("fan_rpm"))
-            return GHelper.Properties.Strings.FanSpeed + ": " + (fan * 100).ToString() + "RPM";
-        else
-            return GHelper.Properties.Strings.FanSpeed + ": " + Math.Min(Math.Round((float)fan / fanMax * 100), 100).ToString() + "%"; // relatively to 6000 rpm
     }
 
     private static int GetGpuUse()
@@ -74,9 +65,12 @@ public static class HardwareControl
     }
 
 
-    public static decimal GetBatteryRate()
+    public static void GetBatteryStatus()
     {
 
+        batteryRate = 0;
+        chargeCapacity = 0;
+
         try
         {
             ManagementScope scope = new ManagementScope("root\\WMI");
@@ -85,26 +79,36 @@ public static class HardwareControl
             using ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
             foreach (ManagementObject obj in searcher.Get().Cast<ManagementObject>())
             {
+
+                chargeCapacity = Convert.ToDecimal(obj["RemainingCapacity"]);
+
+                decimal? discharge = Program.acpi.GetBatteryDischarge();
+                if (discharge is not null)
+                {
+                    batteryRate = discharge;
+                    return;
+                }
+
                 decimal chargeRate = Convert.ToDecimal(obj["ChargeRate"]);
                 decimal dischargeRate = Convert.ToDecimal(obj["DischargeRate"]);
-                if (chargeRate > 0)
-                    return chargeRate;
-                else
-                    return -dischargeRate;
-            }
 
-            return 0;
+                if (chargeRate > 0)
+                    batteryRate = chargeRate / 1000;
+                else
+                    batteryRate = -dischargeRate / 1000;
+
+            }
 
         }
         catch (Exception ex)
         {
-            Logger.WriteLine("Discharge Reading: " + ex.Message);
-            return 0;
+            Debug.WriteLine("Discharge Reading: " + ex.Message);
         }
 
     }
     public static void ReadFullChargeCapacity()
     {
+        if (fullCapacity > 0) return;
 
         try
         {
@@ -120,13 +124,15 @@ public static class HardwareControl
         }
         catch (Exception ex)
         {
-            Logger.WriteLine("Full Charge Reading: " + ex.Message);
+            Debug.WriteLine("Full Charge Reading: " + ex.Message);
         }
 
     }
 
     public static void ReadDesignCapacity()
     {
+        if (designCapacity > 0) return;
+
         try
         {
             ManagementScope scope = new ManagementScope("root\\WMI");
@@ -141,7 +147,7 @@ public static class HardwareControl
         }
         catch (Exception ex)
         {
-            Logger.WriteLine("Design Capacity Reading: " + ex.Message);
+            Debug.WriteLine("Design Capacity Reading: " + ex.Message);
         }
     }
 
@@ -159,7 +165,7 @@ public static class HardwareControl
         }
         ReadFullChargeCapacity();
 
-        if (designCapacity is null || fullCapacity is null)
+        if (designCapacity is null || fullCapacity is null || designCapacity == 0 || fullCapacity == 0)
         {
             return -1;
         }
@@ -170,15 +176,12 @@ public static class HardwareControl
         return health;
     }
 
-    public static void ReadSensors()
+    public static float? GetCPUTemp()
     {
-        batteryRate = 0;
-        gpuTemp = -1;
-        gpuUse = -1;
 
-        cpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.CPU_Fan));
-        gpuFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.GPU_Fan));
-        midFan = FormatFan(Program.acpi.DeviceGet(AsusACPI.Mid_Fan));
+        var last = DateTimeOffset.Now.ToUnixTimeSeconds();
+        if (Math.Abs(last - lastUpdate) < 2) return cpuTemp;
+        lastUpdate = last;
 
         cpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_CPU);
 
@@ -191,9 +194,15 @@ public static class HardwareControl
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("Failed reading CPU temp :" + ex.Message);
+                //Debug.WriteLine("Failed reading CPU temp :" + ex.Message);
             }
 
+
+        return cpuTemp;
+    }
+
+    public static float? GetGPUTemp()
+    {
         try
         {
             gpuTemp = GpuControl?.GetCurrentTemperature();
@@ -202,13 +211,46 @@ public static class HardwareControl
         catch (Exception ex)
         {
             gpuTemp = -1;
-            Debug.WriteLine("Failed reading GPU temp :" + ex.Message);
+            //Debug.WriteLine("Failed reading GPU temp :" + ex.Message);
         }
 
         if (gpuTemp is null || gpuTemp < 0)
+        {
             gpuTemp = Program.acpi.DeviceGet(AsusACPI.Temp_GPU);
+        }
 
-        batteryRate = GetBatteryRate() / 1000;
+        return gpuTemp;
+    }
+
+
+    public static void ReadSensors()
+    {
+        batteryRate = 0;
+        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();
+        gpuTemp = GetGPUTemp();
+
+        ReadFullChargeCapacity();
+        GetBatteryStatus();
+
+        if (fullCapacity > 0 && chargeCapacity > 0)
+        {
+            batteryCapacity = Math.Min(100, (decimal)chargeCapacity / (decimal)fullCapacity * 100);
+            if (batteryCapacity > 99 && BatteryControl.chargeFull) BatteryControl.UnSetBatteryLimitFull();
+            if (chargeWatt)
+            {
+                batteryCharge = Math.Round((decimal)chargeCapacity / 1000, 1).ToString() + "Wh";
+            }
+            else
+            {
+                batteryCharge = Math.Round(batteryCapacity, 1) + "%";
+            }
+        }
     }
 
     public static bool IsUsedGPU(int threshold = 10)
@@ -243,12 +285,13 @@ public static class HardwareControl
 
     public static void RecreateGpuControl()
     {
+        if (AppConfig.NoGpu()) return;
         try
         {
             GpuControl?.Dispose();
 
             IGpuControl _gpuControl = new NvidiaGpuControl();
-            
+
             if (_gpuControl.IsValid)
             {
                 GpuControl = _gpuControl;
@@ -262,6 +305,7 @@ public static class HardwareControl
             if (_gpuControl.IsValid)
             {
                 GpuControl = _gpuControl;
+                if (GpuControl.FullName.Contains("6850M")) AppConfig.Set("xgm_special", 1);
                 Logger.WriteLine(GpuControl.FullName);
                 return;
             }
@@ -282,7 +326,8 @@ public static class HardwareControl
     public static void KillGPUApps()
     {
 
-        List<string> tokill = new() { "EADesktop", "RadeonSoftware", "epicgameslauncher", "ASUSSmartDisplayControl" };
+        List<string> tokill = new() { "EADesktop", "epicgameslauncher", "ASUSSmartDisplayControl" };
+
         foreach (string kill in tokill) ProcessHelper.KillByName(kill);
 
         if (AppConfig.Is("kill_gpu_apps") && GpuControl is not null)

app/Helpers/ClamshellModeControl.cs

@@ -6,24 +6,38 @@ 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)
+            try
             {
-                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)
+                var devicesList = ScreenInterrogatory.GetAllDevices();
+                var devices = devicesList.ToArray();
+
+                string internalName = AppConfig.GetString("internal_display");
+
+                foreach (var device in devices)
                 {
-                    Logger.WriteLine("Found external screen: " + device.monitorFriendlyDeviceName + ":" + device.outputTechnology.ToString());
+                    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;
+                    }
 
-                    //Already found one, we do not have to check whether there are more
-                    return true;
                 }
-
+            } catch (Exception ex)
+            {
+                Logger.WriteLine(ex.ToString());
             }
 
             return false;
@@ -31,7 +45,7 @@ namespace GHelper.Helpers
 
         public bool IsClamshellEnabled()
         {
-            return AppConfig.Get("toggle_clamshell_mode") != 0;
+            return AppConfig.Is("toggle_clamshell_mode");
         }
 
         public bool IsChargerConnected()
@@ -39,24 +53,40 @@ namespace GHelper.Helpers
             return SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online;
         }
 
-        public bool IsInClamshellMode()
+        public bool IsClamshellReady()
         {
             return IsExternalDisplayConnected() && IsChargerConnected();
         }
 
         public void ToggleLidAction()
         {
-            if (IsInClamshellMode() && IsClamshellEnabled())
+            if (!IsClamshellEnabled())
             {
-                PowerNative.SetLidAction(0, true);
-                Logger.WriteLine("Engaging Clamshell Mode");
+                return;
+            }
+
+            if (IsClamshellReady())
+            {
+                EnableClamshellMode();
             }
             else
             {
-                PowerNative.SetLidAction(1, true);
-                Logger.WriteLine("Disengaging Clamshell Mode");
+                DisableClamshellMode();
             }
         }
+        public static void DisableClamshellMode()
+        {
+            if (PowerNative.GetLidAction(true) == GetDefaultLidAction()) return;
+            PowerNative.SetLidAction(GetDefaultLidAction(), true);
+            Logger.WriteLine("Disengaging Clamshell Mode");
+        }
+
+        public static void EnableClamshellMode()
+        {
+            if (PowerNative.GetLidAction(true) == 0) return;
+            PowerNative.SetLidAction(0, true);
+            Logger.WriteLine("Engaging Clamshell Mode");
+        }
 
         public void UnregisterDisplayEvents()
         {
@@ -74,6 +104,51 @@ namespace GHelper.Helpers
 
             if (IsClamshellEnabled())
                 ToggleLidAction();
+
+            if (Program.settingsForm.Visible)
+                Program.screenControl.InitScreen();
+
+            if (AppConfig.IsForceMiniled()) 
+                Program.screenControl.InitMiniled();
+
+        }
+
+        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;
         }
     }
 }

app/Helpers/ColorUtilities.cs

@@ -0,0 +1,193 @@
+using System.Runtime.CompilerServices;
+
+namespace GHelper.Helpers
+{
+    public class ColorUtils
+    {
+        // 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);
+        }
+
+        public static Color GetMidColor(Color color1, Color color2)
+        {
+            return Color.FromArgb((color1.R + color2.R) / 2,
+                (color1.G + color2.G) / 2,
+                (color1.B + color2.B) / 2);
+        }
+
+        public static Color GetDominantColor(Bitmap bmp)
+        {
+
+            //Used for tally
+            int r = 0;
+            int g = 0;
+            int b = 0;
+
+            int total = 0;
+
+            for (int x = 0; x < bmp.Width; x++)
+            {
+                for (int y = 0; y < bmp.Height; y++)
+                {
+                    Color clr = bmp.GetPixel(x, y);
+
+                    r += clr.R;
+                    g += clr.G;
+                    b += clr.B;
+
+                    total++;
+                }
+            }
+
+            //Calculate average
+            r /= total;
+            g /= total;
+            b /= total;
+
+            return Color.FromArgb(r, g, b);
+        }
+
+        public class HSV
+        {
+            public double Hue { get; set; }
+            public double Saturation { get; set; }
+            public double Value { get; set; }
+
+            public Color ToRGB()
+            {
+                var hue = Hue * 6;
+                var saturation = Saturation;
+                var value = Value;
+
+                double red;
+                double green;
+                double blue;
+
+                if (saturation == 0)
+                {
+                    red = green = blue = value;
+                }
+                else
+                {
+                    var i = Convert.ToInt32(Math.Floor(hue));
+                    var f = hue - i;
+                    var p = value * (1 - saturation);
+                    var q = value * (1 - saturation * f);
+                    var t = value * (1 - saturation * (1 - f));
+                    int mod = i % 6;
+
+                    red = new[] { value, q, p, p, t, value }[mod];
+                    green = new[] { t, value, value, q, p, p }[mod];
+                    blue = new[] { p, p, t, value, value, q }[mod];
+                }
+
+                return Color.FromArgb(Convert.ToInt32(red * 255), Convert.ToInt32(green * 255), Convert.ToInt32(blue * 255));
+            }
+
+            public static HSV ToHSV(Color rgb)
+            {
+                double red = rgb.R / 255.0;
+                double green = rgb.G / 255.0;
+                double blue = rgb.B / 255.0;
+                var min = Math.Min(red, Math.Min(green, blue));
+                var max = Math.Max(red, Math.Max(green, blue));
+                var delta = max - min;
+                double hue;
+                double saturation = 0;
+                var value = max;
+
+                if (max != 0)
+                    saturation = delta / max;
+
+                if (delta == 0)
+                    hue = 0;
+                else
+                {
+                    if (red == max)
+                        hue = (green - blue) / delta + (green < blue ? 6 : 0);
+                    else if (green == max)
+                        hue = 2 + (blue - red) / delta;
+                    else
+                        hue = 4 + (red - green) / delta;
+
+                    hue /= 6;
+                }
+
+                return new HSV { Hue = hue, Saturation = saturation, Value = value };
+            }
+
+            public static Color UpSaturation(Color rgb, float increse = 0.2f) //make color more colored
+            {
+                if (rgb.R == rgb.G && rgb.G == rgb.B)
+                    return rgb;
+                var hsv_color = ToHSV(rgb);
+                hsv_color.Saturation = Math.Min(hsv_color.Saturation + increse, 1.00f);
+                return hsv_color.ToRGB();
+            }
+
+        }
+
+        public class SmoothColor
+        {
+            public Color RGB
+            {
+                get { return Interpolate(); }
+                set { clr = value; }
+            }
+
+            Color Interpolate()
+            {
+                clr_ = ColorInterpolator.InterpolateBetween(clr, clr_, smooth);
+                return clr_;
+            }
+
+            private float smooth = 0.65f; //smooth
+            private Color clr = new Color();
+            private Color clr_ = new Color();
+
+            static class ColorInterpolator
+            {
+                delegate byte ComponentSelector(Color color);
+                static ComponentSelector _redSelector = color => color.R;
+                static ComponentSelector _greenSelector = color => color.G;
+                static ComponentSelector _blueSelector = color => color.B;
+
+                public static Color InterpolateBetween(Color endPoint1, Color endPoint2, double lambda)
+                {
+                    if (lambda < 0 || lambda > 1)
+                        throw new ArgumentOutOfRangeException("lambda");
+
+                    if (endPoint1 != endPoint2)
+                    {
+                        return Color.FromArgb(
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _redSelector),
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _greenSelector),
+                        InterpolateComponent(endPoint1, endPoint2, lambda, _blueSelector)
+                        );
+                    }
+
+                    return endPoint1;
+                }
+
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                static byte InterpolateComponent(Color end1, Color end2, double lambda, ComponentSelector selector)
+                {
+                    return (byte)(selector(end1) + (selector(end2) - selector(end1)) * lambda);
+                }
+            }
+
+        }
+    }
+
+}

app/Helpers/DynamicLightingHelper.cs

@@ -0,0 +1,26 @@
+using Microsoft.Win32;
+
+namespace GHelper.Helpers
+{
+    public static class DynamicLightingHelper
+    {
+
+        public static bool IsEnabled()
+        {
+            if (Environment.OSVersion.Version.Build < 22000) return false;
+
+            using var key = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Lighting");
+            var registryValueObject = key?.GetValue("AmbientLightingEnabled");
+
+            if (registryValueObject == null) return true;
+            return (int)registryValueObject > 0;
+        }
+
+        public static void OpenSettings()
+        {
+            ProcessHelper.RunCMD("explorer","ms-settings:personalization-lighting");
+        }
+
+
+    }
+}

app/Helpers/Logger.cs

@@ -30,7 +30,7 @@ public static class Logger
         try
         {
             var file = File.ReadAllLines(logFile);
-            int skip = Math.Max(0, file.Count() - 1000);
+            int skip = Math.Max(0, file.Count() - 2000);
             File.WriteAllLines(logFile, file.Skip(skip).ToArray());
         }
         catch { }

app/Helpers/OnScreenKeyboard.cs

@@ -0,0 +1,176 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace GHelper.Helpers
+{
+    public static class OnScreenKeyboard
+    {
+        static OnScreenKeyboard()
+        {
+            var version = Environment.OSVersion.Version;
+            switch (version.Major)
+            {
+                case 6:
+                    switch (version.Minor)
+                    {
+                        case 2:
+                            // Windows 10 (ok)
+                            break;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        private static void StartTabTip()
+        {
+            var p = Process.Start(@"C:\Program Files\Common Files\Microsoft Shared\ink\TabTip.exe");
+            int handle = 0;
+            while ((handle = NativeMethods.FindWindow("IPTIP_Main_Window", "")) <= 0)
+            {
+                Thread.Sleep(100);
+            }
+        }
+
+        public static void ToggleVisibility()
+        {
+            var type = Type.GetTypeFromCLSID(Guid.Parse("4ce576fa-83dc-4F88-951c-9d0782b4e376"));
+            var instance = (ITipInvocation)Activator.CreateInstance(type);
+            instance.Toggle(NativeMethods.GetDesktopWindow());
+            Marshal.ReleaseComObject(instance);
+        }
+
+        public static void Show()
+        {
+            int handle = NativeMethods.FindWindow("IPTIP_Main_Window", "");
+            if (handle <= 0) // nothing found
+            {
+                StartTabTip();
+                Thread.Sleep(100);
+            }
+            // on some devices starting TabTip don't show keyboard, on some does  ¯\_(ツ)_/¯
+            if (!IsOpen())
+            {
+                ToggleVisibility();
+            }
+        }
+
+        public static void Hide()
+        {
+            if (IsOpen())
+            {
+                ToggleVisibility();
+            }
+        }
+
+
+        public static bool Close()
+        {
+            // find it
+            int handle = NativeMethods.FindWindow("IPTIP_Main_Window", "");
+            bool active = handle > 0;
+            if (active)
+            {
+                // don't check style - just close
+                NativeMethods.SendMessage(handle, NativeMethods.WM_SYSCOMMAND, NativeMethods.SC_CLOSE, 0);
+            }
+            return active;
+        }
+
+        public static bool IsOpen()
+        {
+            return GetIsOpen1709() ?? GetIsOpenLegacy();
+        }
+
+
+        [DllImport("user32.dll", SetLastError = false)]
+        private static extern IntPtr FindWindowEx(IntPtr parent, IntPtr after, string className, string title = null);
+
+        [DllImport("user32.dll", SetLastError = false)]
+        private static extern uint GetWindowLong(IntPtr wnd, int index);
+
+        private static bool? GetIsOpen1709()
+        {
+            // if there is a top-level window - the keyboard is closed
+            var wnd = FindWindowEx(IntPtr.Zero, IntPtr.Zero, WindowClass1709, WindowCaption1709);
+            if (wnd != IntPtr.Zero)
+                return false;
+
+            var parent = IntPtr.Zero;
+            for (; ; )
+            {
+                parent = FindWindowEx(IntPtr.Zero, parent, WindowParentClass1709);
+                if (parent == IntPtr.Zero)
+                    return null; // no more windows, keyboard state is unknown
+
+                // if it's a child of a WindowParentClass1709 window - the keyboard is open
+                wnd = FindWindowEx(parent, IntPtr.Zero, WindowClass1709, WindowCaption1709);
+                if (wnd != IntPtr.Zero)
+                    return true;
+            }
+        }
+
+        private static bool GetIsOpenLegacy()
+        {
+            var wnd = FindWindowEx(IntPtr.Zero, IntPtr.Zero, WindowClass);
+            if (wnd == IntPtr.Zero)
+                return false;
+
+            var style = GetWindowStyle(wnd);
+            return style.HasFlag(WindowStyle.Visible)
+                && !style.HasFlag(WindowStyle.Disabled);
+        }
+
+        private const string WindowClass = "IPTip_Main_Window";
+        private const string WindowParentClass1709 = "ApplicationFrameWindow";
+        private const string WindowClass1709 = "Windows.UI.Core.CoreWindow";
+        private const string WindowCaption1709 = "Microsoft Text Input Application";
+
+        private enum WindowStyle : uint
+        {
+            Disabled = 0x08000000,
+            Visible = 0x10000000,
+        }
+
+        private static WindowStyle GetWindowStyle(IntPtr wnd)
+        {
+            return (WindowStyle)GetWindowLong(wnd, -16);
+        }
+
+    }
+
+
+    [ComImport]
+    [Guid("37c994e7-432b-4834-a2f7-dce1f13b834b")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface ITipInvocation
+    {
+        void Toggle(IntPtr hwnd);
+    }
+
+    internal static class NativeMethods
+    {
+        [DllImport("user32.dll", EntryPoint = "FindWindow")]
+        internal static extern int FindWindow(string lpClassName, string lpWindowName);
+
+        [DllImport("user32.dll", EntryPoint = "SendMessage")]
+        internal static extern int SendMessage(int hWnd, uint Msg, int wParam, int lParam);
+
+        [DllImport("user32.dll", EntryPoint = "GetDesktopWindow", SetLastError = false)]
+        internal static extern IntPtr GetDesktopWindow();
+
+        [DllImport("user32.dll", EntryPoint = "GetWindowLong")]
+        internal static extern int GetWindowLong(int hWnd, int nIndex);
+
+        internal const int GWL_STYLE = -16;
+        internal const int GWL_EXSTYLE = -20;
+        internal const int WM_SYSCOMMAND = 0x0112;
+        internal const int SC_CLOSE = 0xF060;
+
+        internal const int WS_DISABLED = 0x08000000;
+
+        internal const int WS_VISIBLE = 0x10000000;
+
+    }
+}

app/Helpers/OptimizationService.cs

@@ -1,7 +1,4 @@
-using Microsoft.Win32;
-using System.Diagnostics;
-using System.Text;
-using System.Text.RegularExpressions;
+using System.Diagnostics;
 
 namespace GHelper.Helpers
 {
@@ -10,51 +7,44 @@ namespace GHelper.Helpers
 
         static List<string> services = new() {
                 "ArmouryCrateControlInterface",
+                "AsHidService",
                 "ASUSOptimization",
                 "AsusAppService",
                 "ASUSLinkNear",
                 "ASUSLinkRemote",
                 "ASUSSoftwareManager",
+                "ASUSLiveUpdateAgent",
                 "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";
+        //"AsusPTPService",
 
+        static List<string> processesAC = new() {
+                "ArmouryCrateSE.Service",
+                "ArmouryCrate.Service",
+                "LightingService",
+        };
 
-            // 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);
-            }
-        }
+        static List<string> servicesAC = new() {
+                "ArmouryCrateSEService",
+                "ArmouryCrateService",
+                "LightingService",
+        };
 
         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;
@@ -62,35 +52,37 @@ namespace GHelper.Helpers
             {
                 if (Process.GetProcessesByName(service).Count() > 0) count++;
             }
+
+            if (AppConfig.IsStopAC())
+                foreach (string service in processesAC)
+                {
+                    if (Process.GetProcessesByName(service).Count() > 0)
+                    {
+                        count++;
+                        Logger.WriteLine(service);
+                    }
+                }
+
             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);
             }
+
+            if (AppConfig.IsStopAC())
+            {
+                foreach (string service in servicesAC)
+                {
+                    ProcessHelper.StopDisableService(service, "Manual");
+                }
+                Thread.Sleep(1000);
+            }
+
         }
 
         public static void StartAsusServices()
@@ -99,6 +91,16 @@ namespace GHelper.Helpers
             {
                 ProcessHelper.StartEnableService(service);
             }
+
+            if (AppConfig.IsStopAC())
+            {
+                foreach (string service in servicesAC)
+                {
+                    ProcessHelper.StartEnableService(service);
+                }
+                Thread.Sleep(1000);
+            }
+
         }
 
     }

app/Helpers/ProcessHelper.cs

@@ -37,14 +37,14 @@ namespace GHelper.Helpers
             return principal.IsInRole(WindowsBuiltInRole.Administrator);
         }
 
-        public static void RunAsAdmin(string? param = null)
+        public static void RunAsAdmin(string? param = null, bool force = false)
         {
 
             if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAdmin) < 2000) return;
             lastAdmin = DateTimeOffset.Now.ToUnixTimeMilliseconds();
 
             // Check if the current user is an administrator
-            if (!IsUserAdministrator())
+            if (!IsUserAdministrator() || force)
             {
                 ProcessStartInfo startInfo = new ProcessStartInfo();
                 startInfo.UseShellExecute = true;
@@ -94,11 +94,11 @@ namespace GHelper.Helpers
             }
         }
 
-        public static void StopDisableService(string serviceName)
+        public static void StopDisableService(string serviceName, string disable = "Disabled")
         {
             try
             {
-                string script = $"Get-Service -Name \"{serviceName}\" | Stop-Service -Force -PassThru | Set-Service -StartupType Disabled";
+                string script = $"Get-Service -Name \"{serviceName}\" | Stop-Service -Force -PassThru | Set-Service -StartupType {disable}";
                 Logger.WriteLine(script);
                 RunCMD("powershell", script);
             }
@@ -122,7 +122,7 @@ namespace GHelper.Helpers
             }
         }
 
-        public static void RunCMD(string name, string args)
+        public static string RunCMD(string name, string args)
         {
             var cmd = new Process();
             cmd.StartInfo.UseShellExecute = false;
@@ -132,8 +132,14 @@ namespace GHelper.Helpers
             cmd.StartInfo.FileName = name;
             cmd.StartInfo.Arguments = args;
             cmd.Start();
-            Logger.WriteLine(cmd.StandardOutput.ReadToEnd());
+
+            Logger.WriteLine(name + " " + args);
+            string result = cmd.StandardOutput.ReadToEnd().Replace(Environment.NewLine, " ").Trim(' ');
+            Logger.WriteLine(result);
+            
             cmd.WaitForExit();
+
+            return result;
         }
 
 

app/Helpers/RestrictedProcessHelper.cs

@@ -0,0 +1,376 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class RestrictedProcessHelper
+{
+    /// Runs a process as a non-elevated version of the current user.
+    public static Process? RunAsRestrictedUser(string fileName, string? args = null)
+    {
+        if (string.IsNullOrWhiteSpace(fileName))
+            throw new ArgumentException("Value cannot be null or whitespace.", nameof(fileName));
+
+        if (!GetRestrictedSessionUserToken(out var hRestrictedToken))
+        {
+            return null;
+        }
+
+        try
+        {
+            var si = new STARTUPINFO();
+            si.cb = Marshal.SizeOf(si);
+            si.dwFlags = 0x1;
+            si.wShowWindow = 0x00; // Set the window to be hidden
+
+            var pi = new PROCESS_INFORMATION();
+            var cmd = new StringBuilder();
+            cmd.Append('"').Append(fileName).Append('"');
+            if (!string.IsNullOrWhiteSpace(args))
+            {
+                cmd.Append(' ').Append(args);
+            }
+
+            Logger.WriteLine($"Launching {cmd}");
+
+            if (!CreateProcessAsUser(
+                hRestrictedToken,
+                null,
+                cmd,
+                IntPtr.Zero,
+                IntPtr.Zero,
+                true, // inherit handle
+                0,
+                IntPtr.Zero,
+                Path.GetDirectoryName(fileName),
+                ref si,
+                out pi))
+            {
+                return null;
+            }
+
+            return Process.GetProcessById(pi.dwProcessId);
+        }
+        finally
+        {
+            CloseHandle(hRestrictedToken);
+        }
+    }
+
+    private static bool GetRestrictedSessionUserToken(out IntPtr token)
+    {
+        token = IntPtr.Zero;
+        if (!SaferCreateLevel(SaferScope.User, SaferLevel.NormalUser, SaferOpenFlags.Open, out var hLevel, IntPtr.Zero))
+        {
+            return false;
+        }
+
+        IntPtr hRestrictedToken = IntPtr.Zero;
+        TOKEN_MANDATORY_LABEL tml = default;
+        tml.Label.Sid = IntPtr.Zero;
+        IntPtr tmlPtr = IntPtr.Zero;
+
+        try
+        {
+            if (!SaferComputeTokenFromLevel(hLevel, IntPtr.Zero, out hRestrictedToken, 0, IntPtr.Zero))
+            {
+                return false;
+            }
+
+            // Set the token to medium integrity.
+            tml.Label.Attributes = SE_GROUP_INTEGRITY;
+            tml.Label.Sid = IntPtr.Zero;
+            if (!ConvertStringSidToSid("S-1-16-8192", out tml.Label.Sid))
+            {
+                return false;
+            }
+
+            tmlPtr = Marshal.AllocHGlobal(Marshal.SizeOf(tml));
+            Marshal.StructureToPtr(tml, tmlPtr, false);
+            if (!SetTokenInformation(hRestrictedToken,
+                TOKEN_INFORMATION_CLASS.TokenIntegrityLevel,
+                tmlPtr, (uint)Marshal.SizeOf(tml)))
+            {
+                return false;
+            }
+
+            token = hRestrictedToken;
+            hRestrictedToken = IntPtr.Zero; // make sure finally() doesn't close the handle
+        }
+        finally
+        {
+            SaferCloseLevel(hLevel);
+            SafeCloseHandle(hRestrictedToken);
+            if (tml.Label.Sid != IntPtr.Zero)
+            {
+                LocalFree(tml.Label.Sid);
+            }
+            if (tmlPtr != IntPtr.Zero)
+            {
+                Marshal.FreeHGlobal(tmlPtr);
+            }
+        }
+
+        return true;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct PROCESS_INFORMATION
+    {
+        public IntPtr hProcess;
+        public IntPtr hThread;
+        public int dwProcessId;
+        public int dwThreadId;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    private struct STARTUPINFO
+    {
+        public Int32 cb;
+        public string lpReserved;
+        public string lpDesktop;
+        public string lpTitle;
+        public Int32 dwX;
+        public Int32 dwY;
+        public Int32 dwXSize;
+        public Int32 dwYSize;
+        public Int32 dwXCountChars;
+        public Int32 dwYCountChars;
+        public Int32 dwFillAttribute;
+        public Int32 dwFlags;
+        public Int16 wShowWindow;
+        public Int16 cbReserved2;
+        public IntPtr lpReserved2;
+        public IntPtr hStdInput;
+        public IntPtr hStdOutput;
+        public IntPtr hStdError;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct SID_AND_ATTRIBUTES
+    {
+        public IntPtr Sid;
+        public uint Attributes;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct TOKEN_MANDATORY_LABEL
+    {
+        public SID_AND_ATTRIBUTES Label;
+    }
+
+    public enum SaferLevel : uint
+    {
+        Disallowed = 0,
+        Untrusted = 0x1000,
+        Constrained = 0x10000,
+        NormalUser = 0x20000,
+        FullyTrusted = 0x40000
+    }
+
+    public enum SaferScope : uint
+    {
+        Machine = 1,
+        User = 2
+    }
+
+    [Flags]
+    public enum SaferOpenFlags : uint
+    {
+        Open = 1
+    }
+
+    [DllImport("advapi32", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
+    private static extern bool SaferCreateLevel(SaferScope scope, SaferLevel level, SaferOpenFlags openFlags, out IntPtr pLevelHandle, IntPtr lpReserved);
+
+    [DllImport("advapi32", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
+    private static extern bool SaferComputeTokenFromLevel(IntPtr LevelHandle, IntPtr InAccessToken, out IntPtr OutAccessToken, int dwFlags, IntPtr lpReserved);
+
+    [DllImport("advapi32", SetLastError = true)]
+    private static extern bool SaferCloseLevel(IntPtr hLevelHandle);
+
+    [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+    private static extern bool ConvertStringSidToSid(string StringSid, out IntPtr ptrSid);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CloseHandle(IntPtr hObject);
+
+    private static bool SafeCloseHandle(IntPtr hObject)
+    {
+        return (hObject == IntPtr.Zero) ? true : CloseHandle(hObject);
+    }
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern IntPtr LocalFree(IntPtr hMem);
+
+    enum TOKEN_INFORMATION_CLASS
+    {
+        /// <summary>
+        /// The buffer receives a TOKEN_USER structure that contains the user account of the token.
+        /// </summary>
+        TokenUser = 1,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_GROUPS structure that contains the group accounts associated with the token.
+        /// </summary>
+        TokenGroups,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_PRIVILEGES structure that contains the privileges of the token.
+        /// </summary>
+        TokenPrivileges,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_OWNER structure that contains the default owner security identifier (SID) for newly created objects.
+        /// </summary>
+        TokenOwner,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_PRIMARY_GROUP structure that contains the default primary group SID for newly created objects.
+        /// </summary>
+        TokenPrimaryGroup,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_DEFAULT_DACL structure that contains the default DACL for newly created objects.
+        /// </summary>
+        TokenDefaultDacl,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_SOURCE structure that contains the source of the token. TOKEN_QUERY_SOURCE access is needed to retrieve this information.
+        /// </summary>
+        TokenSource,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_TYPE value that indicates whether the token is a primary or impersonation token.
+        /// </summary>
+        TokenType,
+
+        /// <summary>
+        /// The buffer receives a SECURITY_IMPERSONATION_LEVEL value that indicates the impersonation level of the token. If the access token is not an impersonation token, the function fails.
+        /// </summary>
+        TokenImpersonationLevel,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_STATISTICS structure that contains various token statistics.
+        /// </summary>
+        TokenStatistics,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_GROUPS structure that contains the list of restricting SIDs in a restricted token.
+        /// </summary>
+        TokenRestrictedSids,
+
+        /// <summary>
+        /// The buffer receives a DWORD value that indicates the Terminal Services session identifier that is associated with the token.
+        /// </summary>
+        TokenSessionId,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_GROUPS_AND_PRIVILEGES structure that contains the user SID, the group accounts, the restricted SIDs, and the authentication ID associated with the token.
+        /// </summary>
+        TokenGroupsAndPrivileges,
+
+        /// <summary>
+        /// Reserved.
+        /// </summary>
+        TokenSessionReference,
+
+        /// <summary>
+        /// The buffer receives a DWORD value that is nonzero if the token includes the SANDBOX_INERT flag.
+        /// </summary>
+        TokenSandBoxInert,
+
+        /// <summary>
+        /// Reserved.
+        /// </summary>
+        TokenAuditPolicy,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_ORIGIN value.
+        /// </summary>
+        TokenOrigin,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_ELEVATION_TYPE value that specifies the elevation level of the token.
+        /// </summary>
+        TokenElevationType,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_LINKED_TOKEN structure that contains a handle to another token that is linked to this token.
+        /// </summary>
+        TokenLinkedToken,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_ELEVATION structure that specifies whether the token is elevated.
+        /// </summary>
+        TokenElevation,
+
+        /// <summary>
+        /// The buffer receives a DWORD value that is nonzero if the token has ever been filtered.
+        /// </summary>
+        TokenHasRestrictions,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_ACCESS_INFORMATION structure that specifies security information contained in the token.
+        /// </summary>
+        TokenAccessInformation,
+
+        /// <summary>
+        /// The buffer receives a DWORD value that is nonzero if virtualization is allowed for the token.
+        /// </summary>
+        TokenVirtualizationAllowed,
+
+        /// <summary>
+        /// The buffer receives a DWORD value that is nonzero if virtualization is enabled for the token.
+        /// </summary>
+        TokenVirtualizationEnabled,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_MANDATORY_LABEL structure that specifies the token's integrity level.
+        /// </summary>
+        TokenIntegrityLevel,
+
+        /// <summary>
+        /// The buffer receives a DWORD value that is nonzero if the token has the UIAccess flag set.
+        /// </summary>
+        TokenUIAccess,
+
+        /// <summary>
+        /// The buffer receives a TOKEN_MANDATORY_POLICY structure that specifies the token's mandatory integrity policy.
+        /// </summary>
+        TokenMandatoryPolicy,
+
+        /// <summary>
+        /// The buffer receives the token's logon security identifier (SID).
+        /// </summary>
+        TokenLogonSid,
+
+        /// <summary>
+        /// The maximum value for this enumeration
+        /// </summary>
+        MaxTokenInfoClass
+    }
+
+    [DllImport("advapi32.dll", SetLastError = true)]
+    static extern Boolean SetTokenInformation(
+        IntPtr TokenHandle,
+        TOKEN_INFORMATION_CLASS TokenInformationClass,
+        IntPtr TokenInformation,
+        UInt32 TokenInformationLength);
+
+    const uint SE_GROUP_INTEGRITY = 0x00000020;
+
+    [DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+    static extern bool CreateProcessAsUser(
+        IntPtr hToken,
+        string? lpApplicationName,
+        StringBuilder? lpCommandLine,
+        IntPtr lpProcessAttributes,
+        IntPtr lpThreadAttributes,
+        bool bInheritHandles,
+        uint dwCreationFlags,
+        IntPtr lpEnvironment,
+        string? lpCurrentDirectory,
+        ref STARTUPINFO lpStartupInfo,
+        out PROCESS_INFORMATION lpProcessInformation);
+}

app/Helpers/Startup.cs

@@ -1,17 +1,18 @@
 using GHelper.Helpers;
 using Microsoft.Win32.TaskScheduler;
-using System.Diagnostics;
 using System.Security.Principal;
 
 public class Startup
 {
 
     static string taskName = "GHelper";
+    static string chargeTaskName = taskName + "Charge";
+    static string strExeFilePath = Application.ExecutablePath.Trim();
 
     public static bool IsScheduled()
     {
-        TaskService taskService = new TaskService();
-        return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
+        using (TaskService taskService = new TaskService())
+            return (taskService.RootFolder.AllTasks.Any(t => t.Name == taskName));
     }
 
     public static void ReScheduleAdmin()
@@ -23,31 +24,97 @@ public class Startup
         }
     }
 
-    public static void Schedule()
+    public static void StartupCheck()
     {
+        using (TaskService taskService = new TaskService())
+        {
+            var task = taskService.RootFolder.AllTasks.FirstOrDefault(t => t.Name == taskName);
+            if (task != null)
+            {
+                try
+                {
+                    string action = task.Definition.Actions.FirstOrDefault()!.ToString().Trim();
+                    if (!strExeFilePath.Equals(action, StringComparison.OrdinalIgnoreCase) && !File.Exists(action))
+                    {
+                        Logger.WriteLine("File doesn't exist: " + action);
+                        Logger.WriteLine("Rescheduling to: " + strExeFilePath);
+                        UnSchedule();
+                        Schedule();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.WriteLine($"Can't check startup task: {ex.Message}");
+                }
 
-        string strExeFilePath = Application.ExecutablePath;
+                if (taskService.RootFolder.AllTasks.FirstOrDefault(t => t.Name == chargeTaskName) == null) ScheduleCharge();
+
+            }
+        }
+    }
+
+    public static void UnscheduleCharge()
+    {
+        using (TaskService taskService = new TaskService())
+        {
+            try
+            {
+                taskService.RootFolder.DeleteTask(chargeTaskName);
+            }
+            catch (Exception e)
+            {
+                Logger.WriteLine("Can't remove charge limit task: " + e.Message);
+            }
+        }
+    }
+
+    public static void ScheduleCharge()
+    {
 
         if (strExeFilePath is null) return;
 
-        var userId = WindowsIdentity.GetCurrent().Name;
-
         using (TaskDefinition td = TaskService.Instance.NewTask())
         {
+            td.RegistrationInfo.Description = "G-Helper Charge Limit";
+            td.Triggers.Add(new BootTrigger());
+            td.Actions.Add(strExeFilePath, "charge");
 
-            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.Principal.RunLevel = TaskRunLevel.LUA;
+            td.Principal.LogonType = TaskLogonType.S4U;
+            td.Principal.UserId = WindowsIdentity.GetCurrent().Name;
 
             td.Settings.StopIfGoingOnBatteries = false;
             td.Settings.DisallowStartIfOnBatteries = false;
             td.Settings.ExecutionTimeLimit = TimeSpan.Zero;
 
-            Debug.WriteLine(strExeFilePath);
-            Debug.WriteLine(userId);
+            try
+            {
+                TaskService.Instance.RootFolder.RegisterTaskDefinition(chargeTaskName, td);
+                Logger.WriteLine("Charge limit task scheduled: " + strExeFilePath);
+            }
+            catch (Exception e)
+            {
+                Logger.WriteLine("Can't create a charge limit task: " + e.Message);
+            }
+        }
+    }
+
+    public static void Schedule()
+    {
+
+        using (TaskDefinition td = TaskService.Instance.NewTask())
+        {
+
+            td.RegistrationInfo.Description = "G-Helper Auto Start";
+            td.Triggers.Add(new LogonTrigger { UserId = WindowsIdentity.GetCurrent().Name, Delay = TimeSpan.FromSeconds(2) });
+            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;
 
             try
             {
@@ -60,8 +127,12 @@ public class Startup
                 else
                     ProcessHelper.RunAsAdmin();
             }
+
+            Logger.WriteLine("Startup task scheduled: " + strExeFilePath);
         }
 
+        ScheduleCharge();
+
     }
 
     public static void UnSchedule()
@@ -80,5 +151,7 @@ public class Startup
                     ProcessHelper.RunAsAdmin();
             }
         }
+
+        UnscheduleCharge();
     }
 }

app/Helpers/ToastForm.cs

@@ -1,4 +1,5 @@
-using System.Drawing.Drawing2D;
+using System.Diagnostics;
+using System.Drawing.Drawing2D;
 
 namespace GHelper.Helpers
 {
@@ -50,7 +51,8 @@ namespace GHelper.Helpers
         MicrophoneMute,
         FnLock,
         Battery,
-        Charger
+        Charger,
+        Controller
     }
 
     public class ToastForm : OSDNativeForm
@@ -71,6 +73,8 @@ namespace GHelper.Helpers
         protected override void PerformPaint(PaintEventArgs e)
         {
             Brush brush = new SolidBrush(Color.FromArgb(150, Color.Black));
+
+            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
             e.Graphics.FillRoundedRectangle(brush, Bound, 10);
 
             StringFormat format = new StringFormat();
@@ -111,6 +115,9 @@ namespace GHelper.Helpers
                 case ToastIcon.Charger:
                     icon = Properties.Resources.icons8_charging_battery_96;
                     break;
+                case ToastIcon.Controller:
+                    icon = Properties.Resources.icons8_controller_96;
+                    break;
 
             }
 
@@ -130,6 +137,16 @@ namespace GHelper.Helpers
 
         }
 
+        public static void ReadText(string text)
+        {
+            ProcessStartInfo startInfo = new ProcessStartInfo();
+            startInfo.FileName = "PowerShell.exe";
+            startInfo.Arguments = $"-Command \"Add-Type -AssemblyName System.Speech; (New-Object System.Speech.Synthesis.SpeechSynthesizer).Speak('{text}')\"";
+            startInfo.CreateNoWindow = true;
+            Process.Start(startInfo);
+        }
+
+
         public void RunToast(string text, ToastIcon? icon = null)
         {
 
@@ -152,6 +169,14 @@ namespace GHelper.Helpers
 
                 Show();
                 timer.Start();
+
+                //if (AppConfig.Is("narrator")) ReadText(text);
+
+                Program.settingsForm.AccessibilityObject.RaiseAutomationNotification(
+                    System.Windows.Forms.Automation.AutomationNotificationKind.ActionCompleted,
+                    System.Windows.Forms.Automation.AutomationNotificationProcessing.MostRecent,
+                    text);
+
             });
 
         }

app/Helpers/TouchscreenHelper.cs

@@ -0,0 +1,33 @@
+using GHelper.Helpers;
+
+public static class TouchscreenHelper
+{
+
+    public static bool? GetStatus()
+    {
+        try
+        {
+            ProcessHelper.RunAsAdmin();
+            return ProcessHelper.RunCMD("powershell", "(Get-PnpDevice -FriendlyName '*touch*screen*').Status").Contains("OK");
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine($"Can't get touchscreen status: {ex.Message}");
+            return null;
+        }
+    }
+
+    public static void ToggleTouchscreen(bool status)
+    {
+        try
+        {
+            ProcessHelper.RunAsAdmin();
+            ProcessHelper.RunCMD("powershell", (status ? "Enable-PnpDevice" : "Disable-PnpDevice") + " -InstanceId (Get-PnpDevice -FriendlyName '*touch*screen*').InstanceId -Confirm:$false");
+        }
+        catch (Exception ex)
+        {
+            Logger.WriteLine($"Can't toggle touchscreen: {ex.Message}");
+        }
+
+    }
+}

app/Input/KeyboardHook.cs

@@ -17,21 +17,80 @@ public sealed class KeyboardHook : IDisposable
 
     public const int KEYEVENTF_EXTENDEDKEY = 1;
     public const int KEYEVENTF_KEYUP = 2;
+
     private const byte VK_LWIN = 0x5B;
+    private const byte VK_LCONTROL = 0xA2;
+
+    [DllImport("user32.dll")]
+    public static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint cButtons, uint dwExtraInfo);
+    //Mouse actions
+    private const int MOUSEEVENTF_LEFTDOWN = 0x02;
+    private const int MOUSEEVENTF_LEFTUP = 0x04;
+
+    private const int MOUSEEVENTF_RIGHTDOWN = 0x08;
+    private const int MOUSEEVENTF_RIGHTUP = 0x10;
+
+    private const int MOUSEEVENTF_MIDDOWN = 0x20;
+    private const int MOUSEEVENTF_MIDTUP = 0x40;
 
     public static void KeyPress(Keys key)
     {
-        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
-    }
+        switch (key)
+        {
+            case Keys.LButton:
+                mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, (uint)Cursor.Position.X, (uint)Cursor.Position.Y, 0, 0);
+                return;
+            case Keys.RButton:
+                mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, (uint)Cursor.Position.X, (uint)Cursor.Position.Y, 0, 0);
+                return;
+            case Keys.MButton:
+                mouse_event(MOUSEEVENTF_MIDDOWN | MOUSEEVENTF_MIDTUP, (uint)Cursor.Position.X, (uint)Cursor.Position.Y, 0, 0);
+                return;
+        }
 
-    public static void KeyWinPress(Keys key)
-    {
-        keybd_event(VK_LWIN, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
         keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        Thread.Sleep(1);
         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 KeyKeyPress(Keys key, Keys key2)
+    {
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+
+        Thread.Sleep(1);
+
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+    }
+
+    public static void KeyKeyKeyPress(Keys key, Keys key2, Keys key3, int sleep = 1)
+    {
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+
+        Thread.Sleep(sleep);
+
+        keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+    }
+
+    public static void KeyKeyKeyKeyPress(Keys key, Keys key2, Keys key3, Keys key4, int sleep = 1)
+    {
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+        keybd_event((byte)key4, 0, KEYEVENTF_EXTENDEDKEY, IntPtr.Zero);
+
+        Thread.Sleep(sleep);
+
+        keybd_event((byte)key4, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key3, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key2, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+        keybd_event((byte)key, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, IntPtr.Zero);
+    }
 
     /// <summary>
     /// Represents the window that is used internally to get the messages.

app/Input/KeyboardListener.cs

@@ -1,4 +1,6 @@
-using HidLibrary;
+using GHelper.USB;
+using HidSharp;
+using System.Text;
 
 namespace GHelper.Input
 {
@@ -6,17 +8,28 @@ namespace GHelper.Input
     {
 
         CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+        Action<int> _handler;
+
+        static int retry = 0;
 
         public KeyboardListener(Action<int> KeyHandler)
         {
-            HidDevice? input = AsusUSB.GetDevice();
-            
+            _handler = KeyHandler;
+            var task = Task.Run(Listen);
+        }
+
+        private void Listen()
+        {
+
+            HidStream? input = AsusHid.FindHidStream(AsusHid.INPUT_ID);
+
             // Fallback
-            if (input == null)
+            int count = 0;
+
+            while (input == null && count++ < 10)
             {
-                AsusUSB.Init();
                 Thread.Sleep(1000);
-                input = AsusUSB.GetDevice();
+                input = AsusHid.FindHidStream(AsusHid.INPUT_ID);
             }
 
             if (input == null)
@@ -25,39 +38,45 @@ namespace GHelper.Input
                 return;
             }
 
-            Logger.WriteLine($"Input: {input.DevicePath}");
+            AsusHid.WriteInput(Encoding.ASCII.GetBytes("ZASUS Tech.Inc."));
+            Logger.WriteLine($"Input: {input.Device.DevicePath}");
 
-            var task = Task.Run(() =>
+            try
             {
-                try
+                while (!cancellationTokenSource.Token.IsCancellationRequested)
                 {
-                    while (!cancellationTokenSource.Token.IsCancellationRequested)
+
+                    // Emergency break
+                    if (input == null || !input.CanRead)
                     {
-
-                        // 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 terminated");
+                        break;
                     }
 
-                    Logger.WriteLine("Listener stopped");
+                    input.ReadTimeout = int.MaxValue;
 
+                    var data = input.Read();
+                    if (cancellationTokenSource.Token.IsCancellationRequested) break;
+                    if (data.Length > 1 && data[0] == AsusHid.INPUT_ID && data[1] > 0 && data[1] != 236)
+                    {
+                        Logger.WriteLine($"Key: {data[1]}");
+                        _handler(data[1]);
+                    }
                 }
-                catch (Exception ex)
+
+                Logger.WriteLine("Listener stopped");
+
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine($"Listener exited: {ex.Message}");
+                if (retry++ < 2)
                 {
-                    Logger.WriteLine(ex.ToString());
+                    Thread.Sleep(300);
+                    Logger.WriteLine($"Restarting listener {retry}");
+                    Listen();
                 }
-            });
-
+            }
 
         }
 

app/Matrix.Designer.cs

@@ -0,0 +1,425 @@
+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();
+            panelGamma = new Panel();
+            labelGamma = new Label();
+            labelGammaTitle = new Label();
+            trackGamma = new TrackBar();
+            panelContrast = new Panel();
+            labelContrast = new Label();
+            labelContrastTitle = new Label();
+            trackContrast = new TrackBar();
+            panelRotation = new Panel();
+            comboRotation = new UI.RComboBox();
+            labelRotation = new Label();
+            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();
+            panelGamma.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGamma).BeginInit();
+            panelContrast.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)trackContrast).BeginInit();
+            panelRotation.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.AutoSize = true;
+            panelMain.Controls.Add(panelButtons);
+            panelMain.Controls.Add(panelGamma);
+            panelMain.Controls.Add(panelContrast);
+            panelMain.Controls.Add(panelRotation);
+            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, 1104);
+            panelMain.TabIndex = 5;
+            // 
+            // panelButtons
+            // 
+            panelButtons.Controls.Add(buttonReset);
+            panelButtons.Controls.Add(buttonPicture);
+            panelButtons.Dock = DockStyle.Top;
+            panelButtons.Location = new Point(0, 1010);
+            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;
+            // 
+            // panelGamma
+            // 
+            panelGamma.AutoSize = true;
+            panelGamma.Controls.Add(labelGamma);
+            panelGamma.Controls.Add(labelGammaTitle);
+            panelGamma.Controls.Add(trackGamma);
+            panelGamma.Dock = DockStyle.Top;
+            panelGamma.Location = new Point(0, 865);
+            panelGamma.Name = "panelGamma";
+            panelGamma.Size = new Size(834, 145);
+            panelGamma.TabIndex = 7;
+            // 
+            // labelGamma
+            // 
+            labelGamma.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelGamma.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            labelGamma.Location = new Point(673, 17);
+            labelGamma.Name = "labelGamma";
+            labelGamma.Size = new Size(125, 32);
+            labelGamma.TabIndex = 4;
+            labelGamma.Text = "Brightness";
+            labelGamma.TextAlign = ContentAlignment.TopRight;
+            // 
+            // labelGammaTitle
+            // 
+            labelGammaTitle.AutoSize = true;
+            labelGammaTitle.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelGammaTitle.Location = new Point(16, 17);
+            labelGammaTitle.Name = "labelGammaTitle";
+            labelGammaTitle.Size = new Size(134, 32);
+            labelGammaTitle.TabIndex = 3;
+            labelGammaTitle.Text = "Brightness";
+            // 
+            // trackGamma
+            // 
+            trackGamma.LargeChange = 50;
+            trackGamma.Location = new Point(16, 52);
+            trackGamma.Maximum = 100;
+            trackGamma.Minimum = -100;
+            trackGamma.Name = "trackGamma";
+            trackGamma.Size = new Size(782, 90);
+            trackGamma.SmallChange = 10;
+            trackGamma.TabIndex = 2;
+            trackGamma.TickFrequency = 20;
+            trackGamma.TickStyle = TickStyle.TopLeft;
+            // 
+            // panelContrast
+            // 
+            panelContrast.AutoSize = true;
+            panelContrast.Controls.Add(labelContrast);
+            panelContrast.Controls.Add(labelContrastTitle);
+            panelContrast.Controls.Add(trackContrast);
+            panelContrast.Dock = DockStyle.Top;
+            panelContrast.Location = new Point(0, 720);
+            panelContrast.Name = "panelContrast";
+            panelContrast.Size = new Size(834, 145);
+            panelContrast.TabIndex = 6;
+            // 
+            // labelContrast
+            // 
+            labelContrast.Anchor = AnchorStyles.Top | AnchorStyles.Right;
+            labelContrast.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            labelContrast.Location = new Point(701, 17);
+            labelContrast.Name = "labelContrast";
+            labelContrast.Size = new Size(103, 32);
+            labelContrast.TabIndex = 4;
+            labelContrast.Text = "Contrast";
+            labelContrast.TextAlign = ContentAlignment.TopRight;
+            // 
+            // labelContrastTitle
+            // 
+            labelContrastTitle.AutoSize = true;
+            labelContrastTitle.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelContrastTitle.Location = new Point(16, 17);
+            labelContrastTitle.Name = "labelContrastTitle";
+            labelContrastTitle.Size = new Size(111, 32);
+            labelContrastTitle.TabIndex = 3;
+            labelContrastTitle.Text = "Contrast";
+            // 
+            // trackContrast
+            // 
+            trackContrast.LargeChange = 50;
+            trackContrast.Location = new Point(16, 52);
+            trackContrast.Maximum = 200;
+            trackContrast.Minimum = 10;
+            trackContrast.Name = "trackContrast";
+            trackContrast.Size = new Size(782, 90);
+            trackContrast.SmallChange = 10;
+            trackContrast.TabIndex = 2;
+            trackContrast.TickFrequency = 20;
+            trackContrast.TickStyle = TickStyle.TopLeft;
+            trackContrast.Value = 100;
+            // 
+            // panelRotation
+            // 
+            panelRotation.Controls.Add(comboRotation);
+            panelRotation.Controls.Add(labelRotation);
+            panelRotation.Dock = DockStyle.Top;
+            panelRotation.Location = new Point(0, 642);
+            panelRotation.Name = "panelRotation";
+            panelRotation.Size = new Size(834, 78);
+            panelRotation.TabIndex = 8;
+            // 
+            // comboRotation
+            // 
+            comboRotation.BorderColor = Color.White;
+            comboRotation.ButtonColor = Color.FromArgb(255, 255, 255);
+            comboRotation.Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
+            comboRotation.FormattingEnabled = true;
+            comboRotation.ItemHeight = 32;
+            comboRotation.Items.AddRange(new object[] { "Straight", "Diagonal" });
+            comboRotation.Location = new Point(279, 17);
+            comboRotation.Margin = new Padding(4, 11, 4, 8);
+            comboRotation.Name = "comboRotation";
+            comboRotation.Size = new Size(322, 40);
+            comboRotation.TabIndex = 17;
+            // 
+            // labelRotation
+            // 
+            labelRotation.AutoSize = true;
+            labelRotation.Font = new Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point);
+            labelRotation.Location = new Point(16, 20);
+            labelRotation.Name = "labelRotation";
+            labelRotation.Size = new Size(190, 32);
+            labelRotation.TabIndex = 4;
+            labelRotation.Text = "Image Rotation";
+            // 
+            // 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(279, 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, 1142);
+            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);
+            panelGamma.ResumeLayout(false);
+            panelGamma.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackGamma).EndInit();
+            panelContrast.ResumeLayout(false);
+            panelContrast.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)trackContrast).EndInit();
+            panelRotation.ResumeLayout(false);
+            panelRotation.PerformLayout();
+            panelScaling.ResumeLayout(false);
+            panelScaling.PerformLayout();
+            panelZoom.ResumeLayout(false);
+            panelZoom.PerformLayout();
+            ResumeLayout(false);
+            PerformLayout();
+        }
+
+        #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;
+        private Panel panelRotation;
+        private UI.RComboBox comboRotation;
+        private Label labelRotation;
+        private Panel panelContrast;
+        private Label labelContrast;
+        private Label labelContrastTitle;
+        private TrackBar trackContrast;
+        private Panel panelGamma;
+        private Label labelGamma;
+        private Label labelGammaTitle;
+        private TrackBar trackGamma;
+    }
+}

app/Matrix.cs

@@ -0,0 +1,257 @@
+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);
+
+            Text = Properties.Strings.AnimeMatrix;
+            labelZoomTitle.Text = Properties.Strings.Zoom;
+            labelScaling.Text = Properties.Strings.ScalingQuality;
+            labelRotation.Text = Properties.Strings.ImageRotation;
+            labelContrastTitle.Text = Properties.Strings.Contrast;
+            labelGammaTitle.Text = Properties.Strings.Brightness;
+            buttonPicture.Text = Properties.Strings.PictureGif;
+            buttonReset.Text = Properties.Strings.Reset;
+
+            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));
+
+            trackContrast.MouseUp += TrackMatrix_MouseUp;
+            trackContrast.ValueChanged += TrackMatrix_ValueChanged;
+            trackContrast.Value = Math.Min(trackContrast.Maximum, AppConfig.Get("matrix_contrast", 100));
+
+            trackGamma.MouseUp += TrackMatrix_MouseUp;
+            trackGamma.ValueChanged += TrackMatrix_ValueChanged;
+            trackGamma.Value = Math.Min(trackGamma.Maximum, AppConfig.Get("matrix_gamma", 0));
+
+            VisualiseMatrix();
+
+            comboScaling.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboScaling.SelectedIndex = AppConfig.Get("matrix_quality", 0);
+            comboScaling.SelectedValueChanged += ComboScaling_SelectedValueChanged;
+
+            comboRotation.DropDownStyle = ComboBoxStyle.DropDownList;
+            comboRotation.SelectedIndex = AppConfig.Get("matrix_rotation", 0);
+            comboRotation.SelectedValueChanged += ComboRotation_SelectedValueChanged; ;
+
+
+            uiScale = panelPicture.Width / matrixControl.deviceMatrix.MaxColumns / 3;
+            panelPicture.Height = (int)(matrixControl.deviceMatrix.MaxRows * uiScale);
+
+        }
+
+        private void TrackMatrix_ValueChanged(object? sender, EventArgs e)
+        {
+            VisualiseMatrix();
+        }
+
+        private void TrackMatrix_MouseUp(object? sender, MouseEventArgs e)
+        {
+            AppConfig.Set("matrix_contrast", trackContrast.Value);
+            AppConfig.Set("matrix_gamma", trackGamma.Value);
+            SetMatrixPicture(false);
+        }
+
+
+        private void ComboRotation_SelectedValueChanged(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_rotation", comboRotation.SelectedIndex);
+            SetMatrixPicture(false);
+        }
+
+        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 VisualiseMatrix()
+        {
+            labelZoom.Text = trackZoom.Value + "%";
+            labelContrast.Text = trackContrast.Value + "%";
+            labelGamma.Text = trackGamma.Value + "%";
+        }
+
+        private void ButtonReset_Click(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_gamma", 0);
+            AppConfig.Set("matrix_contrast", 100);
+            AppConfig.Set("matrix_zoom", 100);
+            AppConfig.Set("matrix_x", 0);
+            AppConfig.Set("matrix_y", 0);
+
+            trackZoom.Value = 100;
+            trackContrast.Value = 100;
+            trackGamma.Value = 0;
+
+            SetMatrixPicture();
+
+        }
+
+        private void TrackZoom_MouseUp(object? sender, EventArgs e)
+        {
+            AppConfig.Set("matrix_zoom", trackZoom.Value);
+            SetMatrixPicture();
+        }
+
+        private void TrackZoom_Changed(object? sender, EventArgs e)
+        {
+            VisualiseMatrix();
+        }
+
+
+        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;
+
+
+            }
+
+
+
+
+        }
+
+    }
+}

app/Matrix.resx

@@ -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>

app/Mode/ModeControl.cs

@@ -1,6 +1,6 @@
-using GHelper.Battery;
-using GHelper.Gpu.NVidia;
+using GHelper.Gpu.NVidia;
 using GHelper.Helpers;
+using GHelper.USB;
 using Ryzen;
 
 namespace GHelper.Mode
@@ -15,19 +15,23 @@ namespace GHelper.Mode
 
         private int _cpuUV = 0;
         private int _igpuUV = 0;
+        private bool _ryzenPower = false;
 
         static System.Timers.Timer reapplyTimer = default!;
+        static System.Timers.Timer modeToggleTimer = default!;
 
         public ModeControl()
         {
             reapplyTimer = new System.Timers.Timer(AppConfig.GetMode("reapply_time", 30) * 1000);
-            reapplyTimer.Elapsed += ReapplyTimer_Elapsed;
             reapplyTimer.Enabled = false;
+            reapplyTimer.Elapsed += ReapplyTimer_Elapsed;
         }
 
+
         private void ReapplyTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
         {
-            SetCPUTemp(AppConfig.GetMode("cpu_temp"), false);
+            SetCPUTemp(AppConfig.GetMode("cpu_temp"));
+            SetRyzenPower();
         }
 
         public void AutoPerformance(bool powerChanged = false)
@@ -46,7 +50,17 @@ namespace GHelper.Mode
         public void ResetPerformanceMode()
         {
             ResetRyzen();
+
             Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Mode");
+
+            // Default power mode
+            AppConfig.RemoveMode("powermode");
+            PowerNative.SetPowerMode(Modes.GetCurrentBase());
+        }
+
+        public void Toast()
+        {
+            Program.toast.RunToast(Modes.GetCurrentName(), SystemInformation.PowerStatus.PowerLineStatus == PowerLineStatus.Online ? ToastIcon.Charger : ToastIcon.Battery);
         }
 
         public void SetPerformanceMode(int mode = -1, bool notify = false)
@@ -57,54 +71,97 @@ namespace GHelper.Mode
 
             if (!Modes.Exists(mode)) mode = 0;
 
-            customFans = false;
-            customPower = 0;
-
             settings.ShowMode(mode);
-            SetModeLabel();
 
             Modes.SetCurrent(mode);
 
-            Program.acpi.DeviceSet(AsusACPI.PerformanceMode, IsManualModeRequired() ? AsusACPI.PerformanceManual : Modes.GetBase(mode), "Mode");
 
-            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);
-
-            if (AppConfig.Get("auto_apply_power_plan") != 0)
+            Task.Run(async () =>
             {
+                bool reset = AppConfig.IsResetRequired() && (Modes.GetBase(oldMode) == Modes.GetBase(mode)) && customPower > 0 && !AppConfig.IsMode("auto_apply_power");
+
+                customFans = false;
+                customPower = 0;
+                SetModeLabel();
+
+                // Workaround for not properly resetting limits on G14 2024
+                if (reset)
+                {
+                    Program.acpi.DeviceSet(AsusACPI.PerformanceMode, (Modes.GetBase(oldMode) != 1) ? AsusACPI.PerformanceTurbo : AsusACPI.PerformanceBalanced, "ModeReset");
+                    await Task.Delay(TimeSpan.FromMilliseconds(1500));
+                }
+
+                int status = Program.acpi.DeviceSet(AsusACPI.PerformanceMode, AppConfig.IsManualModeRequired() ? AsusACPI.PerformanceManual : Modes.GetBase(mode), "Mode");
+                // Vivobook fallback
+                if (status != 1) Program.acpi.SetVivoMode(Modes.GetBase(mode));
+
+                SetGPUClocks();
+
+                await Task.Delay(TimeSpan.FromMilliseconds(100));
+                AutoFans();
+                await Task.Delay(TimeSpan.FromMilliseconds(1000));
+                AutoPower();
+
+
+            });
+
+
+            if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected()) XGM.Reset();
+
+            if (notify) Toast();
+
+            if (!AppConfig.Is("skip_powermode"))
+            {
+                // Power plan from config or defaulting to balanced
                 if (AppConfig.GetModeString("scheme") is not null)
-                    PowerNative.SetPowerScheme(AppConfig.GetModeString("scheme"));
+                    PowerNative.SetPowerPlan(AppConfig.GetModeString("scheme"));
                 else
-                    PowerNative.SetPowerScheme(Modes.GetBase(mode));
+                    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);
-            }
-            */
+                    PowerNative.SetCPUBoost(AppConfig.GetMode("auto_boost"));
 
             settings.FansInit();
         }
 
 
-        public void CyclePerformanceMode()
+        private void ModeToggleTimer_Elapsed(object? sender, System.Timers.ElapsedEventArgs e)
         {
-            SetPerformanceMode(Modes.GetNext(Control.ModifierKeys == Keys.Shift), true);
+            modeToggleTimer.Stop();
+            Logger.WriteLine($"Timed mode: {Modes.GetCurrent()}");
+            SetPerformanceMode();
+
+        }
+
+        public void CyclePerformanceMode(bool back = false)
+        {
+            int delay = AppConfig.Get("mode_delay");
+            if (delay > 0)
+            {
+                if (modeToggleTimer is null)
+                {
+                    modeToggleTimer = new System.Timers.Timer(delay);
+                    modeToggleTimer.Elapsed += ModeToggleTimer_Elapsed;
+                }
+
+                modeToggleTimer.Stop();
+                modeToggleTimer.Start();
+                Modes.SetCurrent(Modes.GetNext(back));
+                Toast();
+            }
+            else
+            {
+                SetPerformanceMode(Modes.GetNext(back), true);
+            }
+
         }
 
         public void AutoFans(bool force = false)
@@ -117,7 +174,7 @@ namespace GHelper.Mode
                 bool xgmFan = false;
                 if (AppConfig.Is("xgm_fan") && Program.acpi.IsXGConnected())
                 {
-                    AsusUSB.SetXGMFan(AppConfig.GetFanConfig(AsusFan.XGM));
+                    XGM.SetFan(AppConfig.GetFanConfig(AsusFan.XGM));
                     xgmFan = true;
                 }
 
@@ -128,13 +185,18 @@ namespace GHelper.Mode
                     Program.acpi.SetFanCurve(AsusFan.Mid, AppConfig.GetFanConfig(AsusFan.Mid));
 
 
-                // something went wrong, resetting to default profile
+                // Alternative way to set fan curve
                 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");
+                    cpuResult = Program.acpi.SetFanRange(AsusFan.CPU, AppConfig.GetFanConfig(AsusFan.CPU));
+                    gpuResult = Program.acpi.SetFanRange(AsusFan.GPU, AppConfig.GetFanConfig(AsusFan.GPU));
+
+                    // Something went wrong, resetting to default profile
+                    if (cpuResult != 1 || gpuResult != 1)
+                    {
+                        Program.acpi.DeviceSet(AsusACPI.PerformanceMode, Modes.GetCurrentBase(), "Reset Mode");
+                        settings.LabelFansResult("Model doesn't support custom fan curves");
+                    }
                 }
                 else
                 {
@@ -143,12 +205,12 @@ namespace GHelper.Mode
                 }
 
                 // force set PPTs for missbehaving bios on FX507/517 series
-                if ((AppConfig.ContainsModel("FX507") || AppConfig.ContainsModel("FX517") || xgmFan) && !AppConfig.IsMode("auto_apply_power"))
+                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_APUA0, 80, "PowerLimit Fix A0");
                         Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, 80, "PowerLimit Fix A3");
                     });
                 }
@@ -159,68 +221,25 @@ namespace GHelper.Mode
 
         }
 
-        private static bool IsManualModeRequired()
-        {
-            if (!AppConfig.IsMode("auto_apply_power"))
-                return false;
-
-            return
-                AppConfig.Is("manual_mode") ||
-                AppConfig.ContainsModel("GU604") ||
-                AppConfig.ContainsModel("G733");
-        }
-
-        private static bool IsFanRequired()
-        {
-            return AppConfig.ContainsModel("GA402X") || AppConfig.ContainsModel("G513");
-        }
-
-        public void AutoPower(int delay = 0)
+        public void AutoPower(bool launchAsAdmin = false)
         {
 
             customPower = 0;
 
             bool applyPower = AppConfig.IsMode("auto_apply_power");
             bool applyFans = AppConfig.IsMode("auto_apply");
-            //bool applyGPU = true;
 
-            if (applyPower)
+            if (applyPower && !applyFans && (AppConfig.IsFanRequired() || AppConfig.IsManualModeRequired()))
             {
-                // force fan curve for misbehaving bios PPTs on some models
-                if (!applyFans && IsFanRequired())
-                {
-                    delay = 500;
-                    AutoFans(true);
-                }
-
-                // Fix for models that don't support PPT settings in all modes, setting a "manual" mode for them
-                if (IsManualModeRequired() && !applyFans)
-                {
-                    AutoFans(true);
-                }
+                AutoFans(true);
+                Thread.Sleep(500);
             }
 
-            if (delay > 0)
-            {
-                var timer = new System.Timers.Timer(delay);
-                timer.Elapsed += delegate
-                {
-                    timer.Stop();
-                    timer.Dispose();
+            if (applyPower) SetPower(launchAsAdmin);
 
-                    if (applyPower) SetPower();
-                    Thread.Sleep(500);
-                    SetGPUPower();
-                    AutoRyzen();
-                };
-                timer.Start();
-            }
-            else
-            {
-                if (applyPower) SetPower(true);
-                SetGPUPower();
-                AutoRyzen();
-            }
+            Thread.Sleep(500);
+            SetGPUPower();
+            AutoRyzen();
 
         }
 
@@ -229,13 +248,44 @@ namespace GHelper.Mode
             settings.SetModeLabel(Properties.Strings.PerformanceMode + ": " + Modes.GetCurrentName() + (customFans ? "+" : "") + ((customPower > 0) ? " " + customPower + "W" : ""));
         }
 
+        public void SetRyzenPower(bool init = false)
+        {
+            if (init) _ryzenPower = true;
+
+            if (!_ryzenPower) return;
+            if (!RyzenControl.IsRingExsists()) return;
+            if (!AppConfig.IsMode("auto_apply_power")) return;
+
+            int limit_total = AppConfig.GetMode("limit_total");
+            int limit_slow = AppConfig.GetMode("limit_slow", limit_total);
+
+            if (limit_total > AsusACPI.MaxTotal) return;
+            if (limit_total < AsusACPI.MinTotal) return;
+
+            var stapmResult = SendCommand.set_stapm_limit((uint)limit_total * 1000);
+            if (init) Logger.WriteLine($"STAPM: {limit_total} {stapmResult}");
+
+            var slowResult = SendCommand.set_slow_limit((uint)limit_slow * 1000);
+            if (init) Logger.WriteLine($"SLOW: {limit_slow} {slowResult}");
+
+            var fastResult = SendCommand.set_fast_limit((uint)limit_slow * 1000);
+            if (init) Logger.WriteLine($"FAST: {limit_slow} {fastResult}");
+
+        }
+
         public void SetPower(bool launchAsAdmin = false)
         {
 
+            bool allAMD = Program.acpi.IsAllAmdPPT();
+            bool isAMD = RyzenControl.IsAMD();
+
             int limit_total = AppConfig.GetMode("limit_total");
             int limit_cpu = AppConfig.GetMode("limit_cpu");
+            int limit_slow = AppConfig.GetMode("limit_slow");
             int limit_fast = AppConfig.GetMode("limit_fast");
 
+            if (limit_slow < 0 || allAMD) limit_slow = limit_total;
+
             if (limit_total > AsusACPI.MaxTotal) return;
             if (limit_total < AsusACPI.MinTotal) return;
 
@@ -245,31 +295,22 @@ namespace GHelper.Mode
             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)
+            if (limit_slow > AsusACPI.MaxTotal) return;
+            if (limit_slow < AsusACPI.MinTotal) return;
+
+            // SPL and SPPT 
+            if (Program.acpi.DeviceGet(AsusACPI.PPT_APUA0) >= 0)
             {
-                Program.acpi.DeviceSet(AsusACPI.PPT_TotalA0, limit_total, "PowerLimit A0");
                 Program.acpi.DeviceSet(AsusACPI.PPT_APUA3, limit_total, "PowerLimit A3");
+                Program.acpi.DeviceSet(AsusACPI.PPT_APUA0, limit_slow, "PowerLimit A0");
                 customPower = limit_total;
             }
-            else if (RyzenControl.IsAMD())
+            else if (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;
+                    SetRyzenPower(true);
                 }
                 else if (launchAsAdmin)
                 {
@@ -283,10 +324,9 @@ namespace GHelper.Mode
                 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
+            else if (isAMD && 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;
             }
 
 
@@ -294,37 +334,38 @@ namespace GHelper.Mode
 
         }
 
-        public void SetGPUClocks(bool launchAsAdmin = true)
+        public void SetGPUClocks(bool launchAsAdmin = true, bool reset = false)
         {
-
-            int gpu_core = AppConfig.GetMode("gpu_core");
-            int gpu_memory = AppConfig.GetMode("gpu_memory");
-
-            if (gpu_core == -1 && gpu_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
+            Task.Run(() =>
             {
-                int getStatus = nvControl.GetClocks(out int current_core, out int current_memory);
-                if (getStatus != -1)
+
+                int core = AppConfig.GetMode("gpu_core");
+                int memory = AppConfig.GetMode("gpu_memory");
+                int clock_limit = AppConfig.GetMode("gpu_clock_limit");
+
+                if (reset) core = memory = clock_limit = 0;
+
+                if (core == -1 && memory == -1 && clock_limit == -1) return;
+                //if ((gpu_core > -5 && gpu_core < 5) && (gpu_memory > -5 && gpu_memory < 5)) launchAsAdmin = false;
+
+                if (Program.acpi.DeviceGet(AsusACPI.GPUEco) == 1) { Logger.WriteLine("Clocks: Eco"); return; }
+                if (HardwareControl.GpuControl is null) { Logger.WriteLine("Clocks: NoGPUControl"); return; }
+                if (!HardwareControl.GpuControl!.IsNvidia) { Logger.WriteLine("Clocks: NotNvidia"); return; }
+
+                using NvidiaGpuControl nvControl = (NvidiaGpuControl)HardwareControl.GpuControl;
+                try
                 {
-                    if (Math.Abs(gpu_core - current_core) < 5 && Math.Abs(gpu_memory - current_memory) < 5) return;
+                    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("Clocks Error:" + ex.ToString());
                 }
 
-                int setStatus = nvControl.SetClocks(gpu_core, gpu_memory);
-                if (launchAsAdmin && setStatus == -1) ProcessHelper.RunAsAdmin("gpu");
-
-            }
-            catch (Exception ex)
-            {
-                Logger.WriteLine(ex.ToString());
-            }
+                settings.GPUInit();
+            });
         }
 
         public void SetGPUPower()
@@ -332,35 +373,31 @@ namespace GHelper.Mode
 
             int gpu_boost = AppConfig.GetMode("gpu_boost");
             int gpu_temp = AppConfig.GetMode("gpu_temp");
+            int gpu_power = AppConfig.GetMode("gpu_power");
 
+            int boostResult = -1;
 
-            if (gpu_boost < AsusACPI.MinGPUBoost || gpu_boost > AsusACPI.MaxGPUBoost) return;
-            if (gpu_temp < AsusACPI.MinGPUTemp || gpu_temp > AsusACPI.MaxGPUTemp) return;
+            if (gpu_power >= AsusACPI.MinGPUPower && gpu_power <= AsusACPI.MaxGPUPower && Program.acpi.DeviceGet(AsusACPI.GPU_POWER) >= 0)
+                Program.acpi.DeviceSet(AsusACPI.GPU_POWER, gpu_power, "PowerLimit TGP (GPU VAR)");
 
-            if (Program.acpi.DeviceGet(AsusACPI.PPT_GPUC0) >= 0)
+            if (gpu_boost >= AsusACPI.MinGPUBoost && gpu_boost <= AsusACPI.MaxGPUBoost && Program.acpi.DeviceGet(AsusACPI.PPT_GPUC0) >= 0)
+                boostResult = Program.acpi.DeviceSet(AsusACPI.PPT_GPUC0, gpu_boost, "PowerLimit C0 (GPU BOOST)");
+
+            if (gpu_temp >= AsusACPI.MinGPUTemp && gpu_temp <= AsusACPI.MaxGPUTemp && Program.acpi.DeviceGet(AsusACPI.PPT_GPUC2) >= 0)
+                Program.acpi.DeviceSet(AsusACPI.PPT_GPUC2, gpu_temp, "PowerLimit C2 (GPU TEMP)");
+
+            // Fallback
+            if (boostResult == 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)
+        public void SetCPUTemp(int? cpuTemp, bool init = false)
         {
             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;
+                if (init) Logger.WriteLine($"CPU Temp: {cpuTemp} {resultCPU}");
             }
         }
 
@@ -397,22 +434,27 @@ namespace GHelper.Mode
                 return;
             }
 
+            if (!RyzenControl.IsRingExsists()) return;
+
             try
             {
                 SetUV(AppConfig.GetMode("cpu_uv", 0));
                 SetUViGPU(AppConfig.GetMode("igpu_uv", 0));
-                SetCPUTemp(AppConfig.GetMode("cpu_temp"));
+                SetCPUTemp(AppConfig.GetMode("cpu_temp"), true);
             }
             catch (Exception ex)
             {
                 Logger.WriteLine("UV Error: " + ex.ToString());
             }
+
+            reapplyTimer.Enabled = AppConfig.IsMode("auto_uv");
         }
 
         public void ResetRyzen()
         {
             if (_cpuUV != 0) SetUV(0);
             if (_igpuUV != 0) SetUViGPU(0);
+            reapplyTimer.Enabled = false;
         }
 
         public void AutoRyzen()

app/Mode/Modes.cs

@@ -39,9 +39,9 @@
                 "mode_base",
                 "mode_name",
                 "limit_total",
+                "limit_slow",
                 "limit_fast",
                 "limit_cpu",
-                "limit_total",
                 "fan_profile_cpu",
                 "fan_profile_gpu",
                 "fan_profile_mid",
@@ -51,7 +51,8 @@
                 "gpu_memory",
                 "auto_boost",
                 "auto_apply",
-                "auto_apply_power"
+                "auto_apply_power",
+                "powermode"
             };
 
             foreach (string clean in cleanup)

app/Mode/PowerNative.cs

@@ -72,7 +72,24 @@ namespace GHelper.Mode
         [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;
@@ -122,51 +139,97 @@ namespace GHelper.Mode
             Logger.WriteLine("Boost " + boost);
         }
 
-        public static void SetPowerScheme(string scheme)
+        public static string GetPowerMode()
         {
-            List<string> overlays = new() {
-                "00000000-0000-0000-0000-000000000000",
-                "ded574b5-45a0-4f42-8737-46345c09c238",
-                "961cc777-2547-4f9d-8174-7d86181b8a7a",
-                "3af9B8d9-7c97-431d-ad78-34a8bfea439f"
-            };
+            PowerGetEffectiveOverlayScheme(out Guid activeScheme);
+            return activeScheme.ToString();
+        }
+
+        public static void SetPowerMode(string scheme)
+        {
+
+            if (!overlays.Contains(scheme)) return;
 
             Guid guidScheme = new Guid(scheme);
 
-            if (overlays.Contains(scheme))
+            uint status = PowerGetEffectiveOverlayScheme(out Guid activeScheme);
+            
+            if (GetBatterySaverStatus())
             {
-                uint status = PowerGetEffectiveOverlayScheme(out Guid activeScheme);
-                if (status != 0 || activeScheme != guidScheme)
-                {
-                    PowerSetActiveOverlayScheme(guidScheme);
-                    Logger.WriteLine("Power mode: " + scheme);
-                }
-            }
-            else
-            {
-                PowerSetActiveScheme(IntPtr.Zero, guidScheme);
-                Logger.WriteLine("Power plan: " + scheme);
+                Logger.WriteLine("Battery Saver detected");
+                return;
             }
 
+            if (status != 0 || activeScheme != guidScheme)
+            {
+                status = PowerSetActiveOverlayScheme(guidScheme);
+                Logger.WriteLine("Power Mode " + activeScheme + " -> " + scheme + ":" + (status == 0 ? "OK" : status));
+            }
 
         }
 
-        public static void SetPowerScheme(int mode)
+        public static void SetBalancedPowerPlan()
+        {
+            Guid activeSchemeGuid = GetActiveScheme();
+            string balanced = "381b4222-f694-41f0-9685-ff5bb260df2e";
+
+            if (activeSchemeGuid.ToString() != balanced && !AppConfig.Is("skip_power_plan"))
+            {
+                Logger.WriteLine($"Changing power plan from {activeSchemeGuid.ToString()} to Balanced");
+                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 0: // balanced
-                    SetPowerScheme("00000000-0000-0000-0000-000000000000");
-                    break;
                 case 1: // turbo
-                    SetPowerScheme("ded574b5-45a0-4f42-8737-46345c09c238");
-                    break;
+                    return POWER_TURBO;
                 case 2: //silent
-                    SetPowerScheme("961cc777-2547-4f9d-8174-7d86181b8a7a");
-                    break;
+                    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)
         {
             /**
@@ -201,5 +264,80 @@ namespace GHelper.Mode
 
             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;
+            }
+
+        }
+
     }
 }

app/NativeMethods.cs

@@ -27,14 +27,25 @@ public class NativeMethods
     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);
+    private static extern IntPtr SendMessage(nint hWnd, int hMsg, int wParam, int 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 handle)
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool LockWorkStation();
+
+    public static void LockScreen()
     {
-        IntPtr result = SendMessage(handle, WM_SYSCOMMAND, (IntPtr)SC_MONITORPOWER, (IntPtr)MONITOR_OFF);
+        LockWorkStation();
+    }
+
+    public static void TurnOffScreen()
+    {
+        Form f = new Form();
+        IntPtr result = SendMessage(f.Handle, WM_SYSCOMMAND, SC_MONITORPOWER, MONITOR_OFF);
+
         if (result == IntPtr.Zero)
         {
             int error = Marshal.GetLastWin32Error();
@@ -73,36 +84,38 @@ public class NativeMethods
     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");
+        public static 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");
+        public static 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");
+        public static 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");
+        public static 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");
+        public static 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");
+        public static 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");
+        public static 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");
+        public static 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");
+        public static 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 static 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);
+        public static 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");
+        public static Guid MinPowerSavings { get; } = new Guid("8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c");
+        public static Guid MaxPowerSavings { get; } = new Guid("a1841308-3541-4fab-bc81-f71556f20b4a");
+        public static Guid TypicalPowerSavings { get; } = new Guid("381b4222-f694-41f0-9685-ff5bb260df2e");
+
+        public static Guid LIDSWITCH_STATE_CHANGE = new Guid("ba3e0f4d-b817-4094-a2d1-d56379e6a0f3");
     }
 
 

app/Peripherals/IPeripheral.cs

@@ -0,0 +1,31 @@
+
+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 bool CanExport();
+        public byte[] Export();
+        public bool Import(byte[] blob);
+
+        public PeripheralType DeviceType();
+
+        public string GetDisplayName();
+
+        public bool HasBattery();
+
+        public void SynchronizeDevice();
+
+        public void ReadBattery();
+    }
+}

app/Peripherals/Mouse/Models/Chakram.cs

@@ -0,0 +1,209 @@
+
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P704
+    public class Chakram : AsusMouse
+    {
+        public Chakram() : base(0x0B05, 0x18E5, "mi_00", true) { 
+        
+        }
+
+        protected Chakram(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Chakram (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 ChakramWired : Chakram
+    {
+        public ChakramWired() : base(0x18E3, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Chakram (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/ChakramCore.cs

@@ -0,0 +1,211 @@
+
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P511
+    public class ChakramCore : AsusMouse
+    {
+        public ChakramCore() : base(0x0B05, 0x1958, "mi_00", false) { 
+        
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Chakram Core";
+        }
+
+        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 false;
+        }
+
+        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 };
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.React;
+        }
+
+        //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 bool HasBattery()
+        {
+            return false;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return false;
+        }
+
+        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;
+        }
+
+        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) };
+        }
+    }
+}

app/Peripherals/Mouse/Models/ChakramX.cs

@@ -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
+            };
+        }
+    }
+}

app/Peripherals/Mouse/Models/GladiusII.cs

@@ -0,0 +1,462 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P504
+    public class GladiusIIOrigin : AsusMouse
+    {
+        public GladiusIIOrigin() : base(0x0B05, 0x1877, "mi_02", false)
+        {
+        }
+
+        public GladiusIIOrigin(ushort productId, string path) : base(0x0B05, productId, path, false)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 2;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "Gladius II Origin";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 1;
+        }
+        public override int MaxDPI()
+        {
+            return 12_000;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return false;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return false;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return false;
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return false;
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.Rainbow
+                || lightingMode == LightingMode.React
+                || lightingMode == LightingMode.Comet;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
+        }
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        protected override byte[] GetUpdateLightingModePacket(LightingSetting lightingSetting, LightingZone zone)
+        {
+            /*
+             * This mouse uses different speed values for rainbow mode compared to others.
+             * 51 28 03 00 03 04 FF 00 00 00 00 [8C] 00 00 00 00
+             * 51 28 03 00 03 04 FF 00 00 00 00 [64] 00 00 00 00
+             * 51 28 03 00 03 04 FF 00 00 00 00 [3F] 00 00 00 00
+             */
+
+            if (lightingSetting.LightingMode == LightingMode.Rainbow)
+            {
+                byte speed = 0x3F;
+
+                switch (lightingSetting.AnimationSpeed)
+                {
+                    case AnimationSpeed.Slow:
+                        speed = 0x3F;
+                        break;
+                    case AnimationSpeed.Medium:
+                        speed = 0x64;
+                        break;
+                    case AnimationSpeed.Fast:
+                        speed = 0x8C;
+                        break;
+                }
+
+                return new byte[] { reportId, 0x51, 0x28, (byte)zone, 0x00,
+                    IndexForLightingMode(lightingSetting.LightingMode),
+                    (byte)lightingSetting.Brightness,
+                    0xFF, 0x00, 0x00,
+                    (byte)(SupportsAnimationDirection(lightingSetting.LightingMode) ? lightingSetting.AnimationDirection : 0x00),
+                    (byte)((lightingSetting.RandomColor && SupportsRandomColor(lightingSetting.LightingMode)) ? 0x01: 0x00),
+                    (byte)(SupportsAnimationSpeed(lightingSetting.LightingMode) ? speed : 0x00)
+                };
+            }
+
+            return base.GetUpdateLightingModePacket(lightingSetting, zone);
+        }
+
+        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                       Direction, Random col, Speed
+            //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 12 03 00 00 [03 04 00 00 00] [03 04 00 00 00] [03 04 00 00 00] 00 [00] [00] [07] 00 00
+            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;
+                }
+                ls.AnimationDirection = SupportsAnimationDirection(ls.LightingMode)
+                   ? (AnimationDirection)response[21]
+                   : AnimationDirection.Clockwise;
+
+                ls.RandomColor = SupportsRandomColor(ls.LightingMode) && response[22] == 0x01;
+
+                ls.AnimationSpeed = SupportsAnimationSpeed(ls.LightingMode)
+                    ? (AnimationSpeed)response[23]
+                    : AnimationSpeed.Medium;
+
+                if (ls.AnimationSpeed != AnimationSpeed.Fast
+                    && ls.AnimationSpeed != AnimationSpeed.Medium
+                    && ls.AnimationSpeed != AnimationSpeed.Slow)
+                {
+                    ls.AnimationSpeed = AnimationSpeed.Medium;
+                }
+
+                Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
+                LightingSetting[i] = ls;
+            }
+        }
+
+
+
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return (PollingRate)packet[9];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+
+        protected override byte[] GetUpdatePollingRatePacket(PollingRate pollingRate)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x02, 0x00, (byte)pollingRate };
+        }
+
+        protected override bool ParseAngleSnapping(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return packet[13] == 0x01;
+            }
+
+            return false;
+        }
+
+        protected override byte[] GetUpdateAngleSnappingPacket(bool angleSnapping)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x04, 0x00, (byte)(angleSnapping ? 0x01 : 0x00) };
+        }
+
+        protected override DebounceTime ParseDebounce(byte[] packet)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x04 || packet[3] != 0x00)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] < 0x02)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] > 0x07)
+            {
+                return DebounceTime.MS32;
+            }
+
+            return (DebounceTime)packet[11];
+        }
+
+        protected override byte[] GetUpdateDebouncePacket(DebounceTime debounce)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x03, 0x00, ((byte)debounce) };
+        }
+    }
+
+    //P502
+    public class GladiusII : GladiusIIOrigin
+    {
+        public GladiusII() : base(0x1845, "mi_02")
+        {
+
+        }
+        public override string GetDisplayName()
+        {
+            return "Gladius II Origin";
+        }
+
+        public override int ProfileCount()
+        {
+            return 3;
+        }
+    }
+
+    //P504
+    public class GladiusIIOriginPink : GladiusIIOrigin
+    {
+        public GladiusIIOriginPink() : base(0x18CD, "mi_02")
+        {
+
+        }
+        public override string GetDisplayName()
+        {
+            return "Gladius II PNK LTD";
+        }
+        public override int ProfileCount()
+        {
+            return 3;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Scrollwheel, LightingZone.Underglow };
+        }
+
+        protected override byte[] GetUpdateLightingModePacket(LightingSetting lightingSetting, LightingZone zone)
+        {
+            /*
+             * This mouse uses different speed values for rainbow mode compared to others.
+             * 51 28 03 00 03 04 FF 00 00 00 00 [8C] 00 00 00 00
+             * 51 28 03 00 03 04 FF 00 00 00 00 [64] 00 00 00 00
+             * 51 28 03 00 03 04 FF 00 00 00 00 [3F] 00 00 00 00
+             */
+
+            byte speed = (byte)(SupportsAnimationSpeed(lightingSetting.LightingMode) ? lightingSetting.AnimationSpeed : 0x00);
+
+            if (lightingSetting.LightingMode == LightingMode.Rainbow)
+            {
+                speed = 0x64;
+
+                switch (lightingSetting.AnimationSpeed)
+                {
+                    case AnimationSpeed.Slow:
+                        speed = 0x8C;
+                        break;
+                    case AnimationSpeed.Medium:
+                        speed = 0x64;
+                        break;
+                    case AnimationSpeed.Fast:
+                        speed = 0x3F;
+                        break;
+                }
+            }
+
+
+
+            return new byte[] { reportId, 0x51, 0x28, (byte)zone, 0x00,
+                IndexForLightingMode(lightingSetting.LightingMode),
+                (byte)lightingSetting.Brightness,
+                0x00, // this mouse has 2 colors per LED capability, but we do not suppor this yet, so we disable it
+                lightingSetting.RGBColor.R, lightingSetting.RGBColor.G, lightingSetting.RGBColor.B,
+                0x00, 0x00, 0x00, //this would be the second set of RGB Colors if we ever support this
+                (byte)(SupportsAnimationDirection(lightingSetting.LightingMode) ? lightingSetting.AnimationDirection : 0x00),
+                (byte)((lightingSetting.RandomColor && SupportsRandomColor(lightingSetting.LightingMode)) ? 0x01: 0x00),
+                speed
+            };
+        }
+
+        protected LightingSetting? ParseLightingSetting(byte[] packet, LightingZone zone)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x03)
+            {
+                return null;
+            }
+
+            //skip first block as it seems to be empty. Maybe only filled to certain configurations.
+            int offset = 5 + 9 + (((int)zone) * 9);
+
+            LightingSetting setting = new LightingSetting();
+
+            setting.LightingMode = LightingModeForIndex(packet[offset + 0]);
+            setting.Brightness = packet[offset + 1];
+            //Offset 2 is a bool that says whether dual color RGB is in use. Unsupported for now by GHelper
+
+            setting.RGBColor = Color.FromArgb(packet[offset + 3], packet[offset + 4], packet[offset + 5]);
+
+            //Offset 7 - 9 are the second RGB colors, unuse as not supported yet
+
+
+            return setting;
+        }
+
+        public override void ReadLightingSetting()
+        {
+            if (!HasRGB())
+            {
+                return;
+            }
+            //Mouse sends all lighting zones in one response                                                         Direction, Random col, Speed
+            //First block seems emtpy?
+            //00 12 03 00 00 [00 00 00 00 00 00 00 00 00] [03 04 01 00 00 00 00 00 00] [03 04 01 00 00 00 00 00 00] [00 01 8c]
+            //Length 9, offset 5
+            //Direction
+            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;
+                }
+                ls.AnimationDirection = SupportsAnimationDirection(ls.LightingMode)
+                   ? (AnimationDirection)response[32]
+                   : AnimationDirection.Clockwise;
+
+                ls.RandomColor = SupportsRandomColor(ls.LightingMode) && response[33] == 0x01;
+
+                //Rainbow uses different speed values for whatever reason
+                if (response[12] == 0x03)
+                {
+                    byte speed = response[34];
+
+                    switch (speed)
+                    {
+                        case 0x3F:
+                            ls.AnimationSpeed = AnimationSpeed.Fast;
+                            break;
+
+                        case 0x64:
+                            ls.AnimationSpeed = AnimationSpeed.Medium;
+                            break;
+
+                        case 0x8C:
+                            ls.AnimationSpeed = AnimationSpeed.Slow;
+                            break;
+
+                        default:
+                            ls.AnimationSpeed = AnimationSpeed.Medium;
+                            break;
+                    }
+                }
+                else
+                {
+                    ls.AnimationSpeed = SupportsAnimationSpeed(ls.LightingMode)
+                    ? (AnimationSpeed)response[34]
+                    : AnimationSpeed.Medium;
+
+                    if (ls.AnimationSpeed != AnimationSpeed.Fast
+                        && ls.AnimationSpeed != AnimationSpeed.Medium
+                        && ls.AnimationSpeed != AnimationSpeed.Slow)
+                    {
+                        ls.AnimationSpeed = AnimationSpeed.Medium;
+                    }
+                }
+
+
+                Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
+                LightingSetting[i] = ls;
+            }
+        }
+    }
+}

app/Peripherals/Mouse/Models/GladiusIIIAimpoint.cs

@@ -0,0 +1,149 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P711
+    public class GladiusIIIAimpoint : AsusMouse
+    {
+        public GladiusIIIAimpoint() : base(0x0B05, 0x1A72, "mi_00", true)
+        {
+        }
+
+        protected GladiusIIIAimpoint(ushort productId, bool wireless) : base(0x0B05, productId, "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(0x1A70, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III Aimpoint (Wired)";
+        }
+    }
+
+    public class GladiusIIIAimpointEva2 : GladiusIIIAimpoint
+    {
+        public GladiusIIIAimpointEva2() : base(0x1B0C, true)
+        {
+        }
+
+        public GladiusIIIAimpointEva2(ushort productId) : base(productId, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III Eva 2 (Wireless)";
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo };
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.React
+                || lightingMode == LightingMode.Comet
+                || lightingMode == LightingMode.BatteryState;
+        }
+    }
+
+    public class GladiusIIIAimpointEva2Wired : GladiusIIIAimpointEva2
+    {
+        public GladiusIIIAimpointEva2Wired() : base(0x1B0A)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III Eva 2 (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/GladiusIIIWireless.cs

@@ -0,0 +1,130 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P706_Wireless
+    public class GladiusIIIWireless : AsusMouse
+    {
+        public GladiusIIIWireless() : base(0x0B05, 0x197F, "mi_00", true)
+        {
+        }
+
+        protected GladiusIIIWireless(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 : GladiusIIIWireless
+    {
+        public GladiusIIIWired() : base(0x197d, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III (Wired)";
+        }
+    }
+
+
+    //P514
+    public class GladiusIII : GladiusIIIWireless
+    {
+        public GladiusIII() : base(0x197B, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Gladius III";
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return false;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return false;
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.Rainbow
+                || lightingMode == LightingMode.React
+                || lightingMode == LightingMode.Comet;
+        }
+    }
+}

app/Peripherals/Mouse/Models/GladiusIIWireless.cs

@@ -0,0 +1,294 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    public class GladiusIIWireless : AsusMouse
+    {
+        public GladiusIIWireless() : base(0x0B05, 0x18A0, "mi_02", true)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 2;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "Gladius II Wireless";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 1;
+        }
+        public override int MaxDPI()
+        {
+            return 16_000;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return true;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+        public override bool HasLiftOffSetting()
+        {
+            return false;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+
+        public override int LowBatteryWarningStep()
+        {
+            return 25;
+        }
+
+        public override bool HasBattery()
+        {
+            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;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel };
+        }
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        //Has 25% increments
+        protected override int ParseBattery(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x07)
+            {
+                return packet[5] * 25;
+            }
+
+            return -1;
+        }
+
+        protected override byte[] GetUpdateLightingModePacket(LightingSetting lightingSetting, LightingZone zone)
+        {
+            /*
+             * This mouse uses different speed values for rainbow mode compared to others.
+             * 51 28 03 00 03 04 FF 00 00 00 00 [8C] 00 00 00 00
+             * 51 28 03 00 03 04 FF 00 00 00 00 [64] 00 00 00 00
+             * 51 28 03 00 03 04 FF 00 00 00 00 [3F] 00 00 00 00
+             */
+
+            if (lightingSetting.LightingMode == LightingMode.Rainbow)
+            {
+                byte speed = 0x3F;
+
+                switch (lightingSetting.AnimationSpeed)
+                {
+                    case AnimationSpeed.Slow:
+                        speed = 0x3F;
+                        break;
+                    case AnimationSpeed.Medium:
+                        speed = 0x64;
+                        break;
+                    case AnimationSpeed.Fast:
+                        speed = 0x8C;
+                        break;
+                }
+
+                return new byte[] { reportId, 0x51, 0x28, (byte)zone, 0x00,
+                    IndexForLightingMode(lightingSetting.LightingMode),
+                    (byte)lightingSetting.Brightness,
+                    0xFF, 0x00, 0x00,
+                    (byte)(SupportsAnimationDirection(lightingSetting.LightingMode) ? lightingSetting.AnimationDirection : 0x00),
+                    (byte)((lightingSetting.RandomColor && SupportsRandomColor(lightingSetting.LightingMode)) ? 0x01: 0x00),
+                    (byte)(SupportsAnimationSpeed(lightingSetting.LightingMode) ? speed : 0x00)
+                };
+            }
+
+            return base.GetUpdateLightingModePacket(lightingSetting, zone);
+        }
+
+
+        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                       Direction, Random col, Speed
+            //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 12 03 00 00 [03 04 00 00 00] [03 04 00 00 00] [03 04 00 00 00] 00 [00] [00] [07] 00 00
+            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;
+                }
+                ls.AnimationDirection = SupportsAnimationDirection(ls.LightingMode)
+                   ? (AnimationDirection)response[21]
+                   : AnimationDirection.Clockwise;
+
+                ls.RandomColor = SupportsRandomColor(ls.LightingMode) && response[22] == 0x01;
+
+                ls.AnimationSpeed = SupportsAnimationSpeed(ls.LightingMode)
+                    ? (AnimationSpeed)response[23]
+                    : AnimationSpeed.Medium;
+
+                if (ls.AnimationSpeed != AnimationSpeed.Fast
+                    && ls.AnimationSpeed != AnimationSpeed.Medium
+                    && ls.AnimationSpeed != AnimationSpeed.Slow)
+                {
+                    ls.AnimationSpeed = AnimationSpeed.Medium;
+                }
+
+                Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
+                LightingSetting[i] = ls;
+            }
+        }
+
+
+
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return (PollingRate)packet[9];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+
+        protected override byte[] GetUpdatePollingRatePacket(PollingRate pollingRate)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x02, 0x00, (byte)pollingRate };
+        }
+
+        protected override bool ParseAngleSnapping(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return packet[13] == 0x01;
+            }
+
+            return false;
+        }
+
+        protected override byte[] GetUpdateAngleSnappingPacket(bool angleSnapping)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x04, 0x00, (byte)(angleSnapping ? 0x01 : 0x00) };
+        }
+
+        protected override DebounceTime ParseDebounce(byte[] packet)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x04 || packet[3] != 0x00)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] < 0x02)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] > 0x07)
+            {
+                return DebounceTime.MS32;
+            }
+
+            return (DebounceTime)packet[11];
+        }
+
+        protected override byte[] GetUpdateDebouncePacket(DebounceTime debounce)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x03, 0x00, ((byte)debounce) };
+        }
+    }
+
+}

app/Peripherals/Mouse/Models/HarpeAceAimLab.cs

@@ -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;
+        }
+    }
+}

app/Peripherals/Mouse/Models/KerisIIAce.cs

@@ -0,0 +1,124 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+
+    public class KerisIIAceWired : AsusMouse
+    {
+        public KerisIIAceWired() : base(0x0B05, 0x1B16, "mi_00", true)
+        {
+        }
+
+        protected KerisIIAceWired(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Keris II Ace";
+        }
+
+
+        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 42_000;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasXYDPI()
+        {
+            return true;
+        }
+
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.BatteryState
+                || lightingMode == LightingMode.React;
+        }
+
+        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;
+        }
+
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                if ((int)packet[13] > 7)
+                    return (PollingRate)packet[13] - 96;
+                return (PollingRate)packet[13];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+
+    }
+
+    /*
+     * 
+    Mouse uses Omni Reciever
+    public class KerisIIAce : KerisIIAce
+    {
+        public KerisIIAce() : base(0xAAAA, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Keris II Ace (Wired)";
+        }
+    }
+    */
+
+}

app/Peripherals/Mouse/Models/KerisWirelssAimpoint.cs

@@ -0,0 +1,127 @@
+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 IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.BatteryState
+                || lightingMode == LightingMode.React;
+        }
+
+        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;
+        }
+        // 3.00.06 - 4.00.01 or newer firmware
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                if ((int)packet[13] > 7)
+                    return (PollingRate)packet[13] - 96;
+                return (PollingRate)packet[13];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+    }
+
+    public class KerisWirelssAimpointWired : KerisWirelssAimpoint
+    {
+        public KerisWirelssAimpointWired() : base(0x1A66, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Keris Wireless Aimpoint (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/Pugio.cs

@@ -0,0 +1,218 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P503
+    public class Pugio : AsusMouse
+    {
+        public Pugio() : base(0x0B05, 0x1846, "mi_02", false)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 2;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Pugio";
+        }
+
+        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 7_200;
+        }
+        public override int DPIIncrements()
+        {
+            return 50;
+        }
+
+        public override int MinDPI()
+        {
+            return 50;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return false;
+        }
+
+        //00 12 04 00 00 1f 00 07 00 [03] 00 02 00 00 00
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return (PollingRate)packet[9];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.Rainbow
+                || lightingMode == LightingMode.React
+                || lightingMode == LightingMode.Comet;
+        }
+
+        protected override byte[] GetUpdateLightingModePacket(LightingSetting lightingSetting, LightingZone zone)
+        {
+            // 00 51 28 03 00 00 04 00 ff 40 00 00 00 00 00 00 00 00 00 00
+
+            /*
+             * This mouse uses different speed values for rainbow mode compared to others.
+             * 00 51 28 03 00 03 04 FF 00 00 00 00 [8C] 00 00 00 00
+             * 00 51 28 03 00 03 04 FF 00 00 00 00 [64] 00 00 00 00
+             * 00 51 28 03 00 03 04 FF 00 00 00 00 [3F] 00 00 00 00
+             */
+
+            if (lightingSetting.LightingMode == LightingMode.Rainbow)
+            {
+                byte speed = 0x3F;
+
+                switch (lightingSetting.AnimationSpeed)
+                {
+                    case AnimationSpeed.Slow:
+                        speed = 0x3F;
+                        break;
+                    case AnimationSpeed.Medium:
+                        speed = 0x64;
+                        break;
+                    case AnimationSpeed.Fast:
+                        speed = 0x8C;
+                        break;
+                }
+
+                return new byte[] { reportId, 0x51, 0x28, (byte)zone, 0x00,
+                    IndexForLightingMode(lightingSetting.LightingMode),
+                    (byte)lightingSetting.Brightness,
+                    0xFF, 0x00, 0x00,
+                    (byte)(SupportsAnimationDirection(lightingSetting.LightingMode) ? lightingSetting.AnimationDirection : 0x00),
+                    (byte)((lightingSetting.RandomColor && SupportsRandomColor(lightingSetting.LightingMode)) ? 0x01: 0x00),
+                    (byte)(SupportsAnimationSpeed(lightingSetting.LightingMode) ? speed : 0x00)
+                };
+            }
+
+            return base.GetUpdateLightingModePacket(lightingSetting, zone);
+        }
+
+        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             (0x19) Direction, Random col, Speed
+            //00 12 03 00 00 [03 04 00 00 00] [03 04 00 00 00] [03 04 00 00 00] 01 [00] [00] [8c] 00
+            //00 12 03 00 00 [00 04 00 00 00] [00 04 00 00 00] [00 04 00 00 00] 01 [00] [00] [00] 00
+            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;
+                }
+                ls.AnimationDirection = SupportsAnimationDirection(ls.LightingMode)
+                   ? (AnimationDirection)response[21]
+                   : AnimationDirection.Clockwise;
+
+                ls.RandomColor = SupportsRandomColor(ls.LightingMode) && response[22] == 0x01;
+
+                ls.AnimationSpeed = SupportsAnimationSpeed(ls.LightingMode)
+                    ? (AnimationSpeed)response[23]
+                    : AnimationSpeed.Medium;
+
+                if (ls.AnimationSpeed != AnimationSpeed.Fast
+                    && ls.AnimationSpeed != AnimationSpeed.Medium
+                    && ls.AnimationSpeed != AnimationSpeed.Slow)
+                {
+                    ls.AnimationSpeed = AnimationSpeed.Medium;
+                }
+
+                Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
+                LightingSetting[i] = ls;
+            }
+        }
+    }
+}

app/Peripherals/Mouse/Models/PugioII.cs

@@ -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)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/ROGKerisWireless.cs

@@ -0,0 +1,225 @@
+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);
+        }
+    }
+
+    //P509
+    public class ROGKeris : ROGKerisWireless
+    {
+        public ROGKeris() : base(0x195C, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Keris";
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return false;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return false;
+        }
+    }
+
+    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)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/SpathaX.cs

@@ -0,0 +1,106 @@
+
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //SPATHA_WIRELESS
+    public class SpathaX : AsusMouse
+    {
+        public SpathaX() : base(0x0B05, 0x1979, "mi_00", true)
+        {
+        }
+
+        protected SpathaX(ushort vendorId, bool wireless) : base(0x0B05, vendorId, "mi_00", wireless)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Spatha 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 19_000;
+        }
+
+        public override bool HasXYDPI()
+        {
+            return false;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return false;
+        }
+
+        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 false;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return true;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return true;
+        }
+    }
+
+    public class SpathaXWired : SpathaX
+    {
+        public SpathaXWired() : base(0x1977, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Spatha X (Wired)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/StrixCarry.cs

@@ -0,0 +1,184 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P508
+    public class StrixCarry : AsusMouse
+    {
+        public StrixCarry() : base(0x0B05, 0x18B4, "mi_01", true)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 2;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Strix Carry (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 7_200;
+        }
+        public override int DPIIncrements()
+        {
+            return 50;
+        }
+
+        public override int MinDPI()
+        {
+            return 50;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            //Potentially does nothing. AC does not show the setting, but the mouse responds to it and stores it.
+            return true;
+        }
+
+        public override bool HasRGB()
+        {
+            return false;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+        public override bool HasXYDPI()
+        {
+            return false;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return false;
+        }
+
+        //Has 25% increments only.
+        protected override int ParseBattery(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x07)
+            {
+                return packet[7] * 25;
+            }
+
+            return -1;
+        }
+
+        protected override PowerOffSetting ParsePowerOffSetting(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x07)
+            {
+                return (PowerOffSetting)packet[5];
+            }
+
+            return PowerOffSetting.Never;
+        }
+
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return (PollingRate)packet[9];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+
+        protected override byte[] GetUpdatePollingRatePacket(PollingRate pollingRate)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x02, 0x00, (byte)pollingRate };
+        }
+
+        protected override bool ParseAngleSnapping(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return packet[13] == 0x01;
+            }
+
+            return false;
+        }
+
+        protected override byte[] GetUpdateAngleSnappingPacket(bool angleSnapping)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x04, 0x00, (byte)(angleSnapping ? 0x01 : 0x00) };
+        }
+
+        protected override DebounceTime ParseDebounce(byte[] packet)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x04 || packet[3] != 0x00)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] < 0x02)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] > 0x07)
+            {
+                return DebounceTime.MS32;
+            }
+
+            return (DebounceTime)packet[11];
+        }
+
+        protected override byte[] GetUpdateDebouncePacket(DebounceTime debounce)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x03, 0x00, ((byte)debounce) };
+        }
+
+        protected override int ParseProfile(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x00 && packet[3] == 0x00)
+            {
+                return packet[10];
+            }
+            Logger.WriteLine(GetDisplayName() + ": Failed to decode active profile");
+            return 0;
+        }
+
+        protected override int ParseDPIProfile(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x00 && packet[3] == 0x00)
+            {
+                return packet[11];
+            }
+            Logger.WriteLine(GetDisplayName() + ": Failed to decode active profile");
+            return 1;
+        }
+
+        protected override byte[] GetUpdateEnergySettingsPacket(int lowBatteryWarning, PowerOffSetting powerOff)
+        {
+            return new byte[] { 0x00, 0x51, 0x37, 0x00, 0x00, (byte)powerOff, 0x00, (byte)lowBatteryWarning };
+        }
+    }
+}

app/Peripherals/Mouse/Models/StrixEvolve.cs

@@ -0,0 +1,116 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    public class StrixEvolve : AsusMouse
+    {
+        public StrixEvolve() : base(0x0B05, 0x185B, "mi_00", false)
+        {
+        }
+
+
+        public override int DPIProfileCount()
+        {
+            return 2;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "Strix Evolve";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 2;
+        }
+        public override int MaxDPI()
+        {
+            return 7_200;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return false;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return false;
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        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;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo };
+        }
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+
+
+        public override int MinDPI()
+        {
+            return 50;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        public override bool HasLiftOffSetting()
+        {
+            return true;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+    }
+
+}

app/Peripherals/Mouse/Models/StrixImpact.cs

@@ -0,0 +1,247 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P303
+    public class StrixImpact : AsusMouse
+    {
+        public StrixImpact() : base(0x0B05, 0x1847, "mi_02", false)
+        {
+        }
+
+        public StrixImpact(ushort productId, string path) : base(0x0B05, productId, path, false)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 2;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "Strix Impact";
+        }
+
+
+        public override PollingRate[] SupportedPollingrates()
+        {
+            return new PollingRate[] {
+                PollingRate.PR125Hz,
+                PollingRate.PR250Hz,
+                PollingRate.PR500Hz,
+                PollingRate.PR1000Hz
+            };
+        }
+
+        public override int ProfileCount()
+        {
+            return 1;
+        }
+        public override int MaxDPI()
+        {
+            return 5_000;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return false;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return false;
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        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;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo };
+        }
+
+        public override int DPIIncrements()
+        {
+            return 50;
+        }
+
+
+        public override int MinDPI()
+        {
+            return 200;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        protected override byte[] GetUpdateLightingModePacket(LightingSetting lightingSetting, LightingZone zone)
+        {
+            /*
+             * 51 28 00 00 [00] [04] [35 04 FF] 00 00 00 00 00 00 00
+             */
+
+            return new byte[] { reportId, 0x51, 0x28, 0x00, 0x00,
+                IndexForLightingMode(lightingSetting.LightingMode),
+                (byte)lightingSetting.Brightness,
+                lightingSetting.RGBColor.R, lightingSetting.RGBColor.G, lightingSetting.RGBColor.B
+            };
+        }
+
+        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                       Direction, Random col, Speed
+            //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 12 03 00 00 [03 04 00 00 00] [03 04 00 00 00] [03 04 00 00 00] 00 [00] [00] [07] 00 00
+            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;
+                }
+                ls.AnimationDirection = SupportsAnimationDirection(ls.LightingMode)
+                   ? (AnimationDirection)response[21]
+                   : AnimationDirection.Clockwise;
+
+                ls.RandomColor = SupportsRandomColor(ls.LightingMode) && response[22] == 0x01;
+
+                ls.AnimationSpeed = SupportsAnimationSpeed(ls.LightingMode)
+                    ? (AnimationSpeed)response[23]
+                    : AnimationSpeed.Medium;
+
+                if (ls.AnimationSpeed != AnimationSpeed.Fast
+                    && ls.AnimationSpeed != AnimationSpeed.Medium
+                    && ls.AnimationSpeed != AnimationSpeed.Slow)
+                {
+                    ls.AnimationSpeed = AnimationSpeed.Medium;
+                }
+
+                Logger.WriteLine(GetDisplayName() + ": Read RGB Setting for Zone " + lz[i].ToString() + ": " + ls.ToString());
+                LightingSetting[i] = ls;
+            }
+        }
+
+
+
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return (PollingRate)packet[9];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+
+        protected override byte[] GetUpdatePollingRatePacket(PollingRate pollingRate)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x02, 0x00, (byte)pollingRate };
+        }
+
+        protected override bool ParseAngleSnapping(byte[] packet)
+        {
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return packet[13] == 0x01;
+            }
+
+            return false;
+        }
+
+        protected override byte[] GetUpdateAngleSnappingPacket(bool angleSnapping)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x04, 0x00, (byte)(angleSnapping ? 0x01 : 0x00) };
+        }
+
+        protected override DebounceTime ParseDebounce(byte[] packet)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x04 || packet[3] != 0x00)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] < 0x02)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] > 0x07)
+            {
+                return DebounceTime.MS32;
+            }
+
+            return (DebounceTime)packet[11];
+        }
+
+        protected override byte[] GetUpdateDebouncePacket(DebounceTime debounce)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x03, 0x00, ((byte)debounce) };
+        }
+    }
+
+}

app/Peripherals/Mouse/Models/StrixImpactII.cs

@@ -0,0 +1,196 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P506
+    public class StrixImpactII : AsusMouse
+    {
+        public StrixImpactII() : base(0x0B05, 0x18E1, "mi_00", false)
+        {
+        }
+
+        public StrixImpactII(ushort pid) : base(0x0B05, pid, "mi_00", false)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Strix Impact II";
+        }
+
+
+        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 6_200;
+        }
+
+        public override bool HasRGB()
+        {
+            return true;
+        }
+
+        public override bool HasAutoPowerOff()
+        {
+            return false;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return false;
+        }
+
+        public override bool HasDebounceSetting()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return false;
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        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;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel, LightingZone.Underglow };
+        }
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+
+        public override bool CanChangeDPIProfile()
+        {
+            return true;
+        }
+
+        public override int MaxBrightness()
+        {
+            return 4;
+        }
+
+        protected override byte IndexForLightingMode(LightingMode lightingMode)
+        {
+            if (lightingMode == LightingMode.React)
+            {
+                return 0x03;
+            }
+
+            return ((byte)lightingMode);
+        }
+        protected override LightingMode LightingModeForIndex(byte lightingMode)
+        {
+            if (lightingMode == 0x03)
+            {
+                return LightingMode.React;
+            }
+            return base.LightingModeForIndex(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
+            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 StrixImpactIIElectroPunk : StrixImpactII
+    {
+
+        public StrixImpactIIElectroPunk() : base(0x1956)
+        {
+
+        }
+
+
+        public override string GetDisplayName()
+        {
+            return "ROG Strix Impact II Electro Punk";
+        }
+    }
+}

app/Peripherals/Mouse/Models/StrixImpactIII.cs

@@ -0,0 +1,77 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P518
+    public class StrixImpactIII : AsusMouse
+    {
+        public StrixImpactIII() : base(0x0B05, 0x1A88, "mi_00", false)
+        {
+        }
+
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "ROG Strix Impact III";
+        }
+
+
+        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 HasRGB()
+        {
+            return true;
+        }
+
+        public override LightingZone[] SupportedLightingZones()
+        {
+            return new LightingZone[] { LightingZone.Logo, LightingZone.Scrollwheel };
+        }
+
+        public override bool IsLightingModeSupported(LightingMode lightingMode)
+        {
+            return lightingMode == LightingMode.Static
+                || lightingMode == LightingMode.Breathing
+                || lightingMode == LightingMode.ColorCycle
+                || lightingMode == LightingMode.React
+                || lightingMode == LightingMode.Off;
+        }
+
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        public override bool HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasLowBatteryWarning()
+        {
+            return false;
+        }
+    }
+}

app/Peripherals/Mouse/Models/StrixImpactIIWireless.cs

@@ -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)";
+        }
+    }
+}

app/Peripherals/Mouse/Models/TUFM3.cs

@@ -0,0 +1,169 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P306_Wireless
+    public class TUFM3 : AsusMouse
+    {
+        public TUFM3() : base(0x0B05, 0x1910, "mi_01", false)
+        {
+        }
+
+        public TUFM3(ushort productId, string path) : base(0x0B05, productId, path, 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;
+        }
+    }
+
+    public class TUFM3GenII : TUFM3
+    {
+        public TUFM3GenII() : base(0x1A9B, "mi_02")
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "TUF GAMING M3 (Gen II)";
+        }
+
+        public override int MaxBrightness()
+        {
+            return 100;
+        }
+
+        public override int MaxDPI()
+        {
+            return 8_000;
+        }
+
+        public override int MinDPI()
+        {
+            return 100;
+        }
+
+        public override int DPIIncrements()
+        {
+            return 50;
+        }
+
+        public override bool HasDPIColors()
+        {
+            return true;
+        }
+
+        protected override int ParseDPIProfile(byte[] packet)
+        {
+            return base.ParseDPIProfile(packet) + 1;
+        }
+
+        protected override byte[] GetChangeDPIProfilePacket(int profile)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x0A, 0x00, 0x04 };
+        }
+
+        protected override byte[] GetChangeDPIProfilePacket2(int profile)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x09, 0x00, (byte)(profile - 1) };
+        }
+
+    }
+}

app/Peripherals/Mouse/Models/TUFM4Air.cs

@@ -0,0 +1,66 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P307
+    public class TUFM4Air : AsusMouse
+    {
+        public TUFM4Air() : base(0x0B05, 0x1A03, "mi_00", false)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 4;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "TUF GAMING M4 Air";
+        }
+
+
+        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 HasAngleSnapping()
+        {
+            return true;
+        }
+
+        public override bool HasAngleTuning()
+        {
+            return false;
+        }
+
+        public override bool HasBattery()
+        {
+            return false;
+        }
+
+        public override int DPIIncrements()
+        {
+            return 100;
+        }
+    }
+
+}

app/Peripherals/Mouse/Models/TUFM4Wireless.cs

@@ -0,0 +1,141 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P306_Wireless
+    public class TUFM4Wirelss : AsusMouse
+    {
+        public TUFM4Wirelss() : base(0x0B05, 0x19F4, "mi_00", true)
+        {
+        }
+
+        public TUFM4Wirelss(ushort productId, bool wireless) : base(0x0B05, productId, "mi_00", wireless)
+        {
+        }
+
+        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;
+        }
+    }
+
+    //P310
+    public class TUFM4WirelssCN : TUFM4Wirelss
+    {
+        public TUFM4WirelssCN() : base(0x1A8D, true)
+        {
+
+        }
+
+
+        public override string GetDisplayName()
+        {
+            return "TX GAMING MOUSE (Wireless)";
+        }
+    }
+
+    //P519_Wireless
+    public class TXGamingMini : TUFM4Wirelss
+    {
+        public TXGamingMini() : base(0x1AF5, true)
+        {
+        }
+
+        public TXGamingMini(ushort productId, bool wireless) : base(productId, wireless)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "TX GAMING MOUSE Mini (Wireless)";
+        }
+
+        public override bool HasXYDPI()
+        {
+            return true;
+        }
+
+    }
+
+    //P519_Wired
+    public class TXGamingMiniWired : TXGamingMini
+    {
+        public TXGamingMiniWired() : base(0x1AF3, false)
+        {
+        }
+
+        public override string GetDisplayName()
+        {
+            return "TX GAMING MOUSE Mini (Wired)";
+        }
+
+    }
+}

app/Peripherals/Mouse/Models/TUFM5.cs

@@ -0,0 +1,170 @@
+namespace GHelper.Peripherals.Mouse.Models
+{
+    //P304
+    public class TUFM5 : AsusMouse
+    {
+        public TUFM5() : base(0x0B05, 0x1898, "mi_02", false)
+        {
+        }
+
+        public override int DPIProfileCount()
+        {
+            return 2;
+        }
+
+        public override string GetDisplayName()
+        {
+            return "TUF GAMING M5";
+        }
+
+
+        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 3;
+        }
+        public override int MaxDPI()
+        {
+            return 6_200;
+        }
+        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;
+        }
+
+
+        protected override byte[] GetUpdatePollingRatePacket(PollingRate pollingRate)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x02, 0x00, (byte)pollingRate };
+        }
+
+        protected override byte[] GetUpdateAngleSnappingPacket(bool angleSnapping)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x04, 0x00, (byte)(angleSnapping ? 0x01 : 0x00) };
+        }
+
+        protected override PollingRate ParsePollingRate(byte[] packet)
+        {
+
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return (PollingRate)packet[9];
+            }
+
+            return PollingRate.PR125Hz;
+        }
+
+        protected override bool ParseAngleSnapping(byte[] packet)
+        {
+
+            if (packet[1] == 0x12 && packet[2] == 0x04 && packet[3] == 0x00)
+            {
+                return packet[13] == 0x01;
+            }
+
+            return false;
+        }
+
+        protected override byte[] GetUpdateDebouncePacket(DebounceTime debounce)
+        {
+            return new byte[] { reportId, 0x51, 0x31, 0x03, 0x00, ((byte)debounce) };
+        }
+
+        protected override DebounceTime ParseDebounce(byte[] packet)
+        {
+            if (packet[1] != 0x12 || packet[2] != 0x04 || packet[3] != 0x00)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] < 0x02)
+            {
+                return DebounceTime.MS12;
+            }
+
+            if (packet[11] > 0x07)
+            {
+                return DebounceTime.MS32;
+            }
+
+            return (DebounceTime)packet[11];
+        }
+    }
+}

app/Peripherals/PeripheralsProvider.cs

@@ -0,0 +1,266 @@
+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 GladiusIIOrigin());
+            DetectMouse(new GladiusIIOriginPink());
+            DetectMouse(new GladiusII());
+            DetectMouse(new GladiusIIWireless());
+            DetectMouse(new ROGKerisWireless());
+            DetectMouse(new ROGKerisWirelessWired());
+            DetectMouse(new ROGKeris());
+            DetectMouse(new ROGKerisWirelessEvaEdition());
+            DetectMouse(new ROGKerisWirelessEvaEditionWired());
+            DetectMouse(new TUFM4Air());
+            DetectMouse(new TUFM4Wirelss());
+            DetectMouse(new TUFM4WirelssCN());
+            DetectMouse(new StrixImpactIIWireless());
+            DetectMouse(new StrixImpactIIWirelessWired());
+            DetectMouse(new GladiusIIIWireless());
+            DetectMouse(new GladiusIIIWired());
+            DetectMouse(new GladiusIII());
+            DetectMouse(new GladiusIIIAimpointEva2());
+            DetectMouse(new GladiusIIIAimpointEva2Wired());
+            DetectMouse(new HarpeAceAimLabEdition());
+            DetectMouse(new HarpeAceAimLabEditionWired());
+            DetectMouse(new HarpeAceAimLabEditionOmni());
+            DetectMouse(new TUFM3());
+            DetectMouse(new TUFM3GenII());
+            DetectMouse(new TUFM5());
+            DetectMouse(new KerisWirelssAimpoint());
+            DetectMouse(new KerisWirelssAimpointWired());
+            DetectMouse(new KerisIIAceWired());
+            DetectMouse(new PugioII());
+            DetectMouse(new PugioIIWired());
+            DetectMouse(new StrixImpactII());
+            DetectMouse(new StrixImpactIIElectroPunk());
+            DetectMouse(new Chakram());
+            DetectMouse(new ChakramWired());
+            DetectMouse(new ChakramCore());
+            DetectMouse(new SpathaX());
+            DetectMouse(new StrixCarry());
+            DetectMouse(new StrixImpactIII());
+            DetectMouse(new StrixImpact());
+            DetectMouse(new TXGamingMini());
+            DetectMouse(new TXGamingMiniWired());
+            DetectMouse(new Pugio());
+        }
+
+        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();
+            if (AppConfig.IsZ13()) Program.inputDispatcher.Init();
+        }
+    }
+}

app/Program.cs

@@ -1,9 +1,12 @@
+using GHelper.Ally;
 using GHelper.Battery;
 using GHelper.Display;
 using GHelper.Gpu;
 using GHelper.Helpers;
 using GHelper.Input;
 using GHelper.Mode;
+using GHelper.Peripherals;
+using GHelper.USB;
 using Microsoft.Win32;
 using Ryzen;
 using System.Diagnostics;
@@ -28,13 +31,14 @@ namespace GHelper
         public static SettingsForm settingsForm = new SettingsForm();
 
         public static ModeControl modeControl = new ModeControl();
-        static GPUModeControl gpuControl = new GPUModeControl(settingsForm);
-        static ScreenControl screenControl = new ScreenControl();
-        static ClamshellModeControl clamshellControl = new ClamshellModeControl();
+        public static GPUModeControl gpuControl = new GPUModeControl(settingsForm);
+        public static AllyControl allyControl = new AllyControl(settingsForm);
+        public static ScreenControl screenControl = new ScreenControl(); 
+        public static ClamshellModeControl clamshellControl = new ClamshellModeControl();
 
         public static ToastForm toast = new ToastForm();
 
-        public static IntPtr unRegPowerNotify;
+        public static IntPtr unRegPowerNotify, unRegPowerNotifyLid;
 
         private static long lastAuto;
         private static long lastTheme;
@@ -50,6 +54,13 @@ namespace GHelper
             string action = "";
             if (args.Length > 0) action = args[0];
 
+            if (action == "charge")
+            {
+                BatteryLimit();
+                Application.Exit();
+                return;
+            }
+
             string language = AppConfig.GetString("language");
 
             if (language != null && language.Length > 0)
@@ -63,11 +74,16 @@ namespace GHelper
 
             ProcessHelper.CheckAlreadyRunning();
 
-            try
-            {
-                acpi = new AsusACPI();
-            }
-            catch
+            Logger.WriteLine("------------");
+            Logger.WriteLine("App launched: " + AppConfig.GetModel() + " :" + Assembly.GetExecutingAssembly().GetName().Version.ToString() + CultureInfo.CurrentUICulture + (ProcessHelper.IsUserAdministrator() ? "." : ""));
+
+            var startCount = AppConfig.Get("start_count") + 1;
+            AppConfig.Set("start_count", startCount);
+            Logger.WriteLine("Start Count: " + startCount);
+
+            acpi = new AsusACPI();
+
+            if (!acpi.IsConnected() && AppConfig.IsASUS())
             {
                 DialogResult dialogResult = MessageBox.Show(Properties.Strings.ACPIError, Properties.Strings.StartupError, MessageBoxButtons.YesNo);
                 if (dialogResult == DialogResult.Yes)
@@ -79,8 +95,7 @@ namespace GHelper
                 return;
             }
 
-            Logger.WriteLine("------------");
-            Logger.WriteLine("App launched: " + AppConfig.GetModel() + " :" + Assembly.GetExecutingAssembly().GetName().Version.ToString() + CultureInfo.CurrentUICulture + (ProcessHelper.IsUserAdministrator() ? "." : ""));
+            ProcessHelper.KillByName("ASUSSmartDisplayControl");
 
             Application.EnableVisualStyles();
 
@@ -94,23 +109,59 @@ namespace GHelper
             settingsForm.InitAura();
             settingsForm.InitMatrix();
 
+            gpuControl.InitXGM();
 
-            SetAutoModes();
+            SetAutoModes(init: true);
 
             // Subscribing for system power change events
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
             SystemEvents.UserPreferenceChanged += SystemEvents_UserPreferenceChanged;
+
+            SystemEvents.SessionSwitch += SystemEvents_SessionSwitch;
+            SystemEvents.SessionEnding += SystemEvents_SessionEnding;
+
             clamshellControl.RegisterDisplayEvents();
             clamshellControl.ToggleLidAction();
 
             // Subscribing for monitor power on events
-            PowerSettingGuid settingGuid = new NativeMethods.PowerSettingGuid();
-            unRegPowerNotify = NativeMethods.RegisterPowerSettingNotification(settingsForm.Handle, settingGuid.ConsoleDisplayState, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
+            unRegPowerNotify = NativeMethods.RegisterPowerSettingNotification(settingsForm.Handle, PowerSettingGuid.ConsoleDisplayState, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
+            unRegPowerNotifyLid = NativeMethods.RegisterPowerSettingNotification(settingsForm.Handle, PowerSettingGuid.LIDSWITCH_STATE_CHANGE, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
 
 
+            Task task = Task.Run((Action)PeripheralsProvider.DetectAllAsusMice);
+            PeripheralsProvider.RegisterForDeviceEvents();
+
             if (Environment.CurrentDirectory.Trim('\\') == Application.StartupPath.Trim('\\') || action.Length > 0)
             {
-                SettingsToggle(action);
+                SettingsToggle(false);
+            }
+
+            switch (action)
+            {
+                case "cpu":
+                    Startup.ReScheduleAdmin();
+                    settingsForm.FansToggle();
+                    break;
+                case "gpu":
+                    Startup.ReScheduleAdmin();
+                    settingsForm.FansToggle(1);
+                    break;
+                case "gpurestart":
+                    gpuControl.RestartGPU(false);
+                    break;
+                case "services":
+                    settingsForm.extraForm = new Extra();
+                    settingsForm.extraForm.Show();
+                    settingsForm.extraForm.ServiesToggle();
+                    break;
+                case "uv":
+                    Startup.ReScheduleAdmin();
+                    settingsForm.FansToggle(2);
+                    modeControl.SetRyzen();
+                    break;
+                default:
+                    Startup.StartupCheck();
+                    break;
             }
 
             Application.Run();
@@ -118,6 +169,21 @@ namespace GHelper
         }
 
 
+        private static void SystemEvents_SessionEnding(object sender, SessionEndingEventArgs e)
+        {
+            gpuControl.StandardModeFix();
+            BatteryControl.AutoBattery();
+            InputDispatcher.ShutdownStatusLed();
+        }
+
+        private static void SystemEvents_SessionSwitch(object sender, SessionSwitchEventArgs e)
+        {
+            if (e.Reason == SessionSwitchReason.SessionLogon || e.Reason == SessionSwitchReason.SessionUnlock)
+            {
+                Logger.WriteLine("Session:" + e.Reason.ToString());
+                screenControl.AutoScreen();
+            }
+        }
 
         static void SystemEvents_UserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e)
         {
@@ -128,20 +194,28 @@ namespace GHelper
             {
                 case UserPreferenceCategory.General:
                     bool changed = settingsForm.InitTheme();
+                    settingsForm.VisualiseIcon();
+
                     if (changed)
                     {
                         Debug.WriteLine("Theme Changed");
                         lastTheme = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                     }
 
-                    if (settingsForm.fans is not null && settingsForm.fans.Text != "")
-                        settingsForm.fans.InitTheme();
+                    if (settingsForm.fansForm is not null && settingsForm.fansForm.Text != "")
+                        settingsForm.fansForm.InitTheme();
 
-                    if (settingsForm.keyb is not null && settingsForm.keyb.Text != "")
-                        settingsForm.keyb.InitTheme();
+                    if (settingsForm.extraForm is not null && settingsForm.extraForm.Text != "")
+                        settingsForm.extraForm.InitTheme();
 
-                    if (settingsForm.updates is not null && settingsForm.updates.Text != "")
-                        settingsForm.updates.InitTheme();
+                    if (settingsForm.updatesForm is not null && settingsForm.updatesForm.Text != "")
+                        settingsForm.updatesForm.InitTheme();
+
+                    if (settingsForm.matrixForm is not null && settingsForm.matrixForm.Text != "")
+                        settingsForm.matrixForm.InitTheme();
+
+                    if (settingsForm.handheldForm is not null && settingsForm.handheldForm.Text != "")
+                        settingsForm.handheldForm.InitTheme();
 
                     break;
             }
@@ -149,15 +223,21 @@ namespace GHelper
 
 
 
-        public static void SetAutoModes(bool powerChanged = false)
+        public static bool SetAutoModes(bool powerChanged = false, bool init = false)
         {
 
-            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAuto) < 3000) return;
+            if (Math.Abs(DateTimeOffset.Now.ToUnixTimeMilliseconds() - lastAuto) < 3000) return false;
             lastAuto = DateTimeOffset.Now.ToUnixTimeMilliseconds();
 
             isPlugged = SystemInformation.PowerStatus.PowerLineStatus;
             Logger.WriteLine("AutoSetting for " + isPlugged.ToString());
 
+            BatteryControl.AutoBattery(init);
+            if (init)
+            {
+                InputDispatcher.InitScreenpad();
+            }
+
             inputDispatcher.Init();
 
             modeControl.AutoPerformance(powerChanged);
@@ -170,69 +250,89 @@ namespace GHelper
                 screenControl.AutoScreen();
             }
 
-            BatteryControl.SetBatteryChargeLimit();
+            settingsForm.matrixControl.SetDevice(true);
 
-            settingsForm.AutoKeyboard();
-            settingsForm.matrix.SetMatrix();
+            if (AppConfig.IsAlly())
+            {
+                allyControl.Init();
+            }
+            else
+            {
+                InputDispatcher.AutoKeyboard();
+            }
+
+            screenControl.InitMiniled();
+            InputDispatcher.InitStatusLed();
+            XGM.InitLight();
+            VisualControl.InitBrightness();
+
+            return true;
         }
 
         private static void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
         {
+
+            if (e.Mode == PowerModes.Suspend)
+            {
+                Logger.WriteLine("Power Mode Changed:" + e.Mode.ToString());
+                gpuControl.StandardModeFix();
+                InputDispatcher.ShutdownStatusLed();
+            }
+
+            int delay = AppConfig.Get("charger_delay");
+            if (delay > 0)
+            {
+                Logger.WriteLine($"Charger Delay: {delay}");
+                Thread.Sleep(delay);
+            }
+
             if (SystemInformation.PowerStatus.PowerLineStatus == isPlugged) return;
-            Logger.WriteLine("Power Mode Changed");
+            if (AppConfig.Is("disable_power_event")) return;
             SetAutoModes(true);
         }
 
-
-
-        public static void SettingsToggle(string action = "")
+        public static void SettingsToggle(bool checkForFocus = true, bool trayClick = false)
         {
-            if (settingsForm.Visible) settingsForm.HideAll();
+            if (settingsForm.Visible)
+            {
+                // If helper window is not on top, this just focuses on the app again
+                // Pressing the ghelper button again will hide the app
+                if (checkForFocus && !settingsForm.HasAnyFocus(trayClick) && !AppConfig.Is("topmost"))
+                {
+                    settingsForm.ShowAll();
+                }
+                else
+                {
+                    settingsForm.HideAll();
+                }
+            }
             else
             {
+                var screen = Screen.PrimaryScreen;
+                if (screen is null) screen = Screen.FromControl(settingsForm);
 
-                settingsForm.Left = Screen.FromControl(settingsForm).WorkingArea.Width - 10 - settingsForm.Width;
-                settingsForm.Top = Screen.FromControl(settingsForm).WorkingArea.Height - 10 - settingsForm.Height;
+                settingsForm.Location = screen.WorkingArea.Location;
+                settingsForm.Left = screen.WorkingArea.Width - 10 - settingsForm.Width;
+                settingsForm.Top = screen.WorkingArea.Height - 10 - settingsForm.Height;
 
                 settingsForm.Show();
                 settingsForm.Activate();
 
-                settingsForm.Left = Screen.FromControl(settingsForm).WorkingArea.Width - 10 - settingsForm.Width;
-                settingsForm.Top = Screen.FromControl(settingsForm).WorkingArea.Height - 10 - settingsForm.Height;
+                settingsForm.Left = screen.WorkingArea.Width - 10 - settingsForm.Width;
+
+                if (AppConfig.IsAlly())
+                    settingsForm.Top = Math.Max(10, screen.Bounds.Height - 110 - settingsForm.Height);
+                else
+                    settingsForm.Top = screen.WorkingArea.Height - 10 - settingsForm.Height;
 
                 settingsForm.VisualiseGPUMode();
-
-                switch (action)
-                {
-                    case "cpu":
-                        Startup.ReScheduleAdmin();
-                        settingsForm.FansToggle();
-                        break;
-                    case "gpu":
-                        Startup.ReScheduleAdmin();
-                        settingsForm.FansToggle(1);
-                        break;
-                    case "gpurestart":
-                        gpuControl.RestartGPU(false);
-                        break;
-                    case "services":
-                        settingsForm.keyb = new Extra();
-                        settingsForm.keyb.Show();
-                        settingsForm.keyb.ServiesToggle();
-                        break;
-                    case "uv":
-                        Startup.ReScheduleAdmin();
-                        settingsForm.FansToggle(2);
-                        modeControl.SetRyzen();
-                        break;
-                }
             }
         }
 
         static void TrayIcon_MouseClick(object? sender, MouseEventArgs e)
         {
             if (e.Button == MouseButtons.Left)
-                SettingsToggle();
+                SettingsToggle(trayClick: true);
 
         }
 
@@ -241,12 +341,30 @@ namespace GHelper
         static void OnExit(object sender, EventArgs e)
         {
             trayIcon.Visible = false;
+            PeripheralsProvider.UnregisterForDeviceEvents();
             clamshellControl.UnregisterDisplayEvents();
             NativeMethods.UnregisterPowerSettingNotification(unRegPowerNotify);
+            NativeMethods.UnregisterPowerSettingNotification(unRegPowerNotifyLid);
             Application.Exit();
         }
 
+        static void BatteryLimit()
+        {
+            try
+            {
+                int limit = AppConfig.Get("charge_limit");
+                if (limit > 0 && limit < 100)
+                {
+                    Logger.WriteLine($"------- Startup Battery Limit {limit} -------");
+                    acpi = new AsusACPI();
+                    acpi.DeviceSet(AsusACPI.BatteryLimit, limit, "Limit");
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.WriteLine("Startup Battery Limit Error: " + ex.Message);
+            }
+        }
 
     }
-
 }

app/Properties/Resources.Designer.cs

@@ -60,6 +60,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap ally {
+            get {
+                object obj = ResourceManager.GetObject("ally", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -110,6 +120,56 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
+        /// </summary>
+        internal static System.Drawing.Icon dark_eco {
+            get {
+                object obj = ResourceManager.GetObject("dark_eco", 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 dark_standard {
+            get {
+                object obj = ResourceManager.GetObject("dark_standard", resourceCulture);
+                return ((System.Drawing.Icon)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap dot_eco {
+            get {
+                object obj = ResourceManager.GetObject("dot_eco", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap dot_standard {
+            get {
+                object obj = ResourceManager.GetObject("dot_standard", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap dot_ultimate {
+            get {
+                object obj = ResourceManager.GetObject("dot_ultimate", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
         /// </summary>
@@ -130,6 +190,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_animation_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-animation-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -140,6 +210,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_batterie_voll_geladen_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_batterie_voll_geladen_48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -150,6 +230,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_brightness_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-brightness-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -180,6 +270,56 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_color_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-color-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_controller_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-controller-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_controller_96 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_controller_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_controls_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-controls-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_dollar_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-dollar-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -250,6 +390,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_heartbeat_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-heartbeat-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -260,6 +410,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_hibernate_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-hibernate-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_joystick_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-joystick-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -280,6 +450,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_ladende_batterie_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_ladende_batterie_48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -320,6 +500,36 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_maus_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_maus_32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_maus_48 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_maus_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_mauszeiger_50 {
+            get {
+                object obj = ResourceManager.GetObject("icons8_mauszeiger_50", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -340,6 +550,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_next_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-next-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -360,6 +580,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_quit_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-quit-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -410,6 +640,16 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_search_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-search-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -440,6 +680,26 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_software_32_white {
+            get {
+                object obj = ResourceManager.GetObject("icons8-software-32-white", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_soonvibes_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-soonvibes-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -500,6 +760,86 @@ namespace GHelper.Properties {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_xbox_lt_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-xbox-lt-32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap icons8_xbox_rt_32 {
+            get {
+                object obj = ResourceManager.GetObject("icons8-xbox-rt-32", 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 light_eco {
+            get {
+                object obj = ResourceManager.GetObject("light_eco", 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 light_standard {
+            get {
+                object obj = ResourceManager.GetObject("light_standard", resourceCulture);
+                return ((System.Drawing.Icon)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap lighting_dot_24 {
+            get {
+                object obj = ResourceManager.GetObject("lighting_dot_24", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap lighting_dot_32 {
+            get {
+                object obj = ResourceManager.GetObject("lighting_dot_32", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap lighting_dot_48 {
+            get {
+                object obj = ResourceManager.GetObject("lighting_dot_48", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Byte[].
+        /// </summary>
+        internal static byte[] MFont {
+            get {
+                object obj = ResourceManager.GetObject("MFont", resourceCulture);
+                return ((byte[])(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
         /// </summary>