Microsoft Systems Journal – Jacob Filipp

Microsoft Systems Journal — 2000 Index

February 2000 — Vol 15 No 2

Handle Logons in Windows NT And Windows 2000 with Your Own Logon Session Broker
You can create a “logon session broker” to launch processes into arbitrary window stations and desktops with any user’s logon credentials. We bring together our cmdasuser utility and the concepts you need to build your own logon session broker.
Keith Brown
Construct Your E-commerce Business Tier the Easy Way With XML, ASP, and Scripting
Forget COM for the middle layer of your n-tier e-commerce app. Instead, build your business layer with ASP, XML, and scripting. We’ll show you how to use these technologies to develop a powerful, multitier site that interacts with third-party vendors.
Dave Cohen
It’s Simple to Build PerfMon Support into Your Apps With A Little Help from COM
PerfMon in Windows NT is not just for monitoring system resources. Using a COM server and a single DLL, you can painlessly hook up multiple apps to PerfMon and access a whole new level of resource management and debugging.
Ken Knudsen
Editor’s Note
Joe Flanigen
C++ Q&A
Paul DiLascia discusses a new function in Windows 2000, GetLastInputInfo, which holds information about that last events the system handled. With it you can determine how long the system has been idle, and what the last events were.
Paul DiLascia
Visual Programmer
It turns out you can write COM components with scripting languages. This month George Shepherd shows you how the Windows Script Components (WSC) let you package scripts for use as COM components.
George Shepherd
Nerditorium
This month Jim Finnegan looks at the Driver Verifier, a kernel-mode addition introduced in Windows 2000 that’s aimed directly at developers, providing operating-system-level support for testing, debugging, and stressing kernel-mode drivers.
Jim Finnegan
Under the Hood
Matt Pietrek introduces DelayLoadProfile, which helps you determine which DLLs are good candidates for DelayLoad by reporting how often a DLL is called, by which applications, and other pertinent data.
Matt Pietrek

January 2000 — Vol 15 No 1

Use Application Center or COM And MTS for Load Balancing Your Component Servers
Of all the servers in your cluster, the one that is the least busy should respond to a client component request. You can load balance the use of your COM objects when Microsoft Application Center is released­-or you can get started today with COM and MTS.
Timothy Ewald
Visual Basic Design Time Techniques to Prevent Runtime Version Conflicts
Compatibility issues can be a nightmare when components written in different versions of Visual Basic won’t work together. Understanding the Visual Basic compatibility scheme and Interface Definition Language will help you cope.
Brian A. Randell and Ted Pattison
Active Directory Doesn’t Just Manage Network Resources, It Can Manage Your Data Too
You thought Active Directory services was just for managing network resources. But in reality you can use Active Directory services to store static data in a hierarchical manner, just like the files or folders on your hard drive.
Shawn Wildermuth
Editor’s Note
Joe Flanigen
C++ Q&A
Paul Dilascia describes how to use CHtmlView to display HTML in a dialog and addresses a common problem of accessing Data Access Objects from C++ with MFC.
Paul DiLascia
Win32 Q&A
Jeffrey Richter introduces the four levels of opportunistic locks that Windows 2000 supports.
Jeffrey Richter
Bugslayer
This month John Robbins completes last month’s discussion on WinDBG by showing how to extend WinDBG with custom commands, called WinDBG extensions.
John Robbins
House of COM
In this month’s column, Don Box discusses the emerging use of XML as a component technology.
Don Box

Microsoft Systems Journal — 1999 Index

December 1999 — Vol 14 No 12

CODE MSJDec99 (1,173,539 Bytes)

Design Your Application to Manage Performance Data Logs Using the PDH Library
Performance data is useful for more than just system analysis. You can use it to reveal potential application bugs. The ability to create, and better yet, read and analyze performance data logs with PDH.DLL further facilitates this problem-solving process.
Gary Peluso
More Reusable MFC Goodies: Simplify Your (Programming) Life with the COMToys Library
COMToys isn’t an all-embracing system; it’s more of an ad hoc collection of macros, functions, and classes. But, whether or not you’re using MFC, COMToys does offer an approach to programming COM in C++ that works for any kind of COM object.
Paul DiLascia
Extending ATL 3.0 Control Containment to Help You Write Real-world Containers
VBLite is a full-blown control container suitable for use as a simple form-based development environment that was created by extending ATL 3.0. You’ll see how it was developed and get a set of ATL extension classes to use in your own apps.
Dharma Shukla and Chris Sells
Editor’s Note
Joe Flanigen
C++ Q&A
This month Paul DiLascia disables the scrolling of a virtual list control.
Paul DiLascia
Basic Instincts
In this new column, Ted Pattison discusses the proper use of SetComplete in MTS.
Ted Pattison
Visual Programmer
George Shepherd on debugging an ActiveX-based DLL and accessing a nondefault interface.
George Shepherd
Bugslayer
John Robins on utilizing the power of the WinDBG debugger that is included in the Platform SDK.
John Robbins

November 1999 — Vol 14 No 11

CODE MSJNov99 (395,299 Bytes)

MyBand is Your Band: More Reusable MFC Goodies with Band Objects and COMToys
One day, Paul DiLascia got up and decided to write his own desk band. By the time he was finished, he had built a BandObj framework that reduces writing a band object to a few lines of code. It’s part of his own COM programming system called COMToys.
Paul DiLascia
The COM+ Security Model Gets You out of the Security Programming Business
Security has a deserved reputation for being complicated. It’s typically the last thing that developers work on, and when they do, it often breaks the application. But with COM+, you can avoid having to develop this code yourself.
Guy Eddon
Using OLE DB and ADO 2.5 to Represent Nonlinear, Nonrelational Types of Data
The new cotypes introduced by OLE DB 2.5 accommodate types of data that can’t be squeezed into rectangular rowsets. You’ll see how to use these new cotypes, how they integrate with the existing OLE DB object model, and their impact on ADO.
Bob Beauchemin
Editor’s Note
Joe Flanigen
C++ Q&A
This month– Control Panel applets in C++ and MFC.
Paul DiLascia
Wicked Code
Taking the mystery out of monikers.
Jeff Prosise
Security Briefs
This month Keith Brown looks at Windows NT® privileges from a programmer’s perspective.
Keith Brown
Under the Hood
Where has all the memory gone? Managing memory and resource leaks.
Matt Pietrek

October 1999 — Vol 14 No 10

CODE MSJOct99 (625,004 Bytes)

Writing OLTP Apps with Visual Basic, Microsoft Transaction Server, and SQL Server 7.0
If you plan to run MTS-style transactions, you should know how SQL Server works with the MTS runtime and the Windows NT Distributed Transaction Coordinator. Understanding how all these pieces fit together will help you optimize your app.
Ted Pattison
Introducing the Terminal Services APIs for Windows NT Server and Windows 2000
Frank Kim is back to explain the differences between Windows NT Server, Terminal Server Edition, and Windows 2000 Terminal Services. He’ll show you the new Terminal Services APIs, and give you a preview of Virtual Channels in Windows 2000.
Frank Kim
Keeping an Eye on Your NTFS Drives, Part II: Building a Change Journal Application
Last month, you were introduced to the Change Journal. This month, you’ll see how to write a fully functional Change Journal app. Our sample app demonstrates all the techniques described, and can be used as a template project.
Jeffrey Cooperstein and Jeffrey Richter
Editor’s Note
Joe Flanigen
C++ Q&A
This This month– Optimizing your splash screen.
Paul DiLascia
Bugslayer
When SEH translators don’t work.
John Robbins
Visual Programmer
What is active scripting, and how can you use it in your applications.
George Shepherd
Win32
More on creating threads by calling the C runtime library’s _begin- threadex function.
Jeffrey Richter

September 1999 — Vol 14 No 9

CODE MSJSept99 (239,670 Bytes)

Keeping an Eye on Your NTFS Drives: the Windows 2000 Change Journal Explained
The Change Journal is a database that contains a list of every changed file or directory on an NTFS 5.0 volume. You’ll see this new Windows 2000 technology explained and be introduced to the API that’s used to access it.
Jeffrey Cooperstein and Jeffrey Richter
The COM+ Event Service Eases the Pain of Publishing and Subscribing to Data
Notifying interested parties of changes to data is a classic problem of distributed computing. But the COM+ event service provides an infrastructure that makes publishing and subscribing to data easy, as our sample program will demonstrate.
David Platt
Manipulate and Query OLAP Data Using ADOMD and MDX, Part II: Writing the App
Last month, Carl Nolan introduced you to ADOMD and MDX in order to construct a Web-based application for querying OLAP data. Now you’ll see how to construct the app so that you’ll be able to drill down into a particular member or data cell.
Carl Nolan
Editor’s Note
Joe Flanigen
C++ Q&A
This month Paul DiLascia covers adding animation to a toolbar and extracting icons from exe files.
Paul DiLascia
House of COM
Don Box explains why contexts (OS-level abstractions that have a supporting API and underlying implementation) are as real as processes or threads.
Don Box
Visual Programmer
George Shepherd demonstrates how to turn a bitmap into a picture suitable for an ActiveX control by using the function OleCreatePictureIndirect.
George Shepherd
Under the Hood
This month Matt Pietrek tours part of the Windows NT loader code and demonstrates a nifty trick for getting loader status information from the loader.
Matt Pietrek

August 1999 — Vol 14 No 8

CODE MSJAug99 (463,522 Bytes)

