The Active Server Library (ATL) is a tool that simplifies the creation of COM components. The latest version , ATL 3.0, marks the blossoming of ATL as a technology. It now covers the entire spectrum of COM applications. COM is the grand unifying technology on Microsoft platforms, providing the core infrastructure for this and the next generation of Windows. ATL is simply the best way to create COM components, combining flexibility and ease of use with great performance. We'll show you how to get started with COM and ATL. More than that, we'll show you how to create useful controls as we back up the theory with ambitious examples in every chapter.

zlib/Computers/Microsoft Windows/Grimes, Richard, 1964-/Beginning ATL 3 COM programming_21005776.pdf

Templeman, Julian, Grimes, Richard, Reilly, George, Stockton, Alex, Watson, Karli

Richard Grimes; George Reilly; Alex Stockton

Julian Templeman; George Reilly

Richard Grimes ... [et al.]

Apress

Programmer to programmer, Reprint, Birmingham, 2000

Programmer to programmer, Repr, Birmingham, 2001

United Kingdom and Ireland, United Kingdom

Birmingham, UK, England, 1999

Includes index.

topic: Active template library; COM (Computer architecture); Application software

Type: 英文图书

Bookmarks:
1. (p1) Chapter 1: An Introduction To COM
1.1. (p2) A One Sentence Description Of COM
1.2. (p3) The Component Object Model
1.2.1. (p4) The Importance Of Interfaces
1.3. (p5) Creating A COM Component
1.3.1. (p6) The ATLFire Project
1.4. (p7) Using A COM Component
1.4.1. (p8) Initializing COM
1.4.2. (p9) Server Location
1.5. (p10) Creating A COM Object
1.5.1. (p11) Using The Object
1.5.2. (p12) Assembling The Client
1.6. (p13) The Next Stage
1.7. (p14) Summary
2. (p15) Chapter 2: Writing A COM Component
2.1. (p16) Getting Access To Another Interface
2.1.1. (p17) IUnknown
2.2. (p18) Checking And Handling Errors
2.2.1. (p19) HRESULT
2.3. (p20) Writing A COM Component
2.3.1. (p21) The Interface Definition Language
2.3.2. (p22) Creating Interfaces in C
2.3.3. (p23) The MIDL Compiler and C
2.3.4. (p24) Implementing Interfaces
2.3.5. (p25) Vtable Layout, Casting and Identity
2.3.6. (p26) Creating An Object
2.3.7. (p27) Server Lifetime
2.3.8. (p28) Completing A Basic COM DLL Server
2.4. (p29) Creating A Basic Client
2.5. (p30) Summary
3. (p31) Chapter 3: Building And Calling A COM Object Using ATL
3.1. (p32) Using The ATL COM AppWizard
3.1.1. (p33) Server Type
3.1.2. (p34) Allow Merging Of Proxy/Stub Code
3.1.3. (p35) Support MFC
3.1.4. (p36) Support MTS
3.2. (p37) Examining The AppWizard Code
3.2.1. (p38) The Files
3.2.2. (p39) Building The Server
3.3. (p40) Using The ATL Object Wizard
3.3.1. (p41) Names
3.3.2. (p42) Attributes
3.4. (p43) Examining The Object Wizard Code
3.4.1. (p44) Registry Scripts
3.4.2. (p45) Changed Files
3.5. (p46) Adding Methods And Properties
3.5.1. (p47) Methods And Properties
3.5.2. (p48) Adding Properties
3.5.3. (p49) Implementing The Properties
3.5.4. (p50) Adding Methods
3.6. (p51) Creating An ATL Test Client
3.6.1. (p52) Creating The Skeleton
3.6.2. (p53) CExeModule And The Monitor Thread
3.7. (p54) Adding A Dialog
3.8. (p55) Displaying The Dialog
3.8.1. (p56) Tidying Up The Code
3.8.2. (p57) Clearing Up The Resources
3.8.3. (p58) Creating The Dialog
3.8.4. (p59) OnCancel
3.9. (p60) Editing The Dialog Resource
3.10. (p61) Using MIDL Compiler-Generated Files
3.11. (p62) Using The Type Library: The #import Statement
3.12. (p67) Testing The Server From Visual Basic
3.13. (p68) Summary
4. (p69) Chapter 4: ATL Architecture
4.1. (p70) The Structure Of An ATL Class
4.1.1. (p71) The Object Map
4.1.2. (p72) CComObjecto
4.1.3. (p73) CComObjectaorxxx Classes
4.2. (p74) The Maps
4.2.1. (p75) The COM Map
4.2.2. (p76) BEGIN_COM_MAP
4.2.3. (p77) COM_INTERFACE_ENTRY
4.2.4. (p78) END_COM_MAP
4.2.5. (p79) COM Map Summary
4.3. (p80) The Object Map
4.3.1. (p81) BEGIN_OBJECT_MAP and END_OBJECT_MAP
4.3.2. (p82) OBJECT_ENTRY
4.3.3. (p83) OBJECT_ENTRY_NON_CREATEABLE
4.3.4. (p84) Object Map Summary
4.4. (p85) The Category Map
4.5. (p86) Other Maps
4.6. (p87) Object Creation
4.6.1. (p88) Class Object Creation In A DLL
4.6.2. (p89) Class Object Creation In An EXE
4.6.3. (p90) Object Creation In DLLs And EXEs
4.6.4. (p91) Creation Summary
4.7. (p92) An Example of Object Creation
4.7.1. (p93) The Client
4.7.2. (p94) Initializing Objects
4.7.3. (p95) Updating The Client
4.7.4. (p96) Example Summary
4.8. (p97) Reusability
4.8.1. (p98) Containment
4.8.2. (p99) Aggregation
4.8.3. (p100) The Outer Object In ATL
4.8.4. (p101) Aggregating An Object
4.8.5. (p102) Client Changes
4.9. (p103) Aggregation Summary
4.10. (p104) Summary
5. (p105) Chapter 5: Automation And Error Handling
5.1. (p106) Terminology
5.2. (p107) The Need For Automation
5.3. (p108) Automation Interfaces
5.3.1. (p109) Accessing Methods And Properties
5.3.2. (p110) IDispatch
5.3.3. (p111) Dispinterfaces
5.3.4. (p112) IDispatch Methods
5.3.5. (p113) Dual Interfaces
5.3.6. (p114) Type Libraries
5.3.7. (p115) Automation Data Types
5.4. (p116) Accessing Automation Objects
5.4.1. (p117) C++
5.4.2. (p118) Visual Basic
5.4.3. (p119) Java
5.5. (p120) Automation With ATL
5.5.1. (p121) IDispatchlmplo
5.5.2. (p122) Multiple Dual Interfaces
5.5.3. (p123) Handling Errors
5.6. (p124) Summary
6. (p125) Chapter 6: DCOM, Marshaling, And Threading
6.1. (p126) DLL And EXE Servers
6.1.1. (p127) DLLs
6.1.2. (p128) EXEs
6.2. (p129) Marshaling
6.2.1. (p130) MIDL Compiler-Produced Marshaling
6.2.2. (p131) Type Library Marshaling
6.2.3. (p132) Choosing Your Marshaler
6.2.4. (p133) Custom Marshaling
6.3. (p134) Remote Servers
6.3.1. (p135) Surrogates
6.3.2. (p136) Accessing Remote Servers
6.4. (p137) Remote Components With ATL
6.4.1. (p138) A DLL Server
6.4.2. (p139) Moving The Files
6.4.3. (p140) An EXE Server
6.4.4. (p141) Proxy-Stub DLL
6.4.5. (p142) A Configurable Client
6.4.6. (p143) Distributed COM
6.5. (p144) Security
6.5.1. (p145) Authentication And Authorization
6.5.2. (p146) Server Authorization
6.5.3. (p147) Identity
6.5.4. (p148) Endpoints
6.6. (p149) Threading
6.6.1. (p150) Apartments
6.6.2. (p151) Context
6.6.3. (p152) STAs And Message Pumps
6.6.4. (p153) MTAs And Thread Safety
6.6.5. (p154) Threading And In-Process Servers
6.6.6. (p155) Threading And EXE Servers
6.6.7. (p156) ATL And Threading Models
6.6.8. (p157) Manual Marshaling
6.6.9. (p158) A Look To The Future
6.7. (p159) Summary
7. (p160) Chapter 7: ATL Window Classes
7.1. (p161) Basic Window Techniques
7.1.1. (p162) CWindow
7.1.2. (p163) CWindow Wrappers: Atlcontrols.h
7.2. (p164) Window Procedures
7.2.1. (p165) A Window Of Your Own
7.2.2. (p166) Message Maps
7.3. (p167) An Example Application
7.3.1. (p168) Using The ATL Object Wizard In A Win32 Application
7.3.2. (p169) Modifying A Dialog
7.3.3. (p170) Using Alternate Message Maps
7.4. (p171) Summary
8. (p172) Chapter 8: Connectable Components
8.1. (p173) Connection Points And Connectable Components
8.1.1. (p174) A History Of Controls
8.1.2. (p175) Callbacks
8.1.3. (p176) Incoming And Outgoing Interfaces
8.1.4. (p177) Connection Topologies
8.1.5. (p178) Connection Points
8.1.6. (p179) Connection Point Containers
8.1.7. (p180) ATL And Connection Points
8.1.8. (p181) The Outgoing Interface
8.1.9. (p182) Event Firing Code
8.1.10. (p183) Sinking Events
8.1.11. (p184) COM+Events
8.2. (p185) Example: EventWatcher
8.2.1. (p186) The EventWatcher Server
8.2.2. (p187) EventCtrl Client
8.2.3. (p188) Connecting The Two Together
8.2.4. (p189) SetEvent
8.2.5. (p190) Testing The Whole Example
8.3. (p191) Summary
9. (p192) Chapter 9: Properties, Persistence and Collections
9.1. (p193) Control Properties
9.1.1. (p194) Custom Properties
9.1.2. (p195) Stock Properties
9.1.3. (p196) Ambient Properties
9.1.4. (p197) Adding Properties To A Control
9.1.5. (p198) Testing The Control
9.1.6. (p199) Changing Properties From Script Code
9.2. (p200) Persistence
9.2.1. (p201) Persistence Interfaces
9.2.2. (p202) Property Maps
9.2.3. (p203) Persisting As Part Of A Compound Document
9.2.4. (p204) Loading Properties From A Web Page
9.2.5. (p205) Making Object Properties Persistent
9.3. (p206) Collections
9.3.1. (p207) Problems With SAFEARRAYs
9.3.2. (p208) Enumerators
9.3.3. (p209) Writing Collections In C++
9.3.4. (p210) Example: The DeveloperCollection Object
9.4. (p211) Summary
10. (p212) Chapter 10: A Full Control
10.1. (p213) Controls
10.1.1. (p214) Types of Control
10.1.2. (p215) Drawing a Control
10.1.3. (p216) Interaction with the Container
10.1.4. (p217) Object Wizard Options
10.2. (p218) Property Pages
10.2.1. (p219) What Are Property Pages?
10.2.2. (p220) Creating a Property Page
10.2.3. (p221) Relating the Page to the Control
10.3. (p222) Full Control Example
10.3.1. (p223) Tree View Common Controls
10.3.2. (p224) Creating the Control
10.3.3. (p225) The Contained Controls
10.3.4. (p226) Testing the Code
10.3.5. (p227) The URLs Property
10.3.6. (p228) URLTree Tree View Code
10.3.7. (p229) Bitmap Resources
10.3.8. (p230) TVAddItem
10.3.9. (p231) Testing the Control
10.3.10. (p232) Notification Code
10.3.11. (p233) Internet Explorer
10.3.12. (p234) Persistence Code for IE
10.3.13. (p235) Category Map
10.3.14. (p236) Property Page
10.3.15. (p237) Persistence Code for Visual Basic
10.4. (p238) Summary
11. (p239) Appendix A: HRESULT Facility Codes

theme: Active template library; COM (Computer architecture); Application software

2022-03-12