Delphi Programming Guide
Delphi Programmer 

Menu  Table of contents
Bookmark and Share

Part I - Foundations
  Chapter 1 Ц Delphi 7 and Its IDE
  Chapter 2 Ц The Delphi Programming Language
  Chapter 3 Ц The Run-Time Library
  Chapter 4 Ц Core Library classes
  Chapter 5 Ц Visual Controls
  Chapter 6 Ц Building the User Interface
  Chapter 7 Ц Working with Forms
Part II - Delphi Object-Oriented Architectures
  Chapter 8 Ц The Architecture of Delphi Applications
  Chapter 9 Ц Writing Delphi Components
  Chapter 10 Ц Libraries and Packages
  Chapter 11 Ц Modeling and OOP Programming (with ModelMaker)
  Chapter 12 Ц From COM to COM+
Part III - Delphi Database-Oriented Architectures
  Chapter 13 Ц Delphi's Database Architecture
  Chapter 14 Ц Client/Server with dbExpress
  Chapter 15 Ц Working with ADO
  Chapter 16 Ц Multitier DataSnap Applications
  Chapter 17 Ц Writing Database Components
  Chapter 18 Ц Reporting with Rave
Part IV - Delphi, the Internet, and a .NET Preview
  Chapter 19 Ц Internet Programming: Sockets and Indy
  Chapter 20 Ц Web Programming with WebBroker and WebSnap
  Chapter 21 Ц Web Programming with IntraWeb
  Chapter 22 Ц Using XML Technologies
  Chapter 23 Ц Web Services and SOAP
  Chapter 24 Ц The Microsoft .NET Architecture from the Delphi Perspective
  Chapter 25 Ц Delphi for .NET Preview: The Language and the RTL
  Appendix A Ц Extra Delphi Tools by the Author
  Appendix B Ц Extra Delphi Tools from Other Sources
  Appendix C Ц Free Companion Books on Delphi
  List of Figures    
  List of tables    
  List of Listings    
  List of Sidebars  

Previous Section Next Section

Customizing the DBGrid Component

In addition to writing new, custom, data-aware components, Delphi programmers commonly customize the DBGrid control. The goal for the next component is to enhance the DBGrid with the same kind of custom output I used for the RecordView component, directly displaying graphic and memo fields. To do this, the grid needs to make the row height resizable, to allow space for graphics and a reasonable amount of text. You can see an example of this grid at design time in Figure 17.4.

Click To expand
Figure 17.4: An example of the MdDbGrid component at design time. Notice the output of the graphics and memo fields.

Although creating the output was a simple matter of adapting the code used in the record viewer component, setting the height of the grid cells ended up being a difficult problem to solve. The lines of code for that operation may be few, but they cost me hours of work!


Unlike the generic grid used earlier, a DBGrid is a virtual view on the dataset—there is no relation between the number of rows shown on the screen and the number of rows of data in the dataset. When you scroll up and down through the data records of the dataset, you are not scrolling through the rows of the DBGrid; the rows are stationary, and the data moves from one row to the next to give the appearance of movement. For this reason, the program doesn't try to set the height of an individual row to suit its data; it sets the height of all the data rows to a multiline height value.

This time the control doesn't have to create a custom data link, because it is deriving from a component that already has a complex connection with the data. The new class has a new property to specify the number of lines of text for each row and overrides a few virtual methods:

  TMdDbGrid = class(TDbGrid)
    FLinesPerRow: Integer;
    procedure SetLinesPerRow (Value: Integer);
    procedure DrawColumnCell(const Rect: TRect; DataCol: Integer;
      Column: TColumn; State: TGridDrawState); override;
    procedure  LayoutChanged; override;
    constructor Create (AOwner: TComponent); override;
    property LinesPerRow: Integer
      read FLinesPerRow write SetLinesPerRow default 1;

The constructor sets the default value for the FLinesPerRow field. Here is the set method for the property:

procedure TMdDbGrid.SetLinesPerRow(Value: Integer);
  if Value <> FLinesPerRow then
    FLinesPerRow := Value;