Exploring Kerberos, the Protocol for Distributed Security in Windows 2000
Why did Microsoft adopt Kerberos as the default distributed security protocol for Windows 2000? Kerberos provides several features that aren’t available in NTLM. Kerberos is also faster than NTLM, and it’s a multivendor standard.
David Chappell
Manipulate and Query OLAP Data Using ADOMD and Multidimensional Expressions
Multidimensional Expressions (MDX) provides a rich and powerful syntax for querying and manipulating the multidimensional data stored in OLAP server cubes. ActiveX Data Objects Multidimensional (ADOMD) is used to provide client access to the data.
Carl Nolan
Logo Requirements and More: Solutions for Writing Great Windows 2000-based Apps
Whether or not you want the Windows 2000 logo on your product, you’ll find the Windows 2000 Application Specification useful, although sometimes it’s too general. Here are some specific tips that augment it to help you use Windows 2000 to its fullest.
Dino Esposito
Editor’s Note
Joe Flanigen
C++ Q&A
Making a recent file list appear in a menu is easy, but how does it work? And how can you have more than one MRU list?
Paul DiLascia
Bugslayer
This month John Robbins finds a bug in his debugger, but works around it with a snappy quick fix.
John Robbins
Security Briefs
This month Keith Brown looks at Windows NT® privileges from a programmer’s perspective.
Keith Brown
Wicked Code
One of the most eagerly anticipated enhancements that Windows 2000 will bring to COM is support for asynchronous method calls. Let Jeff Prosise show you how to implements this new feature.
Jeff Prosise

July 1999 — Vol 14 No 7

CODE MSJJuly99 (1,787,021 Bytes)

Updated with New Kernel Features, Windows CE 3.0 Really Packs a Punch
Ready for a Web server in your Handheld PC? This and other changes in Windows CE 3.0 should make it a major upgrade to the smallest member of the Windows family. Here’s your guide to the newest kernel and system API features in Windows CE.
Douglas Boling
DirectX 6.0 and Windows Media Technologies Bring Multimedia to Windows CE
DirectX and Windows Media Technologies let you take advantage of real-time multimedia on Windows CE-based devices. We’ll show you the developer side of these new features and how they were implemented in the Sega Dreamcast console.
Rod Deyo and Mike Jazayeri
The Tools You’ll Need to Build Embedded Apps: Windows CE Toolkit for Visual C++ 6.0
The great thing about developing for Windows CE is that you can use the same tools and technologies you’ve been using to create desktop apps. We’ll give you an inside look at the new Windows CE Toolkits for Visual C++ and Visual Basic.
Steve Zimmerman
Editor’s Note
Joe Flanigen
C++ Q&A
This month Paul DiLascia covers exception handling.
Paul DiLascia
Nerditorium
This month James Finnegan explores how to notify user-mode applications asynchronously from kernel mode in more depth.
James Finnegan
Win32
When do you use the CreateThread function., and when do you use _beginthreadex instead?
Jeffrey Richter
House of COM
Don Box shares what he’s learned along the path to better OLE DB understanding.
Don Box

June 1999 — Vol 14 No 6

CODE MSJJun99 (665,155 Bytes)

Building a Store-and-Forward Mechanism with Windows 2000 Queued Components
Support for disconnected operation is extremely useful in distributed computing. The Queued Components service of Windows 2000, which uses MSMQ instead of RPC as the transport mechanism for COM, is a fairly easy way to get disconnected operation.
David Platt
Exposing Your Custom Data In a Standardized Way Through ADO and OLE DB
How do you expose custom and proprietary data formats through a common and standard programming interface? Here, you’ll see three ways to pack your data into recordsets so that they can be successfully handled later via OLE DB and ADO.
Dino Esposito
Distributed Authoring and Versioning Extensions for HTTP Enable Team Authoring
HTTP 1.1 lets you edit Web content from remote locations, but it lacks features needed for team development, such as file locking and versioning. Distributed Authoring and Versioning is a set of extensions that fill this gap.
Leonid Braginski and Matthew Powell
Editor’s Note
Joe Flanigen
C++ Q&A
This month Paul DiLascia examines where MFC sets the AfxWndProc and demonstrates a way to get the exact mouse position that was valid when a Windows message is triggered.
Paul DiLascia
Bugslayer
What to do when you have too many trace statements for effective debugging.
John Robbins
Visual Programmer
Handling BSTRs when writing COM objects in C++.
George Shepherd
Under the Hood
As the Windows programming paradigm shifts from standalone applications toward client-server, n-tier, and distributed computing, programmers are pushed into learning technologies completely new to them such as ActiveX Data Objects (ADO) and Microsoft Transaction Server (MTS).
Matt Pietrek

May 1999 — Vol 14 No 5

CODE MSJMAY99 (221,765 Bytes)

Windows 2000 Brings Significant Refinements to the COM(+) Programming Model
Many new and sexy features are planned for Windows 2000. Some of the most profound changes are slated for the COM programming model, namely the integration of component configuration and interception into the core model and runtime.
Don Box
Using Visual Basic to Integrate MSMQ into Your Distributed Applications
The Microsoft Message Queue (MSMQ) makes it possible to run client apps from across a WAN or a dial-up connection much more reliably than a system that uses COM. Here, you’ll learn important MSMQ design and implementation techniques.
Ted Pattison
Unraveling the Mysteries of Writing a Winsock 2 Layered Service Provider
The Winsock 2 SPI can be used to extend the functionality of an existing transport service provider by implementing a layered service provider. Dissecting the Microsoft Platform SDK layered sample can make it clear how.
Wei Hua, Jim Ohlund, Barry Butterklee
Editor’s Note
Joe Flanigen
C++ Q&A
Part two of the discussion on Folder Tabs like the ones found in Excel, Visual Studio and other Microsoft products. This month Paul DiLascia presents two new classes, CFolderFrame and CFolderView.
Paul DiLascia
Wicked Code
The secret to being efficient on the wire is to know Interface Definition Language (IDL) cold. IDL is the language in which COM interfaces are defined, and it’s the language you feed to MIDL to build type libraries and proxy/stub DLLs.
Jeff Prosise
Security Briefs
After reading this column, you’ll know some of the basic tenets of access control in Windows NT, and some interesting dirt on window stations and desktops. Plus see a cool new feature of Windows® 2000 that you can use today if you install an add-on component that ships with Windows NT 4.0 Service Pack 4 (SP4).
Keith Brown
House of COM
The folks from Redmond who bring you COM have been burning the midnight oil, adding plenty of completely new stuff to the once compact COM. This column attempts to catalog the onslaught of new functionality slated for Windows 2000.
Don Box

April 1999 — Vol 14 No 4

CODE MSJAPRIL99 (1,039,824 Bytes)

New Windows 2000 Pooling Functions Greatly Simplify Thread Management
Microsoft has implemented new thread pooling functions in Windows 2000 to make thread creation, destruction, and general management easier. Though not perfect for every situation, in many cases these new functions can save you hours of development time.
Jeffrey Richter
Design a Single Unicode App that Runs on both Windows 98 and Windows 2000
Windows 2000 is expected to have the best international support of any Windows OS to date. Well address real-world issues such as how to design your Unicode-based app to run as a single executable on both Windows 9x and Windows 2000.
F. Avery Bishop
Write ActiveX Controls Using Custom Interfaces Provided by ATL 3.0, Part III
This third and final installment on ActiveX controls examines the steps necessary to host these controls using ATL 3.0. Youll learn how to host controls both in standalone applications as well as from within COM servers.
Brent Rector and Chris Sells
Editor’s Note
MSJ editor Joe Flanigen illuminates recent developments with the Microsoft VM for Java.
Joe Flanigen
C++ Q&A
Paul DiLascia covers implementing tabs like those in Microsoft Visual Studio and in Microsoft Excel. Hint: they’re not part of MFC
Paul DiLascia
Bugslayer
This month resident bugslayer John Robbins covers testing.
John Robbins
Visual Programmer
Learn the difference between each of the types of controls you can create using ATL this month with George Shepherd.
George Shepherd
Win 32
Jeffrey Richter explains how to get autorun to work with an HTML file.
Jeffrey Richter

March 1999 — Vol 14 No 3

CODE MSJMAR99 (266,543 Bytes)

Improve Your Debugging by Generating Symbols from COM Type Libraries
What if you could use COM type libraries to generate debug information? We’ll walk you through the implementation of a program that can run against COM-based components (typically third-party ActiveX controls) to get a symbol file for your debugger.
Matt Pietrek
Make Your Windows 2000 Processes Play Nice Together With Job Kernel Objects
Windows 2000 gives you more control over your processes with its new job kernel objects, which let you group processes together and create sandboxes that restrict what they can do. You’ll see how simple it is to use job objects in your own apps.
Jeffrey Richter
Write ActiveX Controls Using Custom Interfaces Provided by ATL 3.0, Part II
This month our ATL-based BullsEye ActiveX control gets some significant enhancements, including support for connection point and property change notifications, persistence, quick activation, and complete Visual Basic integration.
Brent Rector and Chris Sells
Editor’s Note
MSJ Editor Joe Flanigen weighs in on the Furby/NSA security issue.
Joe Flanigen
C++ Q&A
Normally when there’s a works-in-debug, fails-in-release problem, the first thing to look for is some code you accidentally put in an ASSERT statement. Paul Dilascia takes a look at the problem along with using the static keyword in object-oriented programs this month.
Paul DiLascia
House of COM
More marshal-by-value from Don Box this month.
Don Box
Nerditorium
I’m dedicating this column as my last hurrah of 16-bit Windows®, showing the 16-bit to Win32® integration enhancements that are now available under Windows 9x, Windows NT®, and Windows 2000. This month I’d like to stress that system-level development doesn’t always have to involve kernel mode explicitly.
James Finnegan
Under the Hood
In this column, I’ll describe a DLL that CoClassSyms hooks up with to generate a .DBG file. The generated .DBG file is the bare minimum required to get symbol information that is usable by a Microsoft® debugger.
Matt Pietrek

