Adios GExperts, Bienvenido cnPacks

[[Lepe]]

Reavivo este hilo porque acabo de flipar en colores con cnWizards. Resulta que puedo crear mis propios Expertos para el IDE, en lenguaje Delphi, usando Delphi.

Si ya, enrevesado y no se entiende nada.

A estas alturas, sabéis que tenemos la opción de seleccionar varias líneas de código en nuestro editor, pulsar CTRL + ç y automáticamente se aplica un comentario (se añade // a todas las líneas).

¿Os habéis preguntado como está implementada esa característica?

la respuesta está en: C:\Archivos de programa\CnPack\CnWizards\PSDemo\CommentCode.pas y viene esto:

Código Delphi [-]
{*******************************************************}
{                                                       }
{       Pascal Script Source File                       }
{       Run by RemObjects Pascal Script in CnWizards    }
{                                                       }
{       Generated by CnPack IDE Wizards                 }
{                                                       }
{*******************************************************}
program CommentCode;

uses
  Windows, SysUtils, Classes, CnWizIdeUtils;

var
  Lines: TStringList;
  i: Integer;
begin
  Lines := TStringList.Create;
  try
    if IdeGetEditorSelectedLines(Lines) then
    begin
      for i := 0 to Lines.Count - 1 do
      begin
        Lines[i] := '//' + Lines[i];
      end;
      IdeSetEditorSelectedLines(Lines);
    end;
  finally
    Lines.Free;
  end;
end.

Las dos funciones de nombre larguísimo, son autoexplicativas, El resto de código, de lo más normal, es código Delphi puro y duro.

... y esto solo es la punta del iceberg. Siento el tocho, pero no he podido callarme esta flipada. Las posibilidades de esta característica...son unas cuantas .

¿alguien ha creado su propio experto?

Saludos

[Neftali [Germán.Estévez]]

Empezado por Lepe

Las dos funciones de nombre larguísimo, son autoexplicativas

La verdad es que esas dos funciones tienen muy buena pinta...
¿Tienes amano una lista de cuales más hay?

[[Lepe]]

Nop, pero en la carpeta de cnWizards:

PsDeclEx
PsDemo

tienes donde empezar, de hecho, ese "uses CnWizIdeUtils" es muy sugerente ¿no crees? (está en la carpeta PSDeclEx).



Todas las funciones vienen comentadas, eso sí, en perfecto chino/japonés (perdón por mi ignorancia). Tampoco viene el código delphi, solo la declaración de la función.

Al parecer no puedes, en el script, usar TODAS las rutinas de delphi, solo aquellas funciones/métodos definidos en PSDecl (que ya son bastantes).

Yo ya hice un par de scripts para ayudarme a depurar aplicaciones, nada del otro mundo, en cuanto tenga tiempo los cuelgo aqui como ejemplo. La rutina que uso es: IdeGetEditorSourceLines usea, obtener el .pas entero que estas editando en el IDE . La homónima es IdeSetEditorSourceLines.

Ahora comprenderás por qué hace unos años colgaba el IDE, podría ser que no estuviesen depurados los scripts .

bye
Saludos

[dec]

Hola,

Ejem... pero, esto no es nuevo... quiero decir, lo que hace "CnPack" y otros "expertos" es usar la API que ofrece Delphi, precisamente, para que este tipo de programas puedan interactuar con el propio entorno. Este API tiene el nombre de "Open Tools API", y, por ejemplo, en Delphi.About se encuentran varios artículos al respecto.

Así que la función "IdeSetEditorSelectedLines()" probablemente pertenece a "CnPack" y hace uso de las interfaces que proporciona la "Open Tools API" para hacer su trabajo. Lo que sí es cierto es que impresiona, es decir, cuando yo supe de esto también vi un montón de posibilidades... y, bueno, ahí está "CnPack", por ejemplo, para demostrar que esto es así.

Hace tiempo escribí ciertos "Expertos del ClubDelphi" que no llegué a publicar nunca, y que, precisamente, hacen cierto uso de la "Open Tools API" de Delphi. Adjunto los archivos que tengo por aquí guardados. Y copio a continuación el contenido de una unidad que llamé en un arrebato de originalidad "UtilesIDE.pas":

Código Delphi [-]
unit UtilesIDE;

interface

uses
  Menus, ExtCtrls, ToolsApi;

type
  TUtilesIDE = class(TObject)
  private
    class function EditorActivo(): IOTASourceEditor;
    class function BloqueEditorActivo(): IOTAEditBlock;
  public
    class function MenuPrincipalIDE(): TMainMenu;
    class function ControlBarPrincipalIDE(): TControlBar;
    class function TextoSeleccionadoEditorActivo(): string;
  end;

implementation

uses
  SysUtils;

class function TUtilesIDE.MenuPrincipalIDE(): TMainMenu;
var
  serviciosNTA: INTAServices;
begin
  if Supports(BorlandIDEServices,
   INTAServices, serviciosNTA) then
    result := serviciosNTA.MainMenu
  else
    result := nil;
end;

class function TUtilesIDE.ControlBarPrincipalIDE(): TControlBar;
var
  i: integer;
begin
  result := nil;
  if Assigned(MenuPrincipalIDE()) then begin
    for i := 0 to MenuPrincipalIDE().Owner.ComponentCount-1 do begin
      if (MenuPrincipalIDE().Owner.Components[i] is TControlBar) then begin
        result := (MenuPrincipalIDE().Owner.Components[i] as TControlBar);
        break;
      end;
    end;
  end;
end;

class function TUtilesIDE.TextoSeleccionadoEditorActivo(): string;
begin
  result := '';
  if Assigned(BloqueEditorActivo()) then
  begin
    if BloqueEditorActivo().IsValid then
      result := BloqueEditorActivo().Text;
  end;
end;

class function TUtilesIDE.BloqueEditorActivo(): IOTAEditBlock;
begin
  result := nil;
  if Assigned(EditorActivo()) then
  begin
    if (EditorActivo().EditViewCount > 0) then begin
      if Assigned(EditorActivo().EditViews[0]) then
        result := EditorActivo().EditViews[0].Block;
    end;
  end;
end;

class function TUtilesIDE.EditorActivo(): IOTASourceEditor;
var
  serviciosModulos: IOTAModuleServices;
begin
  result := nil;
  if Supports(BorlandIDEServices,
   IOTAModuleServices, serviciosModulos) then
  begin
    if Assigned(serviciosModulos.CurrentModule) then begin
      if Assigned(serviciosModulos.CurrentModule.CurrentEditor) then begin
        if ((serviciosModulos.CurrentModule.CurrentEditor as IOTASourceEditor).EditViewCount > 0) then
          result := (serviciosModulos.CurrentModule.CurrentEditor as IOTASourceEditor);
      end;
    end;
  end;
end;

end.

PD. Se me olvidó comentar que todo lo que yo usé de "Tools API", si no recuerdo mal, se basó en la Jedi Library, es decir, que, en alguna de las unidades conque se cuenta en la "JCL", se encuentran implementadas no pocas funciones y procedimientos que nos pueden servir como interfaz de la interfaz, es decir, que nos hacen más sencillo trabajar con "ToolAPI".

[[Lepe]]

Esto.... ¿he dicho yo que era algo nuevo? .

Lo que yo estoy haciendo es usándolo bajo cnWizard con el cnDebugger. De hecho, mi "primer experto" lo construí en apenas 2 horas sin leer demasiada literatura.

Si tengo este código:

Código Delphi [-]
procedure TForm1.AbreTablas(Sender:TObject);
begin
  bla blah
end;

procedure TForm1.DbgridCellPaint(...);
begin // ignore log
 // pintar en el grid
end;

procedure TForm1.CierraTablas;
begin  
  blah blah
end;

Mi experto modifica el código y añade:

Código Delphi [-]
procedure TForm1.AbreTablas(Sender:TObject);
begin
  cnDebugger.LogMsg('TForm1.AbreTablas');
  bla blah
end;

procedure TForm1.DbgridCellPaint(...);
begin // Ignore log
 // pintar en el grid
end;

procedure TForm1.CierraTablas;
begin  
  cnDebugger.LogMsg('TForm1.CierraTablas');
  blah blah
end;

cnDebugger: es un depurador externo que trae implementado cnWizard.
cnDebugger.LogMsg: añade un mensaje a ese depurador.

"Mi experto" añade esa línea de Log para todos los procedimientos que tenga la unidad que estoy creando en mi programa final.

Puesto que en DBGridCellPaint se incluye el modificador // Ignore Log, en ese procedimiento no se añaden líneas de debug.

Cuando usar "mi experto": Estoy loco con una serie de rutinas que no muestran excepciones, pero no hacen lo que yo espero. En lugar de usar puntos de ruptura, Call Stack y demás, ejecuto ese experto y obtengo lo que podríamos llamar un "dynamic Call Stack" que mostrará en el log las llamadas a todos los procedimientos/eventos.

Obviamente he realizado otro experto (copiando y pegando) que elimina las líneas "cnDebugger.LogMsg" de todos los procedimientos.

Con solo 3 clics de ratón, puedo añadir 20 ó 30 trazas al programa que estoy realizando, depurando el programa de forma más cómoda si cabe.

¿útil? pse, no sé, el tiempo lo dirá .

Saludos