Fix Tor v3 onion address checksum: SHA-256 -> SHA3-256

The Tor v3 spec requires SHA3-256 (FIPS-202) for the .onion address
checksum computation, but ToStringIP() was using SHA-256 (double-hash).
This caused every reconstructed .onion address to have incorrect suffix
characters, making all outbound Tor connections fail with SOCKS5 'general
failure' - the entire network had 0 Tor peers despite working Tor instances.

Fix: Replace Hash() call with OpenSSL EVP_sha3_256() which is available
in OpenSSL 3.0+ and produces the correct FIPS-202 SHA3-256 checksum.

Tested: All 5 onion seed nodes now connect successfully.

.claude/settings.json

@@ -1,7 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"ls /mingw64/lib/libboost_system* 2>/dev/null\")"
+      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"ls /mingw64/lib/libboost_system* 2>/dev/null\")",
+      "Bash(git tag:*)"
     ],
     "additionalDirectories": [
       "C:\\msys64\\mingw64\\bin"

.claude/settings.local.json

@@ -73,7 +73,99 @@
       "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" /e/repos/triangles/scan_chain_tip.exe:*)",
       "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" /c/msys64/mingw64/bin/qmake.exe:*)",
       "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" qmake-qt5:*)",
-      "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" mingw32-make:*)"
+      "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" mingw32-make:*)",
+      "Bash(export PATH=\"/c/msys64/mingw64/bin:$PATH\")",
+      "Bash(\"C:/msys64/mingw64/bin/qmake-qt5.exe\" triangles-qt.pro -o Makefile)",
+      "Bash(gh release create:*)",
+      "Bash(gh repo view:*)",
+      "Bash(gh repo create:*)",
+      "Bash(git commit:*)",
+      "Bash(git branch:*)",
+      "Bash(git push:*)",
+      "Bash(gh repo fork:*)",
+      "Bash(gh api:*)",
+      "Bash(gh auth:*)",
+      "Bash(1 <<'EOF'\n{\"visibility\":\"public\"}\nEOF)",
+      "Bash(findstr:*)",
+      "Bash(gh workflow run:*)",
+      "Bash(gh run watch:*)",
+      "Bash(gh run view:*)",
+      "Bash(gh release view:*)",
+      "Bash(gh run download:*)",
+      "Bash(gh release upload:*)",
+      "Bash(gh release delete-asset:*)",
+      "Bash(C:/msys64/mingw64/bin/mingw32-make.exe:*)",
+      "Bash(C:/msys64/usr/bin/env.exe MSYSTEM=MINGW64 PATH=\"/mingw64/bin:/usr/bin:/bin\" /usr/bin/bash -lc \"cd /e/repos/triangles/src && mingw32-make -f makefile.mingw -j8 all 2>&1 | tail -60\")",
+      "Bash(C:/msys64/usr/bin/env.exe MSYSTEM=MINGW64 /usr/bin/bash -lc \"ls /mingw64/lib/libboost_system*\")",
+      "Bash(C:/msys64/usr/bin/env.exe MSYSTEM=MINGW64 PATH=\"/mingw64/bin:/usr/bin:/bin\" /usr/bin/bash -lc \"cd /e/repos/triangles/src && mingw32-make -f makefile.mingw trianglesd.exe 2>&1 | tail -20\")",
+      "Bash(C:/msys64/usr/bin/env.exe MSYSTEM=MINGW64 PATH=\"/mingw64/bin:/usr/bin:/bin\" /usr/bin/bash -lc \"cd /e/repos/triangles/src && mingw32-make -f makefile.mingw trianglesd.exe 2>&1 | tail -10\")",
+      "Bash(gh run list:*)",
+      "Bash(git rm:*)",
+      "Bash(wc:*)",
+      "Bash(C:/msys64/usr/bin/bash.exe -lc \"cd /e/repos/triangles/src && make -f makefile.mingw obj/rest.o 2>&1 | head -80\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -lc \"cd /e/repos/triangles/src && make -f makefile.mingw obj/trianglesrpc.o 2>&1 | tail -20\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -lc \"cd /e/repos/triangles/src && make -f makefile.mingw 2>&1 | tail -30\")",
+      "Bash(node --version:*)",
+      "Bash(npm --version:*)",
+      "Bash(npm install:*)",
+      "Bash(npx svelte-kit sync:*)",
+      "Bash(npx vite build)",
+      "Bash(nslookup:*)",
+      "Bash(tailscale ping:*)",
+      "Bash(del /f \"%APPDATA%\\\\triangles\\\\peers.dat\")",
+      "Bash(C:msys64usrbinbash.exe -l -c \"cd ''e:/repos/triangles'' && qmake triangles-qt.pro ''USE_QRCODE=1'' ''USE_UPNP=-'' 2>&1 | tail -20\")",
+      "Bash(C:msys64msys2_shell.cmd -mingw64 -defterm -no-start -c \"cd /e/repos/triangles && qmake triangles-qt.pro ''USE_QRCODE=1'' ''USE_UPNP=-'' 2>&1 | tail -20\")",
+      "Bash(\"C:\\\\msys64\\\\mingw64\\\\bin\\\\bash.exe\" -c \"export PATH=/mingw64/bin:/usr/bin:$PATH && cd /e/repos/triangles && qmake triangles-qt.pro ''USE_QRCODE=1'' ''USE_UPNP=-'' 2>&1\")",
+      "Bash(C:/msys64/mingw64/bin/qmake.exe:*)",
+      "Bash(/c/msys64/mingw64/bin/qmake-qt5.exe:*)",
+      "Bash(/c/msys64/usr/bin/env.exe MSYSTEM=MINGW64 /c/msys64/usr/bin/bash.exe -l -c \"cd /e/repos/triangles && qmake triangles-qt.pro ''USE_QRCODE=1'' ''USE_UPNP=-'' 2>&1 | tail -5\")",
+      "Bash(export PATH=\"/c/msys64/mingw64/bin:/c/msys64/usr/bin:$PATH\")",
+      "Bash(/c/msys64/usr/bin/env.exe MSYSTEM=MINGW64 /c/msys64/usr/bin/bash.exe:*)",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"cd /e/repos/triangles && make release 2>&1 | grep -E ''error|Error|undefined|cannot find'' | head -20\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"pacman -Qs qrencode\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"pacman -S --noconfirm mingw-w64-x86_64-qrencode\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"cd /e/repos/triangles && qmake-qt5 -o Makefile triangles-qt.pro USE_QRCODE=0 USE_UPNP=- 2>&1\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"ls /mingw64/lib/libqrencode*\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"pacman -S --noconfirm mingw-w64-x86_64-cmake\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"cd /tmp && pacman -Sp mingw-w64-x86_64-qrencode 2>/dev/null\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"cd /e/repos/triangles && mkdir -p dist && cp release/triangles-qt.exe dist/ && cd dist && strip triangles-qt.exe && ls -lh triangles-qt.exe\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"cd /e/repos/triangles/dist && ldd triangles-qt.exe | grep mingw64 | awk ''{print $3}''\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c 'cd /e/repos/triangles/dist && ldd triangles-qt.exe | grep mingw64 | awk \"\"{print \\\\$3}\"\"')",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"cd /e/repos/triangles/dist && ldd triangles-qt.exe | grep mingw64\")",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c 'cd /e/repos/triangles/dist && ldd triangles-qt.exe | grep mingw64 | sed \"\"s/.*=> //\"\" | sed \"\"s/ \\(.*//\"\"> dlls.txt && while read dll; do cp \"\"$dll\"\" .; done < dlls.txt && ls *.dll | wc -l && echo \"\"DLLs copied\"\"')",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c 'cd /e/repos/triangles/dist && mkdir -p platforms && cp /mingw64/share/qt5/plugins/platforms/qwindows.dll platforms/ && echo \"\"Qt platform plugin copied\"\"')",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c 'cd /e/repos/triangles && rm -f Triangles-v5.1.8-win-x64.zip && cd dist && 7z a ../Triangles-v5.1.8-win-x64.zip triangles-qt.exe *.dll platforms/ && echo \"\"ZIP created\"\"')",
+      "Bash(C:/msys64/usr/bin/bash.exe -l -c \"cd /e/repos/triangles && make -j4 2>&1 | tail -15\")",
+      "Bash(pacman:*)",
+      "Bash(tar:*)",
+      "WebFetch(domain:src-ref.docs.torproject.org)",
+      "WebFetch(domain:gitlab.torproject.org)",
+      "Bash(git status:*)",
+      "Bash(git stash:*)",
+      "Bash(git pull:*)",
+      "Bash(git stash pop:*)",
+      "Bash(find:*)",
+      "Read(//e/repos/triangles/**)",
+      "Bash(curl:*)",
+      "Bash(qmake:*)",
+      "Bash(/c/msys64/mingw64/bin/mingw32-make.exe:*)",
+      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"cd /e/repos/triangles && make -j1 2>&1 | tail -30\")",
+      "Bash(C:/msys64/msys2_shell.cmd -defterm -no-start -mingw64 -c \"cd /e/repos/triangles && rm -f build/main.o && mingw32-make -f Makefile.Release build/main.o 2>&1 | grep -E ''^\\(src/|.*error\\)'' | head -10\")",
+      "Bash(C:/msys64/msys2_shell.cmd -defterm -no-start -mingw64 -c \"cd /e/repos/triangles && ls -la build/main.o 2>&1\")",
+      "Bash(git -C \"e:\\\\repos\\\\triangles\" log --oneline -20)",
+      "Bash(git -C \"e:\\\\repos\\\\triangles\" describe --tags --abbrev=0)",
+      "Bash(git -C \"e:\\\\repos\\\\triangles\" rev-parse --short HEAD)",
+      "Bash(PATH=\"/c/msys64/mingw64/bin:$PATH\" which make:*)",
+      "Bash(export PATH=\"/mingw64/bin:$PATH\")",
+      "Bash(make:*)",
+      "Bash(C:/msys64/usr/bin/env.exe PATH=\"C:/msys64/mingw64/bin:C:/msys64/usr/bin\" C:/msys64/usr/bin/make.exe:*)",
+      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -c \"cd /e/repos/triangles && make -f Makefile.Release -j8 2>&1 | tail -40\")",
+      "Bash(C:/msys64/msys2_shell.cmd -mingw64 -defterm -no-start -here -c \"make 2>&1 | tail -10\")",
+      "Bash(gh pr list:*)",
+      "Bash(gh pr view:*)",
+      "Bash(cmd //C \"powershell -NoProfile -Command \"\"Get-Process | Where-Object { $_.Path -like ''*triangles*'' } | Format-Table Id, ProcessName, Path\"\"\")",
+      "Bash(cmd //C \"tasklist /FI \"\"IMAGENAME eq triangles-qt.exe\"\"\")",
+      "Bash(MSYS_NO_PATHCONV=1 tasklist:*)"
     ]
   }
 }

.github/workflows/build-all.yml

