Calimero Files

Overview

Calimero is a wallpaper manager for Windows that lets you fetch and set images from websites like Picsum, Pexels, Reddit, and Danbooru. It also includes some fancy things like the flying icons.

A full description can be found here: https://sourceforge.net/p/kalimero/wiki/Calimero%20home%20page/

This folder contains the source code of the main project (wchg, aka Calimero) and two helper projects (pe and martyrdom).

The Installer with the latest version (the compiled Windows executable) is available here.

Project dependencies

The source code is split between here (SourceForge) and GitHub, because GitHub forced me to remove the main Calimero project.

The files available here on SourceForge are:

• The wchg zipped file, which contains the code for the actual project (Calimero).
• The pe zipped file, which contains an utility to convert Unicode strings into percent-encoded ANSI text.
• The martyrdom zipped file, which contains an utility used as a proxy, to absorb any exceptions thrown by one of the libraries (NexgenIPL), ensuring they don't interfere with the execution flow of the main program.

The Installer for the latest version of the program takes care of installing all the libraries (DLLs) required for the executable to run properly. However, the libraries, DLLs, and related headers needed to recompile the source code must be found and installed separately.

The repositories from GitHub required to compile the above source code, are the following:

• The Include and Library projects, containing the source code I've developed over the years and reuse across various projects.
• The BerkeleyDB repository, which contains the original 1999 distribution of the BerkeleyDB library version 2.7.7, copyright (c) Sleepycat Software. This project is used to build the corresponding DLL, which I use with my own C/C++ interface (CBerkeleyDB.cpp/.h, CBase.cpp/.h, CBdbtf.cpp/.h, etc.) for tabular data access.
• The zLibDll repository, based on the original zLib code copyright (c) Jean-loup Gailly and Mark Adler, which was tweaked specifically to be used with my own C/C++ interface (CGzw.cpp/.h).
• The BrotliDLL repository, (Brotli copyright (c) Google), which contains a modified version of the original project so it can be compiled as a Windows DLL.

Regarding external (not mine) source code required by the main project, you will also need:

• The cJSON interface, copyright (c) by Dave Gamble, which must to be sourced separately.
• The paintLib, NexgenIPL, FreeImageRe, and ImageMagick libraries (all credits go to the respective owners) and potentially a series of helper libraries (like libjpeg, libpng, libtiff, etc.), depending on the graphics interface selected in the main project's source code, which must be found separately.

Calimero uses a specific C/C++ interface (CImageObject.cpp/.h, CImage.cpp/.h, etc.) that allows working with various graphic formats by swapping out the underlying graphics library depending on your needs. In other words, the code lets you dynamically select which graphics library to use, while also introducing its own interface layer for implementing new features. This selection can be done either at run-time (if you have all currently supported libraries available) or at compile-time, by specifying which libraries you want to include.

paintLib and NexgenIPL are very old libraries, the first ones used by the Cimage interface, while FreeImageRe and ImageMagick are more recent additions. The code for these base libraries (and any related ones) is not included here, so they will need to be found separately. My advice is to modify the inclusion macros in the source code to select only FreeImageRe, which is currently available and pretty straightforward to use.

Implementation notes

This project was born out of pure curiosity and boredom. I wanted to resurrect a program I wrote almost 20 years ago and which had stopped working properly due to changes in modern systems (different Windows interfaces, HTTP/1.1 instead of the old HTTP/1.0, and so on).

The program is an absolute hybrid: first of all, the source code is not strictly C or C++, but rather "C with classes".

It builds a Windows console application (no graphical interface), but still makes heavy use of typical Windows GUI objects like tray icons, context menus, and tooltip balloons.

Internally, it follows the classic C/C++ structure with a main() function, but it manually integrates (without using the standard patterns) things like MFC, ATL, COM, etc. (e.g., it creates an internal CWinApp object and injects the console handle into it).

The program is built for the x86 architecture because it needs to interface with some x86 DLLs. However, it also communicates with the Windows Shell (which runs in x64) by allocating memory directly inside Explorer’s process space (this is how it makes desktop icons "fly").

By default, the program runs in ANSI mode, as required by most of the old library codebase. However, it switches explicitly to Unicode where needed (for console output, tooltip balloons, etc.) to properly support wide characters, such as Chinese text.

Internally, there’s a three-layer architecture (kind of a Matryoshka doll) with three different main() functions. This system handles various types of exceptions and allows the program to restart on the fly by throwing specific exceptions. It also includes a dedicated VEH exception handler to prevent abrupt termination by the Kernel.

On top of all this, the program includes specific interfaces for handling different image formats, a local database, and HTTP communication to download images directly from websites like Reddit or Danbooru.

In short, if you’re into low-level (and high-level as well) Windows programming in C and C++, this project contains quite a few interesting techniques and tricks worth exploring.

If you have any doubts, questions, or if there's anything I forgot to mention or clarify, feel free to reach out.

Luca P.