Build your own desktop
Stardock created Object Desktop to allow users to transform Windows into a customized solution. The goal being that individuals and companies can tailor Windows to meet their specific needs. Object Desktop does this through its components. These components each customize a particular part of Windows. These components include WindowBlinds, ObjectBar, IconPackager, ControlCenter, and DesktopX.
DesktopX is designed to handle the actual desktop (ObjectBar handles the bars/wharfs and WindowBlinds the GUI itself). It does this by extending the shell to support true objects. These objects can be combined together to create virtually anything imaginable – apps, utils, bars, wharfs, super icons, etc.
Typical settings dialog for an object.
What’s made DesktopX’s objects so flexible is a combination of four things:
1) Objects can be any size or shape (icons are all identical in size with a fixed resolution such as 32x32).
2) Objects can have any number of different states (normal, mouse over, mouse down, mouse away and custom states)
3) Objects can send and receive messages to the operating system, to applications, and to other objects.
4) Object position can be set by the user and it will stay in that exact position or relative position regardless of screen resolution.
Objects can thus be used together to create virtually anything a user imagines.
Take a close look at the above screenshot. It’s built using hundreds of objects. When those objects are put together, they can form anything. And each of those objects can send and receive messages and react to those messages.
This means one can literally draw up their user interface and put it together. Normally this would require a considerable amount of programming. But DesktopX handles all of the underlying messaging and drawing routines that normally the developer would have to create.
DesktopX 1.0 also included a basic plugin design that allowed developers to extend what was built into DesktopX. With it, users created everything from email checking objects to disk space monitoring objects. DesktopX became very popular with end users looking for a flexible way of creating their own unique desktops either for a company, a kiosk, or individual use.
A nice kids desktop
Stardock also learned a lot of lessons from the initial release of DesktopX. While its architecture was powerful, it required too much programming knowledge to extend it. The net result is that the vast majority of objects and themes were primarily cosmetic in nature. These objects were a sort of “super icon”. Most developers simply do not want to invest time into a proprietary plugin format that was fairly limited in scope.
But DesktopX NG is some ways off, in the meantime, Stardock is delivering some of this in DesktopX 1.1.
The above screenshot to a developer is like a kid in a candy store. There are so many things to choose from and with COM being the “plugin” format, it means for developers that DesktopX is a stepping stone for ambitious developers to learn how to create next generation software that is applicable far beyond just DesktopX. DesktopX also supports a new proprietary Plugin standard called SDPlugin for C++ developers who want a relatively easy way to create plugins that will work on both DesktopX and ObjectBar as a stepping stone to Microsoft’s COM.
The above example also demonstrates the need for “Wrappers” that will arrive with DesktopX NG. A developer can use the scripting language of their choice to put these COM objects together into something useful, but a typical user would be intimidated by it. Wrappers put a user friendly interface in front of this which in turn talk to the various COM objects for the user.
But clearly for developers, the ability to access all of this and be able to create software that is immediately useable is compelling. It’s particularly compelling since the knowledge learned in creating these objects and scripts is directly transferable to ones career in software development (A DesktopX object that displays a graph of how many users are downloading a particular skin on a day by day basis using VB Script and an .asp page is the same code one would use to do it with visual basic (except the developer would also have to handle all the visual display and events which DesktopX handles for them).
What are some examples of DesktopX 1.1 in action? Here are a few compound object examples:
Example #1: A new headling reader.
How about an object that automatically every so often queries a favorite website to see if its news items have changed. How much work would this normally be if you wanted something on your desktop that just sits there and does it? Do it in Visual Basic and it would take a couple of hours and use several megabytes of RAM. Do it with DesktopX 1.1 and it can be done in a few minutes. One literally creates the object, right clicks on it and uses DXScript, chooses VB Script and writes the above code (26 lines total including spaces). That’s it. You now have a news item object that sits on your desktop. How much RAM does this use? 7 megabytes and that includes DesktopX itself. Most of that RAM is the Internet explorer object that it had to create. DesktopX isn’t just easier than using a programming language to create a stand alone program, it uses a lot fewer resources in doing it.
This is actually the same as example 1 except instead of getting news, it queries the stock price on an item that the user has inputted. Time to create – about the same amount as the first example.
Microsoft’s new Instant Messenger is actually a collection of COM objects. This means that it can be accessed as parts in DesktopX. The upcoming IM object example Stardock will be releasing shortly will allow users to actually have a individual objects that can correspond to individual users. When the user double clicks on the object, it will let them send a message to the object’s user. Similarly, when a message is received, it can respond to that (so in the example you could have the object actually be the face of that person. When they send a message to you, you could have them “speak” (play a WAV file) and change their face.
To demonstrate the real time features, Stardock will be releasing two objects – a ball and a bat. The ball will float on the desktop and the bat will be another object that the user can pick up and whack the ball which will go flying around the screen. It’s a simple example to demonstrate how easily one can have one object interact with another.
Microsoft is putting together its .NET initiative and no program is more ready to take advantage of .NET than DesktopX. DesktopX will be able to access those .NET services directly and provide developers an easy way to access .NET technologies. In many ways, DesktopX is “OpenDoc” and “Cairo” on the desktop brought to reality. OpenDoc’s goal was to allow developers to interact with different “parts” in different ways to lower development costs and make it much easier for corporations to create custom environments. This is what DesktopX can do and will continue to make such customization and deployment increasingly easier as it moves towards the DesktopX NG goal.
DesktopX object and theme library: http://www.wincustomize.com/skins.asp?library=3
DesktopX DXScript tutorial: http://www.stardock.com/products/desktopx/dxscript.doc
DesktopX home page: http://www.desktopx.net
Object Desktop home page: http://www.objectdesktop.com
Stardock home page: http://www.stardock.com
DesktopX is available stand alone for $19.95. Users can get the complete Object Desktop for $49.95 which also includes a 1 year subscription to ObjectDesktop.net.