February 1999 — Vol 14 No 2

CODE MSJFEB99 (811,189 Bytes)

With Further ADO: Coding Active Data Objects 2.0 with Visual Studio 6.0
ADO is the proposed standard for programming any kind of data source for which an OLE DB-compliant provider exists. You’ll see how to utilize ADO with Visual Studio 6.0, concentrating on the Visual J++ language WFC classes and Visual Basic 6.0.
Dino Esposito
Write ActiveX Controls Using Custom Interfaces Provided by ATL 3.0
ATL 3.0 contains a number of enhancements you can use when writing ActiveX controls. Sometimes you need to build upon the functionality ATL provides before your control works well with common containers like Visual Basic.
Brent Rector and Chris Sells
Building a Lightweight COM Interception Framework,Part II: The Guts of the UD
The Universal Delegator (UD) is an interception framework for COM programming that provides the code necessary to compose services on top of existing COM objects. This month you’ll explore its internals, and learn how to write services to plug into it.
Keith Brown
Editor’s Note
MSJ editor discusses the Windows 2000 Logo Program.
Joe Flanigen
C++ Q&A
Enabling and disabling a menu item in MFC.
Paul DiLascia
Bugslayer
More IMAGEHLP.DLL, SUPERASSERT, and the Working Set Tuner (WST).
John Robbins
Security Briefs
Understanding more about controlling access for anonymous users with the NULL session and the Guest account in Windows NT.
Keith Brown
Wicked Code
How do I connect multiple clients to a single object instance?” In other words, once a client has created an object instance, how can an interface on that object be made available to other clients so they can talk to the object? Jeff Prosise answes this very question.
Jeff Prosise

January 1999 — Vol 14 No 1

CODE MSJJAN99 (307,769 Bytes)

Building a Lightweight COM Interception Framework, Part I: The Universal Delegator
Keith Brown discusses the design and implementation of a lightweight, COM-based interception framework. His Universal Delegator provides for pluggable interception policies known as hooks, and can be used in client or server-side code.
Keith Brown
DirectX 6.0 Goes Ballistic With Multiple New Features And Much Faster Code
Finally, DirectX has the power and speed necessary to make it a really viable platform. Enhancements include the new Direct3D framework, a Reference Rasterizer, automatic texture management, and new rendering commands.
Ron Fosner
The Windows Driver Model Simplifies Management of Device Driver I/O Requests
I/O Request Packets are the messaging and data transfer lifeblood of Windows 98 and Windows 2000 device drivers. Ervin Peretz explains IRP queuing and related WDM development issues, and provides general-purpose functions for use in your own code.
Ervin Peretz
Editor’s Note
Joe Flanigen
C++ Q&A
If you want to implement cool bars and cool menus, for now you’ll have to write the code yourself. But don’t worry, Paul DiLascia is here to help.
Paul DiLascia
Bugslayer
You could wish away the deadlocks in your multithreaded apps, or you could follow John Robbins’s tried and true techniques.
John Robbins
Nerditorium
MSJ’s new column that will cover tips, tricks, and techniques for using operating system resources in the real world.
James Finnegan
House of COM Q&A
Don Box discusses the infamous type library marshaler that just got a major boost in Windows NT® 4.0 Service Pack 4.
Don Box

Microsoft Systems Journal — 1998 Index

December 1998 — Vol 13 No 12

CODE MSJDEC98 (3,169,167 Bytes)

Run Your Apps on a Variety of Desktop Platforms With Terminal Server
The Terminal Server Edition of Windows NT Server 4.0 can run an entire app on the server side. Only graphics, keyboard, and mouse input are transmitted between client and server. This means it’s now possible to run your apps just about anywhere.
Frank Kim
Build Reliable and Scalable N-tier Applications That Run On Both Windows NT and Unix
Working in a heterogeneous environment is a fact of life for most developers. It’s gotten easier lately since Microsoft and major Unix vendors are working together to improve interoperability between COM and Unix. Find out how you can benefit.
Mai-lan Tomsen
Control Spy Exposes the Clandestine Life of Windows Common Controls, Part III
Mark Finocchio completes his discussion of Control Spy and the Windows common controls by covering the pager, toolbar, rebar, tooltip and other controls. He also explains the controls that were not changed with the release of Internet Explorer 4.0.
Mark Finocchio
Editor’s Note
Joe Flanigen
C++ Q&A
In September Paul DiLascia wrote some code to change the form in a splitter window when there is a tree view on the left and a display view on the right. In response to alert readers’ comments, he proposes a better solution this month.
Paul DiLascia
Win 32 Q&A
Jeffrey Richter discusses delay-load DLL, a new feature offered in Visual C++ 6.0. A delay-load DLL is implicitly linked, but the loader will not load the DLL until your code actually calls a function in the DLL. This keeps the loader from doing all its work up front, improving initialization efficiency. It also averts runtime errors in situations where the application has to do something such as determine which OS it’s running on before deciding which DLL to load.
Jeffrey Richter
Visual Programmer
Visual C++ wrapper classes are great. Just point the wizard towards an ActiveX control and it generates a wrapper class around the control so you don’t have to deal with the COM interfaces. But the wrapper class can hide information your app could use.
Shepherd & Wingo
Under the Hood
Matt Pietrek covers a new feature in Visual C++® 6.0 — the /DELAYLOAD linker option. Executables that use the /DELAYLOAD option don’t implicitly link to the DLLs that you specify with /DELAYLOAD. Instead, the DLL isn’t loaded until the first call to one of its functions.
Matt Pietrek

November 1998 — Vol 13 No 11

CODE MSJNOV98 (753,514 Bytes)

A File System for the 21ST Century: Previewing the Windows NT 5.0 File System
Many programming tasks will be simplified by innovations in NTFS, the Windows NT 5.0 file system. We’ll show you some cool new features like hard links, reparse points, disk quotas, and file stream compression and encryption.
Jeffrey Richter and Luis Felipe Cabrera
Windows NT 5.0 Brings You New Telephony Development Features with TAPI 3.0
Windows NT 5.0 will introduce TAPI 3.0, the newest version of Microsoft’s telephony API. Here’s an inside look at what this means for developers, including new TAPI COM interfaces, streaming media control, and support for Internet telephony.
Michelle Quinton
Supporting Multilanguage Text Layout and Complex Scripts with Windows NT 5.0
Windows NT 5.0 provides new services that support multiple language text layout. Explore the latest techniques for developing international-ized applications, including Uniscribe, the Windows Unicode script processor.
F. Avery Bishop, David C. Brown, and David M. Meltzer
Editor’s Note
Joe Flanigen
C++ Q&A
I have two views. One view needs to check if the other view has been instantiated yet-that is, if the pointer to it is valid. How do I test a pointer to see if it points to a valid class in memory?
Paul DiLascia
Wicked Code
Shared memory is a breeze to allocate and use; you just have to know how. The secret is a pair of API functions named CreateFileMapping and MapViewOfFile.
Jeff Prosise
Security Briefs
If you’re having problems with a COM-based distributed application it may be your security settings. What do you need to know about COM security?
Keith Brown
House of COM
After spening years learning to get the most out of the COM programming model, along comes MTS, which takes away many of the tools and techniques we’ve come to depend on. If you’re trying to trick the MTS runtime into doing what you want, here’s help.
Don Box

October 1998 — Vol 13 No 10

CODE MSJOCT98 (530,530 Bytes)

An Inside Look at Developing Applications Using the New Features of Visual C++ 6.0
Joe Massoni, the Technical Support lead for Visual C++ 6.0, walks you through the issues relevant to porting your existing projects to the newest version of Visual C++, and explains the basic enhancements to the compiler, linker, and runtime library.
Joe Massoni
Visual C++ 6.0 Brings Home a Full Bag of Tricks and Treats for MFC Developers
The release of Visual C++ 6.0 means new goodies for MFC-based application development. We’ll give you an overview of what’s new in MFC 6.0, including an in-depth look at the enhanced support for Internet Explorer 4.0 common controls.
Paul DiLascia
Effective COM Programming: Seven Tips for Building Better COM-based Applications
Many developers want to embrace the COM lifestyle, but need some divine inspiration. Here are seven simple rules from some COM gurus that will help you design and implement more effective COM-based applications.
Don Box, Keith Brown, Timothy J. Ewald, Chris Sells
Editor’s Note
Joe Flanigen
C++ Q&A
Paul DiLascia implements TrackMouseEvent so you can keep track of mouse movements, even if the user quickly moves the mouse out of your app window.
Paul DiLascia
Bugslayer
You could wish away the deadlocks in your multithreaded apps, or you could follow John Robbins’s tried and true techniques.
Jon Robbins
Visual Programmer
If you’re considering using different environments to develop COM-based software you might want to know when to use ATL or MFC and how you can use both.
George Shepherd and Scot Wingo
House of COM
Don Box’s recommended COM and MTS book list.
Don Box

September 1998 — Vol 13 No 9

CODE MSJSEP98 (3,298,761 Bytes)

