Merge pull request #12 from OpenVR-Advanced-Settings/formatting

Implement clang-format and format entire src directory

.appveyor.yml

@@ -7,6 +7,7 @@ environment:
     JOM_LOC: '"C:\Qt\Tools\QtCreator\bin\jom.exe"'
     NSIS_LOC: '"C:\Program Files (x86)\NSIS\"'
     ZIP_LOC: 7z
+    CLANG_FORMAT_LOC: '"C:\Program Files\LLVM\bin\clang-format.exe"'
     COMPILER: msvc
     VSVER: 14
     
@@ -17,6 +18,7 @@ init:
   - set TAG_NAME=%APPVEYOR_REPO_TAG_NAME%
 
 build_script:
+  - python ./build_scripts/run-clang-format.py ./src -r --clang-format-executable %CLANG_FORMAT_LOC%  --color always
   - call "build_windows.cmd"
 
 artifacts:

.clang-format

@@ -0,0 +1,105 @@
+---
+Language:        Cpp
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands: true
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:   
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     true
+  AfterUnion:      true
+  AfterExternBlock: true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: All
+BreakBeforeBraces: Allman
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: false
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:   
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Preserve
+IncludeCategories: 
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        1
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        2
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentPPDirectives: AfterHash
+IndentWidth:     4
+IndentWrappedFunctionNames: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: Inner
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    false
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: true
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: true
+SpacesInParentheses: true
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        4
+UseTab:          Never
+...
+

.travis.yml

@@ -10,6 +10,7 @@ install:
   - sudo apt-get install build-essential qtbase5-dev qttools5-dev qtdeclarative5-dev qtmultimedia5-dev qt5-default qttools5-dev-tools
 
 script:
+  - python ./build_scripts/run-clang-format.py ./src -r --color always
   - mkdir build && cd build
   - qmake ..
   - make

Readme.md

