Special Edition Using Visual C++ 4.2 (Using ... (Que))

Kate Gregory, Que

ISBN:0789708930, Edition: , 1996-10

Price: $49.99 CONTENTS

Introduction

• Who Should Read This Book?
• Before You Start Reading
• Conventions Used in This Book
• Time to Get Started

Chapter 1   Working with Developer Studio

• Developer Studio: An Integrated Development Environment
• Choosing a View
• Looking at Documentation
• Looking at Interface Elements
  • Accelerators
  • Dialog Boxes
  • Icons
  • Menus
  • The String Table
  • Toolbars
  • Version Information
• Looking at Your Code, Arranged by Class
• Looking at Your Code, Arranged by File
• Output and Error Messages
• Editing Your Code
  • Basic Typing and Editing
  • Working with Blocks of Text
  • Syntax Coloring
  • Shortcut Menu
  • Source File Toolbar
• From Here...

Chapter 2   Developer Studio Commands

• Learning the Menu System: Slow and Steady
  • Using File Menu
  • Edit
  • Using the View Menu
  • Insert
  • Build
  • Tools
  • Window
  • Help
• Toolbars: One Click
• From Here…

Chapter 3   AppWizard and ClassWizard

• Creating a Windows Application
  • Deciding How Many Documents the Application Supports
  • Databases
  • OLE Support
  • Appearance and Other Options
  • Other Options
  • File and Class Names
  • Creating the Application
• Creating DLLs, Console Applications, and More
  • MFC AppWizard (DLL)
  • OLE Control Wizard
  • Application
  • Dynamic Link Library
  • Console Application
  • Static Library
  • Makefile
  • Custom AppWizard
  • ISAPI Extension Wizard
• Changing Your AppWizard Decisions
• Making Menus Work with ClassWizard
• Making Dialog Boxes Work with ClassWizard
• Dealing with Messages from the Wizard Bar
• From Here…

Chapter 4   Overview: What's in an Application?

• Programming for Windows
  • A C-Style Windows Class
  • Window Creation
• Programming in C++
• Encapsulating the Windows API
  • Inside CWnd
• What Are All These Classes, Anyway?
  • CObject
  • CCmdTarget
  • CWnd
  • All Those Other Classes
• From Here…

Chapter 5   Messages and Commands

• Message Routing
• Message Loops
• Message Maps
• Using ClassWizard to Catch Messages
• List of Messages
• Commands
• Command Updates
• Using ClassWizard to Catch Commands and Command Updates
• From Here…

Chapter 6   The Document/View Paradigm

• Understanding the Document Class
• Understanding the View Class
• Creating the Rectangles Application
• Running the Rectangles Application
• Exploring the Rectangles Application
  • Declaring Storage for Document Data
  • Initializing Document Data
  • Serializing Document Data
  • Displaying Document Data
  • Modifying Document Data
• Other View Classes
• Document Templates, Views, and Frame Windows
• From Here…

Chapter 7   5Dialog and Controls

• Understanding Dialog Boxes
• Creating a Dialog-Box Resource
  • Defining Dialog-Box and Control IDs
  • A Dialog Box's Resources
• Introducing the Dialog Application
• Exploring the Dialog Application
  • Writing a Dialog-Box Class
  • Using the Dialog-Box Class
• Programming Controls
• Introducing the Control1 Application
• Exploring the Control1 Application
  • Associating MFC Classes with Controls
  • Initializing the Dialog Box's Controls
  • Responding to the OK Button
  • Handling the Dialog Box in the Window Class
• From Here…

Chapter 8   Win95 Common Controls

• The Win95 Controls Application
• The Progress Bar Control
  • Creating the Progress Bar
  • Initializing the Progress Bar
  • Manipulating the Progress Bar
• The Trackbar Control
  • Creating the Trackbar
  • Initializing the Trackbar
  • Manipulating the Trackbar
• The Up-Down Control
  • Creating the Up-Down Control
