Archivo

Entradas Etiquetadas ‘Programación’

Gratis, C++Builder® 10.1 Berlin Starter Edition

Viernes, 17 de Junio de 2016 Sin comentarios
Share Button

PROMOCIÓN ESPECIAL!!

Hoy (y no se si algunos días más) se puede descargar desde la web de embarcadero la versión Starter de C++ Builder 10.1 Berlín.

ClGAk_cXEAAcHbA

 

Enlace a la página.

Vídeo mostrando las características de esta versión.

Un saludo.

Share Button

Replay de las sesiones de la DelphiWeek 2015

Martes, 7 de Abril de 2015 Sin comentarios
Share Button

Si te perdiste las sesiones de la DelphiWeek 2015, ya están disponibles todas las sesiones en esta lista de reproducción de Embarcadero Technologies.

Vale la pena revisarlas, porque algunas son muy interesantes. Hay un poco de todo, de carácter general, técnicas, algunas más “offtopic” y otras referentes a partners y componentes comerciales.

Delphi banner

 

Aquí tenéis una lista completa de las sesiones:

Espero que las encontréis interesantes.

 

Un saludo y hasta la próxima.

Share Button

StackOverflow en Español, nueva propuesta

Jueves, 2 de Agosto de 2012 2 comentarios
Share Button

 Link a a propuesta

Propuesta StackOverflow en Español

Creo que es una buena e interesante iniciativa para la comunidad.

La explicación completa y detallada del proyecto y de lo que se necesita, la tienes aquí, en el Blog de jachguate.  Échale un vistazo y anímate.

Un reto:

  • 60 seguidores.
  • 40 preguntas de ejemplo, con al menos, 10 votos cada una.

¿Lo conseguiremos?  ;-)

TRUCO: Nos interesa que las preguntas lleguen a 10 votos, pero no más; Es decir, es mejor repartir votos para que el máximo de preguntas lleguen a ese límite de 10. ;-)

Share Button
Categories: Programación Tags: ,

Sobre las RXLib (Recopilatorio)

Viernes, 27 de Noviembre de 2009 26 comentarios
Share Button

Personalmente soy de los que llevo unos cuantos años utilizando las RxLib. Siempre me han parecido unas librerías muy buenas y estables.
Hace un tiempo realizé una traducción (no oficial) de la versión para Delphi 7, para traducirla a Delphi 2005/2006.

Desde ese día hasta hoy, no son pocos los programadores que se han puesto en contacto conmigo, vía correo electríonico o vía mi web para pedirme esa versión o para comentarme cosas sobre versiones posteriores.

Así que me he decidido ha hacer esta recopilación de diferentes versiones, oficiales, no-oficiales, recursos,…

Os adjunto también algo de información de cada una de ellas. En la mayoría de los casos datos del autor y poco más, extraídos de los fuentes o de los archivos TXT que incluyen.

(27/04/2017)
Jhonny, Administrador y moderador  de los foros del ClubDelphi, ha portado la ultima versión disponible en la página http://www.micrel.cz/RxLib/ a la versión 10. 2 Tokyo.
Aquí tenéis el enlace a blog donde podéis leer la entrada y descargar los fuentes, que también adjunto debajo de este mensaje.
 (20/12/2016)
En esta página podéis descargar versión no oficial para las últimas versiones de Delphi XE/, XE8, 10 Seatle y 10.1 Berlín.
 (13/01/2015)
Versión no oficial con fecha de Mayo del 2014 compatible con Delphi XE6
(28/03/2012)
Nueva versión no-oficial, de las RxLib. Revisión 1.08. Incluye soporte para la útltima versión de delphi (XE2) y segun el documento con las modificaciones, también soporte para 64 bits.

(02/02/2012)

Añadida versión no-oficial de las RxLib (2.75  build 1.07); Añade un componente nuevo y corrige algunos bugs de la anterior.  Según la documentación comprende versiones delde D2005 hasta Delphi XE2.

