Win32Del

Topics for Win32 & Delphi Training

C.Hanish Menon
1998
Status: INCOMPLETE

Differences between C++ and Object Pascal

Semantic

Object Reference Model & C++'s lets say classic model
Access Specifiers & Classes
Include & Uses
Constructors & Destructors
Virtual functions (Virtual/Dynamic & Override)
Multiple Inheritance
Class Methods & Class Data (Static of C++).
Operator Overloading

Syntactic

OOPS as implemented in Object Pascal

Units & Classes & Friends
Private, Protected, Public & Published
Properties and Get & Set Methods
Single Rooted Hierarchy in Delphi
Object Pascal & Component Development
Conversion (strict) & Coercion (variants)

Windows & Delphi

OS & Computer basics.

The 32 bit platform
Processes & Threads
Message Handling
Memory management
Registering user defined Window Classes & Using PRE Registered Window Classes (Controls)
Owner & Parent

TApplication

CreateHandle (The Window Class Registration & Creation)
Initialize (Misc. initializations say OleAutomation)
CreateForm
Run (The Message Loop)
Default Exception Handling
Help & Hint management
ProcessMessage
Handle, MainForm, Title, Exename, Helpfile, Icon

Window Resources & Window Resources as Delphi Components or Properties

The Dialog Box
Icons, Bitmaps as Properties of Components.
The DFM files
The Res files
ResourceString

Message handling

Window Messages to Delphi Events
Event->MainWndProc->WndProc->Dispatch->Handler
(check Dispatching Messages & the Message Handling system)

SubClassing Window Controls

The Window's way

SetWindowLong
GetWindowLong
Basing new Window Class on a Existing Window Class

The Delphi way

The WndProc (for Component Developers to Override)
The WindowProc property (for Temp Subclassing)

Multitasking & Syncronization

Keeping track of too many threads consumes CPU time; limit the number of threads per process on a Single Processor system to 16
With multiple threads updating the same resources, keep threads synchronized to avoid conflicts
Any methods that access a VCL component and update a form must only be called from within the main VCL thread

Window's way

Processes & Threads

Private Address space |Share the Address Space & Resources

Scheduling (Prioritized Multiple Round robin Queues)
Base & Dynamic Priorities
Using different Priority Classes.
CreateThread, ResumeThread, SuspendThread, SleepEx.
Synchronization (To avoid conflicts, it is necessary to synchronize access by multiple threads to shared resources. Synchronization is also necessary to ensure that interdependent code is executed in the proper sequence.)

· Synchronization objects: mutex, semaphore, and event handles

· Critical Section

· File handles

· Named pipe handles

· Console input buffer handles

· Communication device handles

· Process handles

· Thread handles

The WAIT .... Functions

Mutex & Events can also be used for interprocess synchronization.

Createxxxx,Openxxx,Waitxxxx,Releasexxxx,SetEvent or ResetEvent ....

Thread Local Storage (TLS)
ExitThread, ExitProcess, TerminateThread, TerminateProcess, ThreadFunction Returns
The alternatives Overlapped I/O & Waiting on Multiple Events

Delphi way

TThread

Execute contains the code to execute.
Synchronize provides a mechanism for the passed class method to execute as part of the main thread so a great way to allow code belonging to a thread which accesses the VCL components to execute safely, thus avoiding multithread Conflicts.
the very polite Terminate thread & Terminated property over Win32 API's TerminateThread.
Suspend, Resume & WaitFor.

BeginThread & EndThread instead of CreateThread & ...
Synchronization objects include critical sections that temporarily block the execution of other threads which may interfere with the successful completion of a section of code, and event objects that allow threads to signal when critical events have occurred.

TEvent either within a single process or between processes.
TCriticalSection & it's Enter(Acquire), Leave(Release)

Registry & Ini files

There use

VCL of Delphi

Basic classes like

TObject

The base of all classes
provides Object creation & Deletion support

Create, Destroy(V), Free
NewInstance(V) & FreeInstance(V) ( provide capabilities similar to New & Delete in C++)
If an exception escapes from a constructor, the object's destructor will be called to clean up the failed instance.

RTTI for Published properties & RTCI

ClassName, ClassParent, ClassInfo, ClassType, InheritsFrom
InstanceSize, MethodAddress & MethodName, FieldAddress

