Free Shipping In Australia
Visual C++ 6 Unleashed By Viktor Toth

Visual C++ 6 Unleashed
by Viktor Toth

Out of Stock
inc. GST
Only 0 left

Visual C++ 6 Unleashed Summary

Visual C++ 6 Unleashed by Viktor Toth

Visual C++ 6 Unleashed provides comprehensive coverage of the core topics for Visual C++ 6 programming. This book skips the beginning level material and jumps right in to Visual C++. By the end of the book, you will be able to master the 32-bit power of Windows using Visual C++ as your programming language. Topics include mastering the debugger, using and integrating HTML help, creating custom AppWizards, customizing the IDE with add-ins, writing multi-threaded MFC applications, developing NT services, using advanced UI techniques, and much more.

Why buy from World of Books

Our excellent value books literally don't cost the earth
Free delivery in Australia
Read more here
Every used book bought is one saved from landfill

Table of Contents


1. The Visual C++ 6.0 Environment.

Developer Studio.

View Windows. Toolbars.

The Project Workspace. The Workspace Window.

The FileView. The ClassView.

Project Configurations.

Project Settings.

Converting Older Projects. Working with Multiple Projects. Working with Resources.

The Resource View. Importing Resources. Managing Resource IDs. Resource Templates.

Editing Resources.

Dialog Boxes. Editing Menus. Other Resources.

MFC AppWizard.

What MFC AppWizard Can Do for You. Starting MFC AppWizard. Project Types.


Message Maps. Member Variables. Automation. ActiveX Events. Class Info. Adding a Class.

Component Gallery. Integrated Debugger.

Looking at Your Data. Debugging After Exceptions.

Command-Line Tools. Other Tools.

Spy++. MFC Tracer. Register Control. ActiveX Control Test Container. OLE/COM Object Viewer. Error Lookup. WinDiff. Help Workshop.



2. MFC Class Library Overview.

The Application Framework. Creating an MFC Application with MFC AppWizard.

Starting MFC AppWizard. Getting to Know Your New Application. Classes Created by MFC AppWizard. CDocument, CView, and Frame Classes.

The CWinApp Class. The CWinThread Class. The CCmdTarget Class. The CObject Class.


Runtime Type Information.

Using MFC Runtime Type Information.

Debugging Support.

AssertValid(). The ASSERT Macro. Dump(). The TRACE() Macro.

Putting It All Together.

WinMain(). InitApplication() and InitInstance(). LoadStdProfileSettings(). Working with the Command Line. Creating the Main Window.

The Message Pump.



3. MFC Message Handling Mechanism.

Message Categories. Message Handling in MFC. Message Dispatching. Message Handling with ClassWizard. Creating Your Own Message Maps.

Populating the Message Map. Inside the Message Map. Implementing Handler Functions. PreTranslateMessage().

A Common Problem with MFC Message Maps. Summary.

4. The Document View Architecture.

Examining the Document View Architecture.

Single Versus Multiple Document Applications. Document Classes. View Classes. Frames. Document Templates.

Creating Your Application.

Creating Your Document Class. Document Data. The Dirty Flag. Serialize(). OnNewDocument(). DeleteContents(). OnOpenDocument(). OnSaveDocument(). OnCloseDocument(). ReportSaveLoadException(). Accessing Your Document.

Using the View Classes.

CScrollView. CFormView and CRecordView. Control Views. CEditView. Using CRichEditView. CListView and CTreeView.

Using Document Templates.

The EmpList Sample Project. Creating a Document Template. Creating a Different View for a Document. CDocument: OnChangedViewList(). UpdateAllViews(). Accessing Views from Your Document.

Working with Frames.

Status Bars. Adding a Toolbar. Floating and Docking Toolbars.

More on Working with Menus.

Updating the User Interface. Pop-Up Menus. Creating Menus Dynamically.

Adding Splitters to Your Application.

Dynamic Splitters. Creating Different Views. Static Splitters.

Adding Drag and Drop to Your Application.

Enabling Drag and Drop. Handling WM_DROPFILES Messages.


5. Creating and Using Dialog Boxes.

Handling Dialog Boxes in MFC.

