El misterio de los 200…

enero 26, 2012 en Advertencia, Artículos, Comunidad, Delphi, Enlace interesante, Entrada Diario, FireMonkey, LiveBindings, XE2

Aunque ya he comentado el contenido de esta entrada en el foro de facebook, necesitaba colgar de algún lado las fuentes que había utilizado para revisar el tema y de paso, dar la oportunidad para quien todavía no forme parte del mismo pueda acceder a su contenido, o por lo menos a las cosas que parecen interesantes. Es por esa razón que he acabado añadiéndola.

En este caso concreto, el hilo de comentarios del foro se originaba cuando uno de los compañeros, siguiendo las indicaciones del código publicado en el blog de Jim Tierney, que forma parte de los blogs de Embarcadero,  se extrañaba de que al intentar llenar los items de un componente TListBox (en tiempo de ejecución) desde una fuente de datos (un clientdataset, el numero de items añadidos al TListBox era como máximo igual o menor a 200. Y eso sucedía aun cuando dicha fuente de datos contuviera una cantidad mayor.

Esta es la entrada en la que me he basado para reproducir el problema y comprenderlo.

LiveBindings: Code to create TBindLink and fill a Listbox

Creo que lo mas interesante de estas lineas no es ya la corrección que se ha hecho para solucionar el problema, que solo ha consistido en añadir la linea de asignación en el procedimiento FillList( ) de la unidad UMain.pas

LBindList.BufferCount:= ARecordCount;

sino en destacar el punto que originaba el problema:

constructor TBindScopeDBEnumerator.Create(ABindScope: TCustomBindScopeDB;
  const AMemberName: string; ABufferCount: Integer);
begin
  FBindScope := ABindScope;
  FMemberName := AMemberName;
  FSaveActiveRecord := FBindScope.FDataLink.ActiveRecord;
  FNextRecord := FSaveActiveRecord;
  if ABufferCount > 0 then
    FBindScope.FDataLink.BufferCount := ABufferCount
  else
    FBindScope.FDataLink.BufferCount := 200;  // default to max 200 records in buffer
end;

 Al final, ese era el motivo por el que, no estando definido el valor del campo BufferCount en TBindList, cualquier movimiento hacia adelante de la estructura del enumerador, comprobaba si habia llegado al ultimo registro por lo que aunque existiera una cantida mayor en el dataset, el enlace le indicaba que había llegado al último.

:-)

En fin… cosas de los valores por defecto que supongo que sería fijado por algún motivo, porque de hecho el comentario en la misma linea corrobora que se hizo por alguna razón que ahora mismo ciertamente no comprendo.

Lo mas gracioso de todo es que pienso que esto debería por la forma en que se ha planteado afectar en tiempo de diseño por lo que quizás deberíamos comprobar que al crear una relación TBindList desde el editor de expresiones, en tiempo de diseño, el valor del campo en cuestión es correcto. Podéis hacer la prueba y comentamos en el foro. Para probarlo, simplemente acceded a la propiedad LiveBindings del TListBox y cread un nuevo enlace de tipo TBindList. Y seguidamente definid para la propiedad Format un nuevo item con los valores indicados en la rutina FillList( ). En las pruebas que he hecho, también se reproduce el error.

Tened en cuenta este punto para no caer en el problema.

 

 

unit UMain;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Dialogs, Data.DB, Data.Win.ADODB,
  Datasnap.DBClient, FMX.Layouts, FMX.ListBox, FMX.Bind.Editors, Data.Bind.Components,
  Data.Bind.DBScope, Datasnap.Provider, Data.Bind.EngExt, Fmx.Bind.DBEngExt;