Message handling

Dispatch (nV)
DefaultHandler(V) (Called by Dispatch when no message handler available for a particular message in the class)

Basic Support for COM

TPersistent

DefineProperties (Streaming of Unpublished Data)
Assign & AssignTo (equivalent to Copy Constructor of C++)

Assign (copies the contents of the passed object to itself)
AssignTo (copies its contents to the passed object) This is automatically called by the Assign statement if it finds that the class doesn't know how to copy from the passed object.

DestinationClassObject.Assign(SourceClassObject) in turn if required calls SourceClassObject.AssignTo(DestinationClassObject)
Useful when u want to assign say the contents of the object of a class which u have written to the object of a class which is already there in the VCL or is in someone else?s library.
Override the AssignTo method to extend the functionality of the Assign method of destination objects so that they handle newly created object classes. When defining a new object class, override the Assign method for every existing object class that should be able to copy its properties to the new class. Override the AssignTo method for every existing class that the new class can copy to (from Delphi help)

TComponent

Used for Non Visual Components.
to Appear in the Component Palette, to be manipulated in the Form Designer
To Own other components & manage them
Enhanced Streaming & Filing capabilities
Basic COM capabilities & ActiveX
Methods that provide the above specified functionality

Loaded, Notification, ReadState, WriteState
InsertComponent, DestroyComponents, RemoveComponent
Validatexxxx
ComponentState, ComponentStyle
IUnknown & IDispatch

TControl

abstract base class to create Visual Controls
Controls are visual components, meaning the user can see them and manipulate them at runtime. All controls have properties, methods, and events in common that are specific to the visual aspect of controls, such as the position of the control, the cursor or hint associated with the control's window, methods to paint or move the control, and events to respond to mouse actions. (from Delphi help)
Events are added to the VCL from this point onwards, ca's WndProc implemented at this point. (check the Window Message to Delphi Event topic above)
DefaultHandler is the final opportunity for component writers to handle messages to controls. The WndProc method provides the first opportunity. Individual message methods such as Click provide additional opportunities.
Many times waiting for the Window message queque & loop to pass messages to a window or control's WindowProc may be to slow in such cases call PERFORM method to bypass the Windows message queue and send a message directly to the control's window procedure.
Call Repaint to force the control to repaint its image immediately. If the ControlStyle property includes csOpaque, the control paints itself directly. Otherwise, the Repaint method calls the Invalidate method and then the Update method so that any visible portions of controls beneath the control will be repainted as well.

TWinControl

Abstract base class for all the Windowed Controls
(from Delphi help)Windowed controls are controls that

Can receive focus while the application is running.

Other controls may display data, but the user can use the keyboard to interact with a control only if the control is a windowed control.

Can contain other controls.

A control that contains other controls is a parent. Only a windowed control can be a parent of one or more other child controls.

Have a window handle.

A window handle is the identifier provided by Windows for a window. Windowed controls can represent standard control windows provided by the Windows operating environment or custom windows defined by the application.

Newly created components are seldom derived directly from TWinControl. Base most new controls on TCustomControl, which provides a canvas and handles paint messages, or on any of several more specialized controls, such as TButtonControl, TCustomComboBox, TCustomEdit, or TCustomListBox.

TGraphicControl

These were very important in Win16 where the Resources available with Windows OS where limited. But in Win32 where the processes work in the Virtual address space, this is not a major concern, but still for the type of many Custom Controls that don't require a window handle it provides a very efficient implementation
(from Delphi help)The primary purpose of most graphic controls is to display text or graphics. Delphi controls that descend from TGraphicControl include TBevel, TImage, TPaintBox, TShape, TSpeedButton, TSplitter, and TCustomLabel, from which TDBText and TLabel are derived.
In addition to everything inherited from the abstract TControl component, TGraphicControl provides a Canvas property that provides ready access to the control's drawing surface and a virtual Paint method called in response to WM_PAINT messages received by a parent control.
Graphic controls cannot receive the input focus, nor can they contain other controls. Because a graphic control doesn't need a Windows handle, it's demand on system resources is lessened, and painting a graphic control is quicker than painting a windowed control.
To create a control that can receive input focus or contain other controls, but which needs a Canvas property and a Paint method, derive a class from TCustomControl.

