Grids Reference Page/es: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Objetivo
2	2
3	3		Este texto trata de enseñar al usuario algunos aspectos de los componentes tipo grid ("rejilla" por traducirlo de alguna forma). También tiene el propósito de servir de guía para usuarios que nunca hayan utilizado grids con anterioridad (los usuarios experimentados generalmente solo necesitan las referencias sobre nuevas funcionalidades). Por lo tanto este documento tratará de conseguir los siguientes objetivos:
4	4
5	5		1. Servir de introducción a los componentes tipo grid para la gente que tenga pocos o ningún conocimiento previo de Lazarus.
6	6		2. Documentar las diferencias con respecto a los componentes tipo grid utilizados en Delphi.
7	7		3. Documentar la nueva funcionalidad de las grids en Lazarus.
8	8		4. Crear referencias y ejemplos para estos componentes.
9	9
10	10		## Descripción
11	11
12	12		Una grid es un componente que aporta un significado para los datos mostrados en un formato tabulado (tabla). La característica más obvia de las grids es que están compuestas por celdas (cells) formando filas (rows) y columnas (cols).
13	13
14	14		El tipo de información que pueden mostrar es muy amplio y mayoritariamente depende de lo que el usuario necesita mostrar. Generalmente esta información consiste en texto, colores, imágenes o una combinación de estos tres.
15	15
16	16		Dada la gran variedad de información que pueden representar, se ha creado una serie de grids más específicas dependiendo del tipo de información a mostrar. Por ejemplo existe un tipo de grid para mostrar texto, StringGrid, de la cual podemos encontrar documentación [aquí](http://lazarus-ccr.sourceforge.net/docs/lcl/grids/tstringgrid.html)
17	17
18	18		El siguiente diagrama muestra el árbol de herencia con los tipos existentes:
19	19
20	20		## Árbol de herencia
21	21
22		-	~~<figure>~~
23	22		<img src="diagrama_grids.png" title="diagrama_grids.png" width="750" />
24		-	~~<figcaption>diagrama_grids.png</figcaption>~~
25		-	~~</figure>~~
26	23
27	24		## Un ejemplo inicial
28	25
29	26		Como uno de los objetivos de ésta página es ayudar a la gente con poco o ningún conocimiento previo de Lazarus, nos vamos a permitir poner un breve ejemplo como punto de partida para entender las grids en acción. Porque no, hagamos un tradicional "¡ Hola Mundo !" como ejemplo del uso del componente TStringGrid.
30	27
31	28		1. Crear una nueva aplicación.
32	29		- Desde el menú principal seleccionar: Archivo -\> Nuevo ... -\> Proyecto -\> Aplicación.
33	30		- Una vez selecciona Aplicación pulsamos Aceptar.
34	31		- Nos muestra un formulario (Form1) vacío nuevo.
35	32		2. Situar una grid (rejilla) sobre el formulario Form1.
36	33		- Desde la paleta de componentes seleccionar la solapa "Additional".
37	34		- Hacer Click sobre el icono TStringGrid ![](/wiki-images/6/67/Tstringgrid.png).
38	35		- Hacer Click sobre el formulario, cerca de la esquina superior izquierda. De esta forma aparece una grid nueva vacía.
39	36		3. Situar un pulsador (button) en el formulario.
40	37		- Desde la paleta de componentes seleccionar la solapa "Standard".
41	38		- Hacer Click sobre el icono TButton ![](/wiki-images/b/b2/Tbutton.png).
42	39		- Hacer Click sobre un área vacía del formulario. De esta forma aparece un nuevo pulsador(button).
43	40		4. Hacer doble click sobre el pulsador del paso 3 y donde sitúa el cursor parpadeante (código para el manejador (handler) del pulsador) escribir el siguiente fragmento de código.
44	41		- ``` pascal
45	42		StringGrid1.Cells[1,1] := '¡ Hola Mundo !';
46	43		```
47	44
48	45		- Ejecuta el programa haciendo Click en el icono de play ![](/wiki-images/8/85/Menu_run.png).
49	46		5. Una vez que compila correctamente el programa aparece el formulario con un pulsador, pues bien, si hacemos Click sobre el pulsador "Button1" deberíamos visualizar ¡ Hola Mundo ! en la celda que hemos especificado en este caso la correspondiente a la fila 1 y columna 1.
50	47
51	48		## Diferencias entre las grids de Delphi y las de Lazarus
52	49
53	50		Los componentes tipo grid actuales de Lazarus presentan varias diferencias con respecto a las disponibles en Delphi. Esto se debe principalmente a que las grids de Lazarus fueron creadas desde cero y no se buscaba que tuviesen una total compatibilidad con las de Delphi,
54	51
55	52		Posteriormente, se puso como objetivo tener dicha compatibilidad y las grids se empezaron a diseñar lo más parecidas al interface que tienen en Delphi, pero incluso cuando esto se empezó a implementar así tampoco se realizó un excesivo esfuerzo para hacer coincidir cada propiedad equivalente en Delphi.
56	53
57	54		También, debido a que el desarrollo interno de las grids es muy diferente, algunos aspectos no son posibles o necesitan realizarse de un modo diferente en Lazarus. Además (debido a que las grid de Lazarus internamente son muy diferentes a las de Delphi)algunas funcionalidades de Delphi no son posibles o necesitan ser emuladas de una manera diferente en las grids de Lazarus. De todas formas se ha alcanzado un alto grado de compatibilidad, lo cual es deseable.
58	55
59	56		### Diferencias
60	57
61	58		Las siguientes son diferencias evidentes:
62	59
63	60		- Editores de celdas (Cell).
64	61		- Comportamiento en tiempo de diseño.
65	62		- El dibujo de las celdas tiene algunas diferencias, ver la sección de personalización de grids para más detalles.
66	63
67	64		### Nuevas funcionalidades
68	65
69	66		- Columnas personalizadas.
70	67		- Eventos.
71	68		- Editor de Grid.
72	69
73	70		### Ajustes para afianzar la compatibilidad con grids de Delphi
74	71
75	72		Aquí hay una lista de propiedades y ajustes que se pueden realizar para lograr que las grids de Lazarus se parezcan o comporten de modo similar la las de Delphi. Estos ajustes están basados en una nueva grid creada. Las entradas etiquetadas con \[code\] necesitan establecerse con código, mientras que las etiquetadas como \[Design\] pueden modificarse en tiempo de diseño.
76	73
77	74		- \[Design\] TitleStyle := tsStandard;
78	75		- \[Design\] DefaultRowHeight := 24;
79	76		- \[Code\] EditorBorderStyle := bsNone; // esto debería funcionar únicamente en windows.
80	77		- \[Code\] UseXORFeatures := true;
81	78		- \[Code\] AllowOutBoundEvents := False; {r10992 o posterior}
82	79		- \[Code\] FastEditing := False; (soportado en dbgrid. StringGrid req. r10992 o posterior)
83	80		- \[Design\] AutoAdvance := aaNone;
84	81
85	82		## Referencia de Grids
86	83
87	84		### Información
88	85
89	86		El punto de partida para referencias sobre TCustomGrid, TDrawGrid, TCustomDrawGrid, TCustomStringGrid y TStringGrid es: [Referencia unit Grids.pas](http://lazarus-ccr.sourceforge.net/docs/lcl/grids/index.html)
90	87
91	88		Para TCustomDBGrid y TDBgrid es: [Referencia: unit DBGrids.pas](http://lazarus-ccr.sourceforge.net/docs/lcl/dbgrids/index.html)
92	89
93	90		Hasta hace poco no había demasiado contenido en estos enlaces, debido en parte a la carencia de utilidades que permiten mantener facilmente su contenido: pero finalmente estas herramientas han sido creadas y se ha llenado el vacio de contenido que tenían.
94	91
95	92		En general, cualquier referencia Delphi acerca de las grids deberían ayudar en el uso de las equivalentes de Lazarus (pero no no se debe olvidar que existen algunas diferencias tal como se ha indicado); con esto en mente y como un lugar temporal de referencia de información, este espacio se utilizará para documentar cosas que no funcionan de igual manera en Delphi, aparte de las nuevas funcionalidades de las existentes en Lazarus.
96	93
97	94		Cosas por hacer: el resto de esta sección desaparecerá. Su contenido se trasladará a [Referencia: unit Grids.pas](http://lazarus-ccr.sourceforge.net/docs/lcl/grids/index.html)
98	95
99	96		### TCustomGrid
100	97
101	98		Ver la [[doc:lcl/grids/tcustomgrid.html\|Referencia: TCustomGrid]]
102	99
103	100		#### Propiedad AllowOutboundEvents
104	101
105	102		Protegida en TCustomGrid, pública en TCustomDrawGrid y descendientes. Normalmente cuando un usuario hace click en un punto sobre el espacio vacío después de las celdas (por ejemplo si la grid tiene tres filas pero el usuario hace click sobre una cuarta línea imaginaria), el foco actual se mueve a la celda más cercana a este punto. Llamamos a esto un evento outbound. El valor por defecto de esta propiedad está establecido a True tal como se estableció desde el principio del comportamiento de las grid. Esta propiedad se ha añadido para simular el comportamiento de Delphi donde los eventos outbound no están disponibles, por lo que para habilitar su compatibilidad con Delphi se debe establecer esta propiedad a falso.
106	103
107	104		#### Propiedad Columns
108	105
109	106		Lazarus incluye la propiedad columns' en las grid tipo TStringGrid y TDrawGrid. Esta propiedad añade lo que llamamos columnas personalizadas. Las columnas personalizadas son una colección de objetos con propiedades que se aplican al conjunto completo de columnas que contiene la grid, por ejemplo títulos de las columnas (para una StringGrid sobreescribirá el valor especificado en las propiedades \[ColumnIndex, RowTitle\] correspondientes de las celdas, alineación de texto, color de fondo, etitor preferido, etc.
110	107
111	108		Las columnas personalizadas añaden propiedades extra o reemplazan los valores por defecto de las propiedades en las columnas de la grid normal. No solamente esto, el valor grid.ColCount puede incrementarse o decrementarse para contabilizar el numero de columnas personalizadas añadidas a la grid. En este punto, esto significa grid.ColCount = grid.FixedCols + grid.Columns.Count.
112	109
113	110		Por ejemplo, si a una grid base con with ColCount := 5 y FixedCols := 2 hacemos:
114	111
115	112		- Añadir 3 columnas personalizadas, la grid base estará exactamente como antes, 2 columnas fijas y 3 columnas normales.
116	113		- Añadir una columna personalizada, la grid base tendrá ColCount := 3, esto es 2 columnas fijas y una columna normal.
117	114		- Añadir 4 columnas personalizadas, la grid base tendrá ColCount := 6, esto es 2 columnas fijas y 4 columnas normales.
118	115
119	116		Por tanto podemos concluir que:
120	117
121	118		- Las propiedades de columnas fijas o su cuenta no son afianzadas o modificadas respectivamente por las columnas personalizadas.
122	119		- grid.ColCount es usualmente diferente de grid.Columns.Count (grid.ColCount=grid.Columns.Count solamente cuando FixedCols=0).
123	120
124	121		En tiempo de diseño el usuario puede acceder a las propiedades de columns mediante el Inspector de Objetos para arrancar el editor de columnas. Desde él, se pueden añadir, eliminar o modificar las columnas personalizadas. El editor muestra una lista de las columnas personalizadas mediante la selección de elementos en el listado que nos ofrece el inspector de objetos con las propiedades rellenas para cada columna. El listado de las columnas personalizadas se encuentra también disponible en la vista en árbol de componentes del Inspector de Objetos, donde se pueden añadir, borrar o modificar columnas. Aparecen a un menor nivel bajo la grid (regilla) contenedora.
125	122
126	123		En tiempo de ejecución, las columnas se pueden modificar con un código como este:
127	124
128	125		``` pascal
129	126		var
130	127		c: TGridColumn;
131	128		begin
132	129		// Añade una columna personalizada a la grid
133	130		c := Grid.Columns.Add;
134	131		// La modifica
135	132		c.title.caption := 'Precio'; // Establece el valor caption de la columna.
136	133		c.align := taRightJustify; // Alinea a la derecha el contenido de la columna.
137	134		c.color := clMoneyGreen; // Cambia el valor por defecto a clMoneyGreen.
138	135		c.Index := 0; // La hace la primera columna.
139	136		// Accede a una columna existente
140	137		grid.columns[0].Width := 60; // Cambia el ancho de la columna 0 a 60 pixeles.
141	138		// Elimina una columna existente.
142	139		grid.columns.delete(0); // Elimina la columna 0
143	140		....
144	141		end;
145	142		```
146	143
147	144		Adicionalmente, cuando se utilizan columnas personalizadas, las grids no permiten la modificación directa de grids.colcount; añadir o eliminar columnas se debería hacer utilizando la propiedad columns. La explicación es que hay una inconsistencia al remover gradualmente las columnas personalizadas mediante el uso de ColCount, cuando ColCount llega a FixedCols, la grid no tiene más columnas personalizadas. Si en ese momento incrementamos ColCount, la nueva columna no será del tipo personalizado sino una columna normal.
148	145
149	146		Actualmente no hay planes para hacer que las grids utilicen únicamente columnas personalizadas.
150	147
151	148		### TCustomDBGrid
152	149
153	150		TCustomDBGrid es la base para TDBGrid.
154	151
155	152		No exponen las propiedades Col y Row. Para ir a una determinada columna, utilizar e.g. la propiedad SelectedIndex.
156	153
157	154		Un método público interesante es AutoSizeColumns.
158	155
159	156		#### Procedimiento AutoSizeColumns
160	157
161	158		Este procedimiento establece el ancho (width) al tamaño que abarque el ancho mayor del texto que encuentre. Esto se puede utilizar después de cargar un dataset estableciéndolo a Activo. Sin embargo, contrariamente a TCustomStringGrid.AutoSizecolumns (ver más abajo), esto establecerá tus columnas muy anchas a menos que tengas habilitada la propiedad dgAutoSizeColumns.
162	159
163	160		#### Procedimiento InplaceEditor
164	161
165	162		Ver ejemplo del bug 23103 - e inserta explicación de lo que hace y porque se necesita. ¿Validar valores de entrada? ¿Cambiar lo que se muestra?
166	163
167	164		``` pascal
168	165		procedure TForm1.DBGrid1KeyPress(Sender: TObject; var Key: char);
169	166		var
170	167		S: String;
171	168		begin
172	169		if (Key in [',','.']) then
173	170		begin
174	171		//Al contrario que Delphi no todos los InPlaceEditors son editores para el tipo string, por tanto verificalo.
175	172		if (DBGrid1.InplaceEditor is TStringCellEditor) then
176	173		begin
177	174		S := TStringCellEditor(DBGrid1.InplaceEditor).EditText;
178	175		if Pos(',',S) > 0 then
179	176		Key := #0
180	177		else
181	178		Key := ',';
182	179		end;
183	180		end;
184	181		end;
185	182		```
186	183
187	184		### TCustomStringGrid
188	185
189	186		TCustomStringGrid sirve como base para TStringGrid. Se puede utilizar para componentes derivados TStringGrid que necesiten ocultar propiedades publicadas. Ver [[new intermediate grids]] para más información.
190	187
191	188		Las siguientes propiedades o métodos son públicos y están además disponibles para TStringGrid.
192	189
193	190		Ver la referencia completa para [[doc:lcl/grids/tcustomstringgrid.html\|TCustomStringGrid]]
194	191
195	192		#### Procedimiento AutoSizeColumn(aCol: Integer);
196	193
197	194		Este procedimiento establece el ancho de columna de forma sea suficiente para contener el tamaño del texto más largo que encuentre en todas las filas de la columna aCol. Consejo: ver la opción goDblClickAutoSize para permitir a las columnas redimensionarse automáticamente cuando se realiza el dobleclick en el borde de la columna.
198	195
199	196		#### Procedimiento AutoSizeColumns;
200	197
201	198		Redimensiona automáticamente *todas* las columnas ajustándolas para que quepa el texto más ancho en cada columna. Este es un método rápido de aplicar AutoSizeColumn() para todas las columnas de la grid.
202	199
203	200		#### Procedimiento Clean; overload;
204	201
205	202		Limpia todas las celdas de la grid, fijas o no fijas.
206	203
207	204		#### Procedimiento Clean(CleanOptions: TGridZoneSet); overload;
208	205
209	206		Limpia todas las celdas en la grid sujetas a lo establecido en CleanOptions. Ver [[doc:lcl/grids/tgridzoneset.html\|TGridZoneSet]] para mas información. Algunos ejemplos:
210	207
211	208		- Limpia todas las celdas: grid.Clean(\[\]); (lo mismo que grid.clean)
212	209		- Limpia todas las celdas no fijas: grid.Clean(\[gzNormal\]);
213	210		- Limpia todas las celdas salvo no toca las cabeceras de las columnas: Grid.Clean(\[gzNormal, gzFixedRows\]);
214	211
215	212		#### Procedimiento Clean(StartCol,StartRow,EndCol,EndRow: integer; CleanOptions:TGridZoneSet); overload;
216	213
217	214		Hace lo mismo que Clean(CleanOptions:TGridZoneSet) pero restringiéndolo a lo siguiente StartCol,StartRow,EndCol y EndRow, por tanto acota el contenido a limpiar estableciendo tanto columna como fila de inicio y columna y fila final inclusive. Ejemplos:
218	215
219	216		- Limpia las columnas de indice 4 hasta 6 pero no toca las cabeceras de columna de la grid: algunas variaciones, Grid.Clean(4,Grid.FixedRows,6,Grid.RowCount-1,\[\]); Grid.Clean(4,0,6,Grid,RowCount-1, \[gzNormal\]); etc.
220	217
221	218		#### Procedimiento Clean(aRect: TRect; CleanOptions: TGridZoneSet); overload;
222	219
223	220		Lo mismo que Clean(StartCol,StartRow,EndCol,EndRow, CleanOptions), pero tomando un rectánguno TRect seleccionado en lugar de coordenadas de celdas indivisutales. Útil para limpiar la selección: grid.Clean(Grid.Selection,\[\]);
224	221
225	222		==== Procedimiento SaveToCSVFile(AFileName: string; ADelimiter:Char=','; WithHeader:boolean=true); ====
226	223
227	224		Salva el contenido de la grid a un fichero con formato CSV (Comma Separated Values) conteniendo valores separados por comas (añadido en Lazarus r32179).
228	225
229	226		El argumento AFilename especifica el nombre de fichero en el que se salvará el contenido. Si el fichero existe, se sobreecribe su contenido. Caso de no existir previamente el fichero se crea.
230	227
231	228		Se utiliza ADelimiter (como argumento opcional) para que utilice un separador personalizado en lugar de comas. Por defecto se genera un formato CSV (esto es, ADelimiter:=',';), para poner como separador un tabulador ADelimiter debería valer \#9, correspondiente a TAB.
232	229
233	230		Para decidir si se incluye una "fila de cabecera" o no, se utiliza el parámetro WithHeader. La fila de cabecera es un listado de nombres de campos al comienzo del fichero de salida; su contenido procede de la última fila fija de la grid.
234	231
235	232		Hay una excepción a esta regla: si la grid tiene columnas personalizadas entonces el contenido de la fila de cabecera procede de los títulos de las columnas personalizadas y no del contenido de las celdas de la fila fija.
236	233
237	234		Si WithHeader vale true y la grid no incluye una fila fija o columnas personalizadas, entonces se toma el contenido del la ficha de cabecera desde la primera fila que se encuentra en la grid.
238	235
239	236		Los datos normales de salida CSV deben comenzar en la primera fila no fija de la grid.
240	237
241	238		==== Procedimiento LoadFromCSVFile(AFileName: string; ADelimiter:Char=','; WithHeader:boolean=true); ====
242	239
243	240		Carga el contenido de la grid desde un fichero con formato de valores separados por coma (CSV) (añadido en Lazarus r32179).
244	241
245	242		Las columnas serán añadidas o borradas a o desde la grid según se necesite de acuerdo al número de campos incluidos en cada línea del fichero CSV. Realizar la carga desde un fichero CSV no modificará el número de filas fijas que ya existan en la grid.
246	243
247	244		El argumentoAfilename especifica el nombre de fichero con el contenido CSV.
248	245
249	246		ADelimiter optional parameter may be used to specify a different separator or delimiter. An example: for a tab-separated file, ADelimiter should be \#9. Another popular file format is semicolon-delimited file, where ADelimiter should be ;
250	247
251	248		El parámetro WithHeader se utiliza para decidir si la primera línea en el fichero CSV se considera como la "cabecera de fila" o no. Si la grid tiene filas fijas y WithHeader vale true, entonces los captions de la columna de la última fila fija se utomarán de la fila de cabecera. Ten en cuenta de todas forma que si la grid tiene columnas personalizadas, entonces la fila de cabecera se utilizará como fuente para los títulos columna y los títulos de las columnas personalizadas se muestran siempre en la primera fila fija u oculta si no existen filas fijas en la grid.
252	249
253	250		Si el procedimiento LoadFromCSVFile presenta dificultades para cargar el fichero CSV (e.g. comillas o espacios interpretados incorrectamente), entonces puedes realizar la carga manualmente utilizando e.g. [[CsvDocument]]... y por supuesto un parche para LoadFromCSVFile es siempre bienvenido.
254	251
255	252		#### Propiedad Cols\[index: Integer\]: TStrings lee GetCols escribe SetCols;
256	253
257	254		Obtiene/establece un listado de cadenas desde/hacia la columna índice de la grid comenzando desde la fila índice 0 hasta RowCount-1.
258	255
259	256		##### Ejemplos
260	257
261	258		- Ejemplo para establecer: Establece el contenido de la tercera columna en la grid desde una ListBox
262	259
263	260		``` pascal
264	261		Grid.Cols[2] := ListBox1.Items;
265	262		```
266	263
267	264		- Ejemplo para obtener: Establece el contenido de un Listbox desde la columna índice 4 de la grid.
268	265
269	266		``` pascal
270	267		procedure TForm1.FillListBox1;
271	268		var
272	269		StrTempList: TStringList;
273	270		begin
274	271		StrTempList := TStringList(Grid.Cols[4]);
275	272		if StrTempList<>nil then
276	273		begin
277	274		ListBox1.Items.Assign(StrTempList);
278	275		StrTempList.Free;
279	276		end;
280	277		end;
281	278		```
282	279
283	280		##### Notas.
284	281
285	282		Esta propiedad funciona de una manera diferente en Lazarus respecto a Delphi cuando obtiene datos desde la grid.
286	283
287	284		En Lazarus se crea un objeto temporal del tipo TStringList para obtener el contenido. Es responsabilidad del usuario liberar los recursos de este objeto después de su uso.
288	285
289	286		Esto significa además que los cambios en el listado retornado no afectaran al contenido de la grid o su disposición.
290	287
291	288		Ver el ejemplo "obtener".
292	289
293	290		#### property Rows\[index: Integer\]: TStrings read GetRows write SetRows;
294	291
295	292		Get/set a list of strings from/to the given grid's row index starting from column index 0 to column ColCount-1.
296	293
297	294		##### Notas.
298	295
299	296		Esta propiedad funciona de forma diferente en Lazarus que en Delphi cuando se cogen datos de la grid. En Lazarus se crea un objeto temporal tipo TStringList para recabar el contenido de la fila. Es responsabilidad del usuario liberar este objeto después de finalizar su uso. Esto significa también que los cambios en el listado retornado no afectarán al contenido de la grid o su disposición.
300	297
301	298		##### Ejemplos
302	299
303	300		- Ejemplo para establecer: Establece el contenido de la tercera fila en la grid desde una ListBox:
304	301
305	302		``` pascal
306	303		Grid.Rows[2] := ListBox1.Items;
307	304		```
308	305
309	306		- Ejemplo para obtener: Establece el contenido de una Listbox desde la columna índice 4 de la grid:
310	307
311	308		``` pascal
312	309
313	310		procedure TForm1.FillListBox1;
314	311		var
315	312		StrTempList: TStringList;
316	313		begin
317	314		StrTempList := TStringList(Grid.Rows[4]);
318	315		if StrTempList<>nil then
319	316		begin
320	317		ListBox1.Items.Assign(StrTempList);
321	318		StrTempList.Free;
322	319		end;
323	320		end;
324	321		```
325	322
326	323		- Un ejemplo que no funciona, y su solución: El listado de cadenas es de solo lectura.
327	324
328	325		``` pascal
329	326
330	327		// Esto no funcionará y causará una pérdida de memoria.
331	328		// porque el StringList retornado no se libera.
332	329
333	330		Grid.Rows[1].CommaText := '1,2,3,4,5';
334	331		Grid.Rows[2].Text := 'a'+#13#10+'s'+#13#10+'d'+#13#10+'f'+#13#10+'g';
335	332
336	333		// Solucionando el primer caso.
337	334
338	335		Lst:=TStringList.Create; // Crea el StringList asignándole recursos de memoria.
339	336		Lst.CommaText := '1,2,3,4,5';
340	337		Grid.Rows[1] := Lst;
341	338		Lst.Free; // Libera los recursos de memoria asignados a StringList cuando ya no lo necesitamos.
342	339		```
343	340
344	341		#### Propiedad UseXORFeatures;
345	342
346	343		Propiedad booleana, su valor por defecto es False;
347	344
348	345		Esta propiedad controla como aparece en la grid el rectángulo punteado de foco. Cuando vale true, el rectángulo se pinta utilizando la operación de rasteado XOR. Esto nos permite ver el rectángulo de focus sin preocuparnos del color de fondo que tengan las celdas. Cuando vale false, el usuario puede controlar el color del rectángulo punteado del foco utilizando la \[\[FocusColor property\] Propiedad Focus Color\].
349	346
350	347		Esto controla además el aspecto del redimensionado fila/columna. Cuando vale true una línea muestra visualmente el tamaño que tendrá la fila o la columna si el usuario finaliza la operación. Cuando vale false, entonces el redimensionado de la fila o la columna tendrá efecta tal como el usuario arrastre el ratón.
351	348
352	349		### TValueListEditor
353	350
354	351		TValueListEditor es un control derivado de TCustomStringGrid para edición de pares Key-Value.
355	352
356	353		#### Propiedad DisplayOptions
357	354
358	355		Controla varios aspectos de la aparariencia de TValueListEditor.
359	356
360	357		#### Propiedad TitleCaptions
361	358
362	359		Establece los valores de los captions del título (si doColumnTitles se encuentra en DisplayOptions).
363	360
364	361		Si DisplayOptions carece de vakir doColumnTitles entonces se utilizan los captions por defecto.
365	362
366	363		#### Propiedad Strings
367	364
368	365		Provee acceso al listado de cadenas que alberga los pares Key-Value.\
369	366		Los pares Key-Value deben encontrarse en el formulario:\
370	367		'KeyName=Value'
371	368
372	369		#### Propiedad ItemProps
373	370
374	371		Se puede utilizar esta propiedad para controlar como se pueden editar los elementos en las columnas "Value"\
375	372		Se controla mediante el establecimiento de las propiedades ItemProp's EditStyle y ReadOnly.
376	373
377	374		#### Propiedad KeyOptions
378	375
379	376		KeyOptions es un conjunto de TKeyOptions que controla de que manera el usuario puede modificar los contenidos de la columna "Key".
380	377
381	378		- KeyEdit: el usuario puede editar el nombre y la key.
382	379		- KeyAdd: el usuario puede añadir keys (presionando Insert en la grid). KeyAdd requiere KeyEdit.
383	380		- KeyDelete: el usuario puede borrar pares Key-Value (presionando Ctrl+Delete).
384	381		- KeyUnique: si se establece, entonces las Keys deben tener nombres únicos. Un intento de entrar una key duplicada generará una excepción.
385	382
386	383		#### Propiedad DropDownRows
387	384
388	385		Si el editor de celdas es un picklist (ValueEdit1.ItemProps\['key1'\].EditStyle=esPickList) entonces esta propiedad establece DropDownCount desde el listado mostrado. El valor por defecto es 8.
389	386
390	387		#### Función DeleteRow
391	388
392	389		Borra el par Key-Value de la fila indexada eliminando la fila completamente.
393	390
394	391		#### Función InsertRow
395	392
396	393		Inserta una fila en la grid y establece el par Key-Value. Retorna el índice de la nueva fila insertada.
397	394
398	395		#### Función IsEmptyRow
399	396
400	397		Retorna true si las celdas de la fila insertada están vacias (Keys\[aRow\]=; Values\[aRow\]=).
401	398
402	399		#### Function FindRow
403	400
404	401		Retutns the row that has the specified key name.
405	402
406	403		#### Funcion RestoreCurrentRow
407	404
408	405		Deshace la edición en la fila actual (si el editor está todavía enfocado). Sucede cuando el usuario presiona la tecla Escape (Esc).
409	406
410	407		#### Comportamiento alterada de algunas propiedades derivado de TCustomStringGrid
411	408
412	409		##### Opciones de propiedades
413	410
414	411		Debido a la naturaleza de TValueListEditor sus opciones tienen ciertas restricciones:
415	412
416	413		- goColMoving no está permitida en Options (no puedes establecerla).
417	414		- goAutoAddRows solamente se puede establecer en caso de que KeyAdd se encuentre en KeyOptions. Al establecer KeyAdd automáticamente establecerá goAutoAddRows.
418	415		- goAutoAddRowsSkipContentCheck no está permitida (por tiempo siendo así, causará un crash en TValueListeditor: necesita ser solucionado).
419	416
420	417		##### Propiedad FixedRows
421	418
422	419		Puede valer solamente 1 (mostrar los títulos de las columnas) o 0 (no mostrar los títulos de las columnas).
423	420
424	421		##### Propiedad ColCount
425	422
426	423		Es siempre 2.
427	424
428	425		#### Comentarios generales sobre el uso de TValueListEditor
429	426
430	427		Cuando se manipulan los contenidos de ValueListEditor (la grid), es recomendable manipular las propiedades Strings subyacentes.\
431	428		Si se necesita insertar o borrar filas, entonces cualquiera de los dos realiza esto accediendo directamente a las Strings, o utilizando los métodos públicos de TValueListEditor: DeleteRow(), InsertRow(), MoveRow() and ExchangeRow().\
432	429		Si se intenta utiliza métodos ancestros para manipular las filas o las columnas (e.g. Columns.Add) puede desencadenar un crash.
433	430
434	431		## Trabajando con grids
435	432
436	433		### Personalizando grids
437	434
438	435		Las grid (rejillas) son componentes derivados de la clase [TCustomControl](http://lazarus-ccr.sourceforge.net/docs/lcl/controls/tcustomcontrol.html), y no tienen un widget nativo asociado, lo cual significa que las grids no se encuentran restringidas por el aspecto del tema que tenga el interface en ese momento. Esto puede suponer tanto una ventaja como una desventaja: habitualmente los programadores necesitan crear un aspecto visual uniforme en las aplicaciones. Las buenas noticias son que las grids de Lazarus son suficientemente flexibles para tomar características de ambos mundo; los programadores pueden crear facilmente grids con aspecto similar a otros controles nativos, o las pueden personalizar al detalle más fino por lo que pueden obtener casi el mismo aspecto en cualquier plataforma o interface widget (esto es, con la excepción de las barras de desplazamiento (scrollbars), porque su aspecto viene todavía determinado por el tema en uso).
439	436
440	437		### Propiedades y Eventos para personalizar las grids
441	438
442	439		Algunas propiedades pueden afectar la forma en que se visualiza la grid actuando cuando la celda está apunto de ser pintada en PrepareCanvas/OnPrepareCanvas cambiando las propiedades por defecto del canvas (lienzo) tales como brush color o font. Following is a list of such properties:
443	440
444	441		- AlternateColor. Con esto el usuario puede cambiar el color de fondo por uno que sirve para alternar de fila en fila de forma que sea más legible el contenido. En el dibujo de debajo el valor de AlternateColor:=clLime; que nos da una alternancia verdosa.
445	442
446		-	~~<figure>~~
447	443		<img src="grids_alternatecolor.png" title="grids_alternatecolor.png" width="350" />
448		-	~~<figcaption>grids_alternatecolor.png</figcaption>~~
449		-	~~</figure>~~
450	444
451	445		- Color. Establece el color primario para dibujar el fondo de las celdas no fijas. En el dibujo de encima en color blanco Color:=clWhite.
452	446
453	447		- FixedColor. Este es el color utilizado para dibujar el fondo de las celdas fijas. En el dibujo de arriba que tiene la primera fila de títulos fija y la primera columna también fija FixedColor:=clSkyBlue; les da un color azulado.
454	448
455	449		- Flat. Con Flat:=True; la grid tiene un aspecto plano con Flat:=False presenta un aspecto 3D más estilizado como en el dibujo de arriba.\
456	450		- TitleFont. Establece que fuente se utiliza para dibujar el texto de las celdas fijas de la fila de título.\
457	451		- TitleStyle. This property changes the 3D look of fixed cells, there are 3 settings:
458	452		- tsLazarus. Este es el aspecto por defecto.
459	453		- tsNative. Trata de establecer un aspecto conforme al tema actual del widgetset.
460	454		- tsStandard. Este estilo le da un aspecto más contrastado, similar al de las grids de Delphi.
461	455
462		-	~~<figure>~~
463	456		<img src="grids_titlestyle.png" title="grids_titlestyle.png" width="850" />
464		-	~~<figcaption>grids_titlestyle.png</figcaption>~~
465		-	~~</figure>~~
466	457
467	458		- AltColorStartNormal. Booleano. Si vale 'True: el color de alternancia aparece siempre en la segunda fila después de las filas fijas, , la primera fila después de las filas fijas será siempre el correspondiente al valor de color. Si vale False, entonces el color por defecto se establece a la primera fila, como si no hubiese filas fijas.
468	459		- BorderColor. This sets the grid's border color used when Flat:=True and BorderStyle:=bsSingle;
469	460		- EditorBorderStyle. If set to bsNone bajo Windows los editores de celda no tendrán el borde, como en Delphi, establecer a bsSingle por defecto porque el borde puede ser específico de un tema en algunos widgetsets y para permitir un aspecto uniforme.\
470	461		- FocusColor. El color a utilizar para dibujar la celda actualmente enfocada si UseXORFeatures no está establecida, por defecto FocusColor:=clRed.
471	462		- FocusRectVisible. Turns on/off the drawing of focused cell.
472	463		- GridLineColor. Color of grid lines in non fixed area.
473	464		- GridLineStyle. Pen style used to draw lines in non fixed area, possible choices are: psSolid, psDash, psDot, psDashDot, psDashDotDot, psinsideFrame, psPattern,psClear. default is psSolid.
474	465		- SelectedColor. Color used to draw cell background on selected cells.
475	466		- UseXORFeatures. If set, focus rect is drawn using XOR mode so it should make visible the focus rect in combination with any cell color ackground. It also affects the moving columns look.
476	467		- DefaultDrawing. Boolean. Normally the grids prepare the grid canvas using some properties according to the kind of cell that is being painted. If the user writes an OnDrawCell event handler, a set DefaultDrawing also paints the cell background. If the user draws the cell himself, it is better to turn off this property so painting is not duplicated. In a StringGrid, a set DefaultDrawing dibuja el texto en cada celda.
477	468
478	469		- AutoAdvance. donde irá el cursor de celdas cuando se presione enter, o después de una edición.
479	470		- TabAdvance. donde irá el cursor de celdas cuando se presione Tab o Shift-Tab.
480	471		- ExtendedColSizing. Si vale true entonces el usuario puede redimensionar las columnas no solamente en la cabecera sino a lo largo de toda la altura de la columna.
481	472
482	473		Otras propiedades que también afectan al aspecto de las grids.
483	474
484	475		Options.
485	476
486	477
487	478		La propiedad Options' es un conjunto con algunos elementos para habilitar diversas funcionalidades pero algunas están relacionadas directamente con el aspecto de la grid. Estas opciones pueden establecerse tanto en tiempo de diseño como durante la ejecución del programa.
488	479
489	480		- goFixedVertLine, goFixedHorzLine dibuja respectivamente una línea vertical u horizontal delimitan celdas o columnas en un área fija, activa por defecto.
490	481		- goVertLine, goHorzLine lo mismo que la anterior, pero con un área normal visible. Se puede construir una grid que simule un listbox desestablecidendo estos dos elementos.
491	482		- goDrawFocusSelected si se habilita este elemento entonces se pinta una selección de fondo en la celda con foco en adición al rectangulo punteado con foco (ten en cuenta que esto no funciona todavía cuando la opción goRowSelect está establecida, en tal caso la fila siempre se pinta como si goDrawFocusSelected estuviese establecida).
492	483		- goRowSelect selecciona la fila completa en lugar de celdas individuales.
493	484		- goFixedRowNumbering si se establece, la grid realizará un numerado en su primera columna fija.
494	485		- goHeaderHotTracking si se establece, la grid tratará de mostrar un aspecto diferente cuando el cursor del ratón entre en el área de cualquier celda fija. Para que esto funcione, la zona de celda deseada necedita tener habilitada su propiedad HeaderHotZones. Prueba a combinar esta opción con la propiedad TitleStyle:=tsNative para obtener un aspecto themed hot tracking.
495	486		- goHeaderPushedLook si se establece, este elemento habilita un aspecto de pulsado cuando se hace click en una celda fija. La zona de celda "pulsable" se habilita utilizando la propiedad HeaderPusedZones.
496	487
497	488		(escribir más contenido)
498	489
499	490		### Descripción del proceso de dibujado de las grids
500	491
501	492		Al igual que otros controles personalizados, la grid se dibuja utilizando el método paint. En términos generales la grid se dibuja pintando todas las filas y a su vez cada fila pintando sus celdas individuales.
502	493
503	494		El proceso es el siguiente:
504	495
505	496		- Primeramente se determina el área de las celdas visibles: cada fila es testeada para ver si intersecta con la región de recorte del canvas (lienzo de dibujo), caso de ser así entonces el área visible se pinta dibujando las columnas de cada fila.
506	497		- A continuación se utilizan los valores de columna y fila para identificar la celda que va a ser pintada y de nuevo se testea cada columnapor la intersección con la región de recorte; si todo va bien, entonces se pasan como argumentos al método DrawCell algunas propiedades adicionales tales como la extensión rectangular de la celda.
507	498		- Según avanza el proceso de dibujado se va ajustando el estado visual de cada celda de acuerdo a las opciones y posiciones dentro de la grid. El estado visual se retiene en una variable tipo TGridDrawState que es un conjunto de los siguientes elementos:
508	499		- gdSelected La celda tendrá un aspecto de seleccionada.
509	500		- gdFocused La celda tendrá un aspecto de enfocada.
510	501		- gdFixed La celda tendrá que ser pintada con aspecto de celda fija.
511	502		- gdHot El cursor del ratón se encuentra sobre esta celda, por tanto se pintará la celda con aspecto hot tracking.
512	503		- gdPushed La celda esta siendo clickeada, por tanto se pinta con aspecto de haber sido pulsada.
513	504		- DrawCell. El método DrawCell es virtual y puede ser sustituido (overriden) en grids descendientes para realizar un dibujado personlaizado. La información pasada a DrawCell ayuda a identificar que celda en particular esta siendo dibujada, el área física ocupada en la pantalla y su estado visible. Ver la referencia de DrawCell para más detalles. Lo siguiente sucede para cada celda:
514	505		- PrepareCanvas. En este método, si se establece la propiedad DefaultDrawing , entonces el canvas de la grid se establece con las propiedades por defecto de la brocha (brush) y fuente (font) basadas en el estado visual actual. Por medio de varias propiedades (tanto en tiempo de diseño como de ejecución) se establece la alineación de texto de manera que coincida con la selección del programador en cuanto a las columnas personalizadas si es que existen. En caso de que DefaultDrawing valga false, el color de la brocha (brush) se estable para que valga clWindow y el color de fuente clWindowText, además el valor de la propiedad defaultTextStyle de las grids se utiliza para establecer la alineación de texto.
515	506		- OnPrepareCanvas. si el programador escribe un manejador de evento para el evento OnPrepareCanvas entonces este es llamado en este punto. Este evento se puede utiliar para realizar personalizaciones simples tales como cambiar el color de fondo de las celdas, propiedades de las fuentes como el color, tipografía y estilo, distribución del texto como son sus diferentes combinaciones de alineación: izquierda (left), centro (center), arriba del todo (top), al fondo (botton) o derecha (right), etc. Cualquier cambio realizado al canvas en este evento se perdería porque el siguiente dibujado de celda reseteará el canvas de nuevo a su estado por defecto. Por lo tanto es seguro realizar cambios únicamente para una celda o celdas en particular y olvidarse de esto para el resto. Utilizar este evento ayuda algunas veces a evitarel evento OnDrawCell de las grid, donde los usuarios se verían forzados a duplicar el código de las grids. Por hacer: ¿ejemplos de que puede ser realizado o que no para OnDrawCell?...
516	507		- OnDrawCell. Lo siguiente, si no se ha especificado un manejador para el evento OnDrawCell, es que la grid llama al método DefaultDrawCell, el cual simplemente pinta el fondo de la celda utilizando para ello el color y estilo del brush para canvas actual. Si el manejador OnDrawCell existe entonces la grid pinta primeramente el fondo de la celda pero solamente si la propiedad defaultDrawing está establecida. a continuación llama al evento OnDrawCell para realizar un pintao personalizado. Habitualmente los programadores necesitan realizar un dibujado personalizado solamente para celdas concretas y el estandar para otras; en este caso lo que pueden hacer es restringir la operación personalizada a cierta celda/s mirando denttro de los argumentos ACol, ARow y AState mientras que para las otras celdas simplemente llaman al método DefaultDrawCell y dejan a la grid que se encargue de ello.
517	508		- Text. En este punto (solamente para TStringGrid) si la propiedad DefaultDrawing vale True, realiza el pintado del texto de la celda.
518	509		- Grid lines. El último paso para cada celda consist en pintar las líneas de la grid: si se especifican las opciones de grid goVertLine, goHorzLine, goFixedVertLine y goFixedHorzLine entonces ya se realiza el pintado de la celda. Se pueden obtener grids con únicamente filas o columnas cambiando estas opciones. Si el programador escoge tener un aspecto "themed" esto también se realiza en este punto (ver propiedad TitleStyle).
519	510		- FocusRect. Cuando ya se han pintado todas las columnas de la fila actual llega el momento de realizar el dibujado del rectángulo de foco para la celda actualmente seleccionada o la fila completa en caso de que la opción goRowSelect se encuentre establecida..
520	511
521	512		#### Diferencias con Delphi
522	513
523	514		- En Lazarus el método TCustomGrid.DrawCell no es abstracto y su implementación por defecto realiza el rellenado básico del fondo de la celda.
524	515		- En Delphi, el texto de la celda se dibuja antes del evento OnDrawCell (Ver [bug report \#9619](http://www.freepascal.org/mantis/view.php?id=9619)).
525	516
526	517		### Selección de celdas de la grid
527	518
528	519		La localización de la celda (o fila) actual (enfocada) se puede cambiar utilizando el teclado, el ratón o mediante código. Para cambiar con éxito el foco de una celda a otra posición, debemos comprobar previamente para ver si la posición destino lo admite. Cuando se utiliza el teclado, la propiedad AutoAdvance realiza parte del proceso encontrando cual será la siguiente celda enfocada. Cuando se utiliza el ratón para clickar en la celda o bien mediante código, no se moverá el foco desde la celda actual a menos que la celda destino permita obtener dicho foco.
529	520
530	521		La grid llama a la función SelectCell para ver si una celda es enfocable: si esta función retorna True, entonces la celda destino identificada con los argumentos aCol y aRow es enfocable (la implementación actual de TCustomGrid simplemente retorna true). TCustomDrawGrid y de ahí TDrawGrid y TStringGrid sobreescriben este método para chequear primero si la celda tiene un ancho diferente de cero; normalmente no necesitas una celda seleccionada con un ancho de cero por lo que una celda con estas características es descartada automáticamente en el proceso de encontrar una celda adecuada. La otra cosa que el método SelectCell reemplaza es llamar al evento de usuario configurable OnSelectCell: este evento recibe las coordenadas de la celda como argumentos y siempre retorna una valor por defecto de true.
531	522
532	523		Una vez que se sabe que una celda es enfocable y que el movimiento tendrá lugar, primeramente se llama al método BeforeMoveSelection; este en turnos lanzará el eventoOnBeforeSelection. Los argumentos de este método son las coordenadas de la nueva celda enfocada. En este punto cualquier editor visible se oculta también. La palabra "before" significa que la selección no es cambiada todavía y las coordenadas del foco pueden ser accedidas mediante las propiedades grid.Col y grid.Row.
533	524
534	525		After that, the internal focused cell coordinates are changed and then MoveSelection method is called; this method's purpose is to trigger the OnSelection event if set (this is a notification that the focused cell has, by this time, already changed and cell coordinates are now available through grid.row and grid.col properties).
535	526
536	527		Ten en cuenta que no es bueno utiliza el evento OnSelectCell para detectar cambios en el foco de la celda, ya que este evento se lanzará varias veces para la misma celda en el proceso de encontrar una celda adecuada. Es mejor utilizar los enventos OnBeforeSelection o OnSelection para este propósito.
537	528
538	529		#### Diferencias con Delphi
539	530
540	531		- El comportamiento de SelectCell y OnSelectCell es probablemente diferente - no puedo realmente hacer un comentario sobre las diferencias. En Lazarus se utilizan en funcionalidades tales como AutoAdvance la cual que yo sepa probablemente no existe en Delphi.
541	532
542	533		### Cuando las propiedades de base que trae la grid no son suficiente: grids derivadas
543	534
544	535		Las grids derivadas usualmente tienen que sobreescribir los siguientes métodos:\
545	536		DrawAllRows: Dibuja todas las filas visibles.\
546	537		DrawRow: Dibuja todas las celdas en una fila.\
547	538		DrawRow dibuja todas las celdas de una fila chequeando primeramente si la celda se encuentra en la región del recorten, y dibujando solamente si se cumple dicha situación.\
548	539		DrawCell:\
549	540		DrawCellGrid:\
550	541		DrawCellText:\
551	542		DrawFocusRect:\
552	543		(ampliar esta sección con más contenido).\
553	544
554	545		### ¿Qué sucede en el método `TCustomGrid.Paint`
555	546
556	547		El siguiente listado es para mostrar el orden interno de llamadas a métodos de pintado de un `TCustomGrid` (o descendiente). Cada uno de los elementos en el listado representan llamadas a métodos durante la operación de pintado. Esto debería ayudar a encontrar el punto correcto para cambiar su comportamiento cuando esto viene a descender de `TCustomGrid`.
557	548
558	549		- `DrawEdges`: Dibuja el borde más externo de la grid.
559	550		- `DrawAllRows` (virtual): Dibuja todas las filas en la parte visible de la grid. Este es el único método que se llama en el proceso de dibujado que es declarado `virtual`.
560	551		- `DrawRow` (virtual): Se llama para cada fila dentro de la actual ventana de visualización.
561	552		- `DrawCell` (virtual): Se llama primeramente para cada celda 'normal' (i.e. no fija) en la fila.
562	553		- `PrepareCanvas` (virtual): Establece los estilos de dibujados del canvas de acuredo a las propiedades visuales actuales de las celdas.
563	554		- `DrawFillRect`: Dibuja el fondo de las celdas con los estilos establecidos en `PrepareCanvas`.
564	555		- `DrawCellGrid` (virtual): Dibuja las líneas de borde de las celdas.
565	556		- `DrawFocusRect` (virtual): En `TCustomGrid`este método no hace nada. En las grids descendientes este método se utiliza para dibujar el rectángulo de foco dentro de la celda activa.
566	557		- `DrawCell` (virtual): (ver acerca de) Se llama para cada celda fija en la línea visible dentro de ventana de visualización.
567	558		- `DrawColRowMoving`: Se encuentra activa solamente mientras se mueve una columna o una fila. Este método dibuja la nueva posición de las filas/columnas.
568	559		- `DrawBorder`: Si se necesita (`Flat=TRUE` y `BorderStyle=bsSingle`), esto dibuja una línea de borde interna.
569	560
570	561		#### Métodos adicionales para dibujar en `TCustomGrid`
571	562
572	563		Estos métodos son declarado y (parcialmente) implementados en `TCustomGrid`, pero no son llamados directamente desde aquí. Se utilizan por parte de las clases descendientes para dibujar el contenido de las celdas.
573	564
574	565		- `DrawCellText` (virtual): Escribe/dibuja el texto,que se pasa como parámetro, dentro de la celda. El texto se formatea utilizando los estilos que están activos en `Canvas.TextStyle` (ver también `PrepareCanvas`).
575	566
576	567		- `DrawThemedCell` (virtual): Se utiliza únicamente para las celdas fijas y si `TitleStyle=tsNative`. Dibuja el fondo de las celdas utilizando `ThemeServices`.
577	568
578	569		- `DrawColumnText` (virtual): Se utiliza únicamente en las cabeceras de las columnas de las celdas.
579	570		- `DrawColumnTitleImage`: Si la grid está como un `TitleImageList` asignado y si `Columns.Title[x].Title.ImageIndex` contiene un valor válido, esta imagen es dibujada dentro de la celda.
580	571		- `DrawCellText` : (ver mas sobre esto).
581	572
582	573		- `DrawTextInCell` (virtual): Se utiliza para las celdas 'normal' (i.e. no para las fijas). En `TCustomGrid` este método no hace nada. En las grids descendientes este método se utiliza para dibujar el contenido de las celdas. En `TStringGrid` este método llama a `DrawCellText` (ver más sobre esto).
583	574
584	575		#### Métodos de dibujado introducidos por `TCustomDrawGrid`
585	576
586	577		Como puedes ver la clase base `TCustomGrid` no dibuja contenido dentro de las celdas. Esto es realizado en: `TCustomDrawGrid`. `TCustomDrawGrid` overrides the method `DrawCell` del modo siguiente:
587	578
588	579		- `DrawCell` (override):
589	580		- `PrepareCanvas`: llama al método heredado desde `TCustomGrid`.
590	581		- `DefaultDrawCell` (virtual): Este método se llama solamente si el manejador de eventos para `OnDrawCell` NO está asignado.
591	582		- `DrawFillRect / DrawThemedCell` (de `TCustomGrid`): Dibuja el fondo de las celdas. Si `TitleStyle=tsNative`, entonces el fondo de las celdas fijas se dibuja utilizando `DrawThemedCell`.
592	583		- `DrawCellAutonumbering` (virtual): Si `goFixedAutonumbering en Options`, entonces el número de filas se dibujan dentro de la primera columna fija utilizando `TCustomGrid.DrawCellText`.
593	584		- `DrawColumnText` (desde `TCustomGrid`): Solamente se llama para celdas de cabecera de columna (ver Additional methods to draw in `TCustomGrid`).
594	585		- `DrawTextInCell` (desde `TCustomGrid`): Solamente se llama para celdas 'normales' (i.e. no fijas) (ver Additional methods to draw in `TCustomGrid`).
595	586		- `DrawCellGrid` (virtual): Dibuja los bordes de las celdas.
596	587
597	588		### Salvar y recuperar el contenido de una Grid
598	589
599	590		Los métodos SaveToFile y LoadFromFile permiten salvar y recuperar tanto la disposición como el contenido hacia/desde un fichero con formato XML. TStringGrid, como heredero de TCustomStringGrid, tiene también la habilidad de "exportar" e "importar" su contenido hacia/desde un fichero con formato de valores separados por comas, mejor conocido como ficheros CSV (Comman Separated Values). Esto es descrito en la referencia de los métodos SaveToCSVFile y LoadFromCSVFile (POR HACE: crear enlaces).
600	591
601	592		El tipo de información que puede ser salvada y después recuperada utilizando SaveToFile y LoadFromFile viene determinada por la propiedad SaveOptions (del tipo TSaveOptions) la cual es un conjunto de opciones descritas como sigue:
602	593
603	594		soDesign: Salvar & cargar ColCount, RowCount, FixedCols, FixedRows, ColWidths, RowHeights y Options (TCustomGrid)
604	595
605	596		soPosition: Salvar & cargar Posición de Scroll, Row, Col y Selection (TCustomGrid)
606	597
607	598		soAttributes: Salvar & cargar Colores, Alineación de texto & Disposición, etc. (TCustomDrawGrid)
608	599
609	600		soContent: Salvar & cargar texto (TCustomStringGrid)
610	601
611	602		soAll: Establecer todas las opciones (soAll:=\[soDesign,soPosition,soAttributes,soContent\];)
612	603
613	604		No todas las opciones se aplican a todos los tipos de grids, por ejemplo, soContent no se aplica a las grids derivadas de TCustomGrid como TDrawGrid ya que este tipo de grids no tiene el concepto de "contenido". TStringGrid es un tipo de grid especial que "conoce" como manejar cadenas (strings) y que puede utilizar la opción soContent en caso de que se especifique.
614	605
615	606		La opción soAttributes no se utiliza en las grids standar de Lazarus, se encuentra ahí para las grids derivadas.
616	607
617	608		Cuando se utiliza LoadFromFile la grid también utiliza la propiedad SaveOptions para conocer que tipo de información necesita recuperar desde el fichero, por lo que es perfectamente posible especificar SaveOptions:=\[soDesign,soContent\] al salvar y solamente SaveOptions:=\[soContent\] en la carga. Para una TStringGrid el valor por defecto para SaveOptions es \[soContent\], para otros tipos de grids, SaveOptions es un conjunto vacío..
618	609
619	610		Nota:
620	611
621	612		Una incidencia común tiene lugar cuando se salvan & recuperan datos de la grid al especificar el usuario la propiedad SaveOptions antes que la propiedad SaveToFile pero no antes de LoadFromFile. Cuando se utiliza LoadFromFile algún tiempo después de que se ha utilizado SaveToFile, entonces la propiedad SaveOptions property se establece apropiadamente, pero si se ejecuta LoadFromFile en la próxima ejecución del programa, la propiedad SaveOptions property puede que no haya sido establecida correctamente, por esta razón es recomendable especificar siempre la propiedad SaveOptions justamente antes de LoadFromFile, o haciendo esto mismo globalmente al comienzo del programa como en el siguiente ejemplo:
622	613
623	614		------------------------------------------------------------------------
624	615
625	616		Ejemplo:
626	617
627	618		1. Primeramente, ve al menú en "Fichero -\> Nuevo -\> Proyecto -\> Application";
628	619		2. Emplaza un componente TStringGrid en el formulario (lo veremos como StringGrid1);
629	620		3. Emplaza un componente TButton y otro TOpenDialog en el forumulario (los veremos como Button1 y OpenDialog1);
630	621		4. Añade un evento OnCreate al formulario (tendrá lugar cuando se cree el forumulario).
631	622		5. añade un evento OnClick para el button (tendrá lugar cuando cuando hagamos click sobre el pulsador Button1).
632	623
633	624		``` pascal
634	625		unit Unit1;
635	626
636	627		{$mode objfpc}{$H+}
637	628
638	629		interface
639	630
640	631		uses
641	632		Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, Grids,
642	633		Buttons, StdCtrls, XMLCfg;
643	634
644	635		type
645	636
646	637		{ TForm1 }
647	638		TForm1 = class(TForm)
648	639		StringGrid1: TStringGrid;
649	640		Button1: TButton;
650	641		OpenDialog1: TOpenDialog;
651	642		procedure Button1Click(Sender: TObject);
652	643		procedure Form1Create(Sender: TObject);
653	644		private
654	645		{ private declarations }
655	646		public
656	647		{ public declarations }
657	648		end;
658	649
659	650		var
660	651		Form1: TForm1;
661	652
662	653		implementation
663	654
664	655		{ TForm1 }
665	656
666	657		procedure TForm1.Form1Create(Sender: TObject);
667	658		begin
668	659		//sets the SaveOptions at creation time of the form
669	660		stringgrid1.SaveOptions := [soDesign,soPosition,soAttributes,soContent];
670	661		end;
671	662
672	663		procedure TForm1.Button1Click(Sender: TObject);
673	664		begin
674	665		//Pregunta si se ha lanzado el método Execute de OpenDialog1
675	666		//de forma que cuando esto suceda, el usuario selecciona el fichero .XML a cargar
676	667		//cuyo nombre ha sido almacenado en la propiedad FileName.
677	668
678	669		if opendialog1.Execute then
679	670		Begin
680	671		//Limpia la grid.
681	672		StringGrid1.Clear;
682	673		//Carga desde el fichero .XML seleccionado la grid.
683	674		StringGrid1.LoadFromFile(OpenDialog1.FileName);
684	675		//Refresca la Grid.
685	676		StringGrid1.Refresh;
686	677		End;
687	678		end;
688	679
689	680		initialization
690	681		{$I unit1.lrs}
691	682
692	683		end.
693	684		```
694	685
695	686		------------------------------------------------------------------------
696	687
697	688		Fichero de ejemplo .XML: (Copia el texto de debajo dentro de un fichero tipo texto (txt). No olvides poner la cabecera definitoria xml :-))
698	689
699	690		``` xml
700	691		<?xml version="1.0"?>
701	692		<CONFIG>
702	693		<grid version="3">
703	694		<saveoptions create="True" position="True" content="True"/>
704	695		<design columncount="2" rowcount="5" fixedcols="1" fixedrows="1" defaultcolwidth="64" defaultRowHeight="20">
705	696		<options>
706	697		<goFixedVertLine value="True"/>
707	698		<goFixedHorzLine value="True"/>
708	699		<goVertLine value="True"/>
709	700		<goHorzLine value="True"/>
710	701		<goRangeSelect value="True"/>
711	702		<goDrawFocusSelected value="False"/>
712	703		<goRowSizing value="False"/>
713	704		<goColSizing value="False"/>
714	705		<goRowMoving value="False"/>
715	706		<goColMoving value="False"/>
716	707		<goEditing value="False"/>
717	708		<goTabs value="False"/>
718	709		<goRowSelect value="False"/>
719	710		<goAlwaysShowEditor value="False"/>
720	711		<goThumbTracking value="False"/>
721	712		<goColSpanning value="False"/>
722	713		<goRelaxedRowSelect value="False"/>
723	714		<goDblClickAutoSize value="False"/>
724	715		<goSmoothScroll value="True"/>
725	716		</options>
726	717		</design>
727	718		<position topleftcol="1" topleftrow="1" col="1" row="1">
728	719		<selection left="1" top="1" right="1" bottom="1"/>
729	720		</position>
730	721		<content>
731	722		<cells cellcount="10">
732	723		<cell1 column="0" row="0" text="Title Col1"/>
733	724		<cell2 column="0" row="1" text="value(1.1)"/>
734	725		<cell3 column="0" row="2" text="value(2.1)"/>
735	726		<cell4 column="0" row="3" text="value(3.1)"/>
736	727		<cell5 column="0" row="4" text="value(4.1)"/>
737	728		<cell6 column="1" row="0" text="Title Col2"/>
738	729		<cell7 column="1" row="1" text="value(1.2)"/>
739	730		<cell8 column="1" row="2" text="value(2.2)"/>
740	731		<cell9 column="1" row="3" text="value(3.2)"/>
741	732		<cell10 column="1" row="4" text="value(4.2)"/>
742	733		</cells>
743	734		</content>
744	735		</grid>
745	736		</CONFIG>
746	737		```
747	738
748	739		------------------------------------------------------------------------
749	740
750	741		--Raditz 21:06, 11 Jan 2006 (CET) desde ARGENTINA
751	742
752	743		### Editores de celdas de la grid.
753	744
754	745		La grid utiliza editores de celda para cambiar el contenido de las celdas.
755	746
756	747		Para una grid especializada como TStringGrid, el editor es el usual control editor de simple línea, pero algunas veces es deseable tener otros medios de entrar información. Por ejemplo:
757	748
758	749		1. Mostrar el diálogo de apertura de fichero para encontrar la ubicación de un fichero de manera que el usuario no tenga que teclear el trayecto completo de forma manual.
759	750		2. So eñ texto en la celdai representa una fecha, presentar un calendario emergente de forma que se pueda especificar una fecha facilmente.
760	751
761	752		Algunas veces la información que el usuario debe entrar en una celda está limitada a una lista de palabras; es este caso teclear la información directamente puede inducir a errores y por tanto aparece la necesidad de implementar rutinas de validación. Esto lo podemos evitar utilizando un editor de celda que presente al usuario una lista conteniendo solamente valores legales.
762	753
763	754		Este es también el caso para grids genéricas como TDrawGrid donde el usuario necesita algún tipo de estructura para albergar los datos que serán mostrados en la grid. En esta situación, la información que es entrada en el editor de celda, actualiza la estructura interna para reflejar los cambios en la grid.
764	755
765	756		#### Editores de celdas integrados
766	757
767	758		La unit grids.pas incluye algunos de los editores más utilizados listos para usar en las grids. Es también posible crear nuevos editores de celda (editores de celdas personalizados) en caso de que los integrados no sean suficiente para una tarea específica.
768	759
769	760		Los editores de celdas integrados son Button, Edit, y Picklist.
770	761
771	762		#### Utilizando editores de celdas
772	763
773	764		Los usuarios pueden especificar que editor se utilizará para las celdas escogiendo uno de estos dos métodos.
774	765
775	766		1. Utilizando una columna personalizada y seleccionando la propiedad ButtonStyle de la columna. En este método el usuario puede seleccionar el estilo del editor que se mostrará. Los valores disponibles son: cbsAuto, cbsEllipsis, cbsNone, cbsPickList, cbsCheckboxColumn, cbsButtonColumn.
776	767		2. Utilizando el evento de la grid OnSelectEditor. Aquí el usuario especifica en el parámetro Editor que editor se utilizará para una celda identificada por aCol y row ARow en una grid derivada de TCustomDrawGrid o TColumn en TCustomDBGrid. Para este propósito resultan útil una función pública de las grids, EditorByStyle(), que toma como parámetro uno de los siguientes valores: cbsAuto, cbsEllipsis, cbsNone, cbsPickList, cbsCheckboxColumn, cbsButtonColumn. Este método tiene precedencia sobre el primero utilizando columnas personalizadas. Aquí se puede especificar un editor de celdas personalizado. Este evento es además el lugar para establecer el editor con valres específicos de la celda, fila o columna (e.g. un popupmenu personalizado para el editor de celdas).
777	768
778	769		Establecer la propiedad ButtonStyle solamente funcionará si la columna se crea con la sentencia StringGrid1.Columns.Add;. En caso de utilizar una expresión tal como StringGrid1.ColCount:=X; se originará una excepción. Para establecer la propiedad ButtonStyle se puede hacer con un código similar:
779	770
780	771		``` pascal
781	772
782	773		if ColCB < StringGrid1.Columns.Count then StringGrid1.Columns.Items[ColCB].ButtonStyle:=cbsCheckboxColumn;
783	774		```
784	775
785	776		#### Descripción de estilos del editor
786	777
787	778		La siguiente es una descripción de los estilos de editor. Se enumeran valores de tipo TColumnButtonStyle por lo que utiliza el prefijo 'cbs'. Este tipo se ha utilizado para mantener las compatibilidad con DBGrid de Delphi.
788	779
789	780		- cbsAuto
790	781
791	782
792	783		Este es el estilo por defecto del editor para grids derivadas de TCustimGrid. La clase actual del editor que se utilizará para editar el contenido de las celdas dependerá de varios factores.Para TCustomGrids utiliza una clase TStringCellEditor derivada de TCustomMaskEdit. Este editor está especializado en la edición de cadenas de una sola línea. Es por tanto utilizado por defecto en TStringGrid y TDrawGrid. Cuando se utilizan columnas personalizadas, si el programador rellena Column's PickList apropiadamente, entoces se comporta como si el estilo del editor cbsPickList estuviese establecido. Para una TCustomDBGrid que tenga un campo de tipo booleano, se comportará como si el estilo del editor estuviese establecido a cbsCheckBoxColumn. Este es el valor recomendado para Custom Cell Editors. Por hacer: OnEditingDone relacionado.
793	784
794	785		- cbsEllipsis
795	786
796	787
797	788		Este estilo de editor es el más genérico. Cuando se utiliza, aparece un button en la celda de edición de manera que los programadores pueden utilizar el evento OnEditButtonClick de la grid para detectar cuando el usuario ha presionado el button y por tanto tomar una acción programada para esa celda. Por ejemplo, un programador puede utilizar este estilo de editor para presentar un diálogo emergente tipo calendario para permitir al usuario seleccionar una fecha específica fácilmente. Otras posibilidades podrían ser mostrar un diálogo de apertura de fichero para encontrar ficheros, una calculadora de forma que el usuario pueda introducir el resultado numérico del cálculo, etc.
798	789
799	790
800	791		OnEditButtonClick Es justamente una notificación, para encontrar en que celda se ha clickeado el button mediante la lectura de las propiedades grid.Row y grid.Col.
801	792
802	793
803	794		Una DBGrid tiene propiedades específicas para recuperar la columna activa o campo y dado que este evento tiene lugar en el campo activo, entonces puede actualizar la información que contiene
804	795
805	796
806	797		Este estilo de editor se implementa utilizando TButtonCellEditor, un descendiente directo de TButton.
807	798
808	799		- cbsNone
809	800
810	801
811	802		Este estilo de editor instruye a la grid para que no usue editores para una celda o columna específica; esto se comporta como si la grid fuese de solo lectura para dicha celda o columna.
812	803
813	804		- cbsPickList
814	805
815	806
816	807		Utilizado para presentar al usuario una lista de valores que pueden ser entrados. Este estilo de editor se implementa utilizando TPickListCellEditor, un componente derivado de TCustomComboBox. El listado de valores que se muestran se llena en uno o dos sentidos dependiendo del método utilizado para seleccionar el estilo de editor.
817	808
818	809		1. Cuando se utilizan columnas personalizadas, los programadores pueden introducir un listado de valores utilizando la propiedad de columnas PickList. \[FOR BEGINNERS: TODO: exact procedure to edit the list\]
819	810		2. En OnSelectEditor, los programadores obtienen la instancia TPickListCellEditor utilizando la función EditorByStyle(cbsPickList). [[Grids Reference Page\|Ver aquí para un ejemplo]]
820	811
821	812		`var Lst:TPickListCellEditor; `\
822	813		` begin [...] `\
823	814		` Lst:=TPickListCellEditor(EditorByStyle(cbsPickList)); `\
824	815		` Lst.clear; `\
825	816		` Lst.Items.add('One'); `\
826	817		` Lst.items.add('Two'); `\
827	818		` Editor:=Lst; `\
828	819		` end;`
829	820
830	821
831	822		El valor en una grid tipo TStringGrid reflejará automáticamente el valor seleccionado. Si es necesario el programador puede detectar el momento en que el valor es seleccionado mediante la escritura de un manejador de evento para el evento de la grid OnPickListSelect, por lo que se pueden realizar pasos adicionales (por ejemplo, para procesar un nuevo valor). COSAS POR HACER: relacionado con OnEditingDone.
832	823
833	824		- cbsCheckboxColumn
834	825
835	826
836	827		Puede resulta útil cuando los datos contenidos asociados con la columna se encuentran restringidos a un par de valores, por ejemplo, yes-no, true-false, 1-0, etc. En lugar de forzar al usuario a teclear los valores para estos tipos de datos en un StringCellEditor o escoger de un listado, se usa cbsCheckboxColumn para modificar los datos de una columna mediante el uso de un checkbox en el que el usuario puede facilmente conmutar los valores con un simple click de ratón o presionando la tecla ESPACIADOR (si la columna que contiene el checkbox se encuentra seleccionada y además el StringGrid se encuentra en la modalidad de edición).
837	828
838	829		Obtener o establecer el valor de un checkbox en una celda se realiza de la siguiente manera:
839	830
840	831		``` pascal
841	832		StringGrid1.Cell[x,y]:='Z';
842	833		```
843	834
844	835
845	836		donde Z debe ser reemplazado por o si no marcado, 1 para marcado y una cadena vacío si deshabilitado en color gris (Grayed). Ten en cuenta que cualquier valor (string) diferente de 0 y 1 se mostrará como un checkbox de color gris claro (deshabilitado).
846	837
847	838
848	839		Si la propiedad ButtonStyle de las columnas se establece a cbsAuto y DBGrid detecta que el campo asociado con la columna es un campo booleano, entoces la grid utiliza est estilo de editor automáticamente. Esta selección automática se puede deshabilitar o habilitar utilizando la propiedad OptionsExtra de las DBGrid; estableciendo el elemento dgeCheckboxColumn a false deshabilita esta característica.
849	840
850	841
851	842		Los valores que se utilizan para reconocer los estados de marcado o desmarcado se establecen en las propiedades de columnas ValueChecked y ValueUnchecked.
852	843
853	844
854	845		En cualquier momento, el valor del campo puede estar en uno de estos tres estados: Unchecked, Checked o Grayed. Internamente estos estados están identificados por los siguientes valores de tipo TDBGridCheckBoxState: gcbpUnChecked, gcbpChecked y gcbpGrayed.
855	846
856	847
857	848		Este estilo de editor no utiliza componentes reales tipo TCheckbox para manejar las interacciones de usuario la representación visual viene dada por tres imágenes bitmap internas que se corresponden con los tres posibles estados de checkbox. Los bitmaps utilizados pueden ser personalizados escribiendo un manejador para el evento OnUserCheckboxBitmap de DBGrid; el manejador de este evento obtiene el estado del checkbox del parámetro CheckedState de tipo TDBGridCheckboxState y un parámetro bitmap que el programador puede especificar para bitmaps personalizados.
858	849
859	850		- cbsButtonColumn
860	851
861	852
862	853		Este estilo de editor se utiliza para mostrar un pulsador (button) en cada celda en las columnas. Como en el caso de cbsCheckboxColumn este editor no utiliza pulsadores (buttons) reales sino que su apariencia viene definida por el tema actual del WidgetSet.
863	854
864	855
865	856		El usuario sabe que pulsador en particular ha sido presionado mediante el uso del evento OnEditButtonClick de la grid y chequeando en que fila y columna se encuentra. Fíjate que en este caso en particu. Una vez que el evento OnEditButtonClick se ha gestionado, y si el usuario no ha modificado la fila o columna dentro de este manejador, entonces la grid automáticamente re-establece la columna y fila para reflejar la celda actualmente seleccionada. Mientras se gestiona el evento OnEditButtonClick la actual selección de la grid está disponible en grid.Selection, la cual es una propiedad TRect, donde left y right representan índices columna, siendo Top y Bottom indices fila.
866	857
867	858
868	859		El caption de button es la string correspondiente de la celda.
869	860
870	861		### Editando Grids
871	862
872	863		El efecto de edición es diferente dependiendo de que tipo de grid se esté utilizando, por ejemplo, TStringGrid almacena el texto editado internamente y TDBGrid afecta a los registros dentro del dataset (conjunto de datos). En TDrawGrid (al menos esto debería funcionar para todos las clases de Grids) para acceder al texto editado, el programador puede utilizar el eventoOnSetEditText el cual es disparado cada vez que el usuario modifica algo en el editor, , los parámetros aCol y aRow de este evento identifican la celda que está siendo editada, el valor del parámetro value alberga el texto, este es el método recomendado. Otro camino para acceder al texto editado es tomarlo directamente desde el editor una vez que el proceso de edición ha finalizado utilizando el evento OnEditingDone. This could be accomplished by accessing the internal editor used for editing, in this case, the default "String Cell Editor". Para esto hay dos métodos: El primero es utlilizar el evento OnSelectEditor donde el parámetro Editor es la instacia que se utilizará para editar la celda, tu tiene que almacenar la instancia en una variable, por ejemplo TheEditor (de tipo TStringCellEditor), para posteriormente utilizar OnEditingDone. La segunda alternativa es utilizando el método EditorByStyle de las grids, este método acepta un "editor style" como parámetro y retorna la instancia del editor correspondiente a este estilo. En nuestro caso conociendo que el estilo cbsAuto retorna el editor de celdas por defecto, podemos usar directamente lo sigiente en el manejador de eventos OnEditingDone: TheEditor := Grid.EditorByStyle(cbsAuto) Pudiendo entonces obtener el texto con TheEditor.Text. Si utilizas este método ten en cuenta que "gran poder implica gran responsabilidad" antes de modificar algo.
873	864
874	865		#### Opciones y propiedades que afectan a la edición
875	866
876	867		El comportamiento de la edición se encuentra controlado por un cierto número de propiedades y opciones, virtualmente cualquier ajuste u opciones que afecten a la edición requieren una grid editable o tales ajustes serán ignorados.\
877	868		Al inicio el estado editable de las grids es diferente, para TDrawGrid y TStringGrid la edición está deshabilitada, para TDbGrid está habilitada por defecto.\
878	869		La propiedad Options tiene varios elementos que lidian con la edición, y se encuentran descritas a continuación:\
879	870
880	871		- goEditing, dgEditing (en DbGrid). Esta opción cambia el estado de edición de la grid, se puede cambiar en tiempo de ejecución porque se chequea cuando la edición está apunto de ser iniciada.
881	872		- goAlwaysShowEditor. Normalmente el editor permanece oculto y se hace visible solamente cuando se necesita. Con esta opción, el editor se hará visible todo el tiempo. En caso de que la grid no sea editable esta opción se ingnora y el editor permanece siempre oculto.
882	873
883	874		## Como hacer y Ejemplos
884	875
885	876		#### Enfocando una celda
886	877
887	878		Enfocar una celda en TStringGrid es fácil. Ten en cuenta que la cuenta comienza desde 0 no desde 1, por lo que para enfocar la fila 10, columna 9 hacemos:
888	879
889	880		``` pascal
890	881		StringGrid1.row := 9;
891	882		StringGrid1.col := 8;
892	883		```
893	884
894	885		### Ejemplo: Como establecer un editor de celdas personalizado
895	886
896	887		Ver lazarus/examples/gridexamples/gridcelleditor/gridcelleditor.lpi (desde Lazarus 1.2)
897	888
898	889		### Ejemplo: Como establecer un editor memo para dbgrids
899	890
900	891		Tu puedes, por supuesto, utilizar otro control en lugar de un TMemo. Ajustalo a tu gusto. Adaptado desde [1](http://forum.lazarus.freepascal.org/index.php?topic=3640.0) (simplificado para utilizar la propiedad SelectedFieldRect , ver [2](http://forum.lazarus.freepascal.org/index.php/topic,8713.msg43288.html#msg43288))
901	892
902	893		- Emplaza un control memo o cualquier control que necesites) en tu formulario, establece las propiedades y visible a false. Esto se utilizará cuando se edite una celda de la grid. Nosotros utilizaresmos GridCellMemo en este ejemplo.
903	894
904	895		- En el evento OnSelectEditor ponemos el siguiente código - adáptalo si no necesitas editar la columna lógica 3, columna física 4:
905	896
906	897		``` pascal
907	898		if (Column.DesignIndex = 3) then
908	899		begin
909	900		GridCellMemo.BoundsRect := DbGrid.SelectedFieldRect;
910	901		GridCellMemo.Text:=Column.Field.AsString;
911	902		Editor := GridCellMemo;
912	903		end;
913	904		```
914	905
915	906		- Supón que tu fuente de datos (datasource) se llame Datasource1 y DBGrid se llame ResultsGrid. Entonces, em eñ evemto OnEditingDone para GridCellMemo pon lo siguiente:
916	907
917	908		(En el post original del foro se utilizaba el evento OnChange, que se lanzaría cada vez que el contenido se cambiase. Al utilizar ng OnEditingDone sólamente se lanza después que el usuario ha finalizado con la edición.)
918	909
919	910		``` pascal
920	911		if not(Datasource1.State in [dsEdit, dsInsert]) then
921	912		Datasource1.Edit;
922	913		Datasource1.DataSet.FieldByName(ResultsGrid.SelectedField.FieldName).AsString:=GridCellMemo.Text
923	914		```
924	915
925	916		### Ejemplo: Como añadir un editor pulsador
926	917
927	918		``` pascal
928	919
929	920		// Muestra pulsador de forma condicional en la columna índice 1 o 2 si
930	921		// la celda en la columna de indice 1 está vacía
931	922
932	923		procedure TForm1.StringGrid1SelectEditor(Sender: TObject; aCol, aRow: Integer;
933	924		var Editor: TWinControl);
934	925		begin
935	926		if (aCol = 1) or (aCol = 2) then
936	927		if StringGrid1.Cells[1,aRow] = '' then
937	928		begin
938	929		Editor := StringGrid1.EditorByStyle(cbsEllipsis);
939	930		end;
940	931		end;
941	932
942	933		// Disparando(triggering) acción ...
943	934		procedure TForm1.StringGrid1EditButtonClick(Sender: TObject);
944	935		begin
945	936		if StringGrid1.Col = 1 then Showmessage('Editor columna 1 clickeado');
946	937		if StringGrid1.Col = 2 then Showmessage('Editor columna 2 clickeado');
947	938		end;
948	939		```
949	940
950	941		### Ejemplo: Evitando mostrar campos de texto como "(Memo)" para DBGrids
951	942
952	943		Cuando se utilizan sentencias SQL tales como "SELECT * FROM A" puede que veas "(Memo)" en lugar del contenido en la celda de la grid. Hay varias formas de solucionar esto, pero puede que la más fácil sea cambiar tu sentencia "SELECT * FROM A" por "SELECT CAST (Column as TEXT) AS Column FROM A". Esto es un problema común cuando se utiliza el componente DBGrid.
953	944
954	945		``` pascal
955	946		var
956	947		sql : UTF8String;
957	948		Queryu : TSQLQuery;
958	949		.....
959	950		sql := 'SELECT cast(Name as TEXT) as Name FROM Client';
960	951		Queryu.SQL.Text:=sql;
961	952		```
962	953
963	954		### Ejemplo: Trabajando con Picklist, Como hacerlo de solo lectura y Como llenarlo en tiempo de ejecución
964	955
965	956		Utilizando el envento OnSelectEditor de las grid podemos personalizar el comportamiento del editor PickList (ver estilo del pulsador cbsPickList). En el siguiente ejemplo el editor PickList de la columna 1 se modifica de tal forma que en en las filas impares el usuario puede introducir valores tecleándolos, en las pares los valores están limitados a los contenidos en su listado. Además, este ejemplo muestra como llenar el listado con diferentes valores dependiendo de la fila que se esté procesando.
966	957
967	958		``` pascal
968	959		procedure TForm1.gridSelectEditor(Sender: TObject; aCol, aRow: Integer;
969	960		var Editor: TWinControl);
970	961		begin
971	962		if aCol=1 then begin
972	963		if (Editor is TCustomComboBox) then
973	964		with Editor as TCustomComboBox do begin
974	965		if (aRow mod 2=0) then
975	966		Style := csDropDown
976	967		else
977	968		Style := csDropDownList;
978	969		case aRow of
979	970		1:
980	971		Items.CommaText := 'UNO,DOS,TRES,CUATRO';
981	972		2:
982	973		Items.CommaText := 'A,B,C,D,E';
983	974		3:
984	975		Items.CommaText := 'MX,ES,NL,UK';
985	976		4:
986	977		Items.CommaText := 'ROJO,VERDE.AZUL,AMARILLO';
987	978		end;
988	979		end;
989	980		end;
990	981		end;
991	982		```
992	983
993	984		### Alineando texto en StringGrids
994	985
995	986		Este código muestra como utilizar diferentes alineamientos de texto en las columnas 2 y 3.
996	987
997	988		``` pascal
998	989
999	990		procedure TForm1.StringGrid1PrepareCanvas(sender: TObject; aCol, aRow: Integer;
1000	991		aState: TGridDrawState);
1001	992		var
1002	993		MyTextStyle: TTextStyle;
1003	994		begin
1004	995		if (aCol=2) or (aCol=3) then
1005	996		begin
1006	997		MyTextStyle := StringGrid1.Canvas.TextStyle;
1007	998		if aCol=2 then
1008	999		MyTextStyle.Alignment := taRightJustify
1009	1000		else
1010	1001		if aCol=3 then
1011	1002		MyTextStyle.Alignment := taCenter;
1012	1003		StringGrid1.Canvas.TextStyle := MyTextStyle;
1013	1004		end;
1014	1005		end;
1015	1006		```
1016	1007
1017	1008		### Multilineas en Grids, DBGrid
1018	1009
1019	1010		Este ejemplo muestra como hacer texto multilinea en la celda \[3,2\]. Esto funciona de la misma manera que para DBGrid donde OnPrepareCanvas tiene parámetros para manejarse con TColumns y desde ahí con TFields.
1020	1011
1021	1012		``` pascal
1022	1013
1023	1014		procedure TForm1.StringGrid1PrepareCanvas(sender: TObject; aCol, aRow: Integer;
1024	1015		aState: TGridDrawState);
1025	1016		var
1026	1017		MyTextStyle: TTextStyle;
1027	1018		begin
1028	1019		if (aRow=2) or (aCol=3) then
1029	1020		begin
1030	1021		MyTextStyle := StringGrid1.Canvas.TextStyle;
1031	1022		MyTextStyle.SingleLine := false;
1032	1023		StringGrid1.Canvas.TextStyle := MyTextStyle;
1033	1024		end;
1034	1025		end;
1035	1026		```
1036	1027
1037	1028		### Validating Entered Values
1038	1029
1039	1030		Lazarus en su versión 0.9.29 introduce el evento OnValidateEntry para StringGrid, siendo un evento de tipo TValidateEntryEvent el cual tiene la siguente declaración:
1040	1031
1041	1032		``` pascal
1042	1033
1043	1034		TValidateEntryEvent =
1044	1035		procedure(sender: TObject; aCol, aRow: Integer; const OldValue: string; var NewValue: string) of object;
1045	1036		```
1046	1037
1047	1038		`aCol,aRow son las coordenadas de la celda que se va a validar.`\
1048	1039		`OldValue es el valor que había en la celda cells[aCol,aRow] antes de comenzar la validación.`\
1049	1040		`NewValue es el valor que será finalmente insertado en cells[aCol,aRow].`
1050	1041
1051	1042		Debido a la forma en que trabaja StringGrid, que establece el valor de la celda mientras el usuario está editando (ver evento OnSetEditText de las grid y el método SetEditTex), lo que sucece es que cuando el evento OnValidateEntry se dispara, el valor de la celda que ya contiene el valor entrado (válido o no), puede evaluarse en base a sus argumentos OldValue y NewValue de forma que la validación puede cambiar el valor antiguo si es necesario.
1052	1043
1053	1044		Usualment la valoración ocurre cuando el usuario mueve de la celda actual a otra. En caso de que la validación falle, es deseable que se mantenga el editor de celda tanto visible como enfocado en dicha celda de forma que el valor entrado pueda ser corregido por parte del usuario. Para hacer saber a la grid que la validación ha fallado es necesario que se lance una excepción. La grid en ese momento manejará la excepción con Application.HandleException y cancelará cualquier movimiento.
1054	1045
1055	1046		Por ejemplo, supongamos que cell\[1,1\] deba albergar únicamente valores 'A' o 'B'. En este caso la validación podría realizarse con:
1056	1047
1057	1048		``` pascal
1058	1049
1059	1050		procedure TForm1.GridValidateEntry(sender: TObject; aCol,
1060	1051		aRow: Integer; const OldValue: string; var NewValue: String);
1061	1052		begin
1062	1053		if (aCol=1) and (aRow=1) then begin
1063	1054		if grid.Cells[aCol,aRow]<>'A') and grid.Cells[aCol,aRow]<>'B') then begin
1064	1055		// Establecer un nuevo valor de forma que el usuario pueda presionar RETURN para continuar, por ejemplo.
1065	1056		NewValue := 'A';
1066	1057		// Otra opción es revertir el valor de la celda a su contenido previo (que se asume como válido).
1067	1058		// NewValue := OldValue;
1068	1059		// Utiliza EAbort en lugar de otro tipo de Excepción par evitar errores espureos.
1069	1060		// dialog boxes and backtraces
1070	1061		raise EAbort.Create('Solo se permite A o B aquí');
1071	1062		end else begin
1072	1063		// si no se lanza una excepción, se asume que el valor es válido, todavía si es necesario
1073	1064		// el valor final puede cambiarse todavía mediante el llenado con NewValue con un valor diferente.
1074	1065		// el ordenador lo sabe mejor :)
1075	1066		if grid.Cells[1,1]='A' then
1076	1067		NewValue := 'B'
1077	1068		else
1078	1069		NewValue := 'A';
1079	1070		end;
1080	1071		end;
1081	1072		end;
1082	1073		```
1083	1074
1084	1075		### Ordenando columnas (Columns) o filas (Rows)
1085	1076
1086	1077		La propiedad ColumnClickSorts permite el ordenado automático de la grid cuando el usuario hace click en la cabecera de la columna. Realizando el click varias veces conmuta el tipo de ordenación. Se muestran imágenes de ordenación de columna predeterminadas para indicar que columna ha sido clickeada.
1087	1078
1088	1079		Mediante código se puede utilizar el método SortColRow(). Su primer parámetro es un valor booleano que indica true si lo que se va a ordenar es una columna o false si se trata de una fila. El segundo parámetro es el índice de fila o columna. Los siguientes parámetros son opcionales y seleccionan subrangos de filas (para ordenamiento de columnas) o columnas (para ordenamiento de filas) a ser ordenados. Si no se ha especificado el último parámetro entonces se ordena bien sea la fila o la columna completa. El sistema de ordenación utiliza un algoritmo de ordenado rápido (quicksort) que se puede cambiar en el caso de overrides el método sort() y las llamadas de comparación doCompareCells.
1089	1080
1090	1081		Por defecto esto orcena el contenido de las celdas tanto en orden ascendente como descencente el cual es seleccionable mediante la propiedad SortOrder. Por defecto utiliza el orden ascendente.
1091	1082
1092	1083		``` pascal
1093	1084		// sort column 3 in ascending order
1094	1085		grid.SortColRow(true, 3);
1095	1086
1096	1087		// sort column 3 in descending order, skip fixed rows a top
1097	1088		grid.SortOrder := soDescending; // or soAscending
1098	1089		grid.SortColRow(true, 3, grid.FixedRows, grid.RowCount-1);
1099	1090		```
1100	1091
1101	1092		Para la ordenación personalizada de número, fechas, estados, etc. SgringGrid tiene el evento OnCompareCells que los usuarios pueden utilizar de la manera del siguiente ejemplo:
1102	1093
1103	1094		``` pascal
1104	1095
1105	1096		procedure TForm1.GridCompareCells(Sender: TObject; ACol, ARow, BCol, BRow: Integer; var Result: integer);
1106	1097		begin
1107	1098		// El resultado será uno cualquiera de estos <0, =0, or >0 para un orden normal.
1108	1099		result := StrToIntDef(Grid.Cells[ACol,ARow],0)-StrToIntDef(Grid.Cells[BCol,BRow],0);
1109	1100		// Para el orden inverso simplemente niega el resultado (eg. basado en SortOrder de las grids).
1110	1101		if StringGrid1.SortOrder = soDescending then
1111	1102		result := -result;
1112	1103		end;
1113	1104		```
1114	1105
1115	1106		Puedes utilizar también OnCompareCells cuando está habilitado el reordenado automático de columna a través de la propiedad ColumnClickSorts.
1116	1107
1117	1108		### Ordenando columnas o filas en una DBGrid con flejas de ordenación en la cabecera de la columna
1118	1109
1119	1110		Aquí tenemos un ejemplo que ordenará una DBgrid utilizando el evento OnTitleClick y una TSQLQuery e índices. Esto debería funcionar también para cualquier otro conjunto de datos (data set) como puede ser el caso de TbufDataset.
1120	1111
1121	1112		La función utiliza la propiedad column.tag para almacenar el estado de cada columna en la que realizamos el click, de tal manera que cuando se vuelve a alguna de ellas que previamente ha sido ya ordenada esto aplicará la flecha visual de ordenación correcta. Prerequisitos:
1122	1113
1123	1114		- Se necesita un listado de imágenes para almaenar las flechas de ordenación arriba/abajo. Para ello asignamos el listado de imágenes (imagelist) a la propiedad TitleImageList de la grid.
1124	1115
1125	1116		- Hay que asegurarse de que [[doc:fcl/sqldb/tsqlquery.maxindexescount.html\|TSQLQuery.MaxIndexesCount]] es suficientemente largo para contener los nuevos índices que estamos creando. Para este ejemplo lo hemos establecido a 100.
1126	1117		- Además vamos a necesitar una variable privada para almacenar la última columna que hemos utilizado para ordenar, para este ejemplo se ha llamado FLastColumn.
1127	1118
1128	1119		Para este ejemplo la TSQLQuery que utilizamos la llamamos OpenQuery.
1129	1120
1130	1121		En vistas a reutilizar el componente TSQLQuery con otra sentencia SQL, se deben limpiar los índices después de realizar la ordenación ya que en caso contrario se lanzará una excepción al abrir TSQLQuery con una sentencia de SQL diferente.
1131	1122
1132	1123		``` pascal
1133	1124		FLastColumn: TColumn; // Almacena la última columna que hemos ordenado en la grid.
1134	1125
1135	1126		procedure TSQLForm.ResultsGridTitleClick(Column: TColumn);
1136	1127		const
1137	1128		ImageArrowUp=0; // Debe coincidir con la imagen de flecha arriba contenida en imagelist.
1138	1129		ImageArrowDown=1; // Debe coincidir con la imagen de flecha abajo conenida en imagelist.
1139	1130		var
1140	1131		ASC_IndexName, DESC_IndexName:string;
1141	1132		procedure UpdateIndexes;
1142	1133		begin
1143	1134		// Ensure index defs are up to date
1144	1135		OpenQuery.IndexDefs.Updated:=false; {<<<-- ¡¡¡Esta línea es crítica!!!. IndexDefs.Update no actualizará
1145	1136		// si la encuentra a true, lo cual sucederá en el primer ordenamiento de columna.}
1146	1137		Openquery.IndexDefs.Update;
1147	1138		end;
1148	1139		begin
1149	1140		ASC_IndexName:='ASC_'+Column.FieldName;
1150	1141		DESC_IndexName:='DESC_'+Column.FieldName;
1151	1142		// Los índices no pueden ordenar tipos binarios tales como ftMemo, ftBLOB
1152	1143		if (Column.Field.DataType in [ftBLOB,ftMemo,ftWideMemo]) then
1153	1144		exit;
1154	1145		// Chequea si ya existe un índice ascendente para esta columna,
1155	1146		// en caso contrario, crear uno.
1156	1147		if OpenQuery.IndexDefs.IndexOf(ASC_IndexName) = -1 then
1157	1148		begin
1158	1149		OpenQuery.AddIndex(ASC_IndexName,column.FieldName,[]);
1159	1150		UpdateIndexes; // Asegurarse de que index defs está actualizado.
1160	1151		end;
1161	1152		// Comprobar si ya existe un índice descendente para esta columna,
1162	1153		// caso contrario crear uno.
1163	1154		if OpenQuery.IndexDefs.IndexOf(DESC_IndexName) = -1 then
1164	1155		begin
1165	1156		OpenQuery.AddIndex(DESC_IndexName,column.FieldName,[ixDescending]);
1166	1157		UpdateIndexes; // Asegurarse de que index defs están actualizados.
1167	1158		end;
1168	1159
1169	1160		// Use the column tag to toggle ASC/DESC
1170	1161		column.tag := not column.tag;
1171	1162		if boolean(column.tag) then
1172	1163		begin
1173	1164		Column.Title.ImageIndex:=ImageArrowUp;
1174	1165		Openquery.IndexName:=ASC_IndexName;
1175	1166		end
1176	1167		else
1177	1168		begin
1178	1169		Column.Title.ImageIndex:=ImageArrowDown;
1179	1170		OpenQuery.IndexName:=DESC_IndexName;
1180	1171		end;
1181	1172		// Remover la flecha de ordenamiento de la columna que previamente hemos ordenado.
1182	1173		if (FLastColumn <> nil) and (FlastColumn <> Column) then
1183	1174		FLastColumn.Title.ImageIndex:=-1;
1184	1175		FLastColumn:=column;
1185	1176		end;
1186	1177		```
1187	1178
1188	1179		### Seleccionando Registros en una DBGrid utilizando checkboxes
1189	1180
1190	1181		El objetivo es ser capaz de seleccionar arbitrariamente registros en una dbgrid utilizando checkboxes, la grid tiene la habilidad de mostrar checkboxes automáticamente cuando detecta que hay valores booleanos, para otros tipos d campos el usuario puede escoger manualmente el cbsCheckboxColumn ButtonStyle para la columna. Para este tipo de columnas el usuario directamente hace click en el correspondiente checkbox y como resultado el contenido del campo se modifica apropiadamente.
1191	1182
1192	1183		Pero, ¿que sucede si tal campo no está disponible en nuestro DataSet? ¿o si no necesitamos que la grid entre en modo edición cuando chequeamos el checkbox?. Añadiendo una columna fieldless con ButtonStyle=cbsCheckboxColumn mostrará todos los checkboxes en gris claro y deshabilitados porque no hay un campo enlazado a esta columna y por tanto nada que modificar. Como necesitamos manejar el estado del checkbox por nosotros mismos, necesitamos almacenar el estado en algún lugar para cada registro. Para ello podemos utilizar la clase TBookmarklist (definida en la unidad dbgrids.pas) donde la propiedad CurrentRowSelected puede decirnos si el registro actual está seleccionado o no. Mediante el uso de eventos OnCellClick y OnUserCheckboxState de la grid podemos hacer el seguimiento del estado del checkbox.
1193	1184
1194	1185		Ten en cuenta que esta técnica necesita de Lazarus r31148 o posterior que implementan el event OnUserCheckboxState.
1195	1186
1196	1187		``` pascal
1197	1188		...
1198	1189		uses ..., dbgrids, stdctrls, ...
1199	1190
1200	1191		type
1201	1192
1202	1193		{ TForm1 }
1203	1194
1204	1195		TForm1 = class(TForm)
1205	1196		...
1206	1197		procedure DBGrid1CellClick(Column: TColumn);
1207	1198		procedure DBGrid1UserCheckboxState(sender: TObject; column: TColumn; var AState: TCheckboxState);
1208	1199		procedure FormCreate(Sender: TObject);
1209	1200		procedure FormDestroy(Sender: TObject);
1210	1201		...
1211	1202		private
1212	1203		RecList: TBookmarklist;
1213	1204		...
1214	1205		end;
1215	1206
1216	1207		procedure TForm1.DBGrid1CellClick(Column: TColumn);
1217	1208		begin
1218	1209		if Column.Index=1 then
1219	1210		RecList.CurrentRowSelected := not RecList.CurrentRowSelected;
1220	1211		end;
1221	1212
1222	1213		procedure TForm1.FormCreate(Sender: TObject);
1223	1214		begin
1224	1215		RecList := TBookmarkList.Create(DbGrid1);
1225	1216		end;
1226	1217
1227	1218		procedure TForm1.FormDestroy(Sender: TObject);
1228	1219		begin
1229	1220		RecList.Free;
1230	1221		end;
1231	1222
1232	1223		procedure TForm1.DBGrid1UserCheckboxState(sender: TObject; column: TColumn; var AState: TCheckboxState);
1233	1224		begin
1234	1225		if RecList.CurrentRowSelected then
1235	1226		AState := cbChecked
1236	1227		else
1237	1228		AState := cbUnchecked;
1238	1229		end;
1239	1230		```
1240	1231
1241	1232		### Resaltando (Highlighting) la fila y columna de la celda seleccionada
1242	1233
1243	1234		En Lazarus revision 40276 se ha añadido una opción gdRowHighlight , que funciona de manera similar a goRowSelect pero que utiliza un color más resaltado para el rectángulo de selección y enfoque solamente para para la celda seleccionada y no para toda la fila. Esto funciona bien para filas pero ¿y para las columnas?.
1244	1235
1245	1236		Esta sección presenta un modo de resaltar columnas, filas o ambas (podemos encontrar un ejemplo que resalta solo columnas y filas en lazarus/examples/gridexamples/spreadshee, donde este COMO HACER es realmente una extensión de este ejemplo). Utiliza dos eventos de la grid OnBeforeSelection y OnPrepareCanvas, el dibujado no es necesario.
1246	1237
1247	1238		El evento OnBeforeSelection es disparado cuando when the selection is about the change, en este evento podemos saber que celda está actualmente seleccionada y cual será seleccionada a continuación. Utilizamos esta información para invalidar la fila o columna completas de ambas celdas tanto la antigua como la nueva. Cuando comienza el siguiente ciclo de pintado, la grid será instruida para pintar las celdas que pertenezcan a las áreas invalidadas. Uno de los primeros pasos para pintar se llama evento OnPrepareCanvas (si existe) para configurar las propiedades por defecto de canvas. Nosotros utilizaremos este evento para establecer la fila o columna resaltada:
1248	1239
1249	1240		``` pascal
1250	1241
1251	1242		procedure TForm1.gridBeforeSelection(Sender: TObject; aCol, aRow: Integer);
1252	1243		begin
1253	1244		// Podemos decidir aquí si necesitamos resaltar columnas, filas o ambas.
1254	1245		// En este ejemplo resaltamos ambas.
1255	1246		if Grid.Col<>aCol then
1256	1247		begin
1257	1248		// a change on current column is detected
1258	1249		grid.InvalidateCol(aCol); // Invalida la nueva columna de celda seleccionada.
1259	1250		grid.InvalidateCol(grid.Col); // Invalida la actual columna seleccionada (esta sera la 'old')
1260	1251		end;
1261	1252		if Grid.Row<>aRow then
1262	1253		begin
1263	1254		grid.InvalidateRow(aRow); // Invalida la nueva fila de celda seleccioanda.
1264	1255		grid.InvalidateRow(grid.Row); // Invalida la fila actual seleccionada (esta será la 'old').
1265	1256		end;
1266	1257		end;
1267	1258
1268	1259		procedure TForm1.gridPrepareCanvas(sender: TObject; aCol, aRow: Integer;
1269	1260		aState: TGridDrawState);
1270	1261		begin
1271	1262		if gdFixed in aState then
1272	1263		begin
1273	1264		if (aCol=grid.Col) or (aRow=grid.Row) then
1274	1265		grid.Canvas.Brush.Color := clInactiveCaption; //Esto resaltará además las cabeceras de fila o columna.
1275	1266		end else
1276	1267		if gdFocused in aState then begin
1277	1268		// Dejamos solas la celda actual seleccionada/enfocada.
1278	1269		end else
1279	1270		if (aCol=Grid.Col) or (aRow=grid.Row) then
1280	1271		grid.Canvas.Brush.Color := clSkyBlue; // Resaltamos filas y columnas con el color clSkyBlue.
1281	1272		end;
1282	1273		```
1283	1274
1284	1275		\<\<\>\>
1285	1276
1286	1277		#### property OnBeforeSelection: TOnSelectEvent
1287	1278
1288	1279		#### property OnCompareCells: TOnCompareCells
1289	1280
1290	1281		#### property OnPrepareCanvas: TOnPrepareCanvasEvent
1291	1282
1292	1283		#### property OnDrawCell: TOnDrawCell
1293	1284
1294	1285		#### property OnEditButtonClick: TNotifyEvent
1295	1286
1296	1287		#### property OnSelection: TOnSelectEvent
1297	1288
1298	1289		#### property OnSelectEditor: TSelectEditorEvent
1299	1290
1300	1291		#### property OnTopLeftChanged: TNotifyEvent
1301	1292
1302	1293		#### procedure AutoAdjustColumns;
1303	1294
1304	1295		#### procedure BeginUpdate;
1305	1296
1306	1297		#### procedure Clear;
1307	1298
1308	1299		#### procedure DeleteColRow(IsColumn: Boolean; index: Integer);
1309	1300
1310	1301		#### function EditorByStyle(Style: TColumnButtonStyle): TWinControl;
1311	1302
1312	1303		#### procedure EndUpdate(UO: TUpdateOption); overload;
1313	1304
1314	1305		#### procedure EndUpdate(FullUpdate: Boolean); overload;
1315	1306
1316	1307		#### procedure EndUpdate; overload;
1317	1308
1318	1309		#### procedure ExchangeColRow(IsColumn: Boolean; index, WithIndex:Integer);
1319	1310
1320	1311		#### function IscellSelected(aCol,aRow: Integer): Boolean;
1321	1312
1322	1313		#### function IscellVisible(aCol, aRow: Integer): Boolean;
1323	1314
1324	1315		#### procedure LoadFromFile(FileName: string);
1325	1316
1326	1317		#### function MouseToCell(Mouse: TPoint): TPoint; overload;
1327	1318
1328	1319		#### function MouseToLogcell(Mouse: TPoint): TPoint;
1329	1320
1330	1321		#### function MouseToGridZone(X,Y: Integer): TGridZone;
1331	1322
1332	1323		#### function CellToGridZone(aCol,aRow: Integer): TGridZone;
1333	1324
1334	1325		#### procedure MoveColRow(IsColumn: Boolean; FromIndex, ToIndex: Integer);
1335	1326
1336	1327		#### procedure SaveToFile(FileName: string);
1337	1328
1338	1329		#### procedure SortColRow(IsColumn: Boolean; index:Integer); overload;
1339	1330
1340	1331		#### procedure SortColRow(IsColumn: Boolean; index,FromIndex,ToIndex: Integer); overload;
1341	1332
1342	1333		#### property AllowOutboundEvents:boolean;
1343	1334
1344	1335		Protegida en TCustomGrid, pública (public) en TCustomDrawGrid y descendientes. Normalmente cuando un usuario hace click en un punto sobre un espacio vacío después de las celdas (por ejemplo si la grid tiene tres filas pero el usuario hace click en una imaginaria cuarta fila) la celda seleccionada (que obtiene el foco:focused) se moverá a la celda más cercana al punto que se ha realizado el click, podemos llamar a esto un evento externo y su valor por defecto es verdadero (true) y es un comportamiento que se añadió desde un principio. Esta propiedad fue añadida para simular el comportamiento que tienen en Delphi donde los eventos fuera de su área de acción no estan disponibles. Si se desea mantener la compatibilidad con Delphi se debe establecer esta propiedad al valor falso (false).
1345	1336
1346	1337		### Lo siguiente es ya antiguo pero se deja como referencia, puede que ya esté implementado y/o solucionado
1347	1338
1348	1339		## Todo
1349	1340
1350	1341		- TInplaceEditor Support
1351	1342
1352	1343		### known problems
1353	1344
1354	1345		29-marzo-2005:
1355	1346
1356	1347		- mouse autoedit
1357	1348		- linux: clicking a selected cell doesn't trigger the autoedit function (the editor lost focus inmmediatelly)
1358	1349		- windows: it should work only if the grid has the focus, if not it should focus and a second click should autoedit (cannot detect if the grid was previously focused or not)
1359	1350		- ColumnWidths: linux, windows: dbgrid start with default column widths instead of calculated ones (it's disabled because early canvas creation causes strange effects if the parent is a notebook page)
1360	1351		- Resizing Columns: linux, windows. Resizing a column should not hide the editor (specially in dbgrid if we are inserting)
1361	1352		- MouseWheel:
1362	1353		- linux: mousewheel doesn't work as it should, (seems it's calling the default mousewheel handler)
1363	1354		- windows: patch was sent.
1364	1355		- Double painting: Apparently dbgrid paints the cell background twice (once with fillrect and once in textRect)
1365	1356		- AutoFillColumns: sometimes the clientwidth is evaluated incorrectly (sometimes there are phantom scrollbars)
1366	1357
1367	1358		---
1368	1359		From the Free Pascal wiki, page "Grids Reference Page/es", as it stood on 2022-01-21 after a change by Slawek, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).
1369	1360		Category: Castellano
1370	1361		Category: Español

Back to history