|        
     | 
        
          | C++Builder
            is a powerful and fun way to handle Windows programming.  As
            with any tool, it requires some patience and practice to gain
            familiarity with.  Here you'll find some answers to
            questions that I've deemed "commonly asked."  I've
            also included some advanced techniques and answers to some
            tough questions.  This page is here for fellow developers
            to browse, read, cut-and-paste, and most importantly, learn from. 
            It's also a reference for me, since my memory is slowly
            fading... Enjoy! |  
        
          | 
              
                | Recent
                  Additions |  
                | 
                    
                      | 
                    Check out the new home page of the Windows 2000 Graphics API Black Book (by Damon Chandler and Michael Fötsch):
                      
                       |  |  |  
          | 
 
              
                | Inside
                  the VCL |  
                | 
                    
                      | "Inside the VCL"
                        is a new series of articles that's designed to help you
                        use the VCL effectively.  These articles are
                        primarily from a text that I started, but abandoned
                        because C++Builder isn't too popular with the
                        publishers.  Please excuse the textbook-like tone
                        of these article, and I apologize in advance for any
                        typos. |  
                    
                      | 
                          
                      | 
                          
                            | "Window
                              Creation Fundamentals" 
                              [read
                              article] |  
                            | 
                                
                                  |  | 
                                      
                                        | The
                                          TWinControl
                                          class serves as the "glue"
                                          between the Windows API and all
                                          windowed VCL controls. 
                                          For this reason, in order to
                                          understand the TWinControl
                                          class, we'll need to first examine the
                                          window creation process from an API
                                          point of view. 
                                          As we did in the first article
                                          ("From Messages to Events"),
                                          we'll make several fundamental
                                          connections between the Windows API
                                          and the VCL.  Here we'll focus
                                          specifically on the TWinControl
                                          class and more specifically on the
                                          window creation process. [read
                                          more...]
 |  |  |  |  
                      | 
                          
                            | "From
                              Messages to Events Part I" 
                              [read
                              article] |  
                            | 
                                
                                  |  | 
                                      
                                        | The
                                          purpose of this article is to
                                          introduce the basic constructs of a
                                          VCL application from an API point of
                                          view. 
                                          Mastery of the Windows API is
                                          surely not a prerequisite here. 
                                          As such, many of the
                                          presentations of this first article
                                          will be preceded by a high-level
                                          introduction of the underlying API
                                          methods. The intent here is introduce
                                          the inner workings of the TApplication
                                          and TWinControl
                                          classes from an API point of view; a
                                          look “under the hood” if you
                                          will. [read
                                          more...]
 |  |  |  |  
                      | 
                          
                            | "From
                              Messages to Events Part II" 
                              [read
                              article] |  
                            | 
                                
                                  |  | 
                                      
                                        | In
                                          the previous article of this series we
                                          discussed the trail of member
                                          functions that a message traverses,
                                          and now we have examined how specific
                                          messages can be handled. 
                                          Let us now make the association
                                          between these messages and their
                                          corresponding VCL events. [read
                                          more...]
 |  |  |  |  |  |  |  
          | 
 
              
                | VCL
                  Mini FAQ |  
                | 
                    
                      | The VCL Mini FAQ is provided to supplement the user-supported
                        cppbuilder.vcl.components.using newsgroup.  For convenience, it is
                        divided into separate sections according to the following categories: 
 
                          
                            | Part
                              1:   Application, SDI, and
                              MDI  
                              [go!] |  
                            | Part 2:   Common Controls  
                              [go!] |  
                            | Part 3:   Standard Controls  
                              [go!] |  
                            | Part 4:   VCL-specific Controls  
                              [go!] |  
                            | Part 5:   Other Resources  
                              [go!] |  |  
                    
                      | Download
                                  the entire  VCL Mini FAQ [here].
 |  |  |  
          | 
 |  |