Creating Dialog Box Template Resources. Creating a CDialog-Derived Class. Displaying the Dialog Box. Dialog Box Coordinates. Changing the Input Focus and Default Buttons.

Dialog Box Data Exchange and Validation.

Mapping Member Variables to Controls. The Data Exchange and Validation Mechanism. Initializing the Dialog Box Controls. Retrieving Data from the Controls. Responding to Control Notifications. Dynamically Mapping Controls. Responding to OK and Cancel.

Derived Control Classes in Dialog Boxes.

Creating a Derived Control. Customizing the Derived Control. Using the Derived Control in a Dialog Box.

Modeless Dialog Boxes.

Modeless Dialog Box Resource Templates. Creating and Destroying Modeless Dialog Boxes. Tracking Modeless Dialog Boxes. Dialog Bars.


6. Working with Device Contexts and GDI Objects.

Device Contexts in MFC.

The CDC Class. The CClientDC Class. The CPaintDC Class. The CMetaFileDC Class.

Brushes and Pens.

Pens and the CPen Class. Selecting Pens into the Device Context. Using Stock Pens. Drawing with Pens. Brushes and the CBrush Class. Selecting Brushes into the Device Context. Using Stock Brushes. Drawing with Brushes.

MFC Classes for GDI Operations.

The CPoint Class. The CSize Class. The CRect Class. The CRgn Class and Clipping.

Working with Fonts.

Fonts and the CFont Class. Selecting Fonts into the Device Context. Stock Fonts. Device Context Font Interrogation Functions. Text-Rendering Functions.

Creating and Loading Bitmaps.

Creating a Bitmap Resource with the Resource Editor. Loading a Bitmap. Creating Bitmaps.

Drawing with Bitmaps.

Bitmap Copying.

Creating a Device-Independent Bitmap Class.

Creating a DIB. Creating a DIB from a Device-Dependent Bitmap. Drawing with a DIB.


7. Creating and Using Property Sheets.

Understanding Property Sheets. Creating a Property Sheet.

Creating the Property Page Resources. Creating CPropertyPage-Derived Classes. Creating a CPropertySheet-Derived Class. Adding the Property Pages. Creating a Modeless Property Sheet.

Responding to Property Sheet Messages.

Initializing the Property Pages. Property Page Activation and Deactivation. Handling Messages from OK, Apply, and Cancel Buttons. Sending Messages Between Property Pages.

Customizing the Standard Property Sheet.

Property Page Management. Creating a Wizard Mode Property Sheet. Using the New CPropertySheetEx and CPropertyPageEx Classes. Adding Help Buttons and Help Support.

Understanding the Win32 Sequence of Events. Summary.

8. Working with the File System.

File System Overview.

The FAT File System. Protected-Mode FAT. The FAT-32 File System. The HPFS File System. The NTFS File System. The CDFS File System. Networked File Systems and Mapped Volumes. The DFS File System. File System Compression. Disk Quotas. Differences in Functions Among File Systems. Determining the File System and Drive Types.

Win32 File Objects.

Basic File I/O. Asynchronous I/O.

Compatibility I/O.

Low-Level I/O. Stream I/O. The IOStream Classes.

Serial Communications.

Opening and Configuring Serial Ports. Asynchronous Communications. Setting Communication Timeouts. Communication Events.

Using Consoles.

Allocating a Console. Console I/O. Customizing the Console Buffers and Display.


9. Using Serialization with File and Archive Objects.

File I/O Differences Between MFC and Win32.

Using Basic Win32 File I/O. Using Basic MFC File I/O.

Working with the CFile Class.

Opening Files. Reading and Writing from a CFile Object.

Using the CArchive and CObject Classes.

Using the CObject Class. Using the CArchive Class.

Understanding Serialization in MFC. Using the Insertion and Extraction Operators.

Using the Serialization Macros. Overriding the Serialize Function. Creating a Serialized Collection.

Using Serialization with Document/View. How Are Document/View Applications Serialized?

Creating a Document. Tracking Modifications to a Document. Storing a Document. Closing a Document. Loading a Document.

Creating a Document/View Serialization Example.

Modifying the Document Class. Creating a Dialog Box. Modifying the View.



10. MFC and the Internet Server API (ISAPI).

Developing a Server Extension Application.

