Home	Products	Support	Services	Shop	Company

Products > GRID

The Grid Control

• Contents
• Lcc grid
  • The default user interface
    • Keyboard
    • Mouse
• Programming interface
  • Creating a grid
  • Setting the data of the grid
  • Getting the data from the grid
  • Saving the data in the grid
  • Special data output
  • The virtual rows
  • Managing the selection
  • Getting state information from the grid
  • Hiding or moving columns
  • Adding or deleting columns or rows
  • The undo functionality
  • Controlling user input
    • Establishing the callback
    • A simple filter
  • Customizing the grid
    • Modifying the drawing of a cell
    • Modifying the aspect of the grid lines
    • Modifying the grid fonts
    • Modifying the keyboard interface
    • Getting all window messages
  • Modifying the mouse interface
  • Managing the tool-tips
  • Enumerating cells
  • Using EnumGrid to implement a search function
  • Properties
  • Sorting Columns
  • The programming examples
• Function index

Lcc grid

Lcc grid is a control that allows you to quickly display tabular data. The grid has two modes:

• As a control window within another window.
• As a standalone application.

As a standalone application, the grid will create a standalone window, open a frame with a menu, where the user can edit the data if wished, and save it to disk. The command line parameters are explained below. The general logical outline of a table looks like this :

The column titles and the row titles are predefined as numbers from 1 to the number of columns or rows.

It is possible to change the column titles to any string, but not the row titles. Top of page lcc-win32 main page Products main page

The default user interface

Left click selects a cell. If it is in a column title, it will select a column. If it is in a row title it will select a row.

Double click opens a cell for editing. When editing, Esc means abort the editing, return means validate entry.

Left click in a column title boundary allows the user to resize a column.

Right click in a column will open a context menu for sorting a column.

Top of page lcc-win32 main page Products main page

Programming interface

Creating a grid

   void *newtab, *Database;
   newtab=0;
   if (NULL != (Database = GridOpenDatabase(hwnd, DSNname))) {
      if (GridSelectTable(hwnd, Database)) {
         newtab = LoadODBC(Database,hwndChildMdi);
      }
   }
   if (newtab == NULL) {
      // Close the database if we dont choose a table
      // or if it is not readable
      GridCloseDatabase(Database);
   }

When the grid is destroyed, generally when you close the window that contains it, all elements are correctly closed. You can explicitly destroy the table with :

int DestroyTable(void *tab);

Note that all functions use indexes that are zero based : the first column is always zero and runs until the number of columns minus one, the first row is always zero and runs until the number of rows minus one.

Top of page lcc-win32 main page Products main page

Setting the data of the grid.

Getting the data from the grid.

Saving the data in the grid.

<TABLE>
Number-of-rows="68"
Number-of-columns="10"
<COLUMN-TITLES>
Column0Title="name"
Column1Title="name"
...
</COLUMN-TITLES>
<ROW-TITLES>
Similar layout to column titles: RowX="NAME"
</ROW-TITLES>
<ROW0>
Cell0 "AdjustColumnWidth"
Cell1 "gridresize.c"
Cell2 "37"
...
</ROW0>
Follows the other rows
</TABLE>

Special data output.

The virtual rows.

Managing the selection.

int SetStatusLine(void *tab,int row,int col)
{
    char buf[128];
                
    if (row == -1)
       wsprintf(buf,"col %d",col+1);
    else if (col == -1)
        wsprintf(buf,"line %d",row+1);
    else
        wsprintf(buf,"line %d col %d",row+1,col+1);
    UpdateStatusBar(buf,0,0);
    return 0; // Accept the change!
}

Getting state information from the grid.

typedef struct {
    int AreaCode; 
    int col;      
    int row;
    int x; // point coordinates
} GRID_HITTEST;

Hiding or moving columns.

Adding or deleting columns or rows.

The undo functionality.

Controlling user input.

• When the editing process starts the callback is called. If it returns a non-zero result, the editing process will stop. No edit window will be shown.
• When each character of text is keyed in by the user the callback will be notified. If it returns a non-zero result the character will be discarded.
• When the user presses return or the editing process is otherwise finished (by pressing the tab key for instance), the callback is called again. If it returns a non-zero result, the contents of the cell will be left untouched.
• If the user presses the Esc key, the callback will receive a notification but the contents of the editing process will be discarded anyway.

