wZeeGrid

    Dark Mode
Search:
Group by:

A grid control that allows data to be displayed and edited. Needs ZeeGrid.dll or ZeeGridx64.dll in the same directory as your executable.

Appearance:
Licence:

ZeeGrid is made available free-of-charge for any application development. You are free to redistribute the binary file ZeeGrid.DLL and/or ZeeGridx64.DLLwith your application, and use the message header file ZeeGrid.h or any derivative thereof, provided all copyright information remains unaltered. You may not publish, in any form, instructions, manuals, or tutorials on ZeeGrid usage. This only relates to ZeeGrid instructions, manuals, or tutorials in a development sense. ZeeGrid usage may be included in your own application instructions as it pertains to the user's view and interaction with ZeeGrid. Just to clarify; Discussion, code snippets, examples of ZeeGrid usage on user groups is fine. Writing and publishing an article or book such as "Using ZeeGrid in Win32 Applications" is not.

I do request that if ZeeGrid is used in a commercial or publicly distributed application, a mention of ZeeGrid and my name (David Hillard) be put in your Help/About dialog. I would appreciate you letting me know what type of application ZeeGrid is being used in, and what language/platform was used in its development. It would also be interesting if you'd let me know what part of the world you're in. It would be cool to make a map graphic and put it on this site showing world-wide usage of ZeeGrid.

Copyright:

ZeeGrid Copyright(C) 2002-2015
by David Hillard
http://www.kycsepp.com/
email: david@kycsepp.com

Superclass:wControl
Events:wCommandEvent
wCommandEventDescription
wEvent_ZeeGridButtonPressedWhen the user clicks on a cell having a button data type.
wEvent_ZeeGridCellClickedWhen the mouse is left clicked on any data cell.
wEvent_ZeeGridColumnMovedWhen the column display order is changed by the user.
wEvent_ZeeGridCursorCellChangedWhen the cursor cell is changed.
wEvent_ZeeGridDeleteWhen the delete key is pressed inside the wZeeGrid control that has keyboard input.
wEvent_ZeeGridDoubleClickFixedColumnWhen the user double clicks a fixed column cell.
wEvent_ZeeGridDoubleClickReadOnlyWhen the user double clicks on a read only column cell.
wEvent_ZeeGridEditCompleteWhen the user finishes editing a cell, after ZeeGrid writies to the cell.
wEvent_ZeeGridEditEndWhen the user finishes editing a cell, before ZeeGrid writes to the cell.
wEvent_ZeeGridF1When the F1 key is pressed while wZeeGrid has focus.
wEvent_ZeeGridF2When the F2 key is pressed while wZeeGrid has focus.
wEvent_ZeeGridF3When the F3 key is pressed while wZeeGrid has focus.
wEvent_ZeeGridF4When the F4 key is pressed while wZeeGrid has focus.
wEvent_ZeeGridF5When the F5 key is pressed while wZeeGrid has focus.
wEvent_ZeeGridF6When the F6 key is pressed while wZeeGrid has focus.
wEvent_ZeeGridF7When the F7 key is pressed while wZeeGrid has focus.
wEvent_ZeeGridF8When the F8 key is pressed while wZeeGrid has focus. only if self.enableToolBarToggle(false)
wEvent_ZeeGridGotFocusWhen the wZeeGrid recieves keyboard input focus.
wEvent_ZeeGridInsertWhen the insert key is pressed while wZeeGrid has focus.
wEvent_ZeeGridLoadComboWhen the user begins editing a cell that has edit attribute 2.
wEvent_ZeeGridLostFocusWhen the wZeeGrid loses keyboard focus.
wEvent_ZeeGridMouseMoveWhen the mouse is moved over the wZeeGrid.
wEvent_ZeeGridPasteCompleteWhen paste from the clipboard is complete.
wEvent_ZeeGridRightClickWhen the user has right clicked on the wZeeGrid data area.
wEvent_ZeeGridRowSelectedWhen the user selects a row by clicking in the row numbers column.
wEvent_ZeeGridSortWhen the user has double clicked on a column header before the sort operation takes place.
wEvent_ZeeGridSortCompleteWhen the sort operation has completed taking place.

Cell COLOR Attribute

Every ZeeGrid cell as a foreground (FCOLOR) and background (BCOLOR) color attribute. The ZeeGrid title (cell index 0) and the column headers can only make use of the foreground color attribute.

Every ZeeGrid control holds a 128 color palette that contains the RGB values of 128 color entries. Colors 0..19 are predefined by ZeeGrid and are always available for use, but cannot changed. Palette colors 20..127 can be defined and changed by the programmer using the self.setColor() function.

The ZeeGrid message functions to set cell background or foreground colors, use color parameters that are indexes into the ZeeGrid color palette. This way, a sufficient number of colors can be used in the grid cells, and only require 2 bytes of memory storage to define both the foreground (text) color, and the background color of the cell.

The color palette entries are defined as follows:

Color IndexColorDescription
0 RGB(0, 0, 0)Black
1 RGB(0, 0, 255)Blue
2 RGB(0, 255, 0)Green
3 RGB(0, 255, 255) Auqua
4 RGB(255, 0, 0) Red
5 RGB(255, 0, 255) Magenta
6 RGB(255, 255, 0) Yellow
7 RGB(255, 255, 255) White
8 GetSysColor(COLOR_BTNFACE)Color of system button face
9 GetSystColor(COLOR_BTNSHADOW)Color of system button shadow
10GetSysColor(COLOR_HIGHLIGHT)Color of system button highlight
11GetSysColor(COLOR_HIGHLIGHTTEXT)Color of system text highlight
12GetSysColor(COLOR_INFOBK)Color of system tooltip background
13GetSysColor(COLOR_INFOTEXT);Color of system tooltip text
14RGB(0, 255, 255)Used for mark text - normal columns
15RGB(0, 196, 196)Used for mark text - fixed columns
16RGB(0, 0, 0)Used for mark text foreground
170 (NULL_BRUSH)For using with bitmap background
180Reserved for future use
190Reserved for future use
20 > 127User Defined Colors

By default, every cell has a foreground color of black and a background color of white.

It is possible to animate ZeeGrid colors by manipulating the ZeeGrid color palette entries in response to a WM_TIMER message.

ZeeGrid procs that relate to colors:

Cell Edit Attribute

Every ZeeGrid cell has an edit attribute. The cell edit is a numeric value that signifies the the cell's editing mode and are defined as follows:

Value
0ReadOnly - Cannot be edited
1Editable with an edit control
2Editable with a droplist combobox
3BOOLEAN editable by double-clicking
4Date edit with date picker common control

The only valid values are 0..4. The ZeeGrid title (cell index 0) and the column header cells are never editable. These cells can only be changed programmatically.

Unless you change the default edit (setDefaultEdit) cells are created with an edit value of 0, or ReadOnly.

Cells with an edit value of 1 or 2 can be edited by double-clicking the cell, or beginning typing when the ZeeGrid cursor is over the cell.

Cells with an edit value of 3 are edited by double-clicking the cell. This will toggle the cell type from 0 to 1 (FALSE to TRUE), or 1 to 0 (TRUE to FALSE) depending on its value before double-clicking. Editing a cell of this type can also be done with the keyboard by pressing the [Spacebar] key to toggle the cell between TRUE and FALSE.

ZeeGrid procs that relate to the edit attribute:

Cell FONT Attribute

Every ZeeGrid cell has a FONT attribute that can be set to 1 of a possible 128 fonts that are defined in the font palette.

The font palette is unique to each ZeeGrid control and holds the font handles (HFONT) of the palette entries. Fonts 0..19 are predefined by ZeeGrid and are always available for use, but cannot changed. Palette fonts 20..127 can be defined by the programmer and set using the setFont function.

The ZeeGrid message functions to set cell fonts, use font parameters that are indexes into the ZeeGrid font palette. This allows every cell to have a font from a selection of 128 possible fonts and only require 1 byte of memory for the storage of the cell font attribute.

The predefined fonts are as follows:

Font NumberDescription
0Small variable pitch normal
1Small variable pitch bold
2Medium variable pitch normal (default)
3Medium variable pitch bold
4Large variable pitch normal
5Large variable pitch bold
6Small fixed pitch normal
7Small fixed pitch bold
8Medium fixed pitch normal
9Medium fixed pitch bold
10Large fixed pitch normal
11Large fixed pitch bold
12Undefined; reserved for future use
13Undefined; reserved for future use
14Undefined; reserved for future use
15Undefined; reserved for future use
16Undefined; reserved for future use
17Undefined; reserved for future use
18Undefined; reserved for future use
19Undefined; reserved for future use
20 > 127User defined

If a font is set with the setFont function, it is the application's responsibility to keep the handle to the font valid throughout the life of the ZeeGrid. The predefined fonts are available for use in your application by using the getFont function. If your application uses a ZeeGrid font in this manner, you must keep the ZeeGrid control in existance for the entire time your application depends on the availability of the font.

ZeeGrid procs that relate to the font attribute:

Cell FORMAT Attribute

Every ZeeGrid cell has a FORMAT attribute. The format attribute determines the display format of numeric and date data.

There are two valid values for the FORMAT attribute for numeric data:

Value
0Normal numeric fashion (Default)
1Percentage, 0.1567 will display 15.67%

The number of decimal places displayed is determined by the PRECISION (setCellNumPrecision) attribute of the ZeeGrid cell. Cells with numeric data that have a precision attribute value of 0 will display as integer values.

There are five valid values for the FORMAT attribute for date data:

Value
0YYYY/MM/DD
1DD/MM/YYYY
2D/M/YYYY
3MON D, YYYY
4MONTH D, YYYY

A related attribute is the NUMWIDTH (setCellNumWidth) attribute. This value defaults to 0 and there is really no need that comes to mind where this attribute value would need to be changed. It was initially used in the ZeeGrid to left pad numeric values with spaces so that the sorting function would operate correctly. An earlier implementation of the sort function sorted by the text value of the cell. The sort operation was rewritten to sort based on type, then value, so the original purpose of the NUMWIDTH attribute is defunct now, but is still implemented in case the programmer finds the need for it.

ZeeGrid procs that relate to the format attribute:

Cell ICON Attribute

Every ZeeGrid cell has an ICON attribute. The column header cells are the only cells that cannot display an icon.

Every ZeeGrid control maintains an icon palette of 128 icon handles (HICON). There are no predefined icons.

The only special case for the ICON cell attribute is the icon attribute value of 0. An icon attribute value of 0 means that the cell does not have, and will not display, an icon. Unless the ZeeGrid default is changed (setDefaultIcon), the icon attribute of all new cells is 0, meaning no icon is displayed with the cell.

When an icon is displayed in a cell, it will be left justified against the left cell border.

The ZeeGrid message functions to set cell icons, use icon parameters that are indexes into the ZeeGrid icon palette. This allows every cell to have an icon from a selection of 127 possible icons and only require 1 byte of memory for the storage of the cell icon attribute.

Note: The built-in print function does not print icons.

ZeeGrid procs that are related to the icon attribute:

Cell JUSTIFY Attribute

Every ZeeGrid cell has a justify attribute. It is this attribute that defines the positioning of text and numberic data when it is displayed in the cell. Refer to the diagram of a cell below for justification values and their positioning. :

---------------------------------------------------------
|0                         3                           6|
|                                                       |
|1                         4                           7|
|                                                       |
|2 & 9                   5 & 10                   8 & 11|
---------------------------------------------------------

Justification values 0..8 are for single line data. These would be used in the data rows 1 and higher in the ZeeGrid. Values 9..11 are for multiple line data. Only the ZeeGrid title (cell index 0) and column header cells can use multiline text. (JUSTIFY values 9..11)

Justification values 0, 3, 6, 2, 5, and 8 can be used, but are not considered the norm. The ZeeGrid header file defines the most common justifications as follows:

ValueConstant
1LEFT_SINGLE
4CENTER_SINGLE
7RIGHT_SINGLE
9LEFT_MULTI
10CENTER_MULTI
11RIGHT_MULTI

ZeeGrid procs that are related to the justify attribute:

Cell NUMERIC Register

Every ZeeGrid cell has a NUMERIC register.

The NUMERIC register is an internal variable of type double. When a cell's numeric value is set, the value is cast to a double type and stored in this register. The text representation of this value is determined by other cell attributes and is displayed in the grid cell.

Programmatically, there are three ways to load a cell with a numeric value. The numeric value can be loaded as a text string, such as "3.14159" with setCellText. A program integer variable can be loaded with setCellInt by referencing the integer program variable with a pointer to that variable, and a program double variable can be loaded with setCellDouble by referencing the double program variable with a pointer to that variable.

Also, if the cell is editable (EDIT attribute 1), the user can enter the numeric value from the keyboard.

ZeeGrid procs that are related to the numeric register:

Cell PRECISION Attribute

Every ZeeGrid cell has a PRECISION attribute. The cell precision is a numeric value that signifies the number of decimal digits to display when that cell holds numeric data.

By default, non-integer numeric data types are displayed with 2 decimal digits. The precision attribute of a cell can be changed with the setCellNumPrecision function.

As an example, consider a cell containing a double value of 3.1415926535

By default, this value will display as 3.14 but can be changed at any time to display a different number of decimal digits. Changing a cell's precision attribute does not change the value it holds.

When numeric data is entered by the user by editing the cell contents, a determination is made when the edit function is complete as to whether that new data is text data, or numeric data. If it is determined to be numeric data, and the cell's numeric contents will be displayed with the cell's PRECISION attribute. By default, the PRECISION attribute value is set to 2. Regardless of whether or not the value entered was an integer value or a real number value, it is displayed with the number of decimal places defined by the cell's PRECISION attribute value.

If the cell's PRECISION attribute value is set to 0, the new value will display as an integer value (no decimal digits) regardless of whether the value entered was an integer value or a real number value.

When a numeric value is entered into the grid programmatically with setCellInt, the PRECISION attribute value is set to 0. When a numeric value is entered into the grid programmatically with setCellDouble, the double value is displayed with the current PRECISION attribute value for that cell.

A ZeeGrid data cell will hold the actual number entered by the user, regardless of the cell's precision setting.

When loading the ZeeGrid with data programmatically, the programmer has the option of loading the cell as text (setCellText) and letting ZeeGrid determine if it's numeric or not, or loading the cell as integer (setCellInt), or double (setCellDouble).

Each ZeeGrid cell has a single internal numeric "register" of type double. Whether the supplied value is an integer or a real number, it is cast to a double type and stored in the register. The PRECISION attribute is then used to control how the number contained in the cell's numeric register is displayed.

ZeeGrid procs that are related to the numeric attribute:

Cell RESTRICTION Attribute

The RESTRICTION attribute is not reliable. I have noticed inconsistent behavior with this attribute and will investigate. Until the issues are resolved, use this attribute at your own risk. If I cannot resolve the issues, this attribute may be dropped in a future release.

Every ZeeGrid cell has a RESTRICTION attribute. The cell RESTRICTION attribute is a numeric value that signifies the filtering that will be applied to a cell when it is being edited from the in-cell edit box.

By default, the restriction attribute is 0 for all cells. A RESTRICTION attribute value of zero means that there is no restriction for that cell.

Valid RESTRICTION attribute values are in the range of [0..4]

Restriction value meanings are:

NumberMeaning
0No Restriction
1Signed Integer
2Unsigned Integer
3Signed Double
4Unsigned Double

When numeric data is entered by the user by editing the cell contents, the RESTRICTION attribute value for the cell will determine the valid keystrokes the user may enter. For instance, if a cell is editable and has a restriction value of 3, (Signed Double) only the digits '0'..'9', '+', '-', or '.' are accepted by the edit control. Once a decimal point ('.') is entered, a second one is not allowed.

A RESTRICTION attribute value of 1 (signed integer) would only allow the digits '0'..'9'.