The side effect of changing the number of lines is a call to the LayoutChanged virtual method. The system calls this method frequently when one of the many output parameters changes. In the method's code, the component first calls the inherited version and then sets the height of each row. As a basis for this computation, it uses the same formula as the TCustomDBGrid class: The text height is calculated using the sample word Wg in the current font (this text is used because it includes both a full-height uppercase character and a lowercase letter with a descender). Here's the code:

procedure TMdDbGrid.LayOutChanged;
  PixelsPerRow, PixelsTitle, I: Integer;
  inherited LayOutChanged;
  Canvas.Font := Font;
  PixelsPerRow := Canvas.TextHeight('Wg') + 3;
  if dgRowLines in Options then
    Inc (PixelsPerRow, GridLineWidth);
  Canvas.Font := TitleFont;
  PixelsTitle := Canvas.TextHeight('Wg') + 4;
  if dgRowLines in Options then
    Inc (PixelsTitle, GridLineWidth);
  // set number of rows
  RowCount := 1 + (Height - PixelsTitle) div (PixelsPerRow * FLinesPerRow);
  // set the height of each row
  DefaultRowHeight := PixelsPerRow * FLinesPerRow;
  RowHeights [0] := PixelsTitle;
  for I := 1 to RowCount - 1 do
    RowHeights [I] := PixelsPerRow * FLinesPerRow;
  // send a WM_SIZE message to let the base component recompute
  // the visible rows in the private UpdateRowCount method
  PostMessage (Handle, WM_SIZE, 0, MakeLong(Width, Height));

Font and TitleFont are the grid defaults, which can be overridden by properties of the individual DBGrid column objects. This component currently ignores those settings.

The difficult part of this method was getting the final statements right. You can set the Default-RowHeight property, but in that case the title row will probably be too high. First I tried setting the DefaultRowHeight and then the height of the first row, but this approach complicated the code used to compute the number of visible rows in the grid (the read-only VisibleRowCount property). If you specify the number of rows (to avoid having rows hidden beneath the lower edge of the grid), the base class keeps recomputing it. Here's the code used to draw the data, ported from the RecordView component and adapted slightly for the grid:

procedure TMdDbGrid.DrawColumnCell (const Rect: TRect; DataCol: Integer;
  Column: TColumn; State: TGridDrawState);
  Bmp: TBitmap;
  OutRect: TRect;
  if FLinesPerRow = 1 then
    inherited DrawColumnCell(Rect, DataCol, Column, State)
    // clear area
    Canvas.FillRect (Rect);
    // copy the rectangle
    OutRect := Rect;
    // restrict output
    InflateRect (OutRect, -2, -2);
    // output field data
    if Column.Field is TGraphicField then
      Bmp := TBitmap.Create;
        Bmp.Assign (Column.Field);
        Canvas.StretchDraw (OutRect, Bmp);
    else if Column.Field is TMemoField then
      DrawText (Canvas.Handle, PChar (Column.Field.AsString),
        Length (Column.Field.AsString), OutRect, dt_WordBreak or dt_NoPrefix)
    else // draw single line vertically centered
      DrawText (Canvas.Handle, PChar (Column.Field.DisplayText),
        Length (Column.Field.DisplayText), OutRect,
        dt_vcenter or dt_SingleLine or dt_NoPrefix);

In this code you can see that if the user displays a single line, the grid uses the standard drawing technique with no output for memo and graphic fields. However, as soon as you increase the line count, you'll see better output.

To see this code in action, run the GridDemo example. This program has two buttons you can use to increase or decrease the row height of the grid, and two more buttons to change the font. This is an important test because the height in pixels of each cell is the height of the font multiplied by the number of lines.

Previous Section Next Section



Clever Internet Suite

»нтернет-компоненты Clever Internet Suite Ч набор компонентов дл€ Delphi/C++Builder, позвол€ющих реализовать обмен данными по сети в вашем приложении. — помощью Clever Internet Suite вы можете реализовать различные функции дл€ работы в сети интернет: скачивание файлов, отправка данных, введенных пользователем, рассылка и получение почты, использовать клиенты HTTP, FTP, SMTP, POP3, IMAP и NNTP; серверы SMTP, POP3, IMAP и FTP и многое другое.

Copyright © 2004-2018 "Delphi Sources". Delphi Programming Guide
√руппа ¬ онтакте   Facebook   —сылка на Twitter