• The Image List Control
  • Creating the Image List
  • Initializing the Image List
• The List View Control
  • Creating the List View
  • Initializing the List View
  • Associating the List View with Its Image Lists
  • Creating the List View's Columns
  • Creating the List View's Items
  • Manipulating the List View
• The Tree View Control
  • Creating the Tree View
  • Initializing the Tree View
  • Creating the Tree View's Items
  • Manipulating the Tree View
• The Rich Edit Control
  • Creating the Rich Edit Control
  • Initializing the Rich Edit Control
  • Manipulating the Rich Edit Control
• From Here…

Chapter 9   Property Pages and Sheets and Wizards

• Introducing Property Sheets
• Creating the Property Sheet Demo Application
• Running the Property Sheet Demo Application
• Understanding the Property Sheet Demo Application
• Changing Property Sheets to Wizards
  • Running the Wizard Demo Application
  • Creating Wizard Pages
  • Setting the Wizard's Buttons
  • Responding to the Wizard's Buttons
  • Displaying a Wizard
• From Here…

Chapter 10   Utility and Collection Classes

• The Array Classes
  • Introducing the Array Demo Application
  • Declaring and Initializing the Array
  • Adding Elements to the Array
  • Reading Through the Array
  • Removing Elements from the Array
• The List Classes
  • Introducing the List Demo Application
  • Declaring and Initializing the List
  • Adding a Node to the List
  • Deleting a Node from the List
  • Iterating Over the List
  • Cleaning Up the List
• The Map Classes
  • Introducing the Map Demo Application
  • Creating and Initializing the Map
  • Retrieving a Value from the Map
  • Iterating Over the Map
• The String Class
• The Time Classes
  • Using a CTime Object
  • Using a CTimeSpan Object
• Collection Class Templates
• From Here...

Chapter 11   Drawing on the Screen

• Understanding Device Contexts
• Introducing the Paint1 Application
• Exploring the Paint1 Application
  • Painting in an MFC Program
  • Using Fonts
  • Using Pens
  • Using Brushes
  • Switching the Display
  • Sizing and Positioning the Window
• Scrolling Windows
  • Running the Scroll Application
  • Initializing the Scroll Bars
  • Updating the Scroll Bars
• From Here...

Chapter 12   Persistence and File I/O

• Objects and Persistence
• The File Demo Application
  • A Review of Document Classes
  • A Quick Look at File Demo's Source Code
• Creating a Persistent Class
  • The File Demo 2 Application
  • Looking at the CMessages Class
  • Using the CMessages Class in the Program
• Reading and Writing Files Directly
  • The File Demo 3 Application
  • The CFile Class
  • Exploring the File Demo 3 Application
• Creating Your Own CArchive Objects
• From Here...

Chapter 13   Sockets, MAPI, and the Internet

• Using Windows Sockets
  • Winsock in MFC
• Messaging API (MAPI)
  • What Is MAPI?
  • Win95 Logo Requirements
  • Advanced Use of MAPI
• Using New Internet Classes in Visual C++ 4.2
• Using Internet Server API (ISAPI) Classes
• From Here...

Chapter 14   Database Access

• Understanding Database Concepts
  • Using the Flat Database Model
  • Using the Relational Database Model
  • Accessing a Database
  • The Visual C++ ODBC Classes
• Creating an ODBC Database Program
  • Registering the Database
  • Creating the Basic Employee Application
  • Creating the Database Display
  • Adding and Deleting Records
  • Examining the OnRecordAdd() Function
  • Examining the OnMove() Function
  • Examining the OnRecordDelete() Function
  • Sorting and Filtering
  • Examining the OnSortDept() Function
  • Examining the DoFilter() Function
• Using ODBC versus DAO
• From Here...

Chapter 15   MFC Macros and Globals