type
  TfrmFillListBox = class(TForm)
    lbxData: TListBox;
    bnFill: TButton;
    bnClear: TButton;
    cdsData: TClientDataSet;
    Conexion: TADOConnection;
    qData: TADOTable;
    dsData: TDataSource;
    dspData: TDataSetProvider;
    cdsDataOrderNo: TFloatField;
    cdsDataCustNo: TFloatField;
    BindScopeDB1: TBindScopeDB;
    lbRecordCount: TLabel;
    lbItemsCount: TLabel;
    BindingsList1: TBindingsList;
    procedure bnClearClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure bnFillClick(Sender: TObject);
  private
    { Private declarations }
    procedure FillLabelRecordCount;
    procedure FillLabelItemsCount;
  public
    { Public declarations }
  end;

var
  frmFillListBox: TfrmFillListBox;

implementation

{$R *.fmx}

//fuente del procedimiento: http://blogs.embarcadero.com/jimtierney
//         http://blogs.embarcadero.com/jimtierney/2011/10/03/31601
//
//  El procedimiento encapsula los pasos para rellenar distintos
//  tipos de controles, siguiendo lo que haria el usuario en tiempo de
//  diseño. Es util para el tiempo de ejecución
//
procedure FillList(AControl: TComponent; const AControlExpression: string;
  ASource: TBaseBindScopeComponent; const ASourceExpression: string; ARecordCount: Integer; const ASourceMemberName: string = '');
var
  LBindList: TBindList;
begin
  LBindList := TBindList.Create(nil);
  try
    // Turn off auto properties.
    LBindList.AutoFill := False;
    LBindList.AutoActivate := False;
    LBindList.ControlComponent := AControl;
    LBindList.SourceComponent := ASource;
    LBindList.SourceMemberName := ASourceMemberName;
    LBindList.BufferCount:= ARecordCount; //<- Linea añadida
    with LBindList.FormatExpressions.AddExpression do
    begin
      SourceExpression := ASourceExpression;
      ControlExpression := AControlExpression;
    end;
    LBindList.FillList;
  finally
    LBindList.Free;
  end;
end;

procedure TfrmFillListBox.bnClearClick(Sender: TObject);
begin
  lbxData.Clear;
  FillLabelItemsCount;
  FillLabelRecordCount;
end;

procedure TfrmFillListBox.bnFillClick(Sender: TObject);
begin
  FillList(lbxData, 'Text', BindScopeDB1, 'AsString', dsData.DataSet.RecordCount, 'OrderNo', );
  FillLabelItemsCount;
  FillLabelRecordCount;
end;

procedure TfrmFillListBox.FillLabelItemsCount;
begin
  lbItemsCount.Text:=  'Items.Count: '+IntToStr(lbxData.Items.Count);
end;

procedure TfrmFillListBox.FillLabelRecordCount;
begin
  lbRecordCount.Text:=  'RecordCount: '+IntToStr(cdsData.RecordCount);
end;

procedure TfrmFillListBox.FormCreate(Sender: TObject);

begin
  Conexion.ConnectionString:= 'Provider=Microsoft.Jet.OLEDB.4.0;'+
                              'Data Source=C:\Program Files\Common Files\CodeGear Shared\Data\dbdemos.mdb;'+
                              'Persist Security Info=False';
  cdsData.Open;

  FillLabelItemsCount;
  FillLabelRecordCount;
end;

end.

Nada mas por comentar. Si deseáis ver el ejemplo podéis acceder al siguiente enlace:

Descargar fuentes

Videos demostrativos Firemonkey – Demos (Danysoft)

noviembre 29, 2011 en 64bits, Comunidad, Delphi, Enlace interesante, FireMonkey, Nos deja la semana..., Seminario web, Videos, XE2

 

Con fecha de hoy, Danysoft ha subido a YouTube dos vídeos demostrativos, que sin duda os van a parecer interesantes y es por eso el remarcarlos aquí e incluirlos en esta entrada.

Ambos son parte de la misma sesión: El primero de ellos aborda el tema de Firemonkey desde la perspectiva de Windows, mostrando algunas posibilidades de la plataforma,  como efectos y calidad gráfica propia de los nuevos componentes y del uso de la GPU. El segundo vídeo prosigue la ejecución de la demo en el lado del compilador para Mac, mostrando la ejecución del programa en el simulador de iPhone.