(13/09/2011)

Añadida versión “no-oficial” con soporte para Delphi XE2. Corregisdos algunos errores relacionados con Unicode y el componente rxMemoryData.

(18/03/2011)

Versión “no-oficial” de las RxLib que soporta DelphiXE. Esta incluye nuevas funciones y nuevos componentes (17 según leo). Podéis ver la los cambios principales introducidos en esta versión revisando esta página.

También he subido una recopilación de todos los recursos en los diferentes idiomas para la versión 2.75(Bulgarian, Chinese, Chinese (traditional), Czech, Danish, Dutch, French, Galician, German, Geek, Hungarian, Italian, Korean, Mexican, Polish, Portuguese, Romanian, Serbian, Slovene, Spanish, Slovak, Swedish, Turkish, Ukrainian).

(17/02/2011)

Versión (no oficial) para RAD Studio XE; Compilado sin problemas; Incluye packages para Delphi 6 y posteriores hasta RAD Studio XE, junto con las Demos y la ayuda.

____________________________________________________________

Versión para Lazarus.

Lagunov Aleksey (alexs)
ALEXS75-at-YANDEX-dot-RU

Versión 2.75 para versiones antiguas de Delphi y C++Builder

Los recursos traducidos a español de la versión 2.75

La últimas versión oficiales de las RxLib. 2.75. Comprimidas y con instalador.

qmd@usercontrol.com.br
http://www.usercontrol.com.br
icq: 15630894

Neftalí -Germán Estévez-. El que suscribe estas líneas.

Adapted: psa1974

Steve Jordi.

________________________________________________________

Os adjunto también este link, que permite acceder a la ayuda en línea, a partir de las imágenes de los componentes que aparecen en la paleta de las RxLib.

RxLib Help

AÑADIDO: Adjunto esta página (traducción automática al castellano) que también hace un recopilatorio de páginas ynoticias relacionadas con las RxLib. Está originalmente en ruso y traducida utilizando el traductor de Google.

Share Button

Inventario de software instalado (WMI)

Martes, 24 de Noviembre de 2009 2 comentarios
Share Button

Siguiendo con los ejempos y ahondando en las posibilidades de WMI (Windows Management Instrumentation), a raiz de este hilo en los foros del ClubDelphi, referente al software instalado en nuestro ordenador, he probado a obtener la lista de programas instalados utilizando la WMI.

Para ello podemos utilizar la clase Win32_Product.
Si accedemos a su descripción en MSDN, obtenemos la siguiente descripción de la clase:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Win32_Product : CIM_Product
{
  uint16   AssignmentType;
  string   Caption;
  string   Description;
  string   IdentifyingNumber;
  string   InstallDate;
  datetime InstallDate2;
  string   InstallLocation;
  sint16   InstallState;
  string   HelpLink;
  string   HelpTelephone;
  string   InstallSource;
  string   Language;
  string   LocalPackage;
  string   Name;
  string   PackageCache;
  string   PackageCode;
  string   PackageName;
  string   ProductID;
  string   RegOwner;
  string   RegCompany;
  string   SKUNumber;
  string   Transforms;
  string   URLInfoAbout;
  string   URLUpdateInfo;
  string   Vendor;
  uint32   WordCount;
  string   Version;
};

Podemos disponer así de toda la información, referente a cada uno de los programas/aplicaciones instalados en nuestro equipo (*NOTA*).

Para ello, lo primero que debemos hacer es Importar a Delphi la librería “Microsoft WMI Scripting v1.X Library (Version 1.X)“, si no lo hemos hecho ya.
En la Introducción sobre WMI, se explica un poco más detalladamente.

Una vez importada, lo siguiente (dentro de nuestro ejemplo) es conectar con nuestro proveedor (en este caso nuestra máquina local):