For signed values, the sign must be the in the first character position of the number.

ZeeGrid procs that are related to the restriciton attribute:

Cell TEXT Register

Every ZeeGrid cell has a TEXT register.

The TEXT register is an internal character pointer variable. When a cell's TEXT value is set, ZeeGrid will analyze the text to determine its data type. This type could be BOOLEAN (TRUE/FALSE), a date, text, or a numeric value. This analysis is determined by the settings of interpretBool, interpretDates, and interpretNumeric. If these settings are turned off, the text will be treated as a text string, no matter what the text string represented.

The TEXT register holds the character string that represents the actual data that is stored. If the cell holds a numeric value, the TEXT register will hold the text string that is displayed to represent that number. For example, if the numeric value stored in the cell is 3.1415926535, and the PRECISION attribute for that cell is set to 4, the TEXT register will hold the string "3.1416". Retrieving the text representation of the number from the TEXT register will likely not be equal to the numeric value stored in the NUMERIC register. To retrieve accurate numeric results, always use getCellInt or getCellDouble when getting numeric values from cells. Use getCellText to retrieve cell text.

Use getCellTextLength to first determine the length of the string when the length might be unknown. You can use the length returned to create a dynamic variable to hold the actual text with getCellText.

ZeeGrid procs that are related to the text register:

Cell TYPE Attribute

Every ZeeGrid cell has a type attribute. The cell type is a numeric value that identifies the data type held in it.

The types and are defined as follows:

NumberType
0BOOLEAN FALSE
1BOOLEAN TRUE
2Text
3Numeric
4Date
5Button
127Empty Cell

Cells with type value 0 are displayed as unchecked checkboxes.

Cells with type value 1 are displayed as checked checkboxes.

Cells with type value 2 are displayed as left justifed (by default) text.

Cells with type value 3 are displayed as right justified (by default) numeric values. Cells of this type also depend on the precision, width, and format attributes to determine how they are displayed in the ZeeGrid.

Cells with a type value 4 are displayed as right justified (by default) date format strings. The displayed format of the date can be changed with the format attribute for the cell.

Cells with a type value 5 are displayed as button controls. The text of the cell becomes the button text. When using button data types, the programmer should take care to assure that the cell is set to readonly by setting the cell's edit attribute to zero.

The value 127 is assigned and used internally to ZeeGrid. You cannot programmatically change a cell type to be 127. The only valid values that you, the programmer, can use are the values 0..5.

When a ZeeGrid column has mixed types within it and is sorted in ascending mode, it is sorted in the following order:

NumberType
0BOOLEAN FALSE
1BOOLEAN TRUE
3 & 4Numeric and Dates (low to high)
2 & 5Text and Buttons (low to high)
127Date

ZeeGrid procs that are related to the type attribute:

Types

COLORREF = DWORD
LPCOLORREF = ptr COLORREF
ZGNOTIFYSTRUCT {...}{.bycopy.} = object
  header*: NMHDR
  CONTROL*: BOOL
  SHIFT*: BOOL
  ALT*: BOOL
  vkey*: cint

wZeeGrid = ref object of wControl
  handle: HWND

Consts

wEvent_ZeeGridFirst = 32961'i32
wEvent_ZeeGridButtonPressed = 32962'i32
wEvent_ZeeGridCellClicked = 32963'i32
wEvent_ZeeGridColumnMoved = 32964'i32
wEvent_ZeeGridCursorCellChanged = 32965'i32
wEvent_ZeeGridDelete = 32966'i32
wEvent_ZeeGridDoubleClickFixedColumn = 32967'i32
wEvent_ZeeGridDoubleClickReadOnly = 32968'i32
wEvent_ZeeGridEditComplete = 32969'i32
wEvent_ZeeGridEditEnd = 32970'i32
wEvent_ZeeGridF1 = 32971'i32
wEvent_ZeeGridF2 = 32972'i32
wEvent_ZeeGridF3 = 32973'i32
wEvent_ZeeGridF4 = 32974'i32
wEvent_ZeeGridF5 = 32975'i32
wEvent_ZeeGridF6 = 32976'i32
wEvent_ZeeGridF7 = 32977'i32
wEvent_ZeeGridF8 = 32978'i32
wEvent_ZeeGridGotFocus = 32979'i32
wEvent_ZeeGridInsert = 32980'i32
wEvent_ZeeGridLoadCombo = 32981'i32
wEvent_ZeeGridLostFocus = 32982'i32
wEvent_ZeeGridMouseMove = 32983'i32
wEvent_ZeeGridPasteComplete = 32984'i32
wEvent_ZeeGridRightClick = 32985'i32
wEvent_ZeeGridRowSelected = 32986'i32
wEvent_ZeeGridSort = 32987'i32
wEvent_ZeeGridSortComplete = 32988'i32
wEvent_ZeeGridLast = 32989'i32
EF_FILENAMESUPPLIED = 0x00000001
EF_DELIMITERSUPPLIED = 0x00000002
EF_SILENT = 0x00000004
EF_NOHEADER = 0x00000008
LEFT_SINGLE = 1
CENTER_SINGLE = 4
RIGHT_SINGLE = 7
LEFT_MULTI = 9
CENTER_MULTI = 10
RIGHT_MULTI = 11
ZGM_LOADICON = 1025
ZGM_SETCELLICON = 1026
ZGM_SETROWHEIGHT = 1027
ZGM_SETCELLFONT = 1028
ZGM_SETCELLFCOLOR = 1029
ZGM_SETCELLBCOLOR = 1030
ZGM_SETTITLEHEIGHT = 1031
ZGM_SETCELLJUSTIFY = 1032
ZGM_GETCRC = 1033
ZGM_ENABLETBEDIT = 1034
ZGM_ENABLETBSEARCH = 1035
ZGM_SHOWTOOLBAR = 1036
ZGM_SHOWEDIT = 1037
ZGM_SHOWSEARCH = 1038
ZGM_GRAYBGONLOSTFOCUS = 1039
ZGM_ALLOCATEROWS = 1040
ZGM_SETAUTOINCREASESIZE = 1041
ZGM_APPENDROW = 1042
ZGM_DELETEROW = 1043
ZGM_SHRINKTOFIT = 1044
ZGM_SETRANGE = 1045
ZGM_GETRANGESUM = 1046
ZGM_SHOWTITLE = 1047
ZGM_ENABLESORT = 1048
ZGM_ENABLECOLMOVE = 1049
ZGM_SELECTCOLUMN = 1050
ZGM_DIMGRID = 1051
ZGM_SETROWNUMBERSWIDTH = 1052
ZGM_SETDEFAULTBCOLOR = 1053
ZGM_SETGRIDLINECOLOR = 1054
ZGM_SETCELLTEXT = 1055
ZGM_SETCOLWIDTH = 1056
ZGM_INSERTROW = 1057
ZGM_SHOWROWNUMBERS = 1058
ZGM_GETROWS = 1059
ZGM_REFRESHGRID = 1060
ZGM_SETDEFAULTFCOLOR = 1061
ZGM_SETDEFAULTFONT = 1062
ZGM_MERGEROWS = 1063
ZGM_SETDEFAULTJUSTIFY = 1064
ZGM_SETCELLTYPE = 1065
ZGM_SETCELLFORMAT = 1066
ZGM_SETCOLFORMAT = 1067
ZGM_SETCOLTYPE = 1068
ZGM_SETCOLJUSTIFY = 1069
ZGM_SETCOLFONT = 1070
ZGM_GETCELLINDEX = 1071
ZGM_ENABLETBMERGEROWS = 1072
ZGM_SHOWCURSORONLOSTFOCUS = 1073
ZGM_EMPTYGRID = 1074
ZGM_ENABLETBROWNUMBERS = 1075
ZGM_GETFIXEDCOLUMNS = 1076
ZGM_SETCOLFCOLOR = 1077
ZGM_SETLEFTINDENT = 1078
ZGM_SETRIGHTINDENT = 1079
ZGM_ENABLEICONINDENT = 1080
ZGM_GETROWHEIGHT = 1081
ZGM_ENABLECOLRESIZING = 1082
ZGM_GETCOLWIDTH = 1083
ZGM_SETCOLBCOLOR = 1084
ZGM_SELECTROW = 1085
ZGM_SHOWCURSOR = 1086
ZGM_SETCELLEDIT = 1087
ZGM_GETCELLEDIT = 1088
ZGM_GETCURSORINDEX = 1089
ZGM_AUTOSIZE_ALL_COLUMNS = 1090
ZGM_SETCOLUMNHEADERHEIGHT = 1091
ZGM_GETEDITEDCELL = 1092
ZGM_GOTOCELL = 1093
ZGM_SETCELLMARK = 1094
ZGM_MARKTEXT = 1095
ZGM_SETMARKTEXT = 1096
ZGM_ENABLETOOLBARTOGGLE = 1097
ZGM_HIGHLIGHTCURSORROW = 1098
ZGM_HIGHLIGHTCURSORROWINFIXEDCOLUMNS = 1099
ZGM_GETROWOFINDEX = 1100
ZGM_GETCOLOFINDEX = 1101
ZGM_GETCELLTEXT = 1102
ZGM_SETDEFAULTEDIT = 1103
ZGM_SETCOLEDIT = 1104
ZGM_SHOWGRIDLINES = 1105
ZGM_ENABLEROWSIZING = 1106
ZGM_GETGRIDWIDTH = 1107
ZGM_SETCOLUMNORDER = 1108
ZGM_ENABLETBEXPORT = 1109
ZGM_ENABLETBPRINT = 1110
ZGM_SHOWHSCROLL = 1111
ZGM_SHOWVSCROLL = 1112
ZGM_AUTOVSCROLL = 1113
ZGM_AUTOHSCROLL = 1114
ZGM_EXPORT = 1115
ZGM_COMPARETEXT = 1116
ZGM_GETEDITTEXT = 1117
ZGM_SETEDITTEXT = 1118
ZGM_COMPARETEXT2STRING = 1119
ZGM_GETMOUSEROW = 1120
ZGM_GETMOUSECOL = 1121
ZGM_SETCURSORCELL = 1122
ZGM_CURSORFOLLOWMOUSE = 1123
ZGM_GETROWSPERPAGE = 1124
ZGM_GETTOPROW = 1125
ZGM_SETTOPROW = 1126
ZGM_AUTOSIZECOLONEDIT = 1127
ZGM_SETSORTLIMIT = 1129
ZGM_SORTONCOLDCLICK = 1130
ZGM_STOPWATCH_START = 1131
ZGM_STOPWATCH_STOP = 1132
ZGM_SORTCOLUMNASC = 1133
ZGM_SORTCOLUMNDESC = 1134
ZGM_GETCOLS = 1135
ZGM_SETSORTESTIMATE = 1136
ZGM_GETCELLTYPE = 1137
ZGM_GETCELLJUSTIFY = 1138
ZGM_GETCELLFCOLOR = 1139
ZGM_GETCELLBCOLOR = 1140
ZGM_GETCELLFONT = 1141
ZGM_GETCELLMARK = 1142
ZGM_GETCELLICON = 1143
ZGM_SETROWTYPE = 1144
ZGM_SETROWJUSTIFY = 1145
ZGM_SETROWFCOLOR = 1146
ZGM_SETROWBCOLOR = 1147
ZGM_SETROWFONT = 1148
ZGM_SETROWMARK = 1149
ZGM_SETROWICON = 1150
ZGM_SETROWEDIT = 1151
ZGM_SEARCHEACHKEYSTROKE = 1152
ZGM_COMBOCLEAR = 1153
ZGM_COMBOADDSTRING = 1154
ZGM_CLEARMARKONSELECT = 1155
ZGM_SETCOLICON = 1156
ZGM_SETCOLMARK = 1157
ZGM_SETDEFAULTTYPE = 1158
ZGM_SETDEFAULTMARK = 1159
ZGM_SETDEFAULTICON = 1160
ZGM_SORTSECONDARY = 1161
ZGM_GETSORTCOLUMN = 1162
ZGM_GETCURSORROW = 1163
ZGM_GETCURSORCOL = 1164
ZGM_GETSIZEOFCELL = 1165
ZGM_GETCELLDOUBLE = 1166
ZGM_SETCELLDOUBLE = 1167
ZGM_SETDEFAULTNUMWIDTH = 1168
ZGM_SETDEFAULTNUMPRECISION = 1169
ZGM_SETCELLNUMWIDTH = 1170
ZGM_SETCOLNUMWIDTH = 1171
ZGM_SETROWNUMWIDTH = 1172
ZGM_SETCELLNUMPRECISION = 1173
ZGM_SETCOLNUMPRECISION = 1174
ZGM_SETROWNUMPRECISION = 1175
ZGM_SETCELLINT = 1176
ZGM_GETCELLINT = 1177
ZGM_INTERPRETBOOL = 1178
ZGM_INTERPRETNUMERIC = 1179
ZGM_SETCOLOR = 1181
ZGM_GETCOLOR = 1182
ZGM_SETFONT = 1183
ZGM_GETFONT = 1184
ZGM_SETPRINTPOINTSIZE = 1185
ZGM_GETROWSALLOCATED = 1186
ZGM_GETCELLSALLOCATED = 1187
ZGM_GETSIZEOFGRID = 1189
ZGM_PRINT = 1190
ZGM_SETITEMDATA = 1191
ZGM_GETITEMDATA = 1192
ZGM_ALTERNATEROWCOLORS = 1193
ZGM_UNLOCK = 1194
ZGM_QUERYBUILD = 1195
ZGM_SAVEGRID = 1196
ZGM_LOADGRID = 1197
ZGM_GETCELLTEXTLENGTH = 1198
ZGM_AUTOSIZECOLUMN = 1199
ZGM_ISGRIDDIRTY = 1200
ZGM_INTERPRETDATES = 1201
ZGM_SETCELLCDATE = 1202
ZGM_SETCELLJDATE = 1203
ZGM_GETJDATE = 1204
ZGM_GETCDATE = 1205
ZGM_GETTODAY = 1206
ZGM_SETREGCDATE = 1207
ZGM_SETREGJDATE = 1208
ZGM_GETREGDATEFORMATTED = 1209
ZGM_ISDATEVALID = 1210
ZGM_GETREGDATEYEAR = 1211
ZGM_GETREGDATEMONTH = 1212
ZGM_GETREGDATEDAY = 1213
ZGM_GETREGDATEDOW = 1214
ZGM_GETDOW = 1215
ZGM_GETDOWLONG = 1216
ZGM_GETDOWSHORT = 1217
ZGM_GETREGDATEDOY = 1218
ZGM_GETREGDATEWOY = 1219
ZGM_GETDOY = 1220
ZGM_GETWOY = 1221
ZGM_GETLASTBUTTONPRESSED = 1222
ZGM_ENABLECOLUMNSELECT = 1223
ZGM_KEEP3DONLOSTFOCUS = 1224
ZGM_SETLOSTFOCUSHIGHLIGHTCOLOR = 1225
ZGM_GOTOFIRSTONSEARCH = 1226
ZGM_GETSELECTEDROW = 1227
ZGM_GETSELECTEDCOL = 1228
ZGM_COPYCELL = 1229
ZGM_GETCOLUMNORDER = 1230
ZGM_GETDISPLAYPOSITIONOFCOLUMN = 1231
ZGM_GETCOLUMNINDISPLAYPOSITION = 1232
ZGM_SCROLLDOWN = 1233
ZGM_SCROLLUP = 1234
ZGM_SCROLLRIGHT = 1235
ZGM_SCROLLLEFT = 1236
ZGM_SETBACKGROUNDBITMAP = 1237
ZGM_ENABLECOPY = 1238
ZGM_ENABLECUT = 1239
ZGM_ENABLEPASTE = 1240
ZGM_EXPANDROWSONPASTE = 1241
ZGM_SETCELLRESTRICTION = 1242
ZGM_SETROWRESTRICTION = 1243
ZGM_SETCOLRESTRICTION = 1244
ZGM_SETDEFAULTRESTRICTION = 1245
ZGM_GETCELLRESTRICTION = 1246
ZGM_SETROWNUMBERFONT = 1247
ZGM_SETGRIDBGCOLOR = 1248
ZGM_GETCELLFORMAT = 1249
ZGM_SHOWCOPYMENU = 1250
ZGM_ADJUSTHEADERS = 1251
ZGM_ENABLETRANSPARENTHIGHLIGHTING = 1252
ZGM_GETCELLADVANCE = 1253
ZGM_SETCELLADVANCE = 1254
ZGM_SETCOLADVANCE = 1255
ZGM_SETROWADVANCE = 1256
ZGM_SETDEFAULTADVANCE = 1257
ZGM_GETCELLINTSAFE = 1258
ZGM_GETROWNUMBERSWIDTH = 1259
ZGM_SPANCOLUMN = 1260
ZGM_GETAUTOINCREASESIZE = 1261
ZGN_MOUSEMOVE = 1
ZGN_SORT = 2
ZGN_CURSORCELLCHANGED = 3
ZGN_EDITEND = 4
ZGN_RIGHTCLICK = 5
ZGN_LOADCOMBO = 6
ZGN_INSERT = 7
ZGN_DELETE = 8
ZGN_F1 = 9
ZGN_F2 = 10
ZGN_F3 = 11
ZGN_F4 = 12
ZGN_F5 = 13
ZGN_F6 = 14
ZGN_F7 = 15
ZGN_F8 = 16
ZGN_EDITCOMPLETE = 17
ZGN_DOUBLECLICKREADONLY = 18
ZGN_DOUBLECLICKFIXEDCOLUMN = 19
ZGN_SORTCOMPLETE = 20
ZGN_BUTTONPRESSED = 21
ZGN_CELLCLICKED = 22
ZGN_COLUMNMOVED = 23
ZGN_PASTECOMPLETE = 24
ZGN_GOTFOCUS = 25
ZGN_LOSTFOCUS = 26
ZGN_ROWSELECTED = 27

