NOISSUE fix up translation selection in settings and add OS/sys arch reporting

libraries/systeminfo/CMakeLists.txt

@@ -0,0 +1,27 @@
+project(systeminfo)
+
+find_package(Qt5Core)
+
+set(systeminfo_SOURCES
+include/sys.h
+)
+
+if (WIN32)
+	list(APPEND systeminfo_SOURCES src/sys_win32.cpp)
+elseif (UNIX)
+	if(APPLE)
+		list(APPEND systeminfo_SOURCES src/sys_apple.cpp)
+	else()
+		list(APPEND systeminfo_SOURCES src/sys_unix.cpp)
+	endif()
+endif()
+
+add_library(systeminfo STATIC ${systeminfo_SOURCES})
+qt5_use_modules(systeminfo Core Gui Network)
+target_include_directories(systeminfo PUBLIC include)
+
+include (UnitTest)
+add_unit_test(sys
+	SOURCES src/sys_test.cpp
+	LIBS systeminfo
+)

libraries/systeminfo/include/sys.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <QString>
+
+namespace Sys
+{
+struct KernelInfo
+{
+	QString kernelName;
+	QString kernelVersion;
+};
+
+KernelInfo getKernelInfo();
+
+uint64_t getSystemRam();
+
+bool isSystem64bit();
+
+bool isCPU64bit();
+}

libraries/systeminfo/src/sys_apple.cpp

@@ -0,0 +1,41 @@
+#include "sys.h"
+
+#include <sys/utsname.h>
+
+Sys::KernelInfo Sys::getKernelInfo()
+{
+	Sys::KernelInfo out;
+	struct utsname buf;
+	uname(&buf);
+	out.kernelName = buf.sysname;
+	out.kernelVersion = buf.release;
+	return out;
+}
+
+#include <sys/sysctl.h>
+
+uint64_t Sys::getSystemRam()
+{
+	uint64_t memsize;
+	size_t memsizesize = sizeof(memsize);
+	if(!sysctlbyname("hw.memsize", &memsize, &memsizesize, NULL, 0))
+	{
+		return memsize;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+bool Sys::isCPU64bit()
+{
+	// not even going to pretend I'm going to support anything else
+	return true;
+}
+
+bool Sys::isSystem64bit()
+{
+	// yep. maybe when we have 128bit CPUs on consumer devices.
+	return true;
+}

libraries/systeminfo/src/sys_test.cpp

@@ -0,0 +1,22 @@
+#include <QTest>
+#include "TestUtil.h"
+
+#include <sys.h>
+
+class SysTest : public QObject
+{
+	Q_OBJECT
+private
+slots:
+
+	void test_kernelNotNull()
+	{
+		auto kinfo = Sys::getKernelInfo();
+		QVERIFY(!kinfo.kernelName.isEmpty());
+		QVERIFY(kinfo.kernelVersion != "0.0");
+	}
+};
+
+QTEST_GUILESS_MAIN(SysTest)
+
+#include "sys_test.moc"

libraries/systeminfo/src/sys_unix.cpp

@@ -0,0 +1,49 @@
+#include "sys.h"
+
+#include <sys/utsname.h>
+#include <fstream>
+
+Sys::KernelInfo Sys::getKernelInfo()
+{
+	Sys::KernelInfo out;
+	struct utsname buf;
+	uname(&buf);
+	out.kernelName = buf.sysname;
+	out.kernelVersion = buf.release;
+	return out;
+}
+
+uint64_t Sys::getSystemRam()
+{
+	std::string token;
+	std::ifstream file("/proc/meminfo");
+	while(file >> token)
+	{
+		if(token == "MemTotal:")
+		{
+			uint64_t mem;
+			if(file >> mem)
+			{
+				return mem * 1024ull;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+		// ignore rest of the line
+		file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+	}
+	return 0; // nothing found
+}
+
+bool Sys::isCPU64bit()
+{
+	return isSystem64bit();
+}
+
+bool Sys::isSystem64bit()
+{
+	// kernel build arch on linux
+	return QSysInfo::currentCpuArchitecture() == "x86_64";
+}

libraries/systeminfo/src/sys_win32.cpp

@@ -0,0 +1,46 @@
+#include "sys.h"
+
+#include <windows.h>
+
+Sys::KernelInfo Sys::getKernelInfo()
+{
+	Sys::KernelInfo out;
+	out.kernelName = "Windows";
+	OSVERSIONINFOW osvi;
+	ZeroMemory(&osvi, sizeof(OSVERSIONINFOW));
+	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
+	GetVersionExW(&osvi);
+	out.kernelVersion = QString("%1.%2").arg(osvi.dwMajorVersion).arg(osvi.dwMinorVersion);
+	return out;
+}
+
+uint64_t Sys::getSystemRam()
+{
+	MEMORYSTATUSEX status;
+	status.dwLength = sizeof(status);
+	GlobalMemoryStatusEx( &status );
+	// bytes
+	return (uint64_t)status.ullTotalPhys;
+}
+
+bool Sys::isSystem64bit()
+{
+#if defined(_WIN64)
+	return true;
+#elif defined(_WIN32)
+	BOOL f64 = false;
+	return IsWow64Process(GetCurrentProcess(), &f64) && f64;
+#else
+	// it's some other kind of system...
+	return false;
+#endif
+}
+
+bool Sys::isCPU64bit()
+{
+	SYSTEM_INFO info;
+	ZeroMemory(&info, sizeof(SYSTEM_INFO));
+	GetNativeSystemInfo(&info);
+	auto arch = info.wProcessorArchitecture;
+	return arch == PROCESSOR_ARCHITECTURE_AMD64 || arch == PROCESSOR_ARCHITECTURE_IA64;
+}