1
2
3
4
5
6
    // Create the Location object
    Locator := CoSWbemLocator.Create();
    // Connect to the WMI service, with the root\cimv2 namespace
    aServices := Locator.ConnectServer(STR_EMPTY, {Server}
        STR_CIM2_ROOT, {user}STR_EMPTY, {password}STR_EMPTY,
        STR_EMPTY,STR_EMPTY, 0, nil);

A continuación, si la conexión ha sido correcta, realizamos la consulta sobre la clase Win32_Product, que nos dará la información que necesitamos.

1
2
3
// realizar la consulta
ObjSet := Services.ExecQuery('SELECT * FROM Win32_Product',
 'WQL', wbemFlagReturnImmediately and wbemFlagForwardOnly , nil);

A partir de ahí basta con recorrer los elementos obtenidos y e nuestro caso formatear algunas propiedades para mostrarlas (Caption, InstallDate, Vendor y Version), aunque todas las demás están igualmente a disponsición del programador.

Recordad de colocar en el USES las dos units comentadas antes.

Se puede descargar el código de ejemplo desde aquí y el ejecutable compilado desde aquí.

<Ejemplo_sources>

<Ejemplo_Ejecutable>

(*NOTA*): Recordemos (link), que una de las características de WMI es que permite “Administración remota”, con lo que si tenemos los suficientes permisos, este código también puede servir para inventariar otras máquinas.

Share Button

WMI – Introducción

Martes, 24 de Noviembre de 2009 2 comentarios
Share Button

No hace mucho me cruce con esta “palabrota” este concepto: WMI.

A priori parece sólo eso, una “palabrota” más, de las muchas que nos encontramos en nuestro día a día “informático”. Pero rascando, rascando ha aparecido una perla oculta bajo una capa de polvo.

WMI son las iniciales de “Windows Management Instrumentation”. Se me hace complicado explicar en pocas palabras qué es, pero si tuviera que hacerlo, diría que es algo así como “Una puerta de acceso a la Administración de Sistemas Windows” ( ;-D Windows Management Instrumentation).

Junto a WMI aparecen dos “palabrotas” dos conceptos más que nos ayudan a saber de dónde viene.

  • WBEM (Web-Based Enterprise Management )
  • CMI (Common Model Information).

Si las juntamos todas nos queda que, WMI es una implementación que Microsoft ha hecho para Windows, de un estandard llamado WBEM que sirve para la administración de sistemas vía web y que está basado en CIM, que vienen a ser unas clases que nos dan acceso a diferente información del un equipo.

(Traducción al idioma Terrícola):

“A través de WMI yo puedo administrar un equipo basado en Windows, local o remoto, independientemente de la versión del sistema, utilizando las clases que me provee CIM.”

Y esto visto desde el punto de vista de un programador tiene muy buena pinta.

Este podría ser un gráfico sencillo de su estructura.

Dicho esto, yo me pregunto, ¿Qué tiene de bueno WMI y qué puede hacer por mi? (en el terreno más práctico)

  • Utilizando WMI podemos consultar información sobre nuestro equipo. Desde las aplicaciones instaladas, a la información de la BIOS, discos duros instalados, particiones creadas, Antivirus instalado si lo hay, nivel de carga de la batería (si conviene), procesos ejecutándose, acceso a los servicios instalados, acceso a las tareas programadas, y la lista sigue y sigue…
  • Cuando hablamos de administración significa que no sólo podemos consultar estos parámetros, sino también modificarlos en muchos casos.
  • Administración remota. Significa que lo dicho anteriormente se aplica también a administración remota. Es decir, no sólo podemos hacerlo en nuestro equipo, sino en el resto de equipos de la red. WMI está presente en sistemas Windows 2000 con SP2 en adelante. Para los anteriores (95, 98 y NT 4.0) se puede descargar un SDK para instalarlo (link).
  • Es extensible. Microsoft añade nuevas clases a cada versión de Windows. Además se pueden crear nuevos proveedores de WMI que amplíen funcionalidades.
  • Acceso desde la línea de comandos. Existe una herramienta para trabajar desde la línea de comandos con WMI (link).