Ya he añadido, igualmente, los enlaces al grupo de Facebook Delphi Solidario, para quienes estáis siguiendo el día a día en él. Gran trabajo el que está haciendo el partner español de Embarcadero, Danysoft, al generar esta colección de recursos que van quedando disponibles para todos nosotros.

Que los disfrutéis.

 

Parte 1.

Rad Studio XE2 | FireMonkey | demo windows

Parte 2.

Rad Studio XE2 | FireMonkey | demo Mac

 

¡Felicidades Septiembre!

septiembre 1, 2011 en 64bits, Ado Express & DataSnap, Delphi, Delphi Prism, Enlace interesante, Entrada Diario, Eventos, FireMonkey, Nos deja la semana..., Noticias, Noticias Delphi, XE2

¿Qué tal estais?  :-)

Espero y deseo que bien.

Hoy retomamos oficialmente, tras estas semanas de descanso,  la actividad de la página, eso sí, :-)  ya con las pilas cargadas y llenos de energia. Y digo oficialmente, porque durante los días anteriores sí que había estado publicando comentarios y remarcando algunos enlaces interesantes en Facebook y Twitter (a partir de ahora también en Google Plus). Muchos de vosotros los habréis leído. La agilidad de las redes sociales, la inmediatez de cuanto se expone, hace un marco inmejorable no ya para transmitir las novedades o redescubrir la información, sino para capturar el pulso de la realidad.

¡Cualquiera diría que no iba a llegar el mes de Septiembre!

Me felicitaba a mi mismo por estar disfrutándolo,  por haber sobrevivido -como mero ciudadano de a pié-, a los vaivenes y a las continuas convulsiones económicas que vivimos y que nos afectan a todos los niveles. ¡Sujetense! -grita alguién a lo lejos- ¡qué esto se cae!… Desgraciadamente, nos despertamos día a día con noticias desalentadoras de la crisis económica y cada vez, el margen para la esperanza es mas pequeño: Dia a día nos hacemos conscientes de la destrucción del tejido empresarial y de la quiebra del sistema financiero, del paro, de la crispación social por los recortes que tiene que acometer el sistema, etc.   Es mas, aun siendo este blog un punto de encuentro de compañeros de una comunidad de programadores, resulta dificil abstraerse del problema económico y social latente y hacer como si no existiera, sin que asome de tapadillo entre las lineas del texto que compartimos. Es por ello, el título que abre este post, que se escribe y se comparte en el contexto del lanzamiento de un producto (Rad Studio XE2) que viene al mundo, -en mi opinión-, en el peor de los escenarios deseables: a un mundo bastante decadente, sumido en una crisis produnda, económica, social y ética.

Posiblemente, -y sigo expresando mi opinión-, sea el contexto económico y social y no la calidad del producto en este caso, quien desluzca esas  novedades que van a ir conociendose de la nueva release o versión. Algunos de los detalles que se conocen son muy prometedores y creo que han generado inquietud o curiosidad (Firemonkey, las plantillas de estilos y los esperados 64 bits). A mi particularmente me gusta lo que he podido conocer de las plantillas de estilo, que pienso abrirá las puertas a una estetica mas acorde a lo que nuestros usuarios se han ido acostumbrando.

 No. No conozco todavía la nueva versión. Lo que se de ella es lo que se ha podido ver en los videos de las presentaciones que van siendo publicados. En facebook ya comentabamos que durante Agosto y Septiembre, se iban a ir sucediendo las 66 presentaciones de RadStudio XE2, que incluían Nueva Zelanda, Argentina, Australia, Austria, Belgica, Brasil, Canada, Colombia, Republica Checa, Dinamarca, Finlandia, Francia, Alemania, Hungria, India, Indonesia, Italia, Japón, Korea, Mexico, Holanda, Noruega, Polonia, Russia, Eslovaquia, España, Suecia, Taiwan, UK y USA. Esta información estaba enlazada desde http://www.embarcadero.com/world-tour

