Delphi Clinic C++Builder Gate Training & Consultancy Delphi Notes Weblog Dr.Bob's Webshop
Bob Swart (aka Dr.Bob) - Medical Officer Dr.Bob's Kylix Kicks
 Review: Tomes of Delphi: Win32 Shell API Windows 2000
See Also: Dr.Bob's Programming Books for Delphi, Kylix & C++Builder books co-authored by Bob Swart
Title:
Author:
Publisher:
ISBN:
Info:
Tomes of Delphi: Win32 Shell API Windows 2000
John Ayres
WordWare
1556227493
700 pages, CD-ROM

The Tomes of Delphi: Win32 Core API (published in January 2002) is the Windows 2000 edition of the original Tomes of Delphi: Win32 Core API that has been my number one resource when looking for information about how to use the Win32 core API in Delphi. In fact, that quote is even printed on the cover of the new edition, together with quotes from Steve Teixeira, Marco Cantý and Michael Swindell.
The Tomes of Delphi: Win32 Shell API (published in January 2002) can be seen as a companion to the Tomes of Delphi: Win32 Core API. And while I've loved (and still love) the core API book, I must admit that this one - the Win32 Shell API -is even better, in that I find myself using it more often, and spending more time with it than with the previous book (of course that may also be caused by the fact that the Core API is actually a revised edition based on the original Core API book, and the Shell API is a fresh new book).
Both books aren't meant to be read from cover to cover, although individual chapters can be read just fine (when everything is centred around a single topic). The layout of each book is that of a true reference guide. Each chapter covers a specific (sub)topic, and then covers all APIs, arguments, values and results using Delphi syntax (previously known as Object Pascal). Both comes also come with a Windows Helpfile that can be used while working with Delphi, which is also very convenient. Code Insight is one thing, being able to read what the API does and what the effect is of a certain parameter value is even more useful.

The Tomes of Delphi: Win32 Core API consists of 13 chapters, starting with an introduction in Delphi and the Windows API. The 12 following chapters are about "core" topics such as Window Creation, Message Processing, Memory Management, Dynamic Link Libraries, Process and Threads, Timers, Errors, Graphical Device Interface (GDI), Painting and Drawing, Region and Path, Bitmap and Metafile, and Text Output APIs.

The Tomes of Delphi: Win32 Shell API consists of 14 chapters, and actually starts with the same first chapter introducing Delphi and the Windows API (8 pages). In fact, the entire introduction and foreword of both books is the same, but the difference starts on page 9. Despite the title, the Win32 Shell API doesn't only cover Shell APIs - that would not be enough to fill a whole book. Therefore it starts with some "normal" Win32 APIs that were not included in the Win32 Core API book, such as Window Movement, Window Information, File Input/Output, Input (joystick, keyboard, etc.), String and Atom, Clipboard, System Information, Icon, Cursor and Caret, and Help APIs. All these topics are good for chapters 2 through 10, and about 500 pages.
The last four chapters (about 200 pages) cover the Shell API, starting with Shell File, Shell Folder, and then Shell functions (hooks and extensions) followed by a last chapter on special Shell functions which did not fit in one of the previous three chapters, like a control panel applet and an appbar.

In both books, each chapter will start with a little introduction about the topic, and then list a number of APIs that are available in Win32. For each function, the syntax is shown using the Delphi language, and possible parameter values are listed - along with their meaning and effect. Often, a short few-line example usage is also shown (in a Button OnClick event handler, calling the API with some example parameter values). This means that you can actually see the results right away, especially if you copy that example code from the helpfile in your Delphi Code Editor. Each function is shown with syntax, description, return value, and references to other APIs that are related. These references can also be between both books, as a * will indicate that the API is covered in the other book (so at times I find myself switching back and forth between those two book), which may be a bit frustrating if you only have one of the books, and would like to read the reference in the other book (why not sell them together with a discount?). Where necessary it is mentioned that certain values or APIs are only available on certain versions of Windows (covered versions are 95/98/Me as well as NT/2000/XP, and you often see a reference that this particular parameter value is only supported on 89/2000 for example).
If you need to work with the Win32 API - and who doesn't from time to time - then you'll quickly find that these books are very helpful - again, I can't help to mention the helpfiles that are just great (the books are a bit too heavy to take with you on training or to clients, but the helpfiles fit on my laptop just fine). And even the imminent migration to the .NET world doesn't mean that Win32 is dead. Especially if you consider that you can still call the Win32 API from your .NET applications (as long as you realise that it will be unsafe, unmanaged calls that you are performing), as I'll show in my Dr.Bob Examines #39 column.

(Bob Swart)


More Book Reviews

This webpage © 2002-2003 by webmaster drs. Robert E. Swart (aka Dr.Bob - www.drbob42.com). All Rights Reserved.