ISA Entry Points. GetExtensionVersion(). TerminateExtension(). HttpExtensionProc(). The Extension Control Block. ServerSupportFunction(). WriteClient(). Sending Files. Asynchronous Operations. Writing to the Server Log. Exception Handling in ISAs. Debugging Your ISA. Converting from CGI to ISAPI.

ISAPI Filters.

Installing a Filter. ISAPI Filter Architecture. GetFilterVersion(). TerminateFilter(). HttpFilterProc(). The HTTP_FILTER_CONTEXT Structure. Handling Filter Notifications.

ISAPI Support in MFC.

Creating ISAPI DLLs with AppWizard. CHttpServer. CHttpServerContext. CHtmlStream. CHttpFilter. CHttpFilterContext.

The Internet Service Manager API. Summary.

11. The WinInet API.

Using the WinInet C API.

Handles. Error Handling. Passing Buffer Parameters. Asynchronous I/O.

General Internet Functions.

Beginning a WinInet Session. Setting Handle Options. Querying Handle Options. Verifying Internet Connectivity. Connecting to a Server. Adding a Callback Function. Working with URLs. Basic File Operations. Querying Data Availability. Reading Data. Moving the File Pointer. Writing to Internet Files.

FTP Client Functions.

The Current Directory. Creating and Removing Directories. Finding Files. Retrieving a File. Sending a File. Opening a File on the FTP Server. Other FTP File Operations.

HTTP Client Functions.

HTTP Requests. Handling HttpSendRequest() Errors. Retrieving Response Information. Getting Your Hands in the Cookie Jar. Working with the Cache.

Gopher Client Functions. MFC WinInet Classes.

CInternetSession. Connection Classes. File Classes. CInternetException. Using CInternetSession. Working with FTP. Working with HTTP. Working with Gopher.


12. MFC HTML Support.

Understanding Dynamic HTML. Using the Win32 WebBrowser ActiveX Control.

The WebBrowser Control Architecture. An Example Project Using the WebBrowser Control.

The CHtmlView Class.

Navigating with CHtmlView. Other Useful CHtmlView Functions. Adding Dynamic HTML to Your Programs.

Using MFC and Dynamic HTML.

Simple Navigation Using CHtmlView. Navigating to a Source File. Navigating to the User's Home Page. Using a Dynamic HTML Resource.



13. Using the Standard C++ Library.

Standard C++ Library. Standard Template Library (STL). Containers.

Sequence Containers. Associative Containers.

Iterators. Algorithms.

count(). find(). for_each(). merge(). sort(). swap(). Using _if: The replace_if () Algorithm. Reverse Iterator.

Using STL with MFC and ATL.

Using STL with MFC. Introduction to ATL. ATL Versus MFC.


14. Error Detection and Exception Handling Techniques.

Structured Exception Handling.

The Structured Exception Method. A Look at Software Exceptions. A Look at Hardware Exceptions. Structured Exception Handling Functions.

C++ Exception Handling.

Using C++ Exceptions. Exception-Handling Overhead.

MFC Error and Exception Handling.

MFC Exception Macros. The Advantages of Converting from MFC Exception Macros. Predefined Exceptions for MFC. Using CFileException. Using CMemoryException. Using CResourceCollection. Using CArchiveException. Using CDaoException. Using OLE Exceptions: COleException and COleDispatchException. Using NotSupportedException. Using CUserException.


15. Debugging and Profiling Strategies.

MFC Support for Debugging. Techniques for Debugging Your MFC Application.

AfxDump. The TRACER.EXE Utility. MFC Diagnostic Features. Detecting Memory Leaks.

Using the DevStudio IDE Debugger.

Compiler Warning Levels. Debug Info Settings. Using the Source Browser Tool. Breakpoints and Single-Stepping. Debugger Windows.

Using Spy++.

Tree View. Messages View. Processes View. Threads View.

Using the OLE-COM Object Viewer. Using the Process Viewer. Performing Remote Debugging. Troubleshooting.

Attaching to Running Processes. Using Dr Watson Logs.

Profiling Your Application.

Building the Project for Function Profiling. Line Profiling. Profiling with PREP, PROFILE, and PLIST.


16. Multithreading.

