C++Builder 5 Developer's Guide
Sams Publishing
978-0-672-31972-3 (ISBN)
- Titel erscheint in neuer Auflage
- Artikel merken
PLEASE PROVIDE
C++Builder 5 Developer's Guide is a completely new book authored by insiders of the C++Builder development community. You will learn advanced debugging techniques using CodeGuard, master multi-tier distributed applications with MIDAS 3, discover the latest in multi-media techniques with OpenGL, DirectX, and others, master memory management, learn how to build a chat system with TCP/IP, and more. XML, HTML, CORBA, VisiBroker, ActiveX, and COM+ Server are new features covered by this new edition.
Jarrod Hollingworth has been programming for over 15 years and has several years experience in C++Builder. He is now a software development consultant for his own business, Backslash, based in Melbourne, Australia. Dan Butterfield has been programming for over 15 years and has knowledge of many languages C and C++. He is currently writing mathematical modeling software for the Aquatic Environments Research Centre at The University of Reading in the UK. Bob Swart (aka. Dr. Bob) has been programming for over 17 years and has extensive experience in C++Builder. He is a very prominent developer in the C++Builder community and is the Webmaster of Dr. Bob's Programming Clinic (www.drbob42.com). Jamie Allsop has programmed in a variety of languages but C++ is his language of choice. He has used C++Builder since it was first released. He runs his own software company "Shiying" with his wife and has developed components for Communication and real-time DSP applications.
Introduction.
I. C++BUILDER 5 ESSENTIALS.
1. Introduction to C++Builder.
C++Builder Basics.
Hello World! A Basic Start. The VCL, Forms, and Components. The Component Palette. Your First Real Program. How to Get Around.
What's New in C++Builder.
Web Programming. Distributed Applications. Team Development. Application Localization. Debugging Database Application Development. Developer Productivity. Companion Tools CD-ROM.
Upgrading and Compatibility Issues.
Upgrading C++Builder from an Earlier Version. Using Existing Projects in C++Builder. Creating Projects Compatible with Previous Versions of C++Builder. Solving Other Project Upgrading Issues.
Migration from Delphi.
Comments. Variables. Constants. Operators. Controlling Program Flow. Functions and Procedures. Classes. Preprocessor Directives. Types of Files.
Advantages and Disadvantages of C++Builder.
Visual Reality: True Rapid Application Development. Keeping Up with the Joneses: The C++ Standard. Choosing the Right Development Environment. C++Builder Advantages and Disadvantages Conclusion.
Preparation for Kylix.
Similarities Between Kylix and C++Builder. Differences Between Kylix and C++Builder. Porting C++Builder Projects to Kylix. So When?
Summary.
2. C++Builder Projects and More on the IDE.
Understanding C++Builder Projects.
Files Used in C++Builder Projects. Project Manager.
Using the Object Repository.
Adding Items to the Object Repository. Using Items in the Object Repository. Sharing Items Within a Project. Customizing the Object Repository. Creating and Adding a Wizard to the Object Repository.
Understanding and Using Packages.
Considerations when Using Packages. The C++Builder Runtime Packages. Using Tdump.
Introducing New IDE Features in C++Builder 5.
Property Categories in the Object Inspector. Images in Drop-Down Lists in the Object Inspector. The XML Project File Format. Forms-Save as Text. The Node-Level Options. The New To-Do List. The Console Wizard.
Summary.
3. Programming in C++Builder.
Coding Style to Improve Readability.
The Use of Short and Simple Code. The Use of Code Layout. The Use of Sensible Naming. The Use of Code Constructs. The Use of Comments. A Final Note on Improving the Readability of Code.
Better Programming Practices in C++Builder.
Use a String Class Instead of char*. Understand References and Use Them Where Appropriate. Avoid Using Global Variables. Understand and Use const in Your Code. Be Familiar with the Principles of Exceptions. Use new and delete to Manage Memory. Understand and Use C++-Style Casts. Know When to Use the Preprocessor. Learn About and Use the C++ Standard Library.
Further Reading. Summary.
4. Advanced Programming with C++Builder.
Introducing the Standard C++ Library and Templates.
Understanding C++ Templates. Exploring the Standard C++ Library Features. Coming to Grips with Containers and Iterators. Using the Standard Algorithms. Closing Thoughts on the SCL.
Using Smart Pointers and Strong Containers.
The Heap Versus the Stack. Pointers. A Strong Container. Pitfalls. Smart Pointers and Strong Containers Summary.
Implementing an Advanced Exception Handler.
Reviewing the Strategy. Reviewing the Advantages. Replacing the Compiler's Default Exception Handler. Adding Project-Specific Information to the Class. The Exception Handler's Source Code. Advanced Exception Handler Summary.
Creating Multithreaded Applications.
Understanding Multitasking. Understanding Multithreading. Creating a Thread Using API Calls. Understanding the TThread Object. Understanding the Main VCL Thread. Establishing Priorities. Timing Threads. Synchronizing Threads.
Introducing Design Patterns.
Understanding the Recurring Nature of Patterns. Recurring Patterns in Software Design. Design Patterns as a Vocabulary. Design Pattern Format. Design Pattern Classification. Parting Thoughts About Design Patterns.
Summary.
5. User Interface Principles and Techniques.
User Interface Guidelines. The Example Projects Used in This Chapter.
Introducing the MiniCalculator Project.
Enhancing Usability by Providing Feedback to the User.
Using TProgressBar and TCGauge. Using the Cursor. Using TStatusBar. Using Hints.
Enhancing Usability Through Input Focus Control.
Responding to Input. Moving Input Focus.
Enhancing Usability Through Appearance.
Using Symbols on Their Own with Buttons. Using Symbols in Addition to Text. Using Color to Provide Visual Clues. Using Shaped Controls.
Enhancing Usability by Allowing Customization of the User Interface.
Docking. Resizing. Using TControlBar. Controlling Visibility. Customizing the Client Area of an MDI Parent Form.
Enhancing Usability by Remembering the User's Preferences. Coping with Differing Screen Conditions.
Coping with Different Screen Resolutions. Coping with Different Font Sizes. Coping with Different Color Depths.
Coping with Complexity in the Implementation of the User Interface.
Using Action Lists. Sharing Event Handlers.
Summary.
6. Compiling and Optimizing Your Application.
Understanding How the Compiler Works. Speeding Up Compile Times.
Precompiled Headers. Other Techniques for Speeding Up Compile Times.
Exploring the C++Builder 5 Compiler and Linker Enhancements.
Background Compilation. Miscellaneous Compiler Enhancements. New Linker Enhancements.
Optimizing: An Introduction. Optimizing for Execution Speed.
Crozzle Solver Application Example. Exponential Timings. Project Options for Execution Speed. Detecting Bottlenecks. Optimizing the Design and Algorithms. Exploring Techniques for Streamlining Code. Techniques for Streamlining Data. Hand-Tuning Assembly Code. Using External Optimization. Execution Speed Optimization Summary.
Optimizing Other Aspects of Your Application.
Optimizing Program Size. Final Optimization Aspects.
Summary.
7. Debugging Your Application.
Debugging Overview.
Project Guidelines. Programming Guidelines. The Debugging Task.
Basic Debugging Techniques.
Outputting Debug Information. Using Assertions. Implementing a Global Exception Handler. Other Basic Debugging Issues.
Using the C++Builder Interactive Debugger.
Advanced Breakpoints. New Breakpoint Features in C++Builder. C++Builder Debugging Views. Watches, Evaluating, and Modifying. The Debug Inspector.
CodeGuard.
Enabling and Configuring CodeGuard. Using CodeGuard. Examining CodeGuard Errors and Their Causes.
Advanced Debugging.
Locating the Source of Access Violations. Attaching to a Running Process. Using Just-In-Time Debugging. Remote Debugging. Debugging DLLs. Looking at Other Debugging Tools.
Testing.
Testing Stages and Techniques. Testing Tips.
Summary.
8. Using VCL Components.
VCL Overview.
It All Starts at TObject. Building on Existing Objects. Using the VCL. The C++ Extensions.
The Streaming Mechanism.
Advanced Streaming Requirements. Streaming Unpublished Properties.
Common Control Updates.
Common Control Dynamic Link Library. C++Builder Common Control Updates.
Miscellaneous VCL Enhancements.
New Help Hint and Menu Features. Registry Access. VCL Documentation Enhancements. New TApplicationEvents Component. TIcon Enhancements. Other Miscellaneous VCL Enhancements.
Extending the VCL-More than Just a TStringList.
Using TStringList as a Container. Storing Non-VCL Objects. Linking Strings to Objects of the Same Type. Creating a Chain of Events. Sorting the Lists. Making Improvements.
Advanced Custom Draw Events.
The TTreeView Component. The TListView Component. The TToolBar Component. Advanced Custom Draw Events Example.
Control Panel Applet Wizard Components.
The Basics of an Applet.
Making Use of Third-Party Components.
Third-Party Component Advantages and Disadvantages. Where to Look for More C++Builder Resources.
Summary.
9. Creating Custom Components.
Why Create Custom Components. Understanding Component Writing.
Why Build Upon an Existing Component? Designing Custom Components. Using the VCL Chart.
Writing Non-Visual Components.
Properties. Events. Methods. Creating Component Exceptions. The namespace. Responding to Messages. Designtime Versus Runtime. Linking Components. Linking Events Between Components.
Writing Visual Components.
Where to Begin. TCanvas. Using Graphics in Components. Responding to Mouse Messages. Putting It All Together. Modifying Windowed Components.
Creating Custom Data-Aware Components.
Making the Control Read-Only. Establishing the Link. Using the OnDataChange Event. Changing to a Data-Editing Control. Working Toward a Dataset Update. Adding a Final Message.
Registering Components. Summary.
10. Creating Property and Component Editors.
Creating Custom Property Editors.
The GetAttributes() Method. The GetValue() Method. The SetValue() Method. The Edit() Method. The GetValues() Method. Using the TPropertyEditor Properties. Considerations when Choosing a Suitable Property Editor.
Properties and Exceptions. Registering Custom Property Editors.
Obtaining a TTypeInfo* (PTypeInfo) from an Existing Property and Class for a Non-VCL Type. Obtaining a TTypeInfo* (PTypeInfo) for a Non-VCL Type by Manual Creation. How to Obtain a TTypeInfo* for a Non-VCL Type. Rules for Overriding Property Editors.
Using Images in Property Editors.
The ListMeasureWidth() Method. The ListMeasureHeight() Method. The ListDrawValue() Method. The PropDrawValue() Method. The PropDrawName() Method.
Installing Editor-Only Packages. Using Linked Image Lists in Property Editors.
The GetAttributes() Method. The GetComponentImageList() Method. The GetValues() Method. The ListMeasureWidth() and ListMeasureHeight() Methods. The ListDrawValue() Method. The PropDrawValue() Method. Other Considerations when Rendering Images. Linking to a Parent's TCustomImageList. A Generalized Solution for ImageIndex Properties.
Creating Custom Component Editors.
The Edit() Method. The EditProperty() Method. The GetVerbCount() Method. The GetVerb() Method. The PrepareItem() Method. The ExecuteVerb() Method. The Copy() Method.
Registering Component Editors. Using Predefined Images in Custom Property and Component Editors.
Adding Resource Files to Packages. Using Resources in Property and Component Editors.
Registering Property Categories in Custom Components.
Understanding Categories and Category Creation. Registering a Property or Properties in a Category.
Summary.
11. More Custom Component Techniques.
Miscellaneous Considerations for Custom Components.
Displaying a Class Property's Published Properties in the Object. Inspector. Using Namespaces in Event Parameter Lists. Considerations when Determining an Event's Parameter List. Overriding DYNAMIC Functions. Handling Messages in Custom Components. Using Windows Callback Functions in Components. Considerations when Choosing Fundamental Property Types. Allowing for Designtime and Runtime Component Use.
Frames.
What Exactly Is a Frame? The TCustomFrame Class. Working with Frames at Designtime. Working with Frames at Runtime. Creating a TFrame Descendant Class. Inheriting from a TFrame Descendant Class. Reusing Frames. Closing Remarks on Frames.
Component Distribution and Related Issues.
Packaging Components. Where Distributed Files Should Be Placed. Naming Packages and Package Units. Naming Components. Distributing only a Designtime-Only Package. Distributing Components for Different Versions of C++Builder. Creating Component Palette Bitmaps. Using Guidelines in the Design of Components for Distribution. Taking a Look at Other Distribution Issues.
Summary.
II. COMMUNICATIONS, DATABASE, AND WEB PROGRAMMING.
12. Communications Programming.
Serial Communication.
Protocol. State Machines. Architecture. Thread Synchronization Techniques. Buffering. Concluding Remarks on Serial Communications.
Internet Protocols-SMTP, FTP, HTTP, POP3.
Tour of Component Tabs. An Example Chat Server. An Example Chat Client. An Example Email Application. An Example HTTP Server. Example FTP Client Software.
Summary.
13. Web Server Programming.
Web Modules. Web Server Application Wizard.
CGI. WinCGI. ISAPI/NSAPI. CGI or ISAPI?
WebBroker Support Components.
TWebDispatcher. TWebModule. TWebResponse. TWebRequest.
Web Servers. WebBroker Producing Components.
TPageProducer. TDataSetPageProducer. TDataSetTableProducer TQueryTableProducer.
Web Application Wizards. Maintaining State.
Fat URLs. Cookies. Hidden Fields.
Web Security.
Secure Sockets Layer. Authorization. Securing a Web Application.
HTML and.
XML.
InternetExpress.
Customer Orders. TMidasPageProducer. Deployment. Final Master-Detail. Web Page Design Issues.
Summary.
14. Database Programming.
Architecture Models for Database Applications.
The Borland Database Engine. BDE Native (Single-Tier). BDE/SQL Links (Client/Server). Distributed (Multitier). Data Access Methods. Native Components. ODBC Using the BDE. ODBC Using Native Components. ADO (ActiveX). Embedded SQL. Native API. Database Architectures-Conclusion. Sources for More Information on Database Architectures.
Structured Query Language (SQL).
Tables and Indices. Parameters. insert, update, delete, and select. Aggregate Functions. More Information on SQL.
ADO Express Components for C++Builder.
ADO Versus BDE. Component Overview. Database Connections. Accessing Datasets. Accessing a Dataset with TADOTable. Using TADOCommand for Dataset Access. Managing Transactions. Using Component Events. Creating Generic Database Applications. Performance Optimizations. Error Handling Issues. Multitier Applications and ADO. ADO Express Components-Conclusion.
Data Acquisition Architectures.
The Basic Choices. Fetching Data from Many Sources.
Data Module Designer.
What Are Data Modules? Why Use a Data Module? How Do I Use a Data Module in My Applications, DLLs, and Distributed Objects? What Goes in a Data Module? How Can I Add Properties to My Data Module? How to Use the Data Module Designer. Advanced Concepts. Form Inheritance with Data Modules. Handling Uneven Form Inheritance with Data Modules. How to Avoid Dependence on Specific User Interfaces. How to Work with Application-Specific and Framework Components in Data Modules. Data Modules in Packages. Data Module Designer-Conclusions.
InterBase Express.
Bug Tracker Database Schema. Database Rules. Generators, Triggers, and Stored Procedures. Bug Tracker Implementation. Bug Tracker Wrap Up.
Summary.
III. INTERFACES AND DISTRIBUTED COMPUTING.
15. DLLs and Plug-Ins.
Using the DLL Wizard. Writing and Using DLLs.
Linking DLLs Statically. Importing Functions from a Dynamically Linked. Exporting Classes.
Using Packages Versus DLLs. Using SDI Forms in. Using MDI Child Forms in DLLs and Packages.
Using MDI Child Forms in DLLs. Using MDI Child Forms in Packages.
Using Microsoft Visual C++ DLLs with C++Builder. Using C++Builder DLLs with Microsoft Visual. Writing Plug-Ins.
Anatomy of a Plug-In. TIBCB5PlugInBase Class. TBCB5PluginManager. Wrapping Up Plug-Ins.
Summary.
16. COM Programming.
Understanding COM Servers and Clients. Outgoing Interfaces and Event Sinks Revisited. Writing the COM Server.
Choosing the Server Type. Choosing a Threading Model. Creating the Server. Adding a COM Object. Dissecting the Generated Code. Writing Method Bodies. Adding Better Error Support. Implementing a Method That Fires an Event. Implementing a Custom Interface. Firing Custom Events.
Writing the Proxy/Stub. Writing the COM Client.
Importing the Type Library. Looking at the Generated C++ Constructions. Creating and Using the COM Server Object. Catching Dispinterface-Based Events. Querying for the Custom Interface. Writing the Custom Interface-Based Event Sink.
Recommended Readings. Summary.
17. Going Distributed: DCOM.
What Is DCOM?
Windows OS Family and DCOM.
The DCOMCnfg Utility Tool.
Global Security Settings. Per-Server Security Settings.
Field Testing DCOM.
Creating the Server Application. Creating the Client Application. Configuring Launch and Access Permissions. Configuring Identity. Running the Example.
Programming Security.
CoInitializeSecurity Function Parameters. Using CoInitializeSecurity. Understanding DLL Clients and Security. Implementing Programmatic Access Control. Implementing Interface-Wide Security. Using the Blanket.
Summary.
18. One Step Ahead: COM+.
Introducing COM+.
COM+ Applications. The COM+ Catalog.
Using COM+ Services.
Loosely Coupled Events. Transactions. Synchronization. Security. Queued Components. Load Balancing.
Developing and Using COM+ Events.
Creating the COM+ Event Object. Installing the Event in a COM+ Application. Creating the Publisher. Creating Subscribers. Configuring Subscribers. Creating a Persistent Subscription. Creating a Transient Subscription.
Developing and Using COM+ Transactional Objects.
Creating the Transactional Objects for the Business Layer. Developing Compensated Resource Managers. Creating the Client.
Summary.
19. Multi-Tier Distributed Applications with MIDAS.
Introduction to MIDAS. MIDAS Clients and Servers.
Creating a Simple MIDAS Server. Examining MIDAS Server Registration. Creating a MIDAS Client. Using the Briefcase Model. Using ApplyUpdates. Implementing Error Handling. Demonstrating Reconcile Errors. Accessing the Server Remotely. Creating a MIDAS Master-Detail Server. Exporting Master-Detail DataSets. Creating a MIDAS Master-Detail Client. Using Nested Tables. Understanding MIDAS Bandwidth Bottlenecks.
MIDAS 3 Enhancements.
TDataSetProvider. IProvider Versus IAppServer. Stateless Data Broker. InternetExpress Applications. WebConnection Component. Object Pooling. Socket Server. Object Broker. Deployment.
Summary.
20. Distributed Applications with CORBA.
Introduction to CORBA. How CORBA Works.
Static and Dynamic. Always or On-Demand. Flat or Hierarchical. Who Is the Server and Who Is the Client. The Object Request Broker. The Basic Object Adapter. The Portable Object Adapter. CORBA Versus.
Visibroker Components.
The Smart Agent. The Object Activation Daemon. The Console.
The Interface Definition Language.
The interface Keyword. The attribute Keyword. Methods. Type Definitions. Exceptions. Inheritance. Modules.
What's New in C++Builder. C++Builder Support for CORBA.
Environment Options. Debugger Options. Project Options. The CORBA Server Wizard. The CORBA Client Wizard. CORBA IDL File Wizard. CORBA Object Implementation Wizard. The Project Updates Dialog. The Use CORBA Object Wizard. Differences Between C++Builder 4 and C++Builder.
Implementation Models.
Inheritance. Virtual Implementation Inheritance. Delegation Model (Tie).
Poor Man's CORBA. Summary.
21. Microsoft Office Integration.
Overview of Integration with Microsoft Office. How to Integrate.
Using TOleContainer. Using Automation. Using Variants and Automation Objects. Guarding Against Macro Viruses with Automation. Using Word Basic.
Integrating with Word.
Collections. The Application Object. Working with Documents. Getting Text from Word. Putting Objects into Word Documents.
Integrating with Excel.
Obtaining the Application Object. Working with Workbooks. Putting Cells into Excel Worksheets. Getting Cells from Excel.
Using C++Builder 5's Server Components.
The WordApplication and WordDocument Components. Vocabulary Revisited. Final Thoughts About ATL and OleServers.
Going Further.
Word. Excel. Other Office Applications.
Summary.
22. Using ActiveX Techniques.
Understanding Active Server Objects.
A Step-by-Step Example: Creating Response and Request Objects Via the Active Server Object Wizard. ASP Session, Server, and Application Objects. ASP Objects and WebBroker Support. Redeployment of Active Server Objects. Debugging Active Server Objects.
Introducing ActiveForms. Building an ActiveForm. Deploying an ActiveForm for Use in Internet Explorer.
Setting Options for an ActiveForm. Connecting to an ActiveForm.
Creating a Data-Aware ActiveForm.
Working with CAB Files and Packages. ActiveForm Updates. OCCACHE and Downloaded Program Files.
Creating ActiveForms as MIDAS Clients. Using an ActiveForm in Delphi. Creating Component Templates with ActiveForms. Shell Programming.
Shell Basics. Retrieving a Folder's Contents. Transferring Shell Objects.
Summary.
IV. ADVANCED TOPICS.
23. Data Presentation with C++Builder.
Presenting Data in Reports.
Understanding the Value of a Report. Using QuickReport to Produce Reports. Understanding the Philosophy of the Custom Viewer. QuickReport Custom Viewer Summary.
Printing Text and Graphics.
Printing Text. Printing Graphics.
Using Advanced Printing Techniques.
Determining Printer Resolution. Determining the Printable Paper Size. Determining the Physical Sizes. Determining Printer Drawing Capabilities. How to Print with a Rotated Font. Getting Access to Printer Settings and Setup. How to Get the Default Printer Name. How to Set the Default Printer. Resetting TPrinter. General Information About Accessing DEVMODE Using TPrinter. Using PRINTER_INFO_2. Other Paper-Related Functions. Working with Jobs. How to Catch the Pressing of the Print Screen Button. Printing a Form. Creating a Print Preview. Using Printer-Related Conversion Routines. Other Printer-Related Information.
Creating Charts with the TChart Component.
Getting Started with TeeChart. Altering Chart Appearance at Runtime. Interacting with Charts. Creating Charts Dynamically. Printing Charts. Upgrading to TeeChart.
Summary.
24. Using the Win32 API.
Win32 API Versus Win32 Middleware. Brief History of Windows and the. Win32 API Functional Areas.
Windows Management. System Services. Graphical Device Interface. Multimedia Services. Common Controls and Dialogs. Shell Features. International Features. Network Services.
Anatomy and Operation of a Windows Program.
WinMain(). Window Handles. Windows Messages.
Real-World Examples Using the API.
Launching an Application Within a Program. Fundamental File. Using the Magic of Shell. Implementing Multimedia Services. Using Globally Unique Identifiers (GUIDs). Determining System Information. Flashing a Notification. Adding System Support. Animating Effects. Shaping Your Applications. Writing Control Panel Applets the Old-Fashioned Way.
Summary.
25. Multimedia Techniques.
The Graphical Device Interface (GDI).
The Windows API and the Device Context. Understanding TCanvas: The C++Builder Interface. Customizing a Drawing. An Analogue Clock Example.
Image Support.
The Windows Bitmap Object. The TBitmap Class. JPEG Images. GIF Images. PNG Images.
Image Processing.
Displaying and Obtaining Image Information. Accessing Individual Pixel Values Using TCanvas->Pixels. Image Generation. Fast Access to Pixel Value Using ScanLine. Point Operations: Thresholding and Color/Grayscale Inversion. Global Operation: Histogram Equalization. Geometrical Transformation: Zoom. Spatial Operation: Smoothing and Edge Detection.
Audio Files, Video Files, and CD Music.
The Media Control Interface. The Waveform Audio Interface. Concluding Remarks on the Waveform Audio Interface.
Summary.
26. Advanced Graphics with DirectX and OpenGL.
Introduction to OpenGL.
OpenGL Versus Direct3D. The OpenGL Command Structure. Drawing Loops in C++Builder Using OnIdle().
Using OpenGL.
Stage 1: OpenGL Initialization. Stage 2: Setting Up a Rendering Environment with Lighting and. Shading. Stage 3: 3D Transformations. Stage 4: Drawing Primitives. Stage 5: Flipping Surfaces. An Example OpenGL Program. OpenGL Conclusion. OpenGL References.
Introduction to DirectX.
COM Basis of the DirectX API. Non-Object DirectX Functions.
Using DirectDraw.
Initialization of a DirectDraw Object. Adjusting Display Settings for DirectDraw. Drawing Surfaces. Using the GDI on DirectDraw Surfaces. Loading Bitmaps into a Surface. A DirectDraw Example Program. DirectDraw Conclusion.
Using DirectSound.
Initializing a DirectSound Object. Creating a Secondary Buffer. A DirectSound Example Program-A Multiple Sound Player.
Taking DirectX Further. DirectX References. Summary.
V. C++BUILDER APPLICATION DEPLOYMENT.
27. Creating Help Files and Documentation.
Technical Writing 101-Ten Quick Steps to Better Writing. Types of Documentation. Strategies for Online Documentation.
Approaches to Help.
Help Formats. WinHelp Format Help Files: The Windows Standard.
Help-Authoring Tools. Context-Sensitive Help. The MS Help Workshop. Adding What's This? Help to C++Builder. Expanding Your Help Project Using Advanced Features.
Microsoft HTML Help Files. Help Properties and Methods in the VCL.
Help Properties. Help Methods. Events.
Resources for the Help Author.
Books. Help-Authoring Tools Available on the Internet.
Summary.
28. Software Distribution.
Language Internationalization and Localization.
Overview of Language Internationalization. The Localize Application. Things to Remember.
Resource DLL Wizard.
How Does It Work? How to Create a Resource DLL. How to Test It.
Other Files and Programs to Ship.
Your Application Files. Distribution Steps.
Copyrighting and Software Licensing.
Copyrighting. Software Licensing.
Software Protection.
Protecting Your Application. Protecting Your Application with Third-Party Components. Protecting Your Application with Other Types of Components. Some Final Thoughts on Software Protection.
Shareware.
Shareware and How to Protect It. Implementing Shareware Protection Methods. Shareware Methods in a Nutshell.
Distribution and Marketing Via the Internet.
Web Sites. Customer Support. Advertising. Free Banner Ads. Accepting Credit Cards and Providing Unlock Codes. Internet Marketing Hints and Tips.
Summary.
29. Software Installation and Updates.
Install and Uninstall.
Installation Program Creators. Install Maker. Uninstalling.
CAB and INF Files.
About CAB Files. About INF Files. About Internet Packages.
Versions, Updates, and Patches.
Versions. Updates for Application Improvements. Patches. Patch Maker. Some Tips on Updates and Patches.
Version Control and TeamSource.
Who Should Use TeamSource? Why Should TeamSource Be Used? When Should TeamSource Be Used? Where Can TeamSource Be Used? How Is TeamSource Used? TeamSource Windows. Version Controllers. Bookmarks. Locks.
Using InstallShield Express.
Installing InstallShield. Getting Started in InstallShield. Testing.
Summary.
VI. KNOWLEDGE BASE.
30. Tips, Tricks, and How Tos.
Making the Enter Key Simulate the Tab Key.
The Solution. Explanation of the Code. Some Pitfalls. Tab Key Simulation Wrap Up.
Determining the OS Version.
The Solution. The Code. Determining the OS Version Wrap Up.
Programming Using Floating-Point Numbers.
Background. Working with Numbers. Performing Addition and Subtraction. Performing Formulaic Chains of Arithmetic. Comparing Data. Floating-Point Numbers-Closing Remark.
Implementing Splash Screens.
The WinMain() Function. Creating a Splash Screen.
Preventing More than One Instance of an Application from Running.
The Solution. The Code. Conclusion.
Working with Drag-and-Drop.
The Solution. The Code. How Does It Work? Wrapping Up Drag-and-Drop.
Capturing the Screen.
How Windows Handles Windows. The Solution. Capturing Screens Wrap Up.
Implementing a TJoyStick Component. Creating a Windows System Monitor-Like Application.
A Look at Windows System Resources. The Solution. System Monitor Wrap Up.
Examining a Soundex Application.
The Solution.
Using Tree View Components.
Tree View Basics. Adding Nodes. Using Glyphs. Navigating Tree Views. Accessing Nodes. Finding Nodes. Displaying Node Counts. Moving Nodes Up and Down. Implementing Drag-and-Drop. Modifying a Node. Deleting a Node. Supporting Undo and Redo Deletion. Save a Tree (For the Morning After). TTree Wrap Up.
Implementing an Icon Extraction Utility. Creating a Windows Explorer-Like Application.
Investigating Windows Shell Functions and Interfaces. The Solution. Windows Explorer Wrap Up.
Working with NT Services.
The SendMsg Program. The Stickums Service. The Stickem Client Program. Windows Services Wrap Up.
Using Cryptography.
The Solution. File Encoding. File Decryption.
Creating a World Daylight Clock.
Special Supplement for Non-Believers.
Summary.
31. A Real-World Example.
Examining a World Wave Statistics Program. Examining the Source Code.
Header File math.h. Header File mapunit.h. Header File wavedata.h. Source Code File about.cpp.
Examining the Code for TMainUnit. Making Some Improvements. Summary.
VII. APPENDIX.
Appendix A. Information Sources.
Borland Web Sites.
Borland Community Web Site. Borland Main Web Site.
CodeCentral. Discussion Lists and Forums.
Web-Based Forums. Email Discussion Lists.
Newsgroups. Web Sites.
How-Tos and Technical Articles. Component Repositories.
Books and Magazines.
C++Builder Books. General C++ Books. Magazines.
Conferences and User Groups.
Index.
| Erscheint lt. Verlag | 18.12.2000 |
|---|---|
| Verlagsort | Indianapolis |
| Sprache | englisch |
| Maße | 186 x 231 mm |
| Gewicht | 2341 g |
| Themenwelt | Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge |
| ISBN-10 | 0-672-31972-1 / 0672319721 |
| ISBN-13 | 978-0-672-31972-3 / 9780672319723 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
