cgit | A hyperfast web frontend for git repositories written in C

I'm attempting to implement a subclass of QQuickAsyncImageProvider in Pyside6, referring to the official example. I'm already aware of the potential hurdle that, unlike in the C++ example code, with PySide it's not possible to inherit from both QRunnable and QObject. In order to send a signal from my QRunnable I'm instead using an intermediary QObject, as suggested here. That part works fine.

Here's my attempt so far at using this arrangement along with my own subclass of QQuickAsyncImageProvider:

In a QSpinBox, when the range is sufficient, the user is allowed to enter thousand separators.
Eg: 1.2.3.4 is a valid entry, en then fixup() just removes the dots. Resulting in 1234.

How can I prevent the user from entering thousand separators?

Previously I made something similar based on QLineEdit which uses validators.
But QAbstractSpinbox doesn't use QValidators. So I'm not sure how to proceed.

For a project which uses MQTT, I always had to compile the QtMqtt module from source, because it wasn't included in the prebuilt windows release and couldn't be chosen for installation either. In Qt5 that was pretty easy: Download source code from official git (https://code.qt.io/cgit/qt/qtmqtt.git/), open the .pro file in QtCreator and compile the project. For installation, I just moved the .dll files to my Qt install directory.

Now in Qt6, the build process was switched from qmake to cmake, so I cannot simply load the project in QtCreator, but have to compile it manually using CMake, which I find really unintuitive and prone to errors. From what I understand, I cannot compile single modules on their own from now on, but have to get the whole Qt 6.2.0 source code instead (i.e. via installer option) and then use a --target option on CMake to build only specific module. So here is what I did so far:

1. Get Qt source code from installer (installed to Qt/6.2.0/Src)
2. Create a command line environment according to this manual
3. Open cmd environment, navigate to build folder (i.e. Qt/6.2.0/build)
4. Configure build using command: ..\Src\configure -prefix Qt\6.2.0\build
5. Build with cmake using command cmake --build . --target qtmqtt
6. Install using command cmake --install .

What happens, is that the configuration works, and the build supposedly too, but installation fails with something like:

after several failed attempts to create a QOpenGLWidget.I tried to run the QT example code https://code.qt.io/cgit/qt/qtbase.git/tree/examples/opengl/2dpainting?h=5.15 But that does not work too. I get the same vtable error as in the previous attempts. Here is the complete error code.

I already reinstalled QT and added

I am having some issues with the following gstreamer command

Sender (on embeeded system)

I am curious about the ways to wrap a floating-point value x in a semi-closed interval [0; a[.

For instance, I could have an arbitrary real number, say x = 354638.515, that I wish to fold into [0; 2π[ because I have a good sin approximation for that range.

The fmod standard C functions show up quite high in my benchmarks, and by checking the source code of various libc implementations, I can understand why: the thing is fairly branch-ey, likely in order to handle a lot of IEEE754-specific issues:

• glibc: https://github.com/bminor/glibc/blob/master/sysdeps/ieee754/flt-32/e_fmodf.c
• Apple: https://opensource.apple.com/source/Libm/Libm-315/Source/ARM/fmod.c.auto.html
• musl: https://git.musl-libc.org/cgit/musl/tree/src/math/fmod.c
• Running with -ffast-math causes GCC to generate code that goes through the x87 FPU on x86/x86_64 which comes with its own set of problems (such as 80-bit doubles, FP state, and other fun things). I would like the implementation to vectorize at least semi-correctly, and if possible to not go through the x87 FPU but through vector registers at least as the rest of my code ends up vectorized, even if not necessarily an optimal way, by the compiler.
• This one looks much simpler: https://github.com/KnightOS/libc/blob/master/src/fmod.c

In my case, I am only concerned about usual real values, not NaNs, not infinity. My range is also known at compile-time and sane (a common occurence being π/2), thus the checks for "special cases" such as range == 0 are unnecessary.

Thus, what would be good implementations of fmod for that specific use case ?

I'm building an embedded Android device and I have a Qt/QML app I'd like to install as a system app.

However, when I attempt to launch it after moving it to /system/app or /system/priv-app, I get a popup box "Your application encountered a fatal error and cannot continue"

I tried this on the simplest QML project and as standard an emulator config as I could, and still ran into the issue

I'm doing this on Windows now as I write this question, but I also ran into the same issue trying to do it from my main Linux development machine.

Steps I followed leading up to this (some may be in a different order than they were actually performed, I'm recalling from memory after trial and error):

1. Install Android Studio Canary (2021.1.1 Canary 7)
2. Install Android 29 SDK and the x86 emulator image (Google APIs, not Google Play), create a Pixel 5 API 29 virtual device
3. Install Qt 5.15.2 for Android from the Qt maintenance tool / online installer
4. Install AdoptOpenJDK 8
5. Run Qt Creator, head to Tools->Options->Devices->Android, point it to the AdoptOpenJDK installation, let it set up the tools it needs, and verify everything has green checkmarks
6. Start a new project and select the Qt Quick "Swipe" template (bare minimum QML example), 5.15.2 for Android. Named "QMLhello" in this case.
7. In "Projects" tab under the "Build" settings for 5.15.2 multi-abi, expand the "qmake" section and check the "x86" checkbox so that it builds an ABI for the Android emulator
8. Verify that Qt Creator can build and run the app as a "normal" app (the green "Run" button successfully deploys and launches the app, and can swipe between pages)

Steps I performed in order to prepare to move the app to the system:

1. Add environment variable studio.emu.params to the user environment, with the contents -writable-system
2. Restart Android Studio and cold boot the AVD emulator to start with a writable system as specified in the environment variable
3. adb devices lists the emulator as a device
4. adb root and adb remount successfully remounts

What I tried after some rummaging around, combining some older answers on StackOverflow into my attempt:

I want to add a touchscreen driver available in the linux kernel source tree to my Yocto image (The link takes you to goodix.c). I basically need to add it as a kernel module.

I follow the Incorporating Out-of-Tree Modules section of the Yocto Mega Manual. I base mine off their example kernel-module recipe, called hello-mod.

1. In recipe goodix-9271_0.1.bb: RPROVIDES_${PN} = "kernel-module-goodix"
2. In layer.conf: MACHINE_EXTRA_RDEPENDS += "kernel-module-goodix"

My build simply consistently fails in do_rootfs with:

Prerequisites :

• Bash Version = 4.2.46

I wrote the following code：