typedef struct {
    void *table;
    HWND hControl;// Contains Edit or Combo handle when opened
    HWND hControlEdit;
    HWND hControlCombo;
    int row;      // Will be always equal to the selected row
    int col;      // Will be always equal to the selected column
    int character;// Character typed in
    int flags;     // Type of event
} GRID_EDIT_PARAMS;

int numericFilter(GRID_EDIT_PARAMS *params)
{
    if (0 == (params->flags & GRIDEDIT_CHAR))
        // If the event is not a
        //   character input event, just go on.
        return 0;
    // Accept digits
    if (params->character >= '0' &&
        params->character <= '9')
        return 0;
    // accept the point
    if (params->character == '.')
        return 0;
    // discard everything else
    return 1;
}

Customizing the grid.

typedef struct {
     void *Table;// The table you are drawing in
     int row;    // the row
     int col;    // The column
     HDC hDC;    // The device context
     RECT rc;    // The coordinates of the cell's rectangle
     int selected;// Whether the cell is selected or not
} GRID_DRAW_PARAMS;

• Table : Will be set to the handle of the table.
• hDC : The device context.
• row : Will be set to the row number of the row just below the horizontal line you should draw. If you should draw a vertical line this will be -1.
• col : Will be set to the column number of the column at the right of the vertical line that you should draw, or -1 if you should draw an horizontal line.
• selected : Will always be zero.
• The rectangle will contain the coordinates of the starting point, in the top left members, and the coordinates of the ending point in the right, bottom members.

LRESULT MyGridProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
    if (msg == WM_CLOSE) {
        int r = MessageBox(hwnd,
           "Really quit?" "Grid", MB_OK|MB_CANCEL);
        if (r == MB_OK)
            return 0;
    }
    return CallWindowProc(OriginalFn,msg,wParam,lParam);
}

FARPROC OriginalFn;
HWND GridWindow = GetGridWindow(table1);

OriginalFn = (FARPROC)GetWindowLong(GridWindow,GWL_WNDPROC);
SetWindowLong(GridWindow,GWL_WNDPROC,MyGridProc);

Modifying the mouse interface.

Managing the tool-tips.

Enumerating cells.

Using EnumGrid to implement a search function.

typedef struct {
   char *str; // String to search
   int flags; // case sensitive, regular expression, etc
   int row; // Here the callback stores its result
   int col;
} FINDPARAMETERS;

int findstr(int row,int col,char *data,LPARAM lParam)
{
   FINDPARAMETERS *p = (FINDPARAMETERS *)lParam;
         
   // Note that data can be NULL if the cell has never been assigned
   if (data && strstr(p->str,data)) {
      p->row = row;
      p->col = col;
      // We stop enumerating at the first cell that matches
      return 0;
   }
   // Continue the enumeration.
   return 1;
}

int SearchGrid(void *tab,char *str,int flags)
{
   FINDPARAMETERS fp;
         
   fp.str = str;
   fp.flags = flags;
   fp.row = fp.col = -1;
   EnumGrid(tab,findstr,(LPARAM)&fp);
   if (fp.row != -1 && fp.col != -1) {
      SelectCell(tab,fp.row,fp.col);
      return 1;
   }
   return 0; // Nothing was found
}

Properties.

Sorting Columns.

#include <math.h>
static int invertSortFlipFlop;
static int comparenumbers(const void *n1,const void *n2)
{
     double delta,d1,d2;
     // Note this casts !
     char *p1 = *(char **)n1;
     char *p2 = *(char **)n2;
                 
     //Handle the case where the cell is empty and the
     // pointer to its data is NULL.
     if (p1 == NULL)
          d1 = 0.0;
     else
          d1 = atof(p1);
     if (p2 == NULL)
          d2 = 0.0;
     else
          d2 = atof(p2);
     delta = d1 - d2;
     if (invertSortFlipFlop) {
          delta = -delta;
     }
     if (delta < 0.0)
          return -1;
     else if (delta > 0.0)
          return 1;
     return 0;
}

The programming examples.

Function index