Así que día a día, progresivamente, van a llegarnos durante el mes de Septiembre mas detalles contrastables y fiables, tanto de las cosas buenas como de las que no lo sean.

Para empezar a ver el tema, creo que podríamos acercarnos al video que lanzó Danysoft. Un video corto, de unos 10 minutos, pero que da una idea general bastante buena del producto. Este video se preparó como antesala de las presentaciones que se celebrarán en Barcelona y Madrid a finales de Septiembre. Podéis consultar las fechas en la cabecera del blog.   

Quizás, lo que parece más llamativo de este lanzamiento es la plataforma visual de FireMonkey, que va a dotar a nuestra herramienta de unas prestaciones graficas mas altas, para desarrollos donde se necesiten este tipo de capacidades, vinculadas al 2D/3D. Hasta ahora era una de las asignaturas pendientes que habían hecho que se dependieran de otros motores gráficos.

Ummmmmmmmm…. imagino que quereis ver a FireMonkey en acción. Existen algunos videos y entradas que han sido publicados en las semanas anteriores y que he ido resaltando en las redes sociales.

Por ejemplo. Podeis ver los enlace de Andreano Lanusse, de fecha 3 y 5 de Agosto:

http://www.andreanolanusse.com/en/a-little-bit-about-firemonkey-and-delphi-xe2/

http://www.andreanolanusse.com/en/video-delphi-xe2-and-firemonkey-app-on-windows-mac-and-ios/

 
 

 Seguimos…

Mas videos donde se muestrans las capacidades de FireMonkey nos llega desde Marco Cantú. Con fecha 24 de Agosto nos dejaba un video en you tube, que se enlazaba al post

http://blog.marcocantu.com/blog/firemonkey_betablog_video.html

 

Y finalmente, rebuscando en los enlaces de Danysoft he encontrado 3 detalles adicionales:

http://www.danysoft.com/productos/software/anticipandonos-a-rad-studio-xe2.html

http://www.danysoft.com/productos/software/firemonkey.html

y http://www.danysoft.com/productos/software/las-nuevas-fronteras-de-la-programacion.html

Es precisamente, este último, que por su brevedad pasa inadvertido pero que contiene un pdf que amplia la información sobre las capacidades gráficas de las nueva versión y anticipa el tema de las novedades en DataSnap.

http://www.danysoft.com/free/xe2-articulo-01.pdf

Habrá que estar atento a los articulos sucesivos que vayan publicandose, ya que toda esta información es necesaria de cara a si en un momento posterior decidimos descargar la trial para conocer de primera mano los cambios, poder apreciar los detalles que de otra forma se nos podrían escapar.

Respecto a nuestra Comunidad sale poco a poco del letargo.

Abríamos boca con las publicaciones de Germán Estevez, en el mes de Agosto:

Germán nos dejó un artículo resumen de lo vivido en esas primeras semanas de Agosto (11/08):

http://neftali.clubdelphi.com/?p=1680

Dadle un vistazo. Eran los primeros coletazos del tour de Embarcadero y recogía las anotaciones de David Intersimone, así como uno de los primeros videos sobre Rad Studio XE2. Destacaba en ese post un programa que le habia parecido interesante y que compartía con nosotros:  IOGraph.

Al Gonzalez, otro gran amigo, compartía un truco (16/08) que permitía anclar una ventana e impedir que fuera movida por el usuario.

Inamovible – http://rescatandoadelphi.blogspot.com/2011/08/inamovible.html 

Y finalmente, tambíen compartía con vosotros desde las redes sociales, las aportaciones de Daniel Luyo, en su blog. El enlace que recoge las entradas de Agosto lo tenéis en el enlace siguiente:

http://danielluyo.wordpress.com/2011/08/

Existen un total de 5 entradas. Me parecierón muy interesantes, ya que comparte con nosotros una visión mas cercana a nuestras inquietudes.