Win32 Processes, Threads, and Synchronization.

Understanding Threads. The Need for Synchronization.

Using Multiple Threads in Your Application.

MFC Objects and Threads. Types of Threads.

Using Worker Threads.

Starting the Thread. Implementing a Thread Function. Accessing a Thread's Return Code.

Using User-Interface Threads.

Creating the Thread. Creating a Thread Class. Initializing New Threads. Handling Messages in Threads. Terminating Threads. Thread Local Storage.

Thread Synchronization.

Potential Pitfalls. CCriticalSection. CMutex. CSemaphore. CEvent. CSingleLock. CMultiLock.

Creating a New Process. Summary.

17. Using Scripting and Other Tools to Automate the Visual C++ IDE.

The Developer Studio Object Model.

The Objects Exposed in Developer Studio.

Using VBScript to Write Developer Studio Macros.

Declaring Variables. VBScript Subroutines. Using Functions in VBScript. Creating a VBScript Macro. Removing a Developer Studio Macro File. Example Macros Included with Visual C++. Debugging a Visual Studio Macro. Adding a VBScript Macro to the Toolbar.

Writing Developer Studio Add-Ins.

Using the Developer Studio Add-In Wizard. The Developer Studio Add-in Architecture. Adding Command-Handling Code. Handling Developer Studio Events.

The SourceInfo Add-In.

Adding the Source Information Dialog Box to the Project. Adding Command-Handling Code to the Project. Modifying the Toolbar. Using the SourceInfo Add-in.



18. Creating Custom AppWizards.

How Do AppWizards Work? Creating a Custom AppWizard.

Starting a New AppWizard Project.

Components of a Custom AppWizard Project. Template Files.

The newproj.inf Template File. Macros in Template Files. Directives in Template Files. The confirm.inf Template File. Text Templates. Binary Resource Templates.

Programming Your AppWizard DLL.

Defining Macros. Creating Step Dialog Boxes.

Building a Custom AppWizard. Debugging a Custom AppWizard. Summary.

19. Database Overview.

ODBC 4.0. OLE DB and ATL's Database Classes. ActiveX Data Objects (ADO). MFC's Database Classes. Structured Query Language. Data Definition Language.

Tables. Procedures. Triggers.

Data Control Language.

Granting Privileges. Revoking Privileges.

Data Manipulation Language.

SELECT Statements. INSERT Statements. DELETE Statements. UPDATE Statements.


20. ODBC Programming.

ODBC Architecture.

ODBC Drivers. ODBC Driver Manager. Data Sources. ODBC Data Source Administrator. ODBC Installation and Setup Programming.

ODBC API Basics.

ODBC Handles. ODBC Data Types.

Creating ODBC Applications.

Allocating and Freeing ODBC Handles. ODBC Error Handling. Connecting to a Data Source. SQLDriverConnect(). SQLBrowseConnect(). SQLDataSources(). Retrieving Connection Information.

Executing SQL Statements.

Statement Handles. SQLExecDirect(). Prepared SQL Statements. SQLExecute(). Working with Parameters.

Working with Result Sets.

Binding Columns. SQLBindCol(). SQLFetch(). Closing the Cursor. Reusing Statement Handles. SQLGetData(). Column Information. Retrieving More Than One Row at a Time. Block Cursors. Scrollable Cursors. The ODBC Cursor Library. Using Block Cursors. Using Scrollable Cursors.

Inserting, Updating, and Deleting Rows.

Positioned Updates and Deletions. SQLBulkOperations().

Asynchronous Operations. Transactions.

ODBC Commit Modes. Transaction Isolation Levels. Cursor Concurrency Types.

Catalog Functions. Summary.

21. MFC Database Classes.

Using the AppWizard to Generate MFC Classes.

Step 1. Step 2. Step 3. Step 4. Step 5. Step 6. Step 7.

The CRecordset Class.

Record Field Exchange. GetFieldValue(). Refreshing the Recordset. Moving About in the Recordset. Changing Data in a Recordset.

The CRecordView Class.

Dialog Data Exchange with CRecordView. OnGetRecordset(). CRecordView: :OnMove().

The CDatabase Class.

Executing SQL Statements with CDatabase. Transactions with CDatabase. Using the ODBC API Directly.

Exception Handling. Bulk Row Operations.

Opening a CRecordset for Bulk RFX. Implementing Bulk Record Field Exchange. Fetching Bulk Records. Using Single-Row Functions.


22. Using OLE DB.

OLE DB Architecture. Developing an OLE DB Application.

Adding an ATL OLE DB Consumer Object. Consumer Components. Data Source Properties. Using a Consumer. Opening and Closing a Rowset. Catching OLE DB Errors.

Retrieving Column Information.

GetColumnInfo(). DBCOLUMNINFO. GetColumnsRowset().

Using Transactions. Using Enumerators. Summary.

23. Programming with ADO.

ADO Objects. Connection Objects.

ADOConnection Properties. ADOConnection Methods.

ADOCommand Objects.

ADOCommand Properties. ADOCommand Methods.

ADORecordset Objects.

ADORecordset Properties. ADORecordset Methods.

ADOFields Collections and ADOField Objects.

ADOFields Collection Members. ADOField Object Properties. ADOField Object Methods.

ADOParameter Objects and the ADOParameters Collection.

ADOParameters Collection Members. ADOParameter Object Properties. ADOParameter Object Methods.

ADOProperty Objects and ADOProperties Collections.

ADOProperties Collection Members. ADOProperty Object Properties.

Writing a Visual C++ ADO Application.

Step 1-Creating Connections and Recordsets ADO Objects. Step 2-Connecting to a Database Through ADO. Step 3-Opening an ADO Recordset. Step 4-Closing the Connection and Recordset. Step 5-Writing an UpdateData Routine for ADO. Step 6-Navigating Through a Recordset. Step 7-Inserting into the Recordset. Step 8-Deleting from the Recordset.

Processing ADO Errors.

ADO HRESULT Values, FAILED, and SUCCEEDED. ADOErrors Collection Members. Error Object Properties. ADO C++ Exceptions. The Errors Collection.

Enhanced ADO Recordset Functionality.

Limiting the Rows in a Recordset. Filtering Rows in the Recordset. Refreshing the Recordset. Move(). Absolute Positioning. Scrolling by Pages. Using Bookmarks.

Executing Commands. Transactions. Summary.


24. Overview of COM and Active Technologies.

COM, OLE, and Active Technology History in a Nutshell. COM and OLE from the Eyes of the End User. COM, OLE, and Active Technologies from a Programmer's View.

Component Object Model (COM). Structured Storage. Monikers (Persistent Naming). Uniform Data Transfer (UDT). OLE Documents. Automation. ActiveX Controls.

Evolving OLE with Active Technologies.

Active Documents. ActiveX Controls. COM. Internet Monikers.

New Active Technologies.

Active Hyperlinks. NetShow. Active Scripting. Code Signing. HTML Extensions. ActiveMovie.


25. Active Documents.

Just What Is an Active Document? Some Details About Active Documents. The COM Interfaces.

IOleObject. IDataObject. IPersistStorage. IPersistFile (Optional). IOleDocument. IOleInPlaceObject. IOleInPlaceActiveObject. IOleDocumentView. IPrint. IOleCommandTarget.

The Active Template Library.

ATL Classes Required for Active Document Support.

The ACTIVEDOC Program.

activectl.h. oledocument.h. activedoc.htm.


26. Active Containers.

Just What Is an Active Document Container? Some Details About Active Document Containers.

Structured Storage. Monikers. Uniform Data Transfer. Embedded Objects. Linked Objects. Drag-and-Drop. In-Place Activation. Active Documents.

The COM Interfaces.

IOleInPlaceFrame. IOleCommandTarget. IOleInPlaceUIWindow. IOleContainer. IOleClientSite. IAdviseSink. IOleDocumentSite. IOleInPlaceSite. IContinueCallback.

Building an Active Document Container.

Active Document Container Support in MFC. The Pocket Project. Creating the Pocket Project.


27. Active Servers.

Active Servers Introduction. Three-Tier Development Using Server Components. MFC Versus Active Template Libraries. Designing an MFC Miniserver.

AppWizard: Step-by-Step. A Closer Look at the GLServer Classes. Combining Container and Server Menus During Activation. Testing Out the GLServer Skeleton. Adding Customization to the GLServer Skeleton. Testing the GLServer Example.

Designing an MFC Automation Server.

Using MFC AppWizard to Create Automation Servers. A Closer Look at the MFCAuto Classes. Adding Customization to the MFCAuto Sample Skeleton. Testing the MFCAuto Example.


28. ActiveX Controls.

A Short History. What Is an ActiveX Control?

ActiveX Control Architecture. Properties. Events. Methods.

ActiveX Control Interfaces. ActiveX Controls.

Supporting the IUnknown Interface. A Control Must Be Self-Registering. Component Categories. Component Categories and Interoperability. Code Signing. Performance Considerations.

Reinventing the Wheel.

Visual C++ ActiveX Controls.

Testing an ActiveX Control.

Displaying a Control on a Web Page. ActiveX Control Pad. ActiveX Control Test Container. ActiveX Controls in Development Tools.

Methods of Creating ActiveX Controls. Creating an ActiveX Control with Visual C++ and MFC.

Using Visual C++ and MFC for ActiveX Controls. MFC Encapsulation of ActiveX and ActiveX Controls.



29. ATL Architecture.

The History of ATL. ATL's Advanced Use of Templates. Commonly Used ATL Classes.

High-Level ATL Classes. ATL Helper Classes.

Using the Interface Definition Language. ATL Wizards.

Using the ATL COM AppWizard. Using the ATL Object Wizard. Merging the Proxy/Stub Code with Your DLL.


30. Creating COM Objects Using ATL.

Using IDL to Describe Custom COM Objects.

Understanding MIDL Attributes. Compiling an IDL Source File with MIDL. Using Type Libraries. Using Structures in IDL. Using Enumerations in IDL. Pointers in IDL. Using Direction Attributes in IDL.

A Custom COM Class Example.

Defining the IOsVersion Interface. Modifications to the COsVersion Declaration. Implementing the COsVersion Class. Compiling and Registering the Standard Proxy/Stub DLL. Creating Test Clients for OsVersionInfo.


31. Creating ActiveX Controls Using ATL.

ATL Control Classes.

Implementing Stock Properties Using ATL. Implementing Custom Properties Using ATL. Using Ambient Properties with ATL. Adding Message and Event Handlers.

Connection Points. Creating Scriptable Controls.

Requirements for Scriptable Controls. Persistence for ActiveX Controls. A Scriptable ActiveX Control.


32. Using ATL to Create MTS and COM+ Components.

Understanding Transactions. COM+ and MTS Features.

Understanding Contexts. Concurrency in COM+. Just-In-Time Activation. What Is Object Pooling? Registering a COM+ Application. Configuring Properties for a COM+ Application. Registering a COM+ Component. Configuring Properties for a COM+ Component.

An Example of a COM+ Application.

The VcBank Database. Creating the VCBankApp COM+ Module. Registering the VcBank COM+ Application. A Client Application for VcBank.



33. Adding Windows Help.

Windows Help Basics.

Understanding WinHelp. Understanding HTML Help.

Help Options in AppWizard. Help Project Components. Authoring Help Topics Using WinHelp.

Creating Help Topics. Adding Hot Spots. Including Graphics in Help Files.

Managing Help Projects.

Help Project Files. Contents Files. Compiling Help Projects. Testing Help Projects.

Calling WinHelp from Your Applications.

::WinHelp(). Using Help with MFC.

Adding Context-Sensitive Help. Using HTML Help with Visual C++.

Creating an HTML Help Project. Integrating HTML into a Visual C++ Project.



A. Additional Resources.

Visual C++ Resources.

Microsoft Developer's Network. Hard-Copy Visual C++ Documentation. Magazines and Journals. Conferences. Software. Books on Visual C++, MFC, and Windows Programming. Internet. Newsgroups and FAQs.


Additional information

Visual C++ 6 Unleashed by Viktor Toth
Viktor Toth
Used - Very Good
Pearson Education (US)
Book picture is for illustrative purposes only, actual binding, cover or edition may vary.
This is a used book - there is no escaping the fact it has been read by someone else and it will show signs of wear and previous use. Overall we expect it to be in very good condition, but if you are not entirely satisfied please get in touch with us.