Utilizándola podemos por ejemplo obtener los procesos ejecutándose si desde una ventana de MS-DOS escribimos:

1
2
3
4
WMIC PROCESS
WMIC PROCESS LIST BRIEF (mejora la visualización)
WMIC /output:”c:\procesos.txt” PROCESS LIST BRIEF 
(para obtener salida a un fichero)

Lenguaje de consulta similar a SQL llamado WQL (WMI Query Language). Utilizándolo podemos desde una ventana MS-DOS ejecutar comandos como estos:

1
2
3
4
5
WMIC PRINTER WHERE Default=”TRUE”
(obtener info sobre la impresora predeterminada)
WMIC PRINTER WHERE Default=”TRUE” LIST FULL
WMIC PRINTER WHERE default="TRUE" GET DriverName,PortName,PrintProcessor
(para obtener determinados datos de la impresora predeterminada)

Aquí se pueden ver unos cuantos ejemplos más a parte de la extensa documentación existente en las páginas de Microsoft.

Una vez hecha esta introducción (muy genérica) sobre WMI, me gustaría centrarme en las aplicaciones que pueden acceder a ella. Microsoft proporciona las API de WMI para scripts, aplicaciones Visual Basic, aplicaciones C++ y .NET Framework. Eso no quiere decir que no se pueda acceder desde casi cualquier lenguaje. En mi caso me voy a centrar en el acceso a ella desde Delphi.

Para acceder desde Delphi a WMI lo primero que necesitamos en Importar la librería desde el menú de Project/Import Type Library (pasos aquí):

“Microsoft WMI Scripting v1.X Library (Version 1.X)“

Una vez importada la librería tendremos la unit WbemScripting_TLB.pas generada y lista para utilizar. En nuestros programas deberemos incluir en la clausula USES, esta unit junto con la de ActiveX.

Antes de acabar esta entrada (espero poder publicar más, ya que el tema me parece muy interesante) podemos ver cómo utilizar la WMI para acceder a los datos del disco duro. En este caso, para simplificar vamos a acceder a los datos del primer disco (DiskDrive) existente en el sistema. Para ello se utiliza la clase: Win32_DiskDrive

http://msdn.microsoft.com/en-us/library/aa394132%28VS.85%29.aspx

Basta con crear un nuevo proyecto en Delphi, añadir un memo y un botón y colocar el siguiente código (no explico más, ya que incluye los comentarios):

Recordad de colocar en el USES las dos units comentadas antes.

Se puede descargar el código de ejemplo desde aquí y el ejecutable compilado desde aquí.

<WMI_Ejemplo1_sources>

<WMI_Ejemplo1_Binary>

Share Button

Evento OnMinimize de un formulario

Sábado, 28 de Febrero de 2009 1 comentario
Share Button

Personalmente a veces me sería útil que el formulario que estoy utilizando tuviera algun sistema para detectar cuando se está minimizando el formularo; Y mejor aun que permitiera interactuar con esta acción.

Utilizo a menudo una opción de configuración que llamo: “Minimizar al Tray”. Muchas aplicaciones lo utilizan y se trata simplemente de, en lugar de minimizar la aplicación, ocultarla y mostrar un icono junto al reloj en la barra de tareas de Windows.

Para ellos la forma más sencilla que he encontrado es la que explico a continuación. Hay que decir que estoy usando Delphi 5, así que tal vez en alguna versión posterior (que además cuentan con el componnte para el Tray) habrá alguna solución más sencilla.

1
2
3
// Capturar mensajes al form
procedure WMSysCommand(var Msg: TWMSysCommand);
            message WM_SYSCOMMAND;

Y en la implementación:

1
2
3
4
5
6
7
8
9
10
11
// Capturar mensajes....
procedure TFormMain.WMSysCommand(var Msg: TWMSysCommand);
begin
  // Minimizando?
  if (Msg.CmdType = SC_MINIMIZE) then begin
    actionOcultar.Execute;
  end
  else begin
    DefaultHandler(Msg);
  end;
end;

En mi caso, lo que hago en el procedimiento es llamar al método de ocultar. Importante que en mi caso no deseo que se realice el Minimizar, por eso, la llamada a DefaultHandler está en el else. Si se desea que igualmente se realice esa llamada, esta debe estar fuera del IF.

Share Button
Categories: Delphi, Trucos Tags: , , ,

Actualizados los trucos

Martes, 24 de Febrero de 2009 Sin comentarios
Share Button

Ya están actualizados en la nueva web los trucos que tenía en la antigua; Tal vez las fechas y el orden no coincidan del todo, pero creo que es lo menos importante.

Están accesible por el Tag:  Trucos o desde el acceso de la página principal donde hay creado un pequeño índice de todos los existentes.

Lista de trucos

Si detectáis algun error (que seguro los hay) os ruego que me lo comuniquéis.

Un saludo.

Share Button
Categories: Delphi, Trucos Tags: , ,

Propiedades de una columna en Access utilizando ADOX

Martes, 11 de Noviembre de 2008 Sin comentarios
Share Button

Utilizando ADO se puede acceder a casi toda la información de la Base de Datos, Tablas y Columnas, pero no a toda. En el caso de las Bases de datos de Access, por ejemplo, la propiedad descripción, que utilizamos para añadir un texto descriptivo a las columnas de las tablas, no es accesible.

Para obtenerla, hace falta acceder directamente a la información del “catálogo” utiliando ADOX. Para poder utilizar ADOX, lo primero que debemos hacer es importar la librería a en Delphi;
Esto se puede hacer desde el menú de: Proyect/Import Type Library.

La librería en concreto es la llamada “Microsoft ADO Ext. for DDL and Security” y proceso paso a paso, podéis verlo es esta página de Zarko Gajic.

Una vez importada la librería, basta con abrir la Base de Datos, acceder a una tabla y a un columna; A partir de ahí ya tenemos todos los datos(propiedades) referentes a esa columna.

El código es sencillo (basta con tener un formulario con un memo (Memo1) y un botón (button1)):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
procedure TForm1.Button2Click(Sender: TObject);
const
  DB_CONNECTION='Provider=Microsoft.Jet.OLEDB.4.0;' + 
       'Data Source=%s'; 
  DATABASENAME = 'c:\Archivos de ' +
       'programa\Archivos comunes\Borland Shared\Data' + 
       '\dbdemos.mdb';
var
  i, j:Integer;
  Con:OleVariant;
  fCatalog:Catalog;
  Column: _Column;
  Table:_Table;
  Str1, Str2:string;
begin
  // Limpiar la salida
  Memo1.Lines.Clear;
  // Conectar con la Base de Datos
  Con := CreateOleObject('ADODB.Connection');
  // Abrir
  Con.Open(Format(DB_CONNECTION,[DATABASENAME]));
  // proteccion
  try
    // Acceder a la Base de Datos
    fCatalog := CoCatalog.Create;
    fCatalog._Set_ActiveConnection(Con);
    // Acceder a la tabla de empleados
    Table := fCatalog.Tables['employee'];
    // recorrer las columnas
    for i := 0 to (Table.Columns.Count - 1) do begin
      // Acceder a la columna
      Column := Table.Columns[i];
      // Datos de columna
      Memo1.Lines.Add(' ');
      Memo1.Lines.Add(Format('Columna: %s',[Column.Name]));
      Memo1.Lines.Add('---------------------------------');
      Memo1.Lines.Add(Format(' Tamaño: %d',[Column.DefinedSize]));
      Memo1.Lines.Add(Format(' Precisión: %d',[Column.Precision]));
      // recorrer las propiedades de la columna
      for j := 0 to (Column.Properties.Count - 1) do begin
        // Cada propiedad, Nombre y valor
        Str1 := Column.Properties[j].Name;
        Str2 := Column.Properties[j].Value;
        // Saltamos las propiedades Jet...
        if (Length(Str1) > 0) then begin
          // Saltar las Jet
          if (Str1[1] <> 'J') then begin
            Memo1.Lines.Add(Format(' %s: %s',[Str1, Str2]))
          end; //if
        end; //if
      end; // for
    end; // for
  finally
    // Liberar y cerrar
    Column := nil;
    Table := nil;
    fCatalog := nil;
    Con.Close;
  end;