Yya finalizando el mes, en estos días pasados, ha iniciado una serie de articulos sobre las novedades de XE2, Rodrigo, muy interesantes y que os aconsejo seguir: 

http://theroadtodelphi.wordpress.com/2011/09/01/exploring-delphi-xe2-vcl-styles-part-i/

Precisamente, abordan el tema de los estilos, que quizás ha sido de los temas que menos se ha hablado y que en mi opinión puede tener un impacto grande sobre nuestros desarrollos, por cuanto va a mejorar notablemente el acabado de los interfaces. Y eso, como dice mi hijo: ¡Mola un montón!  jajajaja  :-)

Siento si queda alguien en el tintero y no hago referencia al mismo. Para escribir la entrada he tomado como referencia los enlaces destacados en mi facebook y posiblemente queden detalles que hayan pasado inadvertidos. Cuento con vuestra ayuda para destacar lo que falte.

En lo que respecta a las fronteras de nuestra C0munidad, me parecieron especialmente interesantes los articulos enlazados que he podido leer en días pasados de Allen Jolub:

http://drdobbs.com/java/231600390?pgno=1

En estas entradas se aborda algunas inquietudes sobre los problemas de la gestión de datos de algunos servicios web de Google. En concreto el habla de las Agendas pero lo hace extensivo a otros servicios, ya que se sirve de este primero para ver los problemas en el tratamiento de datos en los formatos de intercambio. Os aconsejo que lo leáis porque no tiene desperdicio.

El mes de Agosto se despide dejandonos una imagen muy deteriorada de Steve Jobs

Steve Jobs
Apple Shaken to Core
CEO Resigns

http://www.tmz.com/2011/08/24/steve-jobs-apple-ceo-resigns-retires-computers-ipad-iphone-health-issues-pancreatic-cancer/?fb_ref=.TliojyexDXs.like&fb_source=profile_oneline

Cualquier comentario resulta un tanto superfluo. La verdad es que sentí bastante tristeza al verlo tan deteriorado. Pero eso es ley de vida.

Iniciamos Septiembre. Bienvenido y felicidades por seguir viviendo.

 

 

La web de JM

julio 4, 2011 en Código, Componentes, Delphi, Enlace interesante, Entrada Diario, Nos deja la semana...

Quisiera compartir con vosotros lo que me parece una buena noticia para nuestra comunidad y se que algunos compañeros se van a alegrar. Y es que, tras cruzar unos correos con mi amigo Jose Manuel Navarro, me ha permitido reactivar su blog dentro de mi servidor, de forma que pueda ser accesible de nuevo.

:-)   

Así que aprovecho estas lineas para darle las gracias a Jose Manuel. Ya he comentado anteriormente, en las paginas de mi blog, que es un gran amigo, que conozco desde hace ya bastantes años.  

Hay muchos compañeros que seguían al dia de hoy solicitandole código existente en su blog (yo he recibido recientemente uno de los correos que fue el que realmente me alertó de esa posibilidad de alojar sus paginas), y a mi particularmente, me parecía que, dada la calidad de sus artículos, merecia ser rescatado del silencio, aunque realmente no se haga ésto para darle continuidad.  También quisiera destacar que antes de mi, fue Jose Luis en el rinconcito, quien alojó una gran parte de los mismos. Yo he preferido mantener íntegra la apariencia de su blog, de forma que resulta hasta curioso porque para muchos va a resultar como ver una fotografia congelada en el tiempo, alla por el año 2006.

Espero que os gusta la iniciativa y que me vayais comentando -o directamente a Jose- si existe algun problema con alguno de los enlaces.

La web de JM 

Para el código, Jose Manuel, tambien ha habilitado un repositorio en el que se han añadido tanto código como artículos en https://github.com/jmnavarro, y que puede servir en un futuro para alojar mas contenido propio, sea o no de nuestra herramienta o comunidad. Seguro que, de cualquier forma, será tan interesante su lectura como lo fue la de los articulos que escribió para Delphi y C++ Builder.