Gain Control of Application Setup and Maintenance with the New Windows Installer
The new Windows installer does more than just copy files; it lets your Windows 95, Windows 98, or Windows NT 5.0-based app tune its disk usage and automatically reinstall missing files. It also supports the Zero Administration Windows initiative.
Mike Kelly
Take Advantage of MTS in Your Distributed System with Custom Resource Dispensers
MTS resource dispensers manage resource pools, automatically enlist them in transactions, and provide standard interfaces. With custom resource dispensers, you can integrate disconnected or nontransactional resources into the MTS framework.
Maros Cunderlik
Control Spy Exposes the Clandestine Life of Windows Common Controls, Part II
Mark Finocchio looks at more Control Spy features and explains how to provide custom notification handlers and add custom code. He’ll also discuss more of the common controls introduced or updated with Microsoft Internet Explorer 4.0.
Mark Finocchio 51
Editor’s Note
MSJoe takes a fast look at Whisper (Speech Recognition), Whistler (Speech Synthesis from Text-to-Speech) and SAPI, the Speech Application Programing Interface.
Joe Flanigen
Under the Hood
This month: Unloading DLLs from memory with tools like NukeDLL
Matt Pietrek
Win32
Jeffrey Richter discusses using AUTORUN in your application, and also how to disable it
Jeffrey Richter
House of COM
Using the Active Server Pages (ASP) runtime environment for COM components without snags.
Don Box
C++ Q&A
This month Paul DiLascia covers form trickery
Paul DiLascia

August 1998 — Vol 13 No 8

CODE MSJAUG98 (426,866 Bytes)

Custom Performance Monitoring for Your Windows NT Applications
Monitoring the health of your computer system is incredibly important. That’s why Microsoft built performance monitoring into Windows NT. Jeffrey Richter shows you a C++ class that lets you easily use performance data within your own apps.
Jeffrey Richter
Implementing a Web View Namespace Extension Using Active Directory Services
Now you can view the Web with Windows Explorer using a namespace extension. We’ll explain how to create and customize a Web View with HTML, the Active Template Library, and the Active Directory Services Interface.
Todd Daniell, Brian Daigle, Doug Bahr, and Dave Mims
Understanding Interface Definition Language: A Developer’s Survival Guide
Interface Definition Language is the preferred way to describe your COM interfaces, but many developers have only a rudimentary knowledge of IDL. Here’s a survival guide that will show you what IDL is, when you need it, and the basics of using it.
Bill Hludzinski
Editor’s Note
MSJ Editor Joe Flanigen survived the sauna of TechEd in New Orleans.
Joe Flanigen
Under the Hood
This month Matt illustrates how Windows NT handles 16-bit Windows and DOS applications.
Matt Pietrek
Wicked Code
There’s a lot more to supporting drag-and-drop in a tree view control than meets the eye.
Jeff Prosise
Bugslayer
Crash handlers are those routines that can gain control right before the application shows that nice fault dialog that drives your users crazy. While the exception handlers are C++-specific, the crash handlers work with both C++ and Visual Basic®-based code.
John Robbins
C++ Q&A
Star C++ columnist Paul DiLascia mends some previous ‘BooBoos’
Paul DiLascia

July 1998 — Vol 13 No 7

CODE MSJJUL98 (3,072,436 Bytes)

Microsoft Message Queue is A Fast, Efficient Choice for Your Distributed Application
How do you get the various parts of your distributed app to communicate with each other? One option is message queuing middleware like the Microsoft Message Queue (MSMQ), which lets applications communicate reliably on unreliable networks.
David Chappell
Use MSMQ and MTS to Simplify the Building of Transactional Applications
MSMQ offers built-in transactional support, so your app can utilize MTS. Not only will you be able to offer the flexibility of asynchronous messages, you can ensure your data won’t be compromised by inconsistent state.
Mark Bukovec and Dick Dievendorff
Control Spy Exposes the Clandestine Life of Windows Common Controls, Part I
Mark Finocchio introduces Control Spy, a suite of 22 programs-one for each Windows common control-that will give you better insight into the new common controls from Microsoft Internet Explorer 4.0 and the latest updates to the old favorites.
Mark Finocchio
Editor’s Note
MSJ Editor Joe Flanigen presents more from the Year 2000 and other strange date anomalies.
Joe Flanigen
Under the Hood
What’s ahead for 64-bit computing? Matt Pietrek tackles that question this month.
Matt Pietrek
Visual Programmer
When you create a new class in Visual C++® using the ClassWizard, the easiest way to put a COM wrapper around it is to check the Automation option. But how do you create the COM wrapper for existing classes?
George Shepherd and Scot Wingo
House of COM
Don Box celebrates the fifth birthday of COM by looking current state of COM, reflecting on what the COM designers got right, and what needs improvement.
Don Box
C++ Q&A
This month Paul DiLascia discusses how to interrupt a process with a cancel dialog.
Paul DiLascia

June 1998 — Vol 13 No 6

CODE MSJJUNE98 (303,282 Bytes)

Exploring DirectX 5.0, Part II: DirectSound Gives Your Apps Advanced 3D Sound
The value of sound is a given; the question today is one of sophistication. Will your app generate yesterday’s beeps and clicks, or will it offer seamlessly integrated 3D sound? DirectX 5.0 lets you add sophisticated sound effects to your apps today without pain.
Jason Clark
How to Design Reusable HTTP Components by Exploiting WinInet and COM
Aaron Skonnard first gives you a brief WinInet primer. Then, he shows how to implement two ATL-based COM components: IHttpRequest and IQuoteProvider. Finally, he ties it all together in a sample application called Stock Watcher.
Aaron Skonnard
Keeping an Eye on Your Browser by Monitoring Internet Explorer 4.0 Events
Being able to control Internet Explorer is great, but if you can’t tell what it’s doing, you don’t have full control. For this reason, Internet Explorer exposes an event interface through which you can monitor its activity and perform certain actions.
Scott Roberts
Editor’s Note
Poseidon, Tiramisu, Sequoia, and Gdansk, SDK, RTP, AVI, Y2K and AHHHHHHHH!
Joe Flanigen
Under the Hood
This month: Just Enough Assembly Language to Get By, Part II. Matt Pietrek continues his coverage from February to include additional instructions and instruction sequences, and some of the most common scenarios that occur when an instruction faults.
Matt Pietrek
Win 32
The Win32 specification states that no relationship exists between a parent process and any of its child processes once a child process has been created. Many other operating systems support a parent/child relationship policy, so if you kill a process, the system automatically kills all of the process’s descendant processes.
Jeffrey Richter
Bugslayer
This month: Getting the most out of debugging. Learn to use a kernel debugger and get to the root of problems between your app and the operating system.
John Robbins
C++ Q&A
One of the great features of MFC is that it provides a way for any kind of object—not just a window—to handle menu commands, unlike in Windows. This month Paul DiLascia shows you how to get objects to execute menu commands.
Paul DiLascia

May 1998 — Vol 13 No 5

CODE MSJMAY98 (223,797 Bytes)

Microsoft Windows CE 2.0: It’s Not Just for Handheld PCs Any More
If you think Windows CE is just a pared-down version of Windows 95, or that it’s only for the Handheld PC, take a closer look at version 2.0. Designed to be small, portable, fast, and scalable, Windows CE is far more comprehensive than you may imagine.
Paul Yao
Minimizing the Memory Footprint of Your Windows CE-based Program
A Windows CE-based machine may have only 1 or 2MB of RAM. While the amount of memory may be small, the functions available for managing memory are quite complete. Windows CE implements almost the entire Win32 memory management API.
Douglas Boling
Windows CE 2.0 Networking Offers Exciting Mobile Computing Possibilities
One of the most appealing features of Windows CE 2.0 is its robust networking capability. It supports many types of communications hardware including serial links, modems, and Ethernet cards, as well as almost all of Microsoft’s networking APIs.
Anthony Jones
Editor’s Note
Joe Flanigen
Under the Hood
A handy feature of Windows NT® is the performance data counter which provides information about a system like running processes, interrupts per second, network I/O stats, etc.In March, Matt Pietrek covered accessing its interface through Visual Basic. This month he does the same for C++.
Matt Pietrek
Wicked Code
Sooner or later, most COM programmers discover the need for outgoing interfaces. An outgoing interface is one that an object doesn’t implement itself, but rather relies on its clients to implement.
Jeff Prosise
ActiveX Q&A
Because threads were not a problem for Visual Basic 4.0, programmers can get confused using Visual Basic 5.0 with its threading options. Don Box, this month, sheds some light on a sticky problem.
Don Box
C++ Q&A
This month learn the difference between CToolBar and CToolBarCtrl, and when you should use them.
Paul DiLascia

April 1998 — Vol 13 No 4

CODE MSJAPR98 (303,282 Bytes)

Build MTS Components with Visual Basic for Deployment in Your ASP-Based Apps
There are several benefits to moving your business logic and data access code out of ASP pages and into COM-based DLLs. Code is easier to maintain, you can use a multitier design, and your app can exploit the integration between IIS and the MTS runtime.
Ted Pattison
For the Telephony API, Press 1; For Unimodem, Press 2; or Stay on the Line
Windows NT 5.0 will support TAPI 3.0, but to exploit that down the road you’ll need to understand TAPI 1.x and 2.0 now. Operators are standing by to give you all the TAPI information you need, and explain how Unimodem will provide dialing assistance.
Hiroo Umeno
Take IIS Customization to the Next Level by Writing ISAPI Filters and Script Interpreters
You can make IIS handle HTTP requests in almost any way you want. With an ISAPI filter, you can modify how HTTP requests are processed by the server. And a server-side script interpreter can customize how certain types of files will be used.
Leon Braginski and Matt Powell
Editor’s Note
Joe Flanigen
Under the Hood
You’ve made a call to a function in some DLL and the linker complains that it can’t find the symbol. It doesn’t take too much to figure out that you need to add another library (.LIB) file to the linker’s command line. But which .LIB file?
Matt Pietrek
Visual Programmer
Integrating components written in two different languages like C++ and Visual Basic® can be tricky. But there are actually several ways to get Visual Basic working with dialogs (or some other C++ class) inside an MFC DLL.
George Shepherd and Scot Wingo
Bugslayer
This month John Robbins explains how to find the exact function, source code file, and line where a crash occurred when you only know the crash address.
John Robbins
C++ Q&A
This month Paul DiLascia writes a C++ class called CModuleVersion that gets the version number from a DLL, and a demo program called VersionDlg that shows how to use CModuleVersion.
Paul DiLascia

