book

Visual C++® 6 Unleashed

by Mickey Williams, David Bennett

July 2000

Intermediate to advanced

1000 pages

24h 49m

English

Sams

Read now

Unlock full access

Copyright
Dedication
About the Authors
About the Contributors
Acknowledgments
Tell Us What You Think!
Introduction
How to Use This BookWhat You Need to Use This BookWhat's New in Visual C++ 6.0Contacting the Main Author
I. Introduction
1. The Visual C++ 6.0 Environment
Developer StudioView WindowsToolbarsThe Project WorkspaceThe Workspace WindowThe FileViewThe ClassViewProject ConfigurationsProject SettingsConverting Older ProjectsWorking with Multiple ProjectsWorking with ResourcesThe Resource ViewImporting ResourcesManaging Resource IDsWorking with Resource SymbolsWorking with Resource IncludesResource TemplatesEditing ResourcesDialog BoxesAdding ControlsControl PropertiesLaying Out Your ControlsTab OrderTesting Your Dialog BoxEditing MenusOther ResourcesMFC AppWizardWhat MFC AppWizard Can Do for YouStarting MFC AppWizardProject TypesATL COM AppWizardCluster Resource Type WizardCustom AppWizardDatabase ProjectDevStudio Add-In WizardExtended Stored Procedure WizardISAPI Extension WizardMakefileMFC ActiveX ControlWizardMFC AppWizard (DLL)MFC AppWizard (EXE)Utility ProjectWin32 ApplicationWin32 Console ApplicationWin32 Dynamic Link LibraryWin32 Static LibraryOther Project TypesClassWizardMessage MapsMember VariablesAutomationActiveX EventsClass InfoAdding a ClassComponent GalleryIntegrated DebuggerLooking at Your DataDebugging After ExceptionsCommand-Line ToolsOther ToolsSpy++MFC TracerRegister ControlActiveX Control Test ContainerOLE/COM Object ViewerError LookupWinDiffHelp WorkshopSummary
II. MFC Programming
2. MFC Class Library Overview
The Application FrameworkCreating an MFC Application with MFC AppWizardStarting MFC AppWizardGetting to Know Your New ApplicationClasses Created by MFC AppWizardCDocument, CView, and Frame ClassesThe CWinApp ClassThe CWinThread ClassThe CCmdTarget ClassThe CObject ClassSerializationThe DECLARE_SERIAL and IMPLEMENT_SERIAL MacrosSerialize()Serialization OperatorsSerializing Different VersionsRuntime Type InformationUsing MFC Runtime Type InformationIsKindOf() and RUNTIME_CLASS()STATIC_DOWNCAST and DYNAMIC_DOWNCASTASSERT_KINDOF()Debugging SupportAssertValid()The ASSERT MacroDump()The TRACE() MacroPutting It All TogetherWinMain()InitApplication() and InitInstance()LoadStdProfileSettings()Working with the Command LineCreating the Main WindowThe Message PumpOnIdle()Summary