TCustomControl

The abstract base for all custom window controls that usually require a Canvas to display themselves or some complex image
Standard windowed controls already "know" how to display themselves, because they are part of Windows. Thus, a button or a check box component descends directly from TWinControl. When creating original windowed controls that do not correspond to standard Windows components, derive them from TCustomControl, rather than directly from TWinControl. TCustomControl makes drawing original controls easier by providing a Canvas property to manage the drawing surface and a virtual Paint method that is called to respond to WM_PAINT messages.
When creating custom controls that don't need to receive input focus, derive them from TGraphicControl instead of TCustomControl, to avoid the overhead associated with being a windowed control. Painting a windowed control is slower than painting a graphic control.

The CustomControl Classes (TCustomxxxxx)

they act as abstract classes that provide all the general functionality required for that group of Controls as protected members, the individual implementations (i.e the derived Classes) inturn have to decide and expose the members they require based on functionality as public or published.

TCustomEdit, TCustomRichEdit,TCustomMemo
TCustomCheckBox, TCustomListBox, TCustomComboBox
TCustomGroupBox, TCustomPanel, TCustomRadioGroup
TCustomGrid, TCustomDBGrid
TCustomForm
TCustomListView, TCustomTreeView, TCustomUpDown, TCustomHotkey
TCustomStaticText

Screen object

A global variable of TScreen type instanstiated automaticaly by delphi (rather in Forms unit). It gives the current Screen state for that particular application
TScreen introduces properties that keep track of

What forms and data modules have been instantiated by the application.
The active form, and the active control within that form.
The size and resolution of the screen.
The cursors and fonts available for the application to use.

Owner & Parent properties

Owner takes care of freeing the owned components when its being freed. This relates to the Delphi part of the logic.
Parent is used to contain the children within its client area. This relates to the Windows logic.

Exception