March 1998 — Vol 13 No 3

CODE MSJMAR98 (104,297 Bytes)

Pop Open a Privileged Set of APIs with Windows NT Kernel Mode Drivers
Windows NT drivers are not just for devices; they’re a means of doing things previously considered impossible. Understanding them not only provides valuable insight into Windows NT, it teaches you APIs you can use without writing any driver code.
James Finnegan
Understanding the DCOM Wire Protocol by Analyzing Network Data Packets
DCOM is simply a high-level network protocol that enables COM-based components to interoperate across a network. You’ll explore DCOM by analyzing the data packets transmitted across a network during the execution of COM-enabled apps.
Guy and Henry Eddon
Why Do Certain Win32 Technologies Misbehave in Windows NT Services?
Some Win32 technologies such as MFC, ODBC, and MAPI behave differently in services than they do in interactive user apps. There are three major areas of concern for a service developer: security, window stations and desktops, and registry hives. existing WinHelp projects or build new HTML-based help systems.
Frank Kim
Editor’s Note
Joe Flanigen
Under the Hood
A handy feature of Windows NT® is the performance data counter which provides information about a system like running processes, interrupts per second, network I/O stats, etc. But the interface is horrible. There is an API-based interface that is even accessible in Visual Basic. Matt Pietrek covers it this month.
Matt Pietrek
Win 32 Q&A
Using the Task Manager in Windows NT to kill processes and services.
Jeffrey Richter
ActiveX Q&A
No technology since the dawn of COM has been more misunderstood than MTS, and no one aspect of MTS has been more misunderstood than the issue of state. Don Box puts the rumors to rest once and for all.
Don Box
C++ Q&A
How can you disable the tabs in a CTabCtrl? There’s no easy way. But you can almost always defeat Windows® if you’re prepared to spend the time and the brain power.
Paul DiLascia

February 1998 — Vol 13 No 2

CODE MSJFEB98 (390,785 Bytes)

May the Force Feedback Be with You: Grappling with DirectX and DirectInput
Much of the gruntwork involved with game development has been greatly simplified by DirectX® 5.0. Jason Clark introduces one of its components, DirectInput®, plus you’ll see a sample application that demonstrates the use of a force feedback joystick.
Jason Clark
Get Fast and Simple 3D Rendering with DrawPrimitive and DirectX 5.0
DrawPrimitive, a brand new interface for 3D object creation, aims to change the balkanized world of 3D graphics development. Ron Fosner examines the use of DrawPrimitive, a new interface that greatly improves the usability of Direct3D®.
Ron Fosner
Manipulate Windows NT Services by Writing a Service Control Program
Every day, developers come up with new reasons to build Windows NT® services. If you’re writing one, it’s important to understand service control programs because they are the applications that allow administration of your service.
Jeffrey Richter
Editor’s Note
Joe Flanigen
Under the Hood
Welcome to Matt Pietrek’s “Just-Enough-Assembly-Language-to-Get-By Guide,” the source for programmers who need to know at least a little assembler to be able to debug compiled code.
Matt Pietrek
Bugslayer
In the December issue John Robbins introduced TraceSrv, a utility that makes it simple to have all the trace statements for your application go to the same place, whether from multiple processes or from many different machines. This month he shows you how to implement TraceSrv in existing projects by calling a single function.
John Robbins
Visual Programmer
The first round of tools for Windows® CE 2.0 is out, and this month we take a look at Visual C++® for Windows CE 2.0 and show what you face in porting your MFC applications to Windows CE.
George Shepherd and Scot Wingo
C++ Q&A
In general, how do you create a window class that’s exactly like one of the MFC default classes, but with one or two modifications, and how do you get the class name?
Paul DiLascia

January 1998 — Vol 13 No 1

CODE MSJJAN98 (414,655 Bytes)

How Microsoft Transaction Server Changes the COM Programming Model
Microsoft Transaction Server isn’t magic, but it does let you write simple, COM-based servers that are powerful and scalable. We’ll give you five basic rules that will actually make your object development with MTS easier.
David Chappell
Give Your Applications the Hot New Interface Look with Cool Menu Buttons
This year’s hot GUI look is the cool menus seen in Office 97. Just so you’re not left wearing last year’s rags, Paul DiLascia explains how he implemented the cool menu buttons and provides some reusable classes that you can use in your own apps.
Paul DiLascia
The New HTML Help System Extends Online Help From the Desktop to the Web
HTML Help allows seamless integration between local and remote help files through your Web browser, HTML, and ActiveX controls. With HTML Help Workshop, you can convert your existing WinHelp projects or build new HTML-based help systems.
Ted Faison
Editor’s Note
Joe Flanigen
Under the Hood
Ever since Matt Pietrek wrote his PEDUMP article (MSJ, March 1994), many people have asked how to access the data for an arbitrary resource. Finding hidden dialog controls was just the excuse he needed to write some C++ classes that traverse the PE resource format.
Matt Pietrek
Win 32 Q&A
In an update to an earlier column, Jeffrey Richter expands on some techniques for writing an unsetup program that deletes itself from the disk.
Jeffrey Richter
ActiveX Q&A
Why would you want to find out the host address of the caller inside a method? Can it be done? Ask Don Box this month.
Don Box
C++ Q&A
I am writing an MFC app that is not a doc/view app. To implement the app with MFC, I used a document object that doesn’t do anything. But I can’t get the document to display the right app name.
Paul DiLascia

Microsoft Systems Journal — 1997 Index

December 1997 — Vol 12 No 12

CODE MSJDEC97 (296,844 Bytes)

The COM+ Programming Model Makes it Easy to Write Components in Any Language
COM+ makes the COM programming model more like the programming model of the language you use-you write classes in your favorite language; your tools and the COM+ runtime take care of turning them into COM components and applications.
Mary Kirtland
A Programmer’s Perspective on New System DLL Features in Windows NT 5.0, Part II
This month, we look at additions to ADVAPI32, the shell, the common controls, and COM. We’ll also examine additions to WININET.DLL and IMAGEHLP.DLL, plus the new Shell Light Weight API and task scheduling interfaces.
Matt Pietrek
Implementing the New Win32 Driver Model for Windows 98 and Windows NT 5.0
Walter Oney finishes our introduction to the Win32 Driver Model by describing the handling of Plug and Play and Power Management I/O requests and demonstrating how a Virtual Device Driver running in Windows 98 can call a WDM driver.
Walter Oney
Editor’s Note
Joe Flanigen
Under the Hood
All of the programs that come with Windows NT are compiled to use the Unicode. This month, Matt Pietrek shows you why.
Matt Pietrek
Visual Programmer
Take advantage of scrolling, zooming, datazoom, panning, and autoscroll with IntelliMouse.
George Shepherd and Scot Wingo
Bugslayer
Unfortunately, there are no debuggers yet that will allow you to single-step across machines, or even step from VBScript into a C++ control. Debugging modern applications definitely isn’t easy, but help is on the way.
John Robbins
C++ Q&A
Paul Dilascia once again helps us find our way in the land of MFC. In this month’s installment, we explore tweaking the new Windows 95 common file dialogs using CFileDialog.
Paul DiLascia

November 1997 — Vol 12 No 11

CODE MSJNOV97 (103,373 Bytes)

A Programmer’s Perspective on New System DLL Features in Windows NT 5.0, Part I
Windows NT® 5.0 is on the way and MSJ’s got the information you need to know. We’ll give you a peek at what to expect from a programmer’s perspective, including changes to existing system DLLs, plus information on some proposed new system DLLs.
Matt Pietrek
Surveying the New Win32 Driver Model for Windows 98 and Windows NT 5.0
The Win32® Driver Model-a new feature planned for Windows® 98 and Windows NT 5.0-will simplify the process of writing device drivers. This month, Walter Oney introduces the basic architecture of this new device driver model.
Walter Oney
Object-Oriented Software Development Made Simple with COM+ Runtime Services
COM+ provides runtime services from any programming language or tool, and it lets components work together regardless of implementation. We’ll review some major object-oriented development issues and discuss how COM+ will resolve many of them.
Mary Kirtland
Editor’s Note
Joe Flanigen
Under the Hood
This month Matt Pietrek writes a program that compares and contrasts Windows NT 4.0 and 5.0 system DLLs.
Matt Pietrek
Win32 Q&A
In a multithreaded application where the user-interface thread is responsible for creating all of the windows and running the message loop to dispatch messages, should you synchronize the worker threads’ access to the user-interface windows?
Jeffrey Richter
ActiveX Q&A
This month Don Box debunks common myths and misconceptions that have surrounded COM over the years.
Don Box
C++ Q&A
You have a network app with MFC where multiple copies of the app on different workstations access the same data file. How can you allow the first user that opens the file to get read/write permission, and other users to get the file read-only?
Paul DiLascia

October 1997 — Vol 12 No 10

