Get Ready to Unleash the Power of UCanCode .NET

Environment: VC++ 6 SP2, NT4 SP5, CE 2.11

One of my applications needed some scanner support. I thought it might be a good idea to get into TWAIN and try it out. Well, here are the results.

Firstly, this is NOT a complete implementation of the TWAIN specification. I have followed version 1.8 and have used just the basic functionality to get an image from a scanner, actually , multiple images too can be acquired one after another. By the way - it will work with didigtal cameras too - anything which exports a TWAIN interface is supported.

Well, lets delve a little further into it. Before we do that though, I would have to mention that I will not be able to tell you all about TWAIN here. You can download the specification at http://www.twain.org. They also have a sample Twain source, if you do not have a scanner and wish to try out TWAIN.

For our purposes here, the important things are the Data Source Manager (DSM) and the Data Source (DS) itself. The DS is the actual scanner or digital camera or any other source which implements TWAIN. The DSM is the module that provides us an interface to the DSM. And yes, this is a very simplistic view of TWAIN ( I shudder to think of what the TWAIN designers would make of my description ).

Now for the class itself. First, the header Twain.h has to be included. I've called my class, rather unimaginatively CTwain. Now this class requires the TWAIN_32.DLL module to be loaded. The way I have handled it is by keeping a static Module handle and incrementing and decrementing the reference count. When the interface is released for the last time, the module is unloaded.

Mostly, the class is quite independant of everything else. What it does require though, is a handle to window to which the DSM can send messages. These messages are not meant for the application itself but for Twain implementor, in this case CTwain. This window handle can be passed either to the constructor, or if as is more likely, if the window isn`t ready yet, in a call to InitTwain.

The CTwain class is an abstract class as it has one pure virtual method. So to use this class you will have to derive from CTwain.

I will now explain the important methods - the ones which will let you start scanning .

CTwain(HWND hWnd= NULL) -- Constructor

~CTwain() -- Destructor

InitTwain(HWND hWnd) -- Initializes TWAIN

ReleaseTwain() --  Releases Twain interface

GetIdentity()  --  Identitifies application

IsValidDriver()  -- Returns true if the Driver was loaded successfully

SourceSelected() -- Returns true if a source was selected successfully

SourceEnabled()  -- Returns true if a source is enabled

SelectDefaultSource() -- Selects the default source for the current machine

SelectSource() -- Shows the Select Source Dialog box and allows the user to select one

Acquire(int numImages=1) -- Starts image acquisition

ProcessMessage(MSG msg) -- Processes messages from Twain

ShouldTransfer(TW_IMAGEINFO& info)

CopyImage(HANDLE hBitmap,TW_IMAGEINFO& info)

Well - these are the routines you would typically use . You can probably do a lot more too, but the TWAIN specification can probably help you a lot more there than I can.

Now for the demo application.

What I have done is used mutiple inheritance with regard to CMainFrame. I figured that would be the simplest way to handle things. So CMainFrame is derived from CTwain. InitTwain is called from the OnCreate member of CMainFrame. Though the destructor would automatically be called when the window closes, the window handle would not be valid at that time. So I call ReleaseTwain from the OnDestroy member function of CMainFrame.

The two additions to the File Menu are

• Select Source
• Acquire

Select Source shows the default dialog which lists the TWAIN sources available. Acquire starts the actual acquisition process.

CTwain::ProcessMessage is called from the PreTranslateMessage member of CMainFrame.

Also CMainFrame implements CopyImage. This in turn calls CMainFrame::SetImage which creates a new document along with a frame and assigns the bitmap scanned to that document. So as new images are scanned new documents are created.

I guess thats it as far as explanations go. I will now very briefly just go through the steps required to start scanning .

First , create a class derived from CTwain. Implement CopyImage to handle bitmaps. Bitmaps are sent as a handle to a Device Independant Bitmap . In the demo app , this is handled with a class -CDIB .

Now in the pretranslate member of the window`s class, insert this line :

ProcessMessage(*pMsg);

Add the two menu items - Select Source and Acquire as done in CMainFrame in the demo app.

And well - you`re done. Thats it - the only thing you really have to work on is CopyImage.

Download Free Sample Source Code