No quisiera despedir la entrada sin comentar que lamentablemente, toda la parte que hace referencia a sus escritos vinculados con Bolivia, que reflejan su humanidad y su solidaridad, finalmente no pude incluirlos, dada su extensión y la cantidad de referencias que habían de rehabilitarse, en una estructura web clásica como lo era su blog. Lo digo porque muchos de los que visitaron su pagina posiblemente se pregunten donde están y realmente me apenó verme en la tesitura de excluirlos.

Nada mas, me despido deseando que los disfruteis de nuevo.

Expresiones regulares: Novedad en XE (y Parte 3.2)

mayo 31, 2011 en Delphi, Enlace interesante, Entrada Diario, Taller práctico, XE

Con esta última entrada que vamos a compartir, creo que podemos dar por cerrada la serie sobre Expresiones Regulares, al menos en lo que respecta estrictamente al blog. Sin embargo, si que me gustaría anticiparos y compartir con vosotros, de la misma forma que lo he hecho con el grupo que se abrió en Facebook, que voy a intentar mantener vivos y dinámicos algunos de los contenidos relacionados con las entradas, de forma que puedan ser consultados o comentados cuando ya no sean de inmediato interés o las entradas ya no habiliten la posibilidad de comentar porque ha caducado el plazo. Es por eso que existe una nueva opción en el menú “Temas de discusión”, inaccesible de momento, pero que se activará si Dios quiere en un breve espacio de tiempo, (que ahora mismo no os puedo confirmar): ¿una semana? ¿un mes? Ni idea. Posiblemente, sea necesario ser miembro del grupo de Delphi Básico en Facebook para acceder al mismo.

De momento he creado cuatro temas de discusión que me parecen interesantes y que están directamente relacionados con entradas de estos últimos meses o del año anterior: el framework del conjunto de entradas de Un día con los mayores, el módulo de control de presencia, el componente TPanelMiniaturas que pudimos compartir con Germán y por último, el que representa a esta última serie sobre Expresiones Regulares.

Todo esto esta un poco en lo alto, madurando y casi diría fermentando… :-)

Cualquier comenario que deseeis hacer sobre esto, lo podeis escribir en el muro del grupo de facebook (no en mi cuenta de facebook personal por favor).

Y por fin llegaron los postres…

Delphi 2007: PerlRegEx y su componente TPerlRegEx

Si hemos optado por Delphi 2007 o cualquiera de las versiones anteriores incluidas en los componentes que descargamos. ¡Enhorabuena!. Has sido un tipo listo, porque no tienes por que esperar a la renovación del IDE para disfrutar de ”algo” que te pueda ahorrar un esfuerzo y un trabajo, con independencia de que este sea más o menos grande. No… no es que ahora sea todo reducido a una expresión regular. No… la idea es mas sencilla, más simple: Si encuentras un motivo para usarla, hazlo, porque posiblemente sea una buena inversión, ya que su uso va a ahorrarte bastantes lineas de código y además no va a ser algo que va a crearte problemas en esa posible actualización del entorno, si decides actualizarte a XE.

Vamos a entender este punto:

Una vez instalado el componente en el IDE podremos usarlo de la forma habitual, como cualquier otro componente de la paleta. En mi caso, y en el primero de los ejemplos, hemos hecho uso en tiempo de diseño de forma que nos despreocupamos tanto de la creación como de la destrucción. Tan solo debemos centrarnos en 3 aspectos claves:

  • Necesitamos asignar la expresión que se va a usar.   
    • (pre.RegEx:= edCadenaBusqueda.Text;)
  • Necesitamos asignar el texto que se va a evaluar de acuerdo a esa expresión
    • (pre.Subject:= s;)
  • Y finalmente, necesitamos invocar el procedimiento que pone en marcha el proceso de analisis y compilación de la expresión
    • (if pre.Match then...) 

 A partir de ese momento, ya nos es posible evaluar si ha tenido exito gracias al método FoundMatch. También podemos conocer qué posición ocupa en primer caracter encontrado, que cumple la expresión, gracias a MatchedExpressionOffset y que longitud tiene el término MatchedExpressionLength.

 Y en el caso de querer seguir buscando la expresión, simplemente sería algo tan sencillo como usar MatchAgain, nos avanzaría hasta la siguiente posición encontrada, de la misma forma que hemos comentado en el parrafo anterior.