end;
Share Button
Categories: Delphi, Trucos Tags: , , , ,

Ordenar un TStringGrid por una determinada columna

Jueves, 9 de Octubre de 2008 2 comentarios
Share Button

Procedimiento que muestra cómo ordenar un TStringGrid a partir de los datos de una columna. El texto está basado en esta página Web donde hay un algoritmo de ordenación. El problema es que sólo es para datos numéricos. En este truco he añadido un par de parámetros para poder definir columnas de otro tipo (u ordenación de otro tipo) y además marcar si que quiere de forma Ascendente o Descendente (que tampoco está en el truco original).

Yo he añadido métodos para ordenar por enteros y Float, aunque ampliando se pueden añadir para alguno más.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// Ordena un TStringGrid.
procedure SortStringGrid(var GenStrGrid: TStringGrid;
    ThatCol: Integer;
    ColData:TGridData=gdString;
    SortOrder:TSortOrder=soASC);
const
  TheSeparator = '@';
var
  CountItem, I, J, K, ThePosition: integer;
  MyList: TStringList;
  MyString, TempString: string;
  str:string;
  vali:Integer;
  valf:Double;
begin
  CountItem := GenStrGrid.RowCount;
  MyList := TStringList.Create;
  MyList.Sorted := False;
  try
    begin
      for I := 1 to (CountItem - 1) do begin
        Str := GenStrGrid.Rows[I].Strings[ThatCol];
        if (ColData = gdInteger) then begin
          vali := StrToIntDef(Str, 0);
          Str := Format('%*d', [15,vali]);
        end;
        if (ColData = gdFloat) then begin
          valf := StrToFloat(Str);
          Str := Format('%15.2f',[valf]);
        end;
        MyList.Add(Str + TheSeparator + GenStrGrid.Rows[I].Text);
      end;
      Mylist.Sort;
 
      for K := 1 to Mylist.Count do begin
        MyString := MyList.Strings[(K - 1)];
        ThePosition := Pos(TheSeparator, MyString);
        TempString := '';
        {Eliminate the Text of the column on which we have
          sorted the StringGrid}
        TempString := Copy(MyString, (ThePosition + 1), Length(MyString));
        MyList.Strings[(K - 1)] := '';
        MyList.Strings[(K - 1)] := TempString;
      end;
 
      if (SortOrder = soASC) then begin
        for J := 1 to (CountItem - 1) do begin
            GenStrGrid.Rows[J].Text := MyList.Strings[(J - 1)];
        end;
      end
      else begin
        for J := 1 to (CountItem - 1) do begin
          I := (CountItem - J);
          GenStrGrid.Rows[I].Text := MyList.Strings[(J - 1)];
        end;
      end;
    end;
 
  finally
    MyList.Free;
  end;
end;

AÑADO: Me falta una cosa.
Además habrá que definir en la unit los dos tipos que se utilizan para la ordenación:

1
2
3
4
5
Type
  //: Tipo de Dat de la columna por la que queremos ordenar.
  TGridData = (gdString, gdInteger, gdFloat);
  //: Tipos de ordenación.
  TSortOrder = (soASC, soDESC);
Share Button