Procs

proc isGridEvent__(msg: UINT): bool {...}{.inline, raises: [], tags: [].}
proc adjustHeaders(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ADJUSTHEADERS message to enable or disable the adding of adjusting pixels to the top of the column headers to cause an integral number of rows to be displayed. If this setting is TRUE (enabled), the adjustment pixels are calculated and place at the top of the column header, to make the column header height make up for a partial row that might be displayed. If this setting is FALSE (disabled), the height that would be added to the column header is placed at the bottom of the grid. This will cause a small blank area to be displayed at the bottom of the grid.
Parameters:
fEnable
Value of wParam. A value of TRUE will place the adjustment height at the top of the column headers. A value of FALSE will place the adjustment height at the bottom of the grid, below the last fully displayable row.
Return Values:
This message does not return a value.
Remarks:
This setting is TRUE by default.
proc allocateRows(self: wZeeGrid; iRows: int = 2000) {...}{.raises: [], tags: [].}
Sends a ZGM_ALLOCATEROWS message to allocate memory for the specified number of rows. This only needs to be done if you expect the grid to have more than 2000 rows. This message should be sent immediately after the grid is dimensioned with ZGM_DIMGRID.
Parameters:
iRows
The value of wParam. The number of rows to allocate.
Retrun Values:
This message does not return a value
proc alternateRowColors(self: wZeeGrid; fEnable: bool; iCPIndex: int) {...}{.
    raises: [], tags: [].}
Sends a ZGM_ALTERNATEROWCOLORS message to enable or disable the displaying of odd numbered rows with the defined alternate background color.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable displaying alternate rows with a different background color. If enabled, the alternate background color is overridden by the cells background color if it is different from the default cell background color for the ZeeGrid. An option to using the BOOLEAN value of TRUE, an integer value greater than or equal to 2 can be used to specify the "spread" of the alternate rows. For instance, setting wParam to a value of 5 will set every 5th row to the color specified in lParam.
iCPIndex
The value of lParam. The color index to use for alternate rows. Valid values are in the range [0..127]. This value is ignored if fEnable is FALSE.
Return Values:
This message does not return a value.
Remarks:
Alternate row colors are disabled by default
proc appendRow(self: wZeeGrid): int {...}{.inline, discardable, raises: [], tags: [].}
Sends a ZGM_APPENDROW to append a new row at the bottom of the grid. To add a new row at a position other than at the bottom of the grid, use ZGM_INSERTROW.
Return Values:
The cell index of the first cell (column 1) in the newly appended row.
proc autoHScroll(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_AUTOHSCROLL message to enable or disable the automatic display of the horizontal scrollbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will cause the horizontal scrollbar to display if there are more columns in the grid than can be displayed onscreen. A value of FALSE will cause the horizontal scrollbar to be displayed as determined by the setting of ZGM_SHOWHSCROLL.
Return Values:
This message does not return a value.
Remarks:
Enabled by default.
proc autoSizeAllColumns(self: wZeeGrid) {...}{.raises: [], tags: [].}
Sends a ZGM_AUTOSIZE_ALL_COLUMNS message to adjust each ZeeGrid column to fit the maximum length text in each column.
Return Values:
This message does not return a value.
Remarks:
This message has the same effect on the ZeeGrid as if the user had double-clicked the right side of each column header.
proc autoSizeColOnEdit(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_AUTOSIZECOLONEDIT message to enable or disable automatic column sizing to fit data entered in an editable cell.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the automatic sizing of columns to fit data entered from an editable cell. A value of TRUE enables automatic column resizing; a value of FALSE disables automatic column resizing.
Return Values:
This message does not return a value.
Remarks:

Automatic column sizing on edit will only happen when the user finishes an edit by pressing the Return key. If a cell is being edited and the user mouse clicks into another cell, the cell that was being edited will not be autosized to fit.

Autosizing of columns on edit is enabled by default.

proc autoSizeColumn(self: wZeeGrid; iCol: int) {...}{.raises: [], tags: [].}
Sends a ZGM_AUTOSIZECOLUMN message to automatically size the specified column to fit the data contained within it.
Parameters:
iCol
The value of wParam. The column number to automatically size.
Return Values:
This message does not return a value.
proc autoVScroll(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_AUTOHSCROLL message to enable or disable the automatic display of the vertical scrollbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will cause the vertical scrollbar to display if there are more columns in the grid than can be displayed onscreen. A value of FALSE will cause the vertical scrollbar to be displayed as determined by the setting of ZGM_SHOWHSCROLL.
Return Values:
This message does not return a value.
Remarks:
Auto Vertical Scroll is enabled by default.
proc clearMarkOnSelect(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [],
    tags: [].}
Sends a ZGM_CLEARMARKONSELECT message to enable or disable the ZeeGrid behavior of clearing a marked cell when the cursor is placed on it. Cells have a MARK attribute that is set by the search function. This is normally set or cleared by the user in the toolbar search function.
Parameters:
fEnable
The value of wParam. A value of TRUE will cause marked cells to change to an unmarked state once the cursor is placed on them. A value of FALSE will keep marked cells marked even after the cursor is placed on them.
Return Values:
This message does not return a value.
proc comboAddString(self: wZeeGrid; lpszString: string = "") {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_COMBOADDSTRING message to load the in-cell droplist combo box with selection items. This is normally done in response to the ZGN_LOADCOMBO notification message after a ZGM_COMBOCLEAR.
Parameters:
lpszString
The value of lParam. The address of the string to add to the in-cell droplist combo box.
Return Values:
This message does not return a value.
proc comboClear(self: wZeeGrid; fSort: bool = true) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_COMBOCLEAR message to initialize the incell droplist combo box.
Parameters:
fSort
The value of wParam. A value of TRUE initializes the incell droplist combo to be sorted. A value of FALSE initializes an unsorted incell droplist combo. In either case, the incell droplist combo is emptied of any previous data strings.
Return Values:
This message does not return a value.
Remarks:
The ZGM_COMBOCLEAR message is sent in response to a ZGN_LOADCOMBO (wEvent_ZeeGridLoadCombo) notification message. The ZGN_LOADCOMBO notification message is sent to the application when a cell with an edit value of 2 is being edited by the user.
proc compareText(self: wZeeGrid; iCellIndex1: int; iCellIndex2: int): int {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_COMPARETEXT message to compare the display text of two cells specified by their cell indexes in wParam and lParam.
Parameters:
iCellIndex1
The value of wParam. The cell index of a cell to compare (1 of 2).
iCellIndex2
The value of wParam. The cell index of a cell to compare (2 of 2).
Return Values:
If the text of the cell pointed to by iCellIndex1 is equal to the text of the cell pointed to by iCellIndex2, the return value is zero. If the text of the cell pointed to by iCellIndex1 is less than the text of the cell pointed to by iCellIndex2, the return value is less than zero. If the text of the cell pointed to by iCellIndex1 is greater than the text of the cell pointed to by iCellIndex2, the return value is greater than zero.
proc compareText2String(self: wZeeGrid; iCellIndex: int; lpszString: string): int {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_COMPARETEXT2STRING message to compare the display text of a cell specified by the cell index in wParam and a string specified in lParam.
Parameters:
iCellIndex
The value of wParam. The cell index of a cell to compare to the text string pointed to by lpString.
lpszString
The value of lParam. A pointer to a string to compare to the text in the cell given in iCellIndex.
Return Values:
If the text of the cell pointed to by iCellIndex is equal to the string lpString, the return value is zero. If the text of the cell pointed to by iCellIndex is less than the string lpString, the return value is less than zero. If the text of the cell pointed to by iCellIndex is greater than the string lpString, the return value is greater than zero.
proc compareText2String(self: wZeeGrid; iCellIndexSource: int;
                        iCellIndexDestination: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCOPYCELL message to copy a cell specified by cell index in wParam to the cell index specified in lParam.
Parameters:
iCellIndexSource
The value of wParam. The cell index of the source cell to copy.
iCellIndexDestination
The value of lParam. The cell index of the destination cell to copy to.
Return Values:
This message does not return a value.
Remarks:
Copying a cell will copy every attribute of the source cell into the destination cell.
proc cursorFollowMouse(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [],
    tags: [].}
Sends a ZGM_CURSORFOLLOWMOUSE message to enable or disable the automatic cursor cell following of mouse movements within the ZeeGrid. This message is buggy if the client area of the grid is not completely filled with cells. I can't think of a good reason to use this, so the fact that it's buggy shouldn't matter. I recommend not using this message. The more I think about it, the less sense it makes.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the cursor following mouse movements. A value of TRUE enables cursor following the mouse; a value of FALSE disables cursor following the mouse.
Return Values:
This message does not return a value.
Remarks:
Cursor mouse following is disabled by default.
proc deleteRow(self: wZeeGrid; iRow: int) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_DELETEROW message to delete a row in the ZeeGrid. If the row specified in wParam is less than 1, or greater than the number of rows in the grid, nothing happens.
Parameters:
iRow
The value of wParam. The row number to delete.
Return Values:
This message does not return a value. 
proc dimGrid(self: wZeeGrid; columns: WPARAM; fixed_columns: LPARAM) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_DIMGRID message to dimension or redimension an existing ZeeGrid. The ZGM_DIMGRID message sets the total number of columns, number of visible columns, and the number of fixed columns in the ZeeGrid.
Parameters:
columns
Value of wParam. The LOWORD of wParam defines the number of total columns the ZeeGrid will have. The HIWORD of wParam is the number of visible columns. The number of visible columns must be greater than or equal to 0 and less than or equal to the total number of columns. If the HIWORD of wParam is 0, the number of visible columns will be equal to the total number of columns. If the LOWORD of wParam is less than 1, the LOWORD of wParam will be set to 1. All ZeeGrids must be dimensioned to have at least 1 column.
fixed_columns
Value of lParam. The number of fixed columns in the ZeeGrid. Fixed columns will not scroll off the ZeeGrid window when the ZeeGrid is scrolled horizontally. The number of fixed columns must be less than or equal to the number of visible columns specified in the HIWORD of wParam.
Return Values:
This message does not return a value.
Remarks:

If an existing and populated ZeeGrid is sent the ZGM_DIMGRID message, all existing data and allocated memory for that ZeeGrid is deleted and released back to the heap before the ZeeGrid is redimensioned.

After sending the ZGM_DIMGRID message to your ZeeGrid, it will be formatted with the number of columns specified and 0 rows.

ZeeGrid columns are defined in the ZGM_DIMGRID message and cannot be modified without issuing another ZGM_DIMGRID. Note that rows are not dimensioned. Rows are dynamically allocated as needed.

#dimension a ZeeGrid with 8 columns and no fixed columns
self.dimGrid(8,0)

#dimension a ZeeGrid with 10 columns, only 8 of which are visible and 2 fixed columns
self.dimGrid(10, 2)
proc emptyGrid(self: wZeeGrid; fEmpty: bool) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_EMPTYGRID message to empty the grid contents. This does not affect the ZeeGrid title, column headers, or column widths.
Parameters:
fEmpty
Value of wParam. A value of TRUE will delete all rows. A value of FALSE will keep all rows, but set all cells to the default values and attributes.
Return Values:
This message does not return a value. 
proc enableColMove(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLECOLMOVE message to enable or disable the users ability to move or reorder the display of columns. When enabled, the user can reorder columns by clicking in the column title to select a column, then use the left and right arrow keys to move the position of that column.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable column moving or reordering. A value of TRUE enables column moving; a value of FALSE disables column moving.
Return Values:
This message does not return a value.
Remarks:

Fixed columns cannot be moved.

Moving or reordering the display of columns does not alter the index of the cells in the ZeeGrid. If column 7 is moved to the 3rd display column, the cells in that column are still addressed as being column 7.

Column moving is enabled by default.

proc enableColResizing(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_ENABLECOLRESIZING message to enable or disable the users ability to resize columns by clicking and dragging the right side of the column header.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the users ability to resize columns. A value of TRUE enables column resizing; a value of FALSE disables column resizing.
Return Values:
This message does not return a value.
Remarks:

This message only affects the users ability to resize columns. Columns can still be sized programmatically with the ZGM_SETCOLWIDTH message.

Column resizing is enabled by default.

proc enableColumnSelect(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_ENABLECOLUMNSELECT message to enable or disable the users ability to select a column by clicking the column header.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the users ability to select a column. A value of TRUE enables column selecting; a value of FALSE disables column selecting.
Return Values:
This message does not return a value.
Remarks:
By default, column selection is enabled. Setting ZGM_ENABLECOLUMNSELECT to FALSE will let the user double-click a column to sort, but will not highlight the column data.
proc enableCopy(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLECOPY message to enable or disable the users ability to use [Ctrl+C] to copy the selected grid area to the Windows clipboard.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable copying the selected grid area to the Windows clipboard. A value of FALSE will disable copying from the ZeeGrid to the clipboard.
Return Values:
This message does not return a value.
Remarks:
Copying is enabled by default.
proc enableCut(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLECUT message to enable or disable the users ability to use [Ctrl+X] to cut the selected grid area from the ZeeGrid.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable cutting the selected grid area from the ZeeGrid. A value of FALSE will disable cutting from the ZeeGrid.
Return Values:
This message does not return a value.
Remarks:
Cutting is disabled by default. Only cells that have edit values of "1" can be cut. Cells that are cut revert to empty grid cells with default grid attributes. If copy is enabled, the selected area is copied to the Windows clipboard before the cut operation is performed on the selected cells of the ZeeGrid.
proc enableIconIndent(self: wZeeGrid; iCol: int; fEnable: bool) {...}{.raises: [],
    tags: [].}
Sends a ZGM_ENABLEICONINDENT message to enable or disable left indenting to allow for cell icons.
Parameters:
iCol
Value of wParam. The column number the apply the icon indent setting specified in lParam.
fEnable
Value of lParam. A value of TRUE will cause the left indent of all cells in the ZeeGrid to be incrememted by the height of the grid row to cause left justified text to line up in all columns even if only one cell contains an icon. A value of FALSE will cause cells without icons to left justify with left cell boundary. Cell with icons will justify left to the right boundary of the icon.
Return Values:
This message does not return a value. 
proc enablePaste(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLEPASTE message to enable or disable the users ability to use [Ctrl+V] paste from the Windows clipboard into the ZeeGrid at the cursor position.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable pasting from the Windows clipboard to the ZeeGrid at the cursor postion. A value of FALSE will disable pasting from the clipboard to the ZeeGrid.
Return Values:
This message does not return a value.
Remarks:
Pasting is disabled by default. Only cells that have edit values of "1" can be pasted to. Pasting that requires expansion of the columns in ZeeGrid will fail, resulting in a messagebox displaying that the operation could not be fully completed. A pasting operation that requires additional rows in the ZeeGrid will depend on the setting of self.expandRowsOnPaste(true).
proc enableRowSizing(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [],
    tags: [].}
Sends a ZGM_ENABLEROWSIZING message to enable or disable the users ability to adjust the row heights in the ZeeGrid. This can only be done when self.showRowNumbers(true) is set. The cell in the column header row above the row numbers is the trigger for this action. When enable row sizing is enabled the mouse cursor will change to a row resizing icon and the user can click and drag the mouse to change the row heights.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable row sizing. A value of FALSE will disable row sizing.
Return Values:
This message does not return a value. 
proc enableSort(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLESORT message to enable or disable sorting of the ZeeGrid.
Parameters:
fEnable
Value of wParam. A value of TRUE enables sorting of the ZeeGrid. A value of FALSE disables sorting.
Return Values:
This message does not return a value.
Remarks:
Sorting is enabled by default. This message only affects the users ability to sort the ZeeGrid by double-clicking in the column header.
proc enableTBEdit(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLETBEDIT message to enable or disable the edit button on the ZeeGrid toolbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable the edit button on the ZeeGrid toolbar. A value of FALSE will disable the edit button on the ZeeGrid toolbar.
Return Values:
This message does not return a value.
Remarks:
The edit button is enabled by default.
proc enableTBExport(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLETBEXPORT message to enable or disable the export button on the ZeeGrid toolbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable the export button on the ZeeGrid toolbar. A value of FALSE will disable the export button on the ZeeGrid toolbar.
Return Values:
This message does not return a value.
Remarks:
The edit button is enabled by default.
proc enableTBMergeRows(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_ENABLETBMERGEROWS message to enable or disable the merge rows button on the ZeeGrid toolbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable the merge rows button on the ZeeGrid toolbar. A value of FALSE will disable the merge rows button on the ZeeGrid toolbar.
Return Values:
This message does not return a value.
Remarks:
The merge rows button is enabled by default.
proc enableTBPrint(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLETBPRINT message to enable or disable the print button on the ZeeGrid toolbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable the print button on the ZeeGrid toolbar. A value of FALSE will disable the print button on the ZeeGrid toolbar.
Return Values:
This message does not return a value.
Remarks:
The print button is enabled by default.
proc enableTBRowNumbers(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_ENABLETBROWNUMBERS message to enable or disable the row numbers button on the ZeeGrid toolbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable the row numbers button on the ZeeGrid toolbar. A value of FALSE will disable the row numbers button on the ZeeGrid toolbar.
Return Values:
This message does not return a value.
Remarks:
The row numbers button is enabled by default.
proc enableTBSearch(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_ENABLETBSEARCH message to enable or disable the search button on the ZeeGrid toolbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable the search button on the ZeeGrid toolbar. A value of FALSE will disable the search button on the ZeeGrid toolbar.
Return Values:
This message does not return a value.
Remarks:
The search button is enabled by default.
proc enableToolBarToggle(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_ENABLETOOLBARTOGGLE message to enable or disable the users ability to toggle the display of the ZeeGrid toobar between its shown and hidden state by pressing F8.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable toolbar toggling and will toggle the toolbar on and off when the user presses F8. A value of FALSE will disable toolbar toggling.
Return Values:
This message does not return a value.
Remarks:
Toolbar toggle is enabled by default.
proc enableTransparentHighlighting(self: wZeeGrid; fEnable: bool = true) {...}{.
    raises: [], tags: [].}
Sends a ZGM_ENABLETRANSPARENTHIGHLIGHTING message to enable or disable the grid using transparent highlighting. Transparent highlighting enables the user to see cell background and foreground colors when the row is highlighted due to it being the cursor row, or because an area has been selected for the clipboard.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable transparent highlighting. A value of FALSE will use solid color highlighting.
Return Values:
This message does not return a value.
Remarks:
Transparent highlighting is enabled by default.
proc expandRowsOnPaste(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_EXPANDROWSONPASTE message to enable or disable the ZeeGrid adding additional rows to complete a clipboard paste operation.
Parameters:
fEnable
Value of wParam. A value of TRUE will let the ZeeGrid add additional rows if needed in a clipboard paste operation. A value of FALSE will cause the ZeeGrid to not add additional rows.
Return Values:
This message does not return a value.
Remarks:
Expanding rows on paste is disabled by default.
proc exportGrid(self: wZeeGrid; dwFlags: DWORD; lpszString: string) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_EXPORT message to save the ZeeGrid contents to a comma-delimited file.
Parameters:
dwFlags
The value of wParam. If this value is zero, and lParam is zero, the user is prompted for the filename to export to. Optionally, the LOWORD of this value can specify the delimiter. The HIWORD of this value can specify special flags for the export operation. See the 'Remarks' section for explaination of the flags.
lpszString
The value of lParam. If this value is zero, the user will be prompted with the save file dialog to name the exported file. If this value is a pointer to a null-terminated string, the ZeeGrid will export to the supplied filename.
Return Values:
This message does not return a value.
Remarks:
The HIWORD of wParam can be a combination of the following flags:
EF_FILENAMESUPPLIED - Filename to export to is given in lParam EF_DELIMITERSUPPLIED - LOWORD of wParam is the character to use for the delimiter, otherwise use comma. EF_SILENT - Export confirmation message is not displayed. EF_NOHEADER - The data export begins with row 1 and does not export the column header row.
proc getCDate(self: wZeeGrid; iJulianDate: int; lpszString: string): bool {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_GETCDATE message to convert a given julian date into a date string in 'YYYY/MM/DD' format.
Parameters:
iJulianDate
Value of wParam. The value of wParam. A valid julian date in the range of [1..3068037]. Julian date 1 = 'Jan 1, 1600'. Julian date 3068037 = 'Dec 31, 9999'
lpszString

The value of lParam. If the julian date supplied in wParam is valid, the julian date is converted to text in the 'YYYY/MM/DD' form and returned in the string pointed to by lParam.

The string must be previously allocated and have a minimum length of 11 characters. Failure to preallocate this string will result in undefined behavior, possibly resulting in data loss and/or program crash.

Return Values:
This message returns TRUE if the julian date is valid, otherwise it returns FALSE.
Remarks:
Preallocate the string in lParam with at least 11 characters.
proc getCellBColor(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLBCOLOR message to get the background color of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to get the background color.
Return Values:
The color palette index of the specified cell's background color.
proc getCellDouble(self: wZeeGrid; iCellIndex: int): float {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLDOUBLE message to get the double value of the specified cell.
Parameters:
iCellIndex
The ZeeGrid cell index.
lpDoubleValue
The value of lParam. A pointer to a double.
Return Values:
Returns float value of cell.
proc getCellEdit(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLEDIT message to get the edit attribute value of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to get the edit attribute value.
Return Values:
The return value is the edit attribute of the specified ZeeGrid cell. A value of 0 means that the cell is not editable, or readonly. A value of 1 means that the cell is editable with a text edit box. A value of 2 means that the cell is editable with a droplist combo box. A value of 3 means that the cell is a boolean value and is editable by double-clicking the cell to change the boolean state from TRUE to FALSE or vice versa. A value of 4 means that the cell is editable by the date picker common control.
proc getCellFColor(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLFCOLOR message to get the foreground color (text color) of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to get the foreground color.
Return Values:
The color palette index of the specified cell's foreground (text) color.
proc getCellFont(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLFONT message to get the font palette index of the font in the specified cell.
Parameters:
iCellIndex
The value of wParam. The cell index to get the cell font palette index.
Return Values:
The font palette index of the font in the specified cell.
proc getCellFormat(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLFORMAT message to get the format value of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
Return Values:
The format value of the cell specified in iCellIndex.
proc getCellIcon(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLICON message to get the icon palette index of the icon in the specified cell.
Parameters:
iCellIndex
The value of wParam. The cell index to get the cell icon palette index.
Return Values:
The icon palette index of the icon in the specified cell.
proc getCellIndex(self: wZeeGrid; iRow: int; iCol: int): int {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_GETCELLINDEX message to get the index of a cell that is being referenced by row and column.
Parameters:
iRow
The value of wParam. The ZeeGrid row number.
iCol
The value of lParam. The ZeeGrid column number.
Return Values:
The ZeeGrid cell index of the cell referenced by row and column.
proc getCellInt(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLINT message to get the integer value of the specified cell.
Parameters:
iCellIndex
The ZeeGrid cell index.
lpIntValue
The value of lParam. A pointer to a integer.
Return Values:
Returns int value of cell.
proc getCellJustify(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLJUSTIFY message to get the text justification value of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index to get the text justification value.
Return Values:
The text justification value of the cell specified in wParam.
proc getCellMark(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLMARK message to get the mark attribute of the specified cell.
Parameters:
iCellIndex
The value of wParam. The index of the ZeeGrid cell.
Return Values:
The value of the cell mark attribute.
proc getCellRestriction(self: wZeeGrid; iCellIndex: int): int {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_GETCELLRESTRICTION message to get the ZeeGrid restriction value of the referenced cell.
Parameters:
iCellIndex
The value of wParam. The index of the ZeeGrid cell.
Return Values:
The value of the cell restriction attribute.
proc getCellsAllocated(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETCELLSALLOCATED message to get the number of cells that are allocated in memory for the ZeeGrid.
Return Values:
The number of cells allocated for the ZeeGrid.
proc getCellTextLength(self: wZeeGrid; iCellIndex: int): int {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_GETCELLTEXTLENGTH message to get the length of the text string specified by the cell index.
Parameters:
iCellIndex
The ZeeGrid cell index.
Return Values:
The length of the string in the cell specified in iCellIndex.
proc getCellText(self: wZeeGrid; iCellIndex: int): string {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLTEXT message to get the display text string of the specified cell.
Parameters:
iCellIndex
The ZeeGrid cell index.
lpszString
The value of lParam. A pointer to a string.
Return Values:
This message does not return a value.
proc getCellType(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCELLTYPE message to get the ZeeGrid data type of the data in the referenced cell.
Parameters:
iCellIndex
The ZeeGrid cell index.
Return Values:
The value of the cell type attribute.
proc getColOfIndex(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCOLOFINDEX message to get the column that contains the specified cell index
Parameters:
iCellIndex
The ZeeGrid cell index.
Return Values:
The column number of the specified ZeeGrid cell index.
proc getColor(self: wZeeGrid; iCPIndex: int): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETCOLOR message to get the RGB value of the specified index of the ZeeGrid color palette.
Parameters:
iCPIndex
The value of wParam. The index of the color palette to retrieve the RGB value.
Return Values:
The RGB value of the specified index of the color palette.
proc getCols(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETCOLS to get the number of columns in the ZeeGrid.
Return Values:
This message returns the total number of columns in the ZeeGrid.
Remarks:
This message function will return the total number of columns in the ZeeGrid. Columns that have been resized to zero width and non-visible columns as specified in ZGM_DIMGRID are included in the returned value.
proc getColumnInDisplayPosition(self: wZeeGrid; iDisplayColumn: int): int {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_GETCOLUMNINDISPLAYPOSITION message to get the column in the specified dislay positon of the ZeeGrid. Since the user can reorder the display positions of the columns, this message provides a way to programmatically determine the column in a particular display position in the ZeeGrid.
Parameters:
iDisplayColumn
The value of wParam. The display position to determine the column.
Return Values:
The column in the specified display position is returned.
proc getColumnOrder(self: wZeeGrid; iElements: int; lpiArray: openArray[int]): pointer {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_GETCOLUMNORDER message to programmatically retrieve the ZeeGrid column dispay order. 
proc getColWidth(self: wZeeGrid; iCol: int): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETCOLWIDTH message to get the width of the specified column in pixels.
Parameters:
iCol
The value of wParam. The column number to get the width.
Return Values:
The width of the specified column in pixels.
proc getCRC(self: wZeeGrid; lpszString: string = ""): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETCRC message to get the CRC (cyclic redundancy checksum) value of the specified null-terminated string.
Parameters:
lpszString
Value of lParam. A pointer to a null-terminated string.
Return Values:
The CRC value of the text supplied in lParam.
proc getCursorCol(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETCURSORCOL message to get the column of the ZeeGrid cursor.
Return Values:
The column of the ZeeGrid cursor.
Remarks:
If the cursor was "lost", the return value will be -1.
proc getCursorIndex(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETCURSORINDEX message to get the cell index of the ZeeGrid cursor.
Return Values:
The return value is the cell index of the ZeeGrid cursor.
Remarks:
If the cursor was "lost", the return value will be -1.
proc getCursorRow(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETCURSORROW message to get the row of the ZeeGrid cursor.
Return Values:
The return value is the row of the ZeeGrid cursor.
Remarks:
If the cursor was "lost", the return value will be -1.
proc getDisplayPositionOfColumn(self: wZeeGrid; iColumn: int): int {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_GETDISPLAYPOSITIONOFCOLUMN message to get the dislay positon of the specified column in the ZeeGrid. Since the user can reorder the display positions of the columns, this message provides a way to programmatically determine the display position of a particular column.
Parameters:
iColumn
The value of wParam. The actual column number to determine the display position.
Return Values:
The display position of the specified column is returned.
proc getDOW(self: wZeeGrid; iJulianDate: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETDOW message to get the day of the week of the julian date specified in wParam.
Parameters:
iJulianDate
The value of wParam. The value is a valid julian date in the range of [1..3068037].
Return Values:

If the julian date specified in wParam is valid, this message returns the day of the week of that date. Otherwise, the message returns -1.

The following values are returned based on the day of the week:

2 - Sunday 3 - Monday 4 - Tuesday 5 - Wednesday 6 - Thursday 0 - Friday 1 - Saturday

proc getDOWLong(self: wZeeGrid; iDayOfWeek: int): string {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETDOWLONG message to get name of the weekday of the day of the week value specified in wParam.
Parameters:
iDayOfWeek
The value of wParam. The value is the value returned by ZGM_GETDOW or ZGM_GETREGDATEDOW.
lpszString
The value of lParam. A pointer to a null-terminated string to hold the weekday name that is returned from this message. This character string must be previously allocated with a minimum length of 10 characters. The string must be previously allocated and have a minimum length of 10 characters. Failure to preallocate this string will result in undefined behavior, possibly resulting in data loss and/or program crash.
Return Values:
This message returns TRUE if the value in wParam is a valid day of the week value in the range of [0..6], otherwise the message returns FALSE.
proc getDOWShort(self: wZeeGrid; iDayOfWeek: int): string {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETDOWLONG message to get 3-character abbreviated name of the weekday of the day of the week value specified in wParam.
Parameters:
iDayOfWeek
The value of wParam. The value is the value returned by ZGM_GETDOW or ZGM_GETREGDATEDOW.
lpszString
The value of lParam. A pointer to a null-terminated string to hold the 3-character abbreviated weekday name that is returned from this message. This character string must be previously allocated with a minimum length of 4 characters. The string must be previously allocated and have a minimum length of 4 characters. Failure to preallocate this string will result in undefined behavior, possibly resulting in data loss and/or program crash.
Return Values:
This message returns TRUE if the value in wParam is a valid day of the week value in the range of [0..6], otherwise the message returns FALSE.
proc getDOY(self: wZeeGrid; iJulianDate: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETDOY message to get the day of the year for the given julian date.
Parameters:
iJulianDate
The value of lParam. A julian date value. Valid values are in the range of [1..3068037].
Return Values:
This message returns the day of the year for the given julian date. If the julian date specified in lParam is valid, the return value will be in the range of [1..366]. If the julian date specified in lParam is not valid, this message will return 0;
proc getEditedCell(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETEDITEDCELL message to retrieve the cell index of the most recently edited cell. 
proc getEditText(self: wZeeGrid): string {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETEDITTEXT to get the text of a cell's edit box after the edit is finished, but before the text is stored in the cell.
Parameters:
iChars
The value of wParam. The number of bytes allocated for the string in lParam
lpszString
The value of lParam. A pointer to a null-terminated string to hold the contents of the cell edit control contents.
Return Values:
This message does not return a value.
proc getFixedColumns(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETFIXEDCOLUMNS message to get the number of fixed columns in the ZeeGrid.
Return Values:
The number of fixed columns in the ZeeGrid.
Remarks:
The return value will be the same value as the lParam in the ZGM_DIMGRID message function.
proc getFont(self: wZeeGrid; iFPIndex: int): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETFONT message to get the font handle (HFONT) of the specified index in the ZeeGrid font palette.
Parameters:
iFPIndex
The value of wParam. The index of the font palette to retrieve the font handle.
Return Values:
The font handle (HFONT) of the specified index of the font palette.
proc getGridWidth(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETGRIDWIDTH message to determine the width of the ZeeGrid client area in pixels.
Return Values:
The width of the client area of the ZeeGrid in pixels.
Remarks:
The returned value is the width in pixels from the left client edge of the ZeeGrid data area to the right client edge if there is no vertical scrollbar. Otherwise, it is the distance to the left edge of the vertical scrollbar.
proc getItemData(self: wZeeGrid; iCellIndex: int): int32 {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETITEMDATA message to get the user supplied 32-bit value associated with the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to get the user supplied 32-bit data value.
Return Values:
The return value is the 32-bit value associated with the specified ZeeGrid cell.
proc getJDate(self: wZeeGrid; lpszString: string): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETJDATE message to get the julian date of a date represented as a null-terminated string.
Parameters:
lpszString
The value of lParam. A pointer to a null-terminated date string. This string could be '12/28/58', '1958/12/28', '12/28/1958' or 'Dec 28, 1958' or other valid string representation of a date. Valid dates are in the range from 'Jan 1, 1600' to 'Dec 31, 9999'
Return Values:
If the date string represented in lParam is a valid date, the message will return the julian date of the text represented date. If the date string cannot be deciphered to a valid date, the message will return 0. Julian dates are valid through the range of [1..3068037]. Julian date 1 = 'Jan 1, 1600'. Julian date 3068037 = 'Dec 31, 9999'.
proc getLastButtonPressed(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETLASTBUTTONPRESSED message to get the index of the button data type cell that was last clicked.
Return Values:
The return value is the cell index of the most recently clicked button data type cell.
proc getMouseCol(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETMOUSECOL message to determine the column of the ZeeGrid that the mouse pointer is currently on.
Return Values:
The column number that the mouse pointer is currently over. The return value will only be valid when this message is sent in response to a ZeeGrid notification message about a mouse action.
Remarks:
A return value of -1 signifies that the mouse is over an area of the grid that is not a valid column. A return value of 0 signifies the mouse is over the row numbers column.
proc getMouseRow(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETMOUSEROW message to determine the row of the ZeeGrid that the mouse pointer is currently on.
Return Values:
The row number that the mouse pointer is currently over. The return value will only be valid when this message is sent in response to a ZeeGrid notification message about a mouse action.
Remarks:
A return value of -1 signifies that the mouse is over an area of the grid that is not a valid row. A return value of 0 signifies the mouse is over the column header row.
proc getRangeSum(self: wZeeGrid; iCellIndex: int): float {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETRANGESUM message to get the sum of the range that was calculated with the ZGM_SETRANGE message.
Parameters:
lpDoubleValue
The value of lParam. A pointer to a double to retrieve the range sum..
Return Values:
This message does not return a value.
proc getRegDateDay(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETREGDATEDAY message to get the day of the month of the date in the internal date register.
Return Values:
If the date in the internal date register is valid, this message returns the day of the month of that date. Otherwise, the message returns 0.
proc getRegDateDOW(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETREGDATEDOW message to get the day of the week of the date in the internal date register.
Return Values:

If the date in the internal date register is valid, this message returns the day of the week of that date. Otherwise, the message returns -1.

The following values are returned based on the day of the week:

2 - Sunday 3 - Monday 4 - Tuesday 5 - Wednesday 6 - Thursday 0 - Friday 1 - Saturday

proc getRegDateDOY(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETREGDATEDOY message to get the day of the year of the date in the internal date register.
Return Values:
If the date in the internal date register is valid, this message returns the day of the year of that date. Otherwise, the message returns 0. If the date is valid, return value will be in the range of [1..366].
proc getRegDateFormatted(self: wZeeGrid; iDateFormat: int): string {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_GETREGDATEFORMATTED message to get the specified text representation of the date in the internal date register.
Parameters:
iDateFormat
The value of wParam. Valid date format numbers are in the range of [0..4]. For example, the date 'February 3, 1965' will be returned as follows for the given formats:

0 - '1965/02/03' 1 - '02/03/1965' 2 - '2/3/1965' 3 - 'Feb 3, 1965' 4 - 'February 3, 1965

lpszString
The value of lParam. The date in the internal date register is converted to text in the specified format and returned in the string pointed to by lParam. The string must be previously allocated and have a minimum length of 19 characters. Failure to preallocate this string will result in undefined behavior, possibly resulting in data loss and/or program crash. A string of 19 characters is needed to hold the longest formatted date that could possibly be returned. That would be 'September DD, YYYY' and is 18 characters in length. One character is needed for the null termination, thus needing a length of at least 19 characters.
Return Values:
Returns the text representation of the date in internal date register.
proc getRegDateMonth(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETREGDATEMONTH message to get the month of the date in the internal date register.
Return Values:
If the date in the internal date register is valid, this message returns the month of that date. Otherwise, the message returns 0.
proc getRegDateWOY(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETREGDATEWOY message to get the week of the year of the date in the internal date register.
Return Values:
If the date in the internal date register is valid, this message returns the week of the year of that date. Otherwise, the message returns 0. If the date is valid, return values are in the range of [1..53]. Weeks begin on Sunday and end on Saturday. If the return value is 53, that day really falls in the first week of the next calendar year, but it is in the 53rd week of the year of the date in question.
proc getRegDateYear(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETREGDATEYEAR message to get the year of the date in the internal date register.
Return Values:
If the date in the internal date register is valid, this message returns the year of that date. Otherwise, the message returns 0.
proc getRowHeight(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETROWHEIGHT to get the height in pixels of the ZeeGrid data rows.
Return Values:
The height of the ZeeGrid data rows in pixels.
Renarks:
All data rows of the ZeeGrid are the same height.
proc getRowOfIndex(self: wZeeGrid; iCellIndex: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETROWOFINDEX message to get the row of the specified cell index.
Parameters:
iCellIndex
The value of wParam. The index of the ZeeGrid cell.
Return Values:
The ZeeGrid row number of the specified cell index.
proc getRows(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETROWS message to get the number of rows in the ZeeGrid.
Return Values:
The return value is the number of rows in the ZeeGrid.
Renarks:
The number of rows does not include the column header row.
proc getRowsAllocated(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETROWSALLOCATED message to get the number of rows that are allocated in memory for the ZeeGrid.
Return Values:
The number of rows allocated for the ZeeGrid.
Renarks:
A ZeeGrid might only have 30 rows of data, but could have 30 or more rows allocated in memory for additional row expansion. The ZeeGrid automatically resizes its number of allocated rows when needed to hold additional rows of data.
proc getRowsPerPage(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETROWSPERPAGE to determine the number of rows that can be displayed in the ZeeGrid without vertical scrolling.
Return Values:
The number of rows per display page. That is, the number of rows that can be displayed in the ZeeGrid without having to use the vertical scrollbar.
proc getSelectedColumn(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETSELECTEDCOL message to get the currently selected column in the ZeeGrid. If no column is selected, this message will return -1.
Return Values:
The currently selected column is returned. If no column is currently selected, the message returns -1.
proc getSelectedRow(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETSELECTEDROW message to get the currently selected row in the ZeeGrid. If no row is selected, this message will return -1.
Return Values:
The currently selected row number is returned. If no row is currently selected, the message returns -1.
proc getSizeOfCell(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETSIZEOFCELL to get the size of the data structure (in bytes) of a ZeeGrid cell.
Return Values:
The size (in bytes) of the ZeeGrid cell data structure.
Remarks:
This value multiplied by the number of cells allocated plus the size of the grid is the total number of bytes of memory required for the ZeeGrid. This does not include the memory required for the actual display contents (the text) of the cells.
proc getSizeOfGrid(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETSIZEOFGRID to get the size of the data structure (in bytes) of a ZeeGrid.
Return Values:
The size (in bytes) of the ZeeGrid data structure.
Remarks:
This is the ZeeGrid overhead for every ZeeGrid window in your application. It is this value, plus the size of the zeegrid cell * the number of cells allocated that determines the minimum amount of memory allocated to a particular ZeeGrid. This does not include the memory required to hold the text strings displayed in the cells.
proc getSortColumn(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETSORTCOLUMN to get the column that was double-clicked indicating that the user wants to sort the ZeeGrid.
Return Values:
The column number that is being double-clicked to sort.
Remarks:
This message is normally sent in response to a ZGN_SORT notification message from the ZeeGrid. Its purpose is to determine the column that is about to be sorted, so that the secondary sort column can be set programmatically. The application will recieve a ZGN_SORT notification if ZGM_SORTONCOLDCLICK is set to TRUE.
proc getToday(self: wZeeGrid): string {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETTODAY message to get the current day's julian date and string representation in 'YYYY/MM/DD' format.
Parameters:
lpszString
The value of lParam. The current date is converted to text in the 'YYYY/MM/DD' form and returned in the string pointed to by lParam. The string must be previously allocated and have a minimum length of 11 characters. Failure to preallocate this string will result in undefined behavior, possibly resulting in data loss and/or program crash.
Return Values:
This message returns TRUE if the date in the internal date register is valid, otherwise it returns FALSE.
proc getTopRow(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_GETTOPROW message retrieve the row number of the first displayed row in the ZeeGrid.
Return Values:
The row number of the first displayed (top) row in the ZeeGrid.
proc getWOY(self: wZeeGrid; iJulianDate: int): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_GETWOY message to get the week of the year for the given julian date.
Parameters:
iJulianDate
The value of lParam. A julian date value. Valid values are in the range of [1..3068037].
Return Values:
This message returns the week of the year that the given date is in. If the julian date specified in lParam is valid, the return value will be in the range of [1..53]. If the julian date specified in lParam is not valid, this message will return 0. Weeks begin on Sunday and end on Saturday. If the return value is 53, that day really falls in the first week of the next calendar year, but it is in the 53rd week of the year of the date in question.
proc goToCell(self: wZeeGrid; iCellIndex: int; bFlag: bool) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_GOTOCELL message to programmatically scroll to the specified cell.
Parameters:
iCellIndex
The value of lParam. A julian date value. Valid values are in the range of [1..3068037].
bFlag
The value of lParam. A value of TRUE will perform a horizontal scroll if needed to put the referenced cell in the first non-fixed display column of the page. A value of FALSE will only perform the vertical scroll necessary to display the specified cell on the page.
Return Values:
This message does not return a value.
proc goToFirstOnSearch(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [],
    tags: [].}
Sends a ZGM_GOTOFIRSTONSEARCH message to enable or disable the movement of the cursor to the first match when the [Enter] key is pressed after typing the string to search for in the search edit control.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the movement of the grid cursor to the first match after [Enter] is pressed from the search edit control.
Return Values:
This message does not return a value.
Remarks:
GOTO_FIRST_ON_SEARCH is disabled (FALSE) by default.
proc grayBGOnLostFocus(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [],
    tags: [].}
Sends a ZGM_GRAYBGONLOSTFOCUS message to enable or disable the graying of a ZeeGrid that has lost the keyboard input focus.
Parameters:
fEnable
Value of wParam. A value of TRUE will enable graying of the ZeeGrid background colors when it loses the keyboard input focus. A value of FALSE will display the ZeeGrid background colors as normal when the ZeeGrid loses the keyboard input focus.
Return Values:
This message does not return a value.
Remarks:
Graying of ZeeGrids that have lost the keyboard input focus is disabled by default..
proc highlightCursorRow(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_HIGHLIGHTCURSORROW message to enable or disable the highlighting of the row of the cursor.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable highlighting of the cursor row. A value of TRUE enables cursor row highlighting; a value of FALSE disables cursor row highlighting.
Return Values:
This message does not return a value.
Remarks:
If cursor row highlighting is disabled, cursor row highlighting in fixed columns (ZGM_HIGHLIGHTCURSORROWINFIXEDCOLUMNS) is disabled. Cursor row highlighting is enabled by default.
proc highlightCursorRowInFixedColumns(self: wZeeGrid; fEnable: bool = true) {...}{.
    raises: [], tags: [].}
Sends a ZGM_HIGHLIGHTCURSORROWINFIXEDCOLUMNS message to enable or disable the highlighting of the row of the cursor in fixed columns.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable highlighting of the cursor row in fixed columns. A value of TRUE enables cursor row highlighting in fixed columns; a value of FALSE disables cursor row highlighting in fixed columns.
Return Values:
This message does not return a value.
Remarks:
If cursor row highlighting (ZGM_HIGHLIGHTCURSORROW)is disabled, cursor row highlighting in fixed columns is disabled. Cursor row highlighting in fixed columns is enabled by default.
proc insertRow(self: wZeeGrid; iRow: int): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_INSERTROW message to insert a row before the specified row in the ZeeGrid. The specified row must already be present in the ZeeGrid.
Parameters:
iRow
The value of wParam. The row number to insert. This row must exist in the ZeeGrid for this message to succeed.
Return Values:
The ZeeGrid cell index of the cell in the first column of the inserted row.
proc interpretBool(self: wZeeGrid; iCol: int; fEnable: bool = true) {...}{.
    raises: [], tags: [].}
Sends a ZGM_INTERPRETBOOL message to enable or disable the interpretation of the text 'TRUE' and 'FALSE' as boolean when entered from an editable cell by the user, or programmatically entered into the cell with the ZGM_SETCELLTEXT message.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the interpretation of entered text as boolean 'TRUE' and 'FALSE'. If enabled and the text 'TRUE' is entered in a cell, ZeeGrid will display that cell as a checked checkbox. If disabled, the text will be displayed literally as 'TRUE'.
iCol
The Column number this applies to.
Return Values:
This message does not return a value.
Remarks:
Interpret boolean is enabled by default. When enabled, the entered text is converted to uppercase and tested for a match with 'TRUE' or 'FALSE'. Therefore, the text strings 'True','trUE', and 'TrUe' would all be interpreted as boolean.
proc interpretDates(self: wZeeGrid; iCol: int; fEnable: bool = true) {...}{.
    raises: [], tags: [].}
Sends a ZGM_INTERPRETDATES message to enable or disable the interpretation of text as a date when entered from an editable cell by the user, or programmatically entered into the cell with the ZGM_SETCELLTEXT message.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the interpretation of entered text as a date. If enabled and the text '12/28/58' is entered in a cell, ZeeGrid will display that cell as a date text string, for instance 'December 28, 1958', and right justify it in the cell. If disabled, the text will be displayed literally as '12/28/58'.
iCol
The Column number this applies to.
Return Values:
This message does not return a value.
Remarks:
Interpret dates is enabled by default.
proc interpretNumeric(self: wZeeGrid; iCol: int; fEnable: bool = true) {...}{.
    raises: [], tags: [].}
Sends a ZGM_INTERPRETNUMERIC message to enable or disable the interpretation of text as a numeric value when entered from an editable cell by the user, or programmatically entered into the cell with the ZGM_SETCELLTEXT message.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the interpretation of entered text as numeric values. If enabled and the text '3.145' is entered in a cell, ZeeGrid will display that cell as a right justified numeric value. If disabled, the text will be displayed as a left justified text string '3.145'.
iCol
The Column number this applies to.
Return Values:
This message does not return a value.
Remarks:
Interpret numeric is enabled by default.
proc isDateValid(self: wZeeGrid; lpszString: string): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_ISDATEVALID message to test the validity of a date represented as a null-terminated character string.
Parameters:
lpszString
The value of lParam. A null-terminated string containing the text representation of a date. This text can be in many date formats. For example, the date 12/28/1958 could be represented in string form as '1958/12/28', '12/28/58', '12/28/1958', 'Dec 28, 1958', or 'December 28, 1958' Valid dates range from 1/1/1600 to 12/31/9999. This fuction also tests for a valid number of days for a given month.
Return Values:
This message returns the julian date of the date represented in the text string in lParam if it is a valid date. If it is not a valid date, the message returns 0.
proc isGridDirty(self: wZeeGrid; fEnable: bool = false): bool {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_ISGRIDDIRTY to determine if a value or an attribute of the grid has been changed.
Parameters:
fEnable
Value of wParam. A value of TRUE resets the "DIRTY" flag. A value of FALSE leaves the "DIRTY" flag in its current state.
Return Values:
A boolean value indicating whether or not the grid is "dirty". A dirty grid means that a value or attribute of the grid has changed and a grid save operation may be necessary.
proc keep3DOnLostFocus(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [],
    tags: [].}
Sends a ZGM_KEEP3DONLOSTFOCUS message to enable or disable the changing of column headers from 3D to flat when ZeeGrid has lost the input focus.
Parameters:
fEnable
Value of wParam. A value of TRUE will keep the column headers and row numbers column displaying in 3D when it loses the keyboard input focus. A value of FALSE will display the column headers and row numbers column as flat when ZeeGrid loses the input focus.
Return Values:
This message does not return a value.
Remarks:
By default, the column headers and row numbers column will display as flat when input focus is lost. You need to only use this message when you want to change the default behavior of the ZeeGrid.
proc loadGrid(self: wZeeGrid; lpszString: string) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_LOADGRID message to load a ZeeGrid from a file. The file must have been created with the ZGM_SAVEGRID message.
Parameters:
lpszString
The value of lParam. The address of a string specifying the path and filename to load.
Return Values:
This message does not return a value.
proc loadIcon(self: wZeeGrid; iIPIndex: int; wIcon: wIcon) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_LOADICON message to load an icon handle (HICON) into the specified index of the ZeeGrid icon palette.
Parameters:
iIPIndex
The value of wParam. The icon palette index to load the icon handle.
wIcon
The value of lParam. The handle to the icon (HICON) that is to be loaded into the ZeeGrid icon palette.
Return Values:
This message does not return a value.
proc markText(self: wZeeGrid; lpszString: string): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_MARKTEXT to mark the text that contains the given string.
Parameters:
lpszString
The value of lParam. The address of a string to match in the grid cells.
Return Values:
The number of cells that matched the text in lpstring.
Remarks:
The return value indicates the number of matches in visible cells. Cells that match the text but are in columns that are sized to a width of zero will not be marked, and are not returned in the match count.
proc mergeRows(self: wZeeGrid; fEnable: bool = false) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_MERGEROWS message to enable or disable the merging of consecutive rows of identical data in fixed columns to display as a single cell.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the merging of identical cells in fixed columns.
Return Values:
This message does not return a value.
Remarks:
Merge rows is disabled by default.
proc print(self: wZeeGrid) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_PRINT message to print the ZeeGrid data.
Return Values:
This message does not return a value.
Remarks:
This message will initiate the common dialog print selection just as though the user had clicked the print button on the toolbar.
proc queryBuild(self: wZeeGrid; fFlag: bool = false): int {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_QUERYBUILD to get the ZeeGrid DLL build number.
Parameters:
fFlag
Value of wParam. A value of TRUE will display the ZeeGrid DLL build number in an internal MessageBox. A value of FALSE will cause the message to operate in "silent" mode. That is, the MessageBox will not be displayed.
Return Values:
The ZeeGrid DLL build number.
Remarks:
This message is used so that an application can be sure that it is not using a ZeeGrid DLL of a build prior to the build with which the application was developed. Build numbers are essentially ZeeGrid DLL version numbers.
proc refreshGrid(self: wZeeGrid) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_REFRESHGRID to force a repaint of the ZeeGrid client area.
Return Values:
A grid refresh is needed after programmatically setting visible cell text or attributes.
proc saveGrid(self: wZeeGrid; lpszString: string) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_SAVEGRID message to save a ZeeGrid from to a file. The saved file can then be loaded at a later time with the ZGM_LOADGRID message.
Parameters:
lpszString
The value of lParam. The address of a string specifying the path and filename to save the ZeeGrid to.
Return Values:
This message does not return a value.
proc scrollDown(self: wZeeGrid; iRows: int) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_SCROLLDOWN message to programmatically scroll the ZeeGrid down the specified number of rows.
Parameters:
iRows
Value of wParam. This specifies the number of rows to scroll down.
Return Values:
This message does not return a value.
proc scrollLeft(self: wZeeGrid; iCols: int) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_SCROLLLEFT message to programmatically scroll the ZeeGrid left the specified number of columns.
Parameters:
iCols
Value of wParam. This specifies the number of columns to scroll left.
Return Values:
This message does not return a value.
proc scrollRight(self: wZeeGrid; iCols: int) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_SCROLLRIGHT message to programmatically scroll the ZeeGrid right the specified number of columns.
Parameters:
iCols
Value of wParam. This specifies the number of columns to scroll right.
Return Values:
This message does not return a value.
proc scrollUp(self: wZeeGrid; iRows: int) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_SCROLLUP message to programmatically scroll the ZeeGrid up the specified number of rows.
Parameters:
iRows
Value of wParam. This specifies the number of rows to scroll up.
Return Values:
This message does not return a value.
proc searchEachKeyStroke(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SEARCHEACHKEYSTROKE message to enable or disable the option in the search panel for the ZeeGrid to be searched for matches on each keystroke in the "find" edit control.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the searching of the ZeeGrid on each keystroke in the "find" edit control in the search panel.
Return Values:
This message does not return a value.
Remarks:
Search each keystroke is enabled by default.
proc selectColumn(self: wZeeGrid; iCol: int) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_SELECTCOLUMN message to programmatically select a ZeeGrid column. This is done manually by the user by clicking in the column header.
Parameters:
iCol
The value of wParam. The column number to select.
Return Values:
This message does not return a value.
proc selectRow(self: wZeeGrid; iRow: int) {...}{.inline, raises: [], tags: [].}
Sends a ZGM_SELECTROW message to programmatically select a ZeeGrid row. This is done manually by the user by clicking in the row number column (if displayed).
Parameters:
iRow
The value of wParam. The row number to select.
Return Values:
This message does not return a value.
proc setAutoIncreaseSize(self: wZeeGrid; iIncreaseSize: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETAUTOINCREASESIZE message to set the number of rows that are allocated for the ZeeGrid when it needs to expand to hold more rows.
Parameters:
iIncreaseSize
The value of wParam. The number of rows to increase allocated memory by when the ZeeGrid needs to expand for additional rows.
Return Values:
This message does not return a value.
proc setBackgroundBitmap(self: wZeeGrid; hBitmap: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETBACKGROUNDBITMAP message to set a background bitmap for the ZeeGrid. The default background color must be set to color index 17 to make the background of the cells paint with a NULL_BRUSH. The user supplied bitmap is stretched to fit the background area of the ZeeGrid control.
Parameters:
hBitmap
The value of lParam. This is a handle to a bitmap to be used for the ZeeGrid background.
Return Values:
This message does not return a value.
Remarks:
The application is responsible for loading the bitmap, and destroying it upon application exit. The bitmap must remain valid for the life of the ZeeGrid using it.
proc setCellBColor(self: wZeeGrid; iCellIndex: int; iCPIndex: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLBCOLOR message to set the background color of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to set the background color.
iCPIndex
The value of lParam. The color index to set the cell background color to. Valid color index numbers are in the range of [0..127].
Return Values:
This message does not return a value.
proc setCellFColor(self: wZeeGrid; iCellIndex: int; iCPIndex: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLFCOLOR message to set the background color of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to set the background color.
iCPIndex
The value of lParam. The color index to set the cell background color to. Valid color index numbers are in the range of [0..127].
Return Values:
This message does not return a value.
proc setCellCDate(self: wZeeGrid; iCellIndex: int; lpszString: string = ""): int {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SETCELLCDATE message to set the specified cell in the ZeeGrid to the date specified by the null-terminated string in lParam.
Parameters:
iCellIndex
The value of wParam. The index of the ZeeGrid cell.
lpszString
The value of lParam. A null-terminated string containing the text representation of a date. This text can be in many date formats. For example, the date 12/28/1958 could be represented in string form as '1958/12/28', '12/28/58', '12/28/1958', 'Dec 28, 1958', or 'December 28, 1958' Valid dates range from 1/1/1600 to 12/31/9999.
Return Values:
If the string representation of the date specified in lParam can be deciphered into a valid date, the message will return the julian date of the specified string date.
proc setCellDouble(self: wZeeGrid; iCellIndex: int; lpDoubleValue: float = 0.0) {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SETCELLDOUBLE message to set the double value of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
lpDoubleValue
The value of lParam. A pointer to a double.
Return Values:
This message does not return a value.
proc setCellEdit(self: wZeeGrid; iCellIndex: int; iEdit: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETCELLEDIT message to set the edit attribute value of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to set the edit attribute value.
iEdit
The value of lParam. The edit attribute value to set the specified cell to. Valid edit attribute values are in the range of [0..4].
0 = cell is not editable, or readonly 1 = editable with a text edit box 2 = editable with a droplist combo box 3 = boolean value and is editable by double-clicking the cell to change the boolean state from TRUE to FALSE or vice versa 4 = editable with date picker common control
Return Values:
This message does not return a value.
proc setCellFont(self: wZeeGrid; iCellIndex: int; iFPIndex: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETCELLFONT message to set the font of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to set the font index value.
iFPIndex
The value of lParam. Valid values are in the range of [0..127].
Return Values:
This message does not return a value.
proc setCellFormat(self: wZeeGrid; iCellIndex: int; iValue: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETCELLFORMAT message to set the format value of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iValue
The value of lParam. The value to set the cell format attribute.
Return Values:
This message does not return a value.
proc setCellIcon(self: wZeeGrid; iCellIndex: int; iIPIndex: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETCELLICON message to set the icon of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iIPIndex
The value of lParam. Valid values are in the range of [0..127].
Return Values:
This message does not return a value.
proc setCellInt(self: wZeeGrid; iCellIndex: int; lpIntValue: int = 0) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLINT message to set the integer value of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
lpIntValue
The value of lParam. A pointer to a integer.
Return Values:
This message does not return a value.
proc setCellJDate(self: wZeeGrid; iCellIndex: int; iJulianDate: int): bool {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SETCELLINT message to set the integer value of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iJulianDate
The value of lParam. The julian date where 1 = 'January 1, 1600' and 3068037 = 'December 31, 9999'. Values less than or equal to 0 are invalid julian dates.
Return Values:
This message does not return a value.
proc setCellJustify(self: wZeeGrid; iCellIndex: int; iJustify: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLJUSTIFY message to set the text justification of the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iJustify
The value of lParam. Valid values are in the range of [0..8].
Return Values:
This message does not return a value.
proc setCellMark(self: wZeeGrid; iCellIndex: int; iMark: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLMARK message to set the mark attribute of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iMark
The value of lParam. The mark attribute value to set the specified cell.
Return Values:
This message does not return a value.
proc setCellNumPrecision(self: wZeeGrid; iCellIndex: int; iValue: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLNUMPRECISION message to set the precision (number of decimal places displayed) of the double value of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iValue
The value of lParam. The value to set the cell number precision.
Return Values:
This message does not return a value.
proc setCellNumWidth(self: wZeeGrid; iCellIndex: int; iValue: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLNUMWIDTH message to set the width (leading padding spaces) of the value of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iValue
The value of lParam. The value to set the cell number width.
Return Values:
This message does not return a value.
proc setCellRestriction(self: wZeeGrid; iCellIndex: int; iRestriction: int) {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SETCELLRESTRICTION to programmatically set a cell's restriction value. Restrictions perform numeric data entry validation, allowing only valid characters per the restriction to be entered.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iRestriction
The value of lParam. The data restriction attribute value to set the specified cell. Valid values are in the range of [0..4].
The restriction values are defined as follows:
0 = No Restriction 1 = Signed Integer 2 = Unsigned Integer 3 = Signed Double 4 = Unsigned Double
Return Values:
This message does not return a value.
Remarks:
A restriction only restricts the characters allowed to be entered into a cell by manual keyboard input. If a paste operation is performed on restricted cells, the restriction will apply and the paste operation may not be able to be completed fully.
proc setCellText(self: wZeeGrid; iCellIndex: int; lpszString: string = "") {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SETCELLTEXT message to set the text of the specified cell.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
lpszString
The value of lParam. A pointer to a string.
Return Values:
This message does not return a value.
proc setCellType(self: wZeeGrid; iCellIndex: int; iType: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCELLTYPE to programmatically set a cell's data type.
Parameters:
iCellIndex
The value of wParam. The ZeeGrid cell index.
iType
The value of lParam. The data type attribute value to set the specified cell. Valid values are in the range of [0..5].
Return Values:
This message does not return a value.
proc setColBColor(self: wZeeGrid; iCol: int; iCPIndex: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCOLBCOLOR message to set the background color of every cell in the specified column of the ZeeGrid.
Parameters:
iCol
The value of wParam. The ZeeGrid column number to set the background color. If this value is zero, the action is performed on all columns.
iCPIndex
The value of lParam. The color index to set the column background color to. Valid color index numbers are in the range of [0..127].
Return Values:
This message does not return a value.
proc setColEdit(self: wZeeGrid; iCol: int; iEdit: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLEDIT message to set the edit attribute value of every cell in the specified column in the ZeeGrid.
Parameters:
iCol
The value of wParam. The ZeeGrid column to set every cell the edit attribute value. If this value is zero, the action is performed on all columns.
iEdit
The value of lParam. The edit attribute value to set every cell in the specified ZeeGrid column to. Valid edit attribute values are in the range of [0..4]. A value of 0 means that the cell is not editable, or readonly. 1 = editable with a text edit box 2 = editable with a droplist combo box 3 = boolean value and is editable by double-clicking the cell to change the boolean state from TRUE to FALSE or vice versa 4 = editable with the date picker common control
Return Values:
This message does not return a value.
proc setColFColor(self: wZeeGrid; iCol: int; iCPIndex: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCOLFCOLOR message to set the foreground color (text color) of every cell in the specified column of the ZeeGrid.
Parameters:
iCol
The value of wParam. The ZeeGrid column number to set the foreground color. If this value is zero, the action is performed on all columns.
iCPIndex
The value of lParam. The color index to set the column foreground color to. Valid color index numbers are in the range of [0..127].
Return Values:
This message does not return a value.
proc setColFont(self: wZeeGrid; iCol: int; iFPIndex: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLFONT message to set the font of every cell in the specified column in the ZeeGrid.
Parameters:
iCol
The value of wParam. The ZeeGrid column to set every cell the font index value. If this value is zero, the action is performed on all columns.
iFPIndex
The value of lParam. Valid values are in the range of [0..127].
Return Values:
This message does not return a value.
proc setColFormat(self: wZeeGrid; iCol: int; iValue: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLFORMAT message to set the format value of the cells in the specified column.
Parameters:
iCol
The value of wParam. The ZeeGrid column number. If this value is zero, the action is performed on all columns.
iValue
The value of lParam. The value to set the cell format for every cell in the specified column.
Return Values:
This message does not return a value.
proc setColIcon(self: wZeeGrid; iCol: int; iIPIndex: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLICON message to set the icon of every cell in the specified column in the ZeeGrid.
Parameters:
iCol
The value of wParam. The ZeeGrid column to set every cell the icon index value. If this value is zero, the action is performed on all columns.
iIPIndex
The value of lParam. Valid values are in the range of [0..127].
Return Values:
This message does not return a value.
proc setColJustify(self: wZeeGrid; iCol: int; iJustify: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCOLJUSTIFY message to set the text justification of every cell in the specified column in the ZeeGrid.
Parameters:
iCol
The value of wParam. The ZeeGrid column to set every cell the text justification value. If this value is zero, the action is performed on all columns.
iJustify
The value of lParam. Valid values are in the range of [0..8].
Return Values:
This message does not return a value.
proc setColMark(self: wZeeGrid; iCol: int; iMark: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLMARK message to set the mark attribute of every cell in the the specified column(s).
Parameters:
iCol
The value of wParam. The column number to set the mark attribute. If this value is zero, the action is performed on all columns.
iMark
The value of lParam. The mark attribute value to set every cell in the column.
Return Values:
This message does not return a value.
proc setColNumPrecision(self: wZeeGrid; iCol: int; iValue: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCOLNUMPRECISION message to set the precision of the double values of the cells in the specified column.
Parameters:
iCol
The value of wParam. The ZeeGrid column number. If this value is zero, the action is performed on all columns.
iValue
The value of lParam. The value to set the cell number precision for every cell in the specified column.
Return Values:
This message does not return a value.
proc setColNumWidth(self: wZeeGrid; iCol: int; iValue: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCOLNUMWIDTH message to set the width of the displayed value in the cells of the specified column.
Parameters:
iCol
The value of wParam. The ZeeGrid column number. If this value is zero, the action is performed on all columns.
iValue
The value of lParam. The value to set the cell number width for every cell in the specified column.
Return Values:
This message does not return a value.
proc setColor(self: wZeeGrid; iCPIndex: int; dwRGB: DWORD) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLOR message to set the RGB color value of the specified index of the ZeeGrid color palette.
Parameters:
iCPIndex
The value of wParam. The index of the color palette to set the color.
dwRGB
The value of lParam. The RGB value to set the specified index of the ZeeGrid color palette.
Return Values:
This message does not return a value.
proc setColRestriction(self: wZeeGrid; iCol: int; iRestriction: int) {...}{.inline,
    raises: [], tags: [].}
Sends a ZGM_SETCOLRESTRICTION message to set the restriction value of every cell in the specified column in the ZeeGrid. Restrictions perform numeric data entry validation, allowing only valid characters per the restriction to be entered.
Parameters:
iCol
The value of wParam. The ZeeGrid column to set every cell the restriction value specified in lParam. If this value is zero, the action is performed on all columns.
iRestriction
The value of lParam. The data restriction attribute value to set every cell in the the specified column. Valid values are in the range of [0..4].
The restriction values are defined as follows:
0 = No Restriction 1 = Signed Integer 2 = Unsigned Integer 3 = Signed Double 4 = Unsigned Double
Return Values:
This message does not return a value.
Remarks:
A restriction only restricts the characters allowed to be entered into a cell by manual keyboard input. If a paste operation is performed on restricted cells, the restriction will apply and the paste operation may not be able to be completed fully.
proc setColType(self: wZeeGrid; iCol: int; iType: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLTYPE message to set the data type of every cell in the specified column in the ZeeGrid.
Parameters:
iCol
The value of wParam. The ZeeGrid column to set every cell the data type value. If this value is zero, the action is performed on all columns.
iType
The value of lParam. Valid values are in the range of [0..5].
Return Values:
This message does not return a value.
proc setColumnHeaderHeight(self: wZeeGrid; iHeight: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLUMNHEADERHEIGHT message to set the minimum height of the column header row in pixels. If iHeight is set to 0, no column headers are displayed. This also makes the grid columns unable to be resized or reordered by the user. If the value of iHeight is greater than zero, the minimum height will be automatically calculated and set to contain the tallest column header title. If iHeight is greater than the calculated height to contain the tallest column header title, the additional space is added to the top of the column headers. If the column header height is set to a value greater than 0, the minimum height will be automatically set to 20. If the column header titles won't fit with the 20 pixel height, it will be automatically sized up to hold the title. A value that is more than that required to contain the title will be respected.
Parameters:
iHeight
The value of wParam. The number of pixels to set for the minumum column header height.
Return Values:
This message does not return a value.
proc setColumnOrder(self: wZeeGrid; iElements: int; lpiArray: openArray[int]) {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SETCOLUMNORDER message to programmatically set the display order of the ZeeGrid columns.
Parameters:
iElements
The value of wParam. The number of elements in the integer array supplied in lParam.
lpiArray
The value of lParam. A pointer to an array of integers. This array defines the column display order. Each element of the array holds a valid ZeeGrid column number. The display order of the columns will be set to the order specified by the array.
Return Values:
This message does not return a value.
proc setColWidth(self: wZeeGrid; iCol: int; iWidth: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCOLWIDTH to programmatically set the width of the specified column in pixels.
Parameters:
iCol
The value of wParam. The column number to set the width.
iWidth
The value of lParam. The width in pixels to set the specified column.
Return Values:
This message does not return a value.
proc setCursorCell(self: wZeeGrid; iCellIndex: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SETCURSORCELL message to programmatically set the cursor cell.
Parameters:
iCellIndex
The value of wParam. The index of the ZeeGrid cell.
Return Values:
This message does not return a value.
proc setDefaultBColor(self: wZeeGrid; iCPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTBCOLOR message to set the default background color of newly added cells to the ZeeGrid.
Parameters:
iCPIndex
The value of wParam. The color palette index to set as the default background color for new cells.
Return Values:
This message does not return a value.
proc setDefaultEdit(self: wZeeGrid; iEdit: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTEDIT message to set the default edit attribute of newly added cells to the ZeeGrid.
Parameters:
iEdit
The value of wParam. The edit attribute value to assign to new cells by default.
Return Values:
This message does not return a value.
proc setDefaultFColor(self: wZeeGrid; iCPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTBCOLOR message to set the default foreground color of newly added cells to the ZeeGrid.
Parameters:
iCPIndex
The value of wParam. The color palette index to set as the default foreground color for new cells.
Return Values:
This message does not return a value.
proc setDefaultFont(self: wZeeGrid; iFPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTFONT message to set the default font of newly added cells to the ZeeGrid.
Parameters:
iFPIndex
The value of wParam. The index of the font palette to assign to new cells by default.
Return Values:
This message does not return a value.
proc setDefaultIcon(self: wZeeGrid; iIPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTICON message to set the default icon attribute of newly added cells to the ZeeGrid.
Parameters:
iIPIndex
The value of wParam. The index of the icon palette to assign to new cells by default.
Return Values:
This message does not return a value.
proc setDefaultJustify(self: wZeeGrid; iJustify: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTJUSTIFY message to set the default text justification of newly added cells to the ZeeGrid.
Parameters:
iJustify
The value of wParam. The value of the justification attribute to assign to new cells by default.
Return Values:
This message does not return a value.
proc setDefaultMark(self: wZeeGrid; iMark: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTMARK message to set the default mark attribute of newly added cells to the ZeeGrid.
Parameters:
iMark
The value of wParam. The value of the mark attribute to assign to new cells by default.
Return Values:
This message does not return a value.
proc setDefaultNumPrecision(self: wZeeGrid; iPrecision: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETDEFAULTNUMPRECISION message to set the default numeric precision of newly added cells to the ZeeGrid.
Parameters:
iPrecision
The value of wParam. The value of the numeric precision attribute to assign to new cells by default.
Return Values:
This message does not return a value.
proc setDefaultNumWidth(self: wZeeGrid; iNumWidth: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTNUMWIDTH message to set the default numeric width of newly added cells to the ZeeGrid.
Parameters:
iNumWidth
The value of wParam. The value of the numeric width attribute to assign to new cells by default.
Return Values:
This message does not return a value.
proc setDefaultRestriction(self: wZeeGrid; iRestriction: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETDEFAULTRESTRICTION message to set the default restriction value of newly added cells to the ZeeGrid.
Parameters:
iRestriction
The value of wParam. The value of the restriction attribute to assign to new cells by default. Valid values are in the range of [0..4].
The restriction values are defined as follows:
0 = No Restriction 1 = Signed Integer 2 = Unsigned Integer 3 = Signed Double 4 = Unsigned Double
Return Values:
This message does not return a value.
Remarks:
A restriction only restricts the characters allowed to be entered into a cell by manual keyboard input. If a paste operation is performed on restricted cells, the restriction will apply and the paste operation may not be able to be completed fully.
proc setDefaultType(self: wZeeGrid; iType: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETDEFAULTTYPE message to set the default data type of newly added cells to the ZeeGrid.
Parameters:
iType
The value of wParam. The value of the data type attribute to assign to new cells by default.
Return Values:
This message does not return a value.
proc setEditText(self: wZeeGrid; lpszString: string) {...}{.raises: [], tags: [].}
Sends a ZGM_SETEDITTEXT message to set the text of the edit control used for incell editing.
Parameters:
lpszString
The value of lParam. A pointer to a null-terminated string to load into the cell edit control.
Return Values:
This message does not return a value.
proc setFont(self: wZeeGrid; iFPIndex: int; wFont: wFont) {...}{.raises: [], tags: [].}
Sends a ZGM_SETFONT message to set the specified ZeeGrid entry in the font palette to the supplied font handle (HFONT).
Parameters:
iFPIndex
The value of wParam. The index of the font palette to assign a font handle.
hFont
The value of lParam. The handle to the font (HFONT) to load into the ZeeGrid font palette.
Return Values:
This message does not return a value.
proc setGridBGColor(self: wZeeGrid; iCPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETGRIDBGCOLOR message to set the grid background color to the specified ZeeGrid color palette entry.
Parameters:
iCPIndex
The value of wParam. The index of the color palette.
Return Values:
This message does not return a value.
Remarks:
The grid background color is specifies the color of the grid body that is not occupied by grid cells. This is the area to the right of the rightmost column, and below the last row. This area will not gray when when grid has lost focus if using ZGM_GRAYBGONLOSTFOCUS.
proc setGridLineColor(self: wZeeGrid; iCPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETGRIDLINECOLOR message to set the gridline color to the specified ZeeGrid color palette entry.
Parameters:
iCPIndex
The value of wParam. The index of the color palette.
Return Values:
This message does not return a value.
proc setItemData(self: wZeeGrid; iCellIndex: int; dwData: DWORD) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETITEMDATA message to set a user supplied 32-bit value associated with the specified cell in the ZeeGrid.
Parameters:
iCellIndex
The value of wParam. The cell index to set cell data value.
dwData
Value of lParam. Specifies the 32-bit value to be associated with the specified ZeeGrid cell.
Return Values:
This message does not return a value.
proc setLeftIndent(self: wZeeGrid; dwIndent: DWORD) {...}{.raises: [], tags: [].}
Sends a ZGM_SETLEFTINDENT message to set the left indent of each cell in the ZeeGrid.
Parameters:
dwIndent
Value of wParam. Specifies the number of pixels to indent cell contents from the left cell gridline.
Return Values:
This message does not return a value.
Remarks:
The left indent is set to 2 pixels by default. The left and right indent values are global indents. All cells will be indented by the specified number of pixels.
proc setLostFocusHighlightColor(self: wZeeGrid; iCPIndex: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETLOSTFOCUSHIGHTLIGHTCOLOR message to set the color index of the color palette to be used for displaying the highlight color when the ZeeGrid loses input focus.
Parameters:
iCPIndex
The value of wParam. The index of the color palette to use for the highlight color when the ZeeGrid loses input focus.
Return Values:
This message does not return a value.
Remarks:
By default, the highlight color is black for a ZeeGrid that has lost the input focus.
proc setMarkText(self: wZeeGrid; fEnable: bool) {...}{.raises: [], tags: [].}
Sends a ZGM_SETMARKTEXT to enable or disable the display of marked text.
Parameters:
fEnable
Value of wParam. A value of TRUE will cause all marked text cells to display in the marked text color. A value of FALSE will cause all marked cells to display without marking.
Return Values:
This message does not return a value.
proc setPrintPointSize(self: wZeeGrid; iPointSize: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETPRINTPOINTSIZE message to set the printing font size.
Parameters:
iPointSize
The value of wParam. The point size of the font to use when printing the ZeeGrid.
Return Values:
This message does not return a value.
proc setRange(self: wZeeGrid; iCellIndex1: int; iCellIndex2: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETRANGE message to define a bounding block of cells and calculates the sum of all numeric type cells in the block. The application must then use ZGM_GETRANGESUM to retrieve this sum.
Parameters:
iCellIndex1
The value of wParam. The cell index of the ZeeGrid. This index is the first of two that defines a block of cells. The block can be in a single column, or span multiple columns. This cell index should be the cell that defines the upper left corner of the cell block.
iCellIndex2
The value of lParam. The cell index of the ZeeGrid. This index is the second of two that defines a block of cells. The block can be in a single column, or span multiple columns. This cell index should be the cell that defines the lower right corner of the cell block.
Return Values:
This message does not return a value.
proc setRegCDate(self: wZeeGrid; lpszString: string): int {...}{.raises: [], tags: [].}
Sends a ZGM_SETREGCDATE message to set the internal date register in the ZeeGrid to the date specified by the null-terminated string in lParam.
Parameters:
lpszString
The value of lParam. A null-terminated string containing the text representation of a date. This text can be in many date formats.
For example, the date 12/28/1958 could be represented in string form as '1958/12/28', '12/28/58', '12/28/1958', 'Dec 28, 1958', or 'December 28, 1958'
Valid dates range from 1/1/1600 to 12/31/9999.
Return Values:
This message returns the julian date if valid, otherwise it returns 0.
proc setRegJDate(self: wZeeGrid; iJulianDate: int): int {...}{.raises: [], tags: [].}
Sends a ZGM_SETREGJDATE message to set the internal date register in the ZeeGrid to the date specified by the julian date in lParam.
Parameters:
iJulianDate
The value of lParam. The julian date where 1 = 'January 1, 1600' and 3068037 = 'December 31, 9999'. Values less than or equal to 0 are invalid julian dates.
Return Values:
This message returns the julian date if valid, otherwise it returns 0.
proc setRightIndent(self: wZeeGrid; dwIndent: DWORD) {...}{.raises: [], tags: [].}
Sends a ZGM_SETRIGHTINDENT message to set the right indent of each cell in the ZeeGrid.
Parameters:
dwIndent
Value of wParam. Specifies the number of pixels to indent cell contents from the right cell gridline.
Return Values:
This message does not return a value.
Remarks:
The right indent is set to 2 pixels by default. The left and right indent values are global indents. All cells will be indented by the specified number of pixels.
proc setRowBColor(self: wZeeGrid; iRow: int; iCPIndex: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETROWBCOLOR message to set the background color of every cell in the specified row of the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row number to set the backgground color.
iCPIndex
The value of lParam. The color index to set the row background color to. Valid color index numbers are in the range of [0..127].
Return Values:
This message does not return a value.
proc setRowEdit(self: wZeeGrid; iRow: int; iEdit: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWBCOLOR message to set the background color of every cell in the specified row of the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row to set every cell the edit attribute value.
iEdit
The value of lParam. The edit attribute value to set every cell in the specified ZeeGrid row to. Valid edit attribute values are in the range of [0..4]. 0 = not editable, or readonly 1 = editable with a text edit box 2 = editable with a droplist combo box 3 = boolean value and is editable by double-clicking the cell to change the boolean state from TRUE to FALSE or vice versa 4 = editable with the date picker common control.
Return Values:
This message does not return a value.
proc setRowFColor(self: wZeeGrid; iRow: int; iCPIndex: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETROWFCOLOR message to set the foreground color (text color) of every cell in the specified row of the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row number to set the foreground color.
iCPIndex
The value of lParam. The color index to set the row foreground color to. Valid color index numbers are in the range of [0..127].
Return Values:
This message does not return a value.
proc setRowFont(self: wZeeGrid; iRow: int; iFPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWFONT message to set the font of every cell in the specified row in the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row to set every cell the font index value.
iFPIndex
The value of lParam. Valid values are in the range of [0..127].
Return Values:
This message does not return a value.
proc setRowHeight(self: wZeeGrid; iHeight: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWHEIGHT message to programmatically set the height of the ZeeGrid rows to the specified number of pixels.
Parameters:
iHeight
The value of wParam. The ZeeGrid row to set every cell the font index value.
Return Values:
This message does not return a value.
proc setRowIcon(self: wZeeGrid; iRow: int; iIPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWICON message to set the icon of every cell in the specified row in the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row to set every cell the icon index value.
iIPIndex
The value of lParam. Valid values are in the range of [0..127].
Return Values:
This message does not return a value.
proc setRowJustify(self: wZeeGrid; iRow: int; iJustify: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETROWJUSTIFY message to set the text justification of every cell in the specified row in the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row to set every cell the text justification value.
iJustify
The value of lParam. Valid values are in the range of [0..8].
Return Values:
This message does not return a value.
proc setRowMark(self: wZeeGrid; iRow: int; iMark: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWMARK message to set the mark attribute of every cell in the the specified row.
Parameters:
iRow
The value of wParam. The ZeeGrid row to set every cell the text justification value.
iMark
The value of lParam. The mark attribute value to set every cell in the row.
Return Values:
This message does not return a value.
proc setRowNumberFont(self: wZeeGrid; iFPIndex: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWNUMBERFONT message to change the font used to display the row number in the ZeeGrid.
Parameters:
iFPIndex
The value of wParam. Valid values are in the range of [0..127].
Return Values:
This message does not return a value.
Remarks:
The row number column will automatically size itself to hold the number of digits required to display the largest row number currently in the ZeeGrid. This width will be determined by the font size of the selected font palette.
proc setRowNumbersWidth(self: wZeeGrid; iWidth: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWNUMBERSWIDTH message to set the width of the row number column. This column cannot be adjusted by the user, so it is the only way to adjust this column's width.
Parameters:
iWidth
The value of wParam. The value is the width of the row numbers column in pixels.
Return Values:
This message does not return a value.
proc setRowNumPrecision(self: wZeeGrid; iRow: int; iValue: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETROWNUMPRECISION message to set the precision of the double values of the cells in the specified row.
Parameters:
iRow
The value of wParam. The ZeeGrid row number.
iValue
The value of lParam. The value to set the cell number precision for every cell in the specified row.
Return Values:
This message does not return a value.
proc setRowNumWidth(self: wZeeGrid; iRow: int; iValue: int) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETROWNUMWIDTH message to set the width of the displayed value in the cells of the specified row.
Parameters:
iRow
The value of wParam. The ZeeGrid row number.
iValue
The value of lParam. The value to set the cell number width for every cell in the specified row.
Return Values:
This message does not return a value.
proc setRowRestriction(self: wZeeGrid; iRow: int; iRestriction: int) {...}{.
    raises: [], tags: [].}
Sends a ZGM_SETROWRESTRICTION message to set the restriction value of every cell in the specified row in the ZeeGrid. Restrictions perform numeric data entry validation, allowing only valid characters per the restriction to be entered.
Parameters:
iRow
The value of wParam. The ZeeGrid row number to set every cell the restriction value specified in lParam.
iRestriction
The value of lParam. The data restriction attribute value to set every cell in the the specified row. Valid values are in the range of [0..4]. The restriction values are defined as follows: 0 = No Restriction 1 = Signed Integer 2 = Unsigned Integer 3 = Signed Double 4 = Unsigned Double
Return Values:
This message does not return a value.
Remarks:
A restriction only restricts the characters allowed to be entered into a cell by manual keyboard input. If a paste operation is performed on restricted cells, the restriction will apply and the paste operation may not be able to be completed fully.
proc setRowType(self: wZeeGrid; iRow: int; iType: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETROWTYPE message to set the data type of every cell in the specified row in the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row number.
iType
The value of lParam. The data type attribute value to set every cell in the row. Valid values are in the range of [0..5].
Return Values:
This message does not return a value.
proc setSortLimit(self: wZeeGrid; iSortLimit: int; bFlag: bool) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SETSORTLIMIT message to set the maximum amount of time (in seconds) that a sort operation will take before prompting the user with the estimated time to sort and asking if (s)he wants to continue the sort operation.
Parameters:
iSortLimit
The value of wParam. The value is the number of seconds to allow for sorting. If this number is less than the estimated time to sort, the user is prompted to continue or cancel the sort operation depending on the boolean flag value of lParam..
bFlag
The value of lParam. If this value is TRUE, the user will receive a prompt to continue or cancel the sort operation if the estimated time exceeds the sort limit value. If this value is FALSE, no prompt is given and the sort operation is canceled.
Return Values:
This message does not return a value.
proc setTitleHeight(self: wZeeGrid; iHeight: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETTITLEHEIGHT message to set the minimum height in pixels of the ZeeGrid title.
Parameters:
iHeight
The value of wParam. The minimum height of the ZeeGrid title in pixels.
Return Values:
This message does not return a value.
proc setTopRow(self: wZeeGrid; iRow: int) {...}{.raises: [], tags: [].}
Sends a ZGM_SETTOPROW message to set the first displayed row number in the ZeeGrid.
Parameters:
iRow
The value of wParam. The ZeeGrid row number to display at the top of the page.
Return Values:
This message does not return a value.
proc showCopyMenu(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWCOPYMENU message to enable or disable the display of the copy/paste context menu when the user right-clicks the selected cell or highlighted range of cells. If the setting is FALSE (disabled), the grid will post a ZGN_RIGHTCLICK message to the host application. If the setting is TRUE (enabled), the context menu is displayed, and the ZGN_RIGHTCLICK message is not sent to the host application.
Parameters:
fEnable
Value of wParam. A value of TRUE will cause the copy/paste context menu to be displayed with the user right-clicks the current cell or selected range of cells. A value of FALSE will inhibit the context menu from showing, and send a ZGN_RIGHTCLICK notification message to the host application.
Return Values:
This message does not return a value.
Remarks:
This setting is enabled (TRUE) by default.
proc showCursor(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWCURSOR message to enable or disable the display of the cursor when the ZeeGrid has the input focus.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable the display of the cursor in the focus ZeeGrid. A value of TRUE enables showing the cursor; a value of FALSE disables showing the cursor.
Return Values:
This message does not return a value.
Remarks:
Showing the cursor is enabled by default.
proc showCursorOnLostFocus(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [],
    tags: [].}
Sends a ZGM_SHOWCURSORONLOSTFOCUS message to enable or disable the display of the cursor on a ZeeGrid that has lost the keyboard input focus.
Parameters:
fEnable
Value of wParam. A value of TRUE will show the cursor on a ZeeGrid that has lost the keyboard input focus. A value of FALSE will not show the cursor on a ZeeGrid that has lost the keyboard input focus.
Return Values:
This message does not return a value.
Remarks:
The cursor is shown on lost focus ZeeGrids by default.
proc showEdit(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWCURSORONLOSTFOCUS message to enable or disable the display of the cursor on a ZeeGrid that has lost the keyboard input focus.
Parameters:
fEnable
Value of wParam. A value of TRUE will show the auxillary edit panel on the ZeeGrid. A value of FALSE will hide the auxillary edit panel on the ZeeGrid.
Return Values:
This message does not return a value.
Remarks:
The edit panel is hidden by default.
proc showGridLines(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWGRIDLINES message to enable or disable the display of gridlines in the ZeeGrid.
Parameters:
fEnable
Value of wParam. Specifies whether to enable or disable displaying of gridlines. A value of TRUE enables displaying gridlines; a value of FALSE disables displaying gridlines.
Return Values:
This message does not return a value.
Remarks:
Gridlines are shown by default.
proc showHScroll(self: wZeeGrid; fEnable: bool) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWHSCROLL message to enable or disable the display of the horizonal scrollbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will show the horizontal scrollbar if ZGM_AUTOHSCROLL is set to FALSE. A value of FALSE will hide the horizontal scrollbar if ZGM_AUTOHSCROLL is set to FALSE. If ZGM_AUTOHSCROLL is set to TRUE, the setting of ZGM_SHOWHSCROLL will have no effect.
Return Values:
This message does not return a value.
proc showRowNumbers(self: wZeeGrid; fEnable: bool = true) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWROWNUMBERS message to enable or disable the display of row numbers in the ZeeGrid.
Parameters:
fEnable
Value of wParam. A value of TRUE will display row numbers. A value of FALSE will hide the row numbers.
Return Values:
This message does not return a value.
proc showSearch(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWSEARCH message to show or hide the ZeeGrid search panel.
Parameters:
fEnable
Value of wParam. A value of TRUE will display the ZeeGrid search panel. A value of FALSE will hide the ZeeGrid search panel.
Return Values:
This message does not return a value.
Remarks:
Show search is disabled by default.
proc showTitle(self: wZeeGrid; fEnable: bool) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWTITLE message to enable or disable the showing of the title in the ZeeGrid.
Parameters:
fEnable
Value of wParam. A value of TRUE will display the ZeeGrid title. A value of FALSE will hide the ZeeGrid title.
Return Values:
This message does not return a value.
proc showToolbar(self: wZeeGrid; fEnable: bool = false) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWSEARCH message to show or hide the ZeeGrid search panel.
Parameters:
fEnable
Value of wParam. A value of TRUE will show the ZeeGrid toolbar. A value of FALSE will hide the ZeeGrid toolbar.
Return Values:
This message does not return a value.
Remarks:
The toolbar is hidden by default.
proc showVScroll(self: wZeeGrid; fEnable: bool) {...}{.raises: [], tags: [].}
Sends a ZGM_SHOWHSCROLL message to enable or disable the display of the horizonal scrollbar.
Parameters:
fEnable
Value of wParam. A value of TRUE will show the vertical scrollbar if ZGM_AUTOVSCROLL is set to FALSE. A value of FALSE will hide the vertical scrollbar if ZGM_AUTOVSCROLL is set to FALSE. If ZGM_AUTOVSCROLL is set to TRUE, the setting of ZGM_SHOWVSCROLL will have no effect.
Return Values:
This message does not return a value.
proc shrinkToFit(self: wZeeGrid) {...}{.raises: [], tags: [].}
Sends a ZGM_SHRINKTOFIT message to release any memory for allocated rows beyond the memory required to hold the current number of data rows.
Return Values:
This message does not return a value.
proc sortColumnASC(self: wZeeGrid; iPrimarySortCol: int; iSecondarySortCol: int) {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SORTCOLUMNASC message to set the primary and secondary sort columns to sort in ascending order.
Parameters:
iPrimarySortCol
The value of wParam. The ZeeGrid column number to use as the primary sort column. When sorting, the order of equal values in this column will be determined by the secondary sort column.
iSecondarySortCol
The value of lParam. The ZeeGrid column number to use as the secondary sort column. The secondary sort column is used as a tie-breaker for rows with equal values in the primary sort column.
Return Values:
This message does not return a value.
Remarks:
ZeeGrid types are sorted in the following order: BOOLEAN FALSE, BOOLEAN TRUE, numeric values (low to high), alpha values (low to high).
proc sortColumnDESC(self: wZeeGrid; iPrimarySortCol: int; iSecondarySortCol: int) {...}{.
    inline, raises: [], tags: [].}
Sends a ZGM_SORTCOLUMNASC message to set the primary and secondary sort columns to sort in ascending order.
Parameters:
iPrimarySortCol
The value of wParam. The ZeeGrid column number to use as the primary sort column. When sorting, the order of equal values in this column will be determined by the secondary sort column.
iSecondarySortCol
The value of lParam. The ZeeGrid column number to use as the secondary sort column. The secondary sort column is used as a tie-breaker for rows with equal values in the primary sort column.
Return Values:
This message does not return a value.
Remarks:
ZeeGrid types are sorted in the following order: alpha values (high to low), numeric values (high to low), BOOLEAN TRUE, BOOLEAN FALSE
proc sortSecondary(self: wZeeGrid; iSecondarySortCol: int) {...}{.inline, raises: [],
    tags: [].}
Sends a ZGM_SORTSECONDARY message in response to the ZGN_SORT notification. This allows the application to programmatically determine the secondary sort column based on the column that the sort operation was requested on by the user double-clicking the column header.
Parameters:
iSecondarySortCol
The value of wParam. The ZeeGrid column to use as the secondary sort column.
Return Values:
This message does not return a value.
Remarks:
This message is primarily used when processing a ZGN_SORT notification message. By determining which column is being sorted, the application can vary the secondary sort column.
proc stopwatch_start(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_STOPWATCH_START message to start an internal interval timer.
Return Values:
This message returns the machine speed value that is calculated when the ZeeGrid DLL is initialized. This value is the basis on which the estimated sort times are calculated.
proc stopwatch_stop(self: wZeeGrid): int {...}{.inline, raises: [], tags: [].}
Sends a ZGM_STOPWATCH_STOP message to get the elapsed time since the execution of the last ZGM_STOPWATCH_START message.
Return Values:
This message returns the elapsed time since the internal stopwatch was started. The time is in 1000ths of a second. For example, a return value of 1500 = 1.5 seconds.
proc final(self: wZeeGrid) {...}{.raises: [], tags: [].}
Default finalizer for wZeeGrid. 
proc init(self: wZeeGrid; parent: wWindow; id = wDefaultID; pos = wDefaultPoint;
          size = wDefaultSize; style = 1342177280 or 0x00800000) {...}{.raises: [
    wError, wWindowError, wCursorError, wBrushError, Exception, wFontError],
    tags: [RootEffect].}
Initializer. 
proc ZeeGrid(parent: wWindow; id = wDefaultID; pos = wDefaultPoint;
             size = wDefaultSize; style = 1342177280 or 0x00800000): wZeeGrid {...}{.
    inline, discardable, raises: [wError, wWindowError, wCursorError,
                                  wBrushError, Exception, wFontError],
    tags: [RootEffect].}
Constructor, creating and showing a zeegrid control.

Templates

template RGB(r: untyped; g: untyped; b: untyped): COLORREF

Made with Nim. Generated: 2020-12-31 16:39:12 UTC