Delphi Clinic

C++Builder Gate

Training & Consultancy

Delphi Notes Weblog

Dr.Bob's Webshop

UK-BUG DIL - Developer Information Library

Delphi IDE Experts and Wizards
Actually, the words Expert and Wizard mean the same for Delphi. They were called Experts up to and including Delphi 2, but then C++Builder started calling them Wizards, which is also used in Delphi 3 now. I'll use and mix the two terms always (hope you don't mind).
There are two ways to write Experts and Wizards. The easy way is to use my Wizard Wizard (available on my website) and let it generate the code for us. The more instructive way is to take a look at the ExptIntf.int and ToolIntf.int files in the Delphi 3/Source/ToolsAPI directory, and try to do it ourselves.
It all boils down to deriving a new class, say TDILWizard, from the abstract base class TIExpert, and override a number of functions that specify the new behaviour.
The following code snippet shows the seven method we need to override in this case.

  uses
    ShareMem, { in case of a DLL Wizard }
    VirtIntf, ExptIntf, ToolIntf, Windows, SysUtils, Forms;

  Type
    TDILWizard = class(TIExpert)
    public
      function GetStyle: TExpertStyle; override;
      function GetIDString: string; override;
      function GetName: string; override;
      function GetAuthor: String; override;
      function GetMenuText: string; override;
      function GetState: TExpertState; override;

      procedure Execute; override;
    end {TDILWizard};

  function TDILWizard.GetStyle: TExpertStyle;
  begin
    Result := esStandard
  end {GetStyle};

  function TDILWizard.GetIDString: String;
  begin
    Result := 'UKBUG.BobSwart.TDILWizard.esStandard'
  end {GetIDString};

  function TDILWizard.GetName: String;
  begin
    Result := 'TDILWizard'
  end {GetName};

  function TDILWizard.GetAuthor: String;
  begin
    Result := 'Bob Swart (aka Dr.Bob - www.drbob42.com)'
  end {GetAuthor};

  function TDILWizard.GetMenuText: String;
  begin
    Result := 'UK-BUG &DIL'
  end {GetMenuText};

  function TDILWizard.GetState: TExpertState;
  begin
    Result := [esEnabled];
  end {GetState};

  procedure TDILWizard.Execute;
  begin
    try
      WinExec('c:\program files\developer information library\dil.exe', SW_NORMAL);
    except
      // if we have one, just eat the exception
    end
  end {Execute};

  function InitExpert(ToolServices: TIToolServices;
                      RegisterProc: TExpertRegisterProc;
                  var Terminate: TExpertTerminateProc): Boolean; stdcall;
  begin
    Result := True;
    try
      ExptIntf.ToolServices := ToolServices; { Save! }
      if ToolServices <> nil then
        Application.Handle := ToolServices.GetParentHandle;
      Terminate := DoneExpert;
      Result := RegisterProc(TDILWizard.Create);
    except
      HandleException
    end
  end {InitExpert};

  exports
    InitExpert name ExpertEntryPoint;

ShortCut
First of all, I'd like to start the DIL Search Engine with a short-cut key, such as [Shift]+F1. This is not possible when DIL is installed as "standard" Wizard in the Help menu (simply because no shortcut-key is assigned to this menuitem). The obvious solution is to turn the standard Wizard into a AddIn Wizard. I will omit most of the source code, and only show the important parts here (you can always download the full Wizard source code from my website later).
The esAddIn style Wizard needs to override the constructor to be able to define a new menuitem (in this case, a menuitem in the Tools menu, where we use [Shift]+F1 as shortcut-key.

  constructor TDrBobDIL.Create;
  var
    MainMenu: TIMainMenuIntf;
    MainItem: TIMenuItemIntf;
    MenuItem: TIMenuItemIntf;
  begin
    inherited Create;
    NewMenuItem := nil;
    if ToolServices <> nil then
    try
      MainMenu := ToolServices.GetMainMenu;
      if MainMenu <> nil then { main menu }
      try
        MenuItem := MainMenu.FindMenuItem('ToolsOptionsItem');
        if MenuItem <> nil then
        try
          MainItem := MenuItem.GetParent;
          if MainItem <> nil then
          try
            NewMenuItem :=
              MainItem.InsertItem(MenuItem.GetIndex+1,
                                 'UK-BUG &DIL',
                                 'DrBobDIL1','',
                                  ShortCut(VK_F1,[ssShift]),0,0,
                                 [mfEnabled, mfVisible], OnClick)
          finally
            MainItem.DestroyMenuItem
          end
        finally
          MenuItem.DestroyMenuItem
        end
      finally
        MainMenu.Free
      end
    except
      HandleException
    end
  end {Create};

  procedure TDrBobDIL.Execute;
  var
    ModIntf: TIModuleInterface;
    EditIntf: TIEditorInterface;
    EditView: TIEditView;
    EditRead: TIEditReader;
    FileName: ShortString;

  const
    IdentSet = ['A'..'Z','0'..'9','.'];
  var
    HWnd: THandle;
    EditPos: TEditPos;
    CharPos: TCharPos;
    Position: LongInt;
  begin
    try
      FileName := ToolServices.GetCurrentFile;
      if Pos('.PAS',UpperCase(FileName)) > 0 then
      begin
        ModIntf := ToolServices.GetModuleInterface(FileName);
        if ModIntf <> nil then
        try
          EditIntf := ModIntf.GetEditorInterface;
          if EditIntf <> nil then
          try
            EditView := EditIntF.GetView(0);
            if EditView <> nil then
            try
              EditPos := EditView.CursorPos;
              EditView.ConvertPos(True,EditPos,CharPos);
              Position := EditView.CharPosToPos(CharPos)
            finally
              EditView.Free
            end
            else Position := 0;
            EditRead := EditIntF.CreateReader;
            if EditRead <> nil then
            try
              repeat
                FileName[0] := Chr(EditRead.GetText(Position,@FileName[1],255));
                Dec(Position)
              until (Position = 0) or not (UpCase(FileName[1]) in IdentSet);
              Delete(FileName,1,1); { remove leading space character }
              Position := 0;
              repeat
                Inc(Position)
              until not (UpCase(FileName[Position]) in IdentSet);
              Delete(FileName,Position,255);
            finally
              EditRead.Free
            end
          finally
            EditIntf.Free
          end
        finally
          ModIntf.Free
        end
      end;
      ....

      ....
      HWnd := FindWindowEx(0,0,'TfmDilSearch',nil);
      if HWnd <> 0 then
      begin
        SetForeGroundWindow(HWnd);
        BringWindowToTop(HWnd);
        SetFocus(HWnd);
        SendKeys(FileName)
      end
      else
        if WinExec('c:\program files\developer information library\dil.exe',
                    SW_NORMAL) > 32 then
          SendKeys(FileName)
    except
      HandleException
    end
  end {Execute};

    procedure SimulateKeyDown(Key : byte);
    begin
      keybd_event(Key, 0, 0, 0)
    end;

    procedure SimulateKeyUp(Key : byte);
    begin
      keybd_event(Key, 0, KEYEVENTF_KEYUP, 0)
    end;

    procedure SimulateKeystroke(Key : byte; extra : DWORD);
    begin
      keybd_event(Key, extra, 0, 0);
      keybd_event(Key, extra, KEYEVENTF_KEYUP, 0)
    end;

    procedure SendKeys(s: String);
    var
      i: integer;
      flag: bool;
      w: word;
    begin
      flag := not GetKeyState(VK_CAPITAL) and 1 = 0;
      if flag then SimulateKeystroke(VK_CAPITAL, 0);
      for i := 1 to Length(s) do
      begin
        w := VkKeyScan(s[i]);
        if ((HiByte(w) <> $FF) and (LoByte(w) <> $FF)) then
        begin
          if HiByte(w) and 1 = 1 then SimulateKeyDown(VK_SHIFT);
          SimulateKeystroke(LoByte(w), 0);
          if HiByte(w) and 1 = 1 then SimulateKeyUp(VK_SHIFT)
        end;
      end;
      if flag then SimulateKeystroke(VK_CAPITAL, 0);
    end;