Disable Acrobat DC acrotray.exe

Adobe Acrobat DC installation is very intrusive, creating things that may slow your Windows 10 down. This is how you disable the worst offenders.

Remove the update service:

1. run services.msc and look for “Adobe Acrobat Update Service”;
2. right click, “Stop”;
3. right-click, “Properties”;
4. set “Startup type” to “Disabled”.

Disable the Explorer context menu and acrotray.exe:

1. open Registry;
2. locate Computer\HKEY_CLASSES_ROOT\*\shellex\ContextMenuHandlers\Adobe.Acrobat.ContextMenu;
3. there will be a value like {A6595CD1-BF77-430A-A452-18696685F7C7}, edit it and prefix with --;
4. locate HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run;
5. delete any Acrobat shit you find.

Creating new file types in Windows 10

After formatting my computer and installing Windows 10 IoT LTSC, I lost all my custom file extensions. So far, I was using FileTypesMan, but then I thought, hey what if I actually learn how this file association thing works.

With the help of ChatGPT, I was able to assemble a Registry script to add a new, custom file extension, along with its icon and associated program:

Windows Registry Editor Version 5.00

; Associate extension with given identifier
[HKEY_CLASSES_ROOT\.srt]
@="rodrigocfd.srt"

; File type description
[HKEY_CLASSES_ROOT\rodrigocfd.srt]
@="SRT subtitle"

; Custom icon
[HKEY_CLASSES_ROOT\rodrigocfd.srt\DefaultIcon]
@="D:\\Dropbox\\core\\icons\\srt-blue.ico"

; Open command
[HKEY_CLASSES_ROOT\rodrigocfd.srt\shell\open\command]
@="\"C:\\Windows\\System32\\notepad.exe\" \"%1\""

By analyzing the structure above, it’s pretty clear how the structure works.

And now I have the itch to write a program to manage that stuff.

Inactive titlebar color in Windows 10

After I installed my Windows 10 IoT LTSC, I noticed that the inactive titlebar was white. The blue active titlebar could be set via Settings, but not the inactive. ChatGPT gave me the Registry entries to set this color manually:

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Microsoft\Windows\DWM]
"AccentColorInactive"=dword:00DCDCDC
"ColorPrevalence"=dword:00000001

Save the content above in a *.reg file, and merge it to the Registry, and it’s done.

Understanding std::rotate

While working on the future version of my C++20 WinDlg library, I stumbled upon the need to shift characters within a string. My first impulse was to use memmove, but hey, there should be a C++ way to do this.

In fact, std::rotate seemed to be the appropriate fit – safe and sound –, but turns out I had a different idea on how it would work, and it took me a while to properly understand it. The central idea is: you take the interval [it1 it2) and move it right, so it will end at it3). Everything beyond it3 will be placed at the beginning. Thus it actually “rotates” to the left.

Examples:

std::wstring s = L"01234";

std::rotate(s.begin(), s.begin() + 1, s.end()); // 12340
std::rotate(s.begin(), s.begin() + 2, s.end()); // 23401
std::rotate(s.begin(), s.begin() + 4, s.end()); // 40123

std::rotate(s.begin() + 1, s.begin() + 2, s.end()); // 02341
std::rotate(s.begin() + 3, s.begin() + 4, s.end()); // 01243

Define initial directory in Git Bash

After installing Git on my new Windows 10 IoT LTSC, as always the default directory of Git Bash is home. It is, however, rather easy to change this behavior.

Right-click the Git Bash shortcut to open its properties, and:

• Target: remove the --cd-to-home suffix; and
• Start in: replace %HOMEDRIVE%%HOMEPATH% with whathever folder you want.

Make Firefox fast again

Still on my new Windows 10 IoT LTSC setup, I found a page which seems to have a large amount of Firefox tweaks. I’ve tried most of them, and honestly I didn’t notice any improvement, but I hope it pays off in the long term:

• gist.github.com/RubenKelevra/fd66c2f856d703260ecdf0379c4f59db

Disable Win global hotkeys

Today I installed a new 1 TB SSD drive, since my old 120 GB one capacity was out of control. Windows 10 IoT LTSC was the OS of my choice, along with the incredibly smooth massgrave.dev aid.

One thing that didn’t work was the global shortcuts of foobar2000.. At first I thought it could be related to the newer 64-bit version I finally installed, but ChatGPT – first time on this blog – told me that IoT LTSC is stricter about hijacking Win hotkeys. And it gave me directions on how to disable them globally, which I didn’t even know it was possible. Create a new key under:

HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced

• New, String Value
• DisabledHotkeys
• AS

The above will disable Win+A and Win+S global hotkeys, which is amazing.

Reusing code in const and non-const methods, C++17

I found the code below from this great answer in StackOverflow. It allows you to implement the const method with your logic, then use this one-liner to implement the non-const method. It’s a trick from the great Scott Meyers:

const T& f() const {
	return something_complicated();
}

T& f() {
	return const_cast<T&>(std::as_const(*this).f());
}

I’m using this thing everywhere.

Project templates in Visual Studio 2022

After configuring C and C++ projects countless times, base on these settings, I finally bit the bullet and created a reusable template in Visual Studio 2022. And it’s surprisingly simple: create the project and then go Project → Export Template.

The project name itself can be used inside files with $safeprojectname$ string. In order to have it replaced even inside .rc files, edit the .vstemplate and add:

<TemplateContent>
  <Project TargetFileName="ayylmao.vcxproj" File="ayylmao.vcxproj" ReplaceParameters="true">
    <ProjectItem ReplaceParameters="true">RES\$safeprojectname$.rc</ProjectItem>
  </Project>
</TemplateContent>

There’s no GUI for deleting a template, though. One must manually remove the zip files from two different locations:

• Documents \ My Exported Templates
• Documents \ Templates \ Project Templates

To restore a template, simply copy the zip back to:

• Documents \ Templates \ Project Templates

The Rust doc_cfg fiasco

In WinSafe, Cargo features are used extensively to gate the DLL modules which are currently implemented. This is good because you specify only the modules you need, reducing your compiler effort. The Rust documentation doc_auto_cfg unstable feature was extemely useful, applying tags on each entity specifying the required feature for it.

Then, at some point of October 2025, doc_auto_cfg was merged into doc_cfg. And it’s now completely broken.

I filled an issue at the official repo. I’m not the only one missing that feature, but no one seems to care. This is so demotivating I stopped WinSafe development completely.

I found a workaround by pinning the compiler version using rust-toolchain.toml, along with the last version where doc_auto_cfg works, which I painfully found out:

[toolchain]
channel = "nightly-2025-09-27"
components = ["rust-docs"]
targets = ["x86_64-pc-windows-msvc"]

With the above file, the command line to generate the docs is:

RUSTDOCFLAGS="--cfg docsrs" cargo doc --all-features

Or even better, directly specify the toolchain the command line:

RUSTDOCFLAGS="--cfg docsrs" cargo +nightly-2025-09-27 doc --all-features

This compiler has the 1.92.0-nightly version, and it seems I’m gonna using for a long time.

Update: after 4 months, the bug was finally fixed.

Windows 10 SDK 10.0.20348.0 is gone

I was caught by surprise today after updating Visual Studio 2022 to version 17.14.11. All my projects failed to compile, because the SDK files disappeared. I first thought something broke with VS Code support, but then I saw that Visual Studio itself had the same problem.

Turns out the Windows SDK I was using – 10.0.20348.0 – was simply deprecated and removed in this update, according to here, and the release note itself. Indeed, Visual Studio Installer won’t show it anymore.

Apparently, now I’ll have to install a Windows 11 SDK, even if I’m running Windows 10. I hope this doesn’t break my stuff.

Non-movable and non-copyable C++20 classes

On my fantastic journey implementing WinLamb v2, I’m diving deep into C++20, grasping a lot of concepts I never understood before, and having a lot of fun along the way.

One of the things that I implemented was the idea of non-copyable and non-movable classes, at first, using macros. This felt inelegant, so I implemented P2895 paper with utility classes. It ultimately failed with the nested ListView classes, so I discarded the idea too.

My final solution was to = delete move constructor, which will prevent all copy and move. The hard rules are not particularly easy to memorize, so I’ll let them here for further reference:

1. The two copy operations are independent. Declaring copy constructor does not prevent compiler to generate copy assignment and vice versa. (Same as in C++98.)
2. Move operations are not independent. Declaring either one of them prevents the compiler to generate the other. (Different from copy operations.)
3. If any of the copy operations is declared, then none of the move operations will be generated.
4. If any of the move operations is declared, then none of the copy operations will be generated.
5. If a destructor is declared, then none of the move operations will be generated. Copy operations are still generated for reverse compatibility with C++98.
6. Default constructor generated only when no constructor is declared. (Same as in C++98.)

Example:

class Foo {
private:
	Foo(Foo&&) = delete; // non-copyable, non-movable
};