CODE MSJOCT97 (193,672 Bytes)

Design a Windows NT Service to Exploit Special Operating System Facilities
In Windows NT®, a service is a type of executable that gets special treatment from the operating system. We’ll explain how a service application must be designed to take advantage of all the built-in features that Windows NT offers.
Jeffrey Richter
Introducing the Bugslayer: Annihilating Bugs in an Application Near You
In this sneak preview of our newest column, our Bugslayer John Robbins illustrates some common software development bugs you’ve probably experienced and takes you through the steps of finding and eradicating these pesky vermin.
John Robbins
A Preview of Active Channel and the Active Desktop for Internet Explorer 4.0
Active Desktop technology in Internet Explorer 4.0 weds the Internet to the Windows® shell, creating a uniform experience for working with information whether it resides locally on your computer, on an intranet, or on the Internet.
Nancy Winnick Cluts and Michael Edwards
Editor’s Note
Joe Flanigen
Under the Hood
This month we’ll take a look at Win32 exceptions specific to the Intel x86 architecture, beginning with the beloved GPF.
Matt Pietrek
Wicked Code
On 256-color display devices, a bitmap containing a wide range of colors looks good only if you create a palette to go with it. But you’ll need to know what colors to put in the palette.
Jeff Prosise
Visual Programmer
Using ATL in developing COM objects: The Active Template Library (ATL) takes a load off developers by implementing most of the boilerplate code necessary for developing simple, straightforward COM classes. ATL also serves as a lightweight alternative to MFC for writing ActiveX™ controls.
George Shepherd and Scot Wingo
C++ Q&A
This month: Coolbars revisited—and fixed. Also preventing users from running multiple instances of an application using MFC.
Paul DiLascia

September 1997 — Vol 12 No 9

CODE MSJSEP97 (185,452 Bytes)

Manage Data from Myriad Sources with the Universal Data Access Interfaces
ODBC, RDO, DAO, OLE DB: how do you find your data in this alphabet soup of APIs? Universal Data Access spells out a solution by providing access to your data through a common set of interfaces, regardless of where the data resides.
Stephen Rauch
Extend Developer Studio 97 with Your Own Add-ins, Macros, and Wizards
Why do menial programming work yourself when you can harness the automation objects exposed by Developer Studio to create add-ins, macros, and wizards? These nifty features let you customize Developer Studio like never before.
Steve Zimmerman
Multiple Threads in Visual Basic 5.0, Part II: Writing a Win32 Debugger
Last month we began writing a multithreaded application using Visual Basic 5.0. In this installment, we build upon our previous work with the AddressOf operator to develop VBDebug, a multithreaded debugger for Win32-based applications.
John Robbins
Editor’s Note
Joe Flanigen
Under the Hood
By observing calls made to the WININET.DLL during an HTTP transaction, it’s possible to create a program that makes similar calls to the WININET APIs. Then you can retrieve data from the internet without the overhead of a browser.
Matt Pietrek
Win32 Q&A
This month Jeffrey Richter takes another look at the GetShortPathName function and the SHGetFileInfo function for converting to long file names. He also covers writing a utility that copies the contents of a ListView control to the clipboard.
Jeffrey Richter
ActiveX Q&A
You can mark your in-process CLSID as ThreadingModel=Apartment or ThreadingModel=Both, but why would you want to mark your CLSID as ThreadingModel=Free? Why does this option exist?
Don Box
C++ Q&A
When you program Windows® with MFC, it’s important to have a clear understanding of the difference between the window that lives on the screen and the C++ CWnd object that represents it.
Paul DiLascia

August 1997 — Vol 12 No 8

CODE MSJAUG97 (685,508 Bytes)

Ingenious Ways to Implement Multiple Threads in Visual Basic 5.0, Part I
While the methodology may not seem obvious, it is possible to write multithreaded applications in Visual Basic 5.0 by using the AddressOf operator and some Win32 APIs. We’ll explain how these facilities will help you build a thread-safe application.
John Robbins
Fashionable App Designers Agree: The Free Threading Model is What’s Hot This Fall
Worried that your app’s looking tired wearing last year’s threads? The simple, clean lines of the free threading model cover you with only the barest minimum of marshaling calls. Join us as we watch this sassy new multithreading model work the runway.
David Platt
Microsoft Transaction Server Helps You Write Scalable, Distributed Internet Apps
Microsoft Transaction Server (MTS) lets you concentrate on the business logic of your Internet or intranet server app. Our sample program takes you through the fundamental MTS development and deployment steps.
Dave Reed, Tracey Trewin, and Mai-lan Tomsen
Editor’s Note
Dave Edson
Under the Hood
This month, a different subset of the IMAGEHLP APIs to show how their powerful features can be implemented with a few simple lines of code.
Matt Pietrek
Wicked Code
Meet a fun little programming technique that will help you write better drag and drop code. The sample application uses MFC, but the technique isn’t specific to MFC; it’s applicable to any language or development environment.
Jeff Prosise
Visual Programmer
ActiveX™ Designer support in Visual Basic® 5.0: An ActiveX Designer is similar to a regular form in that you use it to create Visual Basic classes. ActiveX Designer-produced classes fit into your application just as form classes do.
George Shepherd and Scot Wingo
C++ Q&A
Implementing flat-style buttons in your toolbar: Believe it or not, to get the flat-style toolbar you see in Internet Explorer, all you have to do is add one line to your code.
Paul DiLascia

July 1997 — Vol 12 No 7

CODE MSJJUL97 (591,882 Bytes)

Create Apps That are Easily Extensible With Our Smart “Snap-Ins” Methodology
Wouldn’t it be great if other folks could write extensions for your app? We’ll show you how to implement a simple in-process COM server approach we call “snap-ins.” It lets you write custom tools for your code-or any app that supports snap-ins.
Steve Zimmerman
More First Aid for the Thread Impaired: Cool Ways to Take Advantage of Multithreading
Multithreading can improve an app’s performance, responsiveness, and structure, but it also introduces complexity. We’ll show you how to perform feats like responding to network outages gracefully and handling error conditions asynchronously.
Russell Weisz
Dynamic Runtime Objects: Building Applications Your Users Can Modify at Runtime
Dynamic runtime objects help keep big software development projects under control by isolating object dependencies. The result is an application that is well organized and easy to change-even by users, and even at runtime.
Ed Smetak and Jean Caputo
Editor’s Note
Dave Edson
Under the Hood
Linkers In-Depth: Get a guided tour through the workings of the Win32 linker.
Matt Pietrek
Win32 Q&A
“Reverse Semaphore” Objects you can find code here to implement something that works the exact opposite of a Win32 semaphore.
Jeffrey Richter
ActiveX/COM
Explicit Constructors, Singleton COM Objects: Use custom interfaces so new class objects can be created and initialized automatically.
Don Box
C++ Q&A
File Open Dialogs and Tab Ordering: Extend the File Open dialog in MFC so you can handle your own custom file extensions.
Paul DiLascia

June 1997 — Vol 12 No 6

CODE MSJJUN97 (330,321 Bytes)

How to Exploit Multiple Monitor Support in Memphis and Windows NT 5.0
Running out of screen space? Boss won’t get you that Jumbotron monitor? We’ll detail new APIs through which Memphis, the successor to Windows 95, and Windows NT 5.0 will support a virtual desktop made up of multiple monitors.
David Campbell
The Active Template Library Makes Building Compact COM Objects a Joy
The Active Template Library (ATL) provides the foundation for developing the lightweight COM components that today’s modern distributed apps require. ATL lets you build small, self-contained apps without the bother of additional runtime DLLs.
Don Box
More Fun with MFC: DIBs, Palettes, Subclassing, and a Gamut of Goodies, Part III
In the conclusion to this series, Paul DiLascia completes his MFC-based Quick View application and explains how to build one of your own. He shows you how to use the IFileViewer interface, and finishes off with some useful debugging tips.
Paul DiLascia
Editor’s Note
Dave Edson
Under the Hood
Use our handy MouseWheel.dll to take advantage of the mouse wheel found on the new Microsoft IntelliMouse.
Matt Pietrek
Wicked Code
Add the same smooth scrolling found in Internet Explorer 3.0 to any MFC application by just dropping in the class library presented here.
Jeff Prosise
The Visual Programmer
Learn how you can write add-ins for Microsoft Visual Basic 5.0 to extend the programming environment to suit your needs.
George Shepherd and Scot Wingo
C++ Q&A
Get that fancy caption shading found in Microsoft Office for your MDI applications with our ShadeCap sample code.
Paul DiLascia

May 1997 — Vol 12 No 5

CODE MSJMAY97 (61,634 Bytes)

Introducing Visual Studio 97: A Well-stocked Toolbox for Building Distributed Apps
Visual Studio 97 targets developers and teams that create dynamic, Web-based applications or other distributed apps. Many of the additions to existing Microsoft developer products are aimed at simplifying the creation and use of ActiveX components.
Mary Kirtland
Visual C++ 5.0 Simplifies the Process for Developing and Using COM Objects
Getting MSN™COM objects are becoming more and more important. Many cool Windows features like shell extensions and ActiveX are only available through COM. Visual C++ 5.0 does COM right with new compiler directives and integrated support for ATL.
George Shepherd
Investigating Multilanguage Debugging and the New IDEs of Visual Studio 97
Using the right tool for building an application is one thing, but what about debugging? Visual Studio integrates Visual Basic and Visual C++ so you can code different parts of your application with different languages and debug them simultaneously.
Robert Schmidt
Editor’s Note
Dave Edson
Under the Hood
IMAGEHLP.DLL has many useful functions that provide services such as executable file modification, symbol table access, and security certificate manipulation.
Matt Pietrek
Win32 Q&A
Specifying the location of special folders, such as My Documents, without hardcoding the address.
Jeffrey Richter
ActiveX/COM
When creating COM objects with little interface, which will be called by a variety of client languages, should you build inproc servers or outtofproc servers?
Don Box
C++ Q&A
Writing an application that paints textured backgrounds like those in Encarta® and Bookshelf®.
Paul DiLascia