En el ejemplo se puede ver claramente como avanzamos de forma progresiva a lo largo del texto, hasta encontrar todas las palabras que cumplen la expresión regular.

 Término   Posición   Longitud 
Mancha 19 6
hidalgo 95 7
rocín 149 5
rocín 702 5
hidalgo 760 7

 Guardar en la mente que estamos trabajando con cadenas no Unicode sino AnsiString. Esto lo vamos a ver de reojo en el apartado próximo. Pero antes, y volviendo al comentario que iniciaba éste, la mecánica de trabajo que vamos a utilizar por ejemplo desde Delphi XE, a nivel de la unidad RegularExpressionsCore va a ser similar. Cambian los collares pero los perros son los mismos.

Podemos comparar esos chuchos:   :-)

Salvando que ahora necesitamos crear y destruir dinámicamente la instancia de TPerlRegEx, puesto que ya no tenemos un componente sino un objeto, los metodos que usamos tienen nombres similares como era de esperar. A fin de cuenta estamos usando una importación de la librería y ya se han abstraido los conceptos aplicados a la funcionalidad. Asi pues tenemos de igual forma las propiedades RegEx y Subject, que esperan respectivamente la expresión y el texto a evaluar. Seguimos teniendo Match y MatchAgain. Y tan solo respecto a nuestro ejemplo, nos ha variado que MatchedExpressionOffset ahora es MatchedOffset y MatchedExpressionLength se convierte en MatchedLength.

No parecen unos cambios muy complejos…  :-)

 

RegularExpressionsCore Vs RegularExpressions 

 

Si nos decidimos a ejecutar el ejemplo 2, que utiliza el módulo RegularExpressionsCore, obtenemos un resultado un tanto diferente del ejemplo anterior. Permitidme unos cambios rápidos en el código… veamos… cambiad tanto en el cuerpo de la accion Iniciar como en Seguir las dos lineas, de forma que sean similares a las que teníamos en el primer ejemplo:

      rchContenedorTexto.SelStart:= ConvertirOffSet(pre.MatchedOffset-1);
      rchContenedorTexto.SelLength:= Length(UTF8ToString(pre.MatchedText)); 

 por

      rchContenedorTexto.SelStart:= pre.MatchedOffset-1;
      rchContenedorTexto.SelLength:= pre.MatchedLength; 

Esta es la nueva lectura que podemos hacer: 

 Término   Posición   Longitud 
Mancha 19 6
hidalgo 96 7
rocín 150 6
rocín 717 6
hidalgo 776 7

 ¡Veis! Comparad unas y otras. Ya no nos coinciden y por lo tanto, las selecciones de texto en nuestro componente RichEdit andan digámoslo como desenfocadas. 

:-D

Esa es la magia de Unicode frente a AnsiString. Las vocales acentuadas que aparecen en algunas palabras del texto (como vivía, rócín, más, etc…) van a retornar un Offset y un valor de Length aparentemente incorrectos y ciertamente, esto no es exactamente así. Por tal motivo he utilizado en el ejemplo 2 un array de enteros y una función que corrige la posición.

El motivo de esta contrariedad es simple y de forma llana porque estamos trabajando con cadenas unicode UTF8String, y la codificación de éstas varía entre 1 y 4 bytes según el punto de codigo que consideremos. Para todos aquellos caracteres con mas de 1 byte, ese byte posterior al primero, tanto si consideramos el de dos, tres o cuatro bytes, tiene siempre la estructura binaria [10xxxxxx] donde esos primeros 2 bits (10) son fijos y el resto variable, dependiendo en conjunto de la codificacion del resto de bytes. Eso nos ha permitido de forma sencilla recontar los caracteres (descartando en el conteo los caracteres que representaban ese byte posterior)  y recalcular el offset (ConvertirOffSet( ))  