@@ -0,0 +1,336 @@
+name: Build All Platforms
+
+on:
+  push:
+    branches: [master]
+    tags: ['v*']
+  pull_request:
+    branches: [master]
+  workflow_dispatch:
+
+jobs:
+  test-linux-unit:
+    runs-on: ubuntu-22.04
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential libboost-all-dev \
+            libssl-dev libdb++-dev libleveldb-dev libevent-dev libminiupnpc-dev
+
+      - name: Build LevelDB
+        run: |
+          cd src/leveldb
+          chmod +x build_detect_platform
+          make clean || true
+          make OPT="-O2" libleveldb.a libmemenv.a
+
+      - name: Build and run unit tests
+        run: |
+          cd src
+          make -f makefile.unix test -j$(nproc)
+          ./test_triangles --log_level=test_suite 2>&1 || true
+
+  build-windows-qt:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          update: true
+          install: >-
+            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-qt5-base
+            mingw-w64-x86_64-qt5-tools
+            mingw-w64-x86_64-boost
+            mingw-w64-x86_64-openssl
+            mingw-w64-x86_64-db
+            mingw-w64-x86_64-libevent
+            mingw-w64-x86_64-miniupnpc
+            make
+
+      - name: Create Qt5 tool symlinks
+        run: |
+          ln -sf /mingw64/bin/qmake-qt5.exe /mingw64/bin/qmake.exe 2>/dev/null || true
+          ln -sf /mingw64/bin/lrelease-qt5.exe /mingw64/bin/lrelease.exe 2>/dev/null || true
+          ln -sf /mingw64/bin/windeployqt-qt5.exe /mingw64/bin/windeployqt.exe 2>/dev/null || true
+
+      - name: Clean stale build artifacts
+        run: rm -rf build/*.o build/*.h
+
+      - name: Build LevelDB
+        run: |
+          cd src/leveldb
+          make clean || true
+          CC=gcc CXX=g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE make OPT="-fno-keep-inline-dllexport -march=nocona -msahf -mtune=generic -Wa,-mbig-obj -O2" libleveldb.a libmemenv.a
+
+      - name: Run qmake
+        run: |
+          qmake triangles-qt.pro "RELEASE=1"
+
+      - name: Build
+        run: |
+          make -j$(nproc)
+
+      - name: Package
+        run: |
+          mkdir -p dist
+          cp release/triangles-qt.exe dist/
+          windeployqt dist/triangles-qt.exe || true
+          # Copy runtime DLLs
+          for dll in libgcc_s_seh-1.dll libstdc++-6.dll libwinpthread-1.dll; do
+            cp /mingw64/bin/$dll dist/ 2>/dev/null || true
+          done
+
+      - name: Strip binary
+        run: strip --strip-all dist/triangles-qt.exe
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-qt
+          path: dist/
+
+  build-windows-daemon:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          update: true
+          install: >-
+            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-boost
+            mingw-w64-x86_64-openssl
+            mingw-w64-x86_64-db
+            mingw-w64-x86_64-libevent
+            mingw-w64-x86_64-miniupnpc
+            make
+
+      - name: Build LevelDB
+        run: |
+          cd src/leveldb
+          make clean || true
+          CC=gcc CXX=g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE make OPT="-fno-keep-inline-dllexport -march=nocona -msahf -mtune=generic -Wa,-mbig-obj -O2" libleveldb.a libmemenv.a
+
+      - name: Build daemon
+        run: |
+          set -eo pipefail
+          cd src
+          mkdir -p obj
+          make -f makefile.mingw DEPSDIR=/mingw64 all -j$(nproc) 2>&1
+          strip --strip-all trianglesd.exe
+          cp trianglesd.exe ../trianglesd.exe
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-daemon
+          path: trianglesd.exe
+
+  build-linux-qt:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set VERSION from source
+        run: |
+          MAJOR=$(grep 'CLIENT_VERSION_MAJOR' src/clientversion.h | awk '{print $3}')
+          MINOR=$(grep 'CLIENT_VERSION_MINOR' src/clientversion.h | awk '{print $3}')
+          REV=$(grep 'CLIENT_VERSION_REVISION' src/clientversion.h | awk '{print $3}')
+          echo "VERSION=${MAJOR}.${MINOR}.${REV}" >> $GITHUB_ENV
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential qt5-qmake qtbase5-dev \
+            qttools5-dev-tools libboost-all-dev libssl-dev libdb++-dev \
+            libleveldb-dev libevent-dev libminiupnpc-dev
+
+      - name: Build LevelDB
+        run: |
+          cd src/leveldb
+          chmod +x build_detect_platform
+          make clean || true
+          make OPT="-O2" libleveldb.a libmemenv.a
+
+      - name: Clean stale build artifacts
+        run: rm -rf build/*.o
+
+      - name: Run qmake
+        run: qmake triangles-qt.pro "RELEASE=1"
+
+      - name: Build
+        run: make -j$(nproc)
+
+      - name: Strip binary
+        run: strip --strip-all triangles-qt
+
+      - name: Rename
+        run: mv triangles-qt Cryptographic-Triangles-v${VERSION}-linux-x64-qt
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-qt
+          path: Cryptographic-Triangles-v*-linux-x64-qt
+
+  build-linux-daemon:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set VERSION from source
+        run: |
+          MAJOR=$(grep 'CLIENT_VERSION_MAJOR' src/clientversion.h | awk '{print $3}')
+          MINOR=$(grep 'CLIENT_VERSION_MINOR' src/clientversion.h | awk '{print $3}')
+          REV=$(grep 'CLIENT_VERSION_REVISION' src/clientversion.h | awk '{print $3}')
+          echo "VERSION=${MAJOR}.${MINOR}.${REV}" >> $GITHUB_ENV
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential libboost-all-dev \
+            libssl-dev libdb++-dev libleveldb-dev libevent-dev libminiupnpc-dev
+
+      - name: Build LevelDB
+        run: |
+          cd src/leveldb
+          chmod +x build_detect_platform
+          make clean || true
+          make OPT="-O2" libleveldb.a libmemenv.a
+
+      - name: Build daemon
+        run: |
+          cd src
+          mkdir -p obj
+          make -f makefile.unix trianglesd -j$(nproc)
+
+      - name: Strip binary
+        run: strip --strip-all src/trianglesd
+
+      - name: Rename
+        run: mv src/trianglesd Cryptographic-Triangles-v${VERSION}-linux-x64-daemon
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux-daemon
+          path: Cryptographic-Triangles-v*-linux-x64-daemon
+
+  build-macos:
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set VERSION from source
+        run: |
+          MAJOR=$(grep 'CLIENT_VERSION_MAJOR' src/clientversion.h | awk '{print $3}')
+          MINOR=$(grep 'CLIENT_VERSION_MINOR' src/clientversion.h | awk '{print $3}')
+          REV=$(grep 'CLIENT_VERSION_REVISION' src/clientversion.h | awk '{print $3}')
+          echo "VERSION=${MAJOR}.${MINOR}.${REV}" >> $GITHUB_ENV
+
+      - name: Install dependencies
+        run: |
+          brew install qt@5 openssl@3 boost berkeley-db@5 leveldb libevent miniupnpc
+
+      - name: Clean stale build artifacts
+        run: rm -rf build/*.o build/*.h
+
+      - name: Build LevelDB
+        run: |
+          cd src/leveldb
+          chmod +x build_detect_platform
+          make clean || true
+          CC=clang CXX=clang++ make OPT="-O2" libleveldb.a libmemenv.a
+
+      - name: Run qmake
+        run: |
+          export PATH="/opt/homebrew/opt/qt@5/bin:$PATH"
+          qmake triangles-qt.pro -spec macx-clang \
+            "BOOST_INCLUDE_PATH=/opt/homebrew/opt/boost/include" \
+            "BOOST_LIB_PATH=/opt/homebrew/opt/boost/lib" \
+            "BDB_INCLUDE_PATH=/opt/homebrew/opt/berkeley-db@5/include" \
+            "BDB_LIB_PATH=/opt/homebrew/opt/berkeley-db@5/lib" \
+            "BDB_LIB_SUFFIX=" \
+            "OPENSSL_INCLUDE_PATH=/opt/homebrew/opt/openssl@3/include" \
+            "OPENSSL_LIB_PATH=/opt/homebrew/opt/openssl@3/lib" \
+            "MINIUPNPC_INCLUDE_PATH=/opt/homebrew/opt/miniupnpc/include" \
+            "MINIUPNPC_LIB_PATH=/opt/homebrew/opt/miniupnpc/lib" \
+            "EVENT_INCLUDE_PATH=/opt/homebrew/opt/libevent/include" \
+            "EVENT_LIB_PATH=/opt/homebrew/opt/libevent/lib" \
+            "RELEASE=1"
+
+      - name: Build
+        run: |
+          export PATH="/opt/homebrew/opt/qt@5/bin:$PATH"
+          make -j$(sysctl -n hw.ncpu)
+
+      - name: Create .app bundle
+        run: |
+          export PATH="/opt/homebrew/opt/qt@5/bin:$PATH"
+          macdeployqt Triangles-Qt.app -verbose=1
+
+      - name: Create DMG
+        run: |
+          mkdir -p dmg_contents
+          cp -R Triangles-Qt.app dmg_contents/
+          ln -s /Applications dmg_contents/Applications
+          hdiutil create -volname "Cryptographic Triangles" \
+            -srcfolder dmg_contents \
+            -ov -format UDZO \
+            "Cryptographic-Triangles-v${VERSION}-macos-arm64.dmg"
+
+      - name: Upload DMG
+        uses: actions/upload-artifact@v4
+        with:
+          name: macos-arm64-dmg
+          path: "*.dmg"
+
+  release:
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [build-windows-qt, build-windows-daemon, build-linux-qt, build-linux-daemon, build-macos]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Set VERSION from tag
+        run: echo "VERSION=${GITHUB_REF_NAME#v}" >> $GITHUB_ENV
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Prepare release assets
+        run: |
+          mkdir -p release
+          # Windows
+          cd artifacts/windows-qt && zip -r ../../release/Cryptographic-Triangles-${VERSION}-win-x64.zip . && cd ../..
+          cp artifacts/windows-qt/triangles-qt.exe release/Cryptographic-Triangles-${VERSION}-win-x64-qt.exe
+          cp artifacts/windows-daemon/trianglesd.exe release/Cryptographic-Triangles-${VERSION}-win-x64-daemon.exe
+          # Linux
+          cp artifacts/linux-qt/Cryptographic-Triangles-* release/
+          cp artifacts/linux-daemon/Cryptographic-Triangles-* release/
+          # macOS
+          cp artifacts/macos-arm64-dmg/*.dmg release/
+          ls -la release/
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: release/*
+          generate_release_notes: true

.gitignore

@@ -5,12 +5,18 @@
 *.so
 *.dylib
 *.a
+/dist/
 build/
 release/
 debug/
+/Makefile
 Makefile.Debug
 Makefile.Release
 .qmake.stash
+object_script.triangles-qt.Debug
+object_script.triangles-qt.Release
+/*.zip
+/*.tar.gz
 
 # Qt
 moc_*.cpp
@@ -52,3 +58,6 @@ triangles.conf
 *.key
 *.cert
 *.gpg
+*.o
+src/trianglesd
+src/obj/

CLEANUP_NOTES.md

@@ -0,0 +1,94 @@
+# Triangles Codebase Cleanup Notes
+
+## Overview
+Systematic code quality improvements for the Triangles cryptocurrency codebase (v5.3.4+).
+
+**Goal:** Improve maintainability without changing behavior or breaking consensus.
+
+## Inventory
+
+### TODOs/FIXMEs Found (38 total)
+
+#### High Priority (Affects Safety/Correctness)
+- `rpcmining.cpp:263` - **Thread safety issue** in mapNewBlock (static variable, no mutex)
+- `walletmodel.cpp:249` - **Potential collision** in balance calculation
+- `smessage.cpp:863, 2219, 2373` - **File size limit** (files must be split if >2GB)
+
+#### Medium Priority (Encapsulation/Security)
+- `protocol.h:50, 100, 132` - Public members should be private (3 locations)
+- `wallet.h:378` - nOrderPos calculation should move elsewhere
+- `wallet.cpp:733, 1732` - Change output handling needs improvement
+- `rpcwallet.cpp:1474, 1513, 1569` - SecureString operator= missing (forced .c_str())
+
+#### Low Priority (Nice-to-Have)
+- `util.cpp:1322` - Disabled feature needs verification
+- `tor/tor_embedded.cpp:209` - Tor 0.4.9+ shutdown API upgrade
+- `init.cpp:442` - Remaining sanity checks (see Bitcoin issue #4081)
+- `rpcmining.cpp:232` - DRM comment (unclear what it means)
+- `smessage.cpp:*` - Various improvements (hash inclusion, thread safety, defaults)
+- `qt/*` - UI improvements (decrypt not supported, message filtering, OSX startup)
+
+#### External/Third-Party (Don't Touch)
+- `leveldb/*` - LevelDB library TODOs (upstream issues)
+
+## Code Quality Issues
+
+### Using namespace std (37 files)
+All in .cpp files - **this is fine for .cpp**, problematic only in headers.
+No headers have this issue, so **no action needed**.
+
+### Printf/Cout Usage (56 files)
+Most cryptocurrency code uses printf for early init/error handling before logging is available.
+**Review needed:** Check if these are legitimate early-init cases or should use LogPrintf.
+
+## Cleanup Plan (Safest → Riskiest)
+
+### Phase 1: Documentation & Comments ✅ SAFE
+1. Document all TODOs with context (why deferred, what's needed)
+2. Add function-level comments for complex logic
+3. Improve inline comments for clarity
+
+### Phase 2: Low-Risk Code Quality 🟨 MEDIUM RISK
+4. Fix compiler warnings (-Wall -Wextra)
+5. Add const correctness where missing
+6. Remove commented-out dead code
+7. Standardize code formatting (if inconsistent)
+
+### Phase 3: Functional Improvements 🟥 HIGH RISK (Skip for now)
+8. Fix thread safety issue in rpcmining.cpp (requires testing)
+9. Improve protocol.h encapsulation (may affect other code)
+10. Address >2GB file handling in smessage.cpp
+
+## Decisions
+
+### What NOT to Change
+- **Consensus code** - main.cpp (validation), kernel.cpp (PoS), miner.cpp (staking)
+- **Serialization** - Any READWRITE, serialize/deserialize code
+- **Protocol constants** - Network message types, version numbers
+- **Third-party code** - leveldb/, tor/, sph_types.h, xxhash/, lz4/
+
+### What's Safe to Change
+- Comments and documentation
+- Variable names (in non-consensus code)
+- Code organization (splitting large functions)
+- Logging statements
+- UI code (qt/)
+- RPC interface (as long as API contract preserved)
+
+## Initial Cleanup (2026-03-22)
+
+### Actions Taken
+1. Created this documentation file
+2. Created cleanup/desloppify branch
+3. Inventoried all TODOs/FIXMEs
+
+### Next Steps
+1. Add documentation comments to TODO items
+2. Review printf/cout usage patterns
+3. Check for compiler warnings
+4. Consider low-risk improvements
+
+## Notes
+- This is a Bitcoin-derived codebase, so many patterns follow Bitcoin Core conventions
+- Recent v5.3.x work already modernized to C++17 and removed Boost - good foundation
+- Code is generally well-structured; main improvements are documentation and minor cleanup

CLEANUP_STRATEGY.md

@@ -0,0 +1,76 @@
+# Triangles Cleanup Strategy - Safe Improvements
+
+**Branch:** `cleanup/safe-improvements`  
+**Goal:** Improve code quality without touching consensus-critical code
+
+## ✅ SAFE TO FIX
+
+### 1. Compiler Warnings (Non-Consensus)
+- **C++11 literal-suffix warnings** - Add spaces between literals and suffixes
+- **Unused variables/functions** - Remove dead code (verify not consensus-critical first)
+- **Deprecated-copy warnings** - Fix CScript assignment operator if safe
+
+### 2. Code Style Improvements
+- Remove `using namespace std` from headers (keep in .cpp files)
+- Standardize logging patterns
+- Improve code comments (remove unclear/misleading ones)
+- Add context to TODOs/FIXMEs
+
+### 3. Documentation
+- Add inline comments for thread safety concerns
+- Document collision vulnerabilities
+- Improve function/class documentation
+
+## ❌ DO NOT TOUCH
+
+### Consensus-Critical Code
+- **OpenSSL SHA256/RIPEMD160 usage** - Deprecated warnings OK, do not change
+- **BN_is_prime_ex** - Crypto library deprecation, leave as-is
+- **Hash algorithms** - Third-party libraries with warnings, consensus-critical
+- **Block validation logic** - Any code affecting block/transaction validation
+- **Merkle tree construction** - Core consensus
+- **Proof-of-Work/Proof-of-Stake** - Staking/mining algorithms
+
+### How to Identify Consensus Code
+- Files in `src/` related to: `main.cpp`, `main.h`, block validation, transaction validation
+- Anything in hash algorithm libraries
+- Cryptographic primitives
+- Network protocol message formats (version, serialization)
+
+## Incremental Testing Strategy
+
+1. **One warning category at a time**
+2. **Compile after each change**
+3. **Test basic functionality:**
+   - `trianglesd getinfo`
+   - `trianglesd getblockchaininfo`
+   - Verify block sync works
+4. **Commit incrementally** with clear messages
+
+## Warning Categories (From Build Output)
+
+```
+1. C++11 literal-suffix: ~20 instances (util.h, net.h, alert.cpp)
+2. OpenSSL deprecation: SHA256, RIPEMD160 (DO NOT FIX)
+3. BN_is_prime_ex: crypto library (DO NOT FIX)
+4. Deprecated-copy: CScript assignment (REVIEW CAREFULLY)
+5. Unused variables/functions: Various (SAFE IF NOT CONSENSUS)
+```
+
+## Branch History
+
+- Previous work: `cleanup/desloppify` (documentation improvements, merged to master)
+- This branch: Focus on safe compiler warnings and code quality
+
+## Verification Checklist
+
+Before pushing each commit:
+- [ ] Code compiles successfully
+- [ ] No new warnings introduced
+- [ ] trianglesd runs without errors
+- [ ] getinfo/getblockchaininfo work
+- [ ] No consensus-critical code touched
+
+---
+
+**Principle:** When in doubt, don't touch it. A clean codebase is worthless if the blockchain forks.

CODEX-TOR-GUIDE.md

@@ -0,0 +1,220 @@
+# Embedded Tor Integration Guide for Triangles
+
+This guide explains how to compile Tor as a static library (`libtor.a`) and link
+it directly into the Triangles wallet binary so that every node automatically
+runs a Tor hidden service without needing an external Tor installation.
+
+## Architecture Overview
+
+```
+trianglesd / triangles-qt
+  ├── tor_embedded.cpp    ← calls tor_run_main() in a background thread
+  ├── tor_process.cpp     ← fallback: launches external tor binary (already works)
+  ├── onion_v3.cpp        ← V3 onion address generation / SOCKS5 proxy logic
+  └── libtor.a            ← aggregate static Tor library (built from official source)
+```
+
+When compiled with `ENABLE_TOR_EMBEDDED`, the wallet calls `tor_run_main()` from
+`tor_api.h` on a dedicated thread. This gives the wallet a SOCKS5 proxy on
+`127.0.0.1:19099` and a V3 hidden service on port 24112 (the P2P port).
+
+When compiled **without** the flag, `tor_embedded.cpp` falls back to the external
+`tor_process.cpp` which searches for and launches a system `tor` binary.
+
+## Step 1: Add Tor as a Git Submodule
+
+```bash
+cd /path/to/triangles
+git submodule add https://gitlab.torproject.org/tpo/core/tor.git src/tor/tor-src
+cd src/tor/tor-src
+git checkout release-0.4.9   # latest stable branch as of 2026
+```
+
+This puts the full Tor source at `src/tor/tor-src/`.
+Current imported checkout in this repo: `release-0.4.9` at commit `1442ca4`.
+There is also a helper build script at `src/tor/build-libtor.sh`.
+
+## Step 2: Build libtor.a
+
+Tor uses autotools. Build it as a static library:
+
+```bash
+cd src/tor/tor-src
+
+# Install Tor build dependencies
+sudo apt install autoconf automake libtool pkg-config \
+    libssl-dev libevent-dev zlib1g-dev
+
+# Generate configure script
+./autogen.sh
+
+# Configure for static library build (disable unneeded modules)
+./configure \
+    --enable-static-tor \
+    --disable-module-relay \
+    --disable-module-dirauth \
+    --disable-asciidoc \
+    --disable-manpage \
+    --disable-html-manual \
+    --disable-unittests \
+    --disable-tool-name-check \
+    --with-openssl-dir=/usr \
+    --with-libevent-dir=/usr \
+    --with-zlib-dir=/usr \
+    --prefix=/usr/local
+
+make -j$(nproc)
+```
+
+Or from the repo root:
+```bash
+./src/tor/build-libtor.sh
+```
+
+After building, the static libraries are in `src/tor/tor-src/`:
+- `libtor.a`
+- `src/lib/libtor-*.a` (multiple component libs)
+
+The header `src/feature/api/tor_api.h` provides the public C API:
+```c
+tor_main_configuration_t *tor_main_configuration_new(void);
+int tor_main_configuration_set_command_line(tor_main_configuration_t *cfg,
+                                             int argc, char *argv[]);
+int tor_run_main(const tor_main_configuration_t *);
+void tor_main_configuration_free(tor_main_configuration_t *);
+```
+
+## Step 3: Build Triangles with Embedded Tor
+
+### Linux (makefile.unix)
+
+```bash
+cd src
+
+# Point to Tor's built libraries and headers
+make -f makefile.unix \
+    USE_TOR_EMBEDDED=1
+```
+
+You may need to adjust the `-l` flags in the makefile depending on the exact
+library names Tor produces. Check `src/tor/tor-src/` after building:
+
+```bash
+find tor/tor-src -name '*.a' | sort
+```
+
+On the imported `release-0.4.9` checkout in this repo, the simplest working
+link path is the aggregate `libtor.a` plus the normal dependency libraries.
+
+### Windows (triangles-qt.pro)
+
+Add to `triangles-qt.pro`:
+```qmake
+qmake "USE_TOR_EMBEDDED=1" \
+      "TOR_SOURCE_ROOT=src/tor/tor-src"
+```
+
+Both build systems now default to:
+- source root: `src/tor/tor-src`
+- include path: `src/tor/tor-src/src/feature/api`
+- library path: `src/tor/tor-src`
+- embedded Tor library: `-ltor`
+
+On Windows, the imported Tor `0.4.9.5` build also needed:
+- `-llzma`
+- `-lzstd`
+- `-liphlpapi`
+- `-lshlwapi` (already linked by Triangles)
+
+## Step 4: Wire into init.cpp
+
+The global hooks `StartEmbeddedTor()` and `StopEmbeddedTor()` need to be called
+from `init.cpp`. Add these calls:
+
+### In AppInit2() (after network init, before starting node):
+```cpp
+#include "tor/tor_embedded.h"
+
+// Near the end of AppInit2, after network initialization:
+if (!StartEmbeddedTor()) {
+    printf("WARNING: Embedded Tor failed to start. .onion connectivity unavailable.\n");
+    // Non-fatal: wallet works without Tor, just no .onion
+}
+```
+
+### In Shutdown():
+```cpp
+StopEmbeddedTor();
+```
+
+## Step 5: Configure SOCKS Proxy for Outbound Connections
+
+After Tor starts, the wallet needs to route `.onion` connections through the
+SOCKS5 proxy. In `net.cpp`, after Tor is initialized:
+
+```cpp
+// If embedded Tor is running, use its SOCKS proxy for .onion addresses
+CTorEmbedded* tor = CTorEmbedded::GetInstance();
+if (tor->IsRunning()) {
+    // Set proxy for .onion connections
+    proxyType addrProxy(CService("127.0.0.1", tor->GetSocksPort()), 5);
+    SetNameProxy(addrProxy);
+}
+```
+
+## Runtime Flags
+
+The embedded Tor respects these command-line flags:
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `-notor` | false | Disable Tor entirely |
+| `-torsocks=PORT` | 19099 | SOCKS5 proxy port |
+| `-torhsport=PORT` | 24112 | Hidden service virtual port |
+
+## File Layout After Integration
+
+```
+src/tor/
+├── tor-src/             ← git submodule (official Tor repo)
+│   └── src/
+│       ├── lib/libtor-*.a
+│       └── feature/api/tor_api.h
+│   └── libtor.a
+├── tor_embedded.h       ← CTorEmbedded class header
+├── tor_embedded.cpp     ← implementation (calls tor_run_main)
+├── tor_process.h        ← external Tor process manager (fallback)
+├── tor_process.cpp
+├── onion_v3.h           ← V3 onion address utilities
+├── onion_v3.cpp
+├── anonymize.h          ← data dir helpers
+├── anonymize.cpp
+└── LICENSE
+```
+
+## Reference: How VERGE (XVG) Does It
+
+VERGE uses the same pattern. Their implementation is at:
+- `src/torcontroller.cpp` (~100 lines)
+- They use `tor_main()` (older API, pre-0.4.5)
+- Git submodule at `src/tor/` pointing to `release-0.4.8` branch
+- Build Tor as part of their `depends/` system
+
+Key difference: modern Tor (0.4.5+) uses `tor_run_main()` with a configuration
+object instead of raw `tor_main(int argc, char** argv)`.
+
+## Troubleshooting
+
+**Tor fails to bootstrap**: Check firewall rules. Tor needs outbound TCP to the
+Tor network (ports 80, 443, 9001, 9030).
+
+**Link errors with libtor**: Prefer the aggregate `libtor.a` from the top level
+of the Tor build tree. On the imported Windows/MSYS2 build in this repo, the
+minimal verified link set was:
+```
+-ltor -levent -lssl -lcrypto -lz -llzma -lzstd -lws2_32 -liphlpapi -lshlwapi
+```
+
+**OpenSSL version mismatch**: Both Tor and Triangles must link against the same
+OpenSSL version (3.x). If Tor was built against a different OpenSSL, rebuild it
+with the same `--with-openssl-dir`.

DNS2-SEED-NODE-SETUP.md

@@ -0,0 +1,398 @@
+# Triangles Bootstrap Server Setup - DNS2
+
+**For:** Krystie (@Krystie7777bot)
+**Server:** DNS2 (194.233.88.206) - Ubuntu
+**Date:** March 2026
+
+---
+
+## What This Server Does
+
+Your server is the **bootstrap server** for the Triangles network. When someone opens a fresh Triangles wallet:
+
+1. The wallet connects to `bootstrap.cryptographic-triangles.org` on **port 80**
+2. If that fails, it falls back to your IP directly: `194.233.88.206` on **port 80**
+3. It downloads `/filelist.txt` to see which blockchain files are available
+4. It downloads each file listed (mainly `blk0001.dat`, the entire blockchain)
+5. The user is now synced and ready to go
+
+Your IP is hardcoded in the wallet. If your server is down, new users can't bootstrap.
+
+Your server also runs the Triangles daemon so it doubles as a seed node on **port 24112**.
+
+---
+
+## Step 1: Install nginx
+
+```bash
+sudo apt update
+sudo apt install -y nginx curl
+```
+
+---
+
+## Step 2: Download the Daemon
+
+No building required. Download the pre-built Linux binary from GitHub:
+
+```bash
+cd /tmp
+curl -L -o trianglesd https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.3.7/Cryptographic-Triangles-v5.3.7-linux-x64-daemon
+chmod +x trianglesd
+sudo mv trianglesd /usr/local/bin/
+```
+
+Verify it works:
+
+```bash
+trianglesd --version
+```
+
+---
+
+## Step 3: Configure the Daemon
+
+```bash
+mkdir -p ~/.triangles
+
+RPC_PASS=$(openssl rand -hex 32)
+
+cat > ~/.triangles/triangles.conf << EOF
+port=24112
+listen=1
+maxconnections=125
+rpcport=19112
+rpcuser=trianglesrpc
+rpcpassword=$RPC_PASS
+rpcallowip=127.0.0.1
+server=1
+externalip=194.233.88.206
+addnode=74.208.167.19
+txindex=1
+daemon=1
+EOF
+```
+
+---
+
+## Step 4: Get the Blockchain Data
+
+OpenClaw will send you `blk0001.dat` (or a tarball containing it). Put it in `~/.triangles/`:
+
+```bash
+cd ~/.triangles
+# If you received a tarball:
+tar xzf /path/to/blockchain-data.tar.gz
+# Or if you received blk0001.dat directly:
+cp /path/to/blk0001.dat ~/.triangles/
+```
+
+After this step you should have:
+
+```
+~/.triangles/blk0001.dat
+~/.triangles/triangles.conf
+```
+
+Do NOT copy someone else's `wallet.dat` unless you intend to use that wallet.
+
+---
+
+## Step 5: Open Firewall Ports
+
+You need **two** ports open:
+
+```bash
+sudo ufw allow 80/tcp comment "Bootstrap HTTP server"
+sudo ufw allow 24112/tcp comment "Triangles P2P"
+sudo ufw enable
+sudo ufw status
+```
+
+Verify both show ALLOW:
+
+```
+80/tcp                     ALLOW       Anywhere        # Bootstrap HTTP server
+24112/tcp                  ALLOW       Anywhere        # Triangles P2P
+```
+
+Do NOT open 19112 (RPC).
+
+---
+
+## Step 6: Test the Daemon
+
+```bash
+trianglesd
+```
+
+Wait 10 seconds, then:
+
+```bash
+trianglesd getinfo
+```
+
+Look for:
+- `"blocks"` around 2,186,940 or higher
+- `"connections"` should become 1+ within a couple minutes
+
+If it works, stop it:
+
+```bash
+trianglesd stop
+```
+
+---
+
+## Step 7: Set Up the Daemon as a systemd Service
+
+```bash
+sudo tee /etc/systemd/system/trianglesd.service << 'EOF'
+[Unit]
+Description=Triangles Daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=forking
+ExecStart=/usr/local/bin/trianglesd -daemon -datadir=/root/.triangles
+ExecStop=/usr/local/bin/trianglesd -datadir=/root/.triangles stop
+Restart=on-failure
+RestartSec=30
+TimeoutStopSec=120
+LimitNOFILE=65536
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+sudo systemctl daemon-reload
+sudo systemctl enable trianglesd
+sudo systemctl start trianglesd
+```
+
+If you're running as a non-root user, change `/root/.triangles` to `/home/youruser/.triangles`.
+
+Verify:
+
+```bash
+sudo systemctl status trianglesd
+trianglesd getinfo
+```
+
+---
+
+## Step 8: Set Up the Bootstrap File Server
+
+This is the main event.
+
+### 8a. Create the bootstrap directory and tarball
+
+```bash
+sudo mkdir -p /var/www/triangles-bootstrap
+
+# Create the compressed tarball from the blockchain data
+# Only blk0001.dat is needed - the wallet builds its own block index after download
+cd ~/.triangles
+tar czf /tmp/bootstrap.tar.gz blk0001.dat
+sudo mv /tmp/bootstrap.tar.gz /var/www/triangles-bootstrap/
+
+# Also create the legacy fallback files (for older wallet versions)
+sudo cp ~/.triangles/blk0001.dat /var/www/triangles-bootstrap/
+sudo tee /var/www/triangles-bootstrap/filelist.txt << 'EOF'
+blk0001.dat
+EOF
+
+sudo chown -R www-data:www-data /var/www/triangles-bootstrap
+```
+
+The wallet tries to download `bootstrap.tar.gz` first (compressed, faster). If that's missing, it falls back to downloading `blk0001.dat` directly using `filelist.txt`. After download, the wallet automatically imports the blocks and builds its own index.
+
+### 8b. Configure nginx
+
+```bash
+sudo rm -f /etc/nginx/sites-enabled/default
+
+sudo tee /etc/nginx/sites-available/triangles-bootstrap << 'EOF'
+server {
+    listen 80;
+    server_name bootstrap.cryptographic-triangles.org 194.233.88.206;
+
+    root /var/www/triangles-bootstrap;
+
+    location / {
+        try_files $uri =404;
+    }
+
+    send_timeout 600s;
+    keepalive_timeout 600s;
+}
+EOF
+
+sudo ln -sf /etc/nginx/sites-available/triangles-bootstrap /etc/nginx/sites-enabled/
+sudo nginx -t
+```
+
+That should print `syntax is ok` and `test is successful`. Then:
+
+```bash
+sudo systemctl enable nginx
+sudo systemctl restart nginx
+```
+
+### 8c. Verify it works
+
+```bash
+# Should print "blk0001.dat"
+curl http://localhost/filelist.txt
+
+# Should show HTTP 200 and a Content-Length
+curl -I http://localhost/blk0001.dat
+```
+
+### 8d. Test from outside
+
+Ask OpenClaw to test from another machine:
+
+```bash
+curl -I http://194.233.88.206/bootstrap.tar.gz
+curl http://194.233.88.206/filelist.txt
+```
+
+If both return HTTP 200, the bootstrap server is live.
+
+---
+
+## Step 9: Keeping Bootstrap Data Fresh
+
+Periodically rebuild the tarball from the latest blockchain data:
+
+```bash
+sudo systemctl stop trianglesd
+cd ~/.triangles
+tar czf /tmp/bootstrap.tar.gz blk0001.dat
+sudo mv /tmp/bootstrap.tar.gz /var/www/triangles-bootstrap/
+sudo cp ~/.triangles/blk0001.dat /var/www/triangles-bootstrap/
+sudo chown -R www-data:www-data /var/www/triangles-bootstrap
+sudo systemctl start trianglesd
+```
+
+Or set up a weekly cron job:
+
+```bash
+sudo tee /etc/cron.d/triangles-bootstrap-update << 'EOF'
+0 4 * * 0 root systemctl stop trianglesd && cd /root/.triangles && tar czf /tmp/bootstrap.tar.gz blk0001.dat && mv /tmp/bootstrap.tar.gz /var/www/triangles-bootstrap/ && cp /root/.triangles/blk0001.dat /var/www/triangles-bootstrap/ && chown -R www-data:www-data /var/www/triangles-bootstrap && systemctl start trianglesd
+EOF
+```
+
+---
+
+## Step 10: Tor Hidden Service (Optional)
+
+```bash
+sudo apt install -y tor
+```
+
+Add to `/etc/tor/torrc`:
+
+```
+HiddenServiceDir /var/lib/tor/triangles/
+HiddenServiceVersion 3
+HiddenServicePort 24112 127.0.0.1:24112
+```
+
+Then:
+
+```bash
+sudo systemctl restart tor
+sudo cat /var/lib/tor/triangles/hostname
+```
+
+Send the `.onion` address to OpenClaw, add `externalip=YOUR_ONION_ADDRESS.onion` to `triangles.conf`, and restart the daemon.
+
+---
+
+## Troubleshooting
+
+### Bootstrap server isn't working
+
+```bash
+sudo systemctl status nginx
+sudo ss -tlnp | grep :80
+ls -lh /var/www/triangles-bootstrap/
+curl http://localhost/filelist.txt
+sudo tail -30 /var/log/nginx/error.log
+```
+
+### Daemon has 0 connections
+
+```bash
+sudo ss -tlnp | grep 24112
+sudo ufw status
+trianglesd addnode 74.208.167.19 add
+```
+
+### Daemon won't start
+
+```bash
+tail -100 ~/.triangles/debug.log
+ps aux | grep trianglesd
+ls ~/.triangles/.lock
+```
+
+### "Error loading block database"
+
+```bash
+rm -rf ~/.triangles/txleveldb/
+sudo systemctl restart trianglesd
+```
+
+---
+
+## Quick Reference
+
+| What | Where / Value |
+|------|---------------|
+| **Bootstrap files** | `/var/www/triangles-bootstrap/` |
+| **bootstrap.tar.gz** | `/var/www/triangles-bootstrap/bootstrap.tar.gz` |
+| **filelist.txt** | `/var/www/triangles-bootstrap/filelist.txt` (legacy fallback) |
+| **blk0001.dat (web)** | `/var/www/triangles-bootstrap/blk0001.dat` (legacy fallback) |
+| **nginx config** | `/etc/nginx/sites-available/triangles-bootstrap` |
+| **nginx logs** | `/var/log/nginx/error.log` |
+| Daemon binary | `/usr/local/bin/trianglesd` |
+| Data directory | `~/.triangles/` |
+| Config file | `~/.triangles/triangles.conf` |
+| Debug log | `~/.triangles/debug.log` |
+| P2P port | **24112** (must be open) |
+| HTTP port | **80** (must be open) |
+| RPC port | 19112 (localhost only) |
+| Restart daemon | `sudo systemctl restart trianglesd` |
+| Restart nginx | `sudo systemctl restart nginx` |
+| Other seed node | 74.208.167.19 (DNS3-Sami) |
+| Contact | OpenClaw on Telegram |
+
+---
+
+## You're Done
+
+Once you've completed all the steps, your server is:
+
+1. **A seed node** — other wallets discover and connect to you on port 24112
+2. **A bootstrap server** — new wallets download the blockchain from you on port 80
+
+Send OpenClaw your `.onion` address (if you set up Tor) so it can be added to the wallet's onion seed list.
+
+To confirm everything is running:
+
+```bash
+# Daemon healthy?
+trianglesd getinfo
+
+# nginx serving files?
+curl -I http://localhost/bootstrap.tar.gz
+
+# Ports open externally?
+sudo ss -tlnp | grep -E ':(80|24112)\b'
+```
+
+If all three check out, you're live on the Triangles network.

Dockerfile

@@ -0,0 +1,37 @@
+FROM ubuntu:22.04
+
+LABEL maintainer="Cryptographic Triangles Team"
+LABEL description="Cryptographic Triangles (TRI) headless daemon"
+LABEL version="5.1.5"
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    curl \
+    libssl3 \
+    libdb5.3++ \
+    libboost-system1.74.0 \
+    libboost-filesystem1.74.0 \
+    libboost-program-options1.74.0 \
+    libboost-thread1.74.0 \
+    libboost-chrono1.74.0 \
+    libevent-2.1-7 \
+    libminiupnpc17 \
+    tor \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -L -o /usr/local/bin/trianglesd \
+    https://github.com/SamiAhmed7777/triangles_v5/releases/download/v5.1.5/trianglesd-linux \
+    && chmod +x /usr/local/bin/trianglesd
+
+RUN useradd -m -s /bin/bash triangles
+USER triangles
+WORKDIR /home/triangles
+
+RUN mkdir -p .triangles
+
+EXPOSE 24112 19112
+
+VOLUME ["/home/triangles/.triangles"]
+
+ENTRYPOINT ["trianglesd"]
+CMD ["-printtoconsole", "-txindex=1"]

Makefile

@@ -261,7 +261,7 @@ distclean: release-distclean debug-distclean  FORCE
 	-$(DEL_FILE) .qmake.stash
 
 E:/repos/triangles/src/leveldb/libleveldb.a: FORCE
-	cd E:/repos/triangles/src/leveldb && CC=gcc CXX=g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE $(MAKE) OPT="-fpermissive -O2" libleveldb.a libmemenv.a && ranlib E:/repos/triangles/src/leveldb/libleveldb.a && ranlib E:/repos/triangles/src/leveldb/libmemenv.a
+	cd E:/repos/triangles/src/leveldb && CC=gcc CXX=g++ TARGET_OS=OS_WINDOWS_CROSSCOMPILE $(MAKE) OPT="-fno-keep-inline-dllexport -march=nocona -msahf -mtune=generic -Wa,-mbig-obj -O2" libleveldb.a libmemenv.a && ranlib E:/repos/triangles/src/leveldb/libleveldb.a && ranlib E:/repos/triangles/src/leveldb/libmemenv.a
 
 release-mocclean:
 	$(MAKE) -f $(MAKEFILE).Release mocclean

README.md

@@ -1,4 +1,4 @@
-# Triangles (TRI) - v5.0.0.0 "Black Pharao"
+# Cryptographic Triangles (TRI) - v5.1.5
 
 Triangles is a privacy-focused cryptocurrency featuring Proof-of-Stake consensus, Tor v3 onion routing, and built-in encrypted messaging. Originally launched in July 2014, the chain was revived in March 2026 after being frozen since December 2022.
 
@@ -55,6 +55,11 @@ make -j$(nproc) -f makefile.unix USE_UPNP=0
 strip trianglesd
 ```
 
+Run the unit test suite:
+```bash
+make -C src -f makefile.unix test
+```
+
 ### Linux (AlmaLinux 9 / RHEL 9)
 
 Install dependencies:

TODO_DOCUMENTATION.md

@@ -0,0 +1,123 @@
+# TODO/FIXME Documentation
+
+Detailed context for each TODO/FIXME in the codebase.
+
+## Critical (Needs Attention)
+
+### src/rpcmining.cpp:263 - Thread Safety Issue
+```cpp
+static mapNewBlock_t mapNewBlock;    // FIXME: thread safety
+```
+**Issue:** Static variable accessed by multiple RPC threads without mutex protection.
+**Impact:** Potential race condition in getwork RPC (used for mining).
+**Status:** Low priority - PoW mining ended at block 9000, this code path rarely used.
+**Fix:** Add std::mutex and lock_guard if getwork usage increases.
+
+### src/qt/walletmodel.cpp:249 - Collision Risk
+```cpp
+if((total + nFeeRequired) > nBalance) // FIXME: could cause collisions in the future
+```
+**Issue:** Balance check may have edge case causing transaction collisions.
+**Context:** In createTransaction fee calculation loop.
+**Status:** Needs investigation - unclear what "collisions" means here.
+**Fix:** Review Bitcoin Core's current implementation of this logic.
+
+### src/smessage.cpp - File Size Limits
+```cpp
+// Lines 863, 2219, 2373: "TODO files must be split if > 2GB"
+```
+**Issue:** Secure message storage files not split when exceeding 2GB.
+**Impact:** May fail on 32-bit systems or with large message volumes.
+**Status:** Low priority - unlikely to reach 2GB in practice.
+**Fix:** Implement file rotation when approaching 2GB limit.
+
+## Medium Priority (Encapsulation/API)
+
+### src/protocol.h - Make Members Private
+```cpp
+// Lines 50, 100, 132: "TODO: make private (improves encapsulation)"
+```
+**Issue:** CAddress, CInv, CMessageHeader have public data members.
+**Impact:** Poor encapsulation, harder to maintain invariants.
+**Status:** Deferred - would require extensive refactoring.
+**Fix:** Add getter/setter methods, make members private, update all call sites.
+
+### src/wallet.h:378 - nOrderPos Calculation
+```cpp
+nOrderPos = -1; // TODO: calculate elsewhere
+```
+**Issue:** Transaction ordering position calculated in constructor.
+**Impact:** Minor - works but not ideal separation of concerns.
+**Status:** Deferred - no functional issue.
+**Fix:** Move calculation to WalletDB when transaction is added.
+
+### src/rpcwallet.cpp / src/qt/askpassphrasedialog.cpp - SecureString Conversion
+**Issue:** Password-handling paths were converting through `.c_str()` because `SecureString`
+did not have a convenient conversion helper from `std::string`.
+**Impact:** Unnecessary C-string shims in sensitive code paths.
+**Status:** Resolved.
+**Fix:** Added `MakeSecureString(const std::string&)` in `src/allocators.h` and updated
+the wallet RPC and passphrase dialog call sites to use it directly.
+
+## Low Priority (Nice-to-Have)
+
+### src/util.cpp:1322 - Disabled Feature
+```cpp
+// TODO: This is currently disabled because it needs to be verified to work
+```
+**Context:** File descriptor management code.
+**Status:** Intentionally disabled pending verification.
+**Fix:** Test thoroughly, then enable if needed.
+
+### src/tor/tor_embedded.cpp:209 - Tor Shutdown API
+```cpp
+// TODO: Tor 0.4.9+ may add tor_api_shutdown(), use it when available
+```
+**Context:** Embedded Tor cleanup.
+**Status:** Waiting for upstream Tor API.
+**Fix:** Check Tor 0.4.9+ releases for new API, integrate when stable.
+
+### src/init.cpp:442 - Sanity Checks
+```cpp
+// TODO: remaining sanity checks, see #4081
+```
+**Context:** Bitcoin Core issue #4081 - additional startup sanity checks.
+**Status:** Deferred - core checks already in place.
+**Fix:** Review Bitcoin Core's current sanity check implementation.
+
+### src/rpcmining.cpp:232 - DRM Comment
+```cpp
+CDataStream(coinbase, SER_NETWORK, PROTOCOL_VERSION) >> pblock->vtx[0]; // FIXME - DRM!
+```
+**Issue:** Unclear what "DRM" means here - likely "Data Race Maybe"?
+**Status:** Needs clarification from original author.
+**Fix:** Investigate if there's an actual issue, otherwise remove comment.
+
+## Deferred (External/Low Impact)
+
+### LevelDB TODOs (src/leveldb/*)
+**Status:** Upstream LevelDB issues - don't modify embedded library.
+**Action:** None - track upstream LevelDB project.
+
+### Qt TODOs (src/qt/*)
+**Status:** UI improvements, not critical.
+**Action:** Track as nice-to-have enhancements.
+
+### Secure Message TODOs (src/smessage.cpp)
+Multiple minor improvements suggested:
+- Include hash in certain operations
+- Improve thread shutdown
+- Set default recv/recvAnon behavior
+- Update outbox after PoW completes
+
+**Status:** Non-critical enhancements.
+**Action:** Consider for future encrypted messaging upgrades.
+
+## Summary
+
+**Critical:** 3 items (thread safety, balance collision, file limits)
+**Medium:** 6 items (encapsulation, SecureString)
+**Low:** 5 items (disabled features, upstream APIs)
+**Deferred:** ~24 items (external libs, minor enhancements)
+
+**Recommendation:** Focus on documenting critical items in code comments, defer fixes until specific issues arise.

build/moc_aboutdialog.cpp

@@ -1,119 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'aboutdialog.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/aboutdialog.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'aboutdialog.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_AboutDialog_t {
-    QByteArrayData data[3];
-    char stringdata0[35];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_AboutDialog_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_AboutDialog_t qt_meta_stringdata_AboutDialog = {
-    {
-QT_MOC_LITERAL(0, 0, 11), // "AboutDialog"
-QT_MOC_LITERAL(1, 12, 21), // "on_buttonBox_accepted"
-QT_MOC_LITERAL(2, 34, 0) // ""
-
-    },
-    "AboutDialog\0on_buttonBox_accepted\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_AboutDialog[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       1,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    0,   19,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void AboutDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<AboutDialog *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->on_buttonBox_accepted(); break;
-        default: ;
-        }
-    }
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject AboutDialog::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_AboutDialog.data,
-    qt_meta_data_AboutDialog,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *AboutDialog::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *AboutDialog::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_AboutDialog.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int AboutDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 1)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 1;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 1)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 1;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_addressbookpage.cpp

@@ -1,224 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'addressbookpage.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/addressbookpage.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'addressbookpage.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_AddressBookPage_t {
-    QByteArrayData data[24];
-    char stringdata0[338];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_AddressBookPage_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_AddressBookPage_t qt_meta_stringdata_AddressBookPage = {
-    {
-QT_MOC_LITERAL(0, 0, 15), // "AddressBookPage"
-QT_MOC_LITERAL(1, 16, 11), // "signMessage"
-QT_MOC_LITERAL(2, 28, 0), // ""
-QT_MOC_LITERAL(3, 29, 4), // "addr"
-QT_MOC_LITERAL(4, 34, 13), // "verifyMessage"
-QT_MOC_LITERAL(5, 48, 4), // "done"
-QT_MOC_LITERAL(6, 53, 6), // "retval"
-QT_MOC_LITERAL(7, 60, 13), // "exportClicked"
-QT_MOC_LITERAL(8, 74, 23), // "on_deleteButton_clicked"
-QT_MOC_LITERAL(9, 98, 27), // "on_newAddressButton_clicked"
-QT_MOC_LITERAL(10, 126, 26), // "on_copyToClipboard_clicked"
-QT_MOC_LITERAL(11, 153, 22), // "on_signMessage_clicked"
-QT_MOC_LITERAL(12, 176, 24), // "on_verifyMessage_clicked"
-QT_MOC_LITERAL(13, 201, 16), // "selectionChanged"
-QT_MOC_LITERAL(14, 218, 21), // "on_showQRCode_clicked"
-QT_MOC_LITERAL(15, 240, 14), // "contextualMenu"
-QT_MOC_LITERAL(16, 255, 5), // "point"
-QT_MOC_LITERAL(17, 261, 17), // "onCopyLabelAction"
-QT_MOC_LITERAL(18, 279, 12), // "onEditAction"
-QT_MOC_LITERAL(19, 292, 16), // "selectNewAddress"
-QT_MOC_LITERAL(20, 309, 11), // "QModelIndex"
-QT_MOC_LITERAL(21, 321, 6), // "parent"
-QT_MOC_LITERAL(22, 328, 5), // "begin"
-QT_MOC_LITERAL(23, 334, 3) // "end"
-
-    },
-    "AddressBookPage\0signMessage\0\0addr\0"
-    "verifyMessage\0done\0retval\0exportClicked\0"
-    "on_deleteButton_clicked\0"
-    "on_newAddressButton_clicked\0"
-    "on_copyToClipboard_clicked\0"
-    "on_signMessage_clicked\0on_verifyMessage_clicked\0"
-    "selectionChanged\0on_showQRCode_clicked\0"
-    "contextualMenu\0point\0onCopyLabelAction\0"
-    "onEditAction\0selectNewAddress\0QModelIndex\0"
-    "parent\0begin\0end"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_AddressBookPage[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      15,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       2,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    1,   89,    2, 0x06 /* Public */,
-       4,    1,   92,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       5,    1,   95,    2, 0x0a /* Public */,
-       7,    0,   98,    2, 0x0a /* Public */,
-       8,    0,   99,    2, 0x08 /* Private */,
-       9,    0,  100,    2, 0x08 /* Private */,
-      10,    0,  101,    2, 0x08 /* Private */,
-      11,    0,  102,    2, 0x08 /* Private */,
-      12,    0,  103,    2, 0x08 /* Private */,
-      13,    0,  104,    2, 0x08 /* Private */,
-      14,    0,  105,    2, 0x08 /* Private */,
-      15,    1,  106,    2, 0x08 /* Private */,
-      17,    0,  109,    2, 0x08 /* Private */,
-      18,    0,  110,    2, 0x08 /* Private */,
-      19,    3,  111,    2, 0x08 /* Private */,
-
- // signals: parameters
-    QMetaType::Void, QMetaType::QString,    3,
-    QMetaType::Void, QMetaType::QString,    3,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::Int,    6,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::QPoint,   16,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, 0x80000000 | 20, QMetaType::Int, QMetaType::Int,   21,   22,   23,
-
-       0        // eod
-};
-
-void AddressBookPage::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<AddressBookPage *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->signMessage((*reinterpret_cast< QString(*)>(_a[1]))); break;
-        case 1: _t->verifyMessage((*reinterpret_cast< QString(*)>(_a[1]))); break;
-        case 2: _t->done((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 3: _t->exportClicked(); break;
-        case 4: _t->on_deleteButton_clicked(); break;
-        case 5: _t->on_newAddressButton_clicked(); break;
-        case 6: _t->on_copyToClipboard_clicked(); break;
-        case 7: _t->on_signMessage_clicked(); break;
-        case 8: _t->on_verifyMessage_clicked(); break;
-        case 9: _t->selectionChanged(); break;
-        case 10: _t->on_showQRCode_clicked(); break;
-        case 11: _t->contextualMenu((*reinterpret_cast< const QPoint(*)>(_a[1]))); break;
-        case 12: _t->onCopyLabelAction(); break;
-        case 13: _t->onEditAction(); break;
-        case 14: _t->selectNewAddress((*reinterpret_cast< const QModelIndex(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (AddressBookPage::*)(QString );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&AddressBookPage::signMessage)) {
-                *result = 0;
-                return;
-            }
-        }
-        {
-            using _t = void (AddressBookPage::*)(QString );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&AddressBookPage::verifyMessage)) {
-                *result = 1;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject AddressBookPage::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_AddressBookPage.data,
-    qt_meta_data_AddressBookPage,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *AddressBookPage::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *AddressBookPage::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_AddressBookPage.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int AddressBookPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 15)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 15;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 15)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 15;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void AddressBookPage::signMessage(QString _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-
-// SIGNAL 1
-void AddressBookPage::verifyMessage(QString _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 1, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_addresstablemodel.cpp

@@ -1,148 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'addresstablemodel.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/addresstablemodel.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'addresstablemodel.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_AddressTableModel_t {
-    QByteArrayData data[8];
-    char stringdata0[81];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_AddressTableModel_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_AddressTableModel_t qt_meta_stringdata_AddressTableModel = {
-    {
-QT_MOC_LITERAL(0, 0, 17), // "AddressTableModel"
-QT_MOC_LITERAL(1, 18, 21), // "defaultAddressChanged"
-QT_MOC_LITERAL(2, 40, 0), // ""
-QT_MOC_LITERAL(3, 41, 7), // "address"
-QT_MOC_LITERAL(4, 49, 11), // "updateEntry"
-QT_MOC_LITERAL(5, 61, 5), // "label"
-QT_MOC_LITERAL(6, 67, 6), // "isMine"
-QT_MOC_LITERAL(7, 74, 6) // "status"
-
-    },
-    "AddressTableModel\0defaultAddressChanged\0"
-    "\0address\0updateEntry\0label\0isMine\0"
-    "status"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_AddressTableModel[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       2,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       1,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    1,   24,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       4,    4,   27,    2, 0x0a /* Public */,
-
- // signals: parameters
-    QMetaType::Void, QMetaType::QString,    3,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::Bool, QMetaType::Int,    3,    5,    6,    7,
-
-       0        // eod
-};
-
-void AddressTableModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<AddressTableModel *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->defaultAddressChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 1: _t->updateEntry((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (AddressTableModel::*)(const QString & );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&AddressTableModel::defaultAddressChanged)) {
-                *result = 0;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject AddressTableModel::staticMetaObject = { {
-    QMetaObject::SuperData::link<QAbstractTableModel::staticMetaObject>(),
-    qt_meta_stringdata_AddressTableModel.data,
-    qt_meta_data_AddressTableModel,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *AddressTableModel::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *AddressTableModel::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_AddressTableModel.stringdata0))
-        return static_cast<void*>(this);
-    return QAbstractTableModel::qt_metacast(_clname);
-}
-
-int AddressTableModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QAbstractTableModel::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 2)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 2;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 2)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 2;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void AddressTableModel::defaultAddressChanged(const QString & _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_askpassphrasedialog.cpp

@@ -1,134 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'askpassphrasedialog.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/askpassphrasedialog.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'askpassphrasedialog.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_AskPassphraseDialog_t {
-    QByteArrayData data[7];
-    char stringdata0[81];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_AskPassphraseDialog_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_AskPassphraseDialog_t qt_meta_stringdata_AskPassphraseDialog = {
-    {
-QT_MOC_LITERAL(0, 0, 19), // "AskPassphraseDialog"
-QT_MOC_LITERAL(1, 20, 11), // "textChanged"
-QT_MOC_LITERAL(2, 32, 0), // ""
-QT_MOC_LITERAL(3, 33, 5), // "event"
-QT_MOC_LITERAL(4, 39, 7), // "QEvent*"
-QT_MOC_LITERAL(5, 47, 11), // "eventFilter"
-QT_MOC_LITERAL(6, 59, 21) // "secureClearPassFields"
-
-    },
-    "AskPassphraseDialog\0textChanged\0\0event\0"
-    "QEvent*\0eventFilter\0secureClearPassFields"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_AskPassphraseDialog[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       4,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    0,   34,    2, 0x08 /* Private */,
-       3,    1,   35,    2, 0x08 /* Private */,
-       5,    2,   38,    2, 0x08 /* Private */,
-       6,    0,   43,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void,
-    QMetaType::Bool, 0x80000000 | 4,    3,
-    QMetaType::Bool, QMetaType::QObjectStar, 0x80000000 | 4,    2,    3,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void AskPassphraseDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<AskPassphraseDialog *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->textChanged(); break;
-        case 1: { bool _r = _t->event((*reinterpret_cast< QEvent*(*)>(_a[1])));
-            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
-        case 2: { bool _r = _t->eventFilter((*reinterpret_cast< QObject*(*)>(_a[1])),(*reinterpret_cast< QEvent*(*)>(_a[2])));
-            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
-        case 3: _t->secureClearPassFields(); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject AskPassphraseDialog::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_AskPassphraseDialog.data,
-    qt_meta_data_AskPassphraseDialog,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *AskPassphraseDialog::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *AskPassphraseDialog::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_AskPassphraseDialog.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int AskPassphraseDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 4)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 4;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 4)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 4;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_clientmodel.cpp

@@ -1,198 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'clientmodel.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/clientmodel.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'clientmodel.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_ClientModel_t {
-    QByteArrayData data[16];
-    char stringdata0[169];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_ClientModel_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_ClientModel_t qt_meta_stringdata_ClientModel = {
-    {
-QT_MOC_LITERAL(0, 0, 11), // "ClientModel"
-QT_MOC_LITERAL(1, 12, 21), // "numConnectionsChanged"
-QT_MOC_LITERAL(2, 34, 0), // ""
-QT_MOC_LITERAL(3, 35, 5), // "count"
-QT_MOC_LITERAL(4, 41, 16), // "numBlocksChanged"
-QT_MOC_LITERAL(5, 58, 12), // "countOfPeers"
-QT_MOC_LITERAL(6, 71, 5), // "error"
-QT_MOC_LITERAL(7, 77, 5), // "title"
-QT_MOC_LITERAL(8, 83, 7), // "message"
-QT_MOC_LITERAL(9, 91, 5), // "modal"
-QT_MOC_LITERAL(10, 97, 11), // "updateTimer"
-QT_MOC_LITERAL(11, 109, 20), // "updateNumConnections"
-QT_MOC_LITERAL(12, 130, 14), // "numConnections"
-QT_MOC_LITERAL(13, 145, 11), // "updateAlert"
-QT_MOC_LITERAL(14, 157, 4), // "hash"
-QT_MOC_LITERAL(15, 162, 6) // "status"
-
-    },
-    "ClientModel\0numConnectionsChanged\0\0"
-    "count\0numBlocksChanged\0countOfPeers\0"
-    "error\0title\0message\0modal\0updateTimer\0"
-    "updateNumConnections\0numConnections\0"
-    "updateAlert\0hash\0status"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_ClientModel[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       6,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       3,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    1,   44,    2, 0x06 /* Public */,
-       4,    2,   47,    2, 0x06 /* Public */,
-       6,    3,   52,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-      10,    0,   59,    2, 0x0a /* Public */,
-      11,    1,   60,    2, 0x0a /* Public */,
-      13,    2,   63,    2, 0x0a /* Public */,
-
- // signals: parameters
-    QMetaType::Void, QMetaType::Int,    3,
-    QMetaType::Void, QMetaType::Int, QMetaType::Int,    3,    5,
-    QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::Bool,    7,    8,    9,
-
- // slots: parameters
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Int,   12,
-    QMetaType::Void, QMetaType::QString, QMetaType::Int,   14,   15,
-
-       0        // eod
-};
-
-void ClientModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<ClientModel *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->numConnectionsChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 1: _t->numBlocksChanged((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
-        case 2: _t->error((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3]))); break;
-        case 3: _t->updateTimer(); break;
-        case 4: _t->updateNumConnections((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 5: _t->updateAlert((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (ClientModel::*)(int );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ClientModel::numConnectionsChanged)) {
-                *result = 0;
-                return;
-            }
-        }
-        {
-            using _t = void (ClientModel::*)(int , int );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ClientModel::numBlocksChanged)) {
-                *result = 1;
-                return;
-            }
-        }
-        {
-            using _t = void (ClientModel::*)(const QString & , const QString & , bool );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ClientModel::error)) {
-                *result = 2;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject ClientModel::staticMetaObject = { {
-    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
-    qt_meta_stringdata_ClientModel.data,
-    qt_meta_data_ClientModel,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *ClientModel::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *ClientModel::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_ClientModel.stringdata0))
-        return static_cast<void*>(this);
-    return QObject::qt_metacast(_clname);
-}
-
-int ClientModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 6)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 6;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 6)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 6;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void ClientModel::numConnectionsChanged(int _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-
-// SIGNAL 1
-void ClientModel::numBlocksChanged(int _t1, int _t2)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
-    QMetaObject::activate(this, &staticMetaObject, 1, _a);
-}
-
-// SIGNAL 2
-void ClientModel::error(const QString & _t1, const QString & _t2, bool _t3)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
-    QMetaObject::activate(this, &staticMetaObject, 2, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_coincontroldialog.cpp

@@ -1,212 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'coincontroldialog.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/coincontroldialog.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'coincontroldialog.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_CoinControlDialog_t {
-    QByteArrayData data[23];
-    char stringdata0[353];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_CoinControlDialog_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_CoinControlDialog_t qt_meta_stringdata_CoinControlDialog = {
-    {
-QT_MOC_LITERAL(0, 0, 17), // "CoinControlDialog"
-QT_MOC_LITERAL(1, 18, 8), // "showMenu"
-QT_MOC_LITERAL(2, 27, 0), // ""
-QT_MOC_LITERAL(3, 28, 10), // "copyAmount"
-QT_MOC_LITERAL(4, 39, 9), // "copyLabel"
-QT_MOC_LITERAL(5, 49, 11), // "copyAddress"
-QT_MOC_LITERAL(6, 61, 19), // "copyTransactionHash"
-QT_MOC_LITERAL(7, 81, 17), // "clipboardQuantity"
-QT_MOC_LITERAL(8, 99, 15), // "clipboardAmount"
-QT_MOC_LITERAL(9, 115, 12), // "clipboardFee"
-QT_MOC_LITERAL(10, 128, 17), // "clipboardAfterFee"
-QT_MOC_LITERAL(11, 146, 14), // "clipboardBytes"
-QT_MOC_LITERAL(12, 161, 17), // "clipboardPriority"
-QT_MOC_LITERAL(13, 179, 18), // "clipboardLowOutput"
-QT_MOC_LITERAL(14, 198, 15), // "clipboardChange"
-QT_MOC_LITERAL(15, 214, 13), // "radioTreeMode"
-QT_MOC_LITERAL(16, 228, 13), // "radioListMode"
-QT_MOC_LITERAL(17, 242, 15), // "viewItemChanged"
-QT_MOC_LITERAL(18, 258, 16), // "QTreeWidgetItem*"
-QT_MOC_LITERAL(19, 275, 20), // "headerSectionClicked"
-QT_MOC_LITERAL(20, 296, 16), // "buttonBoxClicked"
-QT_MOC_LITERAL(21, 313, 16), // "QAbstractButton*"
-QT_MOC_LITERAL(22, 330, 22) // "buttonSelectAllClicked"
-
-    },
-    "CoinControlDialog\0showMenu\0\0copyAmount\0"
-    "copyLabel\0copyAddress\0copyTransactionHash\0"
-    "clipboardQuantity\0clipboardAmount\0"
-    "clipboardFee\0clipboardAfterFee\0"
-    "clipboardBytes\0clipboardPriority\0"
-    "clipboardLowOutput\0clipboardChange\0"
-    "radioTreeMode\0radioListMode\0viewItemChanged\0"
-    "QTreeWidgetItem*\0headerSectionClicked\0"
-    "buttonBoxClicked\0QAbstractButton*\0"
-    "buttonSelectAllClicked"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_CoinControlDialog[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      19,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    1,  109,    2, 0x08 /* Private */,
-       3,    0,  112,    2, 0x08 /* Private */,
-       4,    0,  113,    2, 0x08 /* Private */,
-       5,    0,  114,    2, 0x08 /* Private */,
-       6,    0,  115,    2, 0x08 /* Private */,
-       7,    0,  116,    2, 0x08 /* Private */,
-       8,    0,  117,    2, 0x08 /* Private */,
-       9,    0,  118,    2, 0x08 /* Private */,
-      10,    0,  119,    2, 0x08 /* Private */,
-      11,    0,  120,    2, 0x08 /* Private */,
-      12,    0,  121,    2, 0x08 /* Private */,
-      13,    0,  122,    2, 0x08 /* Private */,
-      14,    0,  123,    2, 0x08 /* Private */,
-      15,    1,  124,    2, 0x08 /* Private */,
-      16,    1,  127,    2, 0x08 /* Private */,
-      17,    2,  130,    2, 0x08 /* Private */,
-      19,    1,  135,    2, 0x08 /* Private */,
-      20,    1,  138,    2, 0x08 /* Private */,
-      22,    0,  141,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::QPoint,    2,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Bool,    2,
-    QMetaType::Void, QMetaType::Bool,    2,
-    QMetaType::Void, 0x80000000 | 18, QMetaType::Int,    2,    2,
-    QMetaType::Void, QMetaType::Int,    2,
-    QMetaType::Void, 0x80000000 | 21,    2,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void CoinControlDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<CoinControlDialog *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->showMenu((*reinterpret_cast< const QPoint(*)>(_a[1]))); break;
-        case 1: _t->copyAmount(); break;
-        case 2: _t->copyLabel(); break;
-        case 3: _t->copyAddress(); break;
-        case 4: _t->copyTransactionHash(); break;
-        case 5: _t->clipboardQuantity(); break;
-        case 6: _t->clipboardAmount(); break;
-        case 7: _t->clipboardFee(); break;
-        case 8: _t->clipboardAfterFee(); break;
-        case 9: _t->clipboardBytes(); break;
-        case 10: _t->clipboardPriority(); break;
-        case 11: _t->clipboardLowOutput(); break;
-        case 12: _t->clipboardChange(); break;
-        case 13: _t->radioTreeMode((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 14: _t->radioListMode((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 15: _t->viewItemChanged((*reinterpret_cast< QTreeWidgetItem*(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
-        case 16: _t->headerSectionClicked((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 17: _t->buttonBoxClicked((*reinterpret_cast< QAbstractButton*(*)>(_a[1]))); break;
-        case 18: _t->buttonSelectAllClicked(); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        switch (_id) {
-        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
-        case 17:
-            switch (*reinterpret_cast<int*>(_a[1])) {
-            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
-            case 0:
-                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QAbstractButton* >(); break;
-            }
-            break;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject CoinControlDialog::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_CoinControlDialog.data,
-    qt_meta_data_CoinControlDialog,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *CoinControlDialog::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *CoinControlDialog::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_CoinControlDialog.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int CoinControlDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 19)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 19;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 19)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 19;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_coincontroltreewidget.cpp

@@ -1,95 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'coincontroltreewidget.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/coincontroltreewidget.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'coincontroltreewidget.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_CoinControlTreeWidget_t {
-    QByteArrayData data[1];
-    char stringdata0[22];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_CoinControlTreeWidget_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_CoinControlTreeWidget_t qt_meta_stringdata_CoinControlTreeWidget = {
-    {
-QT_MOC_LITERAL(0, 0, 21) // "CoinControlTreeWidget"
-
-    },
-    "CoinControlTreeWidget"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_CoinControlTreeWidget[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
-       0        // eod
-};
-
-void CoinControlTreeWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    (void)_o;
-    (void)_id;
-    (void)_c;
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject CoinControlTreeWidget::staticMetaObject = { {
-    QMetaObject::SuperData::link<QTreeWidget::staticMetaObject>(),
-    qt_meta_stringdata_CoinControlTreeWidget.data,
-    qt_meta_data_CoinControlTreeWidget,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *CoinControlTreeWidget::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *CoinControlTreeWidget::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_CoinControlTreeWidget.stringdata0))
-        return static_cast<void*>(this);
-    return QTreeWidget::qt_metacast(_clname);
-}
-
-int CoinControlTreeWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QTreeWidget::qt_metacall(_c, _id, _a);
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_csvmodelwriter.cpp

@@ -1,95 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'csvmodelwriter.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/csvmodelwriter.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'csvmodelwriter.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_CSVModelWriter_t {
-    QByteArrayData data[1];
-    char stringdata0[15];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_CSVModelWriter_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_CSVModelWriter_t qt_meta_stringdata_CSVModelWriter = {
-    {
-QT_MOC_LITERAL(0, 0, 14) // "CSVModelWriter"
-
-    },
-    "CSVModelWriter"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_CSVModelWriter[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
-       0        // eod
-};
-
-void CSVModelWriter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    (void)_o;
-    (void)_id;
-    (void)_c;
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject CSVModelWriter::staticMetaObject = { {
-    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
-    qt_meta_stringdata_CSVModelWriter.data,
-    qt_meta_data_CSVModelWriter,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *CSVModelWriter::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *CSVModelWriter::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_CSVModelWriter.stringdata0))
-        return static_cast<void*>(this);
-    return QObject::qt_metacast(_clname);
-}
-
-int CSVModelWriter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_dialog_move_handler.cpp

@@ -1,95 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'dialog_move_handler.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/dialog_move_handler.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'dialog_move_handler.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_DialogMoveHandler_t {
-    QByteArrayData data[1];
-    char stringdata0[18];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_DialogMoveHandler_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_DialogMoveHandler_t qt_meta_stringdata_DialogMoveHandler = {
-    {
-QT_MOC_LITERAL(0, 0, 17) // "DialogMoveHandler"
-
-    },
-    "DialogMoveHandler"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_DialogMoveHandler[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
-       0        // eod
-};
-
-void DialogMoveHandler::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    (void)_o;
-    (void)_id;
-    (void)_c;
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject DialogMoveHandler::staticMetaObject = { {
-    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
-    qt_meta_stringdata_DialogMoveHandler.data,
-    qt_meta_data_DialogMoveHandler,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *DialogMoveHandler::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *DialogMoveHandler::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_DialogMoveHandler.stringdata0))
-        return static_cast<void*>(this);
-    return QObject::qt_metacast(_clname);
-}
-
-int DialogMoveHandler::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_editaddressdialog.cpp

@@ -1,119 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'editaddressdialog.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/editaddressdialog.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'editaddressdialog.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_EditAddressDialog_t {
-    QByteArrayData data[3];
-    char stringdata0[26];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_EditAddressDialog_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_EditAddressDialog_t qt_meta_stringdata_EditAddressDialog = {
-    {
-QT_MOC_LITERAL(0, 0, 17), // "EditAddressDialog"
-QT_MOC_LITERAL(1, 18, 6), // "accept"
-QT_MOC_LITERAL(2, 25, 0) // ""
-
-    },
-    "EditAddressDialog\0accept\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_EditAddressDialog[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       1,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    0,   19,    2, 0x0a /* Public */,
-
- // slots: parameters
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void EditAddressDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<EditAddressDialog *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->accept(); break;
-        default: ;
-        }
-    }
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject EditAddressDialog::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_EditAddressDialog.data,
-    qt_meta_data_EditAddressDialog,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *EditAddressDialog::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *EditAddressDialog::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_EditAddressDialog.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int EditAddressDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 1)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 1;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 1)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 1;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_guiutil.cpp

@@ -1,165 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'guiutil.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/guiutil.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'guiutil.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter_t {
-    QByteArrayData data[1];
-    char stringdata0[33];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter_t qt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter = {
-    {
-QT_MOC_LITERAL(0, 0, 32) // "GUIUtil::ToolTipToRichTextFilter"
-
-    },
-    "GUIUtil::ToolTipToRichTextFilter"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_GUIUtil__ToolTipToRichTextFilter[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
-       0        // eod
-};
-
-void GUIUtil::ToolTipToRichTextFilter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    (void)_o;
-    (void)_id;
-    (void)_c;
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject GUIUtil::ToolTipToRichTextFilter::staticMetaObject = { {
-    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
-    qt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter.data,
-    qt_meta_data_GUIUtil__ToolTipToRichTextFilter,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *GUIUtil::ToolTipToRichTextFilter::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *GUIUtil::ToolTipToRichTextFilter::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_GUIUtil__ToolTipToRichTextFilter.stringdata0))
-        return static_cast<void*>(this);
-    return QObject::qt_metacast(_clname);
-}
-
-int GUIUtil::ToolTipToRichTextFilter::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    return _id;
-}
-struct qt_meta_stringdata_GUIUtil__HelpMessageBox_t {
-    QByteArrayData data[1];
-    char stringdata0[24];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_GUIUtil__HelpMessageBox_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_GUIUtil__HelpMessageBox_t qt_meta_stringdata_GUIUtil__HelpMessageBox = {
-    {
-QT_MOC_LITERAL(0, 0, 23) // "GUIUtil::HelpMessageBox"
-
-    },
-    "GUIUtil::HelpMessageBox"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_GUIUtil__HelpMessageBox[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       0,    0, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
-       0        // eod
-};
-
-void GUIUtil::HelpMessageBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    (void)_o;
-    (void)_id;
-    (void)_c;
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject GUIUtil::HelpMessageBox::staticMetaObject = { {
-    QMetaObject::SuperData::link<QMessageBox::staticMetaObject>(),
-    qt_meta_stringdata_GUIUtil__HelpMessageBox.data,
-    qt_meta_data_GUIUtil__HelpMessageBox,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *GUIUtil::HelpMessageBox::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *GUIUtil::HelpMessageBox::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_GUIUtil__HelpMessageBox.stringdata0))
-        return static_cast<void*>(this);
-    return QMessageBox::qt_metacast(_clname);
-}
-
-int GUIUtil::HelpMessageBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QMessageBox::qt_metacall(_c, _id, _a);
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_messagemodel.cpp

@@ -1,163 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'messagemodel.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/messagemodel.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'messagemodel.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_MessageModel_t {
-    QByteArrayData data[13];
-    char stringdata0[128];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_MessageModel_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_MessageModel_t qt_meta_stringdata_MessageModel = {
-    {
-QT_MOC_LITERAL(0, 0, 12), // "MessageModel"
-QT_MOC_LITERAL(1, 13, 5), // "error"
-QT_MOC_LITERAL(2, 19, 0), // ""
-QT_MOC_LITERAL(3, 20, 5), // "title"
-QT_MOC_LITERAL(4, 26, 7), // "message"
-QT_MOC_LITERAL(5, 34, 5), // "modal"
-QT_MOC_LITERAL(6, 40, 10), // "newMessage"
-QT_MOC_LITERAL(7, 51, 12), // "SecMsgStored"
-QT_MOC_LITERAL(8, 64, 4), // "smsg"
-QT_MOC_LITERAL(9, 69, 16), // "newOutboxMessage"
-QT_MOC_LITERAL(10, 86, 14), // "walletUnlocked"
-QT_MOC_LITERAL(11, 101, 19), // "setEncryptionStatus"
-QT_MOC_LITERAL(12, 121, 6) // "status"
-
-    },
-    "MessageModel\0error\0\0title\0message\0"
-    "modal\0newMessage\0SecMsgStored\0smsg\0"
-    "newOutboxMessage\0walletUnlocked\0"
-    "setEncryptionStatus\0status"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_MessageModel[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       5,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       1,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    3,   39,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       6,    1,   46,    2, 0x0a /* Public */,
-       9,    1,   49,    2, 0x0a /* Public */,
-      10,    0,   52,    2, 0x0a /* Public */,
-      11,    1,   53,    2, 0x0a /* Public */,
-
- // signals: parameters
-    QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::Bool,    3,    4,    5,
-
- // slots: parameters
-    QMetaType::Void, 0x80000000 | 7,    8,
-    QMetaType::Void, 0x80000000 | 7,    8,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Int,   12,
-
-       0        // eod
-};
-
-void MessageModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<MessageModel *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->error((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3]))); break;
-        case 1: _t->newMessage((*reinterpret_cast< const SecMsgStored(*)>(_a[1]))); break;
-        case 2: _t->newOutboxMessage((*reinterpret_cast< const SecMsgStored(*)>(_a[1]))); break;
-        case 3: _t->walletUnlocked(); break;
-        case 4: _t->setEncryptionStatus((*reinterpret_cast< int(*)>(_a[1]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (MessageModel::*)(const QString & , const QString & , bool );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MessageModel::error)) {
-                *result = 0;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject MessageModel::staticMetaObject = { {
-    QMetaObject::SuperData::link<QAbstractTableModel::staticMetaObject>(),
-    qt_meta_stringdata_MessageModel.data,
-    qt_meta_data_MessageModel,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *MessageModel::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *MessageModel::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_MessageModel.stringdata0))
-        return static_cast<void*>(this);
-    return QAbstractTableModel::qt_metacast(_clname);
-}
-
-int MessageModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QAbstractTableModel::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 5)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 5;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 5)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 5;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void MessageModel::error(const QString & _t1, const QString & _t2, bool _t3)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_messagepage.cpp

@@ -1,170 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'messagepage.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/messagepage.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'messagepage.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_MessagePage_t {
-    QByteArrayData data[15];
-    char stringdata0[274];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_MessagePage_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_MessagePage_t qt_meta_stringdata_MessagePage = {
-    {
-QT_MOC_LITERAL(0, 0, 11), // "MessagePage"
-QT_MOC_LITERAL(1, 12, 13), // "exportClicked"
-QT_MOC_LITERAL(2, 26, 0), // ""
-QT_MOC_LITERAL(3, 27, 21), // "on_sendButton_clicked"
-QT_MOC_LITERAL(4, 49, 20), // "on_newButton_clicked"
-QT_MOC_LITERAL(5, 70, 32), // "on_copyFromAddressButton_clicked"
-QT_MOC_LITERAL(6, 103, 30), // "on_copyToAddressButton_clicked"
-QT_MOC_LITERAL(7, 134, 23), // "on_deleteButton_clicked"
-QT_MOC_LITERAL(8, 158, 21), // "on_backButton_clicked"
-QT_MOC_LITERAL(9, 180, 18), // "messageTextChanged"
-QT_MOC_LITERAL(10, 199, 16), // "selectionChanged"
-QT_MOC_LITERAL(11, 216, 20), // "itemSelectionChanged"
-QT_MOC_LITERAL(12, 237, 15), // "incomingMessage"
-QT_MOC_LITERAL(13, 253, 14), // "contextualMenu"
-QT_MOC_LITERAL(14, 268, 5) // "point"
-
-    },
-    "MessagePage\0exportClicked\0\0"
-    "on_sendButton_clicked\0on_newButton_clicked\0"
-    "on_copyFromAddressButton_clicked\0"
-    "on_copyToAddressButton_clicked\0"
-    "on_deleteButton_clicked\0on_backButton_clicked\0"
-    "messageTextChanged\0selectionChanged\0"
-    "itemSelectionChanged\0incomingMessage\0"
-    "contextualMenu\0point"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_MessagePage[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      12,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    0,   74,    2, 0x0a /* Public */,
-       3,    0,   75,    2, 0x08 /* Private */,
-       4,    0,   76,    2, 0x08 /* Private */,
-       5,    0,   77,    2, 0x08 /* Private */,
-       6,    0,   78,    2, 0x08 /* Private */,
-       7,    0,   79,    2, 0x08 /* Private */,
-       8,    0,   80,    2, 0x08 /* Private */,
-       9,    0,   81,    2, 0x08 /* Private */,
-      10,    0,   82,    2, 0x08 /* Private */,
-      11,    0,   83,    2, 0x08 /* Private */,
-      12,    0,   84,    2, 0x08 /* Private */,
-      13,    1,   85,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::QPoint,   14,
-
-       0        // eod
-};
-
-void MessagePage::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<MessagePage *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->exportClicked(); break;
-        case 1: _t->on_sendButton_clicked(); break;
-        case 2: _t->on_newButton_clicked(); break;
-        case 3: _t->on_copyFromAddressButton_clicked(); break;
-        case 4: _t->on_copyToAddressButton_clicked(); break;
-        case 5: _t->on_deleteButton_clicked(); break;
-        case 6: _t->on_backButton_clicked(); break;
-        case 7: _t->messageTextChanged(); break;
-        case 8: _t->selectionChanged(); break;
-        case 9: _t->itemSelectionChanged(); break;
-        case 10: _t->incomingMessage(); break;
-        case 11: _t->contextualMenu((*reinterpret_cast< const QPoint(*)>(_a[1]))); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject MessagePage::staticMetaObject = { {
-    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
-    qt_meta_stringdata_MessagePage.data,
-    qt_meta_data_MessagePage,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *MessagePage::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *MessagePage::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_MessagePage.stringdata0))
-        return static_cast<void*>(this);
-    return QWidget::qt_metacast(_clname);
-}
-
-int MessagePage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QWidget::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 12)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 12;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 12)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 12;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_monitoreddatamapper.cpp

@@ -1,134 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'monitoreddatamapper.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/monitoreddatamapper.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'monitoreddatamapper.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_MonitoredDataMapper_t {
-    QByteArrayData data[3];
-    char stringdata0[34];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_MonitoredDataMapper_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_MonitoredDataMapper_t qt_meta_stringdata_MonitoredDataMapper = {
-    {
-QT_MOC_LITERAL(0, 0, 19), // "MonitoredDataMapper"
-QT_MOC_LITERAL(1, 20, 12), // "viewModified"
-QT_MOC_LITERAL(2, 33, 0) // ""
-
-    },
-    "MonitoredDataMapper\0viewModified\0"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_MonitoredDataMapper[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       1,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       1,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    0,   19,    2, 0x06 /* Public */,
-
- // signals: parameters
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void MonitoredDataMapper::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<MonitoredDataMapper *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->viewModified(); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (MonitoredDataMapper::*)();
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MonitoredDataMapper::viewModified)) {
-                *result = 0;
-                return;
-            }
-        }
-    }
-    (void)_a;
-}
-
-QT_INIT_METAOBJECT const QMetaObject MonitoredDataMapper::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDataWidgetMapper::staticMetaObject>(),
-    qt_meta_stringdata_MonitoredDataMapper.data,
-    qt_meta_data_MonitoredDataMapper,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *MonitoredDataMapper::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *MonitoredDataMapper::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_MonitoredDataMapper.stringdata0))
-        return static_cast<void*>(this);
-    return QDataWidgetMapper::qt_metacast(_clname);
-}
-
-int MonitoredDataMapper::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDataWidgetMapper::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 1)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 1;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 1)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 1;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void MonitoredDataMapper::viewModified()
-{
-    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_mrichtextedit.cpp

@@ -1,206 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'mrichtextedit.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/plugins/mrichtexteditor/mrichtextedit.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'mrichtextedit.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_MRichTextEdit_t {
-    QByteArrayData data[27];
-    char stringdata0[325];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_MRichTextEdit_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_MRichTextEdit_t qt_meta_stringdata_MRichTextEdit = {
-    {
-QT_MOC_LITERAL(0, 0, 13), // "MRichTextEdit"
-QT_MOC_LITERAL(1, 14, 7), // "setText"
-QT_MOC_LITERAL(2, 22, 0), // ""
-QT_MOC_LITERAL(3, 23, 4), // "text"
-QT_MOC_LITERAL(4, 28, 5), // "clear"
-QT_MOC_LITERAL(5, 34, 12), // "setPlainText"
-QT_MOC_LITERAL(6, 47, 7), // "setHtml"
-QT_MOC_LITERAL(7, 55, 8), // "textBold"
-QT_MOC_LITERAL(8, 64, 13), // "textUnderline"
-QT_MOC_LITERAL(9, 78, 13), // "textStrikeout"
-QT_MOC_LITERAL(10, 92, 10), // "textItalic"
-QT_MOC_LITERAL(11, 103, 8), // "textSize"
-QT_MOC_LITERAL(12, 112, 1), // "p"
-QT_MOC_LITERAL(13, 114, 8), // "textLink"
-QT_MOC_LITERAL(14, 123, 7), // "checked"
-QT_MOC_LITERAL(15, 131, 9), // "textStyle"
-QT_MOC_LITERAL(16, 141, 5), // "index"
-QT_MOC_LITERAL(17, 147, 11), // "textBgColor"
-QT_MOC_LITERAL(18, 159, 10), // "listBullet"
-QT_MOC_LITERAL(19, 170, 11), // "listOrdered"
-QT_MOC_LITERAL(20, 182, 28), // "slotCurrentCharFormatChanged"
-QT_MOC_LITERAL(21, 211, 15), // "QTextCharFormat"
-QT_MOC_LITERAL(22, 227, 6), // "format"
-QT_MOC_LITERAL(23, 234, 25), // "slotCursorPositionChanged"
-QT_MOC_LITERAL(24, 260, 24), // "slotClipboardDataChanged"
-QT_MOC_LITERAL(25, 285, 19), // "increaseIndentation"
-QT_MOC_LITERAL(26, 305, 19) // "decreaseIndentation"
-
-    },
-    "MRichTextEdit\0setText\0\0text\0clear\0"
-    "setPlainText\0setHtml\0textBold\0"
-    "textUnderline\0textStrikeout\0textItalic\0"
-    "textSize\0p\0textLink\0checked\0textStyle\0"
-    "index\0textBgColor\0listBullet\0listOrdered\0"
-    "slotCurrentCharFormatChanged\0"
-    "QTextCharFormat\0format\0slotCursorPositionChanged\0"
-    "slotClipboardDataChanged\0increaseIndentation\0"
-    "decreaseIndentation"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_MRichTextEdit[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      19,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    1,  109,    2, 0x0a /* Public */,
-       4,    0,  112,    2, 0x0a /* Public */,
-       5,    1,  113,    2, 0x09 /* Protected */,
-       6,    1,  116,    2, 0x09 /* Protected */,
-       7,    0,  119,    2, 0x09 /* Protected */,
-       8,    0,  120,    2, 0x09 /* Protected */,
-       9,    0,  121,    2, 0x09 /* Protected */,
-      10,    0,  122,    2, 0x09 /* Protected */,
-      11,    1,  123,    2, 0x09 /* Protected */,
-      13,    1,  126,    2, 0x09 /* Protected */,
-      15,    1,  129,    2, 0x09 /* Protected */,
-      17,    0,  132,    2, 0x09 /* Protected */,
-      18,    1,  133,    2, 0x09 /* Protected */,
-      19,    1,  136,    2, 0x09 /* Protected */,
-      20,    1,  139,    2, 0x09 /* Protected */,
-      23,    0,  142,    2, 0x09 /* Protected */,
-      24,    0,  143,    2, 0x09 /* Protected */,
-      25,    0,  144,    2, 0x09 /* Protected */,
-      26,    0,  145,    2, 0x09 /* Protected */,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::QString,    3,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::QString,    3,
-    QMetaType::Void, QMetaType::QString,    3,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::QString,   12,
-    QMetaType::Void, QMetaType::Bool,   14,
-    QMetaType::Void, QMetaType::Int,   16,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Bool,   14,
-    QMetaType::Void, QMetaType::Bool,   14,
-    QMetaType::Void, 0x80000000 | 21,   22,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void MRichTextEdit::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<MRichTextEdit *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->setText((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 1: _t->clear(); break;
-        case 2: _t->setPlainText((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 3: _t->setHtml((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 4: _t->textBold(); break;
-        case 5: _t->textUnderline(); break;
-        case 6: _t->textStrikeout(); break;
-        case 7: _t->textItalic(); break;
-        case 8: _t->textSize((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 9: _t->textLink((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 10: _t->textStyle((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 11: _t->textBgColor(); break;
-        case 12: _t->listBullet((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 13: _t->listOrdered((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 14: _t->slotCurrentCharFormatChanged((*reinterpret_cast< const QTextCharFormat(*)>(_a[1]))); break;
-        case 15: _t->slotCursorPositionChanged(); break;
-        case 16: _t->slotClipboardDataChanged(); break;
-        case 17: _t->increaseIndentation(); break;
-        case 18: _t->decreaseIndentation(); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject MRichTextEdit::staticMetaObject = { {
-    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
-    qt_meta_stringdata_MRichTextEdit.data,
-    qt_meta_data_MRichTextEdit,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *MRichTextEdit::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *MRichTextEdit::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_MRichTextEdit.stringdata0))
-        return static_cast<void*>(this);
-    if (!strcmp(_clname, "Ui::MRichTextEdit"))
-        return static_cast< Ui::MRichTextEdit*>(this);
-    return QWidget::qt_metacast(_clname);
-}
-
-int MRichTextEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QWidget::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 19)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 19;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 19)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 19;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_notificator.cpp

@@ -1,131 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'notificator.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/notificator.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'notificator.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_Notificator_t {
-    QByteArrayData data[9];
-    char stringdata0[60];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_Notificator_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_Notificator_t qt_meta_stringdata_Notificator = {
-    {
-QT_MOC_LITERAL(0, 0, 11), // "Notificator"
-QT_MOC_LITERAL(1, 12, 6), // "notify"
-QT_MOC_LITERAL(2, 19, 0), // ""
-QT_MOC_LITERAL(3, 20, 5), // "Class"
-QT_MOC_LITERAL(4, 26, 3), // "cls"
-QT_MOC_LITERAL(5, 30, 5), // "title"
-QT_MOC_LITERAL(6, 36, 4), // "text"
-QT_MOC_LITERAL(7, 41, 4), // "icon"
-QT_MOC_LITERAL(8, 46, 13) // "millisTimeout"
-
-    },
-    "Notificator\0notify\0\0Class\0cls\0title\0"
-    "text\0icon\0millisTimeout"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_Notificator[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       3,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    5,   29,    2, 0x0a /* Public */,
-       1,    4,   40,    2, 0x2a /* Public | MethodCloned */,
-       1,    3,   49,    2, 0x2a /* Public | MethodCloned */,
-
- // slots: parameters
-    QMetaType::Void, 0x80000000 | 3, QMetaType::QString, QMetaType::QString, QMetaType::QIcon, QMetaType::Int,    4,    5,    6,    7,    8,
-    QMetaType::Void, 0x80000000 | 3, QMetaType::QString, QMetaType::QString, QMetaType::QIcon,    4,    5,    6,    7,
-    QMetaType::Void, 0x80000000 | 3, QMetaType::QString, QMetaType::QString,    4,    5,    6,
-
-       0        // eod
-};
-
-void Notificator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<Notificator *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->notify((*reinterpret_cast< Class(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])),(*reinterpret_cast< const QIcon(*)>(_a[4])),(*reinterpret_cast< int(*)>(_a[5]))); break;
-        case 1: _t->notify((*reinterpret_cast< Class(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])),(*reinterpret_cast< const QIcon(*)>(_a[4]))); break;
-        case 2: _t->notify((*reinterpret_cast< Class(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject Notificator::staticMetaObject = { {
-    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
-    qt_meta_stringdata_Notificator.data,
-    qt_meta_data_Notificator,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *Notificator::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *Notificator::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_Notificator.stringdata0))
-        return static_cast<void*>(this);
-    return QObject::qt_metacast(_clname);
-}
-
-int Notificator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QObject::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 3)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 3;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 3)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 3;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_optionsdialog.cpp

@@ -1,204 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'optionsdialog.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/optionsdialog.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'optionsdialog.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_OptionsDialog_t {
-    QByteArrayData data[21];
-    char stringdata0[340];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_OptionsDialog_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_OptionsDialog_t qt_meta_stringdata_OptionsDialog = {
-    {
-QT_MOC_LITERAL(0, 0, 13), // "OptionsDialog"
-QT_MOC_LITERAL(1, 14, 12), // "proxyIpValid"
-QT_MOC_LITERAL(2, 27, 0), // ""
-QT_MOC_LITERAL(3, 28, 19), // "QValidatedLineEdit*"
-QT_MOC_LITERAL(4, 48, 6), // "object"
-QT_MOC_LITERAL(5, 55, 6), // "fValid"
-QT_MOC_LITERAL(6, 62, 17), // "enableApplyButton"
-QT_MOC_LITERAL(7, 80, 18), // "disableApplyButton"
-QT_MOC_LITERAL(8, 99, 17), // "enableSaveButtons"
-QT_MOC_LITERAL(9, 117, 18), // "disableSaveButtons"
-QT_MOC_LITERAL(10, 136, 18), // "setSaveButtonState"
-QT_MOC_LITERAL(11, 155, 6), // "fState"
-QT_MOC_LITERAL(12, 162, 19), // "on_okButton_clicked"
-QT_MOC_LITERAL(13, 182, 23), // "on_cancelButton_clicked"
-QT_MOC_LITERAL(14, 206, 22), // "on_applyButton_clicked"
-QT_MOC_LITERAL(15, 229, 24), // "showRestartWarning_Proxy"
-QT_MOC_LITERAL(16, 254, 23), // "showRestartWarning_Lang"
-QT_MOC_LITERAL(17, 278, 17), // "updateDisplayUnit"
-QT_MOC_LITERAL(18, 296, 18), // "handleProxyIpValid"
-QT_MOC_LITERAL(19, 315, 16), // "applyTorDefaults"
-QT_MOC_LITERAL(20, 332, 7) // "enabled"
-
-    },
-    "OptionsDialog\0proxyIpValid\0\0"
-    "QValidatedLineEdit*\0object\0fValid\0"
-    "enableApplyButton\0disableApplyButton\0"
-    "enableSaveButtons\0disableSaveButtons\0"
-    "setSaveButtonState\0fState\0on_okButton_clicked\0"
-    "on_cancelButton_clicked\0on_applyButton_clicked\0"
-    "showRestartWarning_Proxy\0"
-    "showRestartWarning_Lang\0updateDisplayUnit\0"
-    "handleProxyIpValid\0applyTorDefaults\0"
-    "enabled"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_OptionsDialog[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      14,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       1,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    2,   84,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       6,    0,   89,    2, 0x08 /* Private */,
-       7,    0,   90,    2, 0x08 /* Private */,
-       8,    0,   91,    2, 0x08 /* Private */,
-       9,    0,   92,    2, 0x08 /* Private */,
-      10,    1,   93,    2, 0x08 /* Private */,
-      12,    0,   96,    2, 0x08 /* Private */,
-      13,    0,   97,    2, 0x08 /* Private */,
-      14,    0,   98,    2, 0x08 /* Private */,
-      15,    0,   99,    2, 0x08 /* Private */,
-      16,    0,  100,    2, 0x08 /* Private */,
-      17,    0,  101,    2, 0x08 /* Private */,
-      18,    2,  102,    2, 0x08 /* Private */,
-      19,    1,  107,    2, 0x08 /* Private */,
-
- // signals: parameters
-    QMetaType::Void, 0x80000000 | 3, QMetaType::Bool,    4,    5,
-
- // slots: parameters
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Bool,   11,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, 0x80000000 | 3, QMetaType::Bool,    4,   11,
-    QMetaType::Void, QMetaType::Bool,   20,
-
-       0        // eod
-};
-
-void OptionsDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<OptionsDialog *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->proxyIpValid((*reinterpret_cast< QValidatedLineEdit*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
-        case 1: _t->enableApplyButton(); break;
-        case 2: _t->disableApplyButton(); break;
-        case 3: _t->enableSaveButtons(); break;
-        case 4: _t->disableSaveButtons(); break;
-        case 5: _t->setSaveButtonState((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 6: _t->on_okButton_clicked(); break;
-        case 7: _t->on_cancelButton_clicked(); break;
-        case 8: _t->on_applyButton_clicked(); break;
-        case 9: _t->showRestartWarning_Proxy(); break;
-        case 10: _t->showRestartWarning_Lang(); break;
-        case 11: _t->updateDisplayUnit(); break;
-        case 12: _t->handleProxyIpValid((*reinterpret_cast< QValidatedLineEdit*(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
-        case 13: _t->applyTorDefaults((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (OptionsDialog::*)(QValidatedLineEdit * , bool );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&OptionsDialog::proxyIpValid)) {
-                *result = 0;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject OptionsDialog::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_OptionsDialog.data,
-    qt_meta_data_OptionsDialog,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *OptionsDialog::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *OptionsDialog::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_OptionsDialog.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int OptionsDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 14)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 14;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 14)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 14;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void OptionsDialog::proxyIpValid(QValidatedLineEdit * _t1, bool _t2)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_optionsmodel.cpp

@@ -1,191 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'optionsmodel.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/optionsmodel.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'optionsmodel.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_OptionsModel_t {
-    QByteArrayData data[7];
-    char stringdata0[109];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_OptionsModel_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_OptionsModel_t qt_meta_stringdata_OptionsModel = {
-    {
-QT_MOC_LITERAL(0, 0, 12), // "OptionsModel"
-QT_MOC_LITERAL(1, 13, 18), // "displayUnitChanged"
-QT_MOC_LITERAL(2, 32, 0), // ""
-QT_MOC_LITERAL(3, 33, 4), // "unit"
-QT_MOC_LITERAL(4, 38, 21), // "transactionFeeChanged"
-QT_MOC_LITERAL(5, 60, 21), // "reserveBalanceChanged"
-QT_MOC_LITERAL(6, 82, 26) // "coinControlFeaturesChanged"
-
-    },
-    "OptionsModel\0displayUnitChanged\0\0unit\0"
-    "transactionFeeChanged\0reserveBalanceChanged\0"
-    "coinControlFeaturesChanged"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_OptionsModel[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       4,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       4,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    1,   34,    2, 0x06 /* Public */,
-       4,    1,   37,    2, 0x06 /* Public */,
-       5,    1,   40,    2, 0x06 /* Public */,
-       6,    1,   43,    2, 0x06 /* Public */,
-
- // signals: parameters
-    QMetaType::Void, QMetaType::Int,    3,
-    QMetaType::Void, QMetaType::LongLong,    2,
-    QMetaType::Void, QMetaType::LongLong,    2,
-    QMetaType::Void, QMetaType::Bool,    2,
-
-       0        // eod
-};
-
-void OptionsModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<OptionsModel *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->displayUnitChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 1: _t->transactionFeeChanged((*reinterpret_cast< qint64(*)>(_a[1]))); break;
-        case 2: _t->reserveBalanceChanged((*reinterpret_cast< qint64(*)>(_a[1]))); break;
-        case 3: _t->coinControlFeaturesChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (OptionsModel::*)(int );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&OptionsModel::displayUnitChanged)) {
-                *result = 0;
-                return;
-            }
-        }
-        {
-            using _t = void (OptionsModel::*)(qint64 );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&OptionsModel::transactionFeeChanged)) {
-                *result = 1;
-                return;
-            }
-        }
-        {
-            using _t = void (OptionsModel::*)(qint64 );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&OptionsModel::reserveBalanceChanged)) {
-                *result = 2;
-                return;
-            }
-        }
-        {
-            using _t = void (OptionsModel::*)(bool );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&OptionsModel::coinControlFeaturesChanged)) {
-                *result = 3;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject OptionsModel::staticMetaObject = { {
-    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
-    qt_meta_stringdata_OptionsModel.data,
-    qt_meta_data_OptionsModel,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *OptionsModel::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *OptionsModel::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_OptionsModel.stringdata0))
-        return static_cast<void*>(this);
-    return QAbstractListModel::qt_metacast(_clname);
-}
-
-int OptionsModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 4)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 4;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 4)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 4;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void OptionsModel::displayUnitChanged(int _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-
-// SIGNAL 1
-void OptionsModel::transactionFeeChanged(qint64 _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 1, _a);
-}
-
-// SIGNAL 2
-void OptionsModel::reserveBalanceChanged(qint64 _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 2, _a);
-}
-
-// SIGNAL 3
-void OptionsModel::coinControlFeaturesChanged(bool _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 3, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_overviewpage.cpp

@@ -1,159 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'overviewpage.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/overviewpage.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'overviewpage.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_OverviewPage_t {
-    QByteArrayData data[12];
-    char stringdata0[154];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_OverviewPage_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_OverviewPage_t qt_meta_stringdata_OverviewPage = {
-    {
-QT_MOC_LITERAL(0, 0, 12), // "OverviewPage"
-QT_MOC_LITERAL(1, 13, 18), // "transactionClicked"
-QT_MOC_LITERAL(2, 32, 0), // ""
-QT_MOC_LITERAL(3, 33, 11), // "QModelIndex"
-QT_MOC_LITERAL(4, 45, 5), // "index"
-QT_MOC_LITERAL(5, 51, 10), // "setBalance"
-QT_MOC_LITERAL(6, 62, 7), // "balance"
-QT_MOC_LITERAL(7, 70, 5), // "stake"
-QT_MOC_LITERAL(8, 76, 18), // "unconfirmedBalance"
-QT_MOC_LITERAL(9, 95, 15), // "immatureBalance"
-QT_MOC_LITERAL(10, 111, 17), // "updateDisplayUnit"
-QT_MOC_LITERAL(11, 129, 24) // "handleTransactionClicked"
-
-    },
-    "OverviewPage\0transactionClicked\0\0"
-    "QModelIndex\0index\0setBalance\0balance\0"
-    "stake\0unconfirmedBalance\0immatureBalance\0"
-    "updateDisplayUnit\0handleTransactionClicked"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_OverviewPage[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       4,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       1,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    1,   34,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       5,    4,   37,    2, 0x0a /* Public */,
-      10,    0,   46,    2, 0x08 /* Private */,
-      11,    1,   47,    2, 0x08 /* Private */,
-
- // signals: parameters
-    QMetaType::Void, 0x80000000 | 3,    4,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::LongLong, QMetaType::LongLong, QMetaType::LongLong, QMetaType::LongLong,    6,    7,    8,    9,
-    QMetaType::Void,
-    QMetaType::Void, 0x80000000 | 3,    4,
-
-       0        // eod
-};
-
-void OverviewPage::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<OverviewPage *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->transactionClicked((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
-        case 1: _t->setBalance((*reinterpret_cast< qint64(*)>(_a[1])),(*reinterpret_cast< qint64(*)>(_a[2])),(*reinterpret_cast< qint64(*)>(_a[3])),(*reinterpret_cast< qint64(*)>(_a[4]))); break;
-        case 2: _t->updateDisplayUnit(); break;
-        case 3: _t->handleTransactionClicked((*reinterpret_cast< const QModelIndex(*)>(_a[1]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (OverviewPage::*)(const QModelIndex & );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&OverviewPage::transactionClicked)) {
-                *result = 0;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject OverviewPage::staticMetaObject = { {
-    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
-    qt_meta_stringdata_OverviewPage.data,
-    qt_meta_data_OverviewPage,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *OverviewPage::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *OverviewPage::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_OverviewPage.stringdata0))
-        return static_cast<void*>(this);
-    return QWidget::qt_metacast(_clname);
-}
-
-int OverviewPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QWidget::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 4)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 4;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 4)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 4;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void OverviewPage::transactionClicked(const QModelIndex & _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_predefs.h

@@ -1,484 +0,0 @@
-#define __DBL_MIN_EXP__ (-1021)
-#define __LDBL_MANT_DIG__ 64
-#define __cpp_nontype_template_parameter_auto 201606L
-#define __UINT_LEAST16_MAX__ 0xffff
-#define __FLT16_HAS_QUIET_NAN__ 1
-#define __ATOMIC_ACQUIRE 2
-#define __FLT128_MAX_10_EXP__ 4932
-#define __FLT_MIN__ 1.17549435082228750796873653722224568e-38F
-#define __GCC_IEC_559_COMPLEX 2
-#define __cpp_aggregate_nsdmi 201304L
-#define __UINT_LEAST8_TYPE__ unsigned char
-#define __SIZEOF_FLOAT80__ 16
-#define __BFLT16_DENORM_MIN__ 9.18354961579912115600575419704879436e-41BF16
-#define __INTMAX_C(c) c ## LL
-#define __CHAR_BIT__ 8
-#define __MINGW32__ 1
-#define __UINT8_MAX__ 0xff
-#define __SCHAR_WIDTH__ 8
-#define _WIN64 1
-#define __WINT_MAX__ 0xffff
-#define __FLT32_MIN_EXP__ (-125)
-#define __cpp_static_assert 201411L
-#define __BFLT16_MIN_10_EXP__ (-37)
-#define __cpp_inheriting_constructors 201511L
-#define __ORDER_LITTLE_ENDIAN__ 1234
-#define __WCHAR_MAX__ 0xffff
-#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1
-#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1
-#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1
-#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
-#define __GCC_IEC_559 2
-#define __FLT32X_DECIMAL_DIG__ 17
-#define __FLT_EVAL_METHOD__ 0
-#define __cpp_binary_literals 201304L
-#define __FLT64_DECIMAL_DIG__ 17
-#define __cpp_noexcept_function_type 201510L
-#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
-#define __cpp_variadic_templates 200704L
-#define __UINT_FAST64_MAX__ 0xffffffffffffffffULL
-#define __SIG_ATOMIC_TYPE__ int
-#define __DBL_MIN_10_EXP__ (-307)
-#define __FINITE_MATH_ONLY__ 0
-#define __cpp_variable_templates 201304L
-#define __FLT32X_MAX_EXP__ 1024
-#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1
-#define __FLT32_HAS_DENORM__ 1
-#define __UINT_FAST8_MAX__ 0xff
-#define __cpp_rvalue_reference 200610L
-#define __cpp_nested_namespace_definitions 201411L
-#define _stdcall __attribute__((__stdcall__))
-#define __DEC64_MAX_EXP__ 385
-#define __INT8_C(c) c
-#define __LDBL_HAS_INFINITY__ 1
-#define __INT_LEAST8_WIDTH__ 8
-#define __cpp_variadic_using 201611L
-#define __UINT_LEAST64_MAX__ 0xffffffffffffffffULL
-#define __INT_LEAST8_MAX__ 0x7f
-#define __cpp_attributes 200809L
-#define __cpp_capture_star_this 201603L
-#define __SHRT_MAX__ 0x7fff
-#define __LDBL_MAX__ 1.18973149535723176502126385303097021e+4932L
-#define __FLT64X_MAX_10_EXP__ 4932
-#define __cpp_if_constexpr 201606L
-#define __BFLT16_MAX_10_EXP__ 38
-#define __BFLT16_MAX_EXP__ 128
-#define __LDBL_IS_IEC_60559__ 1
-#define __FLT64X_HAS_QUIET_NAN__ 1
-#define __UINT_LEAST8_MAX__ 0xff
-#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
-#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966F128
-#define __UINTMAX_TYPE__ long long unsigned int
-#define __cpp_nsdmi 200809L
-#define __BFLT16_DECIMAL_DIG__ 4
-#define __DEC32_EPSILON__ 1E-6DF
-#define __FLT_EVAL_METHOD_TS_18661_3__ 0
-#define __OPTIMIZE__ 1
-#define __UINT32_MAX__ 0xffffffffU
-#define __GXX_EXPERIMENTAL_CXX0X__ 1
-#define __DBL_DENORM_MIN__ double(4.94065645841246544176568792868221372e-324L)
-#define __FLT128_MIN_EXP__ (-16381)
-#define __DEC64X_MAX_EXP__ 6145
-#define __WINT_MIN__ 0
-#define __FLT128_MIN_10_EXP__ (-4931)
-#define __FLT32X_IS_IEC_60559__ 1
-#define __INT_LEAST16_WIDTH__ 16
-#define __SCHAR_MAX__ 0x7f
-#define __FLT128_MANT_DIG__ 113
-#define __WCHAR_MIN__ 0
-#define __INT64_C(c) c ## LL
-#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
-#define __ATOMIC_SEQ_CST 5
-#define __INT_LEAST64_MAX__ 0x7fffffffffffffffLL
-#define __FLT32X_MANT_DIG__ 53
-#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
-#define __cpp_aligned_new 201606L
-#define __FLT32_MAX_10_EXP__ 38
-#define __FLT64X_EPSILON__ 1.08420217248550443400745280086994171e-19F64x
-#define __STDC_HOSTED__ 1
-#define __DEC64_MIN_EXP__ (-382)
-#define __WIN64 1
-#define __cpp_decltype_auto 201304L
-#define __DBL_DIG__ 15
-#define __STDC_EMBED_EMPTY__ 2
-#define __FLT_EPSILON__ 1.19209289550781250000000000000000000e-7F
-#define __GXX_WEAK__ 1
-#define __SHRT_WIDTH__ 16
-#define __FLT32_IS_IEC_60559__ 1
-#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
-#define __DBL_IS_IEC_60559__ 1
-#define __DEC32_MAX__ 9.999999E96DF
-#define __cpp_threadsafe_static_init 200806L
-#define __cpp_enumerator_attributes 201411L
-#define __FLT64X_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951F64x
-#define __FLT32X_HAS_INFINITY__ 1
-#define __INT_WIDTH__ 32
-#define __DECIMAL_DIG__ 21
-#define __FLT64_EPSILON__ 2.22044604925031308084726333618164062e-16F64
-#define __INT16_MAX__ 0x7fff
-#define __FLT64_MIN_EXP__ (-1021)
-#define __DEC64X_EPSILON__ 1E-33D64x
-#define __FLT64X_MIN_10_EXP__ (-4931)
-#define __LDBL_HAS_QUIET_NAN__ 1
-#define __FLT16_MIN_EXP__ (-13)
-#define __FLT64_MANT_DIG__ 53
-#define _REENTRANT 1
-#define __FLT64X_MANT_DIG__ 64
-#define __BFLT16_DIG__ 2
-#define __GNUC__ 15
-#define _cdecl __attribute__((__cdecl__))
-#define __GXX_RTTI 1
-#define __MMX__ 1
-#define __FLT_HAS_DENORM__ 1
-#define __SIZEOF_LONG_DOUBLE__ 16
-#define __BIGGEST_ALIGNMENT__ 16
-#define __STDC_UTF_16__ 1
-#define __SIZE_TYPE__ long long unsigned int
-#define __FLT64_MAX_10_EXP__ 308
-#define __BFLT16_IS_IEC_60559__ 0
-#define __FLT16_MAX_10_EXP__ 4
-#define __cpp_delegating_constructors 200604L
-#define __DBL_MAX__ double(1.79769313486231570814527423731704357e+308L)
-#define _thiscall __attribute__((__thiscall__))
-#define __cpp_raw_strings 200710L
-#define __INT_FAST32_MAX__ 0x7fffffff
-#define __DBL_HAS_INFINITY__ 1
-#define __INT64_MAX__ 0x7fffffffffffffffLL
-#define __SIZEOF_FLOAT__ 4
-#define __WINNT__ 1
-#define __HAVE_SPECULATION_SAFE_VALUE 1
-#define __cpp_fold_expressions 201603L
-#define __DEC32_MIN_EXP__ (-94)
-#define __INTPTR_WIDTH__ 64
-#define __UINT_LEAST32_MAX__ 0xffffffffU
-#define __FLT32X_HAS_DENORM__ 1
-#define __INT_FAST16_TYPE__ short int
-#define __MMX_WITH_SSE__ 1
-#define _fastcall __attribute__((__fastcall__))
-#define __LDBL_HAS_DENORM__ 1
-#define __SEG_GS 1
-#define __BFLT16_EPSILON__ 7.81250000000000000000000000000000000e-3BF16
-#define __cplusplus 201703L
-#define __cpp_ref_qualifiers 200710L
-#define __DEC32_MIN__ 1E-95DF
-#define __DEPRECATED 1
-#define __cpp_rvalue_references 200610L
-#define __DBL_MAX_EXP__ 1024
-#define __WCHAR_WIDTH__ 16
-#define __FLT32_MAX__ 3.40282346638528859811704183484516925e+38F32
-#define __DEC128_EPSILON__ 1E-33DL
-#define __FLT16_DECIMAL_DIG__ 5
-#define __SSE2_MATH__ 1
-#define __ATOMIC_HLE_RELEASE 131072
-#define __WIN32__ 1
-#define __PTRDIFF_MAX__ 0x7fffffffffffffffLL
-#define __amd64 1
-#define __DEC64X_MAX__ 9.999999999999999999999999999999999E6144D64x
-#define __ATOMIC_HLE_ACQUIRE 65536
-#define __GNUG__ 15
-#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL
-#define __SIZEOF_SIZE_T__ 8
-#define __BFLT16_HAS_INFINITY__ 1
-#define __FLT64X_MIN_EXP__ (-16381)
-#define __SIZEOF_WINT_T__ 2
-#define __FLT32X_DIG__ 15
-#define __LONG_LONG_WIDTH__ 64
-#define __cpp_initializer_lists 200806L
-#define __FLT32_MAX_EXP__ 128
-#define __cpp_hex_float 201603L
-#define __GXX_ABI_VERSION 1020
-#define __FLT_MIN_EXP__ (-125)
-#define __x86_64 1
-#define __cpp_lambdas 200907L
-#define __INT_FAST64_TYPE__ long long int
-#define __BFLT16_MAX__ 3.38953138925153547590470800371487867e+38BF16
-#define __FLT64_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F64
-#define __cpp_template_auto 201606L
-#define __FLT16_DENORM_MIN__ 5.96046447753906250000000000000000000e-8F16
-#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34F128
-#define __FLT64X_NORM_MAX__ 1.18973149535723176502126385303097021e+4932F64x
-#define __SIZEOF_POINTER__ 8
-#define __DBL_HAS_QUIET_NAN__ 1
-#define __FLT32X_EPSILON__ 2.22044604925031308084726333618164062e-16F32x
-#define __LDBL_MAX_EXP__ 16384
-#define __DECIMAL_BID_FORMAT__ 1
-#define __GXX_TYPEINFO_EQUALITY_INLINE 0
-#define __FLT64_MIN_10_EXP__ (-307)
-#define __FLT16_MIN_10_EXP__ (-4)
-#define __FLT64X_DECIMAL_DIG__ 21
-#define __DEC128_MIN__ 1E-6143DL
-#define __REGISTER_PREFIX__ 
-#define __UINT16_MAX__ 0xffff
-#define __FLT128_HAS_INFINITY__ 1
-#define __FLT32_MIN__ 1.17549435082228750796873653722224568e-38F32
-#define __UINT8_TYPE__ unsigned char
-#define __FLT_DIG__ 6
-#define __DEC_EVAL_METHOD__ 2
-#define __FLT_MANT_DIG__ 24
-#define __LDBL_DECIMAL_DIG__ 21
-#define __VERSION__ "15.2.0"
-#define __UINT64_C(c) c ## ULL
-#define __cpp_unicode_characters 201411L
-#define __DEC64X_MIN__ 1E-6143D64x
-#define _WIN32 1
-#define __SEH__ 1
-#define __INT_LEAST32_MAX__ 0x7fffffff
-#define __GCC_ATOMIC_INT_LOCK_FREE 2
-#define __FLT128_MAX_EXP__ 16384
-#define __FLT32_MANT_DIG__ 24
-#define __cpp_decltype 200707L
-#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
-#define __FLT32X_MIN_EXP__ (-1021)
-#define __cpp_aggregate_bases 201603L
-#define __BFLT16_MIN__ 1.17549435082228750796873653722224568e-38BF16
-#define __FLT128_HAS_DENORM__ 1
-#define __FLT32_DECIMAL_DIG__ 9
-#define __FLT128_DIG__ 33
-#define _INTEGRAL_MAX_BITS 64
-#define __INT32_C(c) c
-#define __DEC64_EPSILON__ 1E-15DD
-#define __ORDER_PDP_ENDIAN__ 3412
-#define __DEC128_MIN_EXP__ (-6142)
-#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL
-#define __INT_FAST32_TYPE__ int
-#define __UINT_LEAST16_TYPE__ short unsigned int
-#define __DEC64X_MANT_DIG__ 34
-#define __DEC128_MAX_EXP__ 6145
-#define __DBL_HAS_DENORM__ 1
-#define __cpp_rtti 199711L
-#define __UINT64_MAX__ 0xffffffffffffffffULL
-#define __FLT_IS_IEC_60559__ 1
-#define __GNUC_WIDE_EXECUTION_CHARSET_NAME "UTF-16LE"
-#define __cdecl __attribute__((__cdecl__))
-#define __FLT64X_DIG__ 18
-#define __INT8_TYPE__ signed char
-#define __cpp_digit_separators 201309L
-#define __GCC_ASM_FLAG_OUTPUTS__ 1
-#define __UINT32_TYPE__ unsigned int
-#define __BFLT16_HAS_QUIET_NAN__ 1
-#define __FLT_RADIX__ 2
-#define __INT_LEAST16_TYPE__ short int
-#define __LDBL_EPSILON__ 1.08420217248550443400745280086994171e-19L
-#define __UINTMAX_C(c) c ## ULL
-#define __FLT16_DIG__ 3
-#define __FLT32X_MIN__ 2.22507385850720138309023271733240406e-308F32x
-#define __SIG_ATOMIC_MAX__ 0x7fffffff
-#define __cpp_constexpr 201603L
-#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
-#define __USER_LABEL_PREFIX__ 
-#define __SIZEOF_PTRDIFF_T__ 8
-#define __FLT64X_HAS_INFINITY__ 1
-#define __SIZEOF_LONG__ 4
-#define __LDBL_DIG__ 18
-#define __FLT64_IS_IEC_60559__ 1
-#define __x86_64__ 1
-#define __FLT16_IS_IEC_60559__ 1
-#define __FLT16_MAX_EXP__ 16
-#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF
-#define __STDC_EMBED_FOUND__ 1
-#define __MSVCRT__ 1
-#define __INT_FAST16_MAX__ 0x7fff
-#define __GCC_CONSTRUCTIVE_SIZE 64
-#define __FLT64_DIG__ 15
-#define __UINT_FAST32_MAX__ 0xffffffffU
-#define __UINT_LEAST64_TYPE__ long long unsigned int
-#define __FLT16_EPSILON__ 9.76562500000000000000000000000000000e-4F16
-#define __FLT_HAS_QUIET_NAN__ 1
-#define __FLT_MAX_10_EXP__ 38
-#define __FLT64X_HAS_DENORM__ 1
-#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL
-#define __FLT_HAS_INFINITY__ 1
-#define __GNUC_EXECUTION_CHARSET_NAME "UTF-8"
-#define __cpp_unicode_literals 200710L
-#define __UINT_FAST16_TYPE__ short unsigned int
-#define __DEC64_MAX__ 9.999999999999999E384DD
-#define __STDC_EMBED_NOT_FOUND__ 0
-#define __INT_FAST32_WIDTH__ 32
-#define __CHAR16_TYPE__ short unsigned int
-#define __PRAGMA_REDEFINE_EXTNAME 1
-#define __DEC64X_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143D64x
-#define __SIZE_WIDTH__ 64
-#define __SEG_FS 1
-#define __INT_LEAST16_MAX__ 0x7fff
-#define __FLT16_NORM_MAX__ 6.55040000000000000000000000000000000e+4F16
-#define __DEC64_MANT_DIG__ 16
-#define __FLT32_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F32
-#define __SIG_ATOMIC_WIDTH__ 32
-#define __INT_LEAST64_TYPE__ long long int
-#define __INT16_TYPE__ short int
-#define __INT_LEAST8_TYPE__ signed char
-#define __FLT16_MAX__ 6.55040000000000000000000000000000000e+4F16
-#define __nocona__ 1
-#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932F128
-#define __cpp_structured_bindings 201606L
-#define __SIZEOF_INT__ 4
-#define __DEC32_MAX_EXP__ 97
-#define __INT_FAST8_MAX__ 0x7f
-#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932F128
-#define __INTPTR_MAX__ 0x7fffffffffffffffLL
-#define __cpp_sized_deallocation 201309L
-#define __cpp_guaranteed_copy_elision 201606L
-#define __WIN64__ 1
-#define __FLT64_HAS_QUIET_NAN__ 1
-#define __stdcall __attribute__((__stdcall__))
-#define __FLT32_MIN_10_EXP__ (-37)
-#define __EXCEPTIONS 1
-#define __GXX_MERGED_TYPEINFO_NAMES 0
-#define __UINT16_C(c) c
-#define __PTRDIFF_WIDTH__ 64
-#define __cpp_range_based_for 201603L
-#define __INT_FAST16_WIDTH__ 16
-#define __FLT64_HAS_INFINITY__ 1
-#define __FLT64X_MAX__ 1.18973149535723176502126385303097021e+4932F64x
-#define __FLT16_HAS_INFINITY__ 1
-#define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16
-#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1)
-#define __GCC_ATOMIC_LONG_LOCK_FREE 2
-#define __cpp_nontype_template_args 201411L
-#define __DEC32_MANT_DIG__ 7
-#define __INTPTR_TYPE__ long long int
-#define __UINT16_TYPE__ short unsigned int
-#define __WCHAR_TYPE__ short unsigned int
-#define __pic__ 1
-#define __UINTPTR_MAX__ 0xffffffffffffffffULL
-#define __INT_FAST64_WIDTH__ 64
-#define __INT_FAST64_MAX__ 0x7fffffffffffffffLL
-#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
-#define __FLT_NORM_MAX__ 3.40282346638528859811704183484516925e+38F
-#define __FLT32_HAS_INFINITY__ 1
-#define __FLT64X_MAX_EXP__ 16384
-#define __UINT_FAST64_TYPE__ long long unsigned int
-#define __cpp_inline_variables 201606L
-#define __BFLT16_MIN_EXP__ (-125)
-#define __INT_MAX__ 0x7fffffff
-#define WIN32 1
-#define __nocona 1
-#define __code_model_medium__ 1
-#define __INT64_TYPE__ long long int
-#define __FLT_MAX_EXP__ 128
-#define WIN64 1
-#define __ORDER_BIG_ENDIAN__ 4321
-#define __DBL_MANT_DIG__ 53
-#define __SIZEOF_FLOAT128__ 16
-#define __BFLT16_MANT_DIG__ 8
-#define __DEC64_MIN__ 1E-383DD
-#define __WINT_TYPE__ short unsigned int
-#define __UINT_LEAST32_TYPE__ unsigned int
-#define __SIZEOF_SHORT__ 2
-#define __FLT32_NORM_MAX__ 3.40282346638528859811704183484516925e+38F32
-#define __SSE__ 1
-#define __LDBL_MIN_EXP__ (-16381)
-#define __FLT64_MAX__ 1.79769313486231570814527423731704357e+308F64
-#define __DEC64X_MIN_EXP__ (-6142)
-#define __amd64__ 1
-#define __WINT_WIDTH__ 16
-#define __INT_LEAST64_WIDTH__ 64
-#define __FLT32X_MAX_10_EXP__ 308
-#define __cpp_namespace_attributes 201411L
-#define __WIN32 1
-#define __SIZEOF_INT128__ 16
-#define __FLT16_MIN__ 6.10351562500000000000000000000000000e-5F16
-#define __FLT64X_IS_IEC_60559__ 1
-#define __GXX_CONSTEXPR_ASM__ 1
-#define __WCHAR_UNSIGNED__ 1
-#define __LDBL_MAX_10_EXP__ 4932
-#define __ATOMIC_RELAXED 0
-#define __DBL_EPSILON__ double(2.22044604925031308084726333618164062e-16L)
-#define __INT_LEAST32_TYPE__ int
-#define __thiscall __attribute__((__thiscall__))
-#define __UINT8_C(c) c
-#define __FLT64_MAX_EXP__ 1024
-#define __cpp_return_type_deduction 201304L
-#define __SIZEOF_WCHAR_T__ 2
-#define __GNUC_PATCHLEVEL__ 0
-#define __WINNT 1
-#define __FLT128_NORM_MAX__ 1.18973149535723176508575932662800702e+4932F128
-#define __FLT64_NORM_MAX__ 1.79769313486231570814527423731704357e+308F64
-#define __FLT128_HAS_QUIET_NAN__ 1
-#define __INTMAX_MAX__ 0x7fffffffffffffffLL
-#define __SSE3__ 1
-#define __INT_FAST8_TYPE__ signed char
-#define __fastcall __attribute__((__fastcall__))
-#define __FLT64X_MIN__ 3.36210314311209350626267781732175260e-4932F64x
-#define __STDCPP_THREADS__ 1
-#define __BFLT16_HAS_DENORM__ 1
-#define __GNUC_STDC_INLINE__ 1
-#define __FLT64_HAS_DENORM__ 1
-#define __FLT32_EPSILON__ 1.19209289550781250000000000000000000e-7F32
-#define __FLT16_HAS_DENORM__ 1
-#define __DBL_DECIMAL_DIG__ 17
-#define __STDC_UTF_32__ 1
-#define __INT_FAST8_WIDTH__ 8
-#define __FXSR__ 1
-#define __FLT32X_MAX__ 1.79769313486231570814527423731704357e+308F32x
-#define __DBL_NORM_MAX__ double(1.79769313486231570814527423731704357e+308L)
-#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
-#define __MINGW64__ 1
-#define __GCC_DESTRUCTIVE_SIZE 64
-#define __INTMAX_WIDTH__ 64
-#define __cpp_runtime_arrays 198712L
-#define __FLT32_DIG__ 6
-#define __UINT64_TYPE__ long long unsigned int
-#define __UINT32_C(c) c ## U
-#define __cpp_alias_templates 200704L
-#define WINNT 1
-#define __FLT_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F
-#define __FLT128_IS_IEC_60559__ 1
-#define __INT8_MAX__ 0x7f
-#define __LONG_WIDTH__ 32
-#define __DBL_MIN__ double(2.22507385850720138309023271733240406e-308L)
-#define __PIC__ 1
-#define __INT32_MAX__ 0x7fffffff
-#define __UINT_FAST32_TYPE__ unsigned int
-#define __FLT16_MANT_DIG__ 11
-#define __FLT32X_NORM_MAX__ 1.79769313486231570814527423731704357e+308F32x
-#define __CHAR32_TYPE__ unsigned int
-#define __FLT_MAX__ 3.40282346638528859811704183484516925e+38F
-#define __SSE2__ 1
-#define __cpp_deduction_guides 201703L
-#define __BFLT16_NORM_MAX__ 3.38953138925153547590470800371487867e+38BF16
-#define __INT32_TYPE__ int
-#define __SIZEOF_DOUBLE__ 8
-#define __cpp_exceptions 199711L
-#define __FLT_MIN_10_EXP__ (-37)
-#define __FLT64_MIN__ 2.22507385850720138309023271733240406e-308F64
-#define __INT_LEAST32_WIDTH__ 32
-#define __INTMAX_TYPE__ long long int
-#define __GLIBCXX_BITSIZE_INT_N_0 128
-#define __FLT32X_HAS_QUIET_NAN__ 1
-#define __ATOMIC_CONSUME 1
-#define __GNUC_MINOR__ 2
-#define __GLIBCXX_TYPE_INT_N_0 __int128
-#define __UINTMAX_MAX__ 0xffffffffffffffffULL
-#define __FLT32X_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F32x
-#define __cpp_template_template_args 201611L
-#define __DBL_MAX_10_EXP__ 308
-#define __LDBL_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951L
-#define __INT16_C(c) c
-#define __STDC__ 1
-#define __PTRDIFF_TYPE__ long long int
-#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 1
-#define __LONG_MAX__ 0x7fffffffL
-#define __FLT32X_MIN_10_EXP__ (-307)
-#define __UINTPTR_TYPE__ long long unsigned int
-#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD
-#define __DEC128_MANT_DIG__ 34
-#define __LDBL_MIN_10_EXP__ (-4931)
-#define __cpp_generic_lambdas 201304L
-#define __SSE_MATH__ 1
-#define __SIZEOF_LONG_LONG__ 8
-#define __cpp_user_defined_literals 200809L
-#define __FLT128_DECIMAL_DIG__ 36
-#define __GCC_ATOMIC_LLONG_LOCK_FREE 2
-#define __USING_POSIXTHREAD__ 1
-#define __FLT32_HAS_QUIET_NAN__ 1
-#define __FLT_DECIMAL_DIG__ 9
-#define __UINT_FAST16_MAX__ 0xffff
-#define __LDBL_NORM_MAX__ 1.18973149535723176502126385303097021e+4932L
-#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
-#define __SIZE_MAX__ 0xffffffffffffffffULL
-#define __UINT_FAST8_TYPE__ unsigned char
-#define __cpp_init_captures 201304L
-#define __ATOMIC_ACQ_REL 4
-#define __ATOMIC_RELEASE 3
-#define __declspec(x) __attribute__((x))

build/moc_qvalidatedlineedit.cpp

@@ -1,124 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'qvalidatedlineedit.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/qvalidatedlineedit.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'qvalidatedlineedit.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_QValidatedLineEdit_t {
-    QByteArrayData data[5];
-    char stringdata0[45];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_QValidatedLineEdit_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_QValidatedLineEdit_t qt_meta_stringdata_QValidatedLineEdit = {
-    {
-QT_MOC_LITERAL(0, 0, 18), // "QValidatedLineEdit"
-QT_MOC_LITERAL(1, 19, 8), // "setValid"
-QT_MOC_LITERAL(2, 28, 0), // ""
-QT_MOC_LITERAL(3, 29, 5), // "valid"
-QT_MOC_LITERAL(4, 35, 9) // "markValid"
-
-    },
-    "QValidatedLineEdit\0setValid\0\0valid\0"
-    "markValid"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_QValidatedLineEdit[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       2,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    1,   24,    2, 0x0a /* Public */,
-       4,    0,   27,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::Bool,    3,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void QValidatedLineEdit::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<QValidatedLineEdit *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->setValid((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 1: _t->markValid(); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject QValidatedLineEdit::staticMetaObject = { {
-    QMetaObject::SuperData::link<QLineEdit::staticMetaObject>(),
-    qt_meta_stringdata_QValidatedLineEdit.data,
-    qt_meta_data_QValidatedLineEdit,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *QValidatedLineEdit::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *QValidatedLineEdit::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_QValidatedLineEdit.stringdata0))
-        return static_cast<void*>(this);
-    return QLineEdit::qt_metacast(_clname);
-}
-
-int QValidatedLineEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QLineEdit::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 2)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 2;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 2)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 2;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_qvalidatedtextedit.cpp

@@ -1,129 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'qvalidatedtextedit.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/qvalidatedtextedit.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'qvalidatedtextedit.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_QValidatedTextEdit_t {
-    QByteArrayData data[7];
-    char stringdata0[68];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_QValidatedTextEdit_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_QValidatedTextEdit_t qt_meta_stringdata_QValidatedTextEdit = {
-    {
-QT_MOC_LITERAL(0, 0, 18), // "QValidatedTextEdit"
-QT_MOC_LITERAL(1, 19, 8), // "setValid"
-QT_MOC_LITERAL(2, 28, 0), // ""
-QT_MOC_LITERAL(3, 29, 5), // "valid"
-QT_MOC_LITERAL(4, 35, 12), // "setErrorText"
-QT_MOC_LITERAL(5, 48, 9), // "errorText"
-QT_MOC_LITERAL(6, 58, 9) // "markValid"
-
-    },
-    "QValidatedTextEdit\0setValid\0\0valid\0"
-    "setErrorText\0errorText\0markValid"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_QValidatedTextEdit[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       3,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    1,   29,    2, 0x0a /* Public */,
-       4,    1,   32,    2, 0x0a /* Public */,
-       6,    0,   35,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::Bool,    3,
-    QMetaType::Void, QMetaType::QString,    5,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void QValidatedTextEdit::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<QValidatedTextEdit *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->setValid((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 1: _t->setErrorText((*reinterpret_cast< QString(*)>(_a[1]))); break;
-        case 2: _t->markValid(); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject QValidatedTextEdit::staticMetaObject = { {
-    QMetaObject::SuperData::link<QPlainTextEdit::staticMetaObject>(),
-    qt_meta_stringdata_QValidatedTextEdit.data,
-    qt_meta_data_QValidatedTextEdit,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *QValidatedTextEdit::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *QValidatedTextEdit::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_QValidatedTextEdit.stringdata0))
-        return static_cast<void*>(this);
-    return QPlainTextEdit::qt_metacast(_clname);
-}
-
-int QValidatedTextEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QPlainTextEdit::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 3)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 3;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 3)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 3;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_qvaluecombobox.cpp

@@ -1,187 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'qvaluecombobox.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/qvaluecombobox.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'qvaluecombobox.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_QValueComboBox_t {
-    QByteArrayData data[6];
-    char stringdata0[62];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_QValueComboBox_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_QValueComboBox_t qt_meta_stringdata_QValueComboBox = {
-    {
-QT_MOC_LITERAL(0, 0, 14), // "QValueComboBox"
-QT_MOC_LITERAL(1, 15, 12), // "valueChanged"
-QT_MOC_LITERAL(2, 28, 0), // ""
-QT_MOC_LITERAL(3, 29, 22), // "handleSelectionChanged"
-QT_MOC_LITERAL(4, 52, 3), // "idx"
-QT_MOC_LITERAL(5, 56, 5) // "value"
-
-    },
-    "QValueComboBox\0valueChanged\0\0"
-    "handleSelectionChanged\0idx\0value"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_QValueComboBox[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       2,   14, // methods
-       1,   28, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       1,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    0,   24,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       3,    1,   25,    2, 0x08 /* Private */,
-
- // signals: parameters
-    QMetaType::Void,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::Int,    4,
-
- // properties: name, type, flags
-       5, QMetaType::QVariant, 0x00595103,
-
- // properties: notify_signal_id
-       0,
-
-       0        // eod
-};
-
-void QValueComboBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<QValueComboBox *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->valueChanged(); break;
-        case 1: _t->handleSelectionChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (QValueComboBox::*)();
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&QValueComboBox::valueChanged)) {
-                *result = 0;
-                return;
-            }
-        }
-    }
-#ifndef QT_NO_PROPERTIES
-    else if (_c == QMetaObject::ReadProperty) {
-        auto *_t = static_cast<QValueComboBox *>(_o);
-        (void)_t;
-        void *_v = _a[0];
-        switch (_id) {
-        case 0: *reinterpret_cast< QVariant*>(_v) = _t->value(); break;
-        default: break;
-        }
-    } else if (_c == QMetaObject::WriteProperty) {
-        auto *_t = static_cast<QValueComboBox *>(_o);
-        (void)_t;
-        void *_v = _a[0];
-        switch (_id) {
-        case 0: _t->setValue(*reinterpret_cast< QVariant*>(_v)); break;
-        default: break;
-        }
-    } else if (_c == QMetaObject::ResetProperty) {
-    }
-#endif // QT_NO_PROPERTIES
-}
-
-QT_INIT_METAOBJECT const QMetaObject QValueComboBox::staticMetaObject = { {
-    QMetaObject::SuperData::link<QComboBox::staticMetaObject>(),
-    qt_meta_stringdata_QValueComboBox.data,
-    qt_meta_data_QValueComboBox,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *QValueComboBox::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *QValueComboBox::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_QValueComboBox.stringdata0))
-        return static_cast<void*>(this);
-    return QComboBox::qt_metacast(_clname);
-}
-
-int QValueComboBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QComboBox::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 2)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 2;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 2)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 2;
-    }
-#ifndef QT_NO_PROPERTIES
-    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
-            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
-        qt_static_metacall(this, _c, _id, _a);
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyDesignable) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyScriptable) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyStored) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyEditable) {
-        _id -= 1;
-    } else if (_c == QMetaObject::QueryPropertyUser) {
-        _id -= 1;
-    }
-#endif // QT_NO_PROPERTIES
-    return _id;
-}
-
-// SIGNAL 0
-void QValueComboBox::valueChanged()
-{
-    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_rpcconsole.cpp

@@ -1,212 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'rpcconsole.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/rpcconsole.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'rpcconsole.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_RPCConsole_t {
-    QByteArrayData data[21];
-    char stringdata0[280];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_RPCConsole_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_RPCConsole_t qt_meta_stringdata_RPCConsole = {
-    {
-QT_MOC_LITERAL(0, 0, 10), // "RPCConsole"
-QT_MOC_LITERAL(1, 11, 12), // "stopExecutor"
-QT_MOC_LITERAL(2, 24, 0), // ""
-QT_MOC_LITERAL(3, 25, 10), // "cmdRequest"
-QT_MOC_LITERAL(4, 36, 7), // "command"
-QT_MOC_LITERAL(5, 44, 25), // "on_lineEdit_returnPressed"
-QT_MOC_LITERAL(6, 70, 27), // "on_tabWidget_currentChanged"
-QT_MOC_LITERAL(7, 98, 5), // "index"
-QT_MOC_LITERAL(8, 104, 33), // "on_openDebugLogfileButton_cli..."
-QT_MOC_LITERAL(9, 138, 30), // "on_showCLOptionsButton_clicked"
-QT_MOC_LITERAL(10, 169, 5), // "clear"
-QT_MOC_LITERAL(11, 175, 7), // "message"
-QT_MOC_LITERAL(12, 183, 8), // "category"
-QT_MOC_LITERAL(13, 192, 4), // "html"
-QT_MOC_LITERAL(14, 197, 17), // "setNumConnections"
-QT_MOC_LITERAL(15, 215, 5), // "count"
-QT_MOC_LITERAL(16, 221, 12), // "setNumBlocks"
-QT_MOC_LITERAL(17, 234, 12), // "countOfPeers"
-QT_MOC_LITERAL(18, 247, 13), // "browseHistory"
-QT_MOC_LITERAL(19, 261, 6), // "offset"
-QT_MOC_LITERAL(20, 268, 11) // "scrollToEnd"
-
-    },
-    "RPCConsole\0stopExecutor\0\0cmdRequest\0"
-    "command\0on_lineEdit_returnPressed\0"
-    "on_tabWidget_currentChanged\0index\0"
-    "on_openDebugLogfileButton_clicked\0"
-    "on_showCLOptionsButton_clicked\0clear\0"
-    "message\0category\0html\0setNumConnections\0"
-    "count\0setNumBlocks\0countOfPeers\0"
-    "browseHistory\0offset\0scrollToEnd"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_RPCConsole[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      13,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       2,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    0,   79,    2, 0x06 /* Public */,
-       3,    1,   80,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       5,    0,   83,    2, 0x08 /* Private */,
-       6,    1,   84,    2, 0x08 /* Private */,
-       8,    0,   87,    2, 0x08 /* Private */,
-       9,    0,   88,    2, 0x08 /* Private */,
-      10,    0,   89,    2, 0x0a /* Public */,
-      11,    3,   90,    2, 0x0a /* Public */,
-      11,    2,   97,    2, 0x2a /* Public | MethodCloned */,
-      14,    1,  102,    2, 0x0a /* Public */,
-      16,    2,  105,    2, 0x0a /* Public */,
-      18,    1,  110,    2, 0x0a /* Public */,
-      20,    0,  113,    2, 0x0a /* Public */,
-
- // signals: parameters
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::QString,    4,
-
- // slots: parameters
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Int,    7,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Int, QMetaType::QString, QMetaType::Bool,   12,   11,   13,
-    QMetaType::Void, QMetaType::Int, QMetaType::QString,   12,   11,
-    QMetaType::Void, QMetaType::Int,   15,
-    QMetaType::Void, QMetaType::Int, QMetaType::Int,   15,   17,
-    QMetaType::Void, QMetaType::Int,   19,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void RPCConsole::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<RPCConsole *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->stopExecutor(); break;
-        case 1: _t->cmdRequest((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 2: _t->on_lineEdit_returnPressed(); break;
-        case 3: _t->on_tabWidget_currentChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 4: _t->on_openDebugLogfileButton_clicked(); break;
-        case 5: _t->on_showCLOptionsButton_clicked(); break;
-        case 6: _t->clear(); break;
-        case 7: _t->message((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3]))); break;
-        case 8: _t->message((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
-        case 9: _t->setNumConnections((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 10: _t->setNumBlocks((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
-        case 11: _t->browseHistory((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 12: _t->scrollToEnd(); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (RPCConsole::*)();
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&RPCConsole::stopExecutor)) {
-                *result = 0;
-                return;
-            }
-        }
-        {
-            using _t = void (RPCConsole::*)(const QString & );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&RPCConsole::cmdRequest)) {
-                *result = 1;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject RPCConsole::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_RPCConsole.data,
-    qt_meta_data_RPCConsole,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *RPCConsole::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *RPCConsole::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_RPCConsole.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int RPCConsole::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 13)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 13;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 13)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 13;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void RPCConsole::stopExecutor()
-{
-    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
-}
-
-// SIGNAL 1
-void RPCConsole::cmdRequest(const QString & _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 1, _a);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_sendcoinsdialog.cpp

@@ -1,225 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'sendcoinsdialog.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/sendcoinsdialog.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'sendcoinsdialog.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_SendCoinsDialog_t {
-    QByteArrayData data[30];
-    char stringdata0[545];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_SendCoinsDialog_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_SendCoinsDialog_t qt_meta_stringdata_SendCoinsDialog = {
-    {
-QT_MOC_LITERAL(0, 0, 15), // "SendCoinsDialog"
-QT_MOC_LITERAL(1, 16, 5), // "clear"
-QT_MOC_LITERAL(2, 22, 0), // ""
-QT_MOC_LITERAL(3, 23, 6), // "reject"
-QT_MOC_LITERAL(4, 30, 6), // "accept"
-QT_MOC_LITERAL(5, 37, 8), // "addEntry"
-QT_MOC_LITERAL(6, 46, 15), // "SendCoinsEntry*"
-QT_MOC_LITERAL(7, 62, 19), // "updateRemoveEnabled"
-QT_MOC_LITERAL(8, 82, 10), // "setBalance"
-QT_MOC_LITERAL(9, 93, 7), // "balance"
-QT_MOC_LITERAL(10, 101, 5), // "stake"
-QT_MOC_LITERAL(11, 107, 18), // "unconfirmedBalance"
-QT_MOC_LITERAL(12, 126, 15), // "immatureBalance"
-QT_MOC_LITERAL(13, 142, 21), // "on_sendButton_clicked"
-QT_MOC_LITERAL(14, 164, 11), // "removeEntry"
-QT_MOC_LITERAL(15, 176, 5), // "entry"
-QT_MOC_LITERAL(16, 182, 17), // "updateDisplayUnit"
-QT_MOC_LITERAL(17, 200, 25), // "coinControlFeatureChanged"
-QT_MOC_LITERAL(18, 226, 24), // "coinControlButtonClicked"
-QT_MOC_LITERAL(19, 251, 24), // "coinControlChangeChecked"
-QT_MOC_LITERAL(20, 276, 23), // "coinControlChangeEdited"
-QT_MOC_LITERAL(21, 300, 23), // "coinControlUpdateLabels"
-QT_MOC_LITERAL(22, 324, 28), // "coinControlClipboardQuantity"
-QT_MOC_LITERAL(23, 353, 26), // "coinControlClipboardAmount"
-QT_MOC_LITERAL(24, 380, 23), // "coinControlClipboardFee"
-QT_MOC_LITERAL(25, 404, 28), // "coinControlClipboardAfterFee"
-QT_MOC_LITERAL(26, 433, 25), // "coinControlClipboardBytes"
-QT_MOC_LITERAL(27, 459, 28), // "coinControlClipboardPriority"
-QT_MOC_LITERAL(28, 488, 29), // "coinControlClipboardLowOutput"
-QT_MOC_LITERAL(29, 518, 26) // "coinControlClipboardChange"
-
-    },
-    "SendCoinsDialog\0clear\0\0reject\0accept\0"
-    "addEntry\0SendCoinsEntry*\0updateRemoveEnabled\0"
-    "setBalance\0balance\0stake\0unconfirmedBalance\0"
-    "immatureBalance\0on_sendButton_clicked\0"
-    "removeEntry\0entry\0updateDisplayUnit\0"
-    "coinControlFeatureChanged\0"
-    "coinControlButtonClicked\0"
-    "coinControlChangeChecked\0"
-    "coinControlChangeEdited\0coinControlUpdateLabels\0"
-    "coinControlClipboardQuantity\0"
-    "coinControlClipboardAmount\0"
-    "coinControlClipboardFee\0"
-    "coinControlClipboardAfterFee\0"
-    "coinControlClipboardBytes\0"
-    "coinControlClipboardPriority\0"
-    "coinControlClipboardLowOutput\0"
-    "coinControlClipboardChange"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_SendCoinsDialog[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      22,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    0,  124,    2, 0x0a /* Public */,
-       3,    0,  125,    2, 0x0a /* Public */,
-       4,    0,  126,    2, 0x0a /* Public */,
-       5,    0,  127,    2, 0x0a /* Public */,
-       7,    0,  128,    2, 0x0a /* Public */,
-       8,    4,  129,    2, 0x0a /* Public */,
-      13,    0,  138,    2, 0x08 /* Private */,
-      14,    1,  139,    2, 0x08 /* Private */,
-      16,    0,  142,    2, 0x08 /* Private */,
-      17,    1,  143,    2, 0x08 /* Private */,
-      18,    0,  146,    2, 0x08 /* Private */,
-      19,    1,  147,    2, 0x08 /* Private */,
-      20,    1,  150,    2, 0x08 /* Private */,
-      21,    0,  153,    2, 0x08 /* Private */,
-      22,    0,  154,    2, 0x08 /* Private */,
-      23,    0,  155,    2, 0x08 /* Private */,
-      24,    0,  156,    2, 0x08 /* Private */,
-      25,    0,  157,    2, 0x08 /* Private */,
-      26,    0,  158,    2, 0x08 /* Private */,
-      27,    0,  159,    2, 0x08 /* Private */,
-      28,    0,  160,    2, 0x08 /* Private */,
-      29,    0,  161,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    0x80000000 | 6,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::LongLong, QMetaType::LongLong, QMetaType::LongLong, QMetaType::LongLong,    9,   10,   11,   12,
-    QMetaType::Void,
-    QMetaType::Void, 0x80000000 | 6,   15,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Bool,    2,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::Int,    2,
-    QMetaType::Void, QMetaType::QString,    2,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void SendCoinsDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<SendCoinsDialog *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->clear(); break;
-        case 1: _t->reject(); break;
-        case 2: _t->accept(); break;
-        case 3: { SendCoinsEntry* _r = _t->addEntry();
-            if (_a[0]) *reinterpret_cast< SendCoinsEntry**>(_a[0]) = std::move(_r); }  break;
-        case 4: _t->updateRemoveEnabled(); break;
-        case 5: _t->setBalance((*reinterpret_cast< qint64(*)>(_a[1])),(*reinterpret_cast< qint64(*)>(_a[2])),(*reinterpret_cast< qint64(*)>(_a[3])),(*reinterpret_cast< qint64(*)>(_a[4]))); break;
-        case 6: _t->on_sendButton_clicked(); break;
-        case 7: _t->removeEntry((*reinterpret_cast< SendCoinsEntry*(*)>(_a[1]))); break;
-        case 8: _t->updateDisplayUnit(); break;
-        case 9: _t->coinControlFeatureChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 10: _t->coinControlButtonClicked(); break;
-        case 11: _t->coinControlChangeChecked((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 12: _t->coinControlChangeEdited((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 13: _t->coinControlUpdateLabels(); break;
-        case 14: _t->coinControlClipboardQuantity(); break;
-        case 15: _t->coinControlClipboardAmount(); break;
-        case 16: _t->coinControlClipboardFee(); break;
-        case 17: _t->coinControlClipboardAfterFee(); break;
-        case 18: _t->coinControlClipboardBytes(); break;
-        case 19: _t->coinControlClipboardPriority(); break;
-        case 20: _t->coinControlClipboardLowOutput(); break;
-        case 21: _t->coinControlClipboardChange(); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject SendCoinsDialog::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_SendCoinsDialog.data,
-    qt_meta_data_SendCoinsDialog,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *SendCoinsDialog::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *SendCoinsDialog::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_SendCoinsDialog.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int SendCoinsDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 22)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 22;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 22)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 22;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_sendcoinsentry.cpp

@@ -1,203 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'sendcoinsentry.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/sendcoinsentry.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'sendcoinsentry.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_SendCoinsEntry_t {
-    QByteArrayData data[15];
-    char stringdata0[221];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_SendCoinsEntry_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_SendCoinsEntry_t qt_meta_stringdata_SendCoinsEntry = {
-    {
-QT_MOC_LITERAL(0, 0, 14), // "SendCoinsEntry"
-QT_MOC_LITERAL(1, 15, 11), // "removeEntry"
-QT_MOC_LITERAL(2, 27, 0), // ""
-QT_MOC_LITERAL(3, 28, 15), // "SendCoinsEntry*"
-QT_MOC_LITERAL(4, 44, 5), // "entry"
-QT_MOC_LITERAL(5, 50, 16), // "payAmountChanged"
-QT_MOC_LITERAL(6, 67, 16), // "setRemoveEnabled"
-QT_MOC_LITERAL(7, 84, 7), // "enabled"
-QT_MOC_LITERAL(8, 92, 5), // "clear"
-QT_MOC_LITERAL(9, 98, 23), // "on_deleteButton_clicked"
-QT_MOC_LITERAL(10, 122, 20), // "on_payTo_textChanged"
-QT_MOC_LITERAL(11, 143, 7), // "address"
-QT_MOC_LITERAL(12, 151, 28), // "on_addressBookButton_clicked"
-QT_MOC_LITERAL(13, 180, 22), // "on_pasteButton_clicked"
-QT_MOC_LITERAL(14, 203, 17) // "updateDisplayUnit"
-
-    },
-    "SendCoinsEntry\0removeEntry\0\0SendCoinsEntry*\0"
-    "entry\0payAmountChanged\0setRemoveEnabled\0"
-    "enabled\0clear\0on_deleteButton_clicked\0"
-    "on_payTo_textChanged\0address\0"
-    "on_addressBookButton_clicked\0"
-    "on_pasteButton_clicked\0updateDisplayUnit"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_SendCoinsEntry[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-       9,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       2,       // signalCount
-
- // signals: name, argc, parameters, tag, flags
-       1,    1,   59,    2, 0x06 /* Public */,
-       5,    0,   62,    2, 0x06 /* Public */,
-
- // slots: name, argc, parameters, tag, flags
-       6,    1,   63,    2, 0x0a /* Public */,
-       8,    0,   66,    2, 0x0a /* Public */,
-       9,    0,   67,    2, 0x08 /* Private */,
-      10,    1,   68,    2, 0x08 /* Private */,
-      12,    0,   71,    2, 0x08 /* Private */,
-      13,    0,   72,    2, 0x08 /* Private */,
-      14,    0,   73,    2, 0x08 /* Private */,
-
- // signals: parameters
-    QMetaType::Void, 0x80000000 | 3,    4,
-    QMetaType::Void,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::Bool,    7,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, QMetaType::QString,   11,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void SendCoinsEntry::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<SendCoinsEntry *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->removeEntry((*reinterpret_cast< SendCoinsEntry*(*)>(_a[1]))); break;
-        case 1: _t->payAmountChanged(); break;
-        case 2: _t->setRemoveEnabled((*reinterpret_cast< bool(*)>(_a[1]))); break;
-        case 3: _t->clear(); break;
-        case 4: _t->on_deleteButton_clicked(); break;
-        case 5: _t->on_payTo_textChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
-        case 6: _t->on_addressBookButton_clicked(); break;
-        case 7: _t->on_pasteButton_clicked(); break;
-        case 8: _t->updateDisplayUnit(); break;
-        default: ;
-        }
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        switch (_id) {
-        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
-        case 0:
-            switch (*reinterpret_cast<int*>(_a[1])) {
-            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
-            case 0:
-                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< SendCoinsEntry* >(); break;
-            }
-            break;
-        }
-    } else if (_c == QMetaObject::IndexOfMethod) {
-        int *result = reinterpret_cast<int *>(_a[0]);
-        {
-            using _t = void (SendCoinsEntry::*)(SendCoinsEntry * );
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&SendCoinsEntry::removeEntry)) {
-                *result = 0;
-                return;
-            }
-        }
-        {
-            using _t = void (SendCoinsEntry::*)();
-            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&SendCoinsEntry::payAmountChanged)) {
-                *result = 1;
-                return;
-            }
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject SendCoinsEntry::staticMetaObject = { {
-    QMetaObject::SuperData::link<QFrame::staticMetaObject>(),
-    qt_meta_stringdata_SendCoinsEntry.data,
-    qt_meta_data_SendCoinsEntry,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *SendCoinsEntry::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *SendCoinsEntry::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_SendCoinsEntry.stringdata0))
-        return static_cast<void*>(this);
-    return QFrame::qt_metacast(_clname);
-}
-
-int SendCoinsEntry::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QFrame::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 9)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 9;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 9)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 9;
-    }
-    return _id;
-}
-
-// SIGNAL 0
-void SendCoinsEntry::removeEntry(SendCoinsEntry * _t1)
-{
-    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
-    QMetaObject::activate(this, &staticMetaObject, 0, _a);
-}
-
-// SIGNAL 1
-void SendCoinsEntry::payAmountChanged()
-{
-    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE

build/moc_sendmessagesdialog.cpp

@@ -1,162 +0,0 @@
-/****************************************************************************
-** Meta object code from reading C++ file 'sendmessagesdialog.h'
-**
-** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.18)
-**
-** WARNING! All changes made in this file will be lost!
-*****************************************************************************/
-
-#include <memory>
-#include "../src/qt/sendmessagesdialog.h"
-#include <QtCore/qbytearray.h>
-#include <QtCore/qmetatype.h>
-#if !defined(Q_MOC_OUTPUT_REVISION)
-#error "The header file 'sendmessagesdialog.h' doesn't include <QObject>."
-#elif Q_MOC_OUTPUT_REVISION != 67
-#error "This file was generated using the moc from 5.15.18. It"
-#error "cannot be used with the include files from this version of Qt."
-#error "(The moc has changed too much.)"
-#endif
-
-QT_BEGIN_MOC_NAMESPACE
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_DEPRECATED
-struct qt_meta_stringdata_SendMessagesDialog_t {
-    QByteArrayData data[15];
-    char stringdata0[192];
-};
-#define QT_MOC_LITERAL(idx, ofs, len) \
-    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
-    qptrdiff(offsetof(qt_meta_stringdata_SendMessagesDialog_t, stringdata0) + ofs \
-        - idx * sizeof(QByteArrayData)) \
-    )
-static const qt_meta_stringdata_SendMessagesDialog_t qt_meta_stringdata_SendMessagesDialog = {
-    {
-QT_MOC_LITERAL(0, 0, 18), // "SendMessagesDialog"
-QT_MOC_LITERAL(1, 19, 4), // "done"
-QT_MOC_LITERAL(2, 24, 0), // ""
-QT_MOC_LITERAL(3, 25, 6), // "retval"
-QT_MOC_LITERAL(4, 32, 5), // "clear"
-QT_MOC_LITERAL(5, 38, 6), // "reject"
-QT_MOC_LITERAL(6, 45, 6), // "accept"
-QT_MOC_LITERAL(7, 52, 8), // "addEntry"
-QT_MOC_LITERAL(8, 61, 18), // "SendMessagesEntry*"
-QT_MOC_LITERAL(9, 80, 19), // "updateRemoveEnabled"
-QT_MOC_LITERAL(10, 100, 21), // "on_sendButton_clicked"
-QT_MOC_LITERAL(11, 122, 11), // "removeEntry"
-QT_MOC_LITERAL(12, 134, 5), // "entry"
-QT_MOC_LITERAL(13, 140, 28), // "on_addressBookButton_clicked"
-QT_MOC_LITERAL(14, 169, 22) // "on_pasteButton_clicked"
-
-    },
-    "SendMessagesDialog\0done\0\0retval\0clear\0"
-    "reject\0accept\0addEntry\0SendMessagesEntry*\0"
-    "updateRemoveEnabled\0on_sendButton_clicked\0"
-    "removeEntry\0entry\0on_addressBookButton_clicked\0"
-    "on_pasteButton_clicked"
-};
-#undef QT_MOC_LITERAL
-
-static const uint qt_meta_data_SendMessagesDialog[] = {
-
- // content:
-       8,       // revision
-       0,       // classname
-       0,    0, // classinfo
-      10,   14, // methods
-       0,    0, // properties
-       0,    0, // enums/sets
-       0,    0, // constructors
-       0,       // flags
-       0,       // signalCount
-
- // slots: name, argc, parameters, tag, flags
-       1,    1,   64,    2, 0x0a /* Public */,
-       4,    0,   67,    2, 0x0a /* Public */,
-       5,    0,   68,    2, 0x0a /* Public */,
-       6,    0,   69,    2, 0x0a /* Public */,
-       7,    0,   70,    2, 0x0a /* Public */,
-       9,    0,   71,    2, 0x0a /* Public */,
-      10,    0,   72,    2, 0x08 /* Private */,
-      11,    1,   73,    2, 0x08 /* Private */,
-      13,    0,   76,    2, 0x08 /* Private */,
-      14,    0,   77,    2, 0x08 /* Private */,
-
- // slots: parameters
-    QMetaType::Void, QMetaType::Int,    3,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void,
-    0x80000000 | 8,
-    QMetaType::Void,
-    QMetaType::Void,
-    QMetaType::Void, 0x80000000 | 8,   12,
-    QMetaType::Void,
-    QMetaType::Void,
-
-       0        // eod
-};
-
-void SendMessagesDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
-{
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        auto *_t = static_cast<SendMessagesDialog *>(_o);
-        (void)_t;
-        switch (_id) {
-        case 0: _t->done((*reinterpret_cast< int(*)>(_a[1]))); break;
-        case 1: _t->clear(); break;
-        case 2: _t->reject(); break;
-        case 3: _t->accept(); break;
-        case 4: { SendMessagesEntry* _r = _t->addEntry();
-            if (_a[0]) *reinterpret_cast< SendMessagesEntry**>(_a[0]) = std::move(_r); }  break;
-        case 5: _t->updateRemoveEnabled(); break;
-        case 6: _t->on_sendButton_clicked(); break;
-        case 7: _t->removeEntry((*reinterpret_cast< SendMessagesEntry*(*)>(_a[1]))); break;
-        case 8: _t->on_addressBookButton_clicked(); break;
-        case 9: _t->on_pasteButton_clicked(); break;
-        default: ;
-        }
-    }
-}
-
-QT_INIT_METAOBJECT const QMetaObject SendMessagesDialog::staticMetaObject = { {
-    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
-    qt_meta_stringdata_SendMessagesDialog.data,
-    qt_meta_data_SendMessagesDialog,
-    qt_static_metacall,
-    nullptr,
-    nullptr
-} };
-
-
-const QMetaObject *SendMessagesDialog::metaObject() const
-{
-    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
-}
-
-void *SendMessagesDialog::qt_metacast(const char *_clname)
-{
-    if (!_clname) return nullptr;
-    if (!strcmp(_clname, qt_meta_stringdata_SendMessagesDialog.stringdata0))
-        return static_cast<void*>(this);
-    return QDialog::qt_metacast(_clname);
-}
-
-int SendMessagesDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
-{
-    _id = QDialog::qt_metacall(_c, _id, _a);
-    if (_id < 0)
-        return _id;
-    if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 10)
-            qt_static_metacall(this, _c, _id, _a);
-        _id -= 10;
-    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
-        if (_id < 10)
-            *reinterpret_cast<int*>(_a[0]) = -1;
-        _id -= 10;
-    }
-    return _id;
-}
-QT_WARNING_POP
-QT_END_MOC_NAMESPACE