If you visited the other parts of this website, you saw that I developped a plugin for Winamp. After a while, some people requested me to make it work with Litestep. As this moment, I had no idea what Litestep was.
I did some research and found out that Litestep was a shell replacement for Windows and that a rather big community was eriged around it. At this very moment, I did not thought that I'll do what were asked me, because I did not thought that was very important.
But just after the release of a new version of the plugin, other people asked me for the same thing. and that time I took care of their willings. That brought me to do this module, which will be able to help other developpers to integrate their applications with litestep.
The module is an IPC server. IPC is for interprocess commmunication. This server shares information with other processes that ask it to.
For now, the server can only give a few information, mostly the current settings of Litestep and the handle of the main Litestep Window. But the section of the source code that execute requests is very simple, so I'm sure that very soon we'll see this module enhanced by many useful function calls.
I'm not myself a Litestep user yet (I won't try to defend Explorer), so I'm not going to add myself many functions to the module. I only added those useful to make my winamp plugin interact correctly with Litestep.
This module implements a IPC model to get settings and info from a running litestep instance, to provide this data to an external application. This module can help non-litestep appilication developpers to integrate their application with litestep.
Settingsipc is implemented with an emulated shared memory space and synchronisation with mutexes and events. Shared memory is, on certain systems, memory area that can be accessed by any process, with specific absolute addresses. Some operating systems, like older Mac OSes, doesn't have anything but shared memory. Modern operating systems desn't allows that, for evident reasons of stability.
I talk of emulated shared memory because I get some shared memory with file mapping functions. These functions create an area in the memory with specific file data, which can be accessed as any memory. These functions are useful when using a very big amount of random file access to the same file. It's faster than IO access because all is done in the memory and is flushed later.
Windows permits creation of file mapping area without any real file, only with a handle and a unique name for the file, even if it doesn't exists on disk. So many processes can open the same virtual file, and obtains a pointer for the same memory area. The pointer is relative to the virtual address space fo each process, so it can be different addresses, but it really points to the same data. By using mutexes, we are sure that two processes doesn't write or read in the memory at the same time. With events, the client can notify the server (and vice-versa) that they are finished with the data, and that they need an answer.
In the shared memory space, the client put all the data related to the request, with a code specifying the request itself. The server understands this code, translates it to a request to litestep, and write back the answer in the shared memory. The client can read the answer and give it to the external application
For example, Winamp Advanced Controls needs to know is litestep is loaded. So it calls IsServerPresent. The client tries to allocate shared memory space, and find out is it exists or not. If it exists, it send an empty request to the server, which answers with nothing, but answers. The client knows that the server is present.
If you want to use the client in your application, read the documentation in the header file. It's not difficult to understand, even with my not-so-good englsh. If you are willing to, you can also get the source code and read it to know more about the described process, and event to add your own functions to it.
Continue to the download page to download the settingsipc package and sdk