Mike Blaszczak's Sample Programs
Warranty
These samples are provided without warranty; they are notguaranteed to be fit
for any purpose or application. The samples are provided in order to support
presentations or otherdocumentation; they are not endorsed or supported by
Microsoft Corporation. The samples are provided on an "as-is" basis.
Files found on this page which note that they contain long file namescan be
properly unzipped with utilities like
NicoMak's WinZIP.
Copyright
All samples on this page are covered by at least one copyright:
Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000 Mike Blaszczak.
Copyright (C) 1996, 1997, 1999, Wrox Press Limited.
The page itself is covered by copyright:
Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000 by Mike Blaszczak.
Absolutely: link to this page all you want. Scraping the code and/or
descriptions and republishing them is absolutely forbidden. Using the
code for your education is strongly encouraged. Resusing bits of the
code in your own commercial product is fine by me, as is creating a
derivative work based on the code you've found here. But remember
that there is no warranty or support for any bit of code you find here.
Sorry for the leaglese, but there are lots of vultures out there. Everyone
wants to turn a buck and they don't care where they get the
intellectual property that serves for their content, it seems.
MFC Samples
ADD.ZIP 12675 bytes; UNZIP with directory preservation.
This sample was developed on stage at the Washington Software Association's WinSIG
meeting on the ninth of September, 1996 using Visual C++ 4.2. The sample shows an
ISAPI extension that generates a form which allows you to add two numbers.
The server extension may be started by specifying a path to the DLL and using a
question mark after the name of the DLL. If your srever is named
MOOSEBOY, for example, and theADD.DLL
file is installed in thedirectory you've configured as a root for
your web server, you can executethe extension using the URL
http://mooseboy/add.dll?
APIBROW.ZIP 16230 bytes; UNZIP with directory preservation.
This project is designed to be used with Visual C++ 4.1. The project demonstrates the
use of common control callback items in an MFC applicationthat manages a
CListCtrl control in a CListView. The sample parses any
comma-separated variable file, such as theWIN32API.CSV file
found in your \MSDEV\LIB directory.
COLORLB.ZIP 53420 bytes; UNZIP with directory preservation. This sample contains long file names. Uploaded on 24 April, 2000.
The COLORLB sample shows how to implement an owner-draw list box. The
box is drawn LBS_OWNERDRAWFIXED and also uses the LBS_HASSTRINGS style.
The box allows you to individually set the color of each item in the box.
COMPER.ZIP 125740 bytes; UNZIP with directory preservation. This sample contains long file names. Uploaded on 28 February, 2000.
COMPER is an example of the ATL Composite Control. It holds an instance
of the XCTRL sample, which you can download on from this page. When the
COMPER control is resized, it resizes the control within it to be the
exactly fit the client area of the composite control. It demonstrates
a couple of important ways to talk to a contained control from the
encompassing control. First, COMPER exposes an Edit method—invoking
this method causes the control to turn around and invoke the same method
on the contained control. The control also manages its dirty bit, and
demonstrates the use of GetDlgControl().
CUSTFILE.ZIP 23526 bytes; UNZIP with directory preservation. Posted on 18 October, 1998.
This sample shows how to add a couple of extra buttons to a CFileDialog.
The sample derives its own class from CFileDialog, then glues in a
dialog template. The sample includes //SAMPLE comments for the changed code,
but pay particular attention to the styles used on the additional dialog box
template. This is a Visual C++ 6.0 project.
CUSTLIST.ZIP 22550 bytes; UNZIP with directory preservation. Posted 6 March, 1999.
CUSTLIST shows how to use custom draw in a list view control. The exampleis a simple
MFC dialog-based project that has a single list view control (in report mode) on
its client area. The sample adds some items to the control. The sample handles
NM_CUSTOMDRAW notifications and changes the colours of every other
item in the control. You'll see that the custom draw technique is very easy to
implement—and far, far simpler than doing full-blown owner-draw implementations
if you only want to change a few attributes of the control. Written with VC++ 6.0.
DIV.ZIP 14129 bytes; UNZIP with directory preservation. Posted 1 January, 1998.
This sample shows how floating-point exceptions may be captured and handled
in an MFC application. Review the code for CDivDlg::OnOK() in
the DIVDLG.CPP sample file. The call to _control87()
will enable or disable exceptions from floating-point operations. Note
also that the program behaves the same way in debug and release builds.
DOODADS.ZIP 84485 bytes; UNZIP with directory preservation.
This project is designed to be used with Visual C++ 4.1. The project
demonstrates many Windows common controls, including the extensive
use of image lists. The project was used in the book "The Revolutionary
Guide To MFC 4 Programming With Visual C++", published by
Wrox Press. The sample was also used during
the talk "Using Windows Common Controls", offered at Boston University's WinDev
conference.
DOUBLEEDIT.ZIP 18010 bytes; UNZIP with directory preservation. Contains long file names. Posted on 14 January, 1999.
DOULBEEDIT shows how to sublcass an edit control inside a form view and react
to double-clicks on the edit control by handling the WM_LBTNDOUBLECLICK
message. As usual, look for //SAMPLE comments to see where
all the action is!
DUMPSOME.ZIP 7775 bytes; UNZIP with directory preservation.
DUMPSOME is a project for Visual C++ 4.x that shows how to write a CGI
server extension which uses MFC and DAO. The sample dynamically generates
a web page that shows the first three records from a
sample database that's included in the DAO SDK. The README.TXT
file included inthe archive explains how to build and set up the
sample on your server.
EDPOS.ZIP 34989 bytes; UNZIP with directory preservation, this archive contains long file names. Posted on 19 February, 2000.
EDPOS is a MDI-based MFC application that shows an edit control in its
primary view. It adds a pane to the status bar in the window, and uses
MFC's ON_UPDATE_UI mechanism to find the row and column
position of the cursor in the edit control.
This sample clearly shows the use of the CEdit::LineFromChar()
and CEdit::LineIndex() member functions. Written with
Visual C++ 6.0.
EDSTREAM.ZIP 35875 bytes; UNZIP with directory preservation, this archive contains long file names. Posted on 16 February, 1999.
Written for VC++ 6.0, this sample shows how to use the
StreamIn() and StreamOut() members of the
CRichEditCtrl class in MFC. The code sets up a proper
EDITSTREAM structure and implements a callback. The sample provides
a dialog-based user interface that streams in (or out) a file of your choice.
FINDRICH.ZIP 26628 bytes; UNZIP with directory preservation. This archive contains long file names. Posted on 14 October, 2000.
RICHFIND is a dialog-based MFC application for Visual C++ 6.0. It shows
how to use the FindText() method of CRichEditCtrl
to find text in the control.
The user interface allows you to find a string, then search for subsequent
occurences of that string. The UI also provides a button that reads a file
from disk to populate the control; this button's implementation is a good
example of using the StreamIn() method to load text from a file.
FLOATLIST.ZIP 49759 bytes; UNZIP with directory preservation. This archive contains long file names. Posted on 28 October, 1999.
The FloatList sample is an MFC-based SDI application with an edit view as its
main window. When you press CTRL+B in the edit, the application will display a
pick list. You can choose an item from the pick list with the arrow keys
and then press [ENTER] to select it, or press [ESC] to dismiss the list. The sample
shows how to display a floating list control, and how to communicate with it
from the application. Written for Visual C++ 6.0.
FULLY.ZIP 43403 bytes; UNZIP with directory preservation. Posted on 25 July, 1996.
FULLY shows how to make an MFC application make one of its views go full-screen
active. It was written to be published in one of the staple-bound newsletter-style
journals on Visual C++. After the editor for the magazine requested it, he
summarily ignored my communication surrounding the program and its supporting article.
The article, completely unedited, is included in this archive and describes the
sample. Complete source for the program is included. This sample was written
with a beta version of VC++ 4.1 and tested with the shipping version of VC++ 4.2.
The sample was not tested to work correctly under Windows NT 3.51: it's
only been testedfor "new shell" versions of Windows: namely, Windows NT 4.0 and
Windows 95.
HOLDER.ZIP 68009 bytes; UNZIP with directory preservation. Updated on 26 January, 2000.
HOLDER contains the Internet Explorer web browser control using
CHtmlView in an MFC application. To enable extensibility, HOLDER
implements an IDispatch interface on the contained control's site,
allowing the application to expose OLE Automation methods and variables to script
on the contained HTML page. The application holds a simple script page and lets
the container uses DHTML to modify the formatting of the page. The sample also uses
the IDocHostUIHandler interface it supplies to optionally disallow
the context menu to appear when the user right-clicks the contained page.
On 1 November, 1999, this sample was updated to demonstrate the use of
IPersistStreamInitfor retrieving the HTML source code of the displayed page.
On 26 January, 2000, this sample was enhanced to allow programatically
inserting and displaying any arbitrary HTML into the control.
LANGLOAD.ZIP 1790 bytes. Posted on 18 October, 1999.
LANGLOAD shows how to use the LANGUAGE keyword in a resource file to
mark language-specific resources. The sample builds two string tables,
one for French and one for English. The code in the sample sets the locale ID
before calling LoadString(). First, the English locale is set—then,
the French locale. As a result, the code is able to load each string to be printed.
Setting the locale just proves the sample. In a real applciation, you'd rely
on the default locale set by the user for their preferences in the system. Note that
the API used to set the locale is only available on Windows NT, so the sample only
works on Windows NT. But the locale setting is available on Windows 98 and Windows 95,
so the technique of using the LANGUAGE to manage different resources for
each locale is applicable even on those operating systems.
LISTFIND.ZIP 8536 bytes. Posted on 1 November, 1999.
This sample shows how to use the CList<> template. The
sample creates a class called CPlayer, and instantiates a few objects.
The sample inserts those objects into a CList<> collection.
Then, it calls CList::Find() to cause MFC to call the specialization.
The point of this sample is to show a properly declared tempalte function
specialization for theCompareElements() function.
NDBROW.ZIP 20136 bytes. Posted on 13 October, 2000. Unzip with directory preservation.
This Visual C++ 6 project shows how to create an MDI
application that hosts CHtmlView, but doesn't use
the doc/view architecture. Since views don't require
a document to be instantiated, this code is really very simple!
MFCTALK.ZIP 22567 bytes; UNZIP with directory preservation. Posted on 27 June, 1996.
MFCTALK was originally published with Mike's article on ISPAI programming
with MFC in the May, 1996 issue of
Microsoft Systems Journal.
The sample demonstrates how to write an ISAPI application with the MFC classes
introduced in MFC version 4.1. The sample shows how to use synchronization
objects (specifically, a CCriticalSection) to protect data
handled by individual requests from corruption across threads.
MFCTLIST.ZIP 28636 bytes; UNZIP with directory preservation. Posted on 3 May, 1998.
MCTTLIST is a dialog-based application that provides the same
functionality as the TLIST sample in the SDK. That is, it enumerates the
processes on the system and puts information about them into a list view
control. You can use the application to kill processes. Works on Windows 95,
Windows 98, and Windows NT 4.0. This is a VC++ 5.0 project.
MRULESS.ZIP 32414 bytes; UNZIP with directory preservation. This archive has long file names. Posted on 13 October, 2000.
MRULESS shows a way to strip the empty "Recent Files" item off the
"File" menu when there are no entries in the MRU. The program makes
agressive use of the CMenu class and the
WM_INITMENU message, and flirts with MFC's widely misunderstood
CRecentFileList class. This project was written for VC++ 6.0.
MTPRINT.ZIP 21497 bytes; UNZIP with directory preservation. Posted on 1 December, 1996.
MTPRINT demonstrates the use of a secondary thread to perform printing
in an application that uses MFC's document/view architecture. The application was
intended to be included on the CD to The Revolutionary Guide to MFC 4 Programming
With Visual C++ published by
Wrox Press. This is a VC++ 4.2 project.
MULTITOP.ZIP 30430 bytes; UNZIP with directory preservation. Posted on 8 March, 1998.
MULTITOP shows how to write an SDI application which has multiple top level
windows and uses the MFC doc/view architecture. The application creates a
single SDI frame and provides an extra "Create New Frame" command in the
"File" menu. That command causes the application to create a new view, document,
and top-level frame. The application continues to manage a main window: when
the main window is closed, the other frame windows are closed as well. The
non-main windows can be closed an opened at will without affecting the other
windows. The resulting UI is very similar to the "project" style user
interface that the Visual Basic 4.0 IDE provided.
As usual, //SAMPLE comments highlight the changes made to a
normal AppWizard-produced project. This is a VC++ 5.0 project.
NJFIND16.ZIP 33057 bytesThis 16-bit DOS
tool traverses all directories on all drives on your
machine and finds files which match the template you specify. Searches inside ZIP,
ARC, ARJ, DWC, ZOO, and PAK files for matches, too! Extremely fast, with powerful
command-line user interface. Formerly Shareware.
NOFORM.ZIP 33690 bytes; UNZIP with directory preservation.
This sample shows how to make an application that doesn't havethe doc/view
architecture but still offers a form in the client area of the application's main window.
This sample started out as an MDI app without doc/view support from the
Visual C++ 6.0 AppWizard. Look for//SAMPLE comments in all
files to see the changes that were necessary to hook-up the form view.
ODCOMBO.ZIP 22958 bytes; UNZIP with directory preservation. This archive has long file names.
ODCOMBO.ZIP is a VC++ 6.0 dialog-based project that contians
an onwer-drawn combo box. The combo is implemented in its own
class, so it'll be easy to rip out and use in
your own code. The code supports fixed-size ownerdraw to make the combo box
show all of its items text centered horizontally in each line of the box.
Most of the code was ripped off from MFC's CCheckedListBox
class.
PICKNEW.ZIP 49614 bytes; UNZIP with directory preservation. This archive has long file names.
This VC++ 5.0 project shows how to have multiple document templates
registered and avoid the "New File Type" dialog that MFC will automatically
generate. It demonstrates calling CDocTemplate::OpenDocumentFile().
PRIMECON.ZIP 60888 bytes; UNZIP with directory preservation. This archive contains long file names.
PrimeCon is a VC++ 6.0 sample which uses MFC in a console application.
This executable spins off one thread which works at finding prime numbers.
The thraed uses PostThreadMessage() to notify another thread about the
primes that it has found. The secondary thread owns and displays a dialog
box. When a prime is found, the console thread uses printf() to show the
prime found, while the dialog lists all the founds prime numbers in a
list box. The sample shows the proper use of MFC in a console application,
and furhter demonstrates the use of custom thread messages and the creation
of graphical user interface components from a /SUBSYSTEM:CONSOLE
application.
Q1.ZIP 79910 bytes; UNZIP with directory preservation. This archive has long file names. Posted on 16 November, 1999.
Q1 is a VC++ 6.0 project that creates two threads. The first thread does
not have a message queue. The main thread tries to send the first thread amessage,
and shows that the return from the PostThreadMessage()API is
FALSE in that situation. The app creates a second thread that does
have a message queue. The main thread shows that PostThreadMessage()does
indeed return TRUE in that situation. This sample does not use MFC.
SCRL.ZIP 13613 bytes; UNZIP with directory preservation. Posted on 9 November, 1997.
This dialog-based application shows how to use the CListCtrl::Scroll()
member. It subclasses a list view control which is in report mode, and forces
the control to "snap" its horizontal scrolling to the exact start of each column.
The code shows how to retrieve the count of columns in the control, and also
demonstrates how to find information about each column. This is a VC++ 5.0 project.
Differences from a stock AppWizard dialog-based application are marked
with //SAMPLE comments.
SPINRANGE.ZIP 23986 bytes; UNZIP with directory preservation. This archive has long file names. Posted on 10 November, 1999.
SpinRange is a VC++ 6.0 project that shows how to subclass a
CSpinButtonControl to dramatically extend the range of the control.
CHugeSpinButton implements a spin buttoncontrol that can range over
signed or unsigned __int64 values. The class is very reusable:
after test-driving it in the sample's harness, you can readily move it to your
own project with ease.
SPLITS.ZIP 36459 bytes; UNZIP with directory preservation. This archive has long file names.
This VC++ 5.0 project shows how to manage views within a splitter window.
The static splitter will contain two windows; one remains attached to a
particular view type and the other may be toggled using a menu items between
one view type and another. The app features an MDI user interface and demonstrates
the CSplitterWnd::DeleteView() and CSplitterWnd::CreateView()
member functions.
STEALTH.ZIP 29539 bytes; UNZIP with directory preservation. This archive has long file names. Updated on 9 November, 1997.
This SDI application shows how to create an application that doesn't
show up in the task bar in Windows 95 or Windows NT 4.0. (The application
shouldn't show up in the task list in Windows NT 3.51, either, but I'm not at
liberty to test that, I'm afraid.) The application shows how to override
PreCreateWindow() for your CMainFrame,
using AfxRegisterWndClass() for your own windows, and stresses
the difference between a parent window and an owner window. The changes in
this application, above and beyond what the AppWizard produces for an
SDI application, are all marked with //SAMPLE: comments.
This is an VC++ 5.0 project.
TENHOOK.ZIP 19108 bytes; UNZIP with directory preservation.
Because the Windows dialog manager eats all keystrokes, you'll need to
install a Windows keyboard hook if you want to get keyboard input to your
dialog without other controls getting in the way. This sample does just
that, in a VC++ 6.0 MFC Dialog-based application. The code reacts to any
keystroke being made, but shows when ALT+F10 is pressed. This sample
demonstrates the SetWindowsHookEx() API to set a Windows
hook. It also shows proper use of UnhookWindowsHook() and,
GetAsyncKeyState(), as well as a good implementation
of a KeyboardProc().
TREESTORE.ZIP 41736 bytes; UNZIP with directory preservation. This archive has long file names. Uploaded 17 January, 2000.
Tree views are capable of storing hierarchical data, which isn't intuitively
serialized. The TreeStore sample is an MDI application which
shows a view based on CTreeView and demonstrates loading and
saving the content of the control with MFC's CArchive-based
serialization. The code is also rife with calls to the item navagation
routines of CTreeCtrl,
including GetNextSiblingItem(),
GetPrevSiblingItem(), and GetParentItem().
WRITERES.ZIP 579568 bytes; UNZIP with directory preservation. Uploaded on 11 December, 1999.
This console application shows how to bake resources into console applications. The
sample also demonstrates using FindResource(), LockResource(),
FreeResource(), and SizeofResource() APIs to access the
bytes in the image resources directly. The sample uses an ofstream
and a stdio FILE to write the bytes of the resource out to new files.
XCTRL.ZIP 101659 bytes; UNZIP with directory preservation. This archive has long filenames. Uploaded on 28 February, 2000.
The XCTRL sample is an ATL "full control" ATL Control. It's really just
a stock OLE control that draws an "X" through it's client area. It features
a single property that allows you to set the thickness of the line. It also
features a single method, Edit, that increments the size of the line by one.
I'm providing this control just to have a stock control of my own that I
can use in other control containment sample apps.
This page has been hit approximately
times since April 20th, 1997, and was last Updated on 14 October, 2000.
Back to Mike's home page.
Send Feedback.