Hay un ejemplo muy bueno en Wikipedia que explica visualmente este punto. Os aconsejo la lectura así como la del libro de Marco Cantú “La guia de Delphi” (2010) donde se habla abiertamente del cambio a Unicode en nuestro entorno de desarrollo.

 http://es.wikipedia.org/wiki/UTF8

http://es.wikipedia.org/wiki/Archivo:Codificaci%C3%B3n_UTF-8.svg

 

Todo esto comentado, va a influir en nuestra decisión de elegir entre las dos formas de trabajo distintas: una por decirlo de alguna forma de más bajo nivel, RegularExpresionsCore, que manipulará tanto a nivel de parámetros como retorno de funciones cadenas UTF8String. De hecho, en el constructor de la clase, se ocultan las opciones de creación que por defecto, para que esto no pueda ser cambiado, por razones obvias. Notad como estas constantes no estan definidas en el conjunto de opciones TPerlRegExOptions, que tambien van a combinarse previa a la compilación.

constructor TPerlRegEx.Create;
begin
  inherited Create;
  FState := [preNotEmpty];
  FCharTable := pcre_maketables;
  FPCREOptions := PCRE_UTF8 or PCRE_NEWLINE_ANY;
end;

Y por otro lado RegularExpressions, una capa por encima de la anterior, permitiendo que trabajemos directamente con nuestras cadenas habituales String unicode, de forma que para nuestra selección del texto, no nos ha hecho falta ningun mecanismo adicional que haga el recalculo. Por lo demas, podeis usar sin problema tanto una forma como otra. Si os hace falta obtener el mapa de coincidencias, lo mas sencillo es que os decidais por la capa de nivel superior.

 Bueno. Nos despedimos aquí. Es posible que queden algunas dudas. Mi consejo en ese caso es que activeis la depuración de los dcus en las opciones del compilador y recorrais con puntos de parada también las clases que participan. Es una buena forma de comprender que sucede realmente entre bastidores.

 Espero que os haya gustado y que os pueda ser útil.

 

Entradas relacionadas: 

Join the forum discussion on this post

Presentación de la preliminar de Delphi 64bits.

abril 4, 2011 en 64bits, Enlace interesante, Entrada Diario, Nos deja la semana..., Noticias, Noticias Delphi, Ofertas, Presentaciones, Promociones, Videos, XE

:-)

Hola a todos:

Interrumpo el silencio del blog, habitual durante los días laborales, porque creo que la noticia vale la pena.

Hoy he podido leer en facebook que se había presentado el primer video sobre Delphi 64 bits y no he tardado en acceder al enlace en Embarcadero. Ipso facto…  jajajajaja

Os recomiendo que accedais al video disponible en el link:

http://www.embarcadero.com/products/delphi/64-bit  

Aunque esté en Inglés, no creo que tengais demasiado problema en seguirlo ya que la información que visualiza es lo suficiente descriptiva para entender el contenido.

En principio, también se encuentra disponible el acceso a conocer mas detalles de la beta pero existen algunas restricciones, propias de la cantidad de peticiones así como la preferencia de los usuarios de Delphi XE y RAD Studio XE.

http://forms.embarcadero.com/forms/Delphi64-bitCompilerInformation

Me parece una fantastica noticia y personalmente creo que tiene muy buena pinta. Me ha gustado mucho lo que he visto. 

:-)

Ahhh… se ha ampliado el plazo de la oferta de actualización a Delphi XE y Rad Studio XE, finalizando ésta el 31 de Mayo (con un plazo máximo para registrar el producto del 14 de Junio).

http://www.embarcadero.com/radspecial