@@ -1,5 +1,7 @@
-
+![language](https://img.shields.io/badge/Language-C%2B%2B11%2C%20QML-green.svg) ![dependencies](https://img.shields.io/badge/Dependencies-OpenVR%2C%20Qt5-green.svg)
-![language](https://img.shields.io/badge/Language-C%2B%2B11%2C%20QML-green.svg) ![dependencies](https://img.shields.io/badge/Dependencies-OpenVR%2C%20Qt5-green.svg) ![license_gpl3](https://img.shields.io/badge/License-GPL%203.0-green.svg) [![Build status](https://ci.appveyor.com/api/projects/status/8oivf5xws6vsq2x3/branch/master?svg=true)](https://ci.appveyor.com/project/icewind1991/openvr-advancedsettings/branch/master)
+![license_gpl3](https://img.shields.io/badge/License-GPL%203.0-green.svg) 
+[![Build status](https://ci.appveyor.com/api/projects/status/8oivf5xws6vsq2x3/branch/master?svg=true)](https://ci.appveyor.com/project/icewind1991/openvr-advancedsettings/branch/master)
+[![Build Status](https://travis-ci.org/OpenVR-Advanced-Settings/OpenVR-AdvancedSettings.svg?branch=master)](https://travis-ci.org/OpenVR-Advanced-Settings/OpenVR-AdvancedSettings)
 
  > * [Features](#features)
  > * [Usage](#usage)
@@ -272,6 +274,8 @@ Full build instructions can be found [here](docs/building_for_windows.md).
 If you want to run Advanced Settings on linux you can build it yourself using `qmake` and `make` or using Qt Creator, you'll have to copy the `res` folder from the `src` folder into folder that contains the binary
 and copy `third-party/openvr/lib/linux64/libopenvr_api.so` into your systems library path.
 
+If you want to contribute changes running `clang-format` is necessary. More details are in the [CONTRIBUTING.md](docs/CONTRIBUTING.md) file.
+
 <a name="notes"></a>
 # Notes:
 

build_scripts/linux/format

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+clang-format --version
+
+if [ $? -eq 0 ]; then
+    echo "Clang-format found."
+    build_path="`dirname \"$0\"`"
+    project_path=$build_path/../..
+
+    find $project_path/src/ -regex '.*\.\(cpp\|h\)' -exec clang-format -style=file -i {} \; -exec echo "Iteration 1: {}" \;
+    find $project_path/src/ -regex '.*\.\(cpp\|h\)' -exec clang-format -style=file -i {} \; -exec echo "Iteration 2: {}" \;
+    echo "DONE"
+else
+    echo "Could not find clang-format."
+fi
+

build_scripts/linux/verify_formatting

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+clang-format --version;
+
+if [ $? -eq 0 ]; then
+    echo "Clang-format found."
+    build_path="`dirname \"$0\"`"
+    project_path=$build_path/../..
+
+    python $project_path/build_scripts/run-clang-format.py $project_path/src -r --color always;
+    if [ $? -eq 0 ]; then
+        echo "FORMATTED CORRECTLY."
+    else
+        echo "NOT FORMATTED CORRECTLY."
+    fi
+else
+    echo "Could not find clang-format."
+fi
+

build_scripts/run-clang-format.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python
+"""A wrapper script around clang-format, suitable for linting multiple files
+and to use for continuous integration.
+
+This is an alternative API for the clang-format command line.
+It runs over multiple files and directories in parallel.
+A diff output is produced and a sensible exit code is returned.
+
+"""
+
+from __future__ import print_function, unicode_literals
+
+import argparse
+import codecs
+import difflib
+import fnmatch
+import io
+import multiprocessing
+import os
+import signal
+import subprocess
+import sys
+import traceback
+
+from functools import partial
+
+DEFAULT_EXTENSIONS = 'c,h,C,H,cpp,hpp,cc,hh,c++,h++,cxx,hxx'
+
+
+class ExitStatus:
+    SUCCESS = 0
+    DIFF = 1
+    TROUBLE = 2
+
+
+def list_files(files, recursive=False, extensions=None, exclude=None):
+    if extensions is None:
+        extensions = []
+    if exclude is None:
+        exclude = []
+
+    out = []
+    for file in files:
+        if recursive and os.path.isdir(file):
+            for dirpath, dnames, fnames in os.walk(file):
+                fpaths = [os.path.join(dirpath, fname) for fname in fnames]
+                for pattern in exclude:
+                    # os.walk() supports trimming down the dnames list
+                    # by modifying it in-place,
+                    # to avoid unnecessary directory listings.
+                    dnames[:] = [
+                        x for x in dnames
+                        if
+                        not fnmatch.fnmatch(os.path.join(dirpath, x), pattern)
+                    ]
+                    fpaths = [
+                        x for x in fpaths if not fnmatch.fnmatch(x, pattern)
+                    ]
+                for f in fpaths:
+                    ext = os.path.splitext(f)[1][1:]
+                    if ext in extensions:
+                        out.append(f)
+        else:
+            out.append(file)
+    return out
+
+
+def make_diff(file, original, reformatted):
+    return list(
+        difflib.unified_diff(
+            original,
+            reformatted,
+            fromfile='{}\t(original)'.format(file),
+            tofile='{}\t(reformatted)'.format(file),
+            n=3))
+
+
+class DiffError(Exception):
+    def __init__(self, message, errs=None):
+        super(DiffError, self).__init__(message)
+        self.errs = errs or []
+
+
+class UnexpectedError(Exception):
+    def __init__(self, message, exc=None):
+        super(UnexpectedError, self).__init__(message)
+        self.formatted_traceback = traceback.format_exc()
+        self.exc = exc
+
+
+def run_clang_format_diff_wrapper(args, file):
+    try:
+        ret = run_clang_format_diff(args, file)
+        return ret
+    except DiffError:
+        raise
+    except Exception as e:
+        raise UnexpectedError('{}: {}: {}'.format(file, e.__class__.__name__,
+                                                  e), e)
+
+
+def run_clang_format_diff(args, file):
+    try:
+        with io.open(file, 'r', encoding='utf-8') as f:
+            original = f.readlines()
+    except IOError as exc:
+        raise DiffError(str(exc))
+    invocation = [args.clang_format_executable, file]
+
+    # Use of utf-8 to decode the process output.
+    #
+    # Hopefully, this is the correct thing to do.
+    #
+    # It's done due to the following assumptions (which may be incorrect):
+    # - clang-format will returns the bytes read from the files as-is,
+    #   without conversion, and it is already assumed that the files use utf-8.
+    # - if the diagnostics were internationalized, they would use utf-8:
+    #   > Adding Translations to Clang
+    #   >
+    #   > Not possible yet!
+    #   > Diagnostic strings should be written in UTF-8,
+    #   > the client can translate to the relevant code page if needed.
+    #   > Each translation completely replaces the format string
+    #   > for the diagnostic.
+    #   > -- http://clang.llvm.org/docs/InternalsManual.html#internals-diag-translation
+    #
+    # It's not pretty, due to Python 2 & 3 compatibility.
+    encoding_py3 = {}
+    if sys.version_info[0] >= 3:
+        encoding_py3['encoding'] = 'utf-8'
+
+    try:
+        proc = subprocess.Popen(
+            invocation,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True,
+            **encoding_py3)
+    except OSError as exc:
+        raise DiffError(str(exc))
+    proc_stdout = proc.stdout
+    proc_stderr = proc.stderr
+    if sys.version_info[0] < 3:
+        # make the pipes compatible with Python 3,
+        # reading lines should output unicode
+        encoding = 'utf-8'
+        proc_stdout = codecs.getreader(encoding)(proc_stdout)
+        proc_stderr = codecs.getreader(encoding)(proc_stderr)
+    # hopefully the stderr pipe won't get full and block the process
+    outs = list(proc_stdout.readlines())
+    errs = list(proc_stderr.readlines())
+    proc.wait()
+    if proc.returncode:
+        raise DiffError("clang-format exited with status {}: '{}'".format(
+            proc.returncode, file), errs)
+    return make_diff(file, original, outs), errs
+
+
+def bold_red(s):
+    return '\x1b[1m\x1b[31m' + s + '\x1b[0m'
+
+
+def colorize(diff_lines):
+    def bold(s):
+        return '\x1b[1m' + s + '\x1b[0m'
+
+    def cyan(s):
+        return '\x1b[36m' + s + '\x1b[0m'
+
+    def green(s):
+        return '\x1b[32m' + s + '\x1b[0m'
+
+    def red(s):
+        return '\x1b[31m' + s + '\x1b[0m'
+
+    for line in diff_lines:
+        if line[:4] in ['--- ', '+++ ']:
+            yield bold(line)
+        elif line.startswith('@@ '):
+            yield cyan(line)
+        elif line.startswith('+'):
+            yield green(line)
+        elif line.startswith('-'):
+            yield red(line)
+        else:
+            yield line
+
+
+def print_diff(diff_lines, use_color):
+    if use_color:
+        diff_lines = colorize(diff_lines)
+    if sys.version_info[0] < 3:
+        sys.stdout.writelines((l.encode('utf-8') for l in diff_lines))
+    else:
+        sys.stdout.writelines(diff_lines)
+
+
+def print_trouble(prog, message, use_colors):
+    error_text = 'error:'
+    if use_colors:
+        error_text = bold_red(error_text)
+    print("{}: {} {}".format(prog, error_text, message), file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '--clang-format-executable',
+        metavar='EXECUTABLE',
+        help='path to the clang-format executable',
+        default='clang-format')
+    parser.add_argument(
+        '--extensions',
+        help='comma separated list of file extensions (default: {})'.format(
+            DEFAULT_EXTENSIONS),
+        default=DEFAULT_EXTENSIONS)
+    parser.add_argument(
+        '-r',
+        '--recursive',
+        action='store_true',
+        help='run recursively over directories')
+    parser.add_argument('files', metavar='file', nargs='+')
+    parser.add_argument(
+        '-q',
+        '--quiet',
+        action='store_true')
+    parser.add_argument(
+        '-j',
+        metavar='N',
+        type=int,
+        default=0,
+        help='run N clang-format jobs in parallel'
+        ' (default number of cpus + 1)')
+    parser.add_argument(
+        '--color',
+        default='auto',
+        choices=['auto', 'always', 'never'],
+        help='show colored diff (default: auto)')
+    parser.add_argument(
+        '-e',
+        '--exclude',
+        metavar='PATTERN',
+        action='append',
+        default=[],
+        help='exclude paths matching the given glob-like pattern(s)'
+        ' from recursive search')
+
+    args = parser.parse_args()
+
+    # use default signal handling, like diff return SIGINT value on ^C
+    # https://bugs.python.org/issue14229#msg156446
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
+    try:
+        signal.SIGPIPE
+    except AttributeError:
+        # compatibility, SIGPIPE does not exist on Windows
+        pass
+    else:
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+
+    colored_stdout = False
+    colored_stderr = False
+    if args.color == 'always':
+        colored_stdout = True
+        colored_stderr = True
+    elif args.color == 'auto':
+        colored_stdout = sys.stdout.isatty()
+        colored_stderr = sys.stderr.isatty()
+
+    retcode = ExitStatus.SUCCESS
+    files = list_files(
+        args.files,
+        recursive=args.recursive,
+        exclude=args.exclude,
+        extensions=args.extensions.split(','))
+
+    if not files:
+        return
+
+    njobs = args.j
+    if njobs == 0:
+        njobs = multiprocessing.cpu_count() + 1
+    njobs = min(len(files), njobs)
+
+    if njobs == 1:
+        # execute directly instead of in a pool,
+        # less overhead, simpler stacktraces
+        it = (run_clang_format_diff_wrapper(args, file) for file in files)
+        pool = None
+    else:
+        pool = multiprocessing.Pool(njobs)
+        it = pool.imap_unordered(
+            partial(run_clang_format_diff_wrapper, args), files)
+    while True:
+        try:
+            outs, errs = next(it)
+        except StopIteration:
+            break
+        except DiffError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            retcode = ExitStatus.TROUBLE
+            sys.stderr.writelines(e.errs)
+        except UnexpectedError as e:
+            print_trouble(parser.prog, str(e), use_colors=colored_stderr)
+            sys.stderr.write(e.formatted_traceback)
+            retcode = ExitStatus.TROUBLE
+            # stop at the first unexpected error,
+            # something could be very wrong,
+            # don't process all files unnecessarily
+            if pool:
+                pool.terminate()
+            break
+        else:
+            sys.stderr.writelines(errs)
+            if outs == []:
+                continue
+            if not args.quiet:
+                print_diff(outs, use_color=colored_stdout)
+            if retcode == ExitStatus.SUCCESS:
+                retcode = ExitStatus.DIFF
+    return retcode
+
+
+if __name__ == '__main__':
+    sys.exit(main())

build_scripts/win/format.cmd

@@ -0,0 +1,60 @@
+@echo off
+REM Echo off to avoid spam.
+
+REM Non zero is failure, 0 is success.
+SET exit_code_success=0
+SET exit_code_failure_build_apps=1
+SET exit_code_failure_build_locations=2
+
+REM Used for echos.
+SET current_activity=FORMAT
+
+REM If scripts are chain called the original dirs should not be overwritten.
+IF NOT DEFINED original_dir (
+    SET original_dir=%CD%
+)
+IF NOT DEFINED project_dir (
+    REM Arg 0 (called %0) is the full path to the file.
+    REM https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/call#batch-parameters
+    REM As per above link, %~dp0 expands the zeroth arg to a drive letter and path only.
+    REM Project dir is up two dirs from the file.
+    SET project_dir=%~dp0\..\..\
+)
+
+ECHO %current_activity%: Testing if clang-format can be located:
+
+IF NOT DEFINED CLANG_FORMAT_LOC (
+    ECHO %current_activity%: CLANG_FORMAT_LOC not defined. Using default value.
+    SET CLANG_FORMAT_LOC="C:\Program Files\LLVM\bin\clang-format.exe"
+)
+ECHO %current_activity%: CLANG_FORMAT_LOC set to '%CLANG_FORMAT_LOC%'.
+
+REM EXIST won't find items in the PATH. WHERE will.
+SET CLANG_FORMAT_VALID=0
+IF EXIST %CLANG_FORMAT_LOC% SET CLANG_FORMAT_VALID=1
+IF %CLANG_FORMAT_VALID% EQU 0 (
+    WHERE /Q %CLANG_FORMAT_LOC%
+    IF NOT ERRORLEVEL 1 SET CLANG_FORMAT_VALID=1
+)
+
+IF %CLANG_FORMAT_VALID% EQU 1 (
+    ECHO %current_activity%: CLANG_FORMAT_LOC exists.
+) ELSE (
+    ECHO %current_activity%: CLANG_FORMAT_LOC directory does not exist. Exiting.
+    EXIT /B %exit_code_failure_build_locations%
+)
+
+ECHO %current_activity%: Clang-format located.
+
+%CLANG_FORMAT_LOC% --version
+
+REM First iteration.
+FOR /R %project_dir%\src\ %%F IN (*.cpp *.h) DO (%CLANG_FORMAT_LOC% --style=file -i %%F & ECHO Iteration 1. %%F)
+
+REM Clang-format is sometimes indecisive about which exact rules to apply,
+REM leading to differences between first and second iteration. 
+REM Do it twice, just to be sure.
+
+FOR /R %project_dir%\src\ %%F IN (*.cpp *.h) DO (%CLANG_FORMAT_LOC% --style=file -i %%F & ECHO Iteration 2. %%F)
+
+ECHO %current_activity%: %current_activity% DONE.

build_scripts/win/verify_formatting.cmd

@@ -0,0 +1,40 @@
+@echo off
+REM Arg 0 (called %0) is the full path to the file.
+REM https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/call#batch-parameters
+REM As per above link, %~dp0 expands the zeroth arg to a drive letter and path only.
+REM Project dir is up two dirs from the file.
+SET project_dir=%~dp0\..\..\
+
+ECHO %current_activity%: Testing if clang-format can be located:
+
+IF NOT DEFINED CLANG_FORMAT_LOC (
+    ECHO %current_activity%: CLANG_FORMAT_LOC not defined. Using default value.
+    SET CLANG_FORMAT_LOC="C:\Program Files\LLVM\bin\clang-format.exe"
+)
+ECHO %current_activity%: CLANG_FORMAT_LOC set to '%CLANG_FORMAT_LOC%'.
+
+REM EXIST won't find items in the PATH. WHERE will.
+SET CLANG_FORMAT_VALID=0
+IF EXIST %CLANG_FORMAT_LOC% SET CLANG_FORMAT_VALID=1
+IF %CLANG_FORMAT_VALID% EQU 0 (
+    WHERE /Q %CLANG_FORMAT_LOC%
+    IF NOT ERRORLEVEL 1 SET CLANG_FORMAT_VALID=1
+)
+
+IF %CLANG_FORMAT_VALID% EQU 1 (
+    ECHO %current_activity%: CLANG_FORMAT_LOC exists.
+) ELSE (
+    ECHO %current_activity%: CLANG_FORMAT_LOC directory does not exist. Exiting.
+    EXIT /B %exit_code_failure_build_locations%
+)
+
+ECHO %current_activity%: Clang-format located.
+
+%CLANG_FORMAT_LOC% --version
+
+python %project_dir%/build_scripts/run-clang-format.py %project_dir%/src -r --color never --clang-format-executable %CLANG_FORMAT_LOC%
+IF NOT ERRORLEVEL 1 (
+    ECHO FORMATTED CORRECTLY.
+) ELSE (
+    ECHO NOT FORMATTED CORRECTLY.
+)

docs/CONTRIBUTING.md

@@ -0,0 +1,49 @@
+<a name="top"></a>
+# How to contribute to OpenVR Advanced Settings
+
+ > * [You found a bug or have a suggestion for improvement](#bug_improvement)
+ > * [You wrote a patch](#patch)
+ >   * [Building](#building)
+ >   * [Formatting](#formatting)
+ >   * [Style guide](#style)
+
+<a name="bug_improvement"></a>
+## You found a bug or have a suggestion for improvement
+
+First, look through the [issues page](https://github.com/OpenVR-Advanced-Settings/OpenVR-AdvancedSettings/issues) and see if there are any open issues relevant to yours. If there are, describe your issue in detail and why you think it's relevant to the already open issue. 
+
+If there aren't any open issues relevant to yours, create a new issue and give as much detail as possible.
+
+For bug reports include what you expect to happen, what happened, version number of the application, operating system, SteamVR version number (if possible) and any other information you find relevant.
+
+For improvement requests include what you're expecting to do, why you want the feature this way, the problem that you're solving and any other information that you find relevant.
+
+Include logs if possible. Logs can be found in `%APPDATA%\matzman666\OpenVRAdvancedSettings\AdvancedSettings.log` on Windows.
+
+<a name="patch"></a>
+## You want to submit changes
+
+<a name="building"></a>
+### Building
+
+If you haven't already, read the instructions for how to build on [Windows](https://github.com/OpenVR-Advanced-Settings/OpenVR-AdvancedSettings/tree/master#building_on_windows) or [Linux](https://github.com/OpenVR-Advanced-Settings/OpenVR-AdvancedSettings/tree/master#building_on_linux). Your patch must build on all platforms without errors (warnings are treated as errors). Notice that different compilers have different warning messages, being able to successfully compile on one does not mean that all of them will pass. The pull request will be built on both Windows (msvc) and Linux (gcc and clang) CI servers.
+
+<a name="formatting"></a>
+### Formatting
+
+This project uses `clang-format` (part of the [LLVM collection](https://releases.llvm.org/download.html)) on all `*.cpp`and `*.h` files in the `src` directory, using the supplied `.clang-format` file in the root of the repository. Correct formatting is checked by the CI servers.
+
+The `.\build_scripts\win\format.cmd` (for Windows) and `./build_scripts/linux/format` (for Linux) scripts will automatically run `clang-format` on all required files.
+
+The Windows script requires that either your `clang-format.exe` is in `C:\Program Files\LLVM\bin\clang-format.exe` or the `CLANG_FORMAT_LOC` environment variable is set to the location of the `.exe`.
+
+The Linux script requires that `clang-format` is in your `path`.
+
+There are `clang-format` plugins for many IDEs, including  [Qt Creator](https://doc.qt.io/qtcreator/creator-beautifier.html) and [Visual Studio](https://marketplace.visualstudio.com/items?itemName=LLVMExtensions.ClangFormat).
+
+To verify that your patch has been formatted correctly, run `.\build_scripts\win\verify_formatting.cmd` on Windows or `./build_scripts/linux/verify_formatting` on Linux. If there are formatting changes needed the script will output a diff showing which changes are needed, otherwise it will output `FORMATTED CORRECTLY.`. The verification script requires `python` in the `path` for Linux and Windows. On Windows the verification script will either use the `CLANG_FORMAT_LOC` environment variable or the default location.
+
+<a name="style"></a>
+### Style guide
+
+Currently, there are no directives for style other than `clang-format`.

docs/building_for_windows.md

@@ -4,6 +4,7 @@
  > * [Requirements](#requirements)
  > * [Locations and Environment Variables](#locs_and_envs)
  > * [Building](#features)
+ > * [Contributing](#contributing)
  > * [Using with QtCreator](#qt_creator)
  > * [Using with Visual Studio](#visual_studio)
 
@@ -12,12 +13,18 @@
 
 For compiling:
 
-1. Microsoft Visual Studio (tested on 2017 Community)
+1. [Microsoft Visual Studio](https://visualstudio.microsoft.com/downloads/) (tested on 2017 Community)
-2. Qt Framework (tested on 5.10 and 5.11)
+2. [Qt Framework](https://www.qt.io/download) version later than 5.6 (tested on 5.10 and 5.11)
+
+For pushing changes to the repo:
+
+1. [Python 3](https://www.python.org/downloads/) (must be in `PATH` environment variable)
+
+2. Clang format. Part of the [LLVM collection](https://releases.llvm.org/download.html).
 
 Additionally, for fully building portable and installer release versions:
-3. 7zip
+3. [7zip](https://www.7-zip.org/download.html)
-4. Nullsoft Scriptable Install System (NSIS)
+4. [Nullsoft Scriptable Install System (NSIS)](https://sourceforge.net/projects/nsis/)
 
 <a name="locs_and_envs"></a>
 ## Locations and Environment Variables
@@ -28,9 +35,10 @@ The following environmental variables are relevant for building the project.
 | --------------------  | ------------- |
 | `QT_LOC`              | Path to your Qt `\bin\` folder.    |
 | `VS_LOC`              | Path to your Visual Studio `vcvarsall.bat` file.  |
-| `JOM_LOC`             | Path to an `.exe` of `jom.exe`. Usually installed with Qt. `jom` is a wrapper around `nmake` allowing more threads to be used. It is not required, but using `nmake`is slower. If `JOM_LOC` isn't defined, or the `.exe` can't be found `nmake` will be used by default.   |
+| `JOM_LOC`             | Path to an `.exe` of `jom.exe`. Usually installed with Qt. `jom` is a wrapper around `nmake` allowing more threads to be used. It is not required, but using `nmake`is slower. If `JOM_LOC` isn't defined, or the `.exe` can't be found `nmake` will be used by default. To force using `nmake`, set `JOM_LOC` to a non-valid path like `1`.  |
 | `ZIP_LOC`             | Path to your 7zip `.exe`. Both portable and installer will work.  |
 | `NSIS_LOC`            | Path to your installation of NSIS containing the `makensis` file. Both portable and installer will work. |
+| `CLANG_FORMAT_LOC`            | Path to your `clang-format.exe`. Not necessary for building, but necessary for pushing changes to the repo. |
 
 If an environment variable isn't set a default value will be provided. The default values are shown in the table below.
 
@@ -41,6 +49,7 @@ If an environment variable isn't set a default value will be provided. The defau
 | `JOM_LOC`             | `"C:\Qt\Tools\QtCreator\bin\jom.exe"`|
 | `ZIP_LOC`             | `"C:\Program Files\7-Zip\7z.exe"`    |
 | `NSIS_LOC`            | `"C:\Program Files (x86)\NSIS\"`     |
+| `CLANG_FORMAT_LOC`            | `"C:\Program Files\LLVM\bin\clang-format.exe"`     |
 
 Additionally, these optional environment variables are supported.
 
@@ -58,6 +67,11 @@ The `.dll` files necessary for a release build differ from those needed by a deb
 
 With the programs above installed and environment variables set, go into the root folder of the repository and run `build_windows.cmd`. Compiled binaries along with everything needed to run portable will output to `.\bin\win64\AdvancedSettings\`.
 
+<a name="contributing"></a>
+## Contributing
+
+For full details, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
 <a name="qt_creator"></a>
 ## Using with QtCreator
 

src/main.cpp

@@ -12,99 +12,174 @@
 
 INITIALIZE_EASYLOGGINGPP
 
-void myQtMessageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg) {
+void myQtMessageHandler( QtMsgType type,
+                         const QMessageLogContext& context,
+                         const QString& msg )
+{
     QByteArray localMsg = msg.toLocal8Bit();
-	switch (type) {
+    switch ( type )
+    {
     case QtDebugMsg:
-			LOG(DEBUG) << localMsg.constData() << " (" << context.file << ":" << context.line << ")";
+        LOG( DEBUG ) << localMsg.constData() << " (" << context.file << ":"
+                     << context.line << ")";
         break;
     case QtInfoMsg:
-			LOG(INFO) << localMsg.constData() << " (" << context.file << ":" << context.line << ")";
+        LOG( INFO ) << localMsg.constData() << " (" << context.file << ":"
+                    << context.line << ")";
         break;
     case QtWarningMsg:
-			LOG(WARNING) << localMsg.constData() << " (" << context.file << ":" << context.line << ")";
+        LOG( WARNING ) << localMsg.constData() << " (" << context.file << ":"
+                       << context.line << ")";
         break;
     case QtCriticalMsg:
-			LOG(ERROR) << localMsg.constData() << " (" << context.file << ":" << context.line << ")";
+        LOG( ERROR ) << localMsg.constData() << " (" << context.file << ":"
+                     << context.line << ")";
         break;
     case QtFatalMsg:
-			LOG(FATAL) << localMsg.constData() << " (" << context.file << ":" << context.line << ")";
+        LOG( FATAL ) << localMsg.constData() << " (" << context.file << ":"
+                     << context.line << ")";
         break;
     }
 }
 
-void installManifest(bool cleaninstall = false) {
+void installManifest( bool cleaninstall = false )
-	auto manifestQPath = QDir::cleanPath(QDir(QCoreApplication::applicationDirPath()).absoluteFilePath("manifest.vrmanifest"));
+{
-	if (QFile::exists(manifestQPath)) {
+    auto manifestQPath
+        = QDir::cleanPath( QDir( QCoreApplication::applicationDirPath() )
+                               .absoluteFilePath( "manifest.vrmanifest" ) );
+    if ( QFile::exists( manifestQPath ) )
+    {
         bool alreadyInstalled = false;
-		if (vr::VRApplications()->IsApplicationInstalled(advsettings::OverlayController::applicationKey)) {
+        if ( vr::VRApplications()->IsApplicationInstalled(
-			if (cleaninstall) {
+                 advsettings::OverlayController::applicationKey ) )
+        {
+            if ( cleaninstall )
+            {
                 char buffer[1024];
                 auto appError = vr::VRApplicationError_None;
-				vr::VRApplications()->GetApplicationPropertyString(advsettings::OverlayController::applicationKey, vr::VRApplicationProperty_WorkingDirectory_String, buffer, 1024, &appError);
+                vr::VRApplications()->GetApplicationPropertyString(
-				if (appError == vr::VRApplicationError_None) {
+                    advsettings::OverlayController::applicationKey,
-					auto oldManifestQPath = QDir::cleanPath(QDir(buffer).absoluteFilePath("manifest.vrmanifest"));
+                    vr::VRApplicationProperty_WorkingDirectory_String,
-					if (oldManifestQPath.compare(manifestQPath, Qt::CaseInsensitive) != 0) {
+                    buffer,
-						vr::VRApplications()->RemoveApplicationManifest(QDir::toNativeSeparators(oldManifestQPath).toStdString().c_str());
+                    1024,
-					} else {
+                    &appError );
+                if ( appError == vr::VRApplicationError_None )
+                {
+                    auto oldManifestQPath
+                        = QDir::cleanPath( QDir( buffer ).absoluteFilePath(
+                            "manifest.vrmanifest" ) );
+                    if ( oldManifestQPath.compare( manifestQPath,
+                                                   Qt::CaseInsensitive )
+                         != 0 )
+                    {
+                        vr::VRApplications()->RemoveApplicationManifest(
+                            QDir::toNativeSeparators( oldManifestQPath )
+                                .toStdString()
+                                .c_str() );
+                    }
+                    else
+                    {
                         alreadyInstalled = true;
                     }
                 }
-			} else {
+            }
+            else
+            {
                 alreadyInstalled = true;
             }
         }
-		auto apperror = vr::VRApplications()->AddApplicationManifest(QDir::toNativeSeparators(manifestQPath).toStdString().c_str());
+        auto apperror = vr::VRApplications()->AddApplicationManifest(
-		if (apperror != vr::VRApplicationError_None) {
+            QDir::toNativeSeparators( manifestQPath ).toStdString().c_str() );
-			throw std::runtime_error(std::string("Could not add application manifest: ") + std::string(vr::VRApplications()->GetApplicationsErrorNameFromEnum(apperror)));
+        if ( apperror != vr::VRApplicationError_None )
-		} else if (!alreadyInstalled || cleaninstall) {
+        {
-                        auto app_error = vr::VRApplications()->SetApplicationAutoLaunch(advsettings::OverlayController::applicationKey, true);
+            throw std::runtime_error(
-                        if (app_error != vr::VRApplicationError_None) {
+                std::string( "Could not add application manifest: " )
-				throw std::runtime_error(std::string("Could not set auto start: ") + std::string(vr::VRApplications()->GetApplicationsErrorNameFromEnum(apperror)));
+                + std::string(
+                      vr::VRApplications()->GetApplicationsErrorNameFromEnum(
+                          apperror ) ) );
+        }
+        else if ( !alreadyInstalled || cleaninstall )
+        {
+            auto app_error = vr::VRApplications()->SetApplicationAutoLaunch(
+                advsettings::OverlayController::applicationKey, true );
+            if ( app_error != vr::VRApplicationError_None )
+            {
+                throw std::runtime_error(
+                    std::string( "Could not set auto start: " )
+                    + std::string( vr::VRApplications()
+                                       ->GetApplicationsErrorNameFromEnum(
+                                           apperror ) ) );
             }
         }
-	} else {
+    }
-		throw std::runtime_error(std::string("Could not find application manifest: ") + manifestQPath.toStdString());
+    else
+    {
+        throw std::runtime_error(
+            std::string( "Could not find application manifest: " )
+            + manifestQPath.toStdString() );
     }
 }
 
-void removeManifest() {
+void removeManifest()
-	auto manifestQPath = QDir::cleanPath(QDir(QCoreApplication::applicationDirPath()).absoluteFilePath("manifest.vrmanifest"));
+{
-	if (QFile::exists(manifestQPath)) {
+    auto manifestQPath
-		if (vr::VRApplications()->IsApplicationInstalled(advsettings::OverlayController::applicationKey)) {
+        = QDir::cleanPath( QDir( QCoreApplication::applicationDirPath() )
-			vr::VRApplications()->RemoveApplicationManifest(QDir::toNativeSeparators(manifestQPath).toStdString().c_str());
+                               .absoluteFilePath( "manifest.vrmanifest" ) );
+    if ( QFile::exists( manifestQPath ) )
+    {
+        if ( vr::VRApplications()->IsApplicationInstalled(
+                 advsettings::OverlayController::applicationKey ) )
+        {
+            vr::VRApplications()->RemoveApplicationManifest(
+                QDir::toNativeSeparators( manifestQPath )
+                    .toStdString()
+                    .c_str() );
         }
-	} else {
+    }
-		throw std::runtime_error(std::string("Could not find application manifest: ") + manifestQPath.toStdString());
+    else
+    {
+        throw std::runtime_error(
+            std::string( "Could not find application manifest: " )
+            + manifestQPath.toStdString() );
     }
 }
 
-
+class MyQApplication : public QApplication
-class MyQApplication : public QApplication {
+{
 public:
     using QApplication::QApplication;
 
-	virtual bool notify(QObject * receiver, QEvent * event) override {
+    virtual bool notify( QObject* receiver, QEvent* event ) override
-		try {
+    {
+        try
+        {
             return QApplication::notify( receiver, event );
-		} catch (std::exception& e) {
+        }
-			LOG(ERROR) << "Exception thrown from an event handler: " << e.what();
+        catch ( std::exception& e )
+        {
+            LOG( ERROR ) << "Exception thrown from an event handler: "
+                         << e.what();
         }
         return false;
     }
 };
 
-
+namespace argument
-
+{
-namespace argument {
 // Checks whether a specific string was passed as a launch argument.
-    bool CheckCommandLineArgument(int argc, char *argv[], const std::string parameter) {
+bool CheckCommandLineArgument( int argc,
+                               char* argv[],
+                               const std::string parameter )
+{
     // The old way was one giant loop that tested every single parameter.
-        // Having an individual loop for all args most likely has a very small performance
+    // Having an individual loop for all args most likely has a very small
-        // penalty compared to the original solution,
+    // performance penalty compared to the original solution, but the gains in
-        // but the gains in readability and ease of extension of not having a hundred line+ for loop are worth it.
+    // readability and ease of extension of not having a hundred line+ for loop
-        for (int i = 0; i < argc; i++) {
+    // are worth it.
-            if (std::string(argv[i]) == parameter) {
+    for ( int i = 0; i < argc; i++ )
+    {
+        if ( std::string( argv[i] ) == parameter )
+        {
             return true;
         }
     }
@@ -116,20 +191,21 @@ namespace argument {
 constexpr auto NO_MANIFEST = "-nomanifest";
 constexpr auto INSTALL_MANIFEST = "-installmanifest";
 constexpr auto REMOVE_MANIFEST = "-removemanifest";
-}
+} // namespace argument
 
-enum ReturnErrorCode {
+enum ReturnErrorCode
+{
     SUCCESS = 0,
     GENERAL_FAILURE = -1,
     OPENVR_INIT_ERROR = -2,
 };
 
-int main(int argc, char *argv[]) {
+int main( int argc, char* argv[] )
-
+{
     const char* logConfigFileName = "logging.conf";
 
-    const char* logConfigDefault =
+    const char* logConfigDefault
-        "* GLOBAL:\n"
+        = "* GLOBAL:\n"
           "	FORMAT = \"[%level] %datetime{%Y-%M-%d %H:%m:%s}: %msg\"\n"
           "	FILENAME = \"AdvancedSettings.log\"\n"
           "	ENABLED = true\n"
@@ -141,118 +217,176 @@ int main(int argc, char *argv[]) {
           "* DEBUG:\n"
           "	ENABLED = false\n";
 
-    const bool desktop_mode = argument::CheckCommandLineArgument(argc, argv, argument::DESKTOP_MODE);
+    const bool desktop_mode = argument::CheckCommandLineArgument(
-    const bool no_sound = argument::CheckCommandLineArgument(argc, argv, argument::NO_SOUND);
+        argc, argv, argument::DESKTOP_MODE );
-    const bool no_manifest = argument::CheckCommandLineArgument(argc, argv, argument::NO_MANIFEST);
+    const bool no_sound
-    const bool install_manifest = argument::CheckCommandLineArgument(argc, argv, argument::INSTALL_MANIFEST);
+        = argument::CheckCommandLineArgument( argc, argv, argument::NO_SOUND );
-    const bool remove_manifest = argument::CheckCommandLineArgument(argc, argv, argument::REMOVE_MANIFEST);
+    const bool no_manifest = argument::CheckCommandLineArgument(
+        argc, argv, argument::NO_MANIFEST );
+    const bool install_manifest = argument::CheckCommandLineArgument(
+        argc, argv, argument::INSTALL_MANIFEST );
+    const bool remove_manifest = argument::CheckCommandLineArgument(
+        argc, argv, argument::REMOVE_MANIFEST );
 
-    if (install_manifest || remove_manifest) {
+    if ( install_manifest || remove_manifest )
+    {
         int exit_code = ReturnErrorCode::SUCCESS;
         QCoreApplication coreApp( argc, argv );
         auto openvr_init_status = vr::VRInitError_None;
         vr::VR_Init( &openvr_init_status, vr::VRApplication_Utility );
 
-        if (openvr_init_status == vr::VRInitError_None) {
+        if ( openvr_init_status == vr::VRInitError_None )
-            try {
+        {
-                if (install_manifest) {
+            try
+            {
+                if ( install_manifest )
+                {
                     installManifest( true );
                 }
-                else if (remove_manifest) {
+                else if ( remove_manifest )
+                {
                     removeManifest();
                 }
             }
-            catch (std::exception& e) {
+            catch ( std::exception& e )
+            {
                 exit_code = ReturnErrorCode::GENERAL_FAILURE;
                 std::cerr << e.what() << std::endl;
             }
         }
-        else {
+        else
+        {
             exit_code = ReturnErrorCode::OPENVR_INIT_ERROR;
-            std::cerr << std::string("Failed to initialize OpenVR: " + std::string(vr::VR_GetVRInitErrorAsEnglishDescription(openvr_init_status))) << std::endl;
+            std::cerr << std::string(
+                             "Failed to initialize OpenVR: "
+                             + std::string(
+                                   vr::VR_GetVRInitErrorAsEnglishDescription(
+                                       openvr_init_status ) ) )
+                      << std::endl;
         }
 
         vr::VR_Shutdown();
         exit( exit_code );
     }
 
-	try {
+    try
+    {
         MyQApplication a( argc, argv );
         a.setOrganizationName( "matzman666" );
         a.setApplicationName( "OpenVRAdvancedSettings" );
-		a.setApplicationDisplayName(advsettings::OverlayController::applicationName);
+        a.setApplicationDisplayName(
-		a.setApplicationVersion(advsettings::OverlayController::applicationVersionString);
+            advsettings::OverlayController::applicationName );
+        a.setApplicationVersion(
+            advsettings::OverlayController::applicationVersionString );
 
         qInstallMessageHandler( myQtMessageHandler );
 
         // Configure logger
         QString logFilePath;
         START_EASYLOGGINGPP( argc, argv );
-		el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog);
+        el::Loggers::addFlag(
+            el::LoggingFlag::DisableApplicationAbortOnFatalLog );
         auto logconfigfile = QFileInfo( logConfigFileName ).absoluteFilePath();
         el::Configurations conf;
-		if (QFile::exists(logconfigfile)) {
+        if ( QFile::exists( logconfigfile ) )
+        {
             conf.parseFromFile( logconfigfile.toStdString() );
-		} else {
+        }
+        else
+        {
             conf.parseFromText( logConfigDefault );
         }
-		if (!conf.get(el::Level::Global, el::ConfigurationType::Filename)) {
+        if ( !conf.get( el::Level::Global, el::ConfigurationType::Filename ) )
-			logFilePath = QDir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)).absoluteFilePath("AdvancedSettings.log");
+        {
-			conf.set(el::Level::Global, el::ConfigurationType::Filename, QDir::toNativeSeparators(logFilePath).toStdString());
+            logFilePath = QDir( QStandardPaths::writableLocation(
+                                    QStandardPaths::AppDataLocation ) )
+                              .absoluteFilePath( "AdvancedSettings.log" );
+            conf.set( el::Level::Global,
+                      el::ConfigurationType::Filename,
+                      QDir::toNativeSeparators( logFilePath ).toStdString() );
         }
         conf.setRemainingToDefault();
         el::Loggers::reconfigureAllLoggers( conf );
-		LOG(INFO) << "Application started (Version " << advsettings::OverlayController::applicationVersionString << ")";
+        LOG( INFO ) << "Application started (Version "
-		LOG(INFO) << "Log Config: " << QDir::toNativeSeparators(logconfigfile).toStdString();
+                    << advsettings::OverlayController::applicationVersionString
-		if (!logFilePath.isEmpty()) {
+                    << ")";
+        LOG( INFO ) << "Log Config: "
+                    << QDir::toNativeSeparators( logconfigfile ).toStdString();
+        if ( !logFilePath.isEmpty() )
+        {
             LOG( INFO ) << "Log File: " << logFilePath;
         }
 
-		if (desktop_mode) {
+        if ( desktop_mode )
+        {
             LOG( INFO ) << "Desktop mode enabled.";
         }
-		if (no_sound) {
+        if ( no_sound )
+        {
             LOG( INFO ) << "Sound effects disabled.";
         }
-		if (no_manifest) {
+        if ( no_manifest )
+        {
             LOG( INFO ) << "vrmanifest disabled.";
         }
 
-		QSettings appSettings(QSettings::IniFormat, QSettings::UserScope, a.organizationName(), a.applicationName());
+        QSettings appSettings( QSettings::IniFormat,
+                               QSettings::UserScope,
+                               a.organizationName(),
+                               a.applicationName() );
         advsettings::OverlayController::setAppSettings( &appSettings );
-		LOG(INFO) << "Settings File: " << appSettings.fileName().toStdString();
+        LOG( INFO ) << "Settings File: "
+                    << appSettings.fileName().toStdString();
 
         QQmlEngine qmlEngine;
 
-		advsettings::OverlayController* controller = advsettings::OverlayController::createInstance(desktop_mode, no_sound);
+        advsettings::OverlayController* controller
+            = advsettings::OverlayController::createInstance( desktop_mode,
+                                                              no_sound );
         controller->Init( &qmlEngine );
 
-		QQmlComponent component(&qmlEngine, QUrl::fromLocalFile("res/qml/mainwidget.qml"));
+        QQmlComponent component(
+            &qmlEngine, QUrl::fromLocalFile( "res/qml/mainwidget.qml" ) );
         auto errors = component.errors();
-		for (auto& e : errors) {
+        for ( auto& e : errors )
-			LOG(ERROR) << "QML Error: " << e.toString().toStdString() << std::endl;
+        {
+            LOG( ERROR ) << "QML Error: " << e.toString().toStdString()
+                         << std::endl;
         }
         auto quickObj = component.create();
-		controller->SetWidget(qobject_cast<QQuickItem*>(quickObj), advsettings::OverlayController::applicationName, advsettings::OverlayController::applicationKey);
+        controller->SetWidget( qobject_cast<QQuickItem*>( quickObj ),
+                               advsettings::OverlayController::applicationName,
+                               advsettings::OverlayController::applicationKey );
 
-		if (!desktop_mode && !no_manifest) {
+        if ( !desktop_mode && !no_manifest )
-			try {
+        {
+            try
+            {
                 installManifest();
-			} catch (std::exception& e) {
+            }
+            catch ( std::exception& e )
+            {
                 LOG( ERROR ) << e.what();
             }
         }
 
-		if (desktop_mode) {
+        if ( desktop_mode )
+        {
             auto m_pWindow = new QQuickWindow();
-			qobject_cast<QQuickItem*>(quickObj)->setParentItem(m_pWindow->contentItem());
+            qobject_cast<QQuickItem*>( quickObj )
-			m_pWindow->setGeometry(0, 0, qobject_cast<QQuickItem*>(quickObj)->width(), qobject_cast<QQuickItem*>(quickObj)->height());
+                ->setParentItem( m_pWindow->contentItem() );
+            m_pWindow->setGeometry(
+                0,
+                0,
+                qobject_cast<QQuickItem*>( quickObj )->width(),
+                qobject_cast<QQuickItem*>( quickObj )->height() );
             m_pWindow->show();
         }
 
         return a.exec();
-
+    }
-	} catch (const std::exception& e) {
+    catch ( const std::exception& e )
+    {
         LOG( FATAL ) << e.what();
         return ReturnErrorCode::GENERAL_FAILURE;
     }

src/overlaycontroller.h

@@ -3,7 +3,8 @@
 
 #include <openvr.h>
 #include <QtCore/QtCore>
-// because of incompatibilities with QtOpenGL and GLEW we need to cherry pick includes
+// because of incompatibilities with QtOpenGL and GLEW we need to cherry pick
+// includes
 #include <QVector2D>
 #include <QMatrix4x4>
 #include <QVector>
@@ -35,12 +36,11 @@
 #include "tabcontrollers/UtilitiesTabController.h"
 #include "tabcontrollers/AccessibilityTabController.h"
 
-
-
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
-class OverlayController : public QObject {
+class OverlayController : public QObject
+{
     Q_OBJECT
     Q_PROPERTY( bool desktopMode READ isDesktopMode )
 
@@ -51,7 +51,8 @@ public:
 
 private:
     vr::VROverlayHandle_t m_ulOverlayHandle = vr::k_ulOverlayHandleInvalid;
-	vr::VROverlayHandle_t m_ulOverlayThumbnailHandle = vr::k_ulOverlayHandleInvalid;
+    vr::VROverlayHandle_t m_ulOverlayThumbnailHandle
+        = vr::k_ulOverlayHandleInvalid;
 
     std::unique_ptr<QQuickRenderControl> m_pRenderControl;
     std::unique_ptr<QQuickWindow> m_pWindow;
@@ -77,7 +78,8 @@ private:
     QSoundEffect focusChangedSoundEffect;
     QSoundEffect alarm01SoundEffect;
 
-public: // I know it's an ugly hack to make them public to enable external access, but I am too lazy to implement getters.
+public: // I know it's an ugly hack to make them public to enable external
+        // access, but I am too lazy to implement getters.
     SteamVRTabController steamVRTabController;
     ChaperoneTabController chaperoneTabController;
     MoveCenterTabController moveCenterTabController;
@@ -90,7 +92,10 @@ public: // I know it's an ugly hack to make them public to enable external acces
     AccessibilityTabController accessibilityTabController;
 
 private:
-	OverlayController(bool desktopMode, bool noSound) : QObject(), desktopMode(desktopMode), noSound(noSound) {}
+    OverlayController( bool desktopMode, bool noSound )
+        : QObject(), desktopMode( desktopMode ), noSound( noSound )
+    {
+    }
     QPoint getMousePositionForEvent( vr::VREvent_Mouse_t mouse );
 
 public:
@@ -99,22 +104,44 @@ public:
     void Init( QQmlEngine* qmlEngine );
     void Shutdown();
 
-	bool isDashboardVisible() {
+    bool isDashboardVisible()
+    {
         return dashboardVisible;
     }
 
-	void SetWidget(QQuickItem* quickItem, const std::string& name, const std::string& key = "");
+    void SetWidget( QQuickItem* quickItem,
+                    const std::string& name,
+                    const std::string& key = "" );
 
-	void AddOffsetToUniverseCenter(vr::ETrackingUniverseOrigin universe, unsigned axisId, float offset, bool adjustBounds = true, bool commit = true);
+    void AddOffsetToUniverseCenter( vr::ETrackingUniverseOrigin universe,
-	void AddOffsetToUniverseCenter(vr::ETrackingUniverseOrigin universe, float offset[3], bool adjustBounds = true, bool commit = true);
+                                    unsigned axisId,
-	void RotateUniverseCenter(vr::ETrackingUniverseOrigin universe, float yAngle, bool adjustBounds = true, bool commit = true); // around y axis
+                                    float offset,
-	void AddOffsetToCollisionBounds(unsigned axisId, float offset, bool commit = true);
+                                    bool adjustBounds = true,
+                                    bool commit = true );
+    void AddOffsetToUniverseCenter( vr::ETrackingUniverseOrigin universe,
+                                    float offset[3],
+                                    bool adjustBounds = true,
+                                    bool commit = true );
+    void RotateUniverseCenter( vr::ETrackingUniverseOrigin universe,
+                               float yAngle,
+                               bool adjustBounds = true,
+                               bool commit = true ); // around y axis
+    void AddOffsetToCollisionBounds( unsigned axisId,
+                                     float offset,
+                                     bool commit = true );
     void AddOffsetToCollisionBounds( float offset[3], bool commit = true );
-	void RotateCollisionBounds(float angle, bool commit = true); // around y axis
+    void RotateCollisionBounds( float angle,
+                                bool commit = true ); // around y axis
 
-        bool isDesktopMode() { return desktopMode; };
+    bool isDesktopMode()
+    {
+        return desktopMode;
+    };
 
-	utils::ChaperoneUtils& chaperoneUtils() noexcept { return m_chaperoneUtils; }
+    utils::ChaperoneUtils& chaperoneUtils() noexcept
+    {
+        return m_chaperoneUtils;
+    }
 
     Q_INVOKABLE QString getVersionString();
     Q_INVOKABLE QUrl getVRRuntimePathUrl();
@@ -124,7 +151,8 @@ public:
     const vr::VROverlayHandle_t& overlayHandle();
     const vr::VROverlayHandle_t& overlayThumbnailHandle();
 
-	bool pollNextEvent(vr::VROverlayHandle_t ulOverlayHandle, vr::VREvent_t* pEvent);
+    bool pollNextEvent( vr::VROverlayHandle_t ulOverlayHandle,
+                        vr::VREvent_t* pEvent );
 
 public slots:
     void renderOverlay();
@@ -147,18 +175,27 @@ private:
     static std::unique_ptr<OverlayController> singleton;
 
 public:
-	static OverlayController* getInstance() {
+    static OverlayController* getInstance()
+    {
         return singleton.get();
     }
 
-	static OverlayController* createInstance(bool desktopMode, bool noSound) {
+    static OverlayController* createInstance( bool desktopMode, bool noSound )
-		singleton.reset(new advsettings::OverlayController(desktopMode, noSound));
+    {
+        singleton.reset(
+            new advsettings::OverlayController( desktopMode, noSound ) );
         return singleton.get();
     }
 
-	static QSettings* appSettings() { return _appSettings; }
+    static QSettings* appSettings()
+    {
+        return _appSettings;
+    }
 
-	static void setAppSettings(QSettings* settings) { _appSettings = settings; }
+    static void setAppSettings( QSettings* settings )
+    {
+        _appSettings = settings;
+    }
 };
 
 } // namespace advsettings

src/tabcontrollers/AccessibilityTabController.cpp

@@ -3,15 +3,17 @@
 #include "../overlaycontroller.h"
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
-void AccessibilityTabController::initStage1() {
+void AccessibilityTabController::initStage1()
+{
     setTrackingUniverse( vr::VRCompositor()->GetTrackingSpace() );
     auto settings = OverlayController::appSettings();
     settings->beginGroup( getSettingsName() );
     auto value = settings->value( "heightOffset", m_heightOffset );
     settings->endGroup();
-  if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_heightOffset = value.toFloat();
         emit heightOffsetChanged( m_heightOffset );
     }
@@ -19,79 +21,112 @@ void AccessibilityTabController::initStage1() {
     reloadPttConfig();
 }
 
-void AccessibilityTabController::initStage2(OverlayController * var_parent, QQuickWindow * var_widget) {
+void AccessibilityTabController::initStage2( OverlayController* var_parent,
+                                             QQuickWindow* var_widget )
+{
     this->parent = var_parent;
     this->widget = var_widget;
 }
 
-void AccessibilityTabController::setTrackingUniverse(int value) {
+void AccessibilityTabController::setTrackingUniverse( int value )
-  if (m_trackingUniverse != value) {
+{
+    if ( m_trackingUniverse != value )
+    {
         reset();
         m_trackingUniverse = value;
     }
 }
 
-float AccessibilityTabController::heightOffset() const {
+float AccessibilityTabController::heightOffset() const
+{
     return m_heightOffset;
 }
 
-void AccessibilityTabController::setHeightOffset(float value, bool notify) {
+void AccessibilityTabController::setHeightOffset( float value, bool notify )
-  if (std::abs(m_heightOffset - value) > 0.001) {
+{
+    if ( std::abs( m_heightOffset - value ) > 0.001 )
+    {
         modHeightOffset( value - m_heightOffset, notify );
     }
 }
 
-void AccessibilityTabController::modHeightOffset(float value, bool notify) {
+void AccessibilityTabController::modHeightOffset( float value, bool notify )
-  parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, -value, false);
+{
+    parent->AddOffsetToUniverseCenter(
+        ( vr::TrackingUniverseOrigin ) m_trackingUniverse, 1, -value, false );
     m_heightOffset += value;
     auto settings = OverlayController::appSettings();
     settings->beginGroup( getSettingsName() );
     settings->setValue( "heightOffset", m_heightOffset );
     settings->endGroup();
     settings->sync();
-  if (notify) {
+    if ( notify )
+    {
         emit heightOffsetChanged( m_heightOffset );
     }
 }
 
-
+void AccessibilityTabController::onPttStart()
-void AccessibilityTabController::onPttStart() {
+{
     m_toggleHeightOffset = m_heightOffset;
-  parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, m_toggleHeightOffset, false);
+    parent->AddOffsetToUniverseCenter(
+        ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+        1,
+        m_toggleHeightOffset,
+        false );
 }
 
-void AccessibilityTabController::onPttStop() {
+void AccessibilityTabController::onPttStop()
-  parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, -m_toggleHeightOffset, false);
+{
+    parent->AddOffsetToUniverseCenter(
+        ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+        1,
+        -m_toggleHeightOffset,
+        false );
 }
 
-void AccessibilityTabController::onPttDisabled() {
+void AccessibilityTabController::onPttDisabled()
-  if (pttActive()) {
+{
+    if ( pttActive() )
+    {
         stopPtt();
     }
     m_toggleHeightOffset = 0;
 }
 
-void AccessibilityTabController::reset() {
+void AccessibilityTabController::reset()
+{
     std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
     vr::VRChaperoneSetup()->RevertWorkingCopy();
-  parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, m_heightOffset, false, false);
+    parent->AddOffsetToUniverseCenter(
+        ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+        1,
+        m_heightOffset,
+        false,
+        false );
     vr::VRChaperoneSetup()->CommitWorkingCopy( vr::EChaperoneConfigFile_Live );
     m_heightOffset = 0.0f;
     emit heightOffsetChanged( m_heightOffset );
 }
 
-void AccessibilityTabController::eventLoopTick(vr::ETrackingUniverseOrigin universe) {
+void AccessibilityTabController::eventLoopTick(
-  if (!eventLoopMutex.try_lock()) {
+    vr::ETrackingUniverseOrigin universe )
+{
+    if ( !eventLoopMutex.try_lock() )
+    {
         return;
     }
-  if (settingsUpdateCounter >= 50) {
+    if ( settingsUpdateCounter >= 50 )
+    {
         setTrackingUniverse( ( int ) universe );
         settingsUpdateCounter = 0;
-  } else {
+    }
+    else
+    {
         settingsUpdateCounter++;
     }
     checkPttStatus();
     eventLoopMutex.unlock();
 }
 
-} // namespace advconfig
+} // namespace advsettings

src/tabcontrollers/AccessibilityTabController.h

@@ -5,15 +5,16 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-
+class AccessibilityTabController : public PttController
-class AccessibilityTabController : public PttController {
+{
     Q_OBJECT
-  Q_PROPERTY(float heightOffset READ heightOffset WRITE setHeightOffset NOTIFY heightOffsetChanged)
+    Q_PROPERTY( float heightOffset READ heightOffset WRITE setHeightOffset
+                    NOTIFY heightOffsetChanged )
 
 private:
     OverlayController* parent;
@@ -25,7 +26,10 @@ private:
 
     unsigned settingsUpdateCounter = 0;
 
-  QString getSettingsName() override { return "accessibilitySettings"; }
+    QString getSettingsName() override
+    {
+        return "accessibilitySettings";
+    }
     void onPttStart() override;
     void onPttStop() override;
     void onPttDisabled() override;

src/tabcontrollers/AudioManager.h

@@ -4,8 +4,8 @@
 #include <vector>
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 class AudioTabController;
 
 class AudioManager
@@ -15,11 +15,13 @@ public:
 
     virtual void init( AudioTabController* controller ) = 0;
 
-	virtual void setPlaybackDevice(const std::string& id, bool notify = true) = 0;
+    virtual void setPlaybackDevice( const std::string& id, bool notify = true )
+        = 0;
     virtual std::string getPlaybackDevName() = 0;
     virtual std::string getPlaybackDevId() = 0;
 
-	virtual void setMirrorDevice(const std::string& id, bool notify = true) = 0;
+    virtual void setMirrorDevice( const std::string& id, bool notify = true )
+        = 0;
     virtual bool isMirrorValid() = 0;
     virtual std::string getMirrorDevName() = 0;
     virtual std::string getMirrorDevId() = 0;
@@ -37,9 +39,10 @@ public:
     virtual bool getMicMuted() = 0;
     virtual bool setMicMuted( bool value ) = 0;
 
-	virtual std::vector<std::pair<std::string, std::string>> getRecordingDevices() = 0;
+    virtual std::vector<std::pair<std::string, std::string>>
-	virtual std::vector<std::pair<std::string, std::string>> getPlaybackDevices() = 0;
+        getRecordingDevices() = 0;
+    virtual std::vector<std::pair<std::string, std::string>>
+        getPlaybackDevices() = 0;
 };
 
-}
+} // namespace advsettings
-

src/tabcontrollers/AudioTabController.h

@@ -8,12 +8,13 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-	struct AudioProfile {
+struct AudioProfile
+{
     std::string profileName;
     std::string playbackName;
     std::string mirrorName;
@@ -24,28 +25,40 @@ namespace advsettings {
     bool mirrorMute = false;
 };
 
-
+class AudioTabController : public PttController
-	class AudioTabController : public PttController {
+{
     Q_OBJECT
-		Q_PROPERTY(int playbackDeviceIndex READ playbackDeviceIndex WRITE setPlaybackDeviceIndex NOTIFY playbackDeviceIndexChanged)
+    Q_PROPERTY( int playbackDeviceIndex READ playbackDeviceIndex WRITE
-		Q_PROPERTY(int mirrorDeviceIndex READ mirrorDeviceIndex WRITE setMirrorDeviceIndex NOTIFY mirrorDeviceIndexChanged)
+                    setPlaybackDeviceIndex NOTIFY playbackDeviceIndexChanged )
-		//Q_PROPERTY(bool mirrorPresent READ mirrorPresent NOTIFY mirrorPresentChanged)
+    Q_PROPERTY( int mirrorDeviceIndex READ mirrorDeviceIndex WRITE
-		//Q_PROPERTY(QString mirrorDevName READ mirrorDevName NOTIFY mirrorDevNameChanged)
+                    setMirrorDeviceIndex NOTIFY mirrorDeviceIndexChanged )
-		Q_PROPERTY(float mirrorVolume READ mirrorVolume WRITE setMirrorVolume NOTIFY mirrorVolumeChanged)
+    // Q_PROPERTY(bool mirrorPresent READ mirrorPresent NOTIFY
-		Q_PROPERTY(bool mirrorMuted READ mirrorMuted WRITE setMirrorMuted NOTIFY mirrorMutedChanged)
+    // mirrorPresentChanged) Q_PROPERTY(QString mirrorDevName READ mirrorDevName
-		Q_PROPERTY(int micDeviceIndex READ micDeviceIndex WRITE setMicDeviceIndex NOTIFY micDeviceIndexChanged)
+    // NOTIFY mirrorDevNameChanged)
+    Q_PROPERTY( float mirrorVolume READ mirrorVolume WRITE setMirrorVolume
+                    NOTIFY mirrorVolumeChanged )
+    Q_PROPERTY( bool mirrorMuted READ mirrorMuted WRITE setMirrorMuted NOTIFY
+                    mirrorMutedChanged )
+    Q_PROPERTY( int micDeviceIndex READ micDeviceIndex WRITE setMicDeviceIndex
+                    NOTIFY micDeviceIndexChanged )
     // Q_PROPERTY(bool micPresent READ micPresent NOTIFY micPresentChanged)
     // Q_PROPERTY(QString micDevName READ micDevName NOTIFY micDevNameChanged)
-		Q_PROPERTY(float micVolume READ micVolume WRITE setMicVolume NOTIFY micVolumeChanged)
+    Q_PROPERTY( float micVolume READ micVolume WRITE setMicVolume NOTIFY
-		Q_PROPERTY(bool micMuted READ micMuted WRITE setMicMuted NOTIFY micMutedChanged)
+                    micVolumeChanged )
-		Q_PROPERTY(bool micProximitySensorCanMute READ micProximitySensorCanMute WRITE setMicProximitySensorCanMute NOTIFY micProximitySensorCanMuteChanged)
+    Q_PROPERTY(
-		Q_PROPERTY(bool micReversePtt READ micReversePtt WRITE setMicReversePtt NOTIFY micReversePttChanged)
+        bool micMuted READ micMuted WRITE setMicMuted NOTIFY micMutedChanged )
+    Q_PROPERTY( bool micProximitySensorCanMute READ micProximitySensorCanMute
+                    WRITE setMicProximitySensorCanMute NOTIFY
+                        micProximitySensorCanMuteChanged )
+    Q_PROPERTY( bool micReversePtt READ micReversePtt WRITE setMicReversePtt
+                    NOTIFY micReversePttChanged )
 
 private:
     OverlayController* parent;
     QQuickWindow* widget;
 
-		vr::VROverlayHandle_t m_ulNotificationOverlayHandle = vr::k_ulOverlayHandleInvalid;
+    vr::VROverlayHandle_t m_ulNotificationOverlayHandle
+        = vr::k_ulOverlayHandleInvalid;
 
     int m_playbackDeviceIndex = -1;
 
@@ -66,14 +79,20 @@ namespace advsettings {
     std::vector<std::pair<std::string, std::string>> m_playbackDevices;
     std::string lastMirrorDevId;
 
-		QString getSettingsName() override { return "audioSettings"; }
+    QString getSettingsName() override
+    {
+        return "audioSettings";
+    }
     // QString getSettingsNameAudio() override { return "audioSettingsTest"; }
     void onPttStart() override;
     void onPttStop() override;
     void onPttEnabled() override;
     void onPttDisabled() override;
     bool pttChangeValid() override;
-		virtual vr::VROverlayHandle_t getNotificationOverlayHandle() override { return m_ulNotificationOverlayHandle; }
+    virtual vr::VROverlayHandle_t getNotificationOverlayHandle() override
+    {
+        return m_ulNotificationOverlayHandle;
+    }
 
     void findPlaybackDeviceIndex( std::string id, bool notify = true );
     void findMirrorDeviceIndex( std::string id, bool notify = true );
@@ -88,8 +107,6 @@ namespace advsettings {
     // std::recursive_mutex eventLoopMutexAudio;
 
 public:
-
-
     void initStage1();
     void initStage2( OverlayController* parent, QQuickWindow* widget );
 

src/tabcontrollers/ChaperoneTabController.h

@@ -9,13 +9,13 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-
+struct ChaperoneProfile
-struct ChaperoneProfile {
+{
     std::string profileName;
 
     bool includesChaperoneGeometry = false;
@@ -64,32 +64,72 @@ struct ChaperoneProfile {
     float chaperoneVelocityModifier = 0.0f;
 };
 
-
+class ChaperoneTabController : public QObject
-class ChaperoneTabController : public QObject {
+{
     Q_OBJECT
-	Q_PROPERTY(float boundsVisibility READ boundsVisibility WRITE setBoundsVisibility NOTIFY boundsVisibilityChanged)
+    Q_PROPERTY( float boundsVisibility READ boundsVisibility WRITE
-	Q_PROPERTY(float fadeDistance READ fadeDistance WRITE setFadeDistance NOTIFY fadeDistanceChanged)
+                    setBoundsVisibility NOTIFY boundsVisibilityChanged )
+    Q_PROPERTY( float fadeDistance READ fadeDistance WRITE setFadeDistance
+                    NOTIFY fadeDistanceChanged )
     Q_PROPERTY( float height READ height WRITE setHeight NOTIFY heightChanged )
-	Q_PROPERTY(bool centerMarker READ centerMarker WRITE setCenterMarker NOTIFY centerMarkerChanged)
+    Q_PROPERTY( bool centerMarker READ centerMarker WRITE setCenterMarker NOTIFY
-	Q_PROPERTY(bool playSpaceMarker READ playSpaceMarker WRITE setPlaySpaceMarker NOTIFY playSpaceMarkerChanged)
+                    centerMarkerChanged )
-	Q_PROPERTY(bool forceBounds READ forceBounds WRITE setForceBounds NOTIFY forceBoundsChanged)
+    Q_PROPERTY( bool playSpaceMarker READ playSpaceMarker WRITE
+                    setPlaySpaceMarker NOTIFY playSpaceMarkerChanged )
+    Q_PROPERTY( bool forceBounds READ forceBounds WRITE setForceBounds NOTIFY
+                    forceBoundsChanged )
 
-	Q_PROPERTY(bool chaperoneSwitchToBeginnerEnabled READ isChaperoneSwitchToBeginnerEnabled WRITE setChaperoneSwitchToBeginnerEnabled NOTIFY chaperoneSwitchToBeginnerEnabledChanged)
+    Q_PROPERTY( bool chaperoneSwitchToBeginnerEnabled READ
-	Q_PROPERTY(float chaperoneSwitchToBeginnerDistance READ chaperoneSwitchToBeginnerDistance WRITE setChaperoneSwitchToBeginnerDistance NOTIFY chaperoneSwitchToBeginnerDistanceChanged)
+                    isChaperoneSwitchToBeginnerEnabled WRITE
+                        setChaperoneSwitchToBeginnerEnabled NOTIFY
+                            chaperoneSwitchToBeginnerEnabledChanged )
+    Q_PROPERTY( float chaperoneSwitchToBeginnerDistance READ
+                    chaperoneSwitchToBeginnerDistance WRITE
+                        setChaperoneSwitchToBeginnerDistance NOTIFY
+                            chaperoneSwitchToBeginnerDistanceChanged )
 
-	Q_PROPERTY(bool chaperoneHapticFeedbackEnabled READ isChaperoneHapticFeedbackEnabled WRITE setChaperoneHapticFeedbackEnabled NOTIFY chaperoneHapticFeedbackEnabledChanged)
+    Q_PROPERTY( bool chaperoneHapticFeedbackEnabled READ
-	Q_PROPERTY(float chaperoneHapticFeedbackDistance READ chaperoneHapticFeedbackDistance WRITE setChaperoneHapticFeedbackDistance NOTIFY chaperoneHapticFeedbackDistanceChanged)
+                    isChaperoneHapticFeedbackEnabled WRITE
+                        setChaperoneHapticFeedbackEnabled NOTIFY
+                            chaperoneHapticFeedbackEnabledChanged )
+    Q_PROPERTY( float chaperoneHapticFeedbackDistance READ
+                    chaperoneHapticFeedbackDistance WRITE
+                        setChaperoneHapticFeedbackDistance NOTIFY
+                            chaperoneHapticFeedbackDistanceChanged )
 
-	Q_PROPERTY(bool chaperoneAlarmSoundEnabled READ isChaperoneAlarmSoundEnabled WRITE setChaperoneAlarmSoundEnabled NOTIFY chaperoneAlarmSoundEnabledChanged)
+    Q_PROPERTY(
-	Q_PROPERTY(bool chaperoneAlarmSoundLooping READ isChaperoneAlarmSoundLooping WRITE setChaperoneAlarmSoundLooping NOTIFY chaperoneAlarmSoundLoopingChanged)
+        bool chaperoneAlarmSoundEnabled READ isChaperoneAlarmSoundEnabled WRITE
-	Q_PROPERTY(bool chaperoneAlarmSoundAdjustVolume READ isChaperoneAlarmSoundAdjustVolume WRITE setChaperoneAlarmSoundAdjustVolume NOTIFY chaperoneAlarmSoundAdjustVolumeChanged)
+            setChaperoneAlarmSoundEnabled NOTIFY
-	Q_PROPERTY(float chaperoneAlarmSoundDistance READ chaperoneAlarmSoundDistance WRITE setChaperoneAlarmSoundDistance NOTIFY chaperoneAlarmSoundDistanceChanged)
+                chaperoneAlarmSoundEnabledChanged )
+    Q_PROPERTY(
+        bool chaperoneAlarmSoundLooping READ isChaperoneAlarmSoundLooping WRITE
+            setChaperoneAlarmSoundLooping NOTIFY
+                chaperoneAlarmSoundLoopingChanged )
+    Q_PROPERTY( bool chaperoneAlarmSoundAdjustVolume READ
+                    isChaperoneAlarmSoundAdjustVolume WRITE
+                        setChaperoneAlarmSoundAdjustVolume NOTIFY
+                            chaperoneAlarmSoundAdjustVolumeChanged )
+    Q_PROPERTY(
+        float chaperoneAlarmSoundDistance READ chaperoneAlarmSoundDistance WRITE
+            setChaperoneAlarmSoundDistance NOTIFY
+                chaperoneAlarmSoundDistanceChanged )
 
-	Q_PROPERTY(bool chaperoneShowDashboardEnabled READ isChaperoneShowDashboardEnabled WRITE setChaperoneShowDashboardEnabled NOTIFY chaperoneShowDashboardEnabledChanged)
+    Q_PROPERTY(
-	Q_PROPERTY(float chaperoneShowDashboardDistance READ chaperoneShowDashboardDistance WRITE setChaperoneShowDashboardDistance NOTIFY chaperoneShowDashboardDistanceChanged)
+        bool chaperoneShowDashboardEnabled READ isChaperoneShowDashboardEnabled
+            WRITE setChaperoneShowDashboardEnabled NOTIFY
+                chaperoneShowDashboardEnabledChanged )
+    Q_PROPERTY(
+        float chaperoneShowDashboardDistance READ chaperoneShowDashboardDistance
+            WRITE setChaperoneShowDashboardDistance NOTIFY
+                chaperoneShowDashboardDistanceChanged )
 
-	Q_PROPERTY(bool chaperoneVelocityModifierEnabled READ isChaperoneVelocityModifierEnabled WRITE setChaperoneVelocityModifierEnabled NOTIFY chaperoneVelocityModifierEnabledChanged)
+    Q_PROPERTY( bool chaperoneVelocityModifierEnabled READ
-	Q_PROPERTY(float chaperoneVelocityModifier READ chaperoneVelocityModifier WRITE setChaperoneVelocityModifier NOTIFY chaperoneVelocityModifierChanged)
+                    isChaperoneVelocityModifierEnabled WRITE
+                        setChaperoneVelocityModifierEnabled NOTIFY
+                            chaperoneVelocityModifierEnabledChanged )
+    Q_PROPERTY( float chaperoneVelocityModifier READ chaperoneVelocityModifier
+                    WRITE setChaperoneVelocityModifier NOTIFY
+                        chaperoneVelocityModifierChanged )
 
 private:
     OverlayController* parent;
@@ -137,7 +177,10 @@ public:
     void initStage1();
     void initStage2( OverlayController* parent, QQuickWindow* widget );
 
-	void eventLoopTick(vr::TrackedDevicePose_t* devicePoses, float leftSpeed, float rightSpeed, float hmdSpeed);
+    void eventLoopTick( vr::TrackedDevicePose_t* devicePoses,
+                        float leftSpeed,
+                        float rightSpeed,
+                        float hmdSpeed );
     void handleChaperoneWarnings( float distance );
 
     float boundsVisibility() const;
@@ -182,7 +225,8 @@ public slots:
     void setForceBounds( bool value, bool notify = true );
 
     void setChaperoneSwitchToBeginnerEnabled( bool value, bool notify = true );
-	void setChaperoneSwitchToBeginnerDistance(float value, bool notify = true);
+    void setChaperoneSwitchToBeginnerDistance( float value,
+                                               bool notify = true );
 
     void setChaperoneHapticFeedbackEnabled( bool value, bool notify = true );
     void setChaperoneHapticFeedbackDistance( float value, bool notify = true );
@@ -201,8 +245,16 @@ public slots:
     void flipOrientation();
     void reloadFromDisk();
 
-	void addChaperoneProfile(QString name, bool includeGeometry, bool includeVisbility, bool includeFadeDistance, bool includeCenterMarker,
+    void addChaperoneProfile( QString name,
-			bool includePlaySpaceMarker, bool includeFloorBounds, bool includeBoundsColor, bool includeChaperoneStyle, bool includeForceBounds, 
+                              bool includeGeometry,
+                              bool includeVisbility,
+                              bool includeFadeDistance,
+                              bool includeCenterMarker,
+                              bool includePlaySpaceMarker,
+                              bool includeFloorBounds,
+                              bool includeBoundsColor,
+                              bool includeChaperoneStyle,
+                              bool includeForceBounds,
                               bool includesProximityWarningSettings );
     void applyChaperoneProfile( unsigned index );
     void deleteChaperoneProfile( unsigned index );

src/tabcontrollers/FixFloorTabController.cpp

@@ -3,23 +3,30 @@
 #include "../overlaycontroller.h"
 
 // application namespace
-namespace advsettings {
+namespace advsettings
+{
+void FixFloorTabController::initStage1() {}
 
-
+void FixFloorTabController::initStage2( OverlayController* var_parent,
-void FixFloorTabController::initStage1() {
+                                        QQuickWindow* var_widget )
-}
+{
-
-void FixFloorTabController::initStage2(OverlayController * var_parent, QQuickWindow * var_widget) {
     this->parent = var_parent;
     this->widget = var_widget;
 }
 
-void FixFloorTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses) {
+void FixFloorTabController::eventLoopTick(
-	if (state > 0) {
+    vr::TrackedDevicePose_t* devicePoses )
-		if (measurementCount == 0) {
+{
+    if ( state > 0 )
+    {
+        if ( measurementCount == 0 )
+        {
             // Get Controller ids for left/right hand
-			auto leftId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_LeftHand);
+            auto leftId
-			if (leftId == vr::k_unTrackedDeviceIndexInvalid) {
+                = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(
+                    vr::TrackedControllerRole_LeftHand );
+            if ( leftId == vr::k_unTrackedDeviceIndexInvalid )
+            {
                 statusMessage = "No left controller found.";
                 statusMessageTimeout = 2.0;
                 emit statusMessageSignal();
@@ -27,8 +34,11 @@ void FixFloorTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses)
                 state = 0;
                 return;
             }
-			auto rightId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand);
+            auto rightId
-			if (rightId == vr::k_unTrackedDeviceIndexInvalid) {
+                = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(
+                    vr::TrackedControllerRole_RightHand );
+            if ( rightId == vr::k_unTrackedDeviceIndexInvalid )
+            {
                 statusMessage = "No right controller found.";
                 statusMessageTimeout = 2.0;
                 emit statusMessageSignal();
@@ -39,29 +49,43 @@ void FixFloorTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses)
             // Get poses
             vr::TrackedDevicePose_t* leftPose = devicePoses + leftId;
             vr::TrackedDevicePose_t* rightPose = devicePoses + rightId;
-			if (!leftPose->bPoseIsValid || !leftPose->bDeviceIsConnected || leftPose->eTrackingResult != vr::TrackingResult_Running_OK) {
+            if ( !leftPose->bPoseIsValid || !leftPose->bDeviceIsConnected
+                 || leftPose->eTrackingResult != vr::TrackingResult_Running_OK )
+            {
                 statusMessage = "Left controller tracking problems.";
                 statusMessageTimeout = 2.0;
                 emit statusMessageSignal();
                 emit measureEndSignal();
                 state = 0;
                 return;
-			} else if (!rightPose->bPoseIsValid || !rightPose->bDeviceIsConnected || rightPose->eTrackingResult != vr::TrackingResult_Running_OK) {
+            }
+            else if ( !rightPose->bPoseIsValid || !rightPose->bDeviceIsConnected
+                      || rightPose->eTrackingResult
+                             != vr::TrackingResult_Running_OK )
+            {
                 statusMessage = "Right controller tracking problems.";
                 statusMessageTimeout = 2.0;
                 emit statusMessageSignal();
                 emit measureEndSignal();
                 state = 0;
                 return;
-			} else {
+            }
-				// The controller with the lowest y-pos is the floor fix reference
+            else
-				if (leftPose->mDeviceToAbsoluteTracking.m[1][3] < rightPose->mDeviceToAbsoluteTracking.m[1][3]) {
+            {
+                // The controller with the lowest y-pos is the floor fix
+                // reference
+                if ( leftPose->mDeviceToAbsoluteTracking.m[1][3]
+                     < rightPose->mDeviceToAbsoluteTracking.m[1][3] )
+                {
                     referenceController = leftId;
-				} else {
+                }
+                else
+                {
                     referenceController = rightId;
                 }
 
-				auto& m = devicePoses[referenceController].mDeviceToAbsoluteTracking.m;
+                auto& m = devicePoses[referenceController]
+                              .mDeviceToAbsoluteTracking.m;
                 tempOffsetX = ( double ) m[0][3];
                 tempOffsetY = ( double ) m[1][3];
                 tempOffsetZ = ( double ) m[2][3];
@@ -78,43 +102,63 @@ void FixFloorTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses)
                 tempRoll = std::atan2( ( double ) m[1][0], ( double ) m[1][1] );
                 measurementCount = 1;
             }
-
+        }
-		} else {
+        else
+        {
             measurementCount++;
-			auto& m = devicePoses[referenceController].mDeviceToAbsoluteTracking.m;
+            auto& m
+                = devicePoses[referenceController].mDeviceToAbsoluteTracking.m;
 
-			double rollDiff = std::atan2((double)m[1][0], (double)m[1][1]) - tempRoll;
+            double rollDiff
-			if (rollDiff > M_PI) {
+                = std::atan2( ( double ) m[1][0], ( double ) m[1][1] )
+                  - tempRoll;
+            if ( rollDiff > M_PI )
+            {
                 rollDiff -= 2.0 * M_PI;
-			} else if (rollDiff < -M_PI) {
+            }
+            else if ( rollDiff < -M_PI )
+            {
                 rollDiff += 2.0 * M_PI;
             }
             tempRoll += rollDiff / ( double ) measurementCount;
-			if (tempRoll > M_PI) {
+            if ( tempRoll > M_PI )
+            {
                 tempRoll -= 2.0 * M_PI;
-			} else if (tempRoll < -M_PI) {
+            }
+            else if ( tempRoll < -M_PI )
+            {
                 tempRoll += 2.0 * M_PI;
             }
 
-			if (measurementCount >= 25) {
+            if ( measurementCount >= 25 )
-				if (std::abs(tempRoll) <= M_PI_2) {
+            {
+                if ( std::abs( tempRoll ) <= M_PI_2 )
+                {
                     floorOffsetY = tempOffsetY - controllerUpOffsetCorrection;
-				} else {
+                }
+                else
+                {
                     floorOffsetY = tempOffsetY - controllerDownOffsetCorrection;
                 }
 
                 floorOffsetX = tempOffsetX;
                 floorOffsetZ = tempOffsetZ;
 
-				LOG(INFO) << "Fix Floor and adjust playspace center: Floor Offset = [" << floorOffsetX << ", " << floorOffsetY << ", " << floorOffsetZ << "]";
+                LOG( INFO )
+                    << "Fix Floor and adjust playspace center: Floor Offset = ["
+                    << floorOffsetX << ", " << floorOffsetY << ", "
+                    << floorOffsetZ << "]";
                 float offset[3] = { 0, 0, 0 };
                 offset[1] = floorOffsetY;
-				if (state == 2) {
+                if ( state == 2 )
+                {
                     offset[0] = floorOffsetX;
                     offset[2] = floorOffsetZ;
                 }
-				parent->AddOffsetToUniverseCenter(vr::TrackingUniverseStanding, offset, true);
+                parent->AddOffsetToUniverseCenter(
-				statusMessage = (state == 2) ? "Recentering ... Ok" : "Fixing ... OK";
+                    vr::TrackingUniverseStanding, offset, true );
+                statusMessage
+                    = ( state == 2 ) ? "Recentering ... Ok" : "Fixing ... OK";
                 statusMessageTimeout = 1.0;
                 emit statusMessageSignal();
                 emit measureEndSignal();
@@ -125,28 +169,35 @@ void FixFloorTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses)
     }
 }
 
-QString FixFloorTabController::currentStatusMessage() {
+QString FixFloorTabController::currentStatusMessage()
+{
     return statusMessage;
 }
 
-float FixFloorTabController::currentStatusMessageTimeout() {
+float FixFloorTabController::currentStatusMessageTimeout()
+{
     return statusMessageTimeout;
 }
 
-bool FixFloorTabController::canUndo() const {
+bool FixFloorTabController::canUndo() const
+{
     return m_canUndo;
 }
 
-void FixFloorTabController::setCanUndo(bool value, bool notify) {
+void FixFloorTabController::setCanUndo( bool value, bool notify )
-	if (m_canUndo != value) {
+{
+    if ( m_canUndo != value )
+    {
         m_canUndo = value;
-		if (notify) {
+        if ( notify )
+        {
             emit canUndoChanged( m_canUndo );
         }
     }
 }
 
-void FixFloorTabController::fixFloorClicked() {
+void FixFloorTabController::fixFloorClicked()
+{
     statusMessage = "Fixing ...";
     statusMessageTimeout = 1.0;
     emit statusMessageSignal();
@@ -155,7 +206,8 @@ void FixFloorTabController::fixFloorClicked() {
     state = 1;
 }
 
-void FixFloorTabController::recenterClicked() {
+void FixFloorTabController::recenterClicked()
+{
     statusMessage = "Fixing ...";
     statusMessageTimeout = 1.0;
     emit statusMessageSignal();
@@ -164,11 +216,16 @@ void FixFloorTabController::recenterClicked() {
     state = 2;
 }
 
-void FixFloorTabController::undoFixFloorClicked() {
+void FixFloorTabController::undoFixFloorClicked()
-	parent->AddOffsetToUniverseCenter(vr::TrackingUniverseStanding, 0, -floorOffsetX, false);
+{
-	parent->AddOffsetToUniverseCenter(vr::TrackingUniverseStanding, 1, -floorOffsetY, false);
+    parent->AddOffsetToUniverseCenter(
-	parent->AddOffsetToUniverseCenter(vr::TrackingUniverseStanding, 2, -floorOffsetZ, false);
+        vr::TrackingUniverseStanding, 0, -floorOffsetX, false );
-	LOG(INFO) << "Fix Floor: Undo Floor Offset = [" << -floorOffsetX << ", " << -floorOffsetY << ", " << -floorOffsetZ << "]";
+    parent->AddOffsetToUniverseCenter(
+        vr::TrackingUniverseStanding, 1, -floorOffsetY, false );
+    parent->AddOffsetToUniverseCenter(
+        vr::TrackingUniverseStanding, 2, -floorOffsetZ, false );
+    LOG( INFO ) << "Fix Floor: Undo Floor Offset = [" << -floorOffsetX << ", "
+                << -floorOffsetY << ", " << -floorOffsetZ << "]";
     floorOffsetY = 0.0f;
     statusMessage = "Undo ... OK";
     statusMessageTimeout = 1.0;
@@ -176,4 +233,4 @@ void FixFloorTabController::undoFixFloorClicked() {
     setCanUndo( false );
 }
 
-} // namespace advconfig
+} // namespace advsettings

src/tabcontrollers/FixFloorTabController.h

@@ -6,24 +6,30 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-class FixFloorTabController : public QObject {
+class FixFloorTabController : public QObject
+{
     Q_OBJECT
-	Q_PROPERTY(bool canUndo READ canUndo WRITE setCanUndo NOTIFY canUndoChanged)
+    Q_PROPERTY(
+        bool canUndo READ canUndo WRITE setCanUndo NOTIFY canUndoChanged )
 
 private:
     OverlayController* parent;
     QQuickWindow* widget;
 
-	float controllerUpOffsetCorrection = 0.062f; // Controller touchpad facing upwards
+    float controllerUpOffsetCorrection
-	float controllerDownOffsetCorrection = 0.006f; // Controller touchpad facing downwards
+        = 0.062f; // Controller touchpad facing upwards
+    float controllerDownOffsetCorrection
+        = 0.006f; // Controller touchpad facing downwards
 
-	int state = 0; // 0 .. idle, 1 .. floor fix in progress, 2 .. recenter in progress
+    int state
-	vr::TrackedDeviceIndex_t referenceController = vr::k_unTrackedDeviceIndexInvalid;
+        = 0; // 0 .. idle, 1 .. floor fix in progress, 2 .. recenter in progress
+    vr::TrackedDeviceIndex_t referenceController
+        = vr::k_unTrackedDeviceIndexInvalid;
     unsigned measurementCount = 0;
     double tempOffsetX = 0.0;
     double tempOffsetY = 0.0;
@@ -36,7 +42,6 @@ private:
     float statusMessageTimeout = 0.0f;
     bool m_canUndo = false;
 
-
 public:
     void initStage1();
     void initStage2( OverlayController* parent, QQuickWindow* widget );

src/tabcontrollers/KeyboardInput.h

@@ -4,8 +4,8 @@
 #include <QString>
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 class AudioTabController;
 
 class KeyboardInput
@@ -19,5 +19,4 @@ public:
     virtual void sendKeyboardAltTab() = 0;
 };
 
-}
+} // namespace advsettings
-

src/tabcontrollers/MoveCenterTabController.cpp

@@ -2,8 +2,10 @@
 #include <QQuickWindow>
 #include "../overlaycontroller.h"
 
-void rotateCoordinates(float coordinates[3], float angle) {
+void rotateCoordinates( float coordinates[3], float angle )
-	if (angle == 0) {
+{
+    if ( angle == 0 )
+    {
         return;
     }
     float s = sin( angle );
@@ -15,136 +17,170 @@ void rotateCoordinates(float coordinates[3], float angle) {
 }
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 using std::chrono::duration_cast;
 using std::chrono::milliseconds;
 typedef std::chrono::system_clock clock;
 
-void MoveCenterTabController::initStage1() {
+void MoveCenterTabController::initStage1()
+{
     setTrackingUniverse( vr::VRCompositor()->GetTrackingSpace() );
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "playspaceSettings" );
     auto value = settings->value( "adjustChaperone", m_adjustChaperone );
-	if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_adjustChaperone = value.toBool();
     }
     value = settings->value( "moveShortcutRight", m_moveShortcutRightEnabled );
-	if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_moveShortcutRightEnabled = value.toBool();
     }
     value = settings->value( "moveShortcutLeft", m_moveShortcutLeftEnabled );
-	if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_moveShortcutLeftEnabled = value.toBool();
     }
     value = settings->value( "requireDoubleClick", m_requireDoubleClick );
-    if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_requireDoubleClick = value.toBool();
     }
     value = settings->value( "lockXToggle", m_lockXToggle );
-	if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_lockXToggle = value.toBool();
     }
     value = settings->value( "lockYToggle", m_lockYToggle );
-	if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_lockYToggle = value.toBool();
     }
     value = settings->value( "lockZToggle", m_lockZToggle );
-	if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_lockZToggle = value.toBool();
     }
     settings->endGroup();
     lastMoveButtonClick[0] = lastMoveButtonClick[1] = clock::now();
 }
 
-void MoveCenterTabController::initStage2(OverlayController * var_parent, QQuickWindow * var_widget) {
+void MoveCenterTabController::initStage2( OverlayController* var_parent,
+                                          QQuickWindow* var_widget )
+{
     this->parent = var_parent;
     this->widget = var_widget;
 }
 
-
+int MoveCenterTabController::trackingUniverse() const
-int MoveCenterTabController::trackingUniverse() const {
+{
     return ( int ) m_trackingUniverse;
 }
 
-void MoveCenterTabController::setTrackingUniverse(int value, bool notify) {
+void MoveCenterTabController::setTrackingUniverse( int value, bool notify )
-	if (m_trackingUniverse != value) {
+{
+    if ( m_trackingUniverse != value )
+    {
         reset();
         m_trackingUniverse = value;
-		if (notify) {
+        if ( notify )
+        {
             emit trackingUniverseChanged( m_trackingUniverse );
         }
     }
 }
 
-float MoveCenterTabController::offsetX() const {
+float MoveCenterTabController::offsetX() const
+{
     return m_offsetX;
 }
 
-void MoveCenterTabController::setOffsetX(float value, bool notify) {
+void MoveCenterTabController::setOffsetX( float value, bool notify )
-	if (m_offsetX != value) {
+{
+    if ( m_offsetX != value )
+    {
         modOffsetX( value - m_offsetX, notify );
     }
 }
 
-float MoveCenterTabController::offsetY() const {
+float MoveCenterTabController::offsetY() const
+{
     return m_offsetY;
 }
 
-void MoveCenterTabController::setOffsetY(float value, bool notify) {
+void MoveCenterTabController::setOffsetY( float value, bool notify )
-	if (m_offsetY != value) {
+{
+    if ( m_offsetY != value )
+    {
         modOffsetY( value - m_offsetY, notify );
     }
 }
 
-float MoveCenterTabController::offsetZ() const {
+float MoveCenterTabController::offsetZ() const
+{
     return m_offsetZ;
 }
 
-void MoveCenterTabController::setOffsetZ(float value, bool notify) {
+void MoveCenterTabController::setOffsetZ( float value, bool notify )
-	if (m_offsetZ != value) {
+{
+    if ( m_offsetZ != value )
+    {
         modOffsetZ( value - m_offsetZ, notify );
     }
 }
 
-int MoveCenterTabController::rotation() const {
+int MoveCenterTabController::rotation() const
+{
     return m_rotation;
 }
 
-void MoveCenterTabController::setRotation(int value, bool notify) {
+void MoveCenterTabController::setRotation( int value, bool notify )
-	if (m_rotation != value) {
+{
+    if ( m_rotation != value )
+    {
         // float angle = (value - m_rotation) * 2 * M_PI / 360.0;
-		//parent->RotateUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, angle, m_adjustChaperone);
+        // parent->RotateUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse,
+        // angle, m_adjustChaperone);
         m_rotation = value;
-		 if (notify) {
+        if ( notify )
+        {
             emit rotationChanged( m_rotation );
         }
     }
 }
 
-void MoveCenterTabController::applyRotation() {
+void MoveCenterTabController::applyRotation()
-	if (m_rotation != m_rotationOld) {
+{
+    if ( m_rotation != m_rotationOld )
+    {
         float angle = ( m_rotationOld - m_rotation ) * 2 * M_PI / 360.0;
-		parent->RotateUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, angle, m_adjustChaperone);
+        parent->RotateUniverseCenter(
+            ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+            angle,
+            m_adjustChaperone );
         m_rotationOld = m_rotation;
     }
 }
 
-bool MoveCenterTabController::adjustChaperone() const {
+bool MoveCenterTabController::adjustChaperone() const
+{
     return m_adjustChaperone;
 }
 
-void MoveCenterTabController::setAdjustChaperone(bool value, bool notify) {
+void MoveCenterTabController::setAdjustChaperone( bool value, bool notify )
-	if (m_adjustChaperone != value) {
+{
+    if ( m_adjustChaperone != value )
+    {
         m_adjustChaperone = value;
-		if (m_trackingUniverse == vr::TrackingUniverseStanding) {
+        if ( m_trackingUniverse == vr::TrackingUniverseStanding )
+        {
             auto angle = m_rotation * 2 * M_PI / 360.0;
             float offsetdir = m_adjustChaperone ? -1.0 : 1.0;
-			float offset[3] = {
+            float offset[3] = { offsetdir * m_offsetX,
-				offsetdir * m_offsetX,
                                 offsetdir * m_offsetY,
-				offsetdir * m_offsetZ
+                                offsetdir * m_offsetZ };
-			};
             rotateCoordinates( offset, angle );
 
             parent->AddOffsetToCollisionBounds( offset );
@@ -154,158 +190,197 @@ void MoveCenterTabController::setAdjustChaperone(bool value, bool notify) {
         settings->setValue( "adjustChaperone", m_adjustChaperone );
         settings->endGroup();
         settings->sync();
-		if (notify) {
+        if ( notify )
+        {
             emit adjustChaperoneChanged( m_adjustChaperone );
         }
     }
 }
 
-
+bool MoveCenterTabController::moveShortcutRight() const
-bool MoveCenterTabController::moveShortcutRight() const {
+{
     return m_moveShortcutRightEnabled;
 }
 
-void MoveCenterTabController::setMoveShortcutRight(bool value, bool notify) {
+void MoveCenterTabController::setMoveShortcutRight( bool value, bool notify )
+{
     m_moveShortcutRightEnabled = value;
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "playspaceSettings" );
     settings->setValue( "moveShortcutRight", m_moveShortcutRightEnabled );
     settings->endGroup();
     settings->sync();
-	if (notify) {
+    if ( notify )
+    {
         emit moveShortcutRightChanged( m_moveShortcutRightEnabled );
     }
 }
 
-bool MoveCenterTabController::moveShortcutLeft() const {
+bool MoveCenterTabController::moveShortcutLeft() const
+{
     return m_moveShortcutLeftEnabled;
 }
 
-void MoveCenterTabController::setMoveShortcutLeft(bool value, bool notify) {
+void MoveCenterTabController::setMoveShortcutLeft( bool value, bool notify )
+{
     m_moveShortcutLeftEnabled = value;
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "playspaceSettings" );
     settings->setValue( "moveShortcutLeft", m_moveShortcutLeftEnabled );
     settings->endGroup();
     settings->sync();
-	if (notify) {
+    if ( notify )
+    {
         emit moveShortcutLeftChanged( m_moveShortcutLeftEnabled );
     }
 }
 
-bool MoveCenterTabController::requireDoubleClick() const {
+bool MoveCenterTabController::requireDoubleClick() const
+{
     return m_requireDoubleClick;
 }
 
-void MoveCenterTabController::setRequireDoubleClick(bool value, bool notify) {
+void MoveCenterTabController::setRequireDoubleClick( bool value, bool notify )
+{
     m_requireDoubleClick = value;
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "playspaceSettings" );
     settings->setValue( "requireDoubleClick", m_requireDoubleClick );
     settings->endGroup();
     settings->sync();
-    if (notify) {
+    if ( notify )
+    {
         emit requireDoubleClickChanged( m_requireDoubleClick );
     }
 }
 
-bool MoveCenterTabController::lockXToggle() const {
+bool MoveCenterTabController::lockXToggle() const
+{
     return m_lockXToggle;
 }
 
-void MoveCenterTabController::setLockX(bool value, bool notify) {
+void MoveCenterTabController::setLockX( bool value, bool notify )
+{
     m_lockXToggle = value;
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "playspaceSettings" );
     settings->setValue( "lockXToggle", m_lockXToggle );
     settings->endGroup();
     settings->sync();
-	if (notify) {
+    if ( notify )
+    {
         emit requireLockXChanged( m_lockXToggle );
     }
 }
 
-
+bool MoveCenterTabController::lockYToggle() const
-bool MoveCenterTabController::lockYToggle() const {
+{
     return m_lockYToggle;
 }
 
-void MoveCenterTabController::setLockY(bool value, bool notify) {
+void MoveCenterTabController::setLockY( bool value, bool notify )
+{
     m_lockYToggle = value;
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "playspaceSettings" );
     settings->setValue( "lockYToggle", m_lockYToggle );
     settings->endGroup();
     settings->sync();
-	if (notify) {
+    if ( notify )
+    {
         emit requireLockYChanged( m_lockYToggle );
     }
 }
 
-bool MoveCenterTabController::lockZToggle() const {
+bool MoveCenterTabController::lockZToggle() const
+{
     return m_lockZToggle;
 }
 
-void MoveCenterTabController::setLockZ(bool value, bool notify) {
+void MoveCenterTabController::setLockZ( bool value, bool notify )
+{
     m_lockZToggle = value;
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "playspaceSettings" );
     settings->setValue( "lockZToggle", m_lockZToggle );
     settings->endGroup();
     settings->sync();
-	if (notify) {
+    if ( notify )
+    {
         emit requireLockZChanged( m_lockZToggle );
     }
 }
 
-
+void MoveCenterTabController::modOffsetX( float value, bool notify )
-
+{
-void MoveCenterTabController::modOffsetX(float value, bool notify) {
     // TODO ? possible issue with locking position this way
-	if (!m_lockXToggle) {
+    if ( !m_lockXToggle )
+    {
         auto angle = m_rotation * 2 * M_PI / 360.0;
         float offset[3] = { value, 0, 0 };
         rotateCoordinates( offset, angle );
-		parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, offset, m_adjustChaperone);
+        parent->AddOffsetToUniverseCenter(
+            ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+            offset,
+            m_adjustChaperone );
         m_offsetX += value;
-		if (notify) {
+        if ( notify )
+        {
             emit offsetXChanged( m_offsetX );
         }
     }
 }
 
-void MoveCenterTabController::modOffsetY(float value, bool notify) {
+void MoveCenterTabController::modOffsetY( float value, bool notify )
-	if (!m_lockYToggle) {
+{
-		parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, 1, value, m_adjustChaperone);
+    if ( !m_lockYToggle )
+    {
+        parent->AddOffsetToUniverseCenter(
+            ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+            1,
+            value,
+            m_adjustChaperone );
         m_offsetY += value;
-		if (notify) {
+        if ( notify )
+        {
             emit offsetYChanged( m_offsetY );
         }
     }
 }
 
-void MoveCenterTabController::modOffsetZ(float value, bool notify) {
+void MoveCenterTabController::modOffsetZ( float value, bool notify )
-	if (!m_lockZToggle) {
+{
+    if ( !m_lockZToggle )
+    {
         auto angle = m_rotation * 2 * M_PI / 360.0;
         float offset[3] = { 0, 0, value };
         rotateCoordinates( offset, angle );
-		parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, offset, m_adjustChaperone);
+        parent->AddOffsetToUniverseCenter(
+            ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+            offset,
+            m_adjustChaperone );
         m_offsetZ += value;
-		if (notify) {
+        if ( notify )
+        {
             emit offsetZChanged( m_offsetZ );
         }
     }
 }
 
-void MoveCenterTabController::reset() {
+void MoveCenterTabController::reset()
+{
     vr::VRChaperoneSetup()->RevertWorkingCopy();
-	parent->RotateUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, -m_rotation * 2 * M_PI / 360.0, m_adjustChaperone, false);
+    parent->RotateUniverseCenter(
-	float offset[3] = {
+        ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
-		-m_offsetX,
+        -m_rotation * 2 * M_PI / 360.0,
-		-m_offsetY,
+        m_adjustChaperone,
-		-m_offsetZ
+        false );
-	};
+    float offset[3] = { -m_offsetX, -m_offsetY, -m_offsetZ };
-	parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, offset, m_adjustChaperone, false);
+    parent->AddOffsetToUniverseCenter(
+        ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+        offset,
+        m_adjustChaperone,
+        false );
     vr::VRChaperoneSetup()->CommitWorkingCopy( vr::EChaperoneConfigFile_Live );
     m_offsetX = 0.0f;
     m_offsetY = 0.0f;
@@ -317,55 +392,84 @@ void MoveCenterTabController::reset() {
     emit rotationChanged( m_rotation );
 }
 
-bool isMoveShortCutPressed(vr::ETrackedControllerRole hand) {
+bool isMoveShortCutPressed( vr::ETrackedControllerRole hand )
-	auto handId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(hand);
+{
-	if (handId == vr::k_unTrackedDeviceIndexInvalid || handId >= vr::k_unMaxTrackedDeviceCount) {
+    auto handId
+        = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole( hand );
+    if ( handId == vr::k_unTrackedDeviceIndexInvalid
+         || handId >= vr::k_unMaxTrackedDeviceCount )
+    {
         return false;
     }
 
     vr::VRControllerState_t state;
-	if (vr::VRSystem()->GetControllerState(handId, &state, sizeof(vr::VRControllerState_t))) {
+    if ( vr::VRSystem()->GetControllerState(
-		return state.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ApplicationMenu);
+             handId, &state, sizeof( vr::VRControllerState_t ) ) )
+    {
+        return state.ulButtonPressed
+               & vr::ButtonMaskFromId( vr::k_EButton_ApplicationMenu );
     }
 
     return false;
 }
 
-vr::ETrackedControllerRole MoveCenterTabController::getMoveShortcutHand() {
+vr::ETrackedControllerRole MoveCenterTabController::getMoveShortcutHand()
+{
     auto activeHand = m_activeMoveController;
 
-	bool rightPressed = m_moveShortcutRightEnabled && isMoveShortCutPressed(vr::TrackedControllerRole_RightHand);
+    bool rightPressed
-	bool leftPressed = m_moveShortcutLeftEnabled && isMoveShortCutPressed(vr::TrackedControllerRole_LeftHand);
+        = m_moveShortcutRightEnabled
-    bool checkDoubleClick = m_requireDoubleClick && activeHand == vr::TrackedControllerRole_Invalid;
+          && isMoveShortCutPressed( vr::TrackedControllerRole_RightHand );
+    bool leftPressed
+        = m_moveShortcutLeftEnabled
+          && isMoveShortCutPressed( vr::TrackedControllerRole_LeftHand );
+    bool checkDoubleClick = m_requireDoubleClick
+                            && activeHand == vr::TrackedControllerRole_Invalid;
 
     auto now = clock::now();
-	// if we start pressing the shortcut on a controller we set the active one to it
+    // if we start pressing the shortcut on a controller we set the active one
-	if (rightPressed && !m_moveShortcutRightPressed) {
+    // to it
-        auto elapsed = duration_cast<milliseconds>(now - lastMoveButtonClick[0]).count();
+    if ( rightPressed && !m_moveShortcutRightPressed )
-        if (!checkDoubleClick || elapsed < 250) {
+    {
+        auto elapsed
+            = duration_cast<milliseconds>( now - lastMoveButtonClick[0] )
+                  .count();
+        if ( !checkDoubleClick || elapsed < 250 )
+        {
             activeHand = vr::TrackedControllerRole_RightHand;
         }
         lastMoveButtonClick[0] = now;
     }
-	if (leftPressed && !m_moveShortcutLeftPressed) {
+    if ( leftPressed && !m_moveShortcutLeftPressed )
-        auto elapsed = duration_cast<milliseconds>(now - lastMoveButtonClick[1]).count();
+    {
-        if (!checkDoubleClick || elapsed < 250) {
+        auto elapsed
+            = duration_cast<milliseconds>( now - lastMoveButtonClick[1] )
+                  .count();
+        if ( !checkDoubleClick || elapsed < 250 )
+        {
             activeHand = vr::TrackedControllerRole_LeftHand;
         }
         lastMoveButtonClick[1] = now;
     }
 
-	// if we let down of a shortcut we set the active hand to any remaining pressed down hand
+    // if we let down of a shortcut we set the active hand to any remaining
-	if (!rightPressed && m_moveShortcutRightPressed) {
+    // pressed down hand
-		activeHand = leftPressed ? vr::TrackedControllerRole_LeftHand : vr::TrackedControllerRole_Invalid;
+    if ( !rightPressed && m_moveShortcutRightPressed )
+    {
+        activeHand = leftPressed ? vr::TrackedControllerRole_LeftHand
+                                 : vr::TrackedControllerRole_Invalid;
     }
-	if (!leftPressed && m_moveShortcutLeftPressed) {
+    if ( !leftPressed && m_moveShortcutLeftPressed )
-		activeHand = rightPressed ? vr::TrackedControllerRole_RightHand : vr::TrackedControllerRole_Invalid;
+    {
+        activeHand = rightPressed ? vr::TrackedControllerRole_RightHand
+                                  : vr::TrackedControllerRole_Invalid;
     }
 
-	if (!leftPressed && !rightPressed) {
+    if ( !leftPressed && !rightPressed )
+    {
         activeHand = vr::TrackedControllerRole_Invalid;
-        if (m_activeMoveController != vr::TrackedControllerRole_Invalid) {
+        if ( m_activeMoveController != vr::TrackedControllerRole_Invalid )
+        {
             // grace period while switching hands
             lastMoveButtonClick[0] = lastMoveButtonClick[1] = now;
         }
@@ -378,24 +482,35 @@ vr::ETrackedControllerRole MoveCenterTabController::getMoveShortcutHand() {
     return activeHand;
 }
 
-
+void MoveCenterTabController::eventLoopTick(
-void MoveCenterTabController::eventLoopTick(vr::ETrackingUniverseOrigin universe, vr::TrackedDevicePose_t* devicePoses) {
+    vr::ETrackingUniverseOrigin universe,
-	if (settingsUpdateCounter >= 50) {
+    vr::TrackedDevicePose_t* devicePoses )
+{
+    if ( settingsUpdateCounter >= 50 )
+    {
         setTrackingUniverse( ( int ) universe );
         settingsUpdateCounter = 0;
-	} else {
+    }
+    else
+    {
         settingsUpdateCounter++;
         auto oldMoveHand = m_activeMoveController;
         auto newMoveHand = getMoveShortcutHand();
-		if (newMoveHand == vr::TrackedControllerRole_Invalid) {
+        if ( newMoveHand == vr::TrackedControllerRole_Invalid )
+        {
             emit offsetXChanged( m_offsetX );
             emit offsetYChanged( m_offsetY );
             emit offsetZChanged( m_offsetZ );
             return;
         }
-		auto handId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(newMoveHand);
+        auto handId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(
-		if (newMoveHand == vr::TrackedControllerRole_Invalid || handId == vr::k_unTrackedDeviceIndexInvalid || handId >= vr::k_unMaxTrackedDeviceCount) {
+            newMoveHand );
-			if (oldMoveHand != vr::TrackedControllerRole_Invalid) {
+        if ( newMoveHand == vr::TrackedControllerRole_Invalid
+             || handId == vr::k_unTrackedDeviceIndexInvalid
+             || handId >= vr::k_unMaxTrackedDeviceCount )
+        {
+            if ( oldMoveHand != vr::TrackedControllerRole_Invalid )
+            {
                 emit offsetXChanged( m_offsetX );
                 emit offsetYChanged( m_offsetY );
                 emit offsetZChanged( m_offsetZ );
@@ -403,14 +518,15 @@ void MoveCenterTabController::eventLoopTick(vr::ETrackingUniverseOrigin universe
             return;
         }
         vr::TrackedDevicePose_t* pose = devicePoses + handId;
-		if (!pose->bPoseIsValid || !pose->bDeviceIsConnected || pose->eTrackingResult != vr::TrackingResult_Running_OK) {
+        if ( !pose->bPoseIsValid || !pose->bDeviceIsConnected
+             || pose->eTrackingResult != vr::TrackingResult_Running_OK )
+        {
             return;
         }
-		float relativeControllerPosition[] = {
+        float relativeControllerPosition[]
-			pose->mDeviceToAbsoluteTracking.m[0][3],
+            = { pose->mDeviceToAbsoluteTracking.m[0][3],
                 pose->mDeviceToAbsoluteTracking.m[1][3],
-			pose->mDeviceToAbsoluteTracking.m[2][3]
+                pose->mDeviceToAbsoluteTracking.m[2][3] };
-        };
 
         auto angle = m_rotation * 2 * M_PI / 360.0;
         rotateCoordinates( relativeControllerPosition, -angle );
@@ -420,8 +536,8 @@ void MoveCenterTabController::eventLoopTick(vr::ETrackingUniverseOrigin universe
             relativeControllerPosition[2] + m_offsetZ,
         };
 
-		if (oldMoveHand == newMoveHand) {
+        if ( oldMoveHand == newMoveHand )
-
+        {
             float diff[3] = {
                 absoluteControllerPosition[0] - m_lastControllerPosition[0],
                 absoluteControllerPosition[1] - m_lastControllerPosition[1],
@@ -431,31 +547,38 @@ void MoveCenterTabController::eventLoopTick(vr::ETrackingUniverseOrigin universe
             // offset is un-rotated coordinates
 
             // prevents UI from updating if axis movement is locked
-			if (!m_lockXToggle) {
+            if ( !m_lockXToggle )
+            {
                 m_offsetX += diff[0];
             }
-			if (!m_lockYToggle) {
+            if ( !m_lockYToggle )
+            {
                 m_offsetY += diff[1];
             }
-			if (!m_lockZToggle) {
+            if ( !m_lockZToggle )
+            {
                 m_offsetZ += diff[2];
             }
 
-
-
             rotateCoordinates( diff, angle );
             // If locked removes movement
-			if (m_lockXToggle) {
+            if ( m_lockXToggle )
+            {
                 diff[0] = 0;
             }
-			if (m_lockYToggle) {
+            if ( m_lockYToggle )
+            {
                 diff[1] = 0;
             }
-			if (m_lockZToggle) {
+            if ( m_lockZToggle )
+            {
                 diff[2] = 0;
             }
 
-			parent->AddOffsetToUniverseCenter((vr::TrackingUniverseOrigin)m_trackingUniverse, diff, m_adjustChaperone);
+            parent->AddOffsetToUniverseCenter(
+                ( vr::TrackingUniverseOrigin ) m_trackingUniverse,
+                diff,
+                m_adjustChaperone );
         }
         m_lastControllerPosition[0] = absoluteControllerPosition[0];
         m_lastControllerPosition[1] = absoluteControllerPosition[1];
@@ -463,4 +586,4 @@ void MoveCenterTabController::eventLoopTick(vr::ETrackingUniverseOrigin universe
     }
 }
 
-} // namespace advconfig
+} // namespace advsettings

src/tabcontrollers/MoveCenterTabController.h

@@ -7,26 +7,38 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-
+class MoveCenterTabController : public QObject
-class MoveCenterTabController : public QObject {
+{
     Q_OBJECT
-	Q_PROPERTY(int trackingUniverse READ trackingUniverse WRITE setTrackingUniverse NOTIFY trackingUniverseChanged)
+    Q_PROPERTY( int trackingUniverse READ trackingUniverse WRITE
-	Q_PROPERTY(float offsetX READ offsetX WRITE setOffsetX NOTIFY offsetXChanged)
+                    setTrackingUniverse NOTIFY trackingUniverseChanged )
-	Q_PROPERTY(float offsetY READ offsetY WRITE setOffsetY NOTIFY offsetYChanged)
+    Q_PROPERTY(
-	Q_PROPERTY(float offsetZ READ offsetZ WRITE setOffsetZ NOTIFY offsetZChanged)
+        float offsetX READ offsetX WRITE setOffsetX NOTIFY offsetXChanged )
-	Q_PROPERTY(int rotation READ rotation WRITE setRotation NOTIFY rotationChanged )
+    Q_PROPERTY(
-	Q_PROPERTY(bool adjustChaperone READ adjustChaperone WRITE setAdjustChaperone NOTIFY adjustChaperoneChanged)
+        float offsetY READ offsetY WRITE setOffsetY NOTIFY offsetYChanged )
-	Q_PROPERTY(bool moveShortcutRight READ moveShortcutRight WRITE setMoveShortcutRight NOTIFY moveShortcutRightChanged)
+    Q_PROPERTY(
-	Q_PROPERTY(bool moveShortcutLeft READ moveShortcutLeft WRITE setMoveShortcutLeft NOTIFY moveShortcutLeftChanged)
+        float offsetZ READ offsetZ WRITE setOffsetZ NOTIFY offsetZChanged )
-    Q_PROPERTY(bool requireDoubleClick READ requireDoubleClick WRITE setRequireDoubleClick NOTIFY requireDoubleClickChanged)
+    Q_PROPERTY(
-	Q_PROPERTY(bool lockXToggle READ lockXToggle WRITE setLockX NOTIFY requireLockXChanged)
+        int rotation READ rotation WRITE setRotation NOTIFY rotationChanged )
-	Q_PROPERTY(bool lockYToggle READ lockYToggle WRITE setLockY NOTIFY requireLockYChanged)
+    Q_PROPERTY( bool adjustChaperone READ adjustChaperone WRITE
-	Q_PROPERTY(bool lockZToggle READ lockZToggle WRITE setLockZ NOTIFY requireLockZChanged)
+                    setAdjustChaperone NOTIFY adjustChaperoneChanged )
+    Q_PROPERTY( bool moveShortcutRight READ moveShortcutRight WRITE
+                    setMoveShortcutRight NOTIFY moveShortcutRightChanged )
+    Q_PROPERTY( bool moveShortcutLeft READ moveShortcutLeft WRITE
+                    setMoveShortcutLeft NOTIFY moveShortcutLeftChanged )
+    Q_PROPERTY( bool requireDoubleClick READ requireDoubleClick WRITE
+                    setRequireDoubleClick NOTIFY requireDoubleClickChanged )
+    Q_PROPERTY( bool lockXToggle READ lockXToggle WRITE setLockX NOTIFY
+                    requireLockXChanged )
+    Q_PROPERTY( bool lockYToggle READ lockYToggle WRITE setLockY NOTIFY
+                    requireLockYChanged )
+    Q_PROPERTY( bool lockZToggle READ lockZToggle WRITE setLockZ NOTIFY
+                    requireLockZChanged )
 
 private:
     OverlayController* parent;
@@ -59,7 +71,8 @@ public:
     void initStage1();
     void initStage2( OverlayController* parent, QQuickWindow* widget );
 
-	void eventLoopTick(vr::ETrackingUniverseOrigin universe, vr::TrackedDevicePose_t* devicePoses);
+    void eventLoopTick( vr::ETrackingUniverseOrigin universe,
+                        vr::TrackedDevicePose_t* devicePoses );
 
     float offsetX() const;
     float offsetY() const;

src/tabcontrollers/PttController.h

@@ -10,27 +10,31 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-  enum TouchPadArea {
+enum TouchPadArea
+{
     PAD_AREA_LEFT = ( 1 << 0 ),
     PAD_AREA_TOP = ( 1 << 1 ),
     PAD_AREA_RIGHT = ( 1 << 2 ),
     PAD_AREA_BOTTOM = ( 1 << 3 ),
 };
 
-  struct PttControllerConfig {
+struct PttControllerConfig
+{
     QVariantList digitalButtons;
     uint64_t digitalButtonMask = 0;
     unsigned triggerMode = 0; // 0 .. disabled, 1 .. enabled
-    unsigned touchpadMode = 0; // 0 .. disabled, 1 .. only touch, 2 .. only press, 3 .. both
+    unsigned touchpadMode
+        = 0; // 0 .. disabled, 1 .. only touch, 2 .. only press, 3 .. both
     unsigned touchpadAreas = 0;
 };
 
-  struct PttProfile {
+struct PttProfile
+{
     std::string profileName;
 
     bool showNotification = false;
@@ -39,14 +43,20 @@ namespace advsettings {
     PttControllerConfig controllerConfigs[2];
 };
 
-
+class PttController : public QObject
-  class PttController : public QObject {
+{
     Q_OBJECT
-    Q_PROPERTY(bool pttEnabled READ pttEnabled WRITE setPttEnabled NOTIFY pttEnabledChanged)
+    Q_PROPERTY( bool pttEnabled READ pttEnabled WRITE setPttEnabled NOTIFY
+                    pttEnabledChanged )
     Q_PROPERTY( bool pttActive READ pttActive NOTIFY pttActiveChanged )
-    Q_PROPERTY(bool pttShowNotification READ pttShowNotification WRITE setPttShowNotification NOTIFY pttShowNotificationChanged)
+    Q_PROPERTY( bool pttShowNotification READ pttShowNotification WRITE
-    Q_PROPERTY(bool pttLeftControllerEnabled READ pttLeftControllerEnabled WRITE setPttLeftControllerEnabled NOTIFY pttLeftControllerEnabledChanged)
+                    setPttShowNotification NOTIFY pttShowNotificationChanged )
-    Q_PROPERTY(bool pttRightControllerEnabled READ pttRightControllerEnabled WRITE setPttRightControllerEnabled NOTIFY pttRightControllerEnabledChanged)
+    Q_PROPERTY(
+        bool pttLeftControllerEnabled READ pttLeftControllerEnabled WRITE
+            setPttLeftControllerEnabled NOTIFY pttLeftControllerEnabledChanged )
+    Q_PROPERTY( bool pttRightControllerEnabled READ pttRightControllerEnabled
+                    WRITE setPttRightControllerEnabled NOTIFY
+                        pttRightControllerEnabledChanged )
 
 protected:
     bool m_pttEnabled = false;
@@ -65,8 +75,14 @@ namespace advsettings {
     virtual void onPttStop(){};
     virtual void onPttEnabled(){};
     virtual void onPttDisabled(){};
-    virtual bool pttChangeValid() { return true; }
+    virtual bool pttChangeValid()
-    virtual vr::VROverlayHandle_t getNotificationOverlayHandle() { return vr::k_ulOverlayHandleInvalid; }
+    {
+        return true;
+    }
+    virtual vr::VROverlayHandle_t getNotificationOverlayHandle()
+    {
+        return vr::k_ulOverlayHandleInvalid;
+    }
     std::recursive_mutex eventLoopMutex;
 
 public:
@@ -84,7 +100,6 @@ namespace advsettings {
     void savePttProfiles();
     void savePttConfig();
 
-
     Q_INVOKABLE QVariantList pttDigitalButtons( unsigned controller );
     Q_INVOKABLE unsigned long pttDigitalButtonMask( unsigned controller );
     Q_INVOKABLE unsigned pttTouchpadMode( unsigned controller );
@@ -96,11 +111,21 @@ namespace advsettings {
 
 public slots:
     void setPttEnabled( bool value, bool notify = true, bool save = true );
-    void setPttShowNotification(bool value, bool notify = true, bool save = true);
+    void setPttShowNotification( bool value,
-    void setPttLeftControllerEnabled(bool value, bool notify = true, bool save = true);
+                                 bool notify = true,
-    void setPttRightControllerEnabled(bool value, bool notify = true, bool save = true);
+                                 bool save = true );
+    void setPttLeftControllerEnabled( bool value,
+                                      bool notify = true,
+                                      bool save = true );
+    void setPttRightControllerEnabled( bool value,
+                                       bool notify = true,
+                                       bool save = true );
 
-    void setPttControllerConfig(unsigned controller, QVariantList buttons, unsigned triggerMode, unsigned padMode, unsigned padAreas);
+    void setPttControllerConfig( unsigned controller,
+                                 QVariantList buttons,
+                                 unsigned triggerMode,
+                                 unsigned padMode,
+                                 unsigned padAreas );
 
     void addPttProfile( QString name );
     void applyPttProfile( unsigned index );

src/tabcontrollers/ReviveTabController.h

@@ -5,14 +5,13 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
-
 // forward declaration
 class OverlayController;
 
-
+struct ReviveControllerProfile
-	struct ReviveControllerProfile {
+{
     std::string profileName;
     int gripButtonMode;
     bool triggerAsGrip;
@@ -26,28 +25,48 @@ namespace advsettings {
     float touchZ;
 };
 
-
+class ReviveTabController : public QObject
-	class ReviveTabController : public QObject {
+{
     Q_OBJECT
-		Q_PROPERTY(int isOverlayInstalled READ isOverlayInstalled NOTIFY isOverlayInstalledChanged)
+    Q_PROPERTY( int isOverlayInstalled READ isOverlayInstalled NOTIFY
-		Q_PROPERTY(int gripButtonMode READ gripButtonMode WRITE setGripButtonMode NOTIFY gripButtonModeChanged)
+                    isOverlayInstalledChanged )
-		Q_PROPERTY(int triggerAsGrip READ triggerAsGrip WRITE setTriggerAsGrip NOTIFY triggerAsGripChanged)
+    Q_PROPERTY( int gripButtonMode READ gripButtonMode WRITE setGripButtonMode
-		Q_PROPERTY(bool pixelsPerDisplayPixelOverrideEnabled READ isPixelsPerDisplayPixelOverrideEnabled WRITE setPixelsPerDisplayPixelOverrideEnabled NOTIFY pixelsPerDisplayPixelOverrideEnabledChanged)
+                    NOTIFY gripButtonModeChanged )
-		Q_PROPERTY(float toggleDelay READ toggleDelay WRITE setToggleDelay NOTIFY toggleDelayChanged)
+    Q_PROPERTY( int triggerAsGrip READ triggerAsGrip WRITE setTriggerAsGrip
-		Q_PROPERTY(float pixelsPerDisplayPixelOverride READ pixelsPerDisplayPixelOverride WRITE setPixelsPerDisplayPixelOverride NOTIFY pixelsPerDisplayPixelOverrideChanged)
+                    NOTIFY triggerAsGripChanged )
-		Q_PROPERTY(float thumbDeadzone READ thumbDeadzone WRITE setThumbDeadzone NOTIFY thumbDeadzoneChanged)
+    Q_PROPERTY( bool pixelsPerDisplayPixelOverrideEnabled READ
-		Q_PROPERTY(float thumbRange READ thumbRange WRITE setThumbRange NOTIFY thumbRangeChanged)
+                    isPixelsPerDisplayPixelOverrideEnabled WRITE
-		Q_PROPERTY(float touchPitch READ touchPitch WRITE setTouchPitch NOTIFY touchPitchChanged)
+                        setPixelsPerDisplayPixelOverrideEnabled NOTIFY
-		Q_PROPERTY(float touchYaw READ touchYaw WRITE setTouchYaw NOTIFY touchYawChanged)
+                            pixelsPerDisplayPixelOverrideEnabledChanged )
-		Q_PROPERTY(float touchRoll READ touchRoll WRITE setTouchRoll NOTIFY touchRollChanged)
+    Q_PROPERTY( float toggleDelay READ toggleDelay WRITE setToggleDelay NOTIFY
+                    toggleDelayChanged )
+    Q_PROPERTY(
+        float pixelsPerDisplayPixelOverride READ pixelsPerDisplayPixelOverride
+            WRITE setPixelsPerDisplayPixelOverride NOTIFY
+                pixelsPerDisplayPixelOverrideChanged )
+    Q_PROPERTY( float thumbDeadzone READ thumbDeadzone WRITE setThumbDeadzone
+                    NOTIFY thumbDeadzoneChanged )
+    Q_PROPERTY( float thumbRange READ thumbRange WRITE setThumbRange NOTIFY
+                    thumbRangeChanged )
+    Q_PROPERTY( float touchPitch READ touchPitch WRITE setTouchPitch NOTIFY
+                    touchPitchChanged )
+    Q_PROPERTY(
+        float touchYaw READ touchYaw WRITE setTouchYaw NOTIFY touchYawChanged )
+    Q_PROPERTY( float touchRoll READ touchRoll WRITE setTouchRoll NOTIFY
+                    touchRollChanged )
     Q_PROPERTY( float touchX READ touchX WRITE setTouchX NOTIFY touchXChanged )
     Q_PROPERTY( float touchY READ touchY WRITE setTouchY NOTIFY touchYChanged )
     Q_PROPERTY( float touchZ READ touchZ WRITE setTouchZ NOTIFY touchZChanged )
-		Q_PROPERTY(float piPlayerHeight READ piPlayerHeight WRITE setPiPlayerHeight NOTIFY piPlayerHeightChanged)
+    Q_PROPERTY( float piPlayerHeight READ piPlayerHeight WRITE setPiPlayerHeight
-		Q_PROPERTY(float piEyeHeight READ piEyeHeight WRITE setPiEyeHeight NOTIFY piEyeHeightChanged)
+                    NOTIFY piPlayerHeightChanged )
-		Q_PROPERTY(QString piUsername READ piUsername WRITE setPiUsername NOTIFY piUsernameChanged)
+    Q_PROPERTY( float piEyeHeight READ piEyeHeight WRITE setPiEyeHeight NOTIFY
-		Q_PROPERTY(QString piName READ piName WRITE setPiName NOTIFY piNameChanged)
+                    piEyeHeightChanged )
-		Q_PROPERTY(int piGender READ piGender WRITE setPiGender NOTIFY piGenderChanged)
+    Q_PROPERTY( QString piUsername READ piUsername WRITE setPiUsername NOTIFY
+                    piUsernameChanged )
+    Q_PROPERTY(
+        QString piName READ piName WRITE setPiName NOTIFY piNameChanged )
+    Q_PROPERTY(
+        int piGender READ piGender WRITE setPiGender NOTIFY piGenderChanged )
 
 private:
     OverlayController* parent;
@@ -121,7 +140,8 @@ namespace advsettings {
     void setTriggerAsGrip( bool value, bool notify = true );
     void setToggleDelay( float value, bool notify = true );
 
-		void setPixelsPerDisplayPixelOverrideEnabled(bool value, bool notify = true);
+    void setPixelsPerDisplayPixelOverrideEnabled( bool value,
+                                                  bool notify = true );
     void setPixelsPerDisplayPixelOverride( float value, bool notify = true );
 
     void setThumbDeadzone( float value, bool notify = true );
@@ -138,7 +158,9 @@ namespace advsettings {
     void setPiEyeHeight( float value, bool notify = true );
     void setPiUsername( const QString& value, bool notify = true );
     void setPiName( const QString& value, bool notify = true );
-		void setPiGender(int value, bool notify = true); // 0 .. Unknown, 1 .. Male, 2 .. Female
+    void setPiGender( int value,
+                      bool notify
+                      = true ); // 0 .. Unknown, 1 .. Male, 2 .. Female
 
     void addControllerProfile( QString name );
     void applyControllerProfile( unsigned index );

src/tabcontrollers/SettingsTabController.cpp

@@ -3,69 +3,88 @@
 #include "../overlaycontroller.h"
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
-
+void SettingsTabController::initStage1()
-void SettingsTabController::initStage1() {
+{
-	m_autoStartEnabled = vr::VRApplications()->GetApplicationAutoLaunch(OverlayController::applicationKey);
+    m_autoStartEnabled = vr::VRApplications()->GetApplicationAutoLaunch(
+        OverlayController::applicationKey );
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "applicationSettings" );
     auto value = settings->value( "forceRevivePage", m_forceRevivePage );
     settings->endGroup();
-	if (value.isValid() && !value.isNull()) {
+    if ( value.isValid() && !value.isNull() )
+    {
         m_forceRevivePage = value.toBool();
     }
 }
 
-void SettingsTabController::initStage2(OverlayController * var_parent, QQuickWindow * var_widget) {
+void SettingsTabController::initStage2( OverlayController* var_parent,
+                                        QQuickWindow* var_widget )
+{
     this->parent = var_parent;
     this->widget = var_widget;
 }
 
-void SettingsTabController::eventLoopTick() {
+void SettingsTabController::eventLoopTick()
-	if (settingsUpdateCounter >= 50) {
+{
-		setAutoStartEnabled(vr::VRApplications()->GetApplicationAutoLaunch(OverlayController::applicationKey));
+    if ( settingsUpdateCounter >= 50 )
+    {
+        setAutoStartEnabled( vr::VRApplications()->GetApplicationAutoLaunch(
+            OverlayController::applicationKey ) );
         settingsUpdateCounter = 0;
-	} else {
+    }
+    else
+    {
         settingsUpdateCounter++;
     }
 }
 
-bool SettingsTabController::autoStartEnabled() const {
+bool SettingsTabController::autoStartEnabled() const
+{
     return m_autoStartEnabled;
 }
 
-void SettingsTabController::setAutoStartEnabled(bool value, bool notify) {
+void SettingsTabController::setAutoStartEnabled( bool value, bool notify )
-	if (m_autoStartEnabled != value) {
+{
+    if ( m_autoStartEnabled != value )
+    {
         m_autoStartEnabled = value;
-		auto apperror = vr::VRApplications()->SetApplicationAutoLaunch(OverlayController::applicationKey, m_autoStartEnabled);
+        auto apperror = vr::VRApplications()->SetApplicationAutoLaunch(
-		if (apperror != vr::VRApplicationError_None) {
+            OverlayController::applicationKey, m_autoStartEnabled );
-			LOG(ERROR) << "Could not set auto start: " << vr::VRApplications()->GetApplicationsErrorNameFromEnum(apperror);
+        if ( apperror != vr::VRApplicationError_None )
+        {
+            LOG( ERROR ) << "Could not set auto start: "
+                         << vr::VRApplications()
+                                ->GetApplicationsErrorNameFromEnum( apperror );
         }
-		if (notify) {
+        if ( notify )
+        {
             emit autoStartEnabledChanged( m_autoStartEnabled );
         }
     }
 }
 
-
+bool SettingsTabController::forceRevivePage() const
-bool SettingsTabController::forceRevivePage() const {
+{
     return m_forceRevivePage;
 }
 
-
+void SettingsTabController::setForceRevivePage( bool value, bool notify )
-void SettingsTabController::setForceRevivePage(bool value, bool notify) {
+{
-	if (m_forceRevivePage != value) {
+    if ( m_forceRevivePage != value )
+    {
         m_forceRevivePage = value;
         auto settings = OverlayController::appSettings();
         settings->beginGroup( "applicationSettings" );
         settings->setValue( "forceRevivePage", m_forceRevivePage );
         settings->endGroup();
         settings->sync();
-		if (notify) {
+        if ( notify )
+        {
             emit forceRevivePageChanged( m_forceRevivePage );
         }
     }
 }
 
-} // namespace advconfig
+} // namespace advsettings

src/tabcontrollers/SettingsTabController.h

@@ -5,16 +5,18 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-
+class SettingsTabController : public QObject
-class SettingsTabController : public QObject {
+{
     Q_OBJECT
-	Q_PROPERTY(bool autoStartEnabled READ autoStartEnabled WRITE setAutoStartEnabled NOTIFY autoStartEnabledChanged)
+    Q_PROPERTY( bool autoStartEnabled READ autoStartEnabled WRITE
-	Q_PROPERTY(bool forceRevivePage READ forceRevivePage WRITE setForceRevivePage NOTIFY forceRevivePageChanged)
+                    setAutoStartEnabled NOTIFY autoStartEnabledChanged )
+    Q_PROPERTY( bool forceRevivePage READ forceRevivePage WRITE
+                    setForceRevivePage NOTIFY forceRevivePageChanged )
 
 private:
     OverlayController* parent;

src/tabcontrollers/StatisticsTabController.cpp

@@ -3,20 +3,27 @@
 #include "../overlaycontroller.h"
 
 // application namespace
-namespace advsettings {
+namespace advsettings
+{
+void StatisticsTabController::initStage1() {}
 
-void StatisticsTabController::initStage1() {
+void StatisticsTabController::initStage2( OverlayController* var_parent,
-}
+                                          QQuickWindow* var_widget )
-
+{
-void StatisticsTabController::initStage2(OverlayController * var_parent, QQuickWindow * var_widget) {
     this->parent = var_parent;
     this->widget = var_widget;
 }
 
-void StatisticsTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses, float leftSpeed, float rightSpeed) {
+void StatisticsTabController::eventLoopTick(
+    vr::TrackedDevicePose_t* devicePoses,
+    float leftSpeed,
+    float rightSpeed )
+{
     vr::Compositor_CumulativeStats pStats;
-	vr::VRCompositor()->GetCumulativeStats(&pStats, sizeof(vr::Compositor_CumulativeStats));
+    vr::VRCompositor()->GetCumulativeStats(
-	if (pStats.m_nPid != m_cumStats.m_nPid) {
+        &pStats, sizeof( vr::Compositor_CumulativeStats ) );
+    if ( pStats.m_nPid != m_cumStats.m_nPid )
+    {
         m_cumStats = pStats;
         m_droppedFramesOffset = 0;
         m_reprojectedFramesOffset = 0;
@@ -29,29 +36,44 @@ void StatisticsTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses
     auto& m = devicePoses->mDeviceToAbsoluteTracking.m;
 
     // Hmd Distance //
-	if (lastPosTimer == 0) {
+    if ( lastPosTimer == 0 )
-		if (devicePoses[0].bPoseIsValid && devicePoses[0].eTrackingResult == vr::TrackingResult_Running_OK) {
+    {
-			if (!lastHmdPosValid) {
+        if ( devicePoses[0].bPoseIsValid
+             && devicePoses[0].eTrackingResult
+                    == vr::TrackingResult_Running_OK )
+        {
+            if ( !lastHmdPosValid )
+            {
                 lastHmdPosValid = true;
-			} else {
+            }
-				auto delta = std::sqrt(std::pow(m[0][3] - lastHmdPos[0], 2) /*+ std::pow(m[1][3] - lastHmdPos[1], 2)*/ + std::pow(m[2][3] - lastHmdPos[2], 2));
+            else
-				if (delta >= 0.01f) {
+            {
+                auto delta = std::sqrt(
+                    std::pow( m[0][3] - lastHmdPos[0],
+                              2 ) /*+ std::pow(m[1][3] - lastHmdPos[1], 2)*/
+                    + std::pow( m[2][3] - lastHmdPos[2], 2 ) );
+                if ( delta >= 0.01f )
+                {
                     m_hmdDistanceMoved += delta;
                 }
             }
             lastHmdPos[0] = m[0][3];
             lastHmdPos[1] = m[1][3];
             lastHmdPos[2] = m[2][3];
-		} else {
+        }
+        else
+        {
             lastHmdPosValid = false;
         }
     }
 
     // Controller speeds //
-	if (leftSpeed > m_leftControllerMaxSpeed) {
+    if ( leftSpeed > m_leftControllerMaxSpeed )
+    {
         m_leftControllerMaxSpeed = leftSpeed;
     }
-	if (rightSpeed > m_rightControllerMaxSpeed) {
+    if ( rightSpeed > m_rightControllerMaxSpeed )
+    {
         m_rightControllerMaxSpeed = rightSpeed;
     }
 
@@ -70,165 +92,230 @@ void StatisticsTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses
     double yawRaw = 0.0;
     double yaw = 0.0;
     bool rotationChanged = false;
-	if (devicePoses[0].bPoseIsValid && devicePoses[0].eTrackingResult == vr::TrackingResult_Running_OK) {
+    if ( devicePoses[0].bPoseIsValid
+         && devicePoses[0].eTrackingResult == vr::TrackingResult_Running_OK )
+    {
         yawRaw = std::atan2( m[0][2], m[2][2] );
-		if (yawRaw < 0.0f) {
+        if ( yawRaw < 0.0f )
+        {
             yawRaw += 2 * M_PI; // map to [0, 2*pi], CCW
         }
         yaw = yawRaw - rotationOffset;
-		if (yaw < 0.0) {
+        if ( yaw < 0.0 )
+        {
             yaw = 2 * M_PI + yaw;
         }
-		if (rotationResetFlag) {
+        if ( rotationResetFlag )
+        {
             rotationDir = 0;
             rotationCounter = 0;
             rotationOffset = yawRaw;
             rotationResetFlag = false;
             lastYaw = -1.0f;
             rotationChanged = true;
-		} else if (lastYaw < 0.0f && yaw > 0.0) {
+        }
+        else if ( lastYaw < 0.0f && yaw > 0.0 )
+        {
             lastYaw = yaw;
             rotationChanged = true;
-			if (yaw <= M_PI) {
+            if ( yaw <= M_PI )
+            {
                 rotationDir = 1;
-			} else {
+            }
+            else
+            {
                 rotationDir = -1;
             }
-		} else if (std::abs(lastYaw - yaw) >= 0.01 && yaw > 0.0) {
+        }
+        else if ( std::abs( lastYaw - yaw ) >= 0.01 && yaw > 0.0 )
+        {
             auto diff = yaw - lastYaw;
             int mode = 0;
-			if (std::abs(diff) > M_PI) {
+            if ( std::abs( diff ) > M_PI )
-				if (diff < -M_PI) { // CCW overflow
+            {
+                if ( diff < -M_PI )
+                { // CCW overflow
                     mode = 1;
-				} else if (diff > M_PI) { // CW overflow
-					mode = -1;
                 }
-			} else {
+                else if ( diff > M_PI )
-				if (lastYaw < 0.0 && yaw > 0.0) {
+                { // CW overflow
-					mode = 1;
-				} else if (lastYaw > 0.0 && yaw < 0.0) {
                     mode = -1;
                 }
             }
-			if (mode > 0) {
+            else
-				if (rotationCounter == 0 && rotationDir <= 0) {
+            {
+                if ( lastYaw < 0.0 && yaw > 0.0 )
+                {
+                    mode = 1;
+                }
+                else if ( lastYaw > 0.0 && yaw < 0.0 )
+                {
+                    mode = -1;
+                }
+            }
+            if ( mode > 0 )
+            {
+                if ( rotationCounter == 0 && rotationDir <= 0 )
+                {
                     rotationDir = 1;
-				} else {
+                }
+                else
+                {
                     rotationCounter++;
                 }
-			} else if (mode < 0) {
+            }
-				if (rotationCounter == 0 && rotationDir >= 0) {
+            else if ( mode < 0 )
+            {
+                if ( rotationCounter == 0 && rotationDir >= 0 )
+                {
                     rotationDir = -1;
-				} else {
+                }
+                else
+                {
                     rotationCounter--;
                 }
             }
             lastYaw = yaw;
             rotationChanged = true;
         }
-	} else {
+    }
+    else
+    {
         lastYaw = -1;
     }
 
-	if (rotationChanged) {
+    if ( rotationChanged )
+    {
         m_hmdRotation = ( float ) rotationCounter;
-		if (rotationDir > 0) {
+        if ( rotationDir > 0 )
+        {
             m_hmdRotation += yaw / ( 2 * M_PI );
-		} else if (rotationDir < 0) {
+        }
+        else if ( rotationDir < 0 )
+        {
             m_hmdRotation += -1.0f + yaw / ( 2 * M_PI );
         }
     }
-	if (lastPosTimer == 0) {
+    if ( lastPosTimer == 0 )
+    {
         lastPosTimer = 10;
-	} else {
+    }
+    else
+    {
         lastPosTimer--;
     }
 }
 
-float StatisticsTabController::hmdDistanceMoved() const {
+float StatisticsTabController::hmdDistanceMoved() const
+{
     return m_hmdDistanceMoved;
 }
 
-float StatisticsTabController::hmdRotations() const {
+float StatisticsTabController::hmdRotations() const
+{
     return m_hmdRotation;
 }
 
-float StatisticsTabController::rightControllerMaxSpeed() const {
+float StatisticsTabController::rightControllerMaxSpeed() const
+{
     return m_rightControllerMaxSpeed;
 }
 
-float StatisticsTabController::leftControllerMaxSpeed() const {
+float StatisticsTabController::leftControllerMaxSpeed() const
+{
     return m_leftControllerMaxSpeed;
 }
 
-unsigned StatisticsTabController::presentedFrames() const {
+unsigned StatisticsTabController::presentedFrames() const
+{
     return m_cumStats.m_nNumFramePresents - m_presentedFramesOffset;
 }
 
-unsigned StatisticsTabController::droppedFrames() const {
+unsigned StatisticsTabController::droppedFrames() const
+{
     return m_cumStats.m_nNumDroppedFrames - m_droppedFramesOffset;
 }
 
-unsigned StatisticsTabController::reprojectedFrames() const {
+unsigned StatisticsTabController::reprojectedFrames() const
+{
     return m_cumStats.m_nNumReprojectedFrames - m_reprojectedFramesOffset;
 }
 
-unsigned StatisticsTabController::timedOut() const {
+unsigned StatisticsTabController::timedOut() const
+{
     return m_cumStats.m_nNumTimedOut - m_timedOutOffset;
 }
 
-float StatisticsTabController::totalReprojectedRatio() const {
+float StatisticsTabController::totalReprojectedRatio() const
-	float totalFrames = (float)(m_cumStats.m_nNumFramePresents - m_totalRatioPresentedOffset);
+{
-	float reprojectedFrames = (float)(m_cumStats.m_nNumReprojectedFrames - m_totalRatioReprojectedOffset);
+    float totalFrames = ( float ) ( m_cumStats.m_nNumFramePresents
-	if (totalFrames != 0.0f) {
+                                    - m_totalRatioPresentedOffset );
+    float reprojectedFrames = ( float ) ( m_cumStats.m_nNumReprojectedFrames
+                                          - m_totalRatioReprojectedOffset );
+    if ( totalFrames != 0.0f )
+    {
         return reprojectedFrames / totalFrames;
-	} else {
+    }
+    else
+    {
         return 0.0;
     }
 }
 
-void StatisticsTabController::statsDistanceResetClicked() {
+void StatisticsTabController::statsDistanceResetClicked()
+{
     lastHmdPosValid = false;
-	if (m_hmdDistanceMoved != 0.0) {
+    if ( m_hmdDistanceMoved != 0.0 )
+    {
         m_hmdDistanceMoved = 0.0;
     }
 }
 
-void StatisticsTabController::statsRotationResetClicked() {
+void StatisticsTabController::statsRotationResetClicked()
+{
     rotationResetFlag = true;
 }
 
-void StatisticsTabController::statsLeftControllerSpeedResetClicked() {
+void StatisticsTabController::statsLeftControllerSpeedResetClicked()
-	if (m_leftControllerMaxSpeed != 0.0) {
+{
+    if ( m_leftControllerMaxSpeed != 0.0 )
+    {
         m_leftControllerMaxSpeed = 0.0;
     }
 }
 
-void StatisticsTabController::statsRightControllerSpeedResetClicked() {
+void StatisticsTabController::statsRightControllerSpeedResetClicked()
-	if (m_rightControllerMaxSpeed != 0.0) {
+{
+    if ( m_rightControllerMaxSpeed != 0.0 )
+    {
         m_rightControllerMaxSpeed = 0.0;
     }
 }
 
-void StatisticsTabController::presentedFramesResetClicked() {
+void StatisticsTabController::presentedFramesResetClicked()
+{
     m_presentedFramesOffset = m_cumStats.m_nNumFramePresents;
 }
 
-void StatisticsTabController::droppedFramesResetClicked() {
+void StatisticsTabController::droppedFramesResetClicked()
+{
     m_droppedFramesOffset = m_cumStats.m_nNumDroppedFrames;
 }
 
-void StatisticsTabController::reprojectedFramesResetClicked() {
+void StatisticsTabController::reprojectedFramesResetClicked()
+{
     m_reprojectedFramesOffset = m_cumStats.m_nNumReprojectedFrames;
 }
 
-void StatisticsTabController::timedOutResetClicked() {
+void StatisticsTabController::timedOutResetClicked()
+{
     m_timedOutOffset = m_cumStats.m_nNumTimedOut;
 }
 
-void StatisticsTabController::totalRatioResetClicked() {
+void StatisticsTabController::totalRatioResetClicked()
+{
     m_totalRatioPresentedOffset = m_cumStats.m_nNumFramePresents;
     m_totalRatioReprojectedOffset = m_cumStats.m_nNumReprojectedFrames;
 }
 
-} // namespace advconfig
+} // namespace advsettings

src/tabcontrollers/StatisticsTabController.h

@@ -6,13 +6,13 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-
+class StatisticsTabController : public QObject
-class StatisticsTabController : public QObject {
+{
     Q_OBJECT
     Q_PROPERTY( float hmdDistanceMoved READ hmdDistanceMoved )
     Q_PROPERTY( float hmdRotations READ hmdRotations )
@@ -55,7 +55,9 @@ public:
     void initStage1();
     void initStage2( OverlayController* parent, QQuickWindow* widget );
 
-	void eventLoopTick(vr::TrackedDevicePose_t* devicePoses, float leftSpeed, float rightSpeed);
+    void eventLoopTick( vr::TrackedDevicePose_t* devicePoses,
+                        float leftSpeed,
+                        float rightSpeed );
 
     float hmdDistanceMoved() const;
     float hmdRotations() const;
@@ -80,5 +82,4 @@ public slots:
     void totalRatioResetClicked();
 };
 
-
 } // namespace advsettings

src/tabcontrollers/SteamVRTabController.cpp

@@ -2,346 +2,546 @@
 #include <QQuickWindow>
 #include "../overlaycontroller.h"
 
-namespace vr {
+namespace vr
+{
 // this was removed from openvr_api.h in 1.0.8
-    static const char* const k_pch_SteamVR_RenderTargetMultiplier_Float = "renderTargetMultiplier";
+static const char* const k_pch_SteamVR_RenderTargetMultiplier_Float
-}
+    = "renderTargetMultiplier";
+} // namespace vr
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
-// openvr's github repo hasn't been updated yet to reflect changes in beta 1477423729.
+// openvr's github repo hasn't been updated yet to reflect changes in beta
-//static const char* vrsettings_steamvr_allowAsyncReprojection = "allowAsyncReprojection";
+// 1477423729.
-//static const char* vrsettings_steamvr_allowInterleavedReprojection = "allowInterleavedReprojection";
+// static const char* vrsettings_steamvr_allowAsyncReprojection =
+// "allowAsyncReprojection"; static const char*
+// vrsettings_steamvr_allowInterleavedReprojection =
+// "allowInterleavedReprojection";
 
 static const char* vrsettings_steamvr_supersampleScale = "supersampleScale";
-static const char* vrsettings_steamvr_allowSupersampleFiltering = "allowSupersampleFiltering";
+static const char* vrsettings_steamvr_allowSupersampleFiltering
+    = "allowSupersampleFiltering";
 static const char* vrsettings_compositor_category = "compositor";
 
-void SteamVRTabController::initStage1() {
+void SteamVRTabController::initStage1()
+{
     eventLoopTick();
     reloadSteamVRProfiles();
 }
 
-
+void SteamVRTabController::initStage2( OverlayController* var_parent,
-void SteamVRTabController::initStage2(OverlayController * var_parent, QQuickWindow * var_widget) {
+                                       QQuickWindow* var_widget )
+{
     this->parent = var_parent;
     this->widget = var_widget;
 }
 
-
+void SteamVRTabController::reloadSteamVRProfiles()
-void SteamVRTabController::reloadSteamVRProfiles() {
+{
     steamvrProfiles.clear();
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "steamVRSettings" );
     auto profileCount = settings->beginReadArray( "steamVRProfiles" );
-	for (int i = 0; i < profileCount; i++) {
+    for ( int i = 0; i < profileCount; i++ )
+    {
         settings->setArrayIndex( i );
         steamvrProfiles.emplace_back();
         auto& entry = steamvrProfiles[i];
-		entry.profileName = settings->value("profileName").toString().toStdString();
+        entry.profileName
-		entry.includesSupersampling = settings->value("includesSupersampling", false).toBool();
+            = settings->value( "profileName" ).toString().toStdString();
-		if (entry.includesSupersampling) {
+        entry.includesSupersampling
-			entry.supersampling = settings->value("supersampling", 1.0f).toFloat();
+            = settings->value( "includesSupersampling", false ).toBool();
+        if ( entry.includesSupersampling )
+        {
+            entry.supersampling
+                = settings->value( "supersampling", 1.0f ).toFloat();
         }
-		entry.includesSupersampleFiltering = settings->value("includesSupersampleFiltering", false).toBool();
+        entry.includesSupersampleFiltering
-		if (entry.includesSupersampleFiltering) {
+            = settings->value( "includesSupersampleFiltering", false ).toBool();
-			entry.supersampleFiltering = settings->value("supersampleFiltering", true).toBool();
+        if ( entry.includesSupersampleFiltering )
+        {
+            entry.supersampleFiltering
+                = settings->value( "supersampleFiltering", true ).toBool();
         }
-		entry.includesReprojectionSettings = settings->value("includesReprojectionSettings", false).toBool();
+        entry.includesReprojectionSettings
-		if (entry.includesReprojectionSettings) {
+            = settings->value( "includesReprojectionSettings", false ).toBool();
-			entry.asynchronousReprojection = settings->value("asynchronousReprojection", true).toBool();
+        if ( entry.includesReprojectionSettings )
-			entry.interleavedReprojection = settings->value("interleavedReprojection", true).toBool();
+        {
-			entry.alwaysOnReprojection = settings->value("alwaysOnReprojection", true).toBool();
+            entry.asynchronousReprojection
+                = settings->value( "asynchronousReprojection", true ).toBool();
+            entry.interleavedReprojection
+                = settings->value( "interleavedReprojection", true ).toBool();
+            entry.alwaysOnReprojection
+                = settings->value( "alwaysOnReprojection", true ).toBool();
         }
     }
     settings->endArray();
     settings->endGroup();
 }
 
-
+void SteamVRTabController::saveSteamVRProfiles()
-void SteamVRTabController::saveSteamVRProfiles() {
+{
     auto settings = OverlayController::appSettings();
     settings->beginGroup( "steamVRSettings" );
     settings->beginWriteArray( "steamVRProfiles" );
     unsigned i = 0;
-	for (auto& p : steamvrProfiles) {
+    for ( auto& p : steamvrProfiles )
+    {
         settings->setArrayIndex( i );
-		settings->setValue("profileName", QString::fromStdString(p.profileName));
+        settings->setValue( "profileName",
+                            QString::fromStdString( p.profileName ) );
         settings->setValue( "includesSupersampling", p.includesSupersampling );
-		if (p.includesSupersampling) {
+        if ( p.includesSupersampling )
+        {
             settings->setValue( "supersampling", p.supersampling );
         }
-		settings->setValue("includesSupersampleFiltering", p.includesSupersampleFiltering);
+        settings->setValue( "includesSupersampleFiltering",
-		if (p.includesSupersampleFiltering) {
+                            p.includesSupersampleFiltering );
-			settings->setValue("supersampleFiltering", p.supersampleFiltering);
+        if ( p.includesSupersampleFiltering )
+        {
+            settings->setValue( "supersampleFiltering",
+                                p.supersampleFiltering );
         }
-		settings->setValue("includesReprojectionSettings", p.includesReprojectionSettings);
+        settings->setValue( "includesReprojectionSettings",
-		if (p.includesReprojectionSettings) {
+                            p.includesReprojectionSettings );
-			settings->setValue("asynchronousReprojection", p.asynchronousReprojection);
+        if ( p.includesReprojectionSettings )
-			settings->setValue("interleavedReprojection", p.interleavedReprojection);
+        {
-			settings->setValue("alwaysOnReprojection", p.alwaysOnReprojection);
+            settings->setValue( "asynchronousReprojection",
+                                p.asynchronousReprojection );
+            settings->setValue( "interleavedReprojection",
+                                p.interleavedReprojection );
+            settings->setValue( "alwaysOnReprojection",
+                                p.alwaysOnReprojection );
         }
         i++;
     }
     settings->endArray();
     settings->endGroup();
-
 }
 
-
+Q_INVOKABLE unsigned SteamVRTabController::getSteamVRProfileCount()
-Q_INVOKABLE unsigned SteamVRTabController::getSteamVRProfileCount() {
+{
     return ( unsigned ) steamvrProfiles.size();
 }
 
-Q_INVOKABLE QString SteamVRTabController::getSteamVRProfileName(unsigned index) {
+Q_INVOKABLE QString
-	if (index >= steamvrProfiles.size()) {
+    SteamVRTabController::getSteamVRProfileName( unsigned index )
+{
+    if ( index >= steamvrProfiles.size() )
+    {
         return QString();
-	} else {
+    }
+    else
+    {
         return QString::fromStdString( steamvrProfiles[index].profileName );
     }
 }
 
-
+void SteamVRTabController::eventLoopTick()
-void SteamVRTabController::eventLoopTick() {
+{
-	if (settingsUpdateCounter >= 50) {
+    if ( settingsUpdateCounter >= 50 )
+    {
         vr::EVRSettingsError vrSettingsError;
-		auto ss = vr::VRSettings()->GetFloat(vr::k_pch_SteamVR_Section, vrsettings_steamvr_supersampleScale, &vrSettingsError);
+        auto ss
-		if (vrSettingsError != vr::VRSettingsError_None) {
+            = vr::VRSettings()->GetFloat( vr::k_pch_SteamVR_Section,
-			LOG(WARNING) << "Could not read \"" << vrsettings_steamvr_supersampleScale << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+                                          vrsettings_steamvr_supersampleScale,
-			if (m_superSampling != 1.0) {
+                                          &vrSettingsError );
-				LOG(DEBUG) << "OpenVR returns an error and we have a custom supersampling value: " << m_superSampling;
+        if ( vrSettingsError != vr::VRSettingsError_None )
+        {
+            LOG( WARNING ) << "Could not read \""
+                           << vrsettings_steamvr_supersampleScale
+                           << "\" setting: "
+                           << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                                  vrSettingsError );
+            if ( m_superSampling != 1.0 )
+            {
+                LOG( DEBUG ) << "OpenVR returns an error and we have a custom "
+                                "supersampling value: "
+                             << m_superSampling;
                 setSuperSampling( 1.0 );
             }
-		} else if (m_superSampling != ss) {
+        }
-			LOG(DEBUG) << "OpenVR reports a changed supersampling value: " << m_superSampling << " => " << ss;
+        else if ( m_superSampling != ss )
+        {
+            LOG( DEBUG ) << "OpenVR reports a changed supersampling value: "
+                         << m_superSampling << " => " << ss;
             setSuperSampling( ss );
         }
-		auto css = vr::VRSettings()->GetFloat(vrsettings_compositor_category, vr::k_pch_SteamVR_RenderTargetMultiplier_Float, &vrSettingsError);
+        auto css = vr::VRSettings()->GetFloat(
-		if (vrSettingsError != vr::VRSettingsError_None) {
+            vrsettings_compositor_category,
-			if (vrSettingsError != vr::VRSettingsError_UnsetSettingHasNoDefault) { // does not appear in the default settings file as of beta 1477423729
+            vr::k_pch_SteamVR_RenderTargetMultiplier_Float,
-				LOG(WARNING) << "Could not read \"compositor::" << vr::k_pch_SteamVR_RenderTargetMultiplier_Float << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+            &vrSettingsError );
+        if ( vrSettingsError != vr::VRSettingsError_None )
+        {
+            if ( vrSettingsError
+                 != vr::VRSettingsError_UnsetSettingHasNoDefault )
+            { // does not appear in the default settings file as of beta
+              // 1477423729
+                LOG( WARNING )
+                    << "Could not read \"compositor::"
+                    << vr::k_pch_SteamVR_RenderTargetMultiplier_Float
+                    << "\" setting: "
+                    << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                           vrSettingsError );
             }
-			if (m_compositorSuperSampling != 1.0) {
+            if ( m_compositorSuperSampling != 1.0 )
-				LOG(DEBUG) << "OpenVR returns an error and we have a custom compositor supersampling value: " << m_compositorSuperSampling;
+            {
+                LOG( DEBUG ) << "OpenVR returns an error and we have a custom "
+                                "compositor supersampling value: "
+                             << m_compositorSuperSampling;
                 setCompositorSuperSampling( 1.0 );
             }
-		} else if (m_compositorSuperSampling != css) {
+        }
-			LOG(DEBUG) << "OpenVR reports a changed compositor supersampling value: " << m_compositorSuperSampling << " => " << css;
+        else if ( m_compositorSuperSampling != css )
+        {
+            LOG( DEBUG )
+                << "OpenVR reports a changed compositor supersampling value: "
+                << m_compositorSuperSampling << " => " << css;
             setCompositorSuperSampling( css );
         }
-		auto air = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowReprojection_Bool, &vrSettingsError);
+        auto air = vr::VRSettings()->GetBool(
-		if (vrSettingsError != vr::VRSettingsError_None) {
+            vr::k_pch_SteamVR_Section,
-			LOG(WARNING) << "Could not read \"" << vr::k_pch_SteamVR_AllowReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+            vr::k_pch_SteamVR_AllowReprojection_Bool,
+            &vrSettingsError );
+        if ( vrSettingsError != vr::VRSettingsError_None )
+        {
+            LOG( WARNING ) << "Could not read \""
+                           << vr::k_pch_SteamVR_AllowReprojection_Bool
+                           << "\" setting: "
+                           << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                                  vrSettingsError );
         }
         setAllowInterleavedReprojection( air );
-		auto aar = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowAsyncReprojection_Bool, &vrSettingsError);
+        auto aar = vr::VRSettings()->GetBool(
-		if (vrSettingsError != vr::VRSettingsError_None) {
+            vr::k_pch_SteamVR_Section,
-			LOG(WARNING) << "Could not read \"" << vr::k_pch_SteamVR_AllowAsyncReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+            vr::k_pch_SteamVR_AllowAsyncReprojection_Bool,
+            &vrSettingsError );
+        if ( vrSettingsError != vr::VRSettingsError_None )
+        {
+            LOG( WARNING ) << "Could not read \""
+                           << vr::k_pch_SteamVR_AllowAsyncReprojection_Bool
+                           << "\" setting: "
+                           << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                                  vrSettingsError );
         }
         setAllowAsyncReprojection( aar );
-		auto fr = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_ForceReprojection_Bool, &vrSettingsError);
+        auto fr = vr::VRSettings()->GetBool(
-		if (vrSettingsError != vr::VRSettingsError_None) {
+            vr::k_pch_SteamVR_Section,
-			LOG(WARNING) << "Could not read \"" << vr::k_pch_SteamVR_ForceReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+            vr::k_pch_SteamVR_ForceReprojection_Bool,
+            &vrSettingsError );
+        if ( vrSettingsError != vr::VRSettingsError_None )
+        {
+            LOG( WARNING ) << "Could not read \""
+                           << vr::k_pch_SteamVR_ForceReprojection_Bool
+                           << "\" setting: "
+                           << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                                  vrSettingsError );
         }
         setForceReprojection( fr );
-		auto sf = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowSupersampleFiltering, &vrSettingsError);
+        auto sf = vr::VRSettings()->GetBool(
-		if (vrSettingsError != vr::VRSettingsError_None) {
+            vr::k_pch_SteamVR_Section,
-			LOG(WARNING) << "Could not read \"" << vrsettings_steamvr_allowSupersampleFiltering << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+            vrsettings_steamvr_allowSupersampleFiltering,
+            &vrSettingsError );
+        if ( vrSettingsError != vr::VRSettingsError_None )
+        {
+            LOG( WARNING ) << "Could not read \""
+                           << vrsettings_steamvr_allowSupersampleFiltering
+                           << "\" setting: "
+                           << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                                  vrSettingsError );
         }
         setAllowSupersampleFiltering( sf );
         settingsUpdateCounter = 0;
-	} else {
+    }
+    else
+    {
         settingsUpdateCounter++;
     }
 }
 
-
+void SteamVRTabController::setSuperSampling( float value, bool notify )
-void SteamVRTabController::setSuperSampling(float value, bool notify) {
+{
     bool override = false;
-	if (value <= 0.01f) {
+    if ( value <= 0.01f )
-		LOG(WARNING) << "Encountered a supersampling value <= 0.01, setting supersampling to 1.0";
+    {
+        LOG( WARNING ) << "Encountered a supersampling value <= 0.01, setting "
+                          "supersampling to 1.0";
         value = 1.0f;
         override = true;
     }
-	if (override || m_superSampling != value) {
+    if ( override || m_superSampling != value )
-		LOG(DEBUG) << "Supersampling value changed: " << m_superSampling << " => " << value;
+    {
+        LOG( DEBUG ) << "Supersampling value changed: " << m_superSampling
+                     << " => " << value;
         m_superSampling = value;
-		vr::VRSettings()->SetFloat(vr::k_pch_SteamVR_Section, vrsettings_steamvr_supersampleScale, m_superSampling);
+        vr::VRSettings()->SetFloat( vr::k_pch_SteamVR_Section,
+                                    vrsettings_steamvr_supersampleScale,
+                                    m_superSampling );
         vr::VRSettings()->Sync();
-		if (notify) {
+        if ( notify )
+        {
             emit superSamplingChanged( m_superSampling );
         }
     }
 }
 
-
+void SteamVRTabController::setCompositorSuperSampling( float value,
-void SteamVRTabController::setCompositorSuperSampling(float value, bool notify) {
+                                                       bool notify )
+{
     bool override = false;
-	if (value <= 0.01f) {
+    if ( value <= 0.01f )
-		LOG(WARNING) << "Encountered a compositor supersampling value <= 0.01, setting supersampling to 1.0";
+    {
+        LOG( WARNING ) << "Encountered a compositor supersampling value <= "
+                          "0.01, setting supersampling to 1.0";
         value = 1.0f;
         override = true;
     }
-	if (override || m_compositorSuperSampling != value) {
+    if ( override || m_compositorSuperSampling != value )
-		LOG(DEBUG) << "Compositor supersampling value changed: " << m_compositorSuperSampling << " => " << value;
+    {
+        LOG( DEBUG ) << "Compositor supersampling value changed: "
+                     << m_compositorSuperSampling << " => " << value;
         m_compositorSuperSampling = value;
-		vr::VRSettings()->SetFloat(vrsettings_compositor_category, vr::k_pch_SteamVR_RenderTargetMultiplier_Float, m_compositorSuperSampling);
+        vr::VRSettings()->SetFloat(
+            vrsettings_compositor_category,
+            vr::k_pch_SteamVR_RenderTargetMultiplier_Float,
+            m_compositorSuperSampling );
         vr::VRSettings()->Sync();
-		if (notify) {
+        if ( notify )
+        {
             emit compositorSuperSamplingChanged( m_compositorSuperSampling );
         }
     }
 }
 
-
+float SteamVRTabController::superSampling() const
-float SteamVRTabController::superSampling() const {
+{
     return m_superSampling;
 }
 
-
+float SteamVRTabController::compositorSuperSampling() const
-float SteamVRTabController::compositorSuperSampling() const {
+{
     return m_compositorSuperSampling;
 }
 
-
+bool SteamVRTabController::allowInterleavedReprojection() const
-bool SteamVRTabController::allowInterleavedReprojection() const {
+{
     return m_allowInterleavedReprojection;
 }
 
-
+bool SteamVRTabController::allowAsyncReprojection() const
-bool SteamVRTabController::allowAsyncReprojection() const {
+{
     return m_allowAsyncReprojection;
 }
 
-
+void SteamVRTabController::setAllowInterleavedReprojection( bool value,
-void SteamVRTabController::setAllowInterleavedReprojection(bool value, bool notify) {
+                                                            bool notify )
-	if (m_allowInterleavedReprojection != value) {
+{
+    if ( m_allowInterleavedReprojection != value )
+    {
         m_allowInterleavedReprojection = value;
-		vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowReprojection_Bool, m_allowInterleavedReprojection);
+        vr::VRSettings()->SetBool( vr::k_pch_SteamVR_Section,
+                                   vr::k_pch_SteamVR_AllowReprojection_Bool,
+                                   m_allowInterleavedReprojection );
         vr::VRSettings()->Sync();
-		if (notify) {
+        if ( notify )
-			emit allowInterleavedReprojectionChanged(m_allowInterleavedReprojection);
+        {
+            emit allowInterleavedReprojectionChanged(
+                m_allowInterleavedReprojection );
         }
     }
 }
 
-
+void SteamVRTabController::setAllowAsyncReprojection( bool value, bool notify )
-void SteamVRTabController::setAllowAsyncReprojection(bool value, bool notify) {
+{
-	if (m_allowAsyncReprojection != value) {
+    if ( m_allowAsyncReprojection != value )
+    {
         m_allowAsyncReprojection = value;
-		vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowAsyncReprojection_Bool, m_allowAsyncReprojection);
+        vr::VRSettings()->SetBool(
+            vr::k_pch_SteamVR_Section,
+            vr::k_pch_SteamVR_AllowAsyncReprojection_Bool,
+            m_allowAsyncReprojection );
         vr::VRSettings()->Sync();
-		if (notify) {
+        if ( notify )
+        {
             emit allowAsyncReprojectionChanged( m_allowAsyncReprojection );
         }
     }
 }
 
-bool SteamVRTabController::forceReprojection() const {
+bool SteamVRTabController::forceReprojection() const
+{
     return m_forceReprojection;
 }
 
-
+void SteamVRTabController::setForceReprojection( bool value, bool notify )
-void SteamVRTabController::setForceReprojection(bool value, bool notify) {
+{
-	if (m_forceReprojection != value) {
+    if ( m_forceReprojection != value )
+    {
         m_forceReprojection = value;
-		vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_ForceReprojection_Bool, m_forceReprojection);
+        vr::VRSettings()->SetBool( vr::k_pch_SteamVR_Section,
+                                   vr::k_pch_SteamVR_ForceReprojection_Bool,
+                                   m_forceReprojection );
         vr::VRSettings()->Sync();
-		if (notify) {
+        if ( notify )
+        {
             emit forceReprojectionChanged( m_forceReprojection );
         }
     }
 }
 
-
+bool SteamVRTabController::allowSupersampleFiltering() const
-bool SteamVRTabController::allowSupersampleFiltering() const {
+{
     return m_allowSupersampleFiltering;
 }
 
-
+void SteamVRTabController::setAllowSupersampleFiltering( bool value,
-void SteamVRTabController::setAllowSupersampleFiltering(bool value, bool notify) {
+                                                         bool notify )
-	if (m_allowSupersampleFiltering != value) {
+{
+    if ( m_allowSupersampleFiltering != value )
+    {
         m_allowSupersampleFiltering = value;
-		vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowSupersampleFiltering, m_allowSupersampleFiltering);
+        vr::VRSettings()->SetBool( vr::k_pch_SteamVR_Section,
+                                   vrsettings_steamvr_allowSupersampleFiltering,
+                                   m_allowSupersampleFiltering );
         vr::VRSettings()->Sync();
-		if (notify) {
+        if ( notify )
-			emit allowSupersampleFilteringChanged(m_allowSupersampleFiltering);
+        {
+            emit allowSupersampleFilteringChanged(
+                m_allowSupersampleFiltering );
         }
     }
 }
 
-
+void SteamVRTabController::reset()
-void SteamVRTabController::reset() {
+{
     vr::EVRSettingsError vrSettingsError;
 
-	vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vrsettings_steamvr_supersampleScale, &vrSettingsError);
+    vr::VRSettings()->RemoveKeyInSection( vr::k_pch_SteamVR_Section,
-	if (vrSettingsError != vr::VRSettingsError_None) {
+                                          vrsettings_steamvr_supersampleScale,
-		LOG(WARNING) << "Could not remove \"" << vrsettings_steamvr_supersampleScale << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+                                          &vrSettingsError );
+    if ( vrSettingsError != vr::VRSettingsError_None )
+    {
+        LOG( WARNING ) << "Could not remove \""
+                       << vrsettings_steamvr_supersampleScale << "\" setting: "
+                       << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                              vrSettingsError );
     }
 
     setCompositorSuperSampling( 1.0f ); // Is not in default.vrsettings yet
-	vr::VRSettings()->RemoveKeyInSection(vrsettings_compositor_category, vr::k_pch_SteamVR_RenderTargetMultiplier_Float, &vrSettingsError);
+    vr::VRSettings()->RemoveKeyInSection(
-	if (vrSettingsError != vr::VRSettingsError_None) {
+        vrsettings_compositor_category,
-		LOG(WARNING) << "Could not remove \"" << vrsettings_compositor_category << "::" << vr::k_pch_SteamVR_RenderTargetMultiplier_Float << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+        vr::k_pch_SteamVR_RenderTargetMultiplier_Float,
+        &vrSettingsError );
+    if ( vrSettingsError != vr::VRSettingsError_None )
+    {
+        LOG( WARNING ) << "Could not remove \""
+                       << vrsettings_compositor_category
+                       << "::" << vr::k_pch_SteamVR_RenderTargetMultiplier_Float
+                       << "\" setting: "
+                       << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                              vrSettingsError );
     }
 
-	vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowReprojection_Bool, &vrSettingsError);
+    vr::VRSettings()->RemoveKeyInSection(
-	if (vrSettingsError != vr::VRSettingsError_None) {
+        vr::k_pch_SteamVR_Section,
-		LOG(WARNING) << "Could not remove \"" << vr::k_pch_SteamVR_AllowReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+        vr::k_pch_SteamVR_AllowReprojection_Bool,
+        &vrSettingsError );
+    if ( vrSettingsError != vr::VRSettingsError_None )
+    {
+        LOG( WARNING ) << "Could not remove \""
+                       << vr::k_pch_SteamVR_AllowReprojection_Bool
+                       << "\" setting: "
+                       << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                              vrSettingsError );
     }
 
-	vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowAsyncReprojection_Bool, &vrSettingsError);
+    vr::VRSettings()->RemoveKeyInSection(
-	if (vrSettingsError != vr::VRSettingsError_None) {
+        vr::k_pch_SteamVR_Section,
-		LOG(WARNING) << "Could not remove \"" << vr::k_pch_SteamVR_AllowAsyncReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+        vr::k_pch_SteamVR_AllowAsyncReprojection_Bool,
+        &vrSettingsError );
+    if ( vrSettingsError != vr::VRSettingsError_None )
+    {
+        LOG( WARNING ) << "Could not remove \""
+                       << vr::k_pch_SteamVR_AllowAsyncReprojection_Bool
+                       << "\" setting: "
+                       << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                              vrSettingsError );
     }
 
-	vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_ForceReprojection_Bool, &vrSettingsError);
+    vr::VRSettings()->RemoveKeyInSection(
-	if (vrSettingsError != vr::VRSettingsError_None) {
+        vr::k_pch_SteamVR_Section,
-		LOG(WARNING) << "Could not remove \"" << vr::k_pch_SteamVR_ForceReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+        vr::k_pch_SteamVR_ForceReprojection_Bool,
+        &vrSettingsError );
+    if ( vrSettingsError != vr::VRSettingsError_None )
+    {
+        LOG( WARNING ) << "Could not remove \""
+                       << vr::k_pch_SteamVR_ForceReprojection_Bool
+                       << "\" setting: "
+                       << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                              vrSettingsError );
     }
 
-	vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowSupersampleFiltering, &vrSettingsError);
+    vr::VRSettings()->RemoveKeyInSection(
-	if (vrSettingsError != vr::VRSettingsError_None) {
+        vr::k_pch_SteamVR_Section,
-		LOG(WARNING) << "Could not remove \"" << vrsettings_steamvr_allowSupersampleFiltering << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+        vrsettings_steamvr_allowSupersampleFiltering,
+        &vrSettingsError );
+    if ( vrSettingsError != vr::VRSettingsError_None )
+    {
+        LOG( WARNING ) << "Could not remove \""
+                       << vrsettings_steamvr_allowSupersampleFiltering
+                       << "\" setting: "
+                       << vr::VRSettings()->GetSettingsErrorNameFromEnum(
+                              vrSettingsError );
     }
 
     vr::VRSettings()->Sync();
     settingsUpdateCounter = 999; // Easiest way to get default values
 }
 
-
+void SteamVRTabController::restartSteamVR()
-void SteamVRTabController::restartSteamVR() {
+{
-	QString cmd = QString("cmd.exe /C restartvrserver.bat \"") + parent->getVRRuntimePathUrl().toLocalFile() + QString("\"");
+    QString cmd = QString( "cmd.exe /C restartvrserver.bat \"" )
+                  + parent->getVRRuntimePathUrl().toLocalFile()
+                  + QString( "\"" );
     LOG( INFO ) << "SteamVR Restart Command: " << cmd;
     QProcess::startDetached( cmd );
 }
 
-
+void SteamVRTabController::addSteamVRProfile( QString name,
-void SteamVRTabController::addSteamVRProfile(QString name, bool includeSupersampling, bool includeSupersampleFiltering, bool includeReprojectionSettings) {
+                                              bool includeSupersampling,
+                                              bool includeSupersampleFiltering,
+                                              bool includeReprojectionSettings )
+{
     SteamVRProfile* profile = nullptr;
-	for (auto& p : steamvrProfiles) {
+    for ( auto& p : steamvrProfiles )
-		if (p.profileName.compare(name.toStdString()) == 0) {
+    {
+        if ( p.profileName.compare( name.toStdString() ) == 0 )
+        {
             profile = &p;
             break;
         }
     }
-	if (!profile) {
+    if ( !profile )
+    {
         auto i = steamvrProfiles.size();
         steamvrProfiles.emplace_back();
         profile = &steamvrProfiles[i];
     }
     profile->profileName = name.toStdString();
     profile->includesSupersampling = includeSupersampling;
-	if (includeSupersampling) {
+    if ( includeSupersampling )
+    {
         profile->supersampling = m_superSampling;
     }
     profile->includesSupersampleFiltering = includeSupersampleFiltering;
-	if (includeSupersampleFiltering) {
+    if ( includeSupersampleFiltering )
+    {
         profile->supersampleFiltering = m_allowSupersampleFiltering;
     }
     profile->includesReprojectionSettings = includeReprojectionSettings;
-	if (includeReprojectionSettings) {
+    if ( includeReprojectionSettings )
+    {
         profile->asynchronousReprojection = m_allowAsyncReprojection;
         profile->interleavedReprojection = m_allowInterleavedReprojection;
         profile->alwaysOnReprojection = m_forceReprojection;
@@ -351,17 +551,21 @@ void SteamVRTabController::addSteamVRProfile(QString name, bool includeSupersamp
     emit steamVRProfilesUpdated();
 }
 
-
+void SteamVRTabController::applySteamVRProfile( unsigned index )
-void SteamVRTabController::applySteamVRProfile(unsigned index) {
+{
-	if (index < steamvrProfiles.size()) {
+    if ( index < steamvrProfiles.size() )
+    {
         auto& profile = steamvrProfiles[index];
-		if (profile.includesSupersampling) {
+        if ( profile.includesSupersampling )
+        {
             setSuperSampling( profile.supersampling );
         }
-		if (profile.includesSupersampleFiltering) {
+        if ( profile.includesSupersampleFiltering )
+        {
             setAllowSupersampleFiltering( profile.supersampleFiltering );
         }
-		if (profile.includesReprojectionSettings) {
+        if ( profile.includesReprojectionSettings )
+        {
             setAllowAsyncReprojection( profile.asynchronousReprojection );
             setAllowInterleavedReprojection( profile.interleavedReprojection );
             setForceReprojection( profile.alwaysOnReprojection );
@@ -370,9 +574,10 @@ void SteamVRTabController::applySteamVRProfile(unsigned index) {
     }
 }
 
-
+void SteamVRTabController::deleteSteamVRProfile( unsigned index )
-void SteamVRTabController::deleteSteamVRProfile(unsigned index) {
+{
-	if (index < steamvrProfiles.size()) {
+    if ( index < steamvrProfiles.size() )
+    {
         auto pos = steamvrProfiles.begin() + index;
         steamvrProfiles.erase( pos );
         saveSteamVRProfiles();
@@ -381,7 +586,4 @@ void SteamVRTabController::deleteSteamVRProfile(unsigned index) {
     }
 }
 
-
+} // namespace advsettings
-
-} // namespace advconfig
-

src/tabcontrollers/SteamVRTabController.h

@@ -3,17 +3,15 @@
 
 #include <QObject>
 
-
-
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-
+struct SteamVRProfile
-struct SteamVRProfile {
+{
     std::string profileName;
 
     bool includesSupersampling = false;
@@ -28,15 +26,26 @@ struct SteamVRProfile {
     bool alwaysOnReprojection = true;
 };
 
-
+class SteamVRTabController : public QObject
-class SteamVRTabController : public QObject {
+{
     Q_OBJECT
-	Q_PROPERTY(float superSampling READ superSampling WRITE setSuperSampling NOTIFY superSamplingChanged)
+    Q_PROPERTY( float superSampling READ superSampling WRITE setSuperSampling
-	Q_PROPERTY(float compositorSuperSampling READ compositorSuperSampling WRITE setCompositorSuperSampling NOTIFY compositorSuperSamplingChanged)
+                    NOTIFY superSamplingChanged )
-	Q_PROPERTY(bool allowInterleavedReprojection READ allowInterleavedReprojection WRITE setAllowInterleavedReprojection NOTIFY allowInterleavedReprojectionChanged)
+    Q_PROPERTY(
-	Q_PROPERTY(bool allowAsyncReprojection READ allowAsyncReprojection WRITE setAllowAsyncReprojection NOTIFY allowAsyncReprojectionChanged)
+        float compositorSuperSampling READ compositorSuperSampling WRITE
-	Q_PROPERTY(bool forceReprojection READ forceReprojection WRITE setForceReprojection NOTIFY forceReprojectionChanged)
+            setCompositorSuperSampling NOTIFY compositorSuperSamplingChanged )
-	Q_PROPERTY(bool allowSupersampleFiltering READ allowSupersampleFiltering WRITE setAllowSupersampleFiltering NOTIFY allowSupersampleFilteringChanged)
+    Q_PROPERTY(
+        bool allowInterleavedReprojection READ allowInterleavedReprojection
+            WRITE setAllowInterleavedReprojection NOTIFY
+                allowInterleavedReprojectionChanged )
+    Q_PROPERTY(
+        bool allowAsyncReprojection READ allowAsyncReprojection WRITE
+            setAllowAsyncReprojection NOTIFY allowAsyncReprojectionChanged )
+    Q_PROPERTY( bool forceReprojection READ forceReprojection WRITE
+                    setForceReprojection NOTIFY forceReprojectionChanged )
+    Q_PROPERTY( bool allowSupersampleFiltering READ allowSupersampleFiltering
+                    WRITE setAllowSupersampleFiltering NOTIFY
+                        allowSupersampleFilteringChanged )
 
 private:
     OverlayController* parent;
@@ -80,7 +89,10 @@ public slots:
     void setForceReprojection( bool value, bool notify = true );
     void setAllowSupersampleFiltering( bool value, bool notify = true );
 
-	void addSteamVRProfile(QString name, bool includeSupersampling, bool includeSupersampleFiltering, bool includeReprojectionSettings);
+    void addSteamVRProfile( QString name,
+                            bool includeSupersampling,
+                            bool includeSupersampleFiltering,
+                            bool includeReprojectionSettings );
     void applySteamVRProfile( unsigned index );
     void deleteSteamVRProfile( unsigned index );
 

src/tabcontrollers/UtilitiesTabController.cpp

@@ -10,11 +10,12 @@
 #endif
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 const char* steamDesktopOverlaykey = "valve.steam.desktop";
 
-	void UtilitiesTabController::initStage1() {
+void UtilitiesTabController::initStage1()
+{
 #ifdef _WIN32
     keyboardInput.reset( new KeyboardInputWindows() );
 #else
@@ -31,63 +32,86 @@ namespace advsettings {
     m_alarmIsModal = qAlarmIsModal.toBool();
     m_alarmTime = QTime( qAlarmHour.toInt(), qAlarmMinute.toInt() );
     vr::VROverlayHandle_t pOverlayHandle;
-		auto error = vr::VROverlay()->FindOverlay(steamDesktopOverlaykey, &pOverlayHandle);
+    auto error = vr::VROverlay()->FindOverlay( steamDesktopOverlaykey,
-		if (error != vr::VROverlayError_None) {
+                                               &pOverlayHandle );
+    if ( error != vr::VROverlayError_None )
+    {
         m_steamDesktopOverlayAvailable = false;
-			LOG(INFO) << "Could not find overlay \"" << steamDesktopOverlaykey << "\": " << vr::VROverlay()->GetOverlayErrorNameFromEnum(error);
+        LOG( INFO ) << "Could not find overlay \"" << steamDesktopOverlaykey
-		} else {
+                    << "\": "
+                    << vr::VROverlay()->GetOverlayErrorNameFromEnum( error );
+    }
+    else
+    {
         m_steamDesktopOverlayAvailable = true;
         float width;
-			error = vr::VROverlay()->GetOverlayWidthInMeters(pOverlayHandle, &width);
+        error = vr::VROverlay()->GetOverlayWidthInMeters( pOverlayHandle,
-			if (error != vr::VROverlayError_None) {
+                                                          &width );
-				LOG(ERROR) << "Could not read overlay width of \"" << steamDesktopOverlaykey << "\": " << vr::VROverlay()->GetOverlayErrorNameFromEnum(error);
+        if ( error != vr::VROverlayError_None )
-			} else {
+        {
+            LOG( ERROR ) << "Could not read overlay width of \""
+                         << steamDesktopOverlaykey << "\": "
+                         << vr::VROverlay()->GetOverlayErrorNameFromEnum(
+                                error );
+        }
+        else
+        {
             m_steamDesktopOverlayWidth = width;
         }
     }
-
 }
 
-        void UtilitiesTabController::initStage2(OverlayController * var_parent, QQuickWindow * var_widget) {
+void UtilitiesTabController::initStage2( OverlayController* var_parent,
+                                         QQuickWindow* var_widget )
+{
     this->parent = var_parent;
     this->widget = var_widget;
 }
 
-	void UtilitiesTabController::sendKeyboardInput(QString input) {
+void UtilitiesTabController::sendKeyboardInput( QString input )
+{
     keyboardInput->sendKeyboardInput( input );
 }
 
-	void UtilitiesTabController::sendKeyboardEnter() {
+void UtilitiesTabController::sendKeyboardEnter()
+{
     keyboardInput->sendKeyboardEnter();
 }
 
-    void UtilitiesTabController::sendKeyboardAltTab() {
+void UtilitiesTabController::sendKeyboardAltTab()
+{
     keyboardInput->sendKeyboardAltTab();
 }
 
-	void UtilitiesTabController::sendKeyboardBackspace(int count) {
+void UtilitiesTabController::sendKeyboardBackspace( int count )
+{
     keyboardInput->sendKeyboardBackspace( count );
 }
 
-
+bool UtilitiesTabController::alarmEnabled() const
-	bool UtilitiesTabController::alarmEnabled() const {
+{
     return m_alarmEnabled;
 }
 
-	bool UtilitiesTabController::alarmIsModal() const {
+bool UtilitiesTabController::alarmIsModal() const
+{
     return m_alarmIsModal;
 }
 
-	int UtilitiesTabController::alarmTimeHour() const {
+int UtilitiesTabController::alarmTimeHour() const
+{
     return m_alarmTime.hour();
 }
 
-	int UtilitiesTabController::alarmTimeMinute() const {
+int UtilitiesTabController::alarmTimeMinute() const
+{
     return m_alarmTime.minute();
 }
 
-	void UtilitiesTabController::setAlarmEnabled(bool enabled, bool notify) {
+void UtilitiesTabController::setAlarmEnabled( bool enabled, bool notify )
-		if (m_alarmEnabled != enabled) {
+{
+    if ( m_alarmEnabled != enabled )
+    {
         m_alarmEnabled = enabled;
         auto settings = OverlayController::appSettings();
         settings->beginGroup( "utilitiesSettings" );
@@ -95,31 +119,40 @@ namespace advsettings {
         settings->endGroup();
         settings->sync();
         m_alarmLastCheckTime = QTime();
-			if (notify) {
+        if ( notify )
+        {
             emit alarmEnabledChanged( m_alarmEnabled );
         }
     }
 }
 
-	void UtilitiesTabController::setAlarmIsModal(bool modal, bool notify) {
+void UtilitiesTabController::setAlarmIsModal( bool modal, bool notify )
-		if (m_alarmIsModal != modal) {
+{
+    if ( m_alarmIsModal != modal )
+    {
         m_alarmIsModal = modal;
         auto settings = OverlayController::appSettings();
         settings->beginGroup( "utilitiesSettings" );
         settings->setValue( "alarmIsModal", m_alarmIsModal );
         settings->endGroup();
         settings->sync();
-			if (notify) {
+        if ( notify )
+        {
             emit alarmIsModalChanged( m_alarmIsModal );
         }
     }
 }
 
-	void UtilitiesTabController::setAlarmTimeHour(int hour, bool notify) {
+void UtilitiesTabController::setAlarmTimeHour( int hour, bool notify )
-		if (m_alarmTime.hour() != hour) {
+{
-			if (m_alarmTime.isValid()) {
+    if ( m_alarmTime.hour() != hour )
+    {
+        if ( m_alarmTime.isValid() )
+        {
             m_alarmTime = QTime( hour, m_alarmTime.minute() );
-			} else {
+        }
+        else
+        {
             m_alarmTime = QTime( hour, 0 );
         }
         auto settings = OverlayController::appSettings();
@@ -129,17 +162,23 @@ namespace advsettings {
         settings->endGroup();
         settings->sync();
         m_alarmLastCheckTime = QTime();
-			if (notify) {
+        if ( notify )
+        {
             emit alarmTimeHourChanged( hour );
         }
     }
 }
 
-	void UtilitiesTabController::setAlarmTimeMinute(int min, bool notify) {
+void UtilitiesTabController::setAlarmTimeMinute( int min, bool notify )
-		if (m_alarmTime.minute() != min) {
+{
-			if (m_alarmTime.isValid()) {
+    if ( m_alarmTime.minute() != min )
+    {
+        if ( m_alarmTime.isValid() )
+        {
             m_alarmTime = QTime( m_alarmTime.hour(), min );
-			} else {
+        }
+        else
+        {
             m_alarmTime = QTime( 0, min );
         }
         auto settings = OverlayController::appSettings();
@@ -149,19 +188,22 @@ namespace advsettings {
         settings->endGroup();
         settings->sync();
         m_alarmLastCheckTime = QTime();
-			if (notify) {
+        if ( notify )
+        {
             emit alarmTimeMinuteChanged( min );
         }
     }
 }
 
-	void UtilitiesTabController::setAlarmTimeToCurrentTime() {
+void UtilitiesTabController::setAlarmTimeToCurrentTime()
+{
     auto now = QTime::currentTime();
     setAlarmTimeHour( now.hour() );
     setAlarmTimeMinute( now.minute() );
 }
 
-	void UtilitiesTabController::modAlarmTimeHour(int value, bool notify) {
+void UtilitiesTabController::modAlarmTimeHour( int value, bool notify )
+{
     auto h = m_alarmTime.hour();
     m_alarmTime = m_alarmTime.addSecs( value * 60 * 60 );
     auto settings = OverlayController::appSettings();
@@ -170,15 +212,18 @@ namespace advsettings {
     settings->setValue( "alarmMinute", m_alarmTime.minute() );
     settings->endGroup();
     settings->sync();
-		if (h != m_alarmTime.hour()) {
+    if ( h != m_alarmTime.hour() )
+    {
         m_alarmLastCheckTime = QTime();
-			if (notify) {
+        if ( notify )
+        {
             emit alarmTimeHourChanged( m_alarmTime.hour() );
         }
     }
 }
 
-	void UtilitiesTabController::modAlarmTimeMinute(int value, bool notify) {
+void UtilitiesTabController::modAlarmTimeMinute( int value, bool notify )
+{
     auto h = m_alarmTime.hour();
     auto m = m_alarmTime.minute();
     m_alarmTime = m_alarmTime.addSecs( value * 60 );
@@ -188,131 +233,224 @@ namespace advsettings {
     settings->setValue( "alarmMinute", m_alarmTime.minute() );
     settings->endGroup();
     settings->sync();
-		if (m != m_alarmTime.minute() || h != m_alarmTime.hour()) {
+    if ( m != m_alarmTime.minute() || h != m_alarmTime.hour() )
+    {
         m_alarmLastCheckTime = QTime();
-			if (notify) {
+        if ( notify )
-				if (h != m_alarmTime.hour()) {
+        {
+            if ( h != m_alarmTime.hour() )
+            {
                 emit alarmTimeHourChanged( m_alarmTime.hour() );
             }
-				if (m != m_alarmTime.minute()) {
+            if ( m != m_alarmTime.minute() )
+            {
                 emit alarmTimeMinuteChanged( m_alarmTime.minute() );
             }
         }
     }
 }
 
-    vr::VROverlayHandle_t createBatteryOverlay(vr::TrackedDeviceIndex_t index) {
+vr::VROverlayHandle_t createBatteryOverlay( vr::TrackedDeviceIndex_t index )
+{
     vr::VROverlayHandle_t handle = vr::k_ulOverlayHandleInvalid;
-        std::string batteryKey = std::string(OverlayController::applicationKey) + ".battery." + std::to_string(index);
+    std::string batteryKey = std::string( OverlayController::applicationKey )
-        vr::VROverlayError overlayError = vr::VROverlay()->CreateOverlay(batteryKey.c_str(), batteryKey.c_str(), &handle);
+                             + ".battery." + std::to_string( index );
-        if (overlayError == vr::VROverlayError_None) {
+    vr::VROverlayError overlayError = vr::VROverlay()->CreateOverlay(
-            std::string batteryIconPath = QApplication::applicationDirPath().toStdString() + "/res/battery_0.png";
+        batteryKey.c_str(), batteryKey.c_str(), &handle );
-            if (QFile::exists(QString::fromStdString(batteryIconPath))) {
+    if ( overlayError == vr::VROverlayError_None )
-                vr::VROverlay()->SetOverlayFromFile(handle, batteryIconPath.c_str());
+    {
+        std::string batteryIconPath
+            = QApplication::applicationDirPath().toStdString()
+              + "/res/battery_0.png";
+        if ( QFile::exists( QString::fromStdString( batteryIconPath ) ) )
+        {
+            vr::VROverlay()->SetOverlayFromFile( handle,
+                                                 batteryIconPath.c_str() );
             vr::VROverlay()->SetOverlayWidthInMeters( handle, 0.05f );
-            vr::HmdMatrix34_t notificationTransform = {{
+            vr::HmdMatrix34_t notificationTransform
-                    {1.0f, 0.0f, 0.0f, 0.00f},
+                = { { { 1.0f, 0.0f, 0.0f, 0.00f },
                       { 0.0f, -1.0f, 0.0f, 0.01f },
-                    {0.0f, 0.0f, -1.0f, -0.013f}
+                      { 0.0f, 0.0f, -1.0f, -0.013f } } };
-                }};
+            vr::VROverlay()->SetOverlayTransformTrackedDeviceRelative(
-                vr::VROverlay()->SetOverlayTransformTrackedDeviceRelative(handle, index, &notificationTransform);
+                handle, index, &notificationTransform );
             LOG( INFO ) << "Created battery overlay for device " << index;
-            } else {
-                LOG(ERROR) << "Could not find battery icon \"" << batteryIconPath << "\"";
         }
-        } else {
+        else
-            LOG(ERROR) << "Could not create ptt notification overlay: " << vr::VROverlay()->GetOverlayErrorNameFromEnum(overlayError);
+        {
+            LOG( ERROR ) << "Could not find battery icon \"" << batteryIconPath
+                         << "\"";
+        }
+    }
+    else
+    {
+        LOG( ERROR ) << "Could not create ptt notification overlay: "
+                     << vr::VROverlay()->GetOverlayErrorNameFromEnum(
+                            overlayError );
     }
 
     return handle;
 }
 
-
+void UtilitiesTabController::eventLoopTick()
-	void UtilitiesTabController::eventLoopTick() {
+{
-		if (settingsUpdateCounter >= 10) {
+    if ( settingsUpdateCounter >= 10 )
-
+    {
         vr::VROverlayHandle_t pOverlayHandle;
-			auto error = vr::VROverlay()->FindOverlay(steamDesktopOverlaykey, &pOverlayHandle);
+        auto error = vr::VROverlay()->FindOverlay( steamDesktopOverlaykey,
-			if (error == vr::VROverlayError_None) {
+                                                   &pOverlayHandle );
-				if (!m_steamDesktopOverlayAvailable) {
+        if ( error == vr::VROverlayError_None )
+        {
+            if ( !m_steamDesktopOverlayAvailable )
+            {
                 m_steamDesktopOverlayAvailable = true;
-					emit steamDesktopOverlayAvailableChanged(m_steamDesktopOverlayAvailable);
+                emit steamDesktopOverlayAvailableChanged(
+                    m_steamDesktopOverlayAvailable );
             }
             float width;
-				error = vr::VROverlay()->GetOverlayWidthInMeters(pOverlayHandle, &width);
+            error = vr::VROverlay()->GetOverlayWidthInMeters( pOverlayHandle,
-				if (error != vr::VROverlayError_None) {
+                                                              &width );
-					LOG(ERROR) << "Could not read overlay width of \"" << steamDesktopOverlaykey << "\": " << vr::VROverlay()->GetOverlayErrorNameFromEnum(error);
+            if ( error != vr::VROverlayError_None )
-				} else {
+            {
+                LOG( ERROR )
+                    << "Could not read overlay width of \""
+                    << steamDesktopOverlaykey << "\": "
+                    << vr::VROverlay()->GetOverlayErrorNameFromEnum( error );
+            }
+            else
+            {
                 setSteamDesktopOverlayWidth( width, true, false );
             }
-			} else {
+        }
-				if (m_steamDesktopOverlayAvailable) {
+        else
+        {
+            if ( m_steamDesktopOverlayAvailable )
+            {
                 m_steamDesktopOverlayAvailable = false;
-					emit steamDesktopOverlayAvailableChanged(m_steamDesktopOverlayAvailable);
+                emit steamDesktopOverlayAvailableChanged(
+                    m_steamDesktopOverlayAvailable );
             }
         }
 
-			if (m_alarmEnabled && m_alarmTime.isValid()) {
+        if ( m_alarmEnabled && m_alarmTime.isValid() )
+        {
             auto now = QTime::currentTime();
-				if (m_alarmLastCheckTime.isValid() && m_alarmLastCheckTime <= m_alarmTime && m_alarmTime <= now) {
+            if ( m_alarmLastCheckTime.isValid()
+                 && m_alarmLastCheckTime <= m_alarmTime && m_alarmTime <= now )
+            {
                 setAlarmEnabled( false );
                 char alarmMessageBuffer[1024];
-					std::snprintf(alarmMessageBuffer, 1024, "The alarm at %02i:%02i went off.", alarmTimeHour(), alarmTimeMinute());
+                std::snprintf( alarmMessageBuffer,
-					if (m_alarmIsModal) {
+                               1024,
-						std::thread messageThread([](UtilitiesTabController* parent, std::string message) {
+                               "The alarm at %02i:%02i went off.",
-							auto res = vr::VROverlay()->ShowMessageOverlay(message.c_str(), "Alarm Clock", "Ok", "+15 min");
+                               alarmTimeHour(),
-							if (res == vr::VRMessageOverlayResponse_ButtonPress_1) {
+                               alarmTimeMinute() );
+                if ( m_alarmIsModal )
+                {
+                    std::thread messageThread(
+                        []( UtilitiesTabController* parent,
+                            std::string message ) {
+                            auto res = vr::VROverlay()->ShowMessageOverlay(
+                                message.c_str(),
+                                "Alarm Clock",
+                                "Ok",
+                                "+15 min" );
+                            if ( res
+                                 == vr::VRMessageOverlayResponse_ButtonPress_1 )
+                            {
                                 parent->setAlarmTimeToCurrentTime();
                                 parent->modAlarmTimeMinute( 15 );
                                 parent->setAlarmEnabled( true );
-							} else if (res >= vr::VRMessageOverlayResponse_CouldntFindSystemOverlay) {
+                            }
-								static const char* errorMessages[] = { "CouldntFindSystemOverlay", "CouldntFindOrCreateClientOverlay", "ApplicationQuit" };
+                            else if (
-								int errorCode = res - vr::VRMessageOverlayResponse_CouldntFindSystemOverlay;
+                                res
-								if (res < 3) {
+                                >= vr::VRMessageOverlayResponse_CouldntFindSystemOverlay )
-									LOG(ERROR) << "Could not create Alarm Overlay: " << errorMessages[errorCode];
+                            {
-								} else {
+                                static const char* errorMessages[]
-									LOG(ERROR) << "Could not create Alarm Overlay: Unknown Error";
+                                    = { "CouldntFindSystemOverlay",
+                                        "CouldntFindOrCreateClientOverlay",
+                                        "ApplicationQuit" };
+                                int errorCode
+                                    = res
+                                      - vr::VRMessageOverlayResponse_CouldntFindSystemOverlay;
+                                if ( res < 3 )
+                                {
+                                    LOG( ERROR )
+                                        << "Could not create Alarm Overlay: "
+                                        << errorMessages[errorCode];
+                                }
+                                else
+                                {
+                                    LOG( ERROR ) << "Could not create Alarm "
+                                                    "Overlay: Unknown Error";
                                 }
                             }
-						}, this, std::string(alarmMessageBuffer));
+                        },
+                        this,
+                        std::string( alarmMessageBuffer ) );
                     messageThread.detach();
-					} else {
+                }
+                else
+                {
                     vr::VRNotificationId notificationId;
                     vr::EVRInitError eError;
-						vr::IVRNotifications* vrnotification = (vr::IVRNotifications*)vr::VR_GetGenericInterface(vr::IVRNotifications_Version, &eError);
+                    vr::IVRNotifications* vrnotification
-						if (eError != vr::VRInitError_None) {
+                        = ( vr::IVRNotifications* ) vr::VR_GetGenericInterface(
-							LOG(ERROR) << "Error while getting IVRNotifications interface" << vr::VR_GetVRInitErrorAsEnglishDescription(eError);
+                            vr::IVRNotifications_Version, &eError );
+                    if ( eError != vr::VRInitError_None )
+                    {
+                        LOG( ERROR )
+                            << "Error while getting IVRNotifications interface"
+                            << vr::VR_GetVRInitErrorAsEnglishDescription(
+                                   eError );
                         vrnotification = nullptr;
-						} else {
+                    }
+                    else
+                    {
                         vr::NotificationBitmap_t* messageIconPtr = nullptr;
                         /*
-							// Can i even create this object on the stack, who takes ownership?
+                        // Can i even create this object on the stack, who takes
-							vr::NotificationBitmap_t messageIcon;
+                        ownership? vr::NotificationBitmap_t messageIcon;
 
                         // First get image width and height
-							vr::VROverlay()->GetOverlayImageData(parent->overlayThumbnailHandle(), nullptr, 0, (uint32_t*)&messageIcon.m_nWidth, (uint32_t*)&messageIcon.m_nHeight);
+                        vr::VROverlay()->GetOverlayImageData(parent->overlayThumbnailHandle(),
+                        nullptr, 0, (uint32_t*)&messageIcon.m_nWidth,
+                        (uint32_t*)&messageIcon.m_nHeight);
 
                         messageIcon.m_nBytesPerPixel = 4;
-							unsigned bufferSize = messageIcon.m_nWidth*messageIcon.m_nHeight*messageIcon.m_nBytesPerPixel;
+                        unsigned bufferSize =
+                        messageIcon.m_nWidth*messageIcon.m_nHeight*messageIcon.m_nBytesPerPixel;
 
-							// Can I delete this buffer after this section? Who takes ownership?
+                        // Can I delete this buffer after this section? Who
-							std::unique_ptr<char> imageBuffer; 
+                        takes ownership? std::unique_ptr<char> imageBuffer;
                         imageBuffer.reset(new char[bufferSize]);
                         messageIcon.m_pImageData = imageBuffer.get();
 
                         // Get image data
-							auto iconError = vr::VROverlay()->GetOverlayImageData(parent->overlayThumbnailHandle(), messageIcon.m_pImageData, bufferSize, (uint32_t*)&messageIcon.m_nWidth, (uint32_t*)&messageIcon.m_nHeight);
+                        auto iconError =
-							if (iconError != vr::VROverlayError_None) {
+                        vr::VROverlay()->GetOverlayImageData(parent->overlayThumbnailHandle(),
-								LOG(ERROR) << "Error while getting message overlay icon: " << vr::VROverlay()->GetOverlayErrorNameFromEnum(iconError);
+                        messageIcon.m_pImageData, bufferSize,
+                        (uint32_t*)&messageIcon.m_nWidth,
+                        (uint32_t*)&messageIcon.m_nHeight); if (iconError !=
+                        vr::VROverlayError_None) { LOG(ERROR) << "Error while
+                        getting message overlay icon: " <<
+                        vr::VROverlay()->GetOverlayErrorNameFromEnum(iconError);
                         } else {
                             messageIconPtr = &messageIcon;
                         }
                         */
                         auto nError = vrnotification->CreateNotification(
-								parent->overlayHandle(), 666, vr::EVRNotificationType_Transient, alarmMessageBuffer, vr::EVRNotificationStyle_Application, messageIconPtr, &notificationId
+                            parent->overlayHandle(),
-							);
+                            666,
-							if (nError != vr::VRNotificationError_OK) {
+                            vr::EVRNotificationType_Transient,
-                                LOG(ERROR) << "Error while creating notification: " << nError;
+                            alarmMessageBuffer,
+                            vr::EVRNotificationStyle_Application,
+                            messageIconPtr,
+                            &notificationId );
+                        if ( nError != vr::VRNotificationError_OK )
+                        {
+                            LOG( ERROR )
+                                << "Error while creating notification: "
+                                << nError;
                             vrnotification = nullptr;
                         }
                     }
@@ -321,12 +459,19 @@ namespace advsettings {
             m_alarmLastCheckTime = now;
         }
 
-
+        // attach battery overlay to all tracked devices that aren't a
-            // attach battery overlay to all tracked devices that aren't a controller or hmd
+        // controller or hmd
-            for(vr::TrackedDeviceIndex_t i = 0; i < vr::k_unMaxTrackedDeviceCount; i++) {
+        for ( vr::TrackedDeviceIndex_t i = 0; i < vr::k_unMaxTrackedDeviceCount;
-                vr::ETrackedDeviceClass deviceClass = vr::VRSystem()->GetTrackedDeviceClass(i);
+              i++ )
-                if (deviceClass == vr::ETrackedDeviceClass::TrackedDeviceClass_GenericTracker) {
+        {
-                    if (m_batteryOverlayHandles[i] == vr::k_ulOverlayHandleInvalid) {
+            vr::ETrackedDeviceClass deviceClass
+                = vr::VRSystem()->GetTrackedDeviceClass( i );
+            if ( deviceClass
+                 == vr::ETrackedDeviceClass::TrackedDeviceClass_GenericTracker )
+            {
+                if ( m_batteryOverlayHandles[i]
+                     == vr::k_ulOverlayHandleInvalid )
+                {
                     LOG( INFO ) << "Creating battery overlay for device " << i;
                     m_batteryOverlayHandles[i] = createBatteryOverlay( i );
                     m_batteryVisible[i] = true;
@@ -334,27 +479,55 @@ namespace advsettings {
 
                 bool shouldShow = vr::VROverlay()->IsDashboardVisible();
 
-                    if (shouldShow != m_batteryVisible[i]) {
+                if ( shouldShow != m_batteryVisible[i] )
-                        if (shouldShow) {
+                {
-                            vr::VROverlay()->ShowOverlay(m_batteryOverlayHandles[i]);
+                    if ( shouldShow )
-                        } else {
+                    {
-                            vr::VROverlay()->HideOverlay(m_batteryOverlayHandles[i]);
+                        vr::VROverlay()->ShowOverlay(
+                            m_batteryOverlayHandles[i] );
+                    }
+                    else
+                    {
+                        vr::VROverlay()->HideOverlay(
+                            m_batteryOverlayHandles[i] );
                     }
                     m_batteryVisible[i] = shouldShow;
                 }
 
-                    bool hasBatteryStatus = vr::VRSystem()->GetBoolTrackedDeviceProperty(i, vr::ETrackedDeviceProperty::Prop_DeviceProvidesBatteryStatus_Bool);
+                bool hasBatteryStatus
-                    if (hasBatteryStatus) {
+                    = vr::VRSystem()->GetBoolTrackedDeviceProperty(
-                        float battery = vr::VRSystem()->GetFloatTrackedDeviceProperty(i, vr::ETrackedDeviceProperty::Prop_DeviceBatteryPercentage_Float);
+                        i,
+                        vr::ETrackedDeviceProperty::
+                            Prop_DeviceProvidesBatteryStatus_Bool );
+                if ( hasBatteryStatus )
+                {
+                    float battery
+                        = vr::VRSystem()->GetFloatTrackedDeviceProperty(
+                            i,
+                            vr::ETrackedDeviceProperty::
+                                Prop_DeviceBatteryPercentage_Float );
                     int batteryState = ceil( battery * 5 );
 
-                        if (batteryState != m_batteryState[i]) {
+                    if ( batteryState != m_batteryState[i] )
-                            LOG(INFO) << "Updating battery overlay for device " << i << " to " << batteryState << "(" << battery << "";
+                    {
-                            std::string batteryIconPath = QApplication::applicationDirPath().toStdString() + "/res/battery_" + std::to_string(batteryState) + ".png";
+                        LOG( INFO )
-                            if (QFile::exists(QString::fromStdString(batteryIconPath))) {
+                            << "Updating battery overlay for device " << i
-                                vr::VROverlay()->SetOverlayFromFile(m_batteryOverlayHandles[i], batteryIconPath.c_str());
+                            << " to " << batteryState << "(" << battery << "";
-                            } else {
+                        std::string batteryIconPath
-                                LOG(ERROR) << "Could not find battery icon \"" << batteryIconPath << "\"";
+                            = QApplication::applicationDirPath().toStdString()
+                              + "/res/battery_" + std::to_string( batteryState )
+                              + ".png";
+                        if ( QFile::exists(
+                                 QString::fromStdString( batteryIconPath ) ) )
+                        {
+                            vr::VROverlay()->SetOverlayFromFile(
+                                m_batteryOverlayHandles[i],
+                                batteryIconPath.c_str() );
+                        }
+                        else
+                        {
+                            LOG( ERROR ) << "Could not find battery icon \""
+                                         << batteryIconPath << "\"";
                         }
                         m_batteryState[i] = batteryState;
                     }
@@ -363,40 +536,61 @@ namespace advsettings {
         }
 
         settingsUpdateCounter = 0;
-		} else {
+    }
+    else
+    {
         settingsUpdateCounter++;
     }
 }
 
-
+bool UtilitiesTabController::steamDesktopOverlayAvailable() const
-	bool UtilitiesTabController::steamDesktopOverlayAvailable() const {
+{
     return m_steamDesktopOverlayAvailable;
 }
 
-	float UtilitiesTabController::steamDesktopOverlayWidth() const {
+float UtilitiesTabController::steamDesktopOverlayWidth() const
+{
     return m_steamDesktopOverlayWidth;
 }
 
-	void UtilitiesTabController::setSteamDesktopOverlayWidth(float width, bool notify, bool notifyOpenVr) {
+void UtilitiesTabController::setSteamDesktopOverlayWidth( float width,
-		if (std::abs(m_steamDesktopOverlayWidth - width) > 0.01) {
+                                                          bool notify,
+                                                          bool notifyOpenVr )
+{
+    if ( std::abs( m_steamDesktopOverlayWidth - width ) > 0.01 )
+    {
         m_steamDesktopOverlayWidth = width;
-			if (notifyOpenVr) {
+        if ( notifyOpenVr )
+        {
             vr::VROverlayHandle_t pOverlayHandle;
-				auto error = vr::VROverlay()->FindOverlay(steamDesktopOverlaykey, &pOverlayHandle);
+            auto error = vr::VROverlay()->FindOverlay( steamDesktopOverlaykey,
-				if (error != vr::VROverlayError_None) {
+                                                       &pOverlayHandle );
-					LOG(ERROR) << "Could not find overlay \"" << steamDesktopOverlaykey << "\": " << vr::VROverlay()->GetOverlayErrorNameFromEnum(error);
+            if ( error != vr::VROverlayError_None )
-				} else {
+            {
-					error = vr::VROverlay()->SetOverlayWidthInMeters(pOverlayHandle, m_steamDesktopOverlayWidth);
+                LOG( ERROR )
-					if (error != vr::VROverlayError_None) {
+                    << "Could not find overlay \"" << steamDesktopOverlaykey
-						LOG(ERROR) << "Could not modify overlay width of \"" << steamDesktopOverlaykey << "\": " << vr::VROverlay()->GetOverlayErrorNameFromEnum(error);
+                    << "\": "
+                    << vr::VROverlay()->GetOverlayErrorNameFromEnum( error );
+            }
+            else
+            {
+                error = vr::VROverlay()->SetOverlayWidthInMeters(
+                    pOverlayHandle, m_steamDesktopOverlayWidth );
+                if ( error != vr::VROverlayError_None )
+                {
+                    LOG( ERROR )
+                        << "Could not modify overlay width of \""
+                        << steamDesktopOverlaykey << "\": "
+                        << vr::VROverlay()->GetOverlayErrorNameFromEnum(
+                               error );
                 }
             }
         }
-			if (notify) {
+        if ( notify )
+        {
             emit steamDesktopOverlayWidthChanged( m_steamDesktopOverlayWidth );
         }
     }
 }
 
-
+} // namespace advsettings
-} // namespace advconfig

src/tabcontrollers/UtilitiesTabController.h

@@ -9,20 +9,28 @@
 
 class QQuickWindow;
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 // forward declaration
 class OverlayController;
 
-
+class UtilitiesTabController : public QObject
-	class UtilitiesTabController : public QObject {
+{
     Q_OBJECT
-		Q_PROPERTY(bool alarmEnabled READ alarmEnabled WRITE setAlarmEnabled NOTIFY alarmEnabledChanged)
+    Q_PROPERTY( bool alarmEnabled READ alarmEnabled WRITE setAlarmEnabled NOTIFY
-		Q_PROPERTY(bool alarmIsModal READ alarmIsModal WRITE setAlarmIsModal NOTIFY alarmIsModalChanged)
+                    alarmEnabledChanged )
-		Q_PROPERTY(int alarmTimeHour READ alarmTimeHour WRITE setAlarmTimeHour NOTIFY alarmTimeHourChanged)
+    Q_PROPERTY( bool alarmIsModal READ alarmIsModal WRITE setAlarmIsModal NOTIFY
-		Q_PROPERTY(int alarmTimeMinute READ alarmTimeMinute WRITE setAlarmTimeMinute NOTIFY alarmTimeMinuteChanged)
+                    alarmIsModalChanged )
-		Q_PROPERTY(bool steamDesktopOverlayAvailable READ steamDesktopOverlayAvailable NOTIFY steamDesktopOverlayAvailableChanged)
+    Q_PROPERTY( int alarmTimeHour READ alarmTimeHour WRITE setAlarmTimeHour
-		Q_PROPERTY(float steamDesktopOverlayWidth READ steamDesktopOverlayWidth WRITE setSteamDesktopOverlayWidth NOTIFY steamDesktopOverlayWidthChanged)
+                    NOTIFY alarmTimeHourChanged )
+    Q_PROPERTY( int alarmTimeMinute READ alarmTimeMinute WRITE
+                    setAlarmTimeMinute NOTIFY alarmTimeMinuteChanged )
+    Q_PROPERTY(
+        bool steamDesktopOverlayAvailable READ steamDesktopOverlayAvailable
+            NOTIFY steamDesktopOverlayAvailableChanged )
+    Q_PROPERTY(
+        float steamDesktopOverlayWidth READ steamDesktopOverlayWidth WRITE
+            setSteamDesktopOverlayWidth NOTIFY steamDesktopOverlayWidthChanged )
 
 private:
     OverlayController* parent;
@@ -36,7 +44,8 @@ namespace advsettings {
     QTime m_alarmLastCheckTime;
     bool m_steamDesktopOverlayAvailable = false;
     float m_steamDesktopOverlayWidth = 4.0f;
-        vr::VROverlayHandle_t m_batteryOverlayHandles[vr::k_unMaxTrackedDeviceCount];
+    vr::VROverlayHandle_t
+        m_batteryOverlayHandles[vr::k_unMaxTrackedDeviceCount];
     int m_batteryState[vr::k_unMaxTrackedDeviceCount];
     bool m_batteryVisible[vr::k_unMaxTrackedDeviceCount];
 
@@ -70,7 +79,9 @@ namespace advsettings {
     void modAlarmTimeHour( int value, bool notify = true );
     void modAlarmTimeMinute( int value, bool notify = true );
 
-		void setSteamDesktopOverlayWidth(float width, bool notify = true, bool notifyOpenVr = true);
+    void setSteamDesktopOverlayWidth( float width,
+                                      bool notify = true,
+                                      bool notifyOpenVr = true );
 
 signals:
     void alarmEnabledChanged( bool enabled );

src/tabcontrollers/audiomanager/AudioManagerDummy.cpp

@@ -1,12 +1,12 @@
 #include "AudioManagerDummy.h"
 
-// Used to get the compiler to shut up about C4100: unreferenced formal parameter.
+// Used to get the compiler to shut up about C4100: unreferenced formal
-// The cast is to get GCC to shut up about it.
+// parameter. The cast is to get GCC to shut up about it.
 #define UNREFERENCED_PARAMETER( P ) static_cast<void>( ( P ) )
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 void AudioManagerDummy::init( AudioTabController* controller )
 {
     // noop
@@ -118,16 +118,16 @@ bool AudioManagerDummy::setMicMuted(bool value)
     return false;
 }
 
-std::vector<std::pair<std::string, std::string> > AudioManagerDummy::getRecordingDevices()
+std::vector<std::pair<std::string, std::string>>
+    AudioManagerDummy::getRecordingDevices()
 {
     return {};
 }
 
-std::vector<std::pair<std::string, std::string> > AudioManagerDummy::getPlaybackDevices()
+std::vector<std::pair<std::string, std::string>>
+    AudioManagerDummy::getPlaybackDevices()
 {
     return {};
 }
 
-
+} // namespace advsettings
-
-}

src/tabcontrollers/audiomanager/AudioManagerDummy.h

@@ -4,19 +4,20 @@
 #include "../AudioManager.h"
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 class AudioManagerDummy : public AudioManager
 {
 public:
-
     virtual void init( AudioTabController* controller ) override;
 
-    virtual void setPlaybackDevice(const std::string& id, bool notify = true) override;
+    virtual void setPlaybackDevice( const std::string& id,
+                                    bool notify = true ) override;
     virtual std::string getPlaybackDevName() override;
     virtual std::string getPlaybackDevId() override;
 
-    virtual void setMirrorDevice(const std::string& id, bool notify = true) override;
+    virtual void setMirrorDevice( const std::string& id,
+                                  bool notify = true ) override;
     virtual bool isMirrorValid() override;
     virtual std::string getMirrorDevName() override;
     virtual std::string getMirrorDevId() override;
@@ -26,7 +27,8 @@ public:
     virtual bool setMirrorMuted( bool value ) override;
 
     virtual bool isMicValid() override;
-    virtual void setMicDevice(const std::string& id, bool notify = true) override;
+    virtual void setMicDevice( const std::string& id,
+                               bool notify = true ) override;
     virtual std::string getMicDevName() override;
     virtual std::string getMicDevId() override;
     virtual float getMicVolume() override;
@@ -34,9 +36,11 @@ public:
     virtual bool getMicMuted() override;
     virtual bool setMicMuted( bool value ) override;
 
-    virtual std::vector<std::pair<std::string, std::string>> getRecordingDevices() override;
+    virtual std::vector<std::pair<std::string, std::string>>
-    virtual std::vector<std::pair<std::string, std::string>> getPlaybackDevices() override;
+        getRecordingDevices() override;
+    virtual std::vector<std::pair<std::string, std::string>>
+        getPlaybackDevices() override;
 };
 
-}
+} // namespace advsettings
 #endif // AUDIOMANAGERLINUX_H

src/tabcontrollers/audiomanager/AudioManagerWindows.cpp

@@ -6,336 +6,486 @@
 #include <locale>
 #include <codecvt>
 
-
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
-AudioManagerWindows::~AudioManagerWindows() {
+AudioManagerWindows::~AudioManagerWindows()
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	audioDeviceEnumerator->UnregisterEndpointNotificationCallback((IMMNotificationClient*)this);
+    audioDeviceEnumerator->UnregisterEndpointNotificationCallback(
-	if (mirrorAudioEndpointVolume) {
+        ( IMMNotificationClient* ) this );
+    if ( mirrorAudioEndpointVolume )
+    {
         mirrorAudioEndpointVolume->Release();
     }
-	if (micAudioEndpointVolume) {
+    if ( micAudioEndpointVolume )
+    {
         micAudioEndpointVolume->Release();
     }
-	if (mirrorAudioDevice) {
+    if ( mirrorAudioDevice )
+    {
         mirrorAudioDevice->Release();
     }
-	if (micAudioDevice) {
+    if ( micAudioDevice )
+    {
         micAudioDevice->Release();
     }
-	if (playbackAudioDevice) {
+    if ( playbackAudioDevice )
+    {
         playbackAudioDevice->Release();
     }
     audioDeviceEnumerator->Release();
 }
 
-void AudioManagerWindows::init(AudioTabController* var_controller) {
+void AudioManagerWindows::init( AudioTabController* var_controller )
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
     audioDeviceEnumerator = getAudioDeviceEnumerator();
-	if (!audioDeviceEnumerator) {
+    if ( !audioDeviceEnumerator )
+    {
         throw std::exception( "Could not create audio device enumerator" );
     }
     playbackAudioDevice = getDefaultPlaybackDevice( audioDeviceEnumerator );
-	if (!playbackAudioDevice) {
+    if ( !playbackAudioDevice )
+    {
         LOG( WARNING ) << "Could not find a default recording device.";
     }
     micAudioDevice = getDefaultRecordingDevice( audioDeviceEnumerator );
-	if (micAudioDevice) {
+    if ( micAudioDevice )
+    {
         micAudioEndpointVolume = getAudioEndpointVolume( micAudioDevice );
-	} else {
+    }
+    else
+    {
         LOG( WARNING ) << "Could not find a default recording device.";
     }
     this->controller = var_controller;
-	audioDeviceEnumerator->RegisterEndpointNotificationCallback((IMMNotificationClient*)this);
+    audioDeviceEnumerator->RegisterEndpointNotificationCallback(
+        ( IMMNotificationClient* ) this );
     policyConfig = getPolicyConfig();
-	if (!policyConfig) {
+    if ( !policyConfig )
+    {
         LOG( ERROR ) << "Could not find PolicyConfig interface";
     }
 }
 
-void AudioManagerWindows::setPlaybackDevice(const std::string & id, bool notify) {
+void AudioManagerWindows::setPlaybackDevice( const std::string& id,
+                                             bool notify )
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (!id.empty()) {
+    if ( !id.empty() )
+    {
         auto dev = getDevice( audioDeviceEnumerator, id );
-		if (!dev) {
+        if ( !dev )
-			LOG(WARNING) << "Could not find playback device \"" << id << "\".";
+        {
-		} else {
+            LOG( WARNING ) << "Could not find playback device \"" << id
+                           << "\".";
+        }
+        else
+        {
             playbackAudioDevice = dev;
-			if (policyConfig) {
+            if ( policyConfig )
+            {
                 LPWSTR devId;
-				if (dev->GetId(&devId) >= 0) {
+                if ( dev->GetId( &devId ) >= 0 )
+                {
                     policyConfig->SetDefaultEndpoint( devId, eConsole );
                 }
             }
         }
     }
-	if (notify) {
+    if ( notify )
+    {
         controller->onNewPlaybackDevice();
     }
 }
 
-std::string AudioManagerWindows::getPlaybackDevName() {
+std::string AudioManagerWindows::getPlaybackDevName()
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (playbackAudioDevice) {
+    if ( playbackAudioDevice )
+    {
         return getDeviceName( playbackAudioDevice );
     }
     return "";
 }
 
-std::string AudioManagerWindows::getPlaybackDevId() {
+std::string AudioManagerWindows::getPlaybackDevId()
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (playbackAudioDevice) {
+    if ( playbackAudioDevice )
+    {
         return getDeviceId( playbackAudioDevice );
     }
     return "";
 }
 
-
+void AudioManagerWindows::setMirrorDevice( const std::string& id, bool notify )
-void AudioManagerWindows::setMirrorDevice(const std::string& id, bool notify) {
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (id.empty()) {
+    if ( id.empty() )
+    {
         deleteMirrorDevice();
-		if (notify) {
+        if ( notify )
+        {
             controller->onNewMirrorDevice();
         }
-	} else {
+    }
+    else
+    {
         auto dev = getDevice( audioDeviceEnumerator, id );
-		if (dev) {
+        if ( dev )
+        {
             mirrorAudioDevice = dev;
-			mirrorAudioEndpointVolume = getAudioEndpointVolume(mirrorAudioDevice);
+            mirrorAudioEndpointVolume
-		} else {
+                = getAudioEndpointVolume( mirrorAudioDevice );
+        }
+        else
+        {
             LOG( WARNING ) << "Could not find mirror device \"" << id << "\".";
         }
     }
-	if (notify) {
+    if ( notify )
+    {
         controller->onNewMirrorDevice();
     }
 }
 
-void AudioManagerWindows::deleteMirrorDevice() {
+void AudioManagerWindows::deleteMirrorDevice()
-	if (mirrorAudioEndpointVolume) {
+{
+    if ( mirrorAudioEndpointVolume )
+    {
         mirrorAudioEndpointVolume->Release();
         mirrorAudioEndpointVolume = nullptr;
     }
-	if (mirrorAudioDevice) {
+    if ( mirrorAudioDevice )
+    {
         mirrorAudioDevice->Release();
         mirrorAudioDevice = nullptr;
     }
 }
 
-bool AudioManagerWindows::isMirrorValid() {
+bool AudioManagerWindows::isMirrorValid()
+{
     return mirrorAudioEndpointVolume != nullptr;
 }
 
-std::string AudioManagerWindows::getMirrorDevName() {
+std::string AudioManagerWindows::getMirrorDevName()
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (mirrorAudioDevice) {
+    if ( mirrorAudioDevice )
+    {
         return getDeviceName( mirrorAudioDevice );
     }
     return "";
 }
 
-std::string AudioManagerWindows::getMirrorDevId() {
+std::string AudioManagerWindows::getMirrorDevId()
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (mirrorAudioDevice) {
+    if ( mirrorAudioDevice )
+    {
         return getDeviceId( mirrorAudioDevice );
     }
     return "";
 }
 
-float AudioManagerWindows::getMirrorVolume() {
+float AudioManagerWindows::getMirrorVolume()
+{
     float value;
-	if (mirrorAudioEndpointVolume && mirrorAudioEndpointVolume->GetMasterVolumeLevelScalar(&value) >= 0) {
+    if ( mirrorAudioEndpointVolume
+         && mirrorAudioEndpointVolume->GetMasterVolumeLevelScalar( &value )
+                >= 0 )
+    {
         return value;
-	} else {
+    }
+    else
+    {
         return 0.0;
     }
 }
 
-bool AudioManagerWindows::setMirrorVolume(float value) {
+bool AudioManagerWindows::setMirrorVolume( float value )
-	if (mirrorAudioEndpointVolume) {
+{
-		if (mirrorAudioEndpointVolume->SetMasterVolumeLevelScalar(value, nullptr) >= 0) {
+    if ( mirrorAudioEndpointVolume )
+    {
+        if ( mirrorAudioEndpointVolume->SetMasterVolumeLevelScalar( value,
+                                                                    nullptr )
+             >= 0 )
+        {
             return true;
         }
     }
     return false;
 }
 
-bool AudioManagerWindows::getMirrorMuted() {
+bool AudioManagerWindows::getMirrorMuted()
+{
     BOOL value;
-	if (mirrorAudioEndpointVolume && mirrorAudioEndpointVolume->GetMute(&value) >= 0) {
+    if ( mirrorAudioEndpointVolume
+         && mirrorAudioEndpointVolume->GetMute( &value ) >= 0 )
+    {
         return value;
-	} else {
+    }
+    else
+    {
         return false;
     }
 }
 
-bool AudioManagerWindows::setMirrorMuted(bool value) {
+bool AudioManagerWindows::setMirrorMuted( bool value )
-	if (mirrorAudioEndpointVolume) {
+{
-		if (mirrorAudioEndpointVolume->SetMute(value, nullptr) >= 0) {
+    if ( mirrorAudioEndpointVolume )
+    {
+        if ( mirrorAudioEndpointVolume->SetMute( value, nullptr ) >= 0 )
+        {
             return true;
         }
     }
     return false;
 }
 
-
+bool AudioManagerWindows::isMicValid()
-bool AudioManagerWindows::isMicValid() {
+{
     return micAudioEndpointVolume != nullptr;
 }
 
-void AudioManagerWindows::setMicDevice(const std::string & id, bool notify) {
+void AudioManagerWindows::setMicDevice( const std::string& id, bool notify )
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (!id.empty()) {
+    if ( !id.empty() )
+    {
         auto dev = getDevice( audioDeviceEnumerator, id );
-		if (!dev) {
+        if ( !dev )
-			LOG(WARNING) << "Could not find recording device \"" << id << "\".";
+        {
-		} else {
+            LOG( WARNING ) << "Could not find recording device \"" << id
+                           << "\".";
+        }
+        else
+        {
             micAudioDevice = dev;
-			if (policyConfig) {
+            if ( policyConfig )
+            {
                 LPWSTR devId;
-				if (dev->GetId(&devId) >= 0) {
+                if ( dev->GetId( &devId ) >= 0 )
+                {
                     policyConfig->SetDefaultEndpoint( devId, eConsole );
                 }
             }
         }
     }
-	if (notify) {
+    if ( notify )
+    {
         controller->onNewRecordingDevice();
     }
 }
 
-std::string AudioManagerWindows::getMicDevName() {
+std::string AudioManagerWindows::getMicDevName()
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (micAudioDevice) {
+    if ( micAudioDevice )
+    {
         return getDeviceName( micAudioDevice );
     }
     return "";
 }
 
-std::string AudioManagerWindows::getMicDevId() {
+std::string AudioManagerWindows::getMicDevId()
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (micAudioDevice) {
+    if ( micAudioDevice )
+    {
         return getDeviceId( micAudioDevice );
     }
     return "";
 }
 
-float AudioManagerWindows::getMicVolume() {
+float AudioManagerWindows::getMicVolume()
+{
     float value;
-	if (micAudioEndpointVolume && micAudioEndpointVolume->GetMasterVolumeLevelScalar(&value) >= 0) {
+    if ( micAudioEndpointVolume
+         && micAudioEndpointVolume->GetMasterVolumeLevelScalar( &value ) >= 0 )
+    {
         return value;
-	} else {
+    }
+    else
+    {
         return 0.0;
     }
 }
 
-bool AudioManagerWindows::setMicVolume(float value) {
+bool AudioManagerWindows::setMicVolume( float value )
-	if (micAudioEndpointVolume) {
+{
-		if (micAudioEndpointVolume->SetMasterVolumeLevelScalar(value, nullptr) >= 0) {
+    if ( micAudioEndpointVolume )
+    {
+        if ( micAudioEndpointVolume->SetMasterVolumeLevelScalar( value,
+                                                                 nullptr )
+             >= 0 )
+        {
             return true;
         }
     }
     return false;
 }
 
-bool AudioManagerWindows::getMicMuted() {
+bool AudioManagerWindows::getMicMuted()
+{
     BOOL value;
-	if (micAudioEndpointVolume && micAudioEndpointVolume->GetMute(&value) >= 0) {
+    if ( micAudioEndpointVolume
+         && micAudioEndpointVolume->GetMute( &value ) >= 0 )
+    {
         return value;
-	} else {
+    }
+    else
+    {
         return false;
     }
 }
 
-bool AudioManagerWindows::setMicMuted(bool value) {
+bool AudioManagerWindows::setMicMuted( bool value )
-	if (micAudioEndpointVolume) {
+{
-		if (micAudioEndpointVolume->SetMute(value, nullptr) >= 0) {
+    if ( micAudioEndpointVolume )
+    {
+        if ( micAudioEndpointVolume->SetMute( value, nullptr ) >= 0 )
+        {
             return true;
         }
     }
     return false;
 }
 
-std::vector<std::pair<std::string, std::string>> AudioManagerWindows::getRecordingDevices() {
+std::vector<std::pair<std::string, std::string>>
+    AudioManagerWindows::getRecordingDevices()
+{
     return getDevices( audioDeviceEnumerator, eCapture );
 }
 
-std::vector<std::pair<std::string, std::string>> AudioManagerWindows::getPlaybackDevices() {
+std::vector<std::pair<std::string, std::string>>
+    AudioManagerWindows::getPlaybackDevices()
+{
     return getDevices( audioDeviceEnumerator, eRender );
 }
 
-
+IMMDeviceEnumerator* AudioManagerWindows::getAudioDeviceEnumerator()
-IMMDeviceEnumerator* AudioManagerWindows::getAudioDeviceEnumerator() {
+{
     IMMDeviceEnumerator* pEnumerator;
-	if (CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_ALL, __uuidof(IMMDeviceEnumerator), (void**)&pEnumerator) < 0) {
+    if ( CoCreateInstance( __uuidof( MMDeviceEnumerator ),
+                           NULL,
+                           CLSCTX_ALL,
+                           __uuidof( IMMDeviceEnumerator ),
+                           ( void** ) &pEnumerator )
+         < 0 )
+    {
         return nullptr;
     }
     return pEnumerator;
 }
 
-IPolicyConfig * AudioManagerWindows::getPolicyConfig() {
+IPolicyConfig* AudioManagerWindows::getPolicyConfig()
+{
     IPolicyConfig* var_policyConfig = nullptr;
     // for Win 10
-        auto hr = CoCreateInstance(__uuidof(CPolicyConfigClient), NULL, CLSCTX_INPROC, IID_IPolicyConfig2, (LPVOID *)&var_policyConfig);
+    auto hr = CoCreateInstance( __uuidof( CPolicyConfigClient ),
-	if (hr != S_OK) {
+                                NULL,
-                hr = CoCreateInstance(__uuidof(CPolicyConfigClient), NULL, CLSCTX_INPROC, IID_IPolicyConfig1, (LPVOID *)&var_policyConfig);
+                                CLSCTX_INPROC,
+                                IID_IPolicyConfig2,
+                                ( LPVOID* ) &var_policyConfig );
+    if ( hr != S_OK )
+    {
+        hr = CoCreateInstance( __uuidof( CPolicyConfigClient ),
+                               NULL,
+                               CLSCTX_INPROC,
+                               IID_IPolicyConfig1,
+                               ( LPVOID* ) &var_policyConfig );
     }
     // for Win Vista, 7, 8, 8.1
-	if (hr != S_OK) {
+    if ( hr != S_OK )
-                hr = CoCreateInstance(__uuidof(CPolicyConfigClient), NULL, CLSCTX_INPROC, IID_IPolicyConfig0, (LPVOID *)&var_policyConfig);
+    {
+        hr = CoCreateInstance( __uuidof( CPolicyConfigClient ),
+                               NULL,
+                               CLSCTX_INPROC,
+                               IID_IPolicyConfig0,
+                               ( LPVOID* ) &var_policyConfig );
     }
-	if (hr != S_OK) {
+    if ( hr != S_OK )
+    {
         return nullptr;
-	} else {
+    }
+    else
+    {
         return var_policyConfig;
     }
 }
 
-IMMDevice* AudioManagerWindows::getDefaultRecordingDevice(IMMDeviceEnumerator* deviceEnumerator) {
+IMMDevice* AudioManagerWindows::getDefaultRecordingDevice(
+    IMMDeviceEnumerator* deviceEnumerator )
+{
     IMMDevice* pDevice;
-	if (deviceEnumerator->GetDefaultAudioEndpoint(eCapture, eConsole, &pDevice) < 0) {
+    if ( deviceEnumerator->GetDefaultAudioEndpoint(
+             eCapture, eConsole, &pDevice )
+         < 0 )
+    {
         return nullptr;
     }
     return pDevice;
 }
 
-IMMDevice * AudioManagerWindows::getDefaultPlaybackDevice(IMMDeviceEnumerator * deviceEnumerator) {
+IMMDevice* AudioManagerWindows::getDefaultPlaybackDevice(
+    IMMDeviceEnumerator* deviceEnumerator )
+{
     IMMDevice* pDevice;
-	if (deviceEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &pDevice) < 0) {
+    if ( deviceEnumerator->GetDefaultAudioEndpoint(
+             eRender, eConsole, &pDevice )
+         < 0 )
+    {
         return nullptr;
     }
     return pDevice;
 }
 
-IMMDevice* AudioManagerWindows::getDevice(IMMDeviceEnumerator* deviceEnumerator, const std::string& id) {
+IMMDevice*
+    AudioManagerWindows::getDevice( IMMDeviceEnumerator* deviceEnumerator,
+                                    const std::string& id )
+{
     std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
     std::wstring wid = converter.from_bytes( id );
     return getDevice( deviceEnumerator, wid.c_str() );
 }
 
-IMMDevice * AudioManagerWindows::getDevice(IMMDeviceEnumerator * deviceEnumerator, LPCWSTR id) {
+IMMDevice*
+    AudioManagerWindows::getDevice( IMMDeviceEnumerator* deviceEnumerator,
+                                    LPCWSTR id )
+{
     IMMDevice* pDevice;
-	if (deviceEnumerator->GetDevice(id, &pDevice) < 0) {
+    if ( deviceEnumerator->GetDevice( id, &pDevice ) < 0 )
+    {
         return nullptr;
     }
     return pDevice;
 }
 
-IAudioEndpointVolume * AudioManagerWindows::getAudioEndpointVolume(IMMDevice* device) {
+IAudioEndpointVolume*
+    AudioManagerWindows::getAudioEndpointVolume( IMMDevice* device )
+{
     IAudioEndpointVolume* pEndpointVolume;
-	if (device->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER, NULL, (void**)&pEndpointVolume) < 0) {
+    if ( device->Activate( __uuidof( IAudioEndpointVolume ),
+                           CLSCTX_INPROC_SERVER,
+                           NULL,
+                           ( void** ) &pEndpointVolume )
+         < 0 )
+    {
         return nullptr;
     }
     return pEndpointVolume;
 }
 
-std::string AudioManagerWindows::getDeviceName(IMMDevice* device) {
+std::string AudioManagerWindows::getDeviceName( IMMDevice* device )
+{
     IPropertyStore* pProps = nullptr;
     PROPVARIANT varString;
-	if (device->OpenPropertyStore(STGM_READ, &pProps) >= 0 && pProps->GetValue(PKEY_Device_FriendlyName, &varString) >= 0) {
+    if ( device->OpenPropertyStore( STGM_READ, &pProps ) >= 0
+         && pProps->GetValue( PKEY_Device_FriendlyName, &varString ) >= 0 )
+    {
         std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
         std::string name = converter.to_bytes( varString.pwszVal );
         return name;
@@ -343,26 +493,37 @@ std::string AudioManagerWindows::getDeviceName(IMMDevice* device) {
     return "";
 }
 
-std::string AudioManagerWindows::getDeviceId(IMMDevice* device) {
+std::string AudioManagerWindows::getDeviceId( IMMDevice* device )
+{
     LPWSTR ppstrId;
-	if (device->GetId(&ppstrId) >= 0) {
+    if ( device->GetId( &ppstrId ) >= 0 )
+    {
         std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
         return converter.to_bytes( ppstrId );
     }
     return "";
 }
 
-std::vector<std::pair<std::string, std::string>> AudioManagerWindows::getDevices(IMMDeviceEnumerator * deviceEnumerator, EDataFlow dataFlow) {
+std::vector<std::pair<std::string, std::string>>
+    AudioManagerWindows::getDevices( IMMDeviceEnumerator* deviceEnumerator,
+                                     EDataFlow dataFlow )
+{
     std::vector<std::pair<std::string, std::string>> retval;
     IMMDeviceCollection* ppDevices = nullptr;
-	if (deviceEnumerator->EnumAudioEndpoints(dataFlow, DEVICE_STATE_ACTIVE, &ppDevices) >= 0) {
+    if ( deviceEnumerator->EnumAudioEndpoints(
+             dataFlow, DEVICE_STATE_ACTIVE, &ppDevices )
+         >= 0 )
+    {
         UINT count;
         ppDevices->GetCount( &count );
-		for (UINT i = 0; i < count; ++i) {
+        for ( UINT i = 0; i < count; ++i )
+        {
             IMMDevice* device = nullptr;
             ppDevices->Item( i, &device );
-			if (device) {
+            if ( device )
-				retval.emplace_back(getDeviceId(device), getDeviceName(device));
+            {
+                retval.emplace_back( getDeviceId( device ),
+                                     getDeviceName( device ) );
             }
         }
         ppDevices->Release();
@@ -370,79 +531,115 @@ std::vector<std::pair<std::string, std::string>> AudioManagerWindows::getDevices
     return retval;
 }
 
-
+HRESULT AudioManagerWindows::QueryInterface( REFIID riid, void** ppvObject )
-HRESULT AudioManagerWindows::QueryInterface(REFIID riid, void ** ppvObject) {
+{
-	if (IID_IUnknown == riid) {
+    if ( IID_IUnknown == riid )
+    {
         AddRef();
         *ppvObject = ( IUnknown* ) this;
-	} else if (__uuidof(IMMNotificationClient) == riid) {
+    }
+    else if ( __uuidof( IMMNotificationClient ) == riid )
+    {
         AddRef();
         *ppvObject = ( IMMNotificationClient* ) this;
-	} else {
+    }
+    else
+    {
         *ppvObject = NULL;
         return E_NOINTERFACE;
     }
     return S_OK;
 }
 
-ULONG AudioManagerWindows::AddRef(void) {
+ULONG AudioManagerWindows::AddRef( void )
+{
     return 1; // We don't need reference counting
 }
 
-ULONG AudioManagerWindows::Release(void) {
+ULONG AudioManagerWindows::Release( void )
+{
     return 1; // We don't need reference counting
 }
 
-HRESULT AudioManagerWindows::OnDeviceStateChanged(LPCWSTR, DWORD) {
+HRESULT AudioManagerWindows::OnDeviceStateChanged( LPCWSTR, DWORD )
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
     controller->onDeviceStateChanged();
     return S_OK;
 }
 
-HRESULT AudioManagerWindows::OnDeviceAdded(LPCWSTR) {
+HRESULT AudioManagerWindows::OnDeviceAdded( LPCWSTR )
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
     controller->onDeviceStateChanged();
     return S_OK;
 }
 
-HRESULT AudioManagerWindows::OnDeviceRemoved(LPCWSTR) {
+HRESULT AudioManagerWindows::OnDeviceRemoved( LPCWSTR )
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
     controller->onDeviceStateChanged();
     return S_OK;
 }
 
-HRESULT AudioManagerWindows::OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDefaultDeviceId) {
+HRESULT
+AudioManagerWindows::OnDefaultDeviceChanged( EDataFlow flow,
+                                             ERole role,
+                                             LPCWSTR pwstrDefaultDeviceId )
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
-	if (flow == eCapture && role == eMultimedia) {
+    if ( flow == eCapture && role == eMultimedia )
-		if (audioDeviceEnumerator) {
+    {
-			auto device = getDevice(audioDeviceEnumerator, pwstrDefaultDeviceId);
+        if ( audioDeviceEnumerator )
-			if (device != micAudioDevice) {
+        {
-				if (micAudioDevice) {
+            auto device
+                = getDevice( audioDeviceEnumerator, pwstrDefaultDeviceId );
+            if ( device != micAudioDevice )
+            {
+                if ( micAudioDevice )
+                {
                     micAudioDevice->Release();
                 }
                 micAudioDevice = device;
-				if (micAudioDevice) {
+                if ( micAudioDevice )
-					micAudioEndpointVolume = getAudioEndpointVolume(micAudioDevice);
+                {
-				} else {
+                    micAudioEndpointVolume
-					std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+                        = getAudioEndpointVolume( micAudioDevice );
-					std::string name = converter.to_bytes(pwstrDefaultDeviceId);
+                }
-					LOG(WARNING) << "Could not find recording device \"" << name << "\".";
+                else
+                {
+                    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>
+                        converter;
+                    std::string name
+                        = converter.to_bytes( pwstrDefaultDeviceId );
+                    LOG( WARNING ) << "Could not find recording device \""
+                                   << name << "\".";
                 }
                 controller->onNewRecordingDevice();
             }
         }
-	} else if (flow == eRender && role == eMultimedia) {
+    }
-		if (audioDeviceEnumerator) {
+    else if ( flow == eRender && role == eMultimedia )
-			auto device = getDevice(audioDeviceEnumerator, pwstrDefaultDeviceId);
+    {
-			if (device != playbackAudioDevice) {
+        if ( audioDeviceEnumerator )
-				if (playbackAudioDevice) {
+        {
+            auto device
+                = getDevice( audioDeviceEnumerator, pwstrDefaultDeviceId );
+            if ( device != playbackAudioDevice )
+            {
+                if ( playbackAudioDevice )
+                {
                     playbackAudioDevice->Release();
                 }
                 playbackAudioDevice = device;
-				if (!playbackAudioDevice) {
+                if ( !playbackAudioDevice )
-					std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+                {
-					std::string name = converter.to_bytes(pwstrDefaultDeviceId);
+                    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>
-					LOG(WARNING) << "Could not find playback device \"" << name << "\".";
+                        converter;
+                    std::string name
+                        = converter.to_bytes( pwstrDefaultDeviceId );
+                    LOG( WARNING )
+                        << "Could not find playback device \"" << name << "\".";
                 }
                 controller->onNewPlaybackDevice();
             }
@@ -474,13 +671,15 @@ HRESULT AudioManagerWindows::OnDefaultDeviceChanged(EDataFlow flow, ERole role,
 
     std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
     std::string name = converter.to_bytes(pwstrDefaultDeviceId);
-	printf(" %s -->New default device: flow = %s, role = %s\n", name.c_str(), pszFlow, pszRole);
+    printf(" %s -->New default device: flow = %s, role = %s\n", name.c_str(),
-	fflush(stdout);*/
+    pszFlow, pszRole); fflush(stdout);*/
     return S_OK;
 }
 
-HRESULT AudioManagerWindows::OnPropertyValueChanged(LPCWSTR, const PROPERTYKEY) {
+HRESULT AudioManagerWindows::OnPropertyValueChanged( LPCWSTR,
+                                                     const PROPERTYKEY )
+{
     return S_OK;
 }
 
-}
+} // namespace advsettings

src/tabcontrollers/audiomanager/AudioManagerWindows.h

@@ -8,12 +8,13 @@
 #include "IPolicyConfig.h"
 #include <mutex>
 
-
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
-class AudioManagerWindows : public AudioManager, IMMNotificationClient {
+class AudioManagerWindows : public AudioManager, IMMNotificationClient
+{
     friend class AudioNotificationClient;
+
 private:
     std::recursive_mutex _mutex;
     AudioTabController* controller = nullptr;
@@ -30,11 +31,13 @@ public:
 
     virtual void init( AudioTabController* controller ) override;
 
-	virtual void setPlaybackDevice(const std::string& id, bool notify = true) override;
+    virtual void setPlaybackDevice( const std::string& id,
+                                    bool notify = true ) override;
     virtual std::string getPlaybackDevName() override;
     virtual std::string getPlaybackDevId() override;
 
-	virtual void setMirrorDevice(const std::string& id, bool notify = true) override;
+    virtual void setMirrorDevice( const std::string& id,
+                                  bool notify = true ) override;
     virtual bool isMirrorValid() override;
     virtual std::string getMirrorDevName() override;
     virtual std::string getMirrorDevId() override;
@@ -44,7 +47,8 @@ public:
     virtual bool setMirrorMuted( bool value ) override;
 
     virtual bool isMicValid() override;
-	virtual void setMicDevice(const std::string& id, bool notify = true) override;
+    virtual void setMicDevice( const std::string& id,
+                               bool notify = true ) override;
     virtual std::string getMicDevName() override;
     virtual std::string getMicDevId() override;
     virtual float getMicVolume() override;
@@ -52,8 +56,10 @@ public:
     virtual bool getMicMuted() override;
     virtual bool setMicMuted( bool value ) override;
 
-	virtual std::vector<std::pair<std::string, std::string>> getRecordingDevices() override;
+    virtual std::vector<std::pair<std::string, std::string>>
-	virtual std::vector<std::pair<std::string, std::string>> getPlaybackDevices() override;
+        getRecordingDevices() override;
+    virtual std::vector<std::pair<std::string, std::string>>
+        getPlaybackDevices() override;
 
     void deleteMirrorDevice();
 
@@ -61,24 +67,32 @@ public:
     virtual HRESULT QueryInterface( REFIID riid, void** ppvObject ) override;
     virtual ULONG AddRef( void ) override;
     virtual ULONG Release( void ) override;
-	virtual HRESULT OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState) override;
+    virtual HRESULT OnDeviceStateChanged( LPCWSTR pwstrDeviceId,
+                                          DWORD dwNewState ) override;
     virtual HRESULT OnDeviceAdded( LPCWSTR pwstrDeviceId ) override;
     virtual HRESULT OnDeviceRemoved( LPCWSTR pwstrDeviceId ) override;
-	virtual HRESULT OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDefaultDeviceId) override;
+    virtual HRESULT
-	virtual HRESULT OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key) override;
+        OnDefaultDeviceChanged( EDataFlow flow,
+                                ERole role,
+                                LPCWSTR pwstrDefaultDeviceId ) override;
+    virtual HRESULT OnPropertyValueChanged( LPCWSTR pwstrDeviceId,
+                                            const PROPERTYKEY key ) override;
 
 private:
     IMMDeviceEnumerator* getAudioDeviceEnumerator();
     IPolicyConfig* getPolicyConfig();
-	IMMDevice* getDefaultRecordingDevice(IMMDeviceEnumerator* deviceEnumerator);
+    IMMDevice*
-	IMMDevice* getDefaultPlaybackDevice(IMMDeviceEnumerator* deviceEnumerator);
+        getDefaultRecordingDevice( IMMDeviceEnumerator* deviceEnumerator );
-	IMMDevice* getDevice(IMMDeviceEnumerator* deviceEnumerator, const std::string& id);
+    IMMDevice*
+        getDefaultPlaybackDevice( IMMDeviceEnumerator* deviceEnumerator );
+    IMMDevice* getDevice( IMMDeviceEnumerator* deviceEnumerator,
+                          const std::string& id );
     IMMDevice* getDevice( IMMDeviceEnumerator* deviceEnumerator, LPCWSTR id );
     IAudioEndpointVolume* getAudioEndpointVolume( IMMDevice* device );
     std::string getDeviceName( IMMDevice* device );
     std::string getDeviceId( IMMDevice* device );
-	std::vector<std::pair<std::string, std::string>> getDevices(IMMDeviceEnumerator* deviceEnumerator, EDataFlow dataFlow);
+    std::vector<std::pair<std::string, std::string>>
+        getDevices( IMMDeviceEnumerator* deviceEnumerator, EDataFlow dataFlow );
 };
 
-}
+} // namespace advsettings
-

src/tabcontrollers/audiomanager/IPolicyConfig.h

@@ -5,90 +5,66 @@
 // @author EreTIk
 // ----------------------------------------------------------------------------
 
-
 #pragma once
 
 // ca286fc3-91fd-42c3-8e9b-caafa66242e3
-static const GUID IID_IPolicyConfig2        = { 0xCA286FC3, 0x91FD, 0x42C3, { 0x8E, 0x9B, 0xCA, 0xAF, 0xA6, 0x62, 0x42, 0xE3 } };
+static const GUID IID_IPolicyConfig2
+    = { 0xCA286FC3,
+        0x91FD,
+        0x42C3,
+        { 0x8E, 0x9B, 0xCA, 0xAF, 0xA6, 0x62, 0x42, 0xE3 } };
 
 // 6be54be8-a068-4875-a49d-0c2966473b11
-static const GUID IID_IPolicyConfig1        = { 0x6BE54BE8, 0xA068, 0x4875, { 0xA4, 0x9D, 0x0C, 0x29, 0x66, 0x47, 0x3B, 0x11 } };
+static const GUID IID_IPolicyConfig1
+    = { 0x6BE54BE8,
+        0xA068,
+        0x4875,
+        { 0xA4, 0x9D, 0x0C, 0x29, 0x66, 0x47, 0x3B, 0x11 } };
 
 // f8679f50-850a-41cf-9c72-430f290290c8
-static const GUID IID_IPolicyConfig0        = { 0xF8679F50, 0x850A, 0x41CF, { 0x9C, 0x72, 0x43, 0x0F, 0x29, 0x02, 0x90, 0xC8 } };
+static const GUID IID_IPolicyConfig0
+    = { 0xF8679F50,
+        0x850A,
+        0x41CF,
+        { 0x9C, 0x72, 0x43, 0x0F, 0x29, 0x02, 0x90, 0xC8 } };
 
-class DECLSPEC_UUID("870af99c-171d-4f9e-af0d-e63df40c2bc9") CPolicyConfigClient;
+class DECLSPEC_UUID( "870af99c-171d-4f9e-af0d-e63df40c2bc9" )
+    CPolicyConfigClient;
 
 interface IPolicyConfig : public IUnknown
 {
 public:
-
+    virtual HRESULT GetMixFormat( PCWSTR, WAVEFORMATEX** );
-    virtual HRESULT GetMixFormat(
-        PCWSTR,
-        WAVEFORMATEX **
-    );
 
     virtual HRESULT STDMETHODCALLTYPE GetDeviceFormat(
-        PCWSTR,
+        PCWSTR, INT, WAVEFORMATEX** );
-        INT,
-        WAVEFORMATEX **
-    );
 
-    virtual HRESULT STDMETHODCALLTYPE ResetDeviceFormat(
+    virtual HRESULT STDMETHODCALLTYPE ResetDeviceFormat( PCWSTR );
-        PCWSTR
-    );
 
     virtual HRESULT STDMETHODCALLTYPE SetDeviceFormat(
-        PCWSTR,
+        PCWSTR, WAVEFORMATEX*, WAVEFORMATEX* );
-        WAVEFORMATEX *,
-        WAVEFORMATEX *
-    );
 
     virtual HRESULT STDMETHODCALLTYPE GetProcessingPeriod(
-        PCWSTR,
+        PCWSTR, INT, PINT64, PINT64 );
-        INT,
-        PINT64,
-        PINT64
-    );
 
-    virtual HRESULT STDMETHODCALLTYPE SetProcessingPeriod(
+    virtual HRESULT STDMETHODCALLTYPE SetProcessingPeriod( PCWSTR, PINT64 );
-        PCWSTR,
-        PINT64
-    );
 
-    virtual HRESULT STDMETHODCALLTYPE GetShareMode(
+    virtual HRESULT STDMETHODCALLTYPE GetShareMode( PCWSTR,
-        PCWSTR,
+                                                    struct DeviceShareMode* );
-        struct DeviceShareMode *
-    );
 
-    virtual HRESULT STDMETHODCALLTYPE SetShareMode(
+    virtual HRESULT STDMETHODCALLTYPE SetShareMode( PCWSTR,
-        PCWSTR,
+                                                    struct DeviceShareMode* );
-        struct DeviceShareMode *
-    );
 
     virtual HRESULT STDMETHODCALLTYPE GetPropertyValue(
-        PCWSTR,
+        PCWSTR, int, const PROPERTYKEY&, const PROPVARIANT* );
-        int,
-        const PROPERTYKEY &,
-        const PROPVARIANT *
-    );
 
     virtual HRESULT STDMETHODCALLTYPE SetPropertyValue(
-        PCWSTR,
+        PCWSTR, int, const PROPERTYKEY&, const PROPVARIANT* );
-        int,
-        const PROPERTYKEY &,
-        const PROPVARIANT *
-    );
 
     virtual HRESULT STDMETHODCALLTYPE SetDefaultEndpoint(
-        __in PCWSTR wszDeviceId,
+        __in PCWSTR wszDeviceId, __in ERole eRole );
-        __in ERole eRole 
-    );
 
-    virtual HRESULT STDMETHODCALLTYPE SetEndpointVisibility(
+    virtual HRESULT STDMETHODCALLTYPE SetEndpointVisibility( PCWSTR, INT );
-        PCWSTR,
-        INT
-    );
 };
 
 interface DECLSPEC_UUID( "568b9108-44bf-40b4-9006-86afe5b5a620" )
@@ -111,67 +87,47 @@ CPolicyConfigVistaClient;
 interface IPolicyConfigVista : public IUnknown
 {
 public:
-
     virtual HRESULT GetMixFormat(
         PCWSTR,
-        WAVEFORMATEX **
+        WAVEFORMATEX** ); // not available on Windows 7, use method from
-    );  // not available on Windows 7, use method from IPolicyConfig
+                          // IPolicyConfig
 
     virtual HRESULT STDMETHODCALLTYPE GetDeviceFormat(
-        PCWSTR,
+        PCWSTR, INT, WAVEFORMATEX** );
-        INT,
-        WAVEFORMATEX **
-    );
 
     virtual HRESULT STDMETHODCALLTYPE SetDeviceFormat(
-        PCWSTR,
+        PCWSTR, WAVEFORMATEX*, WAVEFORMATEX* );
-        WAVEFORMATEX *,
-        WAVEFORMATEX *
-    );
 
     virtual HRESULT STDMETHODCALLTYPE GetProcessingPeriod(
         PCWSTR,
         INT,
         PINT64,
-        PINT64
+        PINT64 ); // not available on Windows 7, use method from IPolicyConfig
-    );  // not available on Windows 7, use method from IPolicyConfig
 
     virtual HRESULT STDMETHODCALLTYPE SetProcessingPeriod(
         PCWSTR,
-        PINT64
+        PINT64 ); // not available on Windows 7, use method from IPolicyConfig
-    );  // not available on Windows 7, use method from IPolicyConfig
 
     virtual HRESULT STDMETHODCALLTYPE GetShareMode(
         PCWSTR,
-        struct DeviceShareMode *
+        struct DeviceShareMode* ); // not available on Windows 7, use method
-    );  // not available on Windows 7, use method from IPolicyConfig
+                                   // from IPolicyConfig
 
     virtual HRESULT STDMETHODCALLTYPE SetShareMode(
         PCWSTR,
-        struct DeviceShareMode *
+        struct DeviceShareMode* ); // not available on Windows 7, use method
-    );  // not available on Windows 7, use method from IPolicyConfig
+                                   // from IPolicyConfig
 
     virtual HRESULT STDMETHODCALLTYPE GetPropertyValue(
-        PCWSTR,
+        PCWSTR, int, const PROPERTYKEY&, const PROPVARIANT* );
-        int,
-        const PROPERTYKEY &,
-        const PROPVARIANT *
-    );
 
     virtual HRESULT STDMETHODCALLTYPE SetPropertyValue(
-        PCWSTR,
+        PCWSTR, int, const PROPERTYKEY&, const PROPVARIANT* );
-        int,
-        const PROPERTYKEY &,
-        const PROPVARIANT *
-    );
 
     virtual HRESULT STDMETHODCALLTYPE SetDefaultEndpoint(
-        __in PCWSTR wszDeviceId,
+        __in PCWSTR wszDeviceId, __in ERole eRole );
-        __in ERole eRole 
-    );
 
     virtual HRESULT STDMETHODCALLTYPE SetEndpointVisibility(
         PCWSTR,
-        INT
+        INT ); // not available on Windows 7, use method from IPolicyConfig
-    );  // not available on Windows 7, use method from IPolicyConfig
 };

src/tabcontrollers/keyboardinput/KeyboardInputDummy.cpp

@@ -1,11 +1,11 @@
 #include "KeyboardInputDummy.h"
 
-// Used to get the compiler to shut up about C4100: unreferenced formal parameter.
+// Used to get the compiler to shut up about C4100: unreferenced formal
-// The cast is to get GCC to shut up about it.
+// parameter. The cast is to get GCC to shut up about it.
 #define UNREFERENCED_PARAMETER( P ) static_cast<void>( ( P ) )
 
-namespace advsettings {
+namespace advsettings
-
+{
 void KeyboardInputDummy::sendKeyboardInput( QString input )
 {
     // noop
@@ -28,4 +28,4 @@ void KeyboardInputDummy::sendKeyboardAltTab()
     // noop
 }
 
-}
+} // namespace advsettings

src/tabcontrollers/keyboardinput/KeyboardInputDummy.h

@@ -4,8 +4,8 @@
 #include "../KeyboardInput.h"
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 class KeyboardInputDummy : public KeyboardInput
 {
 public:
@@ -15,6 +15,6 @@ public:
     virtual void sendKeyboardAltTab() override;
 };
 
-}
+} // namespace advsettings
 
 #endif // KEYBOARDINPUTDUMMY_H

src/tabcontrollers/keyboardinput/KeyboardInputWindows.cpp

@@ -2,14 +2,18 @@
 #include <Windows.h>
 #include "../../logging.h"
 
-namespace advsettings {
+namespace advsettings
-
+{
-void fillKiStruct(INPUT& ip, WORD scanCode, bool keyup) {
+void fillKiStruct( INPUT& ip, WORD scanCode, bool keyup )
+{
     ip.type = INPUT_KEYBOARD;
     ip.ki.wVk = scanCode;
-    if (keyup) {
+    if ( keyup )
+    {
         ip.ki.dwFlags = KEYEVENTF_KEYUP;
-    } else {
+    }
+    else
+    {
         ip.ki.dwFlags = 0;
     }
     ip.ki.wScan = 0;
@@ -17,19 +21,30 @@ void fillKiStruct(INPUT& ip, WORD scanCode, bool keyup) {
     ip.ki.time = 0;
 };
 
-void sendKeyboardInputRaw(int inputCount, LPINPUT input) {
+void sendKeyboardInputRaw( int inputCount, LPINPUT input )
-    if ((inputCount > 0) && !SendInput(static_cast<UINT>(inputCount), input, sizeof(INPUT))) {
+{
+    if ( ( inputCount > 0 )
+         && !SendInput(
+                static_cast<UINT>( inputCount ), input, sizeof( INPUT ) ) )
+    {
         char* err;
         auto errCode = GetLastError();
-        if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+        if ( !FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
+                                 | FORMAT_MESSAGE_FROM_SYSTEM,
                              nullptr,
                              errCode,
-                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // default language
+                             MAKELANGID( LANG_NEUTRAL,
+                                         SUBLANG_DEFAULT ), // default language
                              reinterpret_cast<LPTSTR>( &err ),
                              0,
-                nullptr)){
+                             nullptr ) )
-            LOG(ERROR) << "Error calling SendInput(): Could not get error message (" << errCode << ")";
+        {
-        } else {
+            LOG( ERROR )
+                << "Error calling SendInput(): Could not get error message ("
+                << errCode << ")";
+        }
+        else
+        {
             LOG( ERROR ) << "Error calling SendInput(): " << err;
         }
     }
@@ -38,52 +53,66 @@ void sendKeyboardInputRaw(int inputCount, LPINPUT input) {
 void KeyboardInputWindows::sendKeyboardInput( QString input )
 {
     int len = input.length();
-    if (len > 0) {
+    if ( len > 0 )
+    {
         LPINPUT ips = new INPUT[static_cast<unsigned int>( len ) * 5 + 3];
         int ii = 0;
         bool shiftPressed = false;
         bool ctrlPressed = false;
         bool altPressed = false;
-        for (int i = 0; i < len; i++) {
+        for ( int i = 0; i < len; i++ )
+        {
             short tmp = VkKeyScan( input.at( i ).toLatin1() );
             WORD c = tmp & 0xFF;
             short shiftState = tmp >> 8;
             bool isShift = shiftState & 1;
             bool isCtrl = shiftState & 2;
             bool isAlt = shiftState & 4;
-            if (isShift && !shiftPressed) {
+            if ( isShift && !shiftPressed )
+            {
                 fillKiStruct( ips[ii++], VK_SHIFT, false );
                 shiftPressed = true;
-            } else if (!isShift && shiftPressed) {
+            }
+            else if ( !isShift && shiftPressed )
+            {
                 fillKiStruct( ips[ii++], VK_SHIFT, true );
                 shiftPressed = false;
             }
-            if (isCtrl && !ctrlPressed) {
+            if ( isCtrl && !ctrlPressed )
+            {
                 fillKiStruct( ips[ii++], VK_CONTROL, false );
                 ctrlPressed = true;
-            } else if (!isCtrl && ctrlPressed) {
+            }
+            else if ( !isCtrl && ctrlPressed )
+            {
                 fillKiStruct( ips[ii++], VK_CONTROL, true );
                 ctrlPressed = false;
             }
-            if (isAlt && !altPressed) {
+            if ( isAlt && !altPressed )
+            {
                 fillKiStruct( ips[ii++], VK_MENU, false );
                 altPressed = true;
-            } else if (!isAlt && altPressed) {
+            }
+            else if ( !isAlt && altPressed )
+            {
                 fillKiStruct( ips[ii++], VK_MENU, true );
                 altPressed = false;
             }
             fillKiStruct( ips[ii++], c, false );
             fillKiStruct( ips[ii++], c, true );
         }
-        if (shiftPressed) {
+        if ( shiftPressed )
+        {
             fillKiStruct( ips[ii++], VK_SHIFT, true );
             shiftPressed = false;
         }
-        if (ctrlPressed) {
+        if ( ctrlPressed )
+        {
             fillKiStruct( ips[ii++], VK_CONTROL, true );
             ctrlPressed = false;
         }
-        if (altPressed) {
+        if ( altPressed )
+        {
             fillKiStruct( ips[ii++], VK_MENU, true );
             altPressed = false;
         }
@@ -105,10 +134,12 @@ void KeyboardInputWindows::sendKeyboardEnter()
 
 void KeyboardInputWindows::sendKeyboardBackspace( int count )
 {
-    if (count > 0) {
+    if ( count > 0 )
+    {
         // We ensure that count is nonnegative, therefore safe cast.
         LPINPUT ips = new INPUT[static_cast<unsigned int>( count ) * 2];
-        for (int i = 0; i < count; i++) {
+        for ( int i = 0; i < count; i++ )
+        {
             fillKiStruct( ips[2 * i], VK_BACK, false );
             fillKiStruct( ips[2 * i + 1], VK_BACK, true );
         }
@@ -131,4 +162,4 @@ void KeyboardInputWindows::sendKeyboardAltTab()
     delete[] ips;
 }
 
-}
+} // namespace advsettings

src/tabcontrollers/keyboardinput/KeyboardInputWindows.h

@@ -4,8 +4,8 @@
 #include "../KeyboardInput.h"
 
 // application namespace
-namespace advsettings {
+namespace advsettings
-
+{
 class KeyboardInputWindows : public KeyboardInput
 {
 public:
@@ -15,6 +15,6 @@ public:
     virtual void sendKeyboardAltTab() override;
 };
 
-}
+} // namespace advsettings
 
 #endif // KEYBOARDINPUTWINDOWS_H

src/utils/ChaperoneUtils.cpp

@@ -2,49 +2,63 @@
 #include <iostream>
 #include <cmath>
 
-namespace utils {
+namespace utils
-
+{
-
+float ChaperoneUtils::_getDistanceToChaperone(
-float ChaperoneUtils::_getDistanceToChaperone(const vr::HmdVector3_t & x, vr::HmdVector3_t * projectedPoint) {
+    const vr::HmdVector3_t& x,
+    vr::HmdVector3_t* projectedPoint )
+{
     float distance = NAN;
     vr::HmdVector3_t* _cornersPtr = _corners.get();
-	for (uint32_t i = 0; i < _quadsCount; i++) {
+    for ( uint32_t i = 0; i < _quadsCount; i++ )
+    {
         uint32_t i2 = ( i + 1 ) % _quadsCount;
         vr::HmdVector3_t& r0 = _cornersPtr[i];
         vr::HmdVector3_t& r1 = _cornersPtr[i2];
         float u_x = r1.v[0] - r0.v[0];
         float u_z = r1.v[2] - r0.v[2];
-		float r = ((x.v[0] - r0.v[0]) * u_x + (x.v[2] - r0.v[2]) * u_z) / (u_x*u_x + u_z*u_z);
+        float r = ( ( x.v[0] - r0.v[0] ) * u_x + ( x.v[2] - r0.v[2] ) * u_z )
-		//int mode = 0; // 0 .. projected point on segment, 1 .. projected point outside of segment (r0 closer than r1), 2 .. projected point outside of segment (r1 closer than r0)
+                  / ( u_x * u_x + u_z * u_z );
+        // int mode = 0; // 0 .. projected point on segment, 1 .. projected
+        // point outside of segment (r0 closer than r1), 2 .. projected point
+        // outside of segment (r1 closer than r0)
         float d;
         float x1_x;
         float x1_z;
-		if (r < 0.0f || r > 1.0f) { // projected point outside of segment
+        if ( r < 0.0f || r > 1.0f )
+        { // projected point outside of segment
             float d_x = r0.v[0] - x.v[0];
             float d_z = r0.v[2] - x.v[2];
             float d1 = sqrt( d_x * d_x + d_z * d_z );
             d_x = r1.v[0] - x.v[0];
             d_z = r1.v[2] - x.v[2];
             float d2 = sqrt( d_x * d_x + d_z * d_z );
-			if (d1 < d2) {
+            if ( d1 < d2 )
+            {
                 d = d1;
                 x1_x = r0.v[0];
                 x1_z = r0.v[2];
-			} else {
+            }
+            else
+            {
                 d = d2;
                 x1_x = r1.v[0];
                 x1_z = r1.v[2];
             }
-		} else { // projected point on segment
+        }
+        else
+        { // projected point on segment
             x1_x = r0.v[0] + r * u_x;
             x1_z = r0.v[2] + r * u_z;
             float d_x = x1_x - x.v[0];
             float d_z = x1_z - x.v[2];
             d = sqrt( d_x * d_x + d_z * d_z );
         }
-		if (std::isnan(distance) || d < distance) {
+        if ( std::isnan( distance ) || d < distance )
+        {
             distance = d;
-			if (projectedPoint) {
+            if ( projectedPoint )
+            {
                 projectedPoint->v[0] = x1_x;
                 projectedPoint->v[1] = x.v[1];
                 projectedPoint->v[2] = x1_z;
@@ -54,28 +68,35 @@ float ChaperoneUtils::_getDistanceToChaperone(const vr::HmdVector3_t & x, vr::Hm
     return distance;
 }
 
-
+void ChaperoneUtils::loadChaperoneData()
-void ChaperoneUtils::loadChaperoneData() {
+{
     std::lock_guard<std::recursive_mutex> lock( _mutex );
     vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo( nullptr, &_quadsCount );
-	if (_quadsCount > 0) {
+    if ( _quadsCount > 0 )
-		std::unique_ptr<vr::HmdQuad_t> quadsBuffer(new vr::HmdQuad_t[_quadsCount]);
+    {
+        std::unique_ptr<vr::HmdQuad_t> quadsBuffer(
+            new vr::HmdQuad_t[_quadsCount] );
         vr::HmdQuad_t* quadsBufferPtr = quadsBuffer.get();
         _corners.reset( ( vr::HmdVector3_t* ) new vr::HmdQuad_t[_quadsCount] );
         vr::HmdVector3_t* _cornersPtr = _corners.get();
-		vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo(quadsBufferPtr, &_quadsCount);
+        vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo( quadsBufferPtr,
-		for (uint32_t i = 0; i < _quadsCount; i++) {
+                                                            &_quadsCount );
+        for ( uint32_t i = 0; i < _quadsCount; i++ )
+        {
             _cornersPtr[i] = quadsBufferPtr[i].vCorners[0];
             uint32_t i2 = ( i + 1 ) % _quadsCount;
-			if (quadsBufferPtr[i].vCorners[3].v[0] != quadsBufferPtr[i2].vCorners[0].v[0]
+            if ( quadsBufferPtr[i].vCorners[3].v[0]
-					|| quadsBufferPtr[i].vCorners[3].v[1] != quadsBufferPtr[i2].vCorners[0].v[1]
+                     != quadsBufferPtr[i2].vCorners[0].v[0]
-					|| quadsBufferPtr[i].vCorners[3].v[2] != quadsBufferPtr[i2].vCorners[0].v[2]
+                 || quadsBufferPtr[i].vCorners[3].v[1]
-					|| quadsBufferPtr[i].vCorners[0].v[1] != 0.0f) {
+                        != quadsBufferPtr[i2].vCorners[0].v[1]
+                 || quadsBufferPtr[i].vCorners[3].v[2]
+                        != quadsBufferPtr[i2].vCorners[0].v[2]
+                 || quadsBufferPtr[i].vCorners[0].v[1] != 0.0f )
+            {
                 _chaperoneWellFormed = false;
             }
         }
     }
 }
 
-
 } // end namespace utils

src/utils/ChaperoneUtils.h

@@ -4,35 +4,50 @@
 #include <mutex>
 #include <openvr.h>
 
-namespace utils {
+namespace utils
-
+{
-class ChaperoneUtils {
+class ChaperoneUtils
+{
 private:
     std::recursive_mutex _mutex;
     uint32_t _quadsCount = 0;
     std::unique_ptr<vr::HmdVector3_t> _corners;
     bool _chaperoneWellFormed = true;
 
-	float _getDistanceToChaperone(const vr::HmdVector3_t& point, vr::HmdVector3_t* projectedPoint);
+    float _getDistanceToChaperone( const vr::HmdVector3_t& point,
+                                   vr::HmdVector3_t* projectedPoint );
 
 public:
-	uint32_t quadsCount() const noexcept { return _quadsCount; }
+    uint32_t quadsCount() const noexcept
-	bool isChaperoneWellFormed() const noexcept { return _chaperoneWellFormed; }
+    {
+        return _quadsCount;
+    }
+    bool isChaperoneWellFormed() const noexcept
+    {
+        return _chaperoneWellFormed;
+    }
 
-	std::recursive_mutex& mutex() noexcept { return _mutex; }
+    std::recursive_mutex& mutex() noexcept
+    {
+        return _mutex;
+    }
 
     void loadChaperoneData();
 
-	float getDistanceToChaperone(const vr::HmdVector3_t& point, vr::HmdVector3_t* projectedPoint = nullptr, bool doLock = false) {
+    float getDistanceToChaperone( const vr::HmdVector3_t& point,
-		if (doLock) {
+                                  vr::HmdVector3_t* projectedPoint = nullptr,
+                                  bool doLock = false )
+    {
+        if ( doLock )
+        {
             std::lock_guard<std::recursive_mutex> lock( _mutex );
             return _getDistanceToChaperone( point, projectedPoint );
-		} else {
+        }
+        else
+        {
             return _getDistanceToChaperone( point, projectedPoint );
         }
     }
 };
 
-
 } // end namespace utils
-

src/utils/Matrix.h

@@ -3,11 +3,14 @@
 #include <openvr.h>
 #include <cmath>
 
-
+namespace utils
-namespace utils {
+{
-
+inline vr::HmdMatrix34_t& initRotationMatrix( vr::HmdMatrix34_t& matrix,
-inline vr::HmdMatrix34_t& initRotationMatrix(vr::HmdMatrix34_t& matrix, unsigned axisId, float angle) {
+                                              unsigned axisId,
-	switch (axisId) {
+                                              float angle )
+{
+    switch ( axisId )
+    {
     case 0: // x-axis
         matrix.m[0][0] = 1.0f;
         matrix.m[0][1] = 0.0f;
@@ -56,12 +59,17 @@ inline vr::HmdMatrix34_t& initRotationMatrix(vr::HmdMatrix34_t& matrix, unsigned
     return matrix;
 }
 
-
+inline vr::HmdMatrix34_t& matMul33( vr::HmdMatrix34_t& result,
-inline vr::HmdMatrix34_t& matMul33(vr::HmdMatrix34_t& result, const vr::HmdMatrix34_t& a, const vr::HmdMatrix34_t& b) {
+                                    const vr::HmdMatrix34_t& a,
-	for (unsigned i = 0; i < 3; i++) {
+                                    const vr::HmdMatrix34_t& b )
-		for (unsigned j = 0; j < 3; j++) {
+{
+    for ( unsigned i = 0; i < 3; i++ )
+    {
+        for ( unsigned j = 0; j < 3; j++ )
+        {
             result.m[i][j] = 0.0f;
-			for (unsigned k = 0; k < 3; k++) {
+            for ( unsigned k = 0; k < 3; k++ )
+            {
                 result.m[i][j] += a.m[i][k] * b.m[k][j];
             }
         }
@@ -69,29 +77,34 @@ inline vr::HmdMatrix34_t& matMul33(vr::HmdMatrix34_t& result, const vr::HmdMatri
     return result;
 }
 
-
+inline vr::HmdVector3_t& matMul33( vr::HmdVector3_t& result,
-inline vr::HmdVector3_t& matMul33(vr::HmdVector3_t& result, const vr::HmdMatrix34_t& a, const vr::HmdVector3_t& b) {
+                                   const vr::HmdMatrix34_t& a,
-	for (unsigned i = 0; i < 3; i++) {
+                                   const vr::HmdVector3_t& b )
+{
+    for ( unsigned i = 0; i < 3; i++ )
+    {
         result.v[i] = 0.0f;
-		for (unsigned k = 0; k < 3; k++) {
+        for ( unsigned k = 0; k < 3; k++ )
+        {
             result.v[i] += a.m[i][k] * b.v[k];
         };
     }
     return result;
 }
 
-
+inline vr::HmdVector3_t& matMul33( vr::HmdVector3_t& result,
-inline vr::HmdVector3_t& matMul33(vr::HmdVector3_t& result, const vr::HmdVector3_t& a, const vr::HmdMatrix34_t& b) {
+                                   const vr::HmdVector3_t& a,
-	for (unsigned i = 0; i < 3; i++) {
+                                   const vr::HmdMatrix34_t& b )
+{
+    for ( unsigned i = 0; i < 3; i++ )
+    {
         result.v[i] = 0.0f;
-		for (unsigned k = 0; k < 3; k++) {
+        for ( unsigned k = 0; k < 3; k++ )
+        {
             result.v[i] += a.v[k] * b.m[k][i];
         };
     }
     return result;
 }
 
-
-
 } // end namespace utils
-