• Ten Categories of Macros and Globals
• Application Information and Management Functions
• ClassWizard Comment Delimiters
• Collection Class Helpers
• CString Formatting and Message-Box Display
• Data Types
• Using Diagnostic Services
• Exception Processing
• Using Message-Map Macros
• Run-Time Object Model Services
• Standard Command and Window IDs
• From Here...

Chapter 16   Choosing an Application Type and Building an Empty Shell

• A Dialog-Based Application
• A Single Document Interface Application
  • Other Files
• A Multiple Document Interface Application
• AppWizard Decisions and This Book
• From Here...

Chapter 17   Building Menus and Dialogs

• Building an Application That Displays a String
  • Creating an Empty Shell with AppWizard
  • Displaying a String
• Building the ShowString Menus
• Building the ShowString Dialogs
  • ShowString's About Box
  • ShowString's Options Dialog
• Making the Menu Work
  • The Dialog Class
  • Catching the Message
• Making the Dialog Work
• Adding Appearance Options to the Options Dialog
  • Changing the Options Dialog
  • Adding Member Variables to the Dialog Class
  • Adding Member Variables to the Document
  • Changing OnToolsOptions()
  • Changing OnDraw()
• From Here...

Chapter 18   Interface Issues

• Working with Toolbars
  • Deleting Toolbar Buttons
  • Adding Buttons to a Toolbar
  • The CToolBar Class's Member Functions
• Working with Status Bars
  • Creating a New Command ID
  • Creating the Default String
  • Adding the ID to the Indicators Array
  • Creating the Pane's Command-Update Handler
  • Setting the Status Bar's Appearance
• The Registry
  • How the Registry Is Set Up
  • The Predefined Keys
  • Using the Registry in an MFC Application
  • The Status Bar Demo Application Revisited
• From Here...

Chapter 19   Printing and Print Preview

• Understanding Basic Printing and Print Preview with MFC
• Scaling
• Printing Multiple Pages
• Setting the Origin
• MFC and Printing
• From Here...

Chapter 20   Debugging

• Using the Developer Studio Basic Debugging Features
  • Debugging Menus, Hotkeys, and Toolbars
  • Stepping Through a Project in the Developer Studio
  • Development vs. Delivery Constraints
• Employing ASSERT and TRACE
  • Understanding ASSERT and TRACE
  • Using ASSERT Constructively
  • Applying Code Tracing Techniques
• Exploring MFC Debugging Features and Classes
  • Using MFC Tracer
  • Defining a Dump Member Function
  • MFC Run-Time Type Identification
• Advanced Data Watching Tips
  • What Are AutoExpand and AutoDowncast?
  • Using Data Tips, Watch Windows, and QuickWatch
• Techniques for Sealing Memory Leaks
  • Using the MFC CMemoryState Class
  • Using DEBUG_NEW
  • Blocking Memory Leaks During an Exception
• From Here...

Chapter 21   Help

• Different Kinds of Help
  • Getting Help
  • Presenting Help
  • Using Help
  • Programming Help
• Components of the Help System
• Help Support from AppWizard
• Planning Your Help Approach
• Programming for Command Help
• Programming for Context Help
• Writing Help Text
  • Changing Placeholder Strings
  • Adding Topics
  • Changing the "How to Modify Text" Topic
• Adjustments to the Contents
• From Here...

Chapter 22   ActiveX Concepts

• The Purpose of ActiveX
• Object Linking
• Object Embedding
• Containers and Servers
• Toward a More Intuitive User Interface
• The Component Object Model
• ActiveX Automation
• ActiveX Controls
• From Here...

Chapter 23   Building an ActiveX Container Application

• Changing ShowString
  • AppWizard Generated ActiveX Container Code
  • Returning the ShowString Functionality
• Moving, Resizing, and Tracking
• Handling Multiple Objects and Object Selection
  • Hit Testing
  • Drawing Multiple Items
  • Handling Single Clicks
  • Handling Double-Clicks