April 1997 — Vol 12 No 4

CODE MSJAPR97 (600,179 Bytes)

The Windows CE SDK: The Tools You Need to Program the Handheld PC
The Win32® API is still the basis for developing apps for Windows® CE devices. But developers targeting this new class of hardware will have to follow special programming guidelines and use new tools such as the Handheld PC Emulator.
Neil Fishman and Jeffrey Richter
Behind the Scenes at MSN 2.0: Architecting an Internet-Based Online Service
Getting MSN™ 2.0 up and working was a huge task involving complex communications among server machines, as well as frugal programming on the client. In this case study, the MSN Development team shares its solutions.
Alok Sinha, Don Clore, and Dale Phurrough
Tiptoe Through the Tooltips With our All-Encompassing ToolTip Programmers’ Guide
MFC supports ToolTips in vanilla Application Framework-based programs, but there are plenty of apps that need more support. Find out how you can enhance existing ToolTip classes, roll your own new classes, and add ToolTips to your Web pages.
Roger Jack
Editor’s Note
Dave Edson
Under the Hood
Matt Pietrek explains how to implement an exception handler that can be used as the default exception handler for each thread.
Matt Pietrek
Wicked Code
Many programmers find out the hard way that if their application displays files, folders, and other file system objects, it should also support Explorer-like context menus.
Jeff Prosise
Visual Programmer
This month, we’ll look at the relationship between COM and Visual J++. As it turns out, you can use Visual J++ to implement COM objects.
Shepherd and Wingo
C++ Q&A
This month brings you up to date on a program called TRACEWIN, first described in the October 1995 column. TRACEWIN displays MFC diagnostic output in a window instead of the debugger.
Paul DiLascia

March 1997 — Vol 12 No 3

CODE MSJMAR97 (337,234 Bytes)

Pay No Attention to the Man Behind the Curtain! Write Your Own C++ AppWizards
Working with MFC makes it easy to build great Windows®-based applications-but only if you really know your way around the library. AppWizard helps you get started by creating skeleton projects jam-packed with boilerplate code.
Walter Oney
Visual Basic 5.0 Relieves the Pain and Discomfort of ActiveX Control Creation, Part II
The distinction between classic and ActiveX events is important-classic events received by your control are opportunities for your code to do something interesting; ActiveX events your control raises provide opportunities for the developer using your control to do something interesting.
Guy Eddon and Henry Eddon
More Fun with MFC: DIBs, Palettes, Subclassing, and a Gamut of Goodies, Part II
Wouldn’t it be nice if, instead of copying all that palette code from app to app, there was some way to encapsulate that palette code in a class you could instantiate in your app to just do palettes? Every application is slightly different, but there is a basic pattern to palettes.
Paul DiLascia
Editor’s Note
Dave Edson
Under the Hood
Calling DispatchMessage isn’t optional if you’re using timers. DispatchMessage is needed for both varieties of timer notifications (that is, window messages and callback functions).
Matt Pietrek
Win32 Q&A
To make Windows NT and Windows 95 more robust, every thread is given its own local-input state. However, the Win32 API contains a new function called AttachThreadInput that allows you to connect the local-input states of two threads.
Jeffrey Richter
ActiveX/COM
Marshal By Value
This month Don helps you tackle the problems encountered in integrating old C++ and other pre-COM era code with COM and IDL.
Don Box
C++ Q&A
Paul DiLascia discusses his progam Virgil that implements non-rectangular hot spots and displays tool tips as the user moves the mouse over one of the hot spots.
Paul DiLascia

February 1997 — Vol 12 No 2

CODE MSJFEB97 (216,058 Bytes)

Give ActiveX-based Web Pages a Boost with the Apartment Threading Model
Starting with Internet Explorer 3.0, ActiveX™ controls have been enriching Web pages. By following three simple rules, you can make sure your controls conform to the apartment threading model, which drastically boosts Web page performance.
David Platt
Building Multitiered Client/Server Apps with Visual Basic 4.0 Enterprise Edition, Part II
In this installment, Jenny Notestein writes and walks you through the actual Reporting System API code. Follow along as a SQL table turns into an HTML-based report, and issues such as security and optimization are discussed.
Jenny Notestein
Visual Basic 5.0 Relieves the Pain and Discomfort of ActiveX Control Creation
Now that Visual Basic® 5.0 allows developers to crank out ActiveX controls with great ease, it’s time to jump onto the bandwagon. Come explore how objects, properties, and methods are tackled in the first part of this series.
Guy Eddon and Henry Eddon
Editor’s Note
Dave Edson
Under the Hood
To solve the problem of multiple versions of a DLL in different directories, leading to the wrong DLL being used, Matt Pietrek unveils the Depends utility.
Matt Pietrek
Wicked Code
The author offers CWaitDialog class to simplify the display of a cancel dialog at the outset of a time-consuming operation and to have your application respond to clicks of the Cancel button.
Jeff Prosise
The Visual Programmer
What if you want to expose that IDispatch interface as a dual interface for clients that understand dual interfaces? All it takes is a bit of exploring MFC, learning about Object Description Language (ODL), and your ability to exercise the TextWizard.
George Shepherd and Scot Wingo
C++ Q&A
Is there some easy way I can use C++ to initialize an object when it’s first used?
Paul DiLascia

January 1997 — Vol 12 No 1

CODE MSJJAN97 (248,269 Bytes)

More Fun with MFC: DIBs, Palettes, Subclassing, and a Gamut of Reusable Goodies
Writing real-world apps in MFC is never as simple as the sample programs found in the documentation. Paul DiLascia develops a set of reusable MFC classes that are the result of writing a genuine app, and shares them here in the first part of this series.
Paul DiLascia
A Crash Course on the Depths of Win 32® Structured Exception Handling
Sure, you may use _try and _except in your C++ code, but have you ever wondered what’s going on under the hood? Matt Pietrek goes where almost no one has gone before, diving into the abyss of SEH and surfacing with a human-readable explanation.
Matt Pietrek
Hid Your Data and Make Objects Responsible for Their Own User Interfaces, Part III
In the conclusion of this series, Allen Holub shows you the actual working sample code for his Forms-based application—one that keeps the data hidden inside the objects and completely conforms to object-oriented programming techniques.
Allen Holub
Editor’s Note
Dave Edson
Under the Hood
Matt Pietrek shows how to call NtQueryInformation APIs in order to gain system-level information from WindowsNT.
Matt Pietrek
Win 32 Q&A
Jeffrey Richter describes his own WaitForMultipleExpressions function that works with Windows® 95 and Windows NT® 4.0 or later.
Jeffrey Richter
ActiveX/COM Q&A
Server Lifetime/Threading
Managing the lifetime of a server process in COM can be tricky. Usually you will want your server process to remain running as long as there is at least one object with an outstanding interface pointer held by an external client. Find out this month how to do that successfully and reliably.
Don Box
C++ Q&A
The author uncovers bugs in MFC 4.0 that affect printing and title bar painting.
Paul DiLascia

Microsoft Systems Journal — 1995-1996 Index

December 1996 — Vol 11 No 12

First Aid for the ThreadImpaired: Using Multiple Threads with MFC
Russell Weisz
Hide Your Data and Make Objects Responsible for Their Own User Interfaces, Part II
Allen Holub
Leveraging Your Visual C++ Experience on the Internet with Thin Client Technology
David C. Mitchell
Under the Hood
Matt Pietrek
The Visual Programmer
Joshua Trupin
Wicked Code
Jeff Prosise
C++ Q&A
Paul DiLascia

November 1996 — Vol 11 No 11

Preview the Common Controls DLL for Microsoft Internet Explorer 4.0, Part II
Strohm Armstrong
OpenGL Without the Pain: Creating a Reuseable 3D View Class for MFC
Ron Fosner
Building Multitiered Client/Server Apps with Visual Basic 4.0 Enterprise Edition
Jenny Notestein
Under the Hood
Matt Pietrek
Win32® Q&A
Jeffrey Richter
ActiveX/COM Q&A
Don Box
C++ Q&A
Paul DiLascia

October 1996 — Vol 11 No 10

Remove Fatty Deposits from Your Applications Using Our 32-bit Liposuction Tools
Matt Pietrek
What You Need to Know about “Pegasus,” Microsoft’s Uncoming Handheld Device
Jeffrey Richter
Previewing the New and Improved Common Controls DLL for Microsoft IE 4.0
Strohm Armstrong
Under the Hood
Matt Pietrek
The Visual Programmer
Josh Trupin
Wicked Code
Jeff Prosise
C++ Q&A
Paul DiLascia

September 1996 — Vol 11 No 9

Unified Browsing with ActiveX™ Extensions Brings the Internet to Your Desktop
Stephen Rauch
Our Exclusive Class Library Speeds Building Windows NT® Kernol Mode Device Drivers
John Elliott and Jeff Huckins
Visual C++® 4.2 Dramatically Reduces the Learning Curve for Writing Internet Apps
Nancy Nicholaisen
Under the Hood
Matt Pietrek
Win32® Q&A
Jeffrey Richter
OLE Q&A
Don Box
C++ Q&A
Paul DiLascia