3. MFC Message Handling Mechanism
Message CategoriesMessage Handling in MFCMessage DispatchingMessage Handling with ClassWizardCreating Your Own Message MapsPopulating the Message MapPredefined Windows Message HandlersOther Windows MessagesCommand MessagesControl NotificationsCommand and Control RangesRegistered MessagesOther Message Map MacrosInside the Message MapImplementing Handler FunctionsPreTranslateMessage()A Common Problem with MFC Message MapsSummary
4. The Document View Architecture
Examining the Document View ArchitectureSingle Versus Multiple Document ApplicationsDocument ClassesView ClassesFramesDocument TemplatesCreating Your ApplicationCreating Your Document ClassDocument DataThe Dirty FlagSerialize()OnNewDocument()DeleteContents()OnOpenDocument()OnSaveDocument()OnCloseDocument()ReportSaveLoadException()Accessing Your DocumentUsing the View ClassesCScrollViewSetting Up the ScrollbarsDrawing with CScrollViewCFormView and CRecordViewControl ViewsSetting Control View StylesHandling Control NotificationsCEditViewWorking with CEditView DataUsing CRichEditViewCListView and CTreeViewUsing Document TemplatesThe EmpList Sample ProjectCreating a Document TemplateThe Document String ResourceUsing Multiple Document TemplatesCreating a Different View for a DocumentCDocument::OnChangedViewList()UpdateAllViews()Accessing Views from Your DocumentWorking with FramesStatus BarsCustomizing the Status BarAdding a ToolbarFloating and Docking ToolbarsMore on Working with MenusUpdating the User InterfacePop-Up MenusCreating Menus DynamicallyAdding Splitters to Your ApplicationDynamic SplittersCreating Different ViewsStatic SplittersAdding Drag and Drop to Your ApplicationEnabling Drag and DropHandling WM_DROPFILES MessagesSummary
5. Creating and Using Dialog Boxes
Handling Dialog Boxes in MFCCreating Dialog Box Template ResourcesCreating a CDialog-Derived ClassDisplaying the Dialog BoxDialog Box CoordinatesChanging the Input Focus and Default ButtonsDialog Box Data Exchange and ValidationMapping Member Variables to ControlsThe Data Exchange and Validation MechanismInitializing the Dialog Box ControlsRetrieving Data from the ControlsResponding to Control NotificationsDynamically Mapping ControlsResponding to OK and CancelDerived Control Classes in Dialog BoxesCreating a Derived ControlCustomizing the Derived ControlUsing the Derived Control in a Dialog BoxModeless Dialog BoxesModeless Dialog Box Resource TemplatesCreating and Destroying Modeless Dialog BoxesTracking Modeless Dialog BoxesDialog BarsSummary
6. Working with Device Contexts and GDI Objects
Device Contexts in MFCThe CDC ClassThe CClientDC ClassThe CPaintDC ClassThe CMetaFileDC ClassBrushes and PensPens and the CPen ClassSelecting Pens into the Device ContextUsing Stock PensDrawing with PensBrushes and the CBrush ClassSelecting Brushes into the Device ContextUsing Stock BrushesDrawing with BrushesMFC Classes for GDI OperationsThe CPoint ClassThe CSize ClassThe CRect ClassThe CRgn Class and ClippingWorking with FontsFonts and the CFont ClassSelecting Fonts into the Device ContextStock FontsDevice Context Font Interrogation FunctionsText-Rendering FunctionsCreating and Loading BitmapsCreating a Bitmap Resource with the Resource EditorLoading a BitmapCreating BitmapsDrawing with BitmapsBitmap CopyingCreating a Device-Independent Bitmap ClassCreating a DIBCreating a DIB from a Device-Dependent BitmapDrawing with a DIBSummary
7. Creating and Using Property Sheets
Understanding Property SheetsCreating a Property SheetCreating the Property Page ResourcesCreating CPropertyPage-Derived ClassesCreating a CPropertySheet-Derived ClassAdding the Property PagesCreating a Modeless Property SheetResponding to Property Sheet MessagesInitializing the Property PagesProperty Page Activation and DeactivationHandling Messages from OK, Apply, and Cancel ButtonsSending Messages Between Property PagesCustomizing the Standard Property SheetProperty Page ManagementCreating a Wizard Mode Property SheetUsing the New CPropertySheetEx and CPropertyPageEx ClassesAdding Help Buttons and Help SupportUnderstanding the Win32 Sequence of EventsSummary
8. Working with the File System
File System OverviewThe FAT File SystemProtected-Mode FATThe FAT-32 File SystemThe HPFS File SystemThe NTFS File SystemThe CDFS File SystemNetworked File Systems and Mapped VolumesThe DFS File SystemFile System CompressionDisk QuotasDifferences in Functions Among File SystemsDetermining the File System and Drive TypesWin32 File ObjectsBasic File I/OAsynchronous I/OCompatibility I/OLow-Level I/OStream I/OThe IOStream ClassesSerial CommunicationsOpening and Configuring Serial PortsAsynchronous CommunicationsSetting Communication TimeoutsCommunication EventsUsing ConsolesAllocating a ConsoleConsole I/OCustomizing the Console Buffers and DisplaySummary
9. Using Serialization with File and Archive Objects
File I/O Differences Between MFC and Win32Using Basic Win32 File I/OUsing Basic MFC File I/OWorking with the CFile ClassOpening FilesReading and Writing from a CFile ObjectUsing the CArchive and CObject ClassesUsing the CObject ClassUsing the CArchive ClassUnderstanding Serialization in MFCUsing the Insertion and Extraction OperatorsUsing the Serialization MacrosDeclaring a Persistent ClassDefining a Persistent ClassOverriding the Serialize FunctionCreating a Serialized CollectionUsing Serialization with Document/ViewHow Are Document/View Applications Serialized?Creating a DocumentTracking Modifications to a DocumentStoring a DocumentClosing a DocumentLoading a DocumentCreating a Document/View Serialization ExampleModifying the Document ClassCreating a Dialog BoxAdding a Menu ItemModifying the ViewSummary
III. Internet Programming with MFC
10. MFC and the Internet Server API (ISAPI)
Developing a Server Extension ApplicationISA Entry PointsGetExtensionVersion()TerminateExtension()HttpExtensionProc()The Extension Control BlockGeneral Request ParametersQuery InformationGetServerVariable()Additional Request DataServerSupportFunction()HSE_REQ_REFRESH_ISAPI_ACLHSE_REQ_IS_KEEP_CONNHSE_REQ_GET_IMPERSONATION_TOKENHSE_REQ_ABORTIVE_CLOSEHSE_REQ_GET_CERT_INFO_EXHSE_REQ_SEND_URL_REDIRECT_RESPHSE_REQ_SEND_URLHSE_REQ_SEND_RESPONSE_HEADERHSE_REQ_SEND_RESPONSE_HEADER_EXHSE_REQ_MAP_URL_TO_PATHHSE_REQ_MAP_URL_TO_PATH_EXHSE_REQ_DONE_WITH_SESSIONHSE_REQ_IO_COMPLETIONHSE_REQ_TRANSMIT_FILEHSE_REQ_GET_SSPI_INFOHSE_APPEND_LOG_PARAMETERHSE_REQ_ASYNC_READ_CLIENTHSE_REQ_CLOSE_CONNECTIONWriteClient()Sending FilesAsynchronous OperationsThe I/O Completion CallbackWriting to the Server LogException Handling in ISAsDebugging Your ISAConverting from CGI to ISAPIISAPI FiltersInstalling a FilterISAPI Filter ArchitectureGetFilterVersion()TerminateFilter()HttpFilterProc()The HTTP_FILTER_CONTEXT StructureGetServerVariable()AddResponseHeaders()WriteClient()AllocMem()ServerSupportFunction()Handling Filter NotificationsSF_NOTIFY_READ_RAW_DATASF_NOTIFY_SEND_RAW_DATASF_NOTIFY_PREPROC_HEADERSGetHeader()SetHeader()AddHeader()SF_NOTIFY_AUTHENTICATIONSF_NOTIFY_URL_MAPSF_NOTIFY_LOGSF_NOTIFY_END_OF_NET_SESSIONSF_NOTIFY_ACCESS_DENIEDISAPI Support in MFCCreating ISAPI DLLs with AppWizardCHttpServerCHttpServer::GetExtensionVersion()CHttpServer::HttpExtensionProc()InitInstance()CallFunction()Parse MapsHandler FunctionsOnParseError()ConstructStream()StartContent()EndContent()WriteTitle()GetTitle()AddHeader()CHttpServerContextCHtmlStreamCHttpFilterCHttpFilterContextThe Internet Service Manager APISummary
11. The WinInet API
Using the WinInet C APIHandlesError HandlingPassing Buffer ParametersAsynchronous I/OGeneral Internet FunctionsBeginning a WinInet SessionSetting Handle OptionsQuerying Handle OptionsVerifying Internet ConnectivityConnecting to a ServerAdding a Callback FunctionWorking with URLsBasic File OperationsQuerying Data AvailabilityReading DataMoving the File PointerWriting to Internet FilesFTP Client FunctionsThe Current DirectoryCreating and Removing DirectoriesFinding FilesRetrieving a FileSending a FileOpening a File on the FTP ServerOther FTP File OperationsHTTP Client FunctionsHTTP RequestsCreating an HTTP RequestRequest HeadersSending an HTTP RequestHandling HttpSendRequest() ErrorsRetrieving Response InformationGetting Your Hands in the Cookie JarWorking with the CacheGopher Client FunctionsMFC WinInet ClassesCInternetSessionConnection ClassesFile ClassesCInternetExceptionUsing CInternetSessionCreating a SessionRetrieving a FileEstablishing a ConnectionAsynchronous Operations with CInternetSessionOther CInternetSession MembersWorking with FTPFTP DirectoriesFinding FilesFTP FilesWorking with HTTPHTTP ConnectionsHTTP FilesCreating a New CHttpFileAdding HTTP HeadersSending the RequestWorking with GopherGopher ConnectionsGopher LocatorsFinding Gopher FilesWorking with Gopher FilesSummary
12. MFC HTML Support
Understanding Dynamic HTMLUsing the Win32 WebBrowser ActiveX ControlThe WebBrowser Control ArchitectureWebBrowser Control Properties and MethodsWebBrowser EventsAn Example Project Using the WebBrowser ControlAdding the WebBrowser ActiveX Control to an MFC ProjectThe CHtmlView ClassNavigating with CHtmlViewOther Useful CHtmlView FunctionsAdding Dynamic HTML to Your ProgramsUsing MFC and Dynamic HTMLSimple Navigation Using CHtmlViewNavigating to a Source FileNavigating to the User's Home PageUsing a Dynamic HTML ResourceSummary
IV. Advanced Programming Topics
13. Using the Standard C++ Library
Standard C++ LibraryStandard Template Library (STL)ContainersSequence ContainersThe Vector ContainerThe List ContainerThe Deque ContainerAssociative ContainersIteratorsAlgorithmscount()find()for_each()merge()sort()swap()Using _if: The replace_if () AlgorithmReverse IteratorUsing STL with MFC and ATLUsing STL with MFCIntroduction to ATLATL Versus MFCSummary
14. Error Detection and Exception Handling Techniques
Structured Exception HandlingThe Structured Exception MethodA Look at Software ExceptionsA Look at Hardware ExceptionsStructured Exception Handling FunctionsAbnormalTerminationGetExceptionCodeGetExceptionInformationRaiseExceptionThe ExitProcess FunctionSetUnhandledExceptionFilterUnhandledExceptionFilterC++ Exception HandlingUsing C++ ExceptionsThe C++ Exception StructureAn Exception ExampleMultiple Exception HandlingUsing Arguments with ExceptionsException-Handling OverheadMFC Error and Exception HandlingMFC Exception MacrosTHROWTHROW_LASTTRYCATCHAND_CATCHAND_CATCH_ALLEND_CATCHEND_CATCH_ALLAfxThrowArchiveExceptionAfxThrowFileExceptionAfxThrowMemoryExceptionAfxThrowNotSupportedExceptionAfxThrowResourceAfxThrowResourceExceptionAfxThrowUserExceptionAfxThrowOleDispatchExceptionAfxThrowOleExceptionAfxAbortUsing MFC Exception Macros with C ++ Exception HandlingThe Advantages of Converting from MFC Exception MacrosConverting Code from MFC Macros to C++ Exception HandlingPredefined Exceptions for MFCUsing CFileExceptionUsing CMemoryExceptionUsing CResourceCollectionUsing CArchiveExceptionUsing CDaoExceptionUsing OLE Exceptions: COleException and COleDispatchExceptionUsing NotSupportedExceptionUsing CUserExceptionSummary
15. Debugging and Profiling Strategies
MFC Support for DebuggingTechniques for Debugging Your MFC ApplicationAfxDumpThe TRACER.EXE UtilityMFC Diagnostic FeaturesThe TRACE MacroOther TRACE MacrosThe ASSERT MacroThe ASSERT_VALID MacroUsing DEBUG_NEW to Track Memory AllocationDetecting Memory LeaksUsing the DevStudio IDE DebuggerCompiler Warning LevelsDebug Info SettingsUsing the Source Browser ToolBreakpoints and Single-SteppingApply Code ChangesBreak ExecutionGoRestartRun to CursorStep IntoStep OverStep OutStop DebuggingDebugger WindowsVariables WindowWatch WindowQuickWatch WindowRegisters WindowCall Stack WindowDisassembly WindowMemory WindowUsing Spy++Tree ViewMessages ViewProcesses ViewThreads ViewUsing the OLE-COM Object ViewerUsing the Process ViewerPerforming Remote DebuggingTroubleshootingAttaching to Running ProcessesUsing Dr. Watson LogsRunning Dr. WatsonProfiling Your ApplicationBuilding the Project for Function ProfilingLine ProfilingProfiling with PREP, PROFILE, and PLISTPREPPROFILEPLISTSummary
16. Multithreading
Win32 Processes, Threads, and SynchronizationUnderstanding ThreadsThe Need for SynchronizationUsing Multiple Threads in Your ApplicationMFC Objects and ThreadsTypes of ThreadsUsing Worker ThreadsStarting the ThreadImplementing a Thread FunctionAccessing a Thread's Return CodeUsing User-Interface ThreadsCreating the ThreadCreating a Thread ClassInitializing New ThreadsHandling Messages in ThreadsTerminating ThreadsThread Local StorageAllocating a TLS IndexUsing Thread Local StorageThread SynchronizationPotential PitfallsCCriticalSectionCMutexCSemaphoreCEventSignaling an EventCSingleLockCMultiLockCMultiLock::Lock()CMultiLock::Lock() Return ValuesCleaning UpCreating a New ProcessSummary
17. Using Scripting and Other Tools to Automate the Visual C++ IDE
The Developer Studio Object ModelThe Objects Exposed in Developer StudioUsing VBScript to Write Developer Studio MacrosDeclaring VariablesVBScript SubroutinesUsing Functions in VBScriptCreating a VBScript MacroRemoving a Developer Studio Macro FileExample Macros Included with Visual C++Debugging a Visual Studio MacroAdding a VBScript Macro to the ToolbarWriting Developer Studio Add-InsUsing the Developer Studio Add-In WizardThe Developer Studio Add-in ArchitectureAdding Command-Handling CodeHandling Developer Studio EventsThe SourceInfo Add-InAdding the Source Information Dialog Box to the ProjectAdding Command-Handling Code to the ProjectModifying the ToolbarUsing the SourceInfo Add-inSummary
V. Database Programming
18. Creating Custom AppWizards
How Do AppWizards Work?Creating a Custom AppWizardStarting a New AppWizard ProjectCreating an AppWizard from an Existing ProjectCreating an AppWizard from a Standard MFC AppWizardCreating a Custom AppWizard with Your Own Custom StepsComponents of a Custom AppWizard ProjectTemplate FilesThe newproj.inf Template FileStatements in newproj.infMacros in Template FilesStandard MacrosUser-Defined MacrosDirectives in Template FilesConditional DirectivesLoops$$INCLUDEThe Default LanguageThe confirm.inf Template FileText TemplatesBinary Resource TemplatesCreating Binary TemplatesProgramming Your AppWizard DLLDefining MacrosCreating Step Dialog BoxesBuilding a Custom AppWizardDebugging a Custom AppWizardSummary
19. Database Overview
ODBC 4.0OLE DB and ATL's Database ClassesActiveX Data Objects (ADO)MFC's Database ClassesStructured Query LanguageData Definition LanguageTablesSQL Data TypesProceduresTriggersData Control LanguageGranting PrivilegesRevoking PrivilegesData Manipulation LanguageSELECT StatementsExpressionsThe LIKE PredicateThe IN PredicateThe BETWEEN PredicateAggregate FunctionsODBC SQL Literal ValuesSQL FunctionsJoinsCorrelation NamesOuter JoinsSubqueriesUnion QueriesINSERT StatementsDELETE StatementsUPDATE StatementsSummary
20. ODBC Programming
ODBC ArchitectureODBC DriversCore API ConformanceExtension Level 1 ConformanceExtension Level 2 ConformanceSQL Grammar ConformanceODBC Driver ManagerData SourcesODBC Data Source AdministratorAdding a Data SourceODBC Installation and Setup ProgrammingODBC API BasicsODBC HandlesODBC Data TypesCreating ODBC ApplicationsAllocating and Freeing ODBC HandlesSetting Your Application's ODBC VersionAllocating a Connection HandleConnection OptionsStarting Development on an ODBC ProgramStep 1Step 2Step 3Step 4Step 5Step 6ODBC Error HandlingSQLRETURN ValuesDiagnostic RecordsSQLGetDiagField()Header Record FieldsStatus Record FieldsSQLSTATESSQLGetDiagRec()Writing an ODBC Error Handling RoutineConnecting to a Data SourceSQLConnect()Writing a Program to Connect to a DatabaseSQLDriverConnect()SQLBrowseConnect()SQLDataSources()Retrieving Connection InformationExecuting SQL StatementsStatement HandlesSQLExecDirect()Prepared SQL StatementsSQLExecute()Working with ParametersSQLBindParameter()Parameter ArraysRow-Wise BindingPassing Parameter Data at Execution TimeParameter InformationWorking with Result SetsBinding ColumnsSQLBindCol()SQLFetch()Multiple Result SetsClosing the CursorReusing Statement HandlesSQLGetData()Column InformationSQLDescribeCol()SQLColAttribute()Retrieving More Than One Row at a TimeBlock CursorsScrollable CursorsThe ODBC Cursor LibraryUsing Block CursorsSetting the Size of a RowsetBinding Columns for a RowsetColumn-Wise BindingRow-Wise BindingCalling SQLFetch() for Block CursorsRow Status InformationBlock Cursors and Single-Row FunctionsUsing Scrollable CursorsCursor SupportSetting the Cursor TypeCalling SQLFetchScroll()Using BookmarksInserting, Updating, and Deleting RowsPositioned Updates and DeletionsSQLBulkOperations()Inserting with SQLBulkOperations()Updating with SQLBulkOperations()Deleting with SQLBulkOperations()Fetching with SQLBulkOperations()Asynchronous OperationsTransactionsODBC Commit ModesAuto-Commit ModeManual-Commit ModeTransaction Isolation LevelsCursor Concurrency TypesCatalog FunctionsSummary
21. MFC Database Classes
Using the AppWizard to Generate MFC ClassesStep 1Step 2Step 3Step 4Step 5Step 6Step 7The CRecordset ClassRecord Field ExchangeGetFieldValue()Refreshing the RecordsetMoving About in the RecordsetMoving ForwardScrollingUsing BookmarksCRecordset::Move()Changing Data in a RecordsetDeleting a RowAdding a New RowEditing an Existing RowWorking with NULL ValuesRow LockingUsing Statement ParametersThe CRecordView ClassDialog Data Exchange with CRecordViewOnGetRecordset()CRecordView::OnMove()The CDatabase ClassExecuting SQL Statements with CDatabaseOnSetOptions()Transactions with CDatabaseEffects of Transactions on CRecordsetsUsing the ODBC API DirectlyException HandlingBulk Row OperationsOpening a CRecordset for Bulk RFXImplementing Bulk Record Field ExchangeDoBulkFieldExchange()Fetching Bulk RecordsCheckRowsetError()Using Single-Row FunctionsSummary
22. Using OLE DB
OLE DB ArchitectureDeveloping an OLE DB ApplicationAdding an ATL OLE DB Consumer ObjectConsumer ComponentsCRowsetCAccessor and CAccessorRowsetCCommandData Source PropertiesCCommand PropertiesUsing a ConsumerOpening and Closing a RowsetUpdating and Inserting into RowsetsNavigating Through a RowsetDeleting Rows from a RowsetCatching OLE DB ErrorsRetrieving Column InformationGetColumnInfo()DBCOLUMNINFOGetColumnsRowset()Using TransactionsUsing EnumeratorsSummary
23. Programming with ADO
ADO ObjectsConnection ObjectsADOConnection PropertiesADOConnection MethodsADOCommand ObjectsADOCommand PropertiesADOCommand MethodsADORecordset ObjectsADORecordset PropertiesADORecordset MethodsADOFields Collections and ADOField ObjectsADOFields Collection MembersADOField Object PropertiesADOField Object MethodsADOParameter Objects and the ADOParameters CollectionADOParameters Collection MembersADOParameter Object PropertiesADOParameter Object MethodsADOProperty Objects and ADOProperties CollectionsADOProperties Collection MembersADOProperty Object PropertiesWriting a Visual C++ ADO ApplicationStep 1—Creating Connections and Recordsets ADO ObjectsStep 2—Connecting to a Database Through ADOStep 3—Opening an ADO RecordsetStep 4—Closing the Connection and RecordsetStep 5—Writing an UpdateData Routine for ADOStep 5a—Retrieving Recordset Field InformationStep 5b—Updating Recordset Field InformationStep 5c—Pulling It Together in One UpdateData() RoutineStep 6—Navigating Through a RecordsetStep 7—Inserting into the RecordsetStep 8—Deleting from the RecordsetProcessing ADO ErrorsADO HRESULT Values, FAILED, and SUCCEEDEDADOErrors Collection MembersError Object PropertiesADO C++ ExceptionsThe Errors CollectionEnhanced ADO Recordset FunctionalityLimiting the Rows in a RecordsetFiltering Rows in the RecordsetRefreshing the RecordsetMove()Absolute PositioningScrolling by PagesUsing BookmarksExecuting CommandsTransactionsSummary
VI. MFC Support for COM and ActiveX
24. Overview of COM and Active Technologies
COM, OLE, and Active Technology History in a NutshellCOM and OLE from the Eyes of the End UserCOM, OLE, and Active Technologies from a Programmer's ViewComponent Object Model (COM)Structured StorageMonikers (Persistent Naming)File MonikersItem MonikersAnti-MonikersPointer MonikersClass MonikersAsynchronous MonikersURL MonikersComposite MonikersMFC Encapsulation of MonikersUniform Data Transfer (UDT)OLE ClipboardDrag and DropEmbedding and LinkingOLE DocumentsIn-Place ActivationAutomationActiveX ControlsEvolving OLE with Active TechnologiesActive DocumentsAsynchronous StorageActiveX ControlsActiveX Control: COMActiveX Control: Connectable ObjectsActiveX Control: Uniform Data TransferActiveX Control: Compound DocumentsActiveX Control: Property PagesActiveX Control: AutomationActiveX Control: Persistent StorageCOMDistributed COM (DCOM)Internet MonikersURL MonikersAsynchronous MonikersNew Active TechnologiesActive HyperlinksNetShowActive ScriptingCode SigningHTML ExtensionsActiveMovieSummary
25. Active Documents
Just What Is an Active Document?Some Details About Active DocumentsThe COM InterfacesIOleObjectIDataObjectIPersistStorageIPersistFile (Optional)IOleDocumentIOleInPlaceObjectIOleInPlaceActiveObjectIOleDocumentViewIPrintIOleCommandTargetThe Active Template LibraryATL Classes Required for Active Document SupportThe ACTIVEDOC Programactivectl.holedocument.hactivedoc.htmSummary
26. Active Containers
Just What Is an Active Document Container?Some Details About Active Document ContainersStructured StorageMonikersUniform Data TransferEmbedded ObjectsLinked ObjectsDrag-and-DropIn-Place ActivationActive DocumentsThe COM InterfacesIOleInPlaceFrameIOleCommandTargetIOleInPlaceUIWindowIOleContainerIOleClientSiteIAdviseSinkIOleDocumentSiteIOleInPlaceSiteIContinueCallbackBuilding an Active Document ContainerActive Document Container Support in MFCThe Pocket ProjectCreating the Pocket ProjectUsing MFC AppWizard to Create the ProjectAdding a Splitter to the Pocket ProjectCreating New Active DocumentsSwitching Between Active DocumentsDestroying an Active DocumentUsing the Pocket ApplicationSummary
27. Active Servers
Active Servers IntroductionThree-Tier Development Using Server ComponentsMFC Versus Active Template LibrariesDesigning an MFC MiniserverAppWizard: Step-by-StepStep 1 of 6Step 2 of 6Step 3 of 6Step 4 of 6Step 5 of 6Step 6 of 6A Closer Look at the GLServer ClassesCGLServerAppCGLServerDocCGLServerSrvrItemCInPlaceFrameCGLServerViewCombining Container and Server Menus During ActivationTesting Out the GLServer SkeletonAdding Customization to the GLServer SkeletonCustomizing CGLServerDocCustomizing CGLServerViewCustomizing CGLServerSrvrItemTesting the GLServer ExampleDesigning an MFC Automation ServerUsing MFC AppWizard to Create Automation ServersA Closer Look at the MFCAuto ClassesAdding Customization to the MFCAuto Sample SkeletonAdding Methods to the MFCAuto ExampleTesting the MFCAuto ExampleSummary
28. ActiveX Controls
A Short HistoryWhat Is an ActiveX Control?ActiveX Control ArchitecturePropertiesEventsMethodsActiveX Control InterfacesActiveX ControlsSupporting the IUnknown InterfaceA Control Must Be Self-RegisteringComponent CategoriesSimple Frame Site ContainmentSimple Data BindingAdvanced Data BindingVisual Basic Private InterfacesInternet-Aware ControlsWindowless ControlsComponent Categories and InteroperabilityCode SigningPerformance ConsiderationsOptimize Control DrawingDon't Always Activate Your Control When It Is VisibleProvide Flicker-Free ActivationOptimize Persistence and InitializationUse Windowless ControlsUse a Device Context That Is UnclippedWhile a Control Is Inactive, Provide Mouse InteractionReinventing the WheelVisual C++ ActiveX ControlsTesting an ActiveX ControlDisplaying a Control on a Web PageActiveX Control PadActiveX Control Test ContainerActiveX Controls in Development ToolsMethods of Creating ActiveX ControlsCreating an ActiveX Control with Visual C++ and MFCUsing Visual C++ and MFC for ActiveX ControlsMFC Encapsulation of ActiveX and ActiveX ControlsThe MFC ActiveX ControlWizardSummary
VII. Using the Active Template Library
29. ATL Architecture
The History of ATLATL's Advanced Use of TemplatesCommonly Used ATL ClassesHigh-Level ATL ClassesATL Helper ClassesUsing CRegKey to Access the RegistryUsing CComBstr to Manage COM StringsUsing the CComVariant ClassUsing Smart PointersUsing the Interface Definition LanguageATL WizardsUsing the ATL COM AppWizardUsing the ATL Object WizardMerging the Proxy/Stub Code with Your DLLSummary
30. Creating COM Objects Using ATL
Using IDL to Describe Custom COM ObjectsUnderstanding MIDL AttributesCompiling an IDL Source File with MIDLUsing Type LibrariesUsing Structures in IDLUsing Enumerations in IDLPointers in IDLUsing Direction Attributes in IDLA Custom COM Class ExampleDefining the IOsVersion InterfaceModifications to the COsVersion DeclarationImplementing the COsVersion ClassCompiling and Registering the Standard Proxy/Stub DLLCreating Test Clients for OsVersionInfoSummary
31. Creating ActiveX Controls Using ATL
ATL Control ClassesImplementing Stock Properties Using ATLImplementing Custom Properties Using ATLUsing Ambient Properties with ATLAdding Message and Event HandlersConnection PointsCreating Scriptable ControlsRequirements for Scriptable ControlsPersistence for ActiveX ControlsA Scriptable ActiveX ControlThe Basic Design of ScriptButtonMessages Handled by ScriptButtonHandling Raised-Button and Flat-Button StatesHandling Button ClicksHandling the Focus RectangleCreating the ScrBtn ProjectAdding the ScriptButton Control Class to the ProjectAdding Outgoing EventsModifying the Message MapInitializing the CScriptButton ObjectRetrieving Ambient PropertiesHandling Focus Events for the ControlHandling Mouse Events for the ControlDrawing the ControlImplementing IPersistPropertyBagMarking the Control as Safe for Scriptable ClientsTesting ScriptButton with Internet ExplorerSummary
32. Using ATL to Create MTS and COM+ Components
Understanding TransactionsCOM+ and MTS FeaturesUnderstanding ContextsConcurrency in COM+Just-In-Time ActivationWhat Is Object Pooling?Registering a COM+ ApplicationConfiguring Properties for a COM+ ApplicationRegistering a COM+ ComponentConfiguring Properties for a COM+ ComponentGeneral PropertiesTransactions PropertiesSecurity PropertiesActivation PropertiesConcurrency PropertiesAdvanced PropertiesAn Example of a COM+ ApplicationThe VcBank DatabaseCreating the VCBankApp COM+ ModuleInserting the VcBank COM+ ComponentAdding Interface Methods to the VcBank ComponentChanges to StdAfx.hChanges to VcBank.hAdding Helper Functions to VcBank.cppImplementing the VcBank Interface MethodsRegistering the VcBank COM+ ApplicationA Client Application for VcBankAdding Dialog Boxes to the BankClient ProjectModifying the Main Dialog Box for BankClientAccessing the COM+ ApplicationRetrieving an Account BalanceMaking a DepositMaking a WithdrawalTransferring Money Between AccountsUsing BankClientSummary
VIII. Finishing Touches
33. Adding Windows Help
Windows Help BasicsUnderstanding WinHelpUnderstanding HTML HelpHelp Options in AppWizardHelp Project ComponentsAuthoring Help Topics Using WinHelpCreating Help TopicsAdding Hot SpotsIncluding Graphics in Help FilesManaging Help ProjectsHelp Project FilesContents FilesCompiling Help ProjectsTesting Help ProjectsCalling WinHelp from Your Applications::WinHelp()Using Help with MFCCWinApp::WinHelp()MFC Help HandlersAdding Context-Sensitive HelpUsing HTML Help with Visual C++Creating an HTML Help ProjectUsing HTML Help Workshop to Create a ProjectCreating Topic PagesCreate an Index File for Help TopicsCreating a Table of ContentsCompiling an HTML Help ProjectIntegrating HTML into a Visual C++ ProjectModifications Required in the HTML Help ProjectModifications Required in the Visual C++ ProjectSummary
IX. Appendix
A. Additional Resources
Visual C++ ResourcesMicrosoft Developer's NetworkLibrary SubscriptionProfessional SubscriptionUniversal SubscriptionHard-Copy Visual C++ DocumentationMagazines and JournalsConferencesSoftwareBooks on Visual C++, MFC, and Windows ProgrammingInternetNewsgroups and FAQsSummary
Bibliography

Content preview from Visual C++® 6 Unleashed

Chapter 31. Creating ActiveX Controls Using ATL

by Mickey Williams

In This Chapter

Chapter 29, "ATL Architecture," discussed using MFC to build ActiveX controls. Although these controls are very useful when used with traditional clients such as Visual Basic, they tend to be quite large and often have dependencies on MFC42.DLL.

In this chapter, you'll learn how to use the Active Template Library (ATL) to create ActiveX controls that are lightweight, have few dependencies, and are safely usable by scripting clients. You'll look at the major classes used by ATL for ActiveX controls. You'll also examine connection points, object safety, and persistence for components used by scripting clients. ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Ivor Horton's Beginning Visual C++® 2010

Publisher Resources

ISBN: 0672312417Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Visual C++® 6 Unleashed

by Mickey Williams, David Bennett

Chapter 31. Creating ActiveX Controls Using ATL

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.