• Implementing Drag and Drop
  • Implementing a Drag Source
  • Implementing a Drop Target
  • Registering the View as a Drop Target
  • Setting Up Function Skeletons and Adding Member Variables
  • OnDragEnter
  • OnDragOver
  • OnDragLeave
  • OnDragDrop
  • Testing the Drag Target
• Deleting an Object
• From Here...

Chapter 24   Building an ActiveX Server Application

• Adding Server Capabilities to ShowString
  • AppWizard's Server Boilerplate
  • Showing a String Again
• Applications That Are Both Container and Server
  • Building Another Version of ShowString
  • Nesting and Recursion Issues
• ActiveX Documents
  • What ActiveX Documents Do
  • Making ShowString an ActiveX Document Server
• From Here...

Chapter 25   ActiveX Automation

• Designing ShowString Again
  • AppWizard's Automation Boilerplate
  • Properties to Expose
  • The OnDraw() Function
  • Showing the Window
• DispTest
• Type Libraries and ActiveX Internals
• From Here...

Chapter 26   Building an ActiveX Control

• A Rolling-Die Control
  • Building the Control Shell
  • AppWizard's Code
  • Designing the Control
• Displaying the Current Value
  • Adding a Property
  • Writing the Drawing Code
• Reacting to a Mouse Click and Rolling the Die
  • Notifying the Container
  • Rolling the Die
• A Better User Interface
  • A Bitmap Icon
  • Displaying Dots
• Property Sheets
  • Digits versus Dots
  • User-Selected Colors
• Future Improvements
  • Enable and Disable Rolling
  • Dice with Unusual Numbers of Sides
  • Arrays of Dice
• From Here…

Chapter 27   Internet Programming with the WinInet Classes

• Designing the Internet Query Application
• Building the Query Dialog Box
• Querying HTTP Sites
• Querying FTP Sites
• Querying Gopher Sites
• Using Gopher to Send a Finger Query
• Using Gopher to Send a Whois Query
• Future Work
• From Here…

Chapter 28   Building an Internet ActiveX Control

• Embedding an ActiveX Control into a Microsoft Explorer Web Page
• Embedding an ActiveX Control into a Netscape Navigator Web Page
• Choosing between ActiveX and Java
• Using AppWizard to Create Faster ActiveX Controls
• Speeding Control Loads with Asynchronous Properties
  • Properties
  • Using BLOBs
  • Changing Dieroll
  • Testing and Debugging Dieroll
• The Base Control Framework and the ActiveX Template Library (ATL)
• From Here...

Chapter 29   Power-User Features in Developer Studio

• Using Component Gallery
• Introducing Custom AppWizards
• Integrating External Tools
• Using Editor Emulation
• Using Optimization
• From Here...

Chapter 30   Power-User C++ Features

• Understanding Exceptions
  • Simple Exception Handling
  • Exception Objects
  • Placing the catch Block
  • Handling Multiple Types of Exceptions
• Exploring Templates
  • Introducing Templates
  • Creating Function Templates
  • Creating Class Templates
• Using Run-Time Type Information
  • Introducing RTTI
  • Performing Safe Downcasts
  • Getting Object Information
  • Preparing to Use RTTI
  • A Common Use for RTTI
• Namespaces
  • Defining a Namespace
  • Namespace Scope Resolution
  • Unnamed Namespaces
  • Namespace Aliases
• From Here…

Chapter 31   Multitasking with Windows Threads

• Understanding Simple Threads
• Understanding Thread Communication
  • Communicating with Global Variables
  • Communicating with User-Defined Messages
  • Communicating with Event Objects
• Using Thread Synchronization
  • Using Critical Sections
  • Using Mutexes
  • Using Semaphores
• From Here…

Chapter 32   Additional Advanced Topics

• Creating Console Applications
  • Creating a Console Executable
  • Scaffolding Discrete Algorithms
• Creating and Using a 32-bit Dynamic Link Library
  • Making a 32-bit DLL
  • Using 32-bit DLLs
• Sending Messages and Commands
• Considering International Software Development Issues
• From Here…

Credits