Exception handling is the new way of structured error handling in programs
Object Pascal's exception handling support allows the program logic to remain as it should and helps seperate out the exception handling code.i.e it provides a structured means of separating normal program logic from error handling logic, greatly increasing the maintainability and robustness of applications.
In Pascal or C we used to check for the return value of functions or procedures to decide whether an exception occured or not.
But in Object pascal u have protected blocks containing the code that as to be run normally. A Exception block that will be executed in case of any exceptions & a Finally block (the CleanUp code) that will be always executed irrespective of whether an exception occurs or not.
If any error where to occur any where an exception will be raised thus getting the control to the Exception Handling block that follows the Protected Block. Here if that exception is handled, the execution continues with the code after the Exception block. However if an exception is not handled then automaticaly the block is unrolled and the next outer block is checked for to see if the exception is handled, This stack unrolling occurs till it gets handled some where, in the worst case it goes to the Application's DefaultExceptionHandler.
U have the Try Except & the Try Finally constructs to acheive this.
Exceptions are objects, So u can raise any object instance as an exception. But the Standard exception handlers only handle exception objects that belong to the Exception class or its derivatives. So its better & safer to derive custom exceptions from the Exception class or its derivate.
To Raise an exception when an error occurs U create an instance of that Exception class and raise it. Later when the exception gets handled, the handler automatically frees that instance. (internally: When an exception is raised, the exception handling logic takes ownership of the exception object. Once the exception is handled, the exception object is automatically destroyed through a call to the object's Destroy destructor. An application should never attempt to manually destroy a raised exception object)
In the Exception handler block use On [ExceptionInstanceTempVariable:]ExceptionClass do ....;
One can reraise a exception in an exception handler by using just "Raise"
Resource protection block

{ allocate the resource }

try

{ statements that use the resource }

finally

{ free the resource }

end;

We normally respond to an exception by either Cleaning Up things or by Handling the exceptions or by both.
The SysUtils unit implements exception generation and handling for the Object Pascal runtime library.
(from Delphi Help) Object Pascal uses objects to represent exceptions. This has several advantages, the key ones of which are

Exceptions can be grouped into hierarchies using inheritance
New exceptions can be introduced without affecting existing code
An exception object can carry information (such as an error message or an error code) from the point where it was raised to the point where it is handled
Using families (Exception Class Hierarchies) it is possible to handle an entire group of exceptions under one name. For example, an exception handler for EMathError will also handle EInvalidOp, EZeroDivide, EOverflow, and EUnderflow exceptions, and any user-defined exceptions that directly or indirectly derive from EMathError.
Exception classes sometimes define additional fields, methods, and properties used to convey additional information about the exception
Raising an exception in the initialization code (see "The initialization part") of a unit may not produce the desired behavior for the following reason. Exception support comes from the SysUtils unit, so a unit, which uses exceptions, must import SysUtils. With packages (see "Packages"), the startup of a program has changed. An RTL helper function is called to initialize all the units, but if an exception occurs during initialization, all initialized units wll be finalized and the exception re-raised. In this example, SysUtils will get initialized, then another unit raises the exception and SysUtils gets finalized and the exception is re-raised. System will catch the exception and since no exeption handler is installed, attempts to handle it all by itself. It does not understand SysUtils based exceptions, so it maps it to something else that it finds reasonable, usually the ctrl-c interrupt.
To determine whether the exception block of a try...except statement can handle a particular exception, the on...do exception handlers are examined in order of appearance. The first exception handler that lists the exception class or a base class of the exception is considered a match. If an exception block contains an else part, and if none of the on...do exception handlers match the exception, the else part is considered a match. An exception block that contains only a statement list is considered a match for any exception. (To locate a handler for a given exception class, the on...do handlers are processed in order of appearance. This means that handlers for the most derived classes should be listed first.)
As long as exceptions raised in an exception handler are also handled within the exception handler, they do not affect the original exception. However, once an exception raised in an exception handler propagates beyond that handler, the original exception is lost.
If an exception is raised but not handled in the finally statement list, that exception is propagated out of the try...finally statement, and any original exception is lost. (It is strongly recommended that a finally statement list always handle all local exceptions, so as to not disturb the propagation of an external exception.)

TStream

An abstract class for all Delphi Streams. One of the best methods for working with Memory & Files.
(from Delphi help)

Use specialized stream objects to read from, write to, or copy information stored in a particular medium. Each descendant of TStream implements methods for transferring information to and from a particular storage medium, such as a disk file, dynamic memory, and so on. In addition to methods for reading, writing, and copying bytes to and from the stream, stream objects permit applications to seek to an arbitrary position in the stream. Properties of TStream provide information about the stream, such as its size and the current position in the stream.
TStream also introduces methods that work in conjunction with components and filers for loading and saving components in simple and inherited forms. These methods are called automatically by global routines that initiate component streaming. They can also be called directly to the initiate the streaming process. Note, however, that component streaming always involves two additional objects:

A component object that is passed as a parameter to the stream's methods.
A filer object that is automatically created by the stream, and associated with the stream.

As an abstract class, TStream cannot be instantiated. Descendant stream objects, such as memory and file streams used for component streaming are created automatically by the global functions ReadComponentRes and WriteComponentRes. For streaming other kinds of information, choose a descendent class according to the specific data and storage needs.

Databases in General

what is a DBMS
Client/ Server architecture
RDBMS

SQL
Domains
Triggers
Constraints
StoredProcs
Generators
Events
Transactions

Database access in Delphi

The Layered Approach (providing flexiblility to change any one layer without affecting the others a lot)

Database Server (SQL or Flat file Databases like DBase, Paradox, ...)
[ BDE (in turn Native Drivers (SQL Links) or ODBC) ]
DataSet (BDE based on Independent Dataset)

TDataset
TBDEDataset (TTable, TQuery, TStoredProc)

BDEAliases provide a convinient way of specifying the type of Database, its location, and associated parameters. U can easily change over to another type of database or to another database with out requiring to modify the BDE based applications usually.
BDE allows one to access the Database either as FlatTable or as a SQL Result set using TTable & TQuery Components. Of which TQuery is the flexible & powerful one.
TStoreproc is useful for working with Servers that support Stored procedures at the server end.

DataSource
Data Aware Controls

TDatabase & TSession
Session Object
Direct access to InterBase (IB API)

COM & Delphi

Version Control Systems

Delphi applications

General Application that shows the use of Properties & Events to interconnect different components and get some job done.
Database Application that introduces the Layered approach to Database access in Delphi.