August 1996 — Vol 11 No 8

Poking Around Under the Hood: A Programmer’s View of Windows NT® 4.0
Matt Pietrek
To Learn About the Voice Modem Extensions for Windows 95, Press 1 Now!
Charles Mirho
Hide Your Data and Make Objects Responsible for Their Own Interface
Allen Holub
Under the Hood
Matt Pietrek
C++ Q&A
Paul DiLascia
Wicked Code
Jeff Prosise

July 1996 — Vol 11 No 7

Talk to Any Database the COM Way Using the OLE DB Interface
Stephen Rauch
Extending the Windows® Explorer with Name Space Extensions
David Cambell
Safe Web Surfing with the Internet Component Download Service
Mary Kirtland
Under the Hood
Matt Pietrek
Win32® Q&A
Jeffrey Richter
C++ Q&A
Paul DiLascia

June 1996 — Vol 11 No 6

How COM Solves the Problems of Component Software Design, Part II
Kraig Brockschmidt
Roll Your Own Persistence Implementations to Go Beyond the MFC Frontier
Allen Holub
The Visual Programmer Puts ActiveX™ Document Objects Through Their Paces
Joshua Trupin
Under the Hood
Matt Pietrek
OLE Q&A
Don Box
C/C++ Q&A
Paul DiLascia

May 1996 — Vol 11 No 5

Introducing Distributed COM and the New OLE Features in Windows NT® 4.0
Don Box
Writing Interactive Web Apps is a Piece of Cake with the New ISAPI Classes in MFC 4.1
Mike Blaszczak
How OLE and COM Solve the Problems of Component Software Design
Kraig Brockschmidt
Under the Hood
Matt Pietrek
Win 32® Q&A
Jeffrey Richter
The Visual Programmer
Joshua Trupin
C/C++ Q&A
Paul DiLascia

April 1996 — Vol 11 No 4

Build OLE Controls for the Internet that are Fast, Smart, and Interactive
Michael McKeown
Programming Windows® 95 with MFC, Part VIII: Printing and Print Previewing
Jeff Prosise
Fusing Your Applications to the System Through the Windows® 95 Shell
Jeffrey Richter
Under the Hood
Matt Pietrek
OLE Q&A
Don Box
The Visual Programmer
Joshua Trupin
C/C++ Q&A
Paul DiLascia

March 1996 — Vol 11 No 3

The Visual Programmer Fingers WinSock Functions from Visual Basic®
Joshua Trupin
Extend Windows® 95 Shell Application Desktop Toolbars
Jeffrey Richter
Exploring the Client/Server Capabilities of Visual Basic® 4.0 Enterprise Edition
Guy Eddon and Henry Eddon
Under the Hood
Matt Pietrek
Win 32® Q&A
Jeffrey Richter
C/C++ Q&A
Paul DiLascia

February 1996 — Vol 11 No 2

Programming Windows® 95 with MFC, Part VII: The Document/View Architecture
Jeff Prosise
Write a Simple HTTP-based Server Using MFC and Windows Sockets
David Cook
Get World-Class Noise and Total Joy from Your Games with DirectSound and DirectInput
Dave Edson
Under the Hood
Matt Pietrek
The Visual Programmer
Joshua Trupin
OLE Q&A
Don Box
C/C++ Q&A
Paul DiLascia

January 1996 — Vol 11 No 1

Talk to Your Computer and Have It Answer Back with the Microsoft® Speech API
Mike Rozak
The DAO of Databases: Using Data Access Objects and the Jet Engine in C++
Michael Mee, Peter Tucker, and John McCullough
Automatically Configure Your Devices by Exploiting Plug and Play VxD Services
Waler Oney
The Visual Programmer
Joshua Trupin
Under the Hood
Matt Pietrek
Win 32® Q&A
Jeffrey Richter
C/C++ Q&A
Paul DiLascia

December 1995 — Vol 10 No 12

MFC 4.0 Delivers OCX Containers, Improved DLL Models, and New Classes
Bob Chiverton
Building Device Drivers That Conform to Windows® 95 Plug and Play Standards
Walter Oney
Programming Windows® 95 with MFC, Part VI: Dialog Boxes, Property Sheets, and Controls
Jeff Prosise
Under the Hood
Matt Pietrek

OLE Q&A
Don Box

C/C++ Q&A
Paul DiLascia

November 1995 — Vol 10 No 11

The Game SDK for Windows® 95 Gives You Direct Hardware Control for Speedy Animation
Dave Edson
Programming Windows® 95 with MFC, Part V: Menus, Toolbars, and Status Bars
Jeff Prosise
How to Navigate the Treacherous Waters of C++ Exception Handling
Scott Meyers
Under the Hood
Matt Pietrek
Win 32® Q&A
Jeffrey Richter
C/C++ Q&A
Paul DiLascia

October 1995 — Vol 10 No 10

Add Growable Memory-Mapped Files to Your App with Our Exclusive GMMF API
Jeffrey Richter
Visual Basic® 4.0 Provides Easy Entry to the Advanced Features of Windows®
Joshua Trupin
How to Get Your Windows® 95 OLE Controls Refined, Robust, and Ready to Ship
Michael McKeown
Under the Hood
Matt Pietrek

OLE Q&A
Don Box

C/C++ Q&A
Paul DiLascia

September 1995 — Vol 10 No 9

An Exclusive Tour of the New TOOLHELP32 Functions for Windows®
Matt Pietrek
Programming Windows® 95 with MFC, Part IV: Contending with the Keyboard
Jeff Prosise
Developing Client/Server Multimedia App Using RPCs and Video for Windows 1.
James Finnegan
Under the Hood
Matt Pietrek
Win 32® Q&A
Jeffrey Richter
C/C++ Q&A
Paul DiLascia

August 1995 — Vol 10 No 8

Rewriting the MFC Scribble Program Using an Object-Oriented Design Approach
Allen Holub
Tips and Tricks on Developing Killer Server Applications for Windows NT™
Martin Heller
Programming Windows® 95 with MFC, Part III: Processing Mouse Input
Jeff Prosise

OLE Q&A
Don Box

Windows™ Q&A
Matt Pietrek
C/C++ Q&A
Paul DiLascia

July 1995 — Vol 10 No 7

Meandering Through the Maze of MFC Message and Command Routing
Paul DiLascia

Programming Windows® 95 with MFC, Part II: Working with DCs, Pens, and Brushes
Jeff Prosise
Design and Implementation Details of the Windows NT™ Virtual Block Cache Manager
Helen Custer
Windows® Q&A
Matt Pietrek
Win 32® Q&A
Jeffrey Richter
C/C++ Q&A
Paul DiLascia

June 1995 — Vol 10 No 6

Wake Up and Smell the MFC: Using the Visual C++™ Classes and Application Framework
Jeff Prosise
Borland® Delphi: A New Entry in the Pantheon of Visual Programming Tools
Joshua Trupin
Port Your Windows®-based App to the Mac® with the Visual C++™ Cross-Development Edition
Guy Eddon and Henry Eddon

OLE Q&A
Don Box

Windows® Q&A
Matt Pietrek
C/C++ Q&A
Paul DiLascia

May 1995 — Vol 10 No 5

Grab Bag of Gotchas and Goodies for
Programming in Windows®
Dave Edson
Extend Your Application with Dynamically Loaded VxD’s Under Windows®
Walter Oney
Design Considerations for Implementing a Simple OLE Automation Controller
Kraig Brockschmidt
Windows® Q&A
Matt Pietrek
C/C++ Q&A
Paul DiLascia
MS-DOS® Q&A
Jeff Prosise

April 1995 — Vol 10 No 4

Understanding Windows® 95 Memory Management: Paging, Address Spaces, and Contexts
Matt Pietrek
Implementing OLE Control Containers with MFC and the OLE Control Developer’s Kit
Mike Blaszczak
Build a Multilingual User Interface for Your Application with Win 32®
Asmus Freytag
Windows® Q&A
Matt Pietrek
Win32® Q&A
Jeffrey Richter
C/C++ Q&A
Paul DiLascia

March 1995 — Vol 10 No 3

Integrate Your Applications with the Windows® 95 User Interface Using Shell Extensions
Jeff Prosise
Optimize Your Code to Run Faster and Jump Higher with the Visual C++™ 2.0 Compiler
Simon Koeman and Jeff Ross
The BOCOLE Engine and OCF Class Library Make Programming OLE Easier
Ted Faison
Windows® Q&A
Matt Pietrek
C/C++ Q&A
Paul DiLascia
MS-DOS® Q&A
Jeff Prosise

February 1995 — Vol 10 No 2

Understanding Modelview Transformations in OpenGL™ for Windows NT™
Jeff Prosise
Putting Your OLE Controls to Work with Microsoft® Access, Visual Basic®, and C++
Joshua Trupin
Efficient Synchronization Techniques for Multithreaded Win32®-based Applications
Daniel Glasser
Windows™ Q&A
Matt Pietrek
C/C++ Q&A
Paul DiLasica
Win32® Q&A
Jeffrey Richter

January 1995 — Vol 10 No 1

Exploit Video for Windows 1.1 With Visual C++™ and Our Exclusive MFC Extensions
Paul DiLascia
The Windows™ Cartoon Engine Supplies High Quality Animation to Any Application
William Wagner
Implementing Games for Windows™ Using the Win API and the WaveMix DLL
James Finnegan
Windows™ Q&A
Matt Pietrek
C/C++ Q&A
Paul DiLasica
MS-DOS® Q&A
Jeff Prosise