Introduction |
|
xxxiii | |
|
Programming with Visual C++2010 |
|
|
1 | (34) |
|
|
2 | (1) |
|
The Common Language Runtime |
|
|
2 | (1) |
|
|
3 | (2) |
|
Learning Windows Programming |
|
|
5 | (4) |
|
|
5 | (1) |
|
|
5 | (1) |
|
|
6 | (1) |
|
|
6 | (1) |
|
Windows Programming Concepts |
|
|
7 | (2) |
|
What Is the Integrated Development Environment? |
|
|
9 | (1) |
|
|
9 | (1) |
|
|
10 | (1) |
|
|
10 | (1) |
|
|
10 | (1) |
|
|
10 | (22) |
|
|
12 | (1) |
|
|
12 | (1) |
|
|
13 | (1) |
|
|
13 | (14) |
|
Setting Options in Visual C++ 2010 |
|
|
27 | (1) |
|
Creating and Executing Windows Applications |
|
|
28 | (3) |
|
Creating a Windows Forms Application |
|
|
31 | (1) |
|
|
32 | (3) |
|
Data, Variables, and Calculations |
|
|
35 | (86) |
|
The Structure of a C++ Program |
|
|
36 | (13) |
|
|
44 | (1) |
|
|
44 | (2) |
|
|
46 | (1) |
|
|
47 | (1) |
|
Automatically Generated Console Programs |
|
|
47 | (2) |
|
|
49 | (3) |
|
|
49 | (1) |
|
|
50 | (1) |
|
Initial Values for Variables |
|
|
51 | (1) |
|
|
52 | (9) |
|
|
52 | (1) |
|
|
53 | (2) |
|
|
55 | (1) |
|
|
56 | (2) |
|
|
58 | (1) |
|
|
59 | (1) |
|
Defining Synonyms for Data Types |
|
|
59 | (1) |
|
Variables with Specific Sets of Values |
|
|
59 | (2) |
|
Basic Input/Output Operations |
|
|
61 | (5) |
|
|
61 | (1) |
|
Output to the Command Line |
|
|
62 | (1) |
|
|
63 | (1) |
|
|
64 | (2) |
|
|
66 | (12) |
|
|
66 | (1) |
|
|
67 | (5) |
|
|
72 | (1) |
|
|
73 | (1) |
|
The Increment and Decrement Operators |
|
|
74 | (2) |
|
The Sequence of Calculation |
|
|
76 | (2) |
|
Type Conversion and Casting |
|
|
78 | (3) |
|
Type Conversion in Assignments |
|
|
79 | (1) |
|
|
79 | (1) |
|
|
80 | (1) |
|
|
81 | (1) |
|
|
81 | (1) |
|
|
82 | (6) |
|
|
82 | (2) |
|
|
84 | (1) |
|
|
85 | (1) |
|
|
86 | (1) |
|
The Bitwise Shift Operators |
|
|
86 | (2) |
|
Introducing Lvalues and Rvalues |
|
|
88 | (1) |
|
Understanding Storage Duration and Scope |
|
|
89 | (7) |
|
|
89 | (3) |
|
Positioning Variable Declarations |
|
|
92 | (1) |
|
|
92 | (4) |
|
|
96 | (1) |
|
|
96 | (4) |
|
|
97 | (2) |
|
|
99 | (1) |
|
|
100 | (16) |
|
C++/CLI Specific: Fundamental Data Types |
|
|
101 | (4) |
|
C++/CLI Output to the Command Line |
|
|
105 | (1) |
|
C++/CLI Specific---Formatting the Output |
|
|
106 | (3) |
|
C++/CLI Input from the Keyboard |
|
|
109 | (1) |
|
|
110 | (1) |
|
|
111 | (5) |
|
Discovering C++/CLI Types |
|
|
116 | (1) |
|
|
116 | (5) |
|
|
121 | (46) |
|
|
121 | (18) |
|
|
123 | (1) |
|
|
124 | (4) |
|
Nested if-else statements |
|
|
128 | (2) |
|
Logical Operators and Expressions |
|
|
130 | (3) |
|
|
133 | (2) |
|
|
135 | (4) |
|
|
139 | (1) |
|
Repeating a Block of Statements |
|
|
139 | (18) |
|
|
139 | (3) |
|
Variations on the for Loop |
|
|
142 | (8) |
|
|
150 | (2) |
|
|
152 | (2) |
|
|
154 | (3) |
|
|
157 | (6) |
|
|
161 | (2) |
|
|
163 | (4) |
|
Arrays, Strings, and Pointers |
|
|
167 | (84) |
|
Handling Multiple Data Values of the Same Type |
|
|
168 | (12) |
|
|
168 | (1) |
|
|
169 | (3) |
|
|
172 | (2) |
|
Character Arrays and String Handling |
|
|
174 | (3) |
|
|
177 | (3) |
|
|
180 | (21) |
|
|
181 | (1) |
|
|
181 | (1) |
|
|
182 | (1) |
|
|
183 | (7) |
|
|
190 | (2) |
|
Constant Pointers and Pointers to Constants |
|
|
192 | (2) |
|
|
194 | (7) |
|
Dynamic Memory Allocation |
|
|
201 | (5) |
|
The Free Store, Alias the Heap |
|
|
201 | (1) |
|
The new and delete Operators |
|
|
202 | (1) |
|
Allocating Memory Dynamically for Arrays |
|
|
203 | (3) |
|
Dynamic Allocation of Multidimensional Arrays |
|
|
206 | (1) |
|
|
206 | (2) |
|
|
207 | (1) |
|
Declaring and Initializing Lvalue References |
|
|
207 | (1) |
|
Defining and Initializing Rvalue References |
|
|
208 | (1) |
|
Native C++ Library Functions for Strings |
|
|
208 | (7) |
|
Finding the Length of a Null-Terminated String |
|
|
209 | (1) |
|
Joining Null-Terminated Strings |
|
|
210 | (1) |
|
Copying Null-Terminated Strings |
|
|
211 | (1) |
|
Comparing Null-Terminated Strings |
|
|
212 | (1) |
|
Searching Null-Terminated Strings |
|
|
213 | (2) |
|
|
215 | (32) |
|
|
216 | (1) |
|
|
217 | (16) |
|
|
233 | (11) |
|
|
244 | (1) |
|
|
244 | (3) |
|
|
247 | (4) |
|
Introducing Structure into Your Programs |
|
|
251 | (44) |
|
|
252 | (7) |
|
Why Do You Need Functions? |
|
|
253 | (1) |
|
|
253 | (3) |
|
|
256 | (3) |
|
Passing Arguments to a Function |
|
|
259 | (18) |
|
The Pass-by-value Mechanism |
|
|
260 | (2) |
|
Pointers as Arguments to a Function |
|
|
262 | (1) |
|
Passing Arrays to a Function |
|
|
263 | (4) |
|
References as Arguments to a Function |
|
|
267 | (3) |
|
Use of the const Modifier |
|
|
270 | (1) |
|
Rvalue Reference Parameters |
|
|
271 | (2) |
|
|
273 | (2) |
|
Accepting a Variable Number of Function Arguments |
|
|
275 | (2) |
|
Returning Values from a Function |
|
|
277 | (8) |
|
|
277 | (3) |
|
|
280 | (3) |
|
Static Variables in a Function |
|
|
283 | (2) |
|
|
285 | (4) |
|
|
288 | (1) |
|
|
289 | (3) |
|
Functions Accepting a Variable Number of Arguments |
|
|
289 | (1) |
|
|
290 | (2) |
|
|
292 | (3) |
|
More About Program Structure |
|
|
295 | (58) |
|
|
295 | (7) |
|
Declaring Pointers to Functions |
|
|
296 | (3) |
|
A Pointer to a Function as an Argument |
|
|
299 | (2) |
|
Arrays of Pointers to Functions |
|
|
301 | (1) |
|
Initializing Function Parameters |
|
|
302 | (1) |
|
|
303 | (5) |
|
|
305 | (1) |
|
|
306 | (1) |
|
Exception Handling in the MFC |
|
|
307 | (1) |
|
Handling Memory Allocation Errors |
|
|
308 | (2) |
|
|
310 | (4) |
|
What Is Function Overloading? |
|
|
310 | (3) |
|
Reference Types and Overload Selection |
|
|
313 | (1) |
|
When to Overload Functions |
|
|
313 | (1) |
|
|
314 | (3) |
|
Using a Function Template |
|
|
314 | (3) |
|
Using the decltype Operator |
|
|
317 | (1) |
|
An Example Using Functions |
|
|
318 | (18) |
|
Implementing a Calculator |
|
|
319 | (3) |
|
Eliminating Blanks from a String |
|
|
322 | (1) |
|
|
322 | (3) |
|
Getting the Value of a Term |
|
|
325 | (1) |
|
|
326 | (4) |
|
Putting the Program Together |
|
|
330 | (1) |
|
|
331 | (2) |
|
|
333 | (3) |
|
Running the Modified Program |
|
|
336 | (1) |
|
|
336 | (13) |
|
Understanding Generic Functions |
|
|
337 | (6) |
|
A Calculator Program for the CLR |
|
|
343 | (6) |
|
|
349 | (4) |
|
Defining Your Own Data Types |
|
|
353 | (82) |
|
|
354 | (9) |
|
|
354 | (1) |
|
|
354 | (1) |
|
|
355 | (1) |
|
Accessing the Members of a struct |
|
|
355 | (4) |
|
IntelliSense Assistance with Structures |
|
|
359 | (1) |
|
|
360 | (1) |
|
Using Pointers with a struct |
|
|
361 | (2) |
|
Data Types, Objects, Classes, and Instances |
|
|
363 | (3) |
|
|
364 | (1) |
|
|
364 | (1) |
|
|
365 | (1) |
|
|
366 | (8) |
|
|
366 | (1) |
|
Declaring Objects of a Class |
|
|
367 | (1) |
|
Accessing the Data Members of a Class |
|
|
367 | (3) |
|
Member Functions of a Class |
|
|
370 | (2) |
|
Positioning a Member Function Definition |
|
|
372 | (1) |
|
|
372 | (2) |
|
|
374 | (8) |
|
|
374 | (2) |
|
|
376 | (2) |
|
Assigning Default Parameter Values in a Class |
|
|
378 | (3) |
|
Using an Initialization List in a Constructor |
|
|
381 | (1) |
|
Making a Constructor Explicit |
|
|
381 | (1) |
|
Private Members of a Class |
|
|
382 | (8) |
|
Accessing private Class Members |
|
|
385 | (1) |
|
The friend Functions of a Class |
|
|
386 | (2) |
|
The Default Copy Constructor |
|
|
388 | (2) |
|
|
390 | (3) |
|
|
393 | (2) |
|
Const Member Functions of a Class |
|
|
393 | (1) |
|
Member Function Definitions Outside the Class |
|
|
394 | (1) |
|
|
395 | (2) |
|
Static Members of a Class |
|
|
397 | (4) |
|
|
397 | (1) |
|
Static Function Members of a Class |
|
|
397 | (4) |
|
Pointers and References to Class Objects |
|
|
401 | (5) |
|
|
401 | (3) |
|
References to Class Objects |
|
|
404 | (2) |
|
|
406 | (26) |
|
Defining Value Class Types |
|
|
407 | (5) |
|
Defining Reference Class Types |
|
|
412 | (3) |
|
Defining a Copy Constructor for a Reference Class Type |
|
|
415 | (1) |
|
|
416 | (13) |
|
|
429 | (2) |
|
|
431 | (1) |
|
|
432 | (3) |
|
|
435 | (114) |
|
|
435 | (7) |
|
|
436 | (1) |
|
|
436 | (2) |
|
Destructors and Dynamic Memory Allocation |
|
|
438 | (4) |
|
Implementing a Copy Constructor |
|
|
442 | (2) |
|
Sharing Memory Between Variables |
|
|
444 | (2) |
|
|
444 | (2) |
|
|
446 | (1) |
|
Unions in Classes and Structures |
|
|
446 | (1) |
|
|
446 | (20) |
|
Implementing an Overloaded Operator |
|
|
447 | (3) |
|
Implementing Full Support for a Comparison Operator |
|
|
450 | (4) |
|
Overloading the Assignment Operator |
|
|
454 | (5) |
|
Overloading the Addition Operator |
|
|
459 | (4) |
|
Overloading the Increment and Decrement Operators |
|
|
463 | (2) |
|
Overloading the Function Call Operator |
|
|
465 | (1) |
|
The Object Copying Problem |
|
|
466 | (11) |
|
Avoiding Unnecessary Copy Operations |
|
|
466 | (4) |
|
Applying Rvalue Reference Parameters |
|
|
470 | (2) |
|
Named Objects are Lvalues |
|
|
472 | (5) |
|
|
477 | (9) |
|
Defining a Class Template |
|
|
478 | (3) |
|
Creating Objects from a Class Template |
|
|
481 | (2) |
|
Class Templates with Multiple Parameters |
|
|
483 | (3) |
|
Templates for Function Objects |
|
|
486 | (1) |
|
|
486 | (22) |
|
The Idea of a Class Interface |
|
|
486 | (1) |
|
|
487 | (1) |
|
Implementing the CBox Class |
|
|
487 | (21) |
|
Organizing Your Program Code |
|
|
508 | (2) |
|
|
509 | (1) |
|
Native C++ Library Classes for Strings |
|
|
510 | (23) |
|
|
510 | (2) |
|
|
512 | (4) |
|
Accessing and Modifying Strings |
|
|
516 | (4) |
|
|
520 | (3) |
|
|
523 | (10) |
|
|
533 | (11) |
|
Overloading Operators in Value Classes |
|
|
534 | (6) |
|
Overloading the Increment and Decrement Operators |
|
|
540 | (1) |
|
Overloading Operators in Reference Classes |
|
|
540 | (3) |
|
Implementing the Assignment Operator for Reference Types |
|
|
543 | (1) |
|
|
544 | (5) |
|
Class Inheritance and Virtual Functions |
|
|
549 | (96) |
|
Object-Oriented Programming Basics |
|
|
549 | (2) |
|
|
551 | (4) |
|
|
551 | (1) |
|
Deriving Classes from a Base Class |
|
|
552 | (3) |
|
Access Control Under Inheritance |
|
|
555 | (11) |
|
Constructor Operation in a Derived Class |
|
|
558 | (4) |
|
Declaring Protected Class Members |
|
|
562 | (3) |
|
The Access Level of Inherited Class Members |
|
|
565 | (1) |
|
The Copy Constructor in a Derived Class |
|
|
566 | (3) |
|
|
569 | (3) |
|
|
571 | (1) |
|
Limitations on Class Friendship |
|
|
572 | (1) |
|
|
572 | (18) |
|
What is a Virtual Function? |
|
|
574 | (2) |
|
Using Pointers to Class Objects |
|
|
576 | (2) |
|
Using References with Virtual Functions |
|
|
578 | (2) |
|
|
580 | (1) |
|
|
581 | (3) |
|
|
584 | (2) |
|
|
586 | (4) |
|
Casting Between Class Types |
|
|
590 | (1) |
|
|
590 | (4) |
|
|
594 | (44) |
|
|
594 | (1) |
|
Inheritance in C++/CLI Classes |
|
|
595 | (7) |
|
|
602 | (1) |
|
Defining Interface Classes |
|
|
602 | (4) |
|
|
606 | (5) |
|
Functions Specified as new |
|
|
611 | (1) |
|
|
612 | (13) |
|
Destructors and Finalizers in Reference Classes |
|
|
625 | (3) |
|
|
628 | (10) |
|
|
638 | (7) |
|
The Standard Template Library |
|
|
645 | (110) |
|
What is the Standard Template Library? |
|
|
645 | (6) |
|
|
646 | (1) |
|
|
647 | (1) |
|
|
648 | (1) |
|
|
649 | (1) |
|
Function Objects in the STL |
|
|
650 | (1) |
|
|
650 | (1) |
|
The Range of STL Containers |
|
|
651 | (1) |
|
|
651 | (50) |
|
Creating Vector Containers |
|
|
652 | (3) |
|
The Capacity and Size of a Vector Container |
|
|
655 | (5) |
|
Accessing the Elements in a Vector |
|
|
660 | (1) |
|
Inserting and Deleting Elements in a Vector |
|
|
661 | (2) |
|
Storing Class Objects in a Vector |
|
|
663 | (5) |
|
|
668 | (1) |
|
Storing Pointers in a Vector |
|
|
669 | (2) |
|
Double-Ended Queue Containers |
|
|
671 | (4) |
|
|
675 | (10) |
|
Using Other Sequence Containers |
|
|
685 | (16) |
|
|
701 | (14) |
|
|
702 | (12) |
|
Using a Multimap Container |
|
|
714 | (1) |
|
|
715 | (8) |
|
Using Input Stream Iterators |
|
|
715 | (4) |
|
|
719 | (1) |
|
Using Output Stream Iterators |
|
|
720 | (3) |
|
|
723 | (1) |
|
|
724 | (3) |
|
|
725 | (1) |
|
|
725 | (1) |
|
|
725 | (1) |
|
|
726 | (1) |
|
|
727 | (9) |
|
|
728 | (2) |
|
Capturing Specific Variables |
|
|
730 | (1) |
|
Templates and Lambda Expressions |
|
|
730 | (4) |
|
Wrapping a Lambda Expression |
|
|
734 | (2) |
|
The STL for C++/CLI Programs |
|
|
736 | (16) |
|
|
737 | (1) |
|
Using Sequence Containers |
|
|
737 | (8) |
|
Using Associative Containers |
|
|
745 | (7) |
|
Lambda Expressions in C++/CLI |
|
|
752 | (1) |
|
|
752 | (3) |
|
|
755 | (52) |
|
|
756 | (3) |
|
|
757 | (1) |
|
|
758 | (1) |
|
Basic Debugging Operations |
|
|
759 | (8) |
|
|
761 | (2) |
|
|
763 | (1) |
|
|
763 | (4) |
|
Changing the Value of a Variable |
|
|
767 | (1) |
|
|
767 | (8) |
|
|
768 | (1) |
|
Adding Your Own Debugging Code |
|
|
769 | (6) |
|
|
775 | (5) |
|
|
775 | (2) |
|
|
777 | (3) |
|
Testing the Extended Class |
|
|
780 | (3) |
|
|
783 | (1) |
|
|
783 | (10) |
|
Functions for Checking the Free Store |
|
|
784 | (1) |
|
Controlling Free Store Debug Operations |
|
|
785 | (1) |
|
Free Store Debugging Output |
|
|
786 | (7) |
|
Debugging C++/CLI Programs |
|
|
793 | (11) |
|
Using the Debug and Trace Classes |
|
|
793 | (10) |
|
Getting Trace Output in Windows Forms Applications |
|
|
803 | (1) |
|
|
804 | (3) |
|
Windows Programming Concepts |
|
|
807 | (36) |
|
Windows Programming Basics |
|
|
808 | (6) |
|
|
808 | (2) |
|
Windows Programs and the Operating System |
|
|
810 | (1) |
|
|
811 | (1) |
|
|
811 | (1) |
|
|
811 | (1) |
|
|
812 | (1) |
|
Notation in Windows Programs |
|
|
813 | (1) |
|
The Structure of a Windows Program |
|
|
814 | (20) |
|
|
815 | (12) |
|
Message Processing Functions |
|
|
827 | (6) |
|
|
833 | (1) |
|
Windows Program Organization |
|
|
834 | (1) |
|
The Microsoft Foundation Classes |
|
|
835 | (5) |
|
|
836 | (1) |
|
How an MFC Program Is Structured |
|
|
836 | (4) |
|
|
840 | (1) |
|
|
841 | (2) |
|
Programming for Multiple Cores |
|
|
843 | (32) |
|
Parallel Processing Basics |
|
|
843 | (1) |
|
Introducing the Parallel Patterns Library |
|
|
844 | (1) |
|
Algorithms for Parallel Processing |
|
|
844 | (6) |
|
Using the parallel_for Algorithm |
|
|
845 | (1) |
|
Using the parallel_for_each Algorithm |
|
|
846 | (3) |
|
Using the parallel_invoke Algorithm |
|
|
849 | (1) |
|
|
850 | (14) |
|
|
864 | (3) |
|
Using critical_section Objects |
|
|
865 | (1) |
|
Locking and Unlocking a Section of Code |
|
|
865 | (2) |
|
The combinable Class Template |
|
|
867 | (2) |
|
|
869 | (4) |
|
|
873 | (2) |
|
Windows Programming with the Microsoft Foundation Classes |
|
|
875 | (28) |
|
The Document/View Concept in MFC |
|
|
876 | (4) |
|
|
876 | (1) |
|
|
876 | (1) |
|
|
877 | (1) |
|
Linking a Document and Its Views |
|
|
878 | (1) |
|
|
879 | (1) |
|
Creating MFC Applications |
|
|
880 | (19) |
|
Creating an SDI Application |
|
|
882 | (4) |
|
MFC Application Wizard Output |
|
|
886 | (11) |
|
Creating an MDI Application |
|
|
897 | (2) |
|
|
899 | (4) |
|
Working with Menus and Toolbars |
|
|
903 | (42) |
|
Communicating with Windows |
|
|
903 | (6) |
|
Understanding Message Maps |
|
|
904 | (3) |
|
|
907 | (1) |
|
Handling Messages in Your Program |
|
|
908 | (1) |
|
Extending the Sketcher Program |
|
|
909 | (1) |
|
|
910 | (3) |
|
Creating and Editing Menu Resources |
|
|
910 | (3) |
|
Adding Handlers for Menu Messages |
|
|
913 | (11) |
|
Choosing a Class to Handle Menu Messages |
|
|
914 | (1) |
|
Creating Menu Message Functions |
|
|
915 | (1) |
|
Coding Menu Message Functions |
|
|
916 | (4) |
|
Adding Message Handlers to Update the User Interface |
|
|
920 | (4) |
|
|
924 | (4) |
|
Editing Toolbar Button Properties |
|
|
925 | (1) |
|
Exercising the Toolbar Buttons |
|
|
926 | (1) |
|
|
927 | (1) |
|
Menus and Toolbars in a C++/CLI Program |
|
|
928 | (14) |
|
Understanding Windows Forms |
|
|
928 | (1) |
|
Understanding Windows Forms Applications |
|
|
929 | (3) |
|
Adding a Menu to CLR Sketcher |
|
|
932 | (3) |
|
Adding Event Handlers for Menu Items |
|
|
935 | (1) |
|
Implementing Event Handlers |
|
|
936 | (1) |
|
|
937 | (1) |
|
|
938 | (4) |
|
|
942 | (3) |
|
|
945 | (64) |
|
Basics of Drawing in a Window |
|
|
945 | (3) |
|
|
946 | (1) |
|
The Windows Graphical Device Interface |
|
|
946 | (2) |
|
The Drawing Mechanism in Visual C++ |
|
|
948 | (11) |
|
The View Class in Your Application |
|
|
949 | (1) |
|
|
950 | (9) |
|
Drawing Graphics in Practice |
|
|
959 | (2) |
|
Programming for the Mouse |
|
|
961 | (29) |
|
|
962 | (1) |
|
|
963 | (2) |
|
|
965 | (25) |
|
|
990 | (3) |
|
|
991 | (1) |
|
|
992 | (1) |
|
|
993 | (14) |
|
|
993 | (1) |
|
Adding Mouse Event Handlers |
|
|
994 | (2) |
|
Defining C++/CLI Element Classes |
|
|
996 | (8) |
|
Implementing the MouseMove Event Handler |
|
|
1004 | (1) |
|
Implementing the MouseUp Event Handler |
|
|
1005 | (1) |
|
Implementing the Paint Event Handler for the Form |
|
|
1006 | (1) |
|
|
1007 | (2) |
|
Creating the Document and Improving the View |
|
|
1009 | (50) |
|
Creating the Sketch Document |
|
|
1009 | (5) |
|
Using a list<T> Container for the Sketch |
|
|
1010 | (4) |
|
|
1014 | (8) |
|
|
1014 | (2) |
|
|
1016 | (5) |
|
Using MM_LOENGLISH Mapping Mode |
|
|
1021 | (1) |
|
Deleting and Moving Shapes |
|
|
1022 | (1) |
|
Implementing a Context Menu |
|
|
1022 | (16) |
|
Associating a Menu with a Class |
|
|
1023 | (3) |
|
|
1026 | (1) |
|
|
1026 | (4) |
|
Servicing the Menu Messages |
|
|
1030 | (8) |
|
Dealing with Masked Elements |
|
|
1038 | (1) |
|
|
1039 | (17) |
|
Coordinate System Transformations |
|
|
1039 | (3) |
|
|
1042 | (2) |
|
Drawing the Sketch in the Paint Event Handler |
|
|
1044 | (1) |
|
Implementing Element Highlighting |
|
|
1044 | (6) |
|
|
1050 | (6) |
|
|
1056 | (3) |
|
Working with Dialogs and Controls |
|
|
1059 | (64) |
|
|
1059 | (1) |
|
|
1060 | (1) |
|
Creating a Dialog Resource |
|
|
1061 | (2) |
|
Adding Controls to a Dialog Box |
|
|
1062 | (1) |
|
|
1063 | (1) |
|
|
1063 | (4) |
|
|
1063 | (1) |
|
Modal and Modeless Dialogs |
|
|
1064 | (1) |
|
|
1065 | (2) |
|
Supporting the Dialog Controls |
|
|
1067 | (2) |
|
Initializing the Controls |
|
|
1068 | (1) |
|
Handling Radio Button Messages |
|
|
1069 | (1) |
|
Completing Dialog Operations |
|
|
1069 | (3) |
|
Adding Pen Widths to the Document |
|
|
1070 | (1) |
|
Adding Pen Widths to the Elements |
|
|
1070 | (1) |
|
Creating Elements in the View |
|
|
1071 | (1) |
|
|
1072 | (1) |
|
Using a Spin Button Control |
|
|
1072 | (6) |
|
Adding the Scale Menu Item and Toolbar Button |
|
|
1073 | (1) |
|
|
1073 | (1) |
|
Generating the Scale Dialog Class |
|
|
1074 | (3) |
|
Displaying the Spin Button |
|
|
1077 | (1) |
|
|
1078 | (6) |
|
|
1078 | (2) |
|
Setting the Document Size |
|
|
1080 | (1) |
|
|
1080 | (2) |
|
Implementing Scrolling with Scaling |
|
|
1082 | (2) |
|
Using the CTaskDialog Class |
|
|
1084 | (5) |
|
|
1084 | (2) |
|
Creating CTaskDialog Objects |
|
|
1086 | (3) |
|
|
1089 | (4) |
|
Adding a Status Bar to a Frame |
|
|
1089 | (4) |
|
|
1093 | (3) |
|
Removing the Scale Dialog |
|
|
1093 | (1) |
|
Creating a List Box Control |
|
|
1094 | (2) |
|
Using an Edit Box Control |
|
|
1096 | (9) |
|
Creating an Edit Box Resource |
|
|
1096 | (1) |
|
Creating the Dialog Class |
|
|
1097 | (2) |
|
Adding the Text Menu Item |
|
|
1099 | (1) |
|
|
1100 | (1) |
|
Implementing the CText Class |
|
|
1100 | (5) |
|
Dialogs and Controls in CLR Sketcher |
|
|
1105 | (15) |
|
|
1106 | (6) |
|
|
1112 | (8) |
|
|
1120 | (3) |
|
Storing and Printing Documents |
|
|
1123 | (52) |
|
Understanding Serialization |
|
|
1123 | (1) |
|
|
1124 | (7) |
|
Serialization in the Document Class Definition |
|
|
1124 | (1) |
|
Serialization in the Document Class Implementation |
|
|
1125 | (3) |
|
Functionality of CObject-Based Classes |
|
|
1128 | (1) |
|
|
1129 | (2) |
|
How to Implement Serialization for a Class |
|
|
1131 | (1) |
|
|
1131 | (8) |
|
Recording Document Changes |
|
|
1131 | (2) |
|
|
1133 | (2) |
|
Serializing the Element Classes |
|
|
1135 | (4) |
|
|
1139 | (1) |
|
|
1140 | (4) |
|
|
1141 | (3) |
|
Implementing Multipage Printing |
|
|
1144 | (11) |
|
Getting the Overall Document Size |
|
|
1145 | (1) |
|
|
1146 | (1) |
|
|
1147 | (1) |
|
Cleaning Up after Printing |
|
|
1148 | (1) |
|
Preparing the Device Context |
|
|
1149 | (1) |
|
|
1150 | (4) |
|
Getting a Printout of the Document |
|
|
1154 | (1) |
|
Serialization and Printing in CLR Sketcher |
|
|
1155 | (17) |
|
Understanding Binary Serialization |
|
|
1155 | (5) |
|
|
1160 | (11) |
|
|
1171 | (1) |
|
|
1172 | (3) |
|
|
1175 | (18) |
|
|
1175 | (6) |
|
|
1177 | (3) |
|
|
1180 | (1) |
|
|
1180 | (1) |
|
Deciding What to Put in a DLL |
|
|
1181 | (1) |
|
|
1182 | (8) |
|
Writing and Using an Extension DLL |
|
|
1182 | (8) |
|
|
1190 | (3) |
Index |
|
1193 | |