Common try-finally pattern, is this your usual code?

function TXServer.ServiceDelete(const ServiceID: string): IXResponse;
var
  Q_SERVICES: TORM_Q_SERVICES;
begin
  Result := TXResponse.NewResponse();

  Q_SERVICES := TORM_Q_SERVICES.Create; // create new instance
  try
    try
      Q_SERVICES.SERVICE_ID.WhereValue := ServiceID;
      Q_SERVICES.Controller.Delete;
    except
      on E: Exception do
      begin
        Result.RESP_CODE := RC_ERROR;
        Result.RESP_MSG := E.Message;
      end;
    end;
  finally
    Q_SERVICES.Free; // then relese it
  end;
end;

Now compare with this one, see TSafeMe in action:

function TXServer.ServiceDelete(const ServiceID: string): IXResponse;
var
  Q_SERVICES: TORM_Q_SERVICES;
begin
  Result := TXResponse.NewResponse();
  TSafeMe.BindMe(TORM_Q_SERVICES.Create, Q_SERVICES);  // new instance and bind to TSafeMe

  try
    Q_SERVICES.SERVICE_ID.WhereValue := ServiceID;
    Q_SERVICES.Controller.Delete;
  except
    on E: Exception do
    begin
      Result.RESP_CODE := RC_ERROR;
      Result.RESP_MSG := E.Message;
    end;
  end;

  // no need release here, TSafeMe takes care for you
end;

function TXServer.ServiceUpdate(const ServiceID, ServiceName: string): IXResponse;
var
  Q_SERVICES: TORM_Q_SERVICES;
begin
  Result := TXResponse.NewResponse();
  TSafeMe.BindMe(TORM_Q_SERVICES.Create, Q_SERVICES);

  try
    Q_SERVICES.Controller.Edit;
    Q_SERVICES.SERVICE_ID.Value := ServiceID;
    Q_SERVICES.SERVICE_NAME.Value := ServiceName;
    Q_SERVICES.Controller.Post;
  except
    on E: Exception do
    begin
      Result.RESP_CODE := RC_ERROR;
      Result.RESP_MSG := E.Message;
    end;
  end;
end;

OK, here is another example, using common classes (as requested by b_squared):

procedure SafeMeInAction;
var
  MyStrings: TStrings;
  MyStream: TStream;
  MyComponent: TMyComponent; 
begin
  // new instances
  TSafeMe.BindMe(TStringList.Create, MyStrings);
  TSafeMe.BindMe(TStringStream.Create('Well this is the string data.'), MyStream);
  TSafeMe.BindMe(TMyComponent.Create(nil), MyComponent);

  // it is safe & ensure the instances will be destroyed once exit block procedure
  
  MyStrings.Add('One');
  MyStrings.Add(MyStream.DataString);
  MyStrings.Add(MyComponent.Name);

  // it is safe... even when exception occurred...

  raise Exception.Create('Ups something wrong here');
  MyStrings.Add('This never executed');

  // nice is it
  // bump... the instances destroyed as soon the program quit this block
end;

How this works? What a tricks inside this? Before I write the tips let me know your mind, write comment bellow about how this should achieved.

Its main feature is the use of MDI interface, integrated with SSO (Single Sign On), the database access layer (with mini & fast ORM), and controller based architecture (plugin).

Debug your code directly under Delphi environment, no need to be changes, use your programming style and habit because you’re 100% coding in Delphi. Compile (CTRL+F9) and Run+Debug (F9) like usually… Everything configured to be works by the PowerLogic SDK Delphi expert.

With Delphi RAD you can create desktop-based applications quickly, with PowerLogic SDK you will be more rapid!

No need to think about the menus, deploying to the file server, versioning (auto update), and do not have to worry about authentication. All have been handled automatically, you just think the business logic.

PowerLogic SDK snaps.

I think I need replace the default one: gevent. Searching anywhere found nothing about integrating Bootle on gevent. So here is mind, feel free to correct.

from bottle import Bottle, run, ServerAdapter

myapp = Bottle()

@myapp.route('/')
def index():
    return "Hello World"

class GEventServer(ServerAdapter):
    """ Fast HTTP Server """
    def run(self, handler):
        from gevent import monkey; monkey.patch_all()
        from gevent.wsgi import WSGIServer
        WSGIServer((self.host, self.port), handler).serve_forever()

run(app=myapp, server=GEventServer, host='localhost', port=8080)

Happy Unite!

KSpoold Disinfector is a software that writen to restore Microsoft
Office files (Word, Excel, PPT etc.) from damaged file because of KSpoold virus.

KSpoold infect the docs files by mergeing these docs to the virus file,
original docs files will be delete & new file with the same name will be added
to cheating the users with new file extention: .EXE
So anytime you double click this infected file from explorer / open it using
shell api your computer will be infected too.

The software is provided “as-is,” without any express or implied warranty.
In no event shall the Author be held liable for any damages arising from
the use of the Software

The software is writen in Borland Delphi 7.
Full source-code also provided, any comments are noted of the following:

“The const SAMPLE_SIZE = 524; is taken from the following figure:

Microsoft Word & Excel using the same file header at the first 512,
so we get unique header at the first 12 byte after 512 offset
512 + 12 = 524 –> it’s my lucky number “

You can download sample of infected file by KSpoold here…

And the complete source & compiled program:

kspoold-disinfecto…

Hosted by eSnips

Any comments are welcome. Please send me the copy if you’re make modification
TODO: – Batch directory processing (may one of you would be completing this todo?)

Code class snap-shot:

unit MainUnit;

interface

{ KSpoold Disinfector 1.0 - Freeware
  Copyright © Indra Gunawan, indra_im [at] live.com
  www.delphiexpert.wordpress.com

  LICENSE
  ---------------------------------------------------------------------------
  Use and distribution of the library is permitted provided that all of
  the following terms are accepted:
  The software is provided "as-is," without any express or implied warranty.
  In no event shall the Author be held liable for any damages arising from
  the use of the Software.
  All redistributions of the library files must be in their original,
  unmodified form. Distributions of modified versions of the files is
  permitted with express written permission of the Indra.
  All redistributions of the library files must retain all
  copyright notices and web site addresses that are currently in place,
  and must include this list of conditions without modification.
  None of the library may be redistributed for profit or as part of
  another software package without express written permission of the Indra.
  Redistribution of any of the component files in object form
  (including but not limited to .PAS, .DCU and .OBJ formats)
  is strictly prohibited without express written permission of the Indra.
  --------------------------------------------------------------------------- }

uses Windows, Messages, Classes, SysUtils, Controls, Forms, Dialogs, StdCtrls;

const
  SAMPLE_SIZE = 524;

  { Microsoft Word & Excel using the same file header at the first 512,
    so we get unique header at the first 12 byte after 512 offset
    512 + 12 = 524 --> it's my lucky number :D
    You can download sample of infected file by KSpoold here:
    http://delphi-id.org/dpr/Downloads-index-req-viewdownloaddetails-lid-180.pas }

type
  IDEPatternRecognizer = interface
    ['{9AB98B63-B58E-4D0A-B420-30E6F5E37E46}']
    function GetSample(const FileName: WideString; out Sample: Pointer;
      Size: Integer): HRESULT; stdcall;
    function SetSample(const PatternName: WideString; const Sample: Pointer;
      const Size: Integer): HRESULT; stdcall;
    function RemoveSample(const PatternName: WideString): HRESULT; stdcall;
    function EnumSamples(const Dest: TStrings): HRESULT; stdcall;
    function RestoreInfectedFile(const FileName: WideString;
      var DestFileName: string): HRESULT; stdcall;
  end;

  TMainForm = class(TForm)
    GroupBox1: TGroupBox;
    ListBox1: TListBox;
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    Button4: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure ListBox1Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
  private
    { Private declarations } FDEPR: IDEPatternRecognizer;
  public
    { Public declarations } constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;

  TKSpoolInfPattern = class(TInterfacedObject, IDEPatternRecognizer)
  private
    FSamples: TStream;
    function FindResourceOffset(const FileName, Sample: string): Int64;
  protected
    { IDEPatternRecognizer }
    function GetSample(const FileName: WideString; out Sample: Pointer;
      Size: Integer): HRESULT; stdcall;
    function SetSample(const PatternName: WideString; const Sample: Pointer;
      const Size: Integer): HRESULT; stdcall;
    function RemoveSample(const PatternName: WideString): HRESULT; stdcall;
    function EnumSamples(const Dest: TStrings): HRESULT; stdcall;
    function RestoreInfectedFile(const FileName: WideString;
      var DestFileName: string): HRESULT; stdcall;
  public
    constructor Create; virtual;
    destructor Destroy; override;
  end;

var
  MainForm: TMainForm;

implementation

uses IniFiles, Math, ShellApi; {$R *.dfm}  { TMainForm }

constructor TMainForm.Create(AOwner: TComponent);
begin
  inherited;
  FDEPR := TKSpoolInfPattern.Create;
  FDEPR.EnumSamples(ListBox1.Items);
end;

destructor TMainForm.Destroy;
begin
  FDEPR := nil;
  inherited;
end;

procedure TMainForm.Button1Click(Sender: TObject);
var
  Dlg: TOpenDialog;
  Buf: Pointer;
  PattName: string;
begin
  Dlg := TOpenDialog.Create(nil);
  try
    Dlg.Filter := 'Microsoft Office Files (*.doc; *.xls)|*.doc;*.xls';
    if Dlg.Execute then
      if FDEPR.GetSample(Dlg.FileName, Buf, SAMPLE_SIZE) = S_OK then
      begin
        PattName := UpperCase(ExtractFileExt(Dlg.FileName));
        FDEPR.SetSample(PattName, Buf, SAMPLE_SIZE);
        FreeMem(Buf);
        ListBox1.Items.Add(PattName);
      end;
  finally
    Dlg.Free;
  end;
end;

procedure TMainForm.Button2Click(Sender: TObject);
begin
  if MessageBox(Handle, 'Are you sure?', 'Confirm', MB_ICONWARNING or MB_YESNO)
    = mrYes then
  begin
    if FDEPR.RemoveSample(ListBox1.Items[ListBox1.ItemIndex]) = S_OK then
    begin
      ListBox1.DeleteSelected;
      ListBox1.OnClick(nil);
    end
    else
      MessageBox(Handle, 'Unable delete sample!', 'Failed',
        MB_ICONWARNING or MB_OK);
  end;
end;

procedure TMainForm.ListBox1Click(Sender: TObject);
begin
  Button2.Enabled := ListBox1.ItemIndex >= 0;
end;

procedure TMainForm.Button3Click(Sender: TObject);
var
  Dlg: TOpenDialog;
  Dest: string;
begin
  Dlg := TOpenDialog.Create(nil);
  try
    Dlg.Filter := 'Infected File (*.exe)|*.exe';
    if Dlg.Execute then
    begin
      Dest := ChangeFileExt(Dlg.FileName, '.clean.unk');
      if FDEPR.RestoreInfectedFile(Dlg.FileName, Dest) = S_OK then
      begin
        if MessageBox(Handle,
          'Succesully disinfecting the file. Open the file now?', 'Success',
          MB_ICONINFORMATION or MB_YESNO) = mrYes then
          ShellExecute(0, 'open', PAnsiChar(Dest), '', '', SW_SHOW);
      end
      else
        MessageBox(Handle, 'Unable disinfecting file!', 'Failed',
          MB_ICONWARNING or MB_OK);
    end;
  finally
    Dlg.Free;
  end;
end;

procedure TMainForm.Button4Click(Sender: TObject);
begin
  MessageBox(Handle,
    'KSpoold Disinfector 1.0 - Freeware'#13#10#13#10'Copyright © Indra Gunawan, indra_im@live.com'#13#10'www.delphiexpert.wordpress.com', 'About Disinfecter', MB_ICONINFORMATION or MB_OK);
end;

{ TKSpoolRestore }

const
  CBufferSize = 1024;
  BUFFER_SIZE = 4096;

constructor TKSpoolInfPattern.Create;
var
  SampleFile: string;
begin
  SampleFile := ChangeFileExt(ParamStr(0), '.samples.bin');
  if FileExists(SampleFile) then
    FSamples := TFileStream.Create(SampleFile, fmOpenReadWrite)
  else
    FSamples := TFileStream.Create(SampleFile, fmCreate);
end;

destructor TKSpoolInfPattern.Destroy;
begin
  FSamples.Free;
  inherited;
end;

function TKSpoolInfPattern.EnumSamples(const Dest: TStrings): HRESULT;
var
  Mem: TMemIniFile;
begin
  Mem := TMemIniFile.Create('');
  try
    FSamples.Seek(0, soFromBeginning);
    Dest.LoadFromStream(FSamples);
    Mem.SetStrings(Dest);
    Mem.ReadSections(Dest);
    Result := S_OK;
  finally
    Mem.Free;
  end;
end;

function TKSpoolInfPattern.GetSample(const FileName: WideString;
  out Sample: Pointer; Size: Integer): HRESULT;
var
  F: TFileStream;
begin
  Result := S_OK;
  F := TFileStream.Create(FileName, fmOpenRead);
  try
    GetMem(Sample, Size);
    try
      F.ReadBuffer(Sample^, Size);
    except
      FreeMem(Sample, Size);
      Result := E_POINTER;
    end;
  finally
    F.Free;
  end;
end;

function TKSpoolInfPattern.FindResourceOffset(const FileName, Sample: string): Int64;
var
  FS: TFileStream;
  Buf: PChar;
  BufSize: Integer;
  WorkPos: Int64;
  Signature: string;
  SignatureLen: Integer;
  function IsCorrectHeader(Data: PChar): Boolean;
  begin
    Result := StrLComp(PChar(Signature), Data, SignatureLen) = 0;
  end;
  function FindSignatureInBlock(FilePos: Int64; var SignatureOffset: Int64)
    : Boolean;
  var
    i: Integer;
    SizeToCheck: Integer;
  begin
    Result := False;
    SizeToCheck := min(FS.Size - FS.Position, BufSize) - SignatureLen;
    FS.Read(Buf^, SizeToCheck);
    for i := 0 to SizeToCheck do
      if (StrLComp(PChar(Signature), Buf + i, SignatureLen) = 0) then
        if (IsCorrectHeader(Buf + i)) then
        begin
          Result := True;
          SignatureOffset := FilePos + i + SignatureLen + SignatureLen;
          Break;
        end;
  end;

begin
  Result := -1;
  FS := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
  try
    Signature := Sample;
    SignatureLen := Length(Sample);
    BufSize := 10000;
    Buf := AllocMem(BufSize);
    try
      FS.ReadBuffer(Buf^, SignatureLen + SignatureLen);
      if (StrLComp(PChar(Signature), Buf, SignatureLen) = 0) then
        if (IsCorrectHeader(Buf)) then
          Result := 0;
      if (Result < 0) then
      begin
        WorkPos := 0;
        while (WorkPos < FS.Size) do
          if (FindSignatureInBlock(WorkPos, Result)) then
            Break
          else
            WorkPos := WorkPos + BufSize - SignatureLen;
      end;
    finally
      FreeMem(Buf, BufSize);
    end;
  finally
    FS.Free;
  end;
end;

function TKSpoolInfPattern.RestoreInfectedFile(const FileName: WideString;
  var DestFileName: string): HRESULT;
var
  Mem: TMemIniFile;
  Strs: TStrings;
  Stream, Dest: TStream;
  Sample: string;
  SignOffset: Int64;
begin
  Mem := TMemIniFile.Create('');
  try
    FSamples.Seek(0, soFromBeginning);
    Strs := TStringList.Create;
    try
      Strs.LoadFromStream(FSamples);
      Mem.SetStrings(Strs);
      Strs.Clear;
      Mem.ReadSections(Strs);
      while Strs.Count > 0 do
      begin
        Stream := TMemoryStream.Create;
        try
          Mem.ReadBinaryStream(Strs[0], 'Sample', Stream);
          Stream.Seek(0, soFromBeginning);
          SetLength(Sample, Stream.Size);
          Stream.ReadBuffer(Sample[1], Stream.Size);
        finally
          Stream.Free;
        end;
        SignOffset := FindResourceOffset(FileName, Sample);
        if SignOffset >= 0 then
        begin
          DestFileName := ChangeFileExt(DestFileName, LowerCase(Strs[0]));
          Dest := TFileStream.Create(DestFileName, fmCreate);
          try
            Stream := TFileStream.Create(FileName, fmOpenRead);
            try
              Stream.Seek(SignOffset, soFromBeginning);
              Dest.CopyFrom(Stream, Stream.Size - SignOffset);
              Result := S_OK;
              Exit;
            finally
              Stream.Free;
            end;
          finally
            Dest.Free;
          end;
        end;
        Strs.Delete(0);
      end;
    finally
      Strs.Free;
    end;
  finally
    Mem.Free;
  end;
  Result := S_FALSE;
end;

function TKSpoolInfPattern.RemoveSample(const PatternName: WideString): HRESULT;
var
  Mem: TMemIniFile;
  Strs: TStrings;
begin
  Mem := TMemIniFile.Create('');
  try
    FSamples.Seek(0, soFromBeginning);
    Strs := TStringList.Create;
    try
      Strs.LoadFromStream(FSamples);
      Mem.SetStrings(Strs);
      if Mem.SectionExists(PatternName) then
      begin
        Mem.EraseSection(PatternName);
        Strs.Clear;
        Mem.GetStrings(Strs);
        FSamples.Size := 0;
        Strs.SaveToStream(FSamples);
        Result := S_OK;
      end
      else
        Result := S_FALSE;
    finally
      Strs.Free;
    end;
  finally
    Mem.Free;
  end;
end;

function TKSpoolInfPattern.SetSample(const PatternName: WideString;
  const Sample: Pointer; const Size: Integer): HRESULT;
var
  Mem: TMemIniFile;
  Strs: TStrings;
  Stream: TStream;
begin
  Mem := TMemIniFile.Create('');
  try
    FSamples.Seek(0, soFromBeginning);
    Strs := TStringList.Create;
    try
      Strs.LoadFromStream(FSamples);
      Mem.SetStrings(Strs);
    finally
      Strs.Free;
    end;
    Stream := TMemoryStream.Create;
    try
      Stream.WriteBuffer(Sample^, Size);
      Stream.Seek(0, soFromBeginning);
      Mem.WriteBinaryStream(PatternName, 'Sample', Stream);
    finally
      Stream.Free;
    end;
    Strs := TStringList.Create;
    try
      Mem.GetStrings(Strs);
      FSamples.Size := 0;
      Strs.SaveToStream(FSamples);
    finally
      Strs.Free;
    end;
    Result := S_OK;
  finally
    Mem.Free;
  end;
end;

end.

unit DECoreIntf;

{ This unit contains graphical core, editor framework & resource manager
  interfaces

  Author: Indra Gunawan
  Date: 06-11-2007
  Modified: 06-14-2007
}

interface

{$DEFINE DECORE_TYPES}

uses Windows, Messages, Classes {$IFDEF ALLOW_TCANVAS}, Graphics {$ENDIF}
  {$IFDEF DECORE_TYPES}, DECoreTypes {$ENDIF};

const
  R_NO_PAINT_HANDLES = $2;

  AR_SQUARE                    = 1;
  AR_D1DV_NTSC_0_9             = 0.9;
  AR_D4D16_STANDARD_0_95       = 0.95;
  AR_D1DV_PAL_1_066            = 1.066;
  AR_D1DV_NTSC_WIDESCREEN_1_2  = 1.2;
  AR_HDV_ANAMORPHIC_1_333      = 1.333;
  AR_D1DV_PAL_WIDESCREEN_1_422 = 1.422;
  AR_D4D6_ANAMORPHIC_1_9       = 1.9;
  AR_ANAMORPHIC_2D1_2          = 2;

  ASPECT_RATIO_NAMES: array[0..8] of string =
    ('Square',
     'D1/DV NTSC (0.9)',
     'D4/D16 Standard (0.95)',
     'D1/DV PAL (1.066)',
     'D1/DV NTSC Widescreen (1.2)',
     'HDV Anamorphic (1.333)',
     'D1/DV PAL Widescreen (1.422)',
     'D4/D6 Anamorphic (1.9)',
     'Anamorphic 2:1 (2)'
    );

const
  { Service startup type }
  SRV_STARTUP_AUTOMATIC = 0;
  SRV_STARTUP_MANUAL    = 1;
  SRV_STARTUP_DISABLED  = 2;

  { Service Status }
  SRV_STATUS_STARTED = 0;
  SRV_STATUS_STOPPED = 1;
  SRV_STATUS_PAUSED  = 2;

  { Success codes }
  S_HANDLED = $00000004;

type
  { used to load buffer into specified format in a image-list }
  TIconType = (itIcon, itPng, itBmp, itUnknown);

  TArrayOfVariant = array of Variant;

  {$IFNDEF DECORE_TYPES}
  {PColor32 = ^TColor32;
  TColor32 = type Cardinal;

  PColor32Array = ^TColor32Array;
  TColor32Array = array [0..0] of TColor32;
  TArrayOfColor32 = array of TColor32;

  PFloat = ^TFloat;
  TFloat = Single;

  PFloatPoint = ^TFloatPoint;
  TFloatPoint = record
    X, Y: TFloat;
  end;

  PFloatRect = ^TFloatRect;
  TFloatRect = packed record
    case Integer of
      0: (Left, Top, Right, Bottom: TFloat);
      1: (TopLeft, BottomRight: TFloatPoint);
  end;}
  {$ENDIF}

  { Interface Declarations }

  IDEUniqueInterfaceList = interface
  ['{8A705EE5-4EE0-497D-B995-03104763FCC0}']
    function  GetCount: Integer; stdcall;
    function  AddInterface(const IID: TGUID; const Instance: IInterface): Integer; stdcall;
    function  RemoveInterface(const IID: TGUID): IInterface; stdcall;
    function  Delete(const Index: Integer): IInterface; stdcall;
    procedure Clear; stdcall;
    function  GetInterface(const IID: TGUID): IInterface; overload; stdcall;
    function  GetInterface(const Index: Integer): IInterface; overload; stdcall;

    property Count: Integer read GetCount;
  end;

  PAspectRatioRegistryEntry = ^TAspectRatioRegistryEntry;
  TAspectRatioRegistryEntry = packed record
    Name: Widestring;
    Value: Single;
  end;

  IDEAspectRatioRegistry = interface
  ['{4FEB64FB-BACE-4ACF-B107-B28A3A0D9849}']
    function RegisterAspectRatio(Name: string; Value: Single): HRESULT; stdcall;
    function UnregisterAspectRatio(AValue: Single): HRESULT; stdcall;
    function Count: Integer; stdcall;
    function GetAspectRatio(const Index: Integer): PAspectRatioRegistryEntry; stdcall;
    function GetAspectRatioByValue(const Value: Single): PAspectRatioRegistryEntry; stdcall;
    function GetAspectRatioName(const Value: Single): Widestring; stdcall;
    function GetAspectRatioIndex(const Value: Single): Integer; stdcall;
    procedure Clear; stdcall;
  end;

  PResourceEntry = ^TResourceEntry;
  TResourceEntry = packed record
    IID: TGUID;
    Instance: IInterface;
    { instance need maintenance the list dynamicly
      so we use semi circular double-linked-list rather than fixed array.
      indexing also supported by HashedList or TList }
    Prev: PResourceEntry;  // if entry is root, Prev may linked to it self or nil
    Next: PResourceEntry;
  end;

  { forward declarations }

  IDEGraphicLayer = interface;
  IDEPersistent = interface;
  IDEProxyDispatcher = interface;
  IDEClassRegistry = interface;
  IDEFrameworkEnv = interface;
  IDEUserInterface = interface;
  IDEEditorManager = interface;
  IDEBitmap = interface;
  IDEGuides = interface;

  { ----- resource manager interfaces ----- }

  { Note: Based on rule, IDECachedResources only accept unique TGUID resource }

  IDECachedResource = interface
  ['{0E55234C-1E19-4D1E-B6E7-088C6CF5B23A}']
    function GetResourceEntry(IID: TGUID; out Entry: PResourceEntry): HRESULT; stdcall;
    function AddResource(IID: TGUID; Res: IInterface): HRESULT; stdcall;
    function GetResource(Res: TGUID; out Intf): HRESULT; stdcall;
    function GetFirstResourceEntry(out Entry: PResourceEntry): HRESULT; stdcall;
    function GetLastResourceEntry(out Entry: PResourceEntry): HRESULT; stdcall;
    function RemoveResource(Res: TGUID): HRESULT; stdcall;
    function Clear: HRESULT; stdcall;
    function ResourceExist(Res: TGUID): HRESULT; stdcall;
    { indexing supports }
    function GetCount: Integer; stdcall;
    function GetResourceEntryByIndex(Index: Integer; out Entry: PResourceEntry): HRESULT; stdcall;
    function GetResourceByIndex(Index: Integer; out Intf): HRESULT; stdcall;
    function RemoveResourceByIndex(Index: Integer): HRESULT; stdcall;
    { persistent supports }
    function WriteToStream(Dest: TStream): HRESULT; stdcall;
    function ReadFromStream(Source: TStream): HRESULT; stdcall;
  end;

  IDESystemResource = interface
  ['{95B022AB-0ECF-4CC9-93CF-BBA176C28822}']
    { Opens/creates a file. 'FileName' parameter must contain full path. Folders are
      created automatically. 'Mode' parameter is the same as in the TFileStream.Create.
      fmCreate: Creates/overwrites a file.
      fmOpenRead, fmOpenWrite, fmOpenReadWrite: Opens existing file in read-write mode.
      Read-only mode is not supported (but is automatically enforced if underlying
      storage is open read-only.
      @param   fileName Absolute path of the file to be created/open. Must start with a
                        folder delimiter (\ or /) and can contain any ascii character
                        except #0, \ and /.
      @returns Nil if file does not exist and mode is not fmCreate; an object
               representing the file otherwise. Caller is responsible for destroying this
               object. }
    function  OpenFile(const FileName: WideString; Mode: Word): TStream; stdcall;
    procedure CreateFolder(const FolderName: WideString); stdcall;
    { Moves a file or folder. }
    procedure Move(const ObjectName, NewName: WideString); stdcall;
    { Deletes a file or folder. When deleting folder, all subfolders and files are automatically deleted. }
    procedure Delete(const ObjectName: WideString); stdcall;
    function  FileExists(const FileName: WideString): Boolean; stdcall;
    function  FolderExists(const FolderName: WideString): Boolean; stdcall;
    procedure FileNames(const FolderName: WideString; Files: TStrings); stdcall;
    { Returns list of folders in folder 'FolderName'. }
    procedure FolderNames(const FolderName: WideString; Folders: TStrings); stdcall;
    { Fast way to check if folder is empty. }
    function  IsFolderEmpty(const FolderName: WideString): Boolean; stdcall;
  end;

  { External module library methods }

  { Host application / framework will be first check is TExtLibProxyDispatcherSignature
    method avaliable in a DLL, then check the signature is compatible or not }
  TExtLibProxyDispatcherSignature = function (out Signature: TGUID): HRESULT; stdcall;

  { Make client library known handle of Framework interface, its a IDEFrameworkEnv }
  TExtLibProxyFrameworkEnv = function (AFrameworkEnv: IInterface): HRESULT; stdcall;

  { After signature match, next, system initiate call to a register process (IDEClassRegistry).
    Be aware for 2nd, 3rd, ... class, set HLibModule to 0 (zero),  :HMM now just ignore this comment line :D
    assign HLibModule value that come from caller only for the 1st register process,
    duplicate HLibModule will cause error on FreeLibrary call }
  TExtLibProxyDispatcherRegister = function (Registry: IDEClassRegistry; HLibModule: Longword; out ClassCount: Integer): HRESULT; stdcall;

  { Synchronise windows message to main thread, switch Host & Module application handle }
  TExtLibProxyApplication = function (const AppHandle: Longword): Longword; stdcall;

  { Determine the lib is being destroyed, you must release any instance of IDEFrameworkEnv here }
  TExtLibProxyUninstall = function : HRESULT; stdcall;

  { Class info }

  TDECreateProc = function: TObject; stdcall;

  PClassEntry = ^TClassEntry;
  TClassEntry = packed record
    CreateProc: TDECreateProc;
    HLibModule: Longword;
    HLibApp: Longword;
    Icon: LongWord;
    IconSize: Longword;
    IconType: TIconType;

    Name: Widestring;
    Description: Widestring;
    Author: Widestring;
    Version: Longint; // Hi word & Lo word

    { advance object hook, Garbage Collector related }
    AfterConstruction: LongWord;
    BeforeDestruction: LongWord;
  end;

  { Base interface rights for IDEClassRegistry }

  TDENotifyEvent = procedure (Sender: TObject; Action, WParam, LParam: Longint) of object; stdcall;
  TDESimpleNotifyEvent = procedure of object; stdcall;
  TDEComponentNotifyEvent = procedure (AComponent: TComponent; Operation: TOperation) of object;

  PNotifyEventEntry = ^TNotifyEventEntry;
  TNotifyEventEntry = packed record
    Proc: TDENotifyEvent;
    RefCount: Integer;
  end;

  IDENotifier = interface
  ['{A85D46B7-7C68-400C-857E-B37A0853F9E8}']
    function RegisterNotification(ANotify: TDENotifyEvent): HRESULT; stdcall;
    function UnregisterNotification(ANotify: TDENotifyEvent): HRESULT; stdcall;
    function Notify(Sender: TObject; Action, WParam, LParam: Longint): HRESULT; stdcall;
  end;

  IDEClassRegistryEntry = interface
  ['{30AFB9F4-60CB-40E7-A41B-24AEA79A7DB5}']
  end;

  IDEClassRegistry = interface(IDENotifier)
  ['{2C58AC7B-B19B-4226-9454-3947D45511F1}']
    function RegisterClass(AClass: TClass; CreateProc: TDECreateProc; HLibModule, HLibApp: Longword;
      const IconData: LongWord; IconDataSize: Longword; const IconType: TIconType; Name, Description, Author: Widestring;
      Version: Longint): PClassEntry; stdcall;
    function CreateObject(AClassName: WideString; out Intf): TObject; stdcall;
    function QueryClassEntry(AClassName: WideString): PClassEntry; stdcall;
  end;

  { Visual supports - Menus, Toolbar & ToolWindow }

  TDEUserInterfaceEvent = procedure (Sender: IDEUserInterface; const ID: Integer; const UIHandle: Longword) of object; stdcall;


  IDEUserInterface = interface(IDEClassRegistryEntry)
  ['{93269A85-8ADA-424D-B734-2924F09ADF5A}']
    function  RegisterImageListIcon(const IconData: LongWord; DataSize: Longint;
      const IconType: TIconType): Integer; stdcall;

    { For each, return the handle of user interface }
    function  Add(const ID, Index, ImageIndex: Integer; const Title, Hint: Widestring; const AutoCheck: Boolean; const OnClick: TDEUserInterfaceEvent): Longword; stdcall;
    function  AddEdit(const ID, Index: Integer; const Hint: Widestring; const OnChange: TDEUserInterfaceEvent): Longword; stdcall;
    function  AddCombo(const ID, Index: Integer; const Hint: Widestring; const OnChange: TDEUserInterfaceEvent): Longword; stdcall;
    function  AddSpinEdit(const ID, Index: Integer; const Hint: Widestring; const OnChange: TDEUserInterfaceEvent): Longword; stdcall;
    function  AddSeparator(const Index: Integer): Longword; stdcall;

    { items contents }
    function  GetUIInstance(Index: Integer): Longword; stdcall;
    function  GetTitle(UIHandle: Longword): Widestring; stdcall;
    procedure SetTitle(UIHandle: Longword; Value: Widestring); stdcall;
    function  GetText(UIHandle: Longword): Widestring; stdcall;
    procedure SetText(UIHandle: Longword; Value: Widestring); stdcall;
    function  GetValues(UIHandle: Longword): TStrings; stdcall;
    procedure SetValues(UIHandle: Longword; Value: TStrings); stdcall;
    function  GetVisiblity(UIHandle: Longword): Boolean; stdcall;
    procedure SetVisiblity(UIHandle: Longword; Value: Boolean); stdcall;
    function  GetChecked(UIHandle: Longword): Boolean; stdcall;
    procedure SetChecked(UIHandle: Longword; Value: Boolean); stdcall;
    function  GetData(UIHandle: Longword): LongWord; stdcall;
    procedure SetData(UIHandle: Longword; Value: LongWord); stdcall;

    { list }
    function  GetCount: Integer; stdcall;
    procedure SetCount(Value: Integer); stdcall;
    procedure Remove(AHandle: Longword); stdcall;
    procedure RemoveByIndex(Index: Integer); stdcall;
    procedure Clear; stdcall;

    function  Click(const ID: Integer): Boolean; stdcall;

    property UIInstance[Index: Integer]: Longword read GetUIInstance;
    property Title[UIHandle: Longword]: Widestring read GetTitle write SetTitle;
    property Text[UIHandle: Longword]: Widestring read GetText write SetText;
    property Values[UIHandle: Longword]: TStrings read GetValues write SetValues;
    property Visibility[UIHandle: Longword]: Boolean read GetVisiblity write SetVisiblity;
    property Checked[UIHandle: Longword]: Boolean read GetChecked write SetChecked;
    property Data[UIHandle: Longword]: LongWord read GetData write SetData;
    property Count: Integer read GetCount write SetCount;
  end;

  IDEToolbar = interface(IDEUserInterface)
  ['{3ED33565-1FFE-414E-A34E-DFD9DD53ED70}']
    function  GetDockHandle: Longword; stdcall;
    procedure SetDockHandle(Value: Longword); stdcall;

    function  GetVisible: Boolean; stdcall;
    procedure SetVisible(Value: Boolean); stdcall;

    property DockHandle: Longword read GetDockHandle write SetDockHandle;
    property Visible: Boolean read GetVisible write SetVisible;
  end;

  IDEContextMenu = interface(IDEUserInterface)
  ['{0BE7F557-F1A0-4E6A-B440-40BD00731FAD}']
    function  GetTargetControl: Longword; stdcall;
    procedure SetTargetControl(Value: Longword); stdcall;

    property TargetControl: Longword read GetTargetControl write SetTargetControl;
  end;

  { Framework }

  IDEService = interface
  ['{5DB30973-5764-47AF-8D4A-1D541815D322}']
    function  GetName: WideString; stdcall;
    function  CreateInstance: IInterface; stdcall;

    function  GetDisplayName: WideString; stdcall;
    function  GetDescription: WideString; stdcall;
    function  GetStartParameters: WideString; stdcall;
    procedure SetStartParameters(const Value: WideString); stdcall;
    function  ParamCount: Integer; stdcall;
    function  ParamStr(const Index: Integer): WideString; stdcall;

    function GetStartupType: DWORD; stdcall;
    function GetStatus: DWORD; stdcall;

    function Start: HRESULT; stdcall;
    function Stop: HRESULT; stdcall;
    function Pause: HRESULT; stdcall;
    function Resume: HRESULT; stdcall;

    property Name: WideString read GetName;
    property DisplayName: WideString read GetDisplayName;
    property Description: WideString read GetDescription;
    property StartupType: DWORD read GetStartupType;
    property Status: DWORD read GetStatus;
  end;

  { Build-in system services }

  IDEXMLService = interface(IDEService)
  ['{6684BA51-A62A-4CCC-A4E8-6D123926E41C}']
  { Service Name: 'XMLService' or query using this IID
    Return: IXMLDocument }
  end;

  IDEXMLPersistentStreamerService = interface(IDEService)
  ['{9686EAA9-8B45-431F-AF6D-62B6843646E0}']
  { Service Name: 'XMLPersistentStreamerService' or query using this IID }
  end;

  IDEGScriptService = interface(IDEService)
  ['{BEE5A20D-2B2F-4982-9AEA-E9318E802649}']
  { Service Name: 'GScriptService' or query using this IID }
  end;

  IDEGPropertiesService = interface(IDEService)
  ['{654B98E9-664A-4EA4-99FE-659E2C6D4B7A}']
  { Service Name: 'GPropertiesService' or query using this IID }
  end;

  IDEServiceManager = interface
  ['{646198CE-DACB-4FF3-B205-62DAFF04BBCA}']
    function QueryService(const ServiceName: WideString; out Intf): Boolean; overload; stdcall;
    function QueryService(const IID: TGUID; out Intf): Boolean; overload; stdcall;
    function QueryServiceIntf(const IID: TGUID; out Service: IDEService): Boolean; stdcall;
    function RegisterService(const Service: IInterface; const ServiceIID: TGUID): Integer; stdcall;
    function UnregisterService(const ServiceIID: TGUID): IInterface; stdcall;
    function Delete(const Index: Integer): IInterface; stdcall;
    function GetCount: Integer; stdcall;
    function GetService(const Index: Integer): IDEService; stdcall;
    property Count: Integer read GetCount;
    property Services[const Index: Integer]: IDEService read GetService;
  end;

  IDEFrameworkEnv = interface
  ['{3A5809FF-91C3-41A1-B54F-2CA688AEF36D}']
    function GetAspectRatioRegistry: IDEAspectRatioRegistry; stdcall;

    { SystemResource contains global resources (image, video, audio, text, binary etc.) related to a project.
      storage structure virtualy using FAT architecture, equal with physical FAT, you can create/delete/read/write folder or file }
    function GetSystemResource: IDESystemResource; stdcall;

    { ProxyDispatcherRegistry contains registered implementation classes of IDEProxyDispatcher
      interface, you may register your own/3rd party class to be able to communicate with the framework.
      Registering from external library DLL/Obj also supported using the specified rules }
    function GetProxyDispatcherRegistry: IDEClassRegistry; stdcall;

    { FilterRegistry contains registered implementation classes of IDEFilter interface,
      you may register your own/3rd party class to be able to communicate with the framework.
      Registering from external library DLL/Obj also supported using the specified rules }
    function GetFilterRegistry: IDEClassRegistry; stdcall;

    { CachedResource may contains any required cache of IInterface descendant,
      ex. you may add your own themmed thumbnails border to share with other.
      For default, system doesn't save these contents to project file, but optionaly you
      may save your self inside your structure stream format or write it in SystemResource. }
    function GetCachedResource: IDECachedResource; stdcall;

    { External module loader supports }
    function LoadExternalModule(ModulePath, FileExt: WideString; Dest: IDEClassRegistry): HRESULT; stdcall;
    function LoadExternalProxyDispatcher(ModulePath, FileExt: WideString): HRESULT; stdcall;

    { Project control }
    function ProjectNew: HRESULT; stdcall;
    function ProjectOpen(const AFileName: WideString): HRESULT; stdcall;
    function ProjectClose: HRESULT; stdcall;
    function ProjectSaveAs(const AFileName: WideString): HRESULT; stdcall;
    function ProjectSave: HRESULT; stdcall;
    function ProjectLowLevelSave: HRESULT; stdcall;
    function GetModified: Boolean; stdcall;
    function GetFileName: WideString; stdcall;
    procedure Changed; stdcall;

    { System }
    function Uninstall: HRESULT; stdcall;

    { Services }
    function GetServices: IDEServiceManager; stdcall;

    { Visual User Interface }
    function GetEditorManager: IDEEditorManager; stdcall;
    function DeInitializeVisualControls: HRESULT; stdcall;
    function GetToolPalette: IDEToolbar; stdcall;

    property AspectRatioRegistry: IDEAspectRatioRegistry read GetAspectRatioRegistry;
    property SystemResource: IDESystemResource read GetSystemResource;
    property ProxyDispatcherRegistry: IDEClassRegistry read GetProxyDispatcherRegistry;
    property FilterRegistry: IDEClassRegistry read GetFilterRegistry;
    property CachedResource: IDECachedResource read GetCachedResource;
    property FileName: WideString read GetFileName;
    property Modified: Boolean read GetModified;

    property ToolPalette: IDEToolbar read GetToolPalette;
    property EditorManager: IDEEditorManager read GetEditorManager;
    property Services: IDEServiceManager read GetServices;
  end;

  { graphical interfaces }

  IDEPersistent = interface
  ['{02A78A81-CBD6-49F0-B372-1C23A53D675C}']
    function  WriteToStream(const Dest: TStream): HRESULT; stdcall;
    function  ReadFromStream(const Source: TStream): HRESULT; stdcall;
  end;

  IDEGuide = interface
  ['{6601F92C-C6F6-4A5A-9E84-37420C4E8E06}']
    function  GetGuides: IDEGuides; stdcall;
    function  GetPosition: Single; stdcall;
    procedure SetPosition(const Value: Single); stdcall;

    function  GetIsHorzGuide: Boolean; stdcall;
    procedure Remove; stdcall;

    property Guides: IDEGuides read GetGuides;
    property Position: Single read GetPosition write SetPosition;
    property IsHorzGuide: Boolean read GetIsHorzGuide;
  end;

  IDEGuides = interface
  ['{57632101-A783-46EE-B78C-37BB98ABBE75}']
    function  GetRulerVisible: Boolean; stdcall;
    procedure SetRulerVisible(const Value: Boolean); stdcall;
    function  GetAutoHideRuler: Boolean; stdcall;
    procedure SetAutoHideRuler(const Value: Boolean); stdcall;
    function  GetRulerSize: Integer; stdcall;
    function  GetGuideColor: Cardinal; stdcall;
    procedure SetGuideColor(const Value: Cardinal); stdcall;

    function  AddGuideHorz(const Y: Single): IDEGuide; stdcall;
    function  AddGuideVert(const X: Single): IDEGuide; stdcall;
    function  GetHorzGuideCount: Integer; stdcall;
    function  GetHorzGuide(const Index: Integer): IDEGuide; stdcall;
    function  GetVertGuideCount: Integer; stdcall;
    function  GetVertGuide(const Index: Integer): IDEGuide; stdcall;
    function  GetSnapToGuides: Boolean; stdcall;
    procedure SetSnapToGuides(const Value: Boolean); stdcall;
    function  GetSnapToObjects: Boolean; stdcall;
    procedure SetSnapToObjects(const Value: Boolean); stdcall;

    function  GetEnabled: Boolean; stdcall;
    procedure SetEnabled(const Value: Boolean); stdcall;
    procedure Initialize; stdcall;
    procedure Finalize; stdcall;
    procedure InvalidGuidesData; stdcall;

    function  SnapToGuid(const Sender: IDEProxyDispatcher; const X, Y: Single): PFloatPoint; stdcall;
    function  IsLastSnapRequester(const AProxy: IDEProxyDispatcher): Boolean; stdcall;

    property HorzGuideCount: Integer read GetHorzGuideCount;
    property HorzGuide[const Index: Integer]: IDEGuide read GetHorzGuide;
    property VertGuideCount: Integer read GetVertGuideCount;
    property VertGuide[const Index: Integer]: IDEGuide read GetVertGuide;
    property SnapToGuides: Boolean read GetSnapToGuides write SetSnapToGuides;
    property SnapToObjects: Boolean read GetSnapToObjects write SetSnapToObjects;
    property Enabled: Boolean read GetEnabled write SetEnabled;
    property RulerVisible: Boolean read GetRulerVisible write SetRulerVisible;
    property AutoHideRuler: Boolean read GetAutoHideRuler write SetAutoHideRuler;
    property RulerSize: Integer read GetRulerSize;
    property GuideColor: Cardinal read GetGuideColor write SetGuideColor;
  end;

  IDEEditor = interface
  ['{C9349B7B-9690-428D-BE16-BCD6F3D6AECE}']
    function  GetAspectRatio: Single; stdcall;
    procedure SetAspectRatio(Value: Single); stdcall;

    function  GetZoom: Single; stdcall;
    procedure SetZoom(Value: Single); stdcall;

    function  GetPageWidth: Integer; stdcall;
    procedure SetPageWidth(Value: Integer); stdcall;

    function  GetPageHeight: Integer; stdcall;
    procedure SetPageHeight(Value: Integer); stdcall;
    procedure SetPageSize(AWidth, AHeight: Integer); stdcall;

    function  GetContentWidth: Integer; stdcall;
    function  GetContentHeight: Integer; stdcall;

    procedure BeginUpdate; stdcall;
    procedure EndUpdate; stdcall;

    function  GetWindowWidth: Integer; stdcall;
    function  GetWindowHeight: Integer; stdcall;

    function  GetPortrait: Boolean; stdcall;
    procedure SetPortrait(Value: Boolean); stdcall;

    function  GetDescription: WideString; stdcall;
    procedure SetDescription(Value: WideString); stdcall;

    function  GetScaleX: Single; stdcall;
    function  GetScaleY: Single; stdcall;

    function  GetOffsetHorz: Integer; stdcall;
    function  GetOffsetVert: Integer; stdcall;

    function  ClientToScreen(const X, Y: Integer): TPoint; stdcall;
    function  ScreenToClient(const X, Y: Integer): TPoint; stdcall;
    function  ClientToScreenX(const X1, X2: Integer): TPoint; stdcall;
    function  ClientToScreenY(const Y1, Y2: Integer): TPoint; stdcall;
    function  ScreenToClientX(const X1, X2: Integer): TPoint; stdcall;
    function  ScreenToClientY(const Y1, Y2: Integer): TPoint; stdcall;

    procedure ShowRuler(const RulerSize: Integer); stdcall;
    procedure HideRuler; stdcall;

    procedure ZoomToFit; stdcall;

    procedure DocumentModified; stdcall;

    property AspectRatio: Single read GetAspectRatio write SetAspectRatio;
    property Zoom: Single read GetZoom write SetZoom;
    property PageWidth: Integer read GetPageWidth write SetPageWidth;
    property PageHeight: Integer read GetPageHeight write SetPageHeight;
    property ContentWidth: Integer read GetContentWidth;
    property ContentHeight: Integer read GetContentHeight;
    property WindowWidth: Integer read GetWindowWidth;
    property WindowHeight: Integer read GetWindowHeight;
    property Portrait: Boolean read GetPortrait write SetPortrait;
    property Description: WideString read GetDescription write SetDescription;
    property ScaleX: Single read GetScaleX;
    property ScaleY: Single read GetScaleY;
    property OffsetHorz: Integer read GetOffsetHorz;
    property OffsetVert: Integer read GetOffsetVert;
  end;

  TDECreateObjectProc = function (AProxyDispatcher: IDEProxyDispatcher): IDEGraphicLayer of object; stdcall;

  IDEEditorStyler = interface
  ['{063E4F74-B14F-4311-9917-413C3922BC35}']
    function  GetInstance: LongWord; stdcall;
    function  GetEditor: IDEEditor; stdcall;
    function  GetEditorInstance: LongWord; stdcall;
    function  GetGuides: IDEGuides; stdcall;

    procedure BindEditor(const AEditor: IDEEditor; const AInstance: LongWord); stdcall;
    procedure UnbindEditor; stdcall;

    procedure InitPage(Buffer: IDEBitmap); stdcall;
    function  GetContextMenu: IDEContextMenu; stdcall;

    function  CreateObject(AProxyDispatcher: IDEProxyDispatcher): IDEGraphicLayer; stdcall;
    function  CreateObjectRegistry(AProxyDispatcherIID: TGUID): IDEGraphicLayer; stdcall;
    function  CreateObjectRegistryString(AProxyDispatcherIID: string): IDEGraphicLayer; stdcall;

    function  GetNewObject: PClassEntry; stdcall;
    procedure SetNewObject(const Value: PClassEntry); stdcall;

    function  GetObjects(const Index: Integer): IDEProxyDispatcher; stdcall;
    function  GetCount: Integer; stdcall;
    procedure ClearObjects; stdcall;

    { maintains selection list }

    procedure AddSelection(const Value: IDEProxyDispatcher; const Clear: Boolean); stdcall;
    procedure ClearSelection; stdcall;
    function  RemoveSelection(const ALayer: IDEProxyDispatcher): IDEProxyDispatcher; stdcall;
    procedure DeleteSelections; stdcall;
    function  GetActiveLayer: IDEProxyDispatcher; stdcall;
    function  GetSelections(const Index: Integer): IDEProxyDispatcher; stdcall;
    function  GetSelectionCount: Integer; stdcall;
    function  GetIsSelecting: Boolean; stdcall;
    function  GetIsPerformingNewAction: Boolean; stdcall;

    { event enhance suff }
    function  PerformLayerMouseEvents(Button: Word; Shift: TShiftState; X, Y: Integer): Boolean; stdcall;
    procedure MouseDown(Button: Word; Shift: TShiftState; X, Y: Integer; const Layer: IDEProxyDispatcher); stdcall;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer; const Layer: IDEProxyDispatcher); stdcall;
    procedure MouseUp(Button: Word; Shift: TShiftState; X, Y: Integer; const Layer: IDEProxyDispatcher); stdcall;
    procedure DblClick; stdcall;
    procedure KeyDown(var Key: Word; Shift: TShiftState); stdcall;
    procedure DefaultToolSelected; stdcall;

    procedure DrawPageFrame(Buffer: IDEBitmap; PageRect: PRect; StageNum: Integer); stdcall;

    { project navigator }
    function  CustomDialogs: Boolean; stdcall;
    function  GetFileTypeDialogFilter: WideString; stdcall;
    function  ProjectNew: HRESULT; stdcall;
    function  ProjectOpen(var AFileName: WideString): HRESULT; stdcall;
    function  ProjectSaveAs(var AFileName: WideString): HRESULT; stdcall;
    function  ProjectSave: HRESULT; stdcall;
    function  NewDocument: HRESULT; stdcall;
    function  OpenDocument: HRESULT; stdcall;
    function  SaveDocument: HRESULT; stdcall;

    property Instance: LongWord read GetInstance;
    property Editor: IDEEditor read GetEditor;
    property EditorInstance: LongWord read GetEditorInstance;
    property ContextMenu: IDEContextMenu read GetContextMenu;

    { maintains selection list }
    property NewObject: PClassEntry read GetNewObject write SetNewObject;
    property Objects[const Index: Integer]: IDEProxyDispatcher read GetObjects;
    property Count: Integer read GetCount;
    property ActiveLayer: IDEProxyDispatcher read GetActiveLayer;
    property Selections[const Index: Integer]: IDEProxyDispatcher read GetSelections;
    property SelectionCount: Integer read GetSelectionCount;
    property IsSelecting: Boolean read GetIsSelecting;
    property IsPerformingNewAction: Boolean read GetIsPerformingNewAction;
    property Guides: IDEGuides read GetGuides;
  end;

  IDEEditorManager = interface(IDEEditor)
  ['{BB337846-5686-4A8B-9D33-4036CE98564F}']
    function  GetEditor: LongWord; stdcall;
    procedure SetEditorParent(AParent: LongWord); stdcall;

    procedure RegisterEditorStyler(AStyler: IDEEditorStyler; SetAsDefault: Boolean); stdcall;
    procedure UnregisterEditorStyler(AStyler: IDEEditorStyler); stdcall;

    function  GetEditorStyler: IDEEditorStyler; stdcall;
    procedure SwitchStyler(AStyler: IDEEditorStyler); stdcall;

    function  GetOnEditorResize: TDESimpleNotifyEvent; stdcall;
    procedure SetOnEditorResize(Value: TDESimpleNotifyEvent); stdcall;

    property Editor: LongWord read GetEditor;// write SetEditor;
    property Styler: IDEEditorStyler read GetEditorStyler;
    property OnEditorResize: TDESimpleNotifyEvent read GetOnEditorResize write SetOnEditorResize;
  end;

  IDEBitmap = interface
  ['{AD2A0F91-2820-4C6C-BC58-1611C02038A8}']
    { Internal Wrapper }
    procedure SetInstance(Value: LongWord; AOwnedObject: Boolean); stdcall;
    function  GetInstance: LongWord; stdcall;

    { Commons }
    function  GetWidth: Integer; stdcall;
    procedure SetWidth(Value: Integer); stdcall;
    function  GetHeight: Integer; stdcall;
    procedure SetHeight(Value: Integer); stdcall;
    function  SetSize(NewWidth, NewHeight: Integer): Boolean; stdcall;
    function  GetEmpty: Boolean; stdcall;
    function  GetMeasuringMode: Boolean; stdcall;
    function  GetBitmapHandle: HBITMAP; stdcall;
    function  GetBitmapInfo: TBitmapInfo; stdcall;
    function  GetHandle: HDC; stdcall;
    {$IFDEF ALLOW_TCANVAS}
    function  GetCanvas: TCanvas; stdcall;
    {$ENDIF}
    function  GetBits: PColor32Array; stdcall;
    function  GetPixelPtr(X, Y: Integer): PColor32; stdcall;
    function  GetScanLine(Y: Integer): PColor32Array; stdcall;
    function  GetPixel(X, Y: Integer): TColor32; stdcall;
    procedure SetPixel(X, Y: Integer; Value: TColor32); stdcall;

    procedure Changed; stdcall;
    procedure Clear; stdcall;
    procedure Reset(FillColor: TColor32); stdcall;

    procedure ResetAlpha; stdcall;
    procedure ResetAlphaValue(const AlphaValue: Byte); stdcall;

    { properties }

    property Instance: LongWord read GetInstance;// write SetInstance;
    property BitmapHandle: HBITMAP read GetBitmapHandle;
    property BitmapInfo: TBitmapInfo read GetBitmapInfo;
    property Handle: HDC read GetHandle;

    property Bits: PColor32Array read GetBits;
    property PixelPtr[X, Y: Integer]: PColor32 read GetPixelPtr;
    property ScanLine[Y: Integer]: PColor32Array read GetScanLine;
    property Pixel[X, Y: Integer]: TColor32 read GetPixel write SetPixel;

    property Width: Integer read GetWidth write SetWidth;
    property Height: Integer read GetHeight write SetHeight;
    property Empty: Boolean read GetEmpty;
    property MeasuringMode: Boolean read GetMeasuringMode;

    {$IFDEF ALLOW_TCANVAS}
    property Canvas: TCanvas read GetCanvas;
    {$ENDIF}
  end;

  IDEGraphicLayer = interface
  ['{19267F9A-51DF-4982-B628-AE6F99157FE6}']
    function  GetProxyDispatcher: IDEProxyDispatcher; stdcall;

    function  GetLocation: TFloatRect; stdcall;
    procedure SetLocation(Value: TFloatRect); stdcall;
    function  GetAdjustedLocation: TFloatRect; stdcall;
    function  GetAdjustedRect(const R: TFloatRect): TFloatRect; stdcall;
    function  GetScaled: Boolean; stdcall;
    procedure SetScaled(Value: Boolean); stdcall;

    procedure BeginUpdate; stdcall;
    procedure EndUpdate; stdcall;
    procedure Changing; stdcall;
    procedure Changed; stdcall;

    procedure DrawFrame(const ARect: TRect; const Buffer: IDEBitmap); stdcall;
    procedure DrawHandles(const ARect: TRect; const Buffer: IDEBitmap;
      const HandleSize: Integer; const HandleFrameColor, HandleFillColor: Cardinal); stdcall;

    procedure PerformMouseDown(Button: Word; Shift: TShiftState; X, Y: Integer); stdcall;
    procedure PerformMouseMove(Shift: TShiftState; X, Y: Integer); stdcall;
    procedure PerformMouseUp(Button: Word; Shift: TShiftState; X, Y: Integer); stdcall;

    function  GetMouseShift: PFloatPoint; stdcall;

    procedure DisableTransformEvents; stdcall;
    procedure EnableTransformEvents; stdcall;

    function  GetUpdateCount: Integer; stdcall;
    function  GetDragging: Boolean; stdcall;
    function  GetDragState: TDragState; stdcall;

    procedure CancelDrag; stdcall;

    procedure Remove; stdcall;

    procedure BringToFront; stdcall;
    procedure SendToBack; stdcall;

    function  GetIndex: Integer; stdcall;
    procedure SetIndex(const Value: Integer); stdcall;

    property ProxyDispatcher: IDEProxyDispatcher read GetProxyDispatcher;
    property AdjustedLocation: TFloatRect read GetAdjustedLocation;
    property Location: TFloatRect read GetLocation write SetLocation;
    property Scaled: Boolean read GetScaled write SetScaled;
    property UpdateCount: Integer read GetUpdateCount;
    property Dragging: Boolean read GetDragging;
    property DragState: TDragState read GetDragState;
    property Index: Integer read GetIndex write SetIndex;
  end;

  IDEFilter = interface
  ['{02470323-C5B5-4435-8D03-8FF4F3BE3286}']
    function  GetControl: IDEProxyDispatcher; stdcall;
    procedure SetControl(const Value: IDEProxyDispatcher); stdcall;
    function  CanApplyTo(const AControl: IDEProxyDispatcher): Boolean; stdcall;
    function  GetIsSystemFilter: Boolean; stdcall;
    function  GetDisplayName: WideString; stdcall;
    function  GetEnabled: Boolean; stdcall;
    procedure SetEnabled(const Value: Boolean); stdcall;
    procedure FilterProc(var Message: TMessage; var Handled: Boolean); stdcall;

    property Control: IDEProxyDispatcher read GetControl write SetControl;
    property IsSystemFilter: Boolean read GetIsSystemFilter;
    property DisplayName: WideString read GetDisplayName;
    property Enabled: Boolean read GetEnabled write SetEnabled;
  end;

  IDEFilters = interface
  ['{1E85ABA6-F75A-41E7-96DE-4123CC398F28}']
    function  GetCount: Integer; stdcall;
    function  GetFilter(const Index: Integer): IDEFilter; stdcall;
    function  Add(const AFilter: IDEFilter): Integer; stdcall;
    procedure Delete(const Index: Integer); stdcall;
    procedure Remove(const AFilter: IDEFilter); stdcall;
    procedure Clear; stdcall;

    property Count: Integer read GetCount;
    property Filters[const Index: Integer]: IDEFilter read GetFilter;
  end;

  { InteractiveStyler used to create different behavior for drag and drop & mouse operations }

  IDEInteractiveStyler = interface
  ['{E4D9B94B-77A4-4D69-9535-D252C47A10C7}']
    function ApplyStyle(Target: IDEGraphicLayer; Shift: TShiftState; MousePos: TPoint; OldLocation: TFloatRect;
      var L, T, R, B: Single; Mx, My, W, H, MoveDirX, MoveDirY: Single): Boolean; stdcall;
  end;

  { This proxy dispatcher present to the class writers }

  IDEProxyDispatcher = interface(IDEClassRegistryEntry)
  ['{B08AF04B-6AF0-45D6-A11A-C0F96CD3E7C5}']
    function  GetInstance: LongWord; stdcall;

    procedure Initialize; stdcall; // called after assigning all required interfaces
    function  GetIsSystemLayer: Boolean; stdcall;
    function  GetIsHighPrioritySystemLayer: Boolean; stdcall;

    procedure SetEditorStyler(Value: IDEEditorStyler); stdcall;
    function  GetEditorStyler: IDEEditorStyler; stdcall;
    procedure SetGraphicLayer(Value: IDEGraphicLayer); stdcall;
    function  GetGraphicLayer: IDEGraphicLayer; stdcall;
    function  GetFilters: IDEFilters; stdcall;
    procedure SetFilters(const Value: IDEFilters); stdcall;

    procedure Remove; stdcall;
    function  GetDefaultSize: PSize; stdcall;

    { interactive supports }
    procedure MouseDown(Button: Word; Shift: TShiftState; X, Y: Integer); stdcall;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); stdcall;
    procedure MouseUp(Button: Word; Shift: TShiftState; X, Y: Integer); stdcall;
    procedure MouseEnter; stdcall;
    procedure MouseLeave; stdcall;
    function  DoHitTest(X, Y: Integer): Boolean; stdcall;
    function  GetDragState(X, Y: Integer): TDragState; stdcall;
    function  GetRubberbandHandles: TRBHandles; stdcall;
    function  GetInteractiveStyler: IDEInteractiveStyler; stdcall;
    function  GetSelected: Boolean; stdcall;
    procedure SetSelected(const Value: Boolean); stdcall;

    procedure DoTransforming(const OldLocation, NewLocation: PFloatRect;
      DragState: TDragState; Shift: TShiftState); stdcall;
    procedure DoTransform(const NewLocation: PFloatRect); stdcall;

    { context menu }
    function  RegisterContextMenuItems(Menu: IDEContextMenu): Integer; stdcall;

    { drawing supports }
    function  DoPaint(Buffer: IDEBitmap): HRESULT; stdcall;

    { editor dialog }
    { window cache model, return handle of editor window : TODO }
    //function  CreateEditor: Longword; virtual; stdcall;

    { simple dialog mode }
    function  ShowEditor(AParentWindow: Longword): HRESULT; stdcall;

    property Instance: LongWord read GetInstance;
    property IsSystemLayer: Boolean read GetIsSystemLayer;
    property IsHighPrioritySystemLayer: Boolean read GetIsHighPrioritySystemLayer;
    property EditorStyler: IDEEditorStyler read GetEditorStyler write SetEditorStyler;
    property GraphicLayer: IDEGraphicLayer read GetGraphicLayer write SetGraphicLayer;
    property Filters: IDEFilters read GetFilters write SetFilters;
    property RubberbandHandles: TRBHandles read GetRubberbandHandles;
    property InteractiveStyler: IDEInteractiveStyler read GetInteractiveStyler;
    property Selected: Boolean read GetSelected write SetSelected;
  end;

  { InstructionSet Builder }

  IDEIdentifier = interface
  ['{9D939DF8-87AC-4172-9868-B8BB26FD3651}']
    procedure SetValue(const AValue: WideString); stdcall;
    function  GetValue: WideString; stdcall;

    property Value: WideString read GetValue write SetValue;
  end;

  IDEVariantParam = interface
  ['{B37157E1-F9D2-4FEA-B969-B1E8676A48BA}']
    procedure StrQuoteON; stdcall;
    procedure StrQuoteOFF; stdcall;

    procedure BeginCascadeCall; stdcall;
    procedure EndCascadeCall; stdcall;

    function  NewObject(const Name, ObjectClass: WideString;
      const Params: array of Variant): IDEVariantParam; stdcall;

    function  CallMethod(const ObjectNames: array of WideString;
      const MethodName: WideString;
      const Params: array of Variant): IDEVariantParam; stdcall;

    function  GetCode: WideString; stdcall;
    procedure Reset; stdcall;

    property Code: WideString read GetCode;
  end;

  IDEInstructionSection = interface
  ['{03CFD50E-972B-4B3B-AB80-450B7B05B91F}']
    { interface info }
    function GetGUID: TGUID; stdcall;
    function GetDescription: WideString; stdcall;

    function  GetName: WideString; stdcall;

    { Params section header }
    function  AddParam(const Value: WideString): Integer; stdcall;
    function  GetParam(const Index: Integer): WideString; stdcall;
    procedure SetParam(const Index: Integer; const Value: WideString); stdcall;
    function  GetParamCount: Integer; stdcall;
    procedure ClearParams; stdcall;
    procedure DeleteParam(const Index: Integer); stdcall;

    procedure StrQuoteON; stdcall;
    procedure StrQuoteOFF; stdcall;

    procedure BeginCascadeCall; stdcall;
    procedure EndCascadeCall; stdcall;

    function  GetIndent: Word; stdcall;
    procedure SetIndent(const Value: Word); stdcall;

    function  GenerateCode(const Index: Integer): WideString; stdcall;
    function  GetCode: WideString; stdcall;

    function  GetCount: Integer; stdcall;
    procedure Reset; stdcall;
    procedure Delete(const Index: Integer); stdcall;

    procedure NewVar(const Name: WideString; const Values: array of Variant); stdcall;
    procedure NewObject(const Name, ObjectClass: WideString;
      const Params: array of Variant); stdcall;
    procedure CallMethod(const ObjectNames: array of WideString;
      const MethodName: WideString;
      const Params: array of Variant); stdcall;
    procedure SetProperty(const ObjectNames: array of WideString;
      const PropertyName: WideString; Values: array of Variant); stdcall;
    procedure SetArrayProperty(const ObjectNames: array of WideString;
      const PropertyName: WideString; const Index: Integer;
      Values: array of Variant); stdcall;
    procedure WriteLine(const Line: WideString); stdcall;

    procedure CallClearEvent; stdcall;
    procedure CallEvent(const Handle, Message, Command: Variant); stdcall;

    function  IsMethodCalled(const ObjectNames: array of WideString;
      const MethodName: WideString;
      const Params: array of Variant): Boolean; stdcall;

    function  EncodeText(const Value: WideString; const Quote: Char): WideString; stdcall;

    procedure WriteToStream(Dest: TStream); stdcall;

    function  QueryIdent(const AValue: WideString): IDEIdentifier; stdcall;
    function  QueryVariantParam: IDEVariantParam; stdcall;
    function  QuerySubSection(const Name: WideString): IDEInstructionSection; stdcall;

    property Name: WideString read GetName;// write SetName;
    property ParamCount: Integer read GetParamCount;
    property Params[const Index: Integer]: WideString read GetParam write SetParam;

    property Count: Integer read GetCount;
    property Indent: Word read GetIndent write SetIndent;
    property Codes[const Index: Integer]: WideString read GenerateCode;
    property Code: WideString read GetCode;
  end;

  IDEInstructionSet = interface
  ['{632B192B-B9B0-42CD-A859-7697CD225241}']
    function  QuerySection(const Name: WideString): IDEInstructionSection; stdcall;
    function  QueryNewSection(const Name: WideString): IDEInstructionSection; stdcall;
    function  GetCount: Integer; stdcall;
    function  GetSection(const Index: Integer): IDEInstructionSection; stdcall;
    procedure Reset; stdcall;
    function  Remove(const Section: IDEInstructionSection): Integer; stdcall;
    procedure Delete(const Index: Integer); stdcall;
    function  GetCode: WideString; stdcall;
    procedure WriteToStream(const Dest: TStream); stdcall;
    procedure WriteToFile(const FileName: WideString); stdcall;
    procedure WriteAssemblyToStream(const Dest: TStream); stdcall;
    procedure WriteAssemblyToFile(const FileName: WideString); stdcall;

    property Section[const Index: Integer]: IDEInstructionSection read GetSection;
    property Count: Integer read GetCount;
    property Code: WideString read GetCode;
  end;

  IDEProperties = interface
  ['{65183EB6-A0BB-4600-97CE-E00283E56627}']
    function  AddProperty(const Name: WideString; const Value: Variant): Integer; stdcall;
    function  AddQuotedProperty(const Name: WideString; const Value: Variant): Integer; stdcall;
    function  GetPropertyCount: Integer; stdcall;
    procedure ClearProperties; stdcall;
    procedure DeleteProperty(const Index: Integer); stdcall;

    function  GetProperty(const Name: WideString): Variant; stdcall;
    procedure SetProperty(const Name: WideString; const Value: Variant); stdcall;

    function  GetValue: Variant; stdcall;
    procedure SetValue(const Value: Variant); stdcall;

    function  Compile: WideString; stdcall;

    property PropertyCount: Integer read GetPropertyCount;
    property Properties[const Name: WideString]: Variant read GetProperty write SetProperty;
    property Value: Variant read GetValue write SetValue;
  end;

  { Publishing }

  IDEPublishingInfo = interface
  ['{659A6867-FA24-4B9C-9B88-1A56FF98DE50}']
    function GetWorkDir: WideString; stdcall;
    function GetResourcesDir: WideString; stdcall;
    function GetTemplateName: WideString; stdcall;

    function GetInstructionSet: IDEInstructionSet; stdcall;
    function QueryCompatibleInstructionSet: IDEInstructionSet; stdcall;

    property WorkDir: WideString read GetWorkDir;
    property ResourcesDir: WideString read GetResourcesDir;
    property TemplateName: WideString read GetTemplateName;

    property InstructionSet: IDEInstructionSet read GetInstructionSet;
  end;

  { TODO: }
  IDEFileLocator = interface
  ['{F24B5FE0-4E6F-4608-A5EF-EC23964B9199}']
    function GetFileCount: Integer; stdcall;
    function GetFileNames(const Dest: TStrings): HResult; stdcall;
    function GetIsInMemoryFile(const Name: WideString): Boolean; stdcall;
    function GetFile(const Name: WideString): TStream; stdcall;
    function GetFileAsText(const Name: WideString): WideString; stdcall;
  end;

  IDEPublisher = interface
  ['{295B96A4-24D9-403A-A652-5E010FAC07C9}']
    function Publish(const NamedId: Integer; const ZoneName: WideString;
      const ZoneRect: TRect; const Info: IDEPublishingInfo): HRESULT; stdcall;
  end;

implementation

end.

TLogin – simplify you to manage User Rights, add multiuser and user rights functionality to your application with just a few mouse clicks.

Allows to control the user access to your app. GUI components (menus, buttons, check boxes, radio, .., everything on your form) and to any non visual functionality. Just drag, drop and run.

With TLogin you can:
- Build the security model of your app. at design time with few mouse clicks
- Add and remove users on fly
- Change users profile on fly
- Add/remove securized items on fly
- Securize non GUI functionalities
- Predefined User Groups – Supervisors, Power Users, …
- Much more…

Here’s some comments (taken from some friend words):
- Very user friendly user interface (UI nya sangat mudah dipahami dan dioperasikan)
- All Dataset descendants will be supported
- Simple drag & drop management
- User & group management
- User Rights to control any controls/components avaliable on any forms
- Exclusive Watch… a thread safe control state monitoring feature to prevent external hook (fitur checking jikalau ada ‘pihak’ yang mencoba iseng meng-invoke / hook / c-r-a-c-k ‘rights’ suatu control)
- Support both design-time & runtime descripting the rights & manage accounts
- Run As feature… (pada saat login sebagai non admin, seseorang bisa meng-interrupt tanpa harus log-out utk menjalankan task yg butuh authorizasi admin rights)
- Store the security description as you like (database, binary file)
- Synch-Data-Synch support… synchronizing existing users data as well as TLogin known data format.
- etc.

Here’s some screen shoot:

Download VCL components (Delphi 6, 7, 2006, 2007, 2009, 2010) also some demo application here:

Hosted by eSnips

New: Demo Showing Features

This software is distributed as shareware. It is not free. You may use the software for a trial period of thirty (30) days, at no cost to you, to determine if it fits your needs. If you decide to use the software, you shall register it and pay the applicable registration fee.
The Shareware (restricted) version may be freely distributed, as long as no fees are charged and original packaging, the above copyright notice and documentation are retained.

Single Developer License (USD$ 59.00) Corporate License (USD$ 189.00)

Contact: indra_im [at] live.com, drop me request email for Paypal payment.

Our Customers:
- DEMOR-SOFT Ltd
- List your name here…

Hasil ketikan daku berikut adalah program yg daku ajukan sebagai skripsi S1, ide dibuatnya program ini karena pada saat skripsi ini diajukan, komponen report (delphi 5) yg ada pada waktu itu cuman Quick Report, daku paling sebel design report pake QReport hihi, tapi gimana lagi, adanya cuman itu. Akhirnya dng setengah malas-malasan daku angkat topik ini, hehehe lumayan dapet A
Bertepatan setelah ujian selesai dilaksanakan dan daku dinyatakan lulus, FreeReport baru kemudian muncul menyusul wakakak…

Basa-basi diambil dari Help aplikasi, 4 tahun yang lalu xixix (Help-helepan)

Program Pengolah Laporan ini dirancang dan dibuat untuk mempermudah pembuatan laporan berbasis database dalam program pengolah laporan.

Salah satu cara untuk menyajikan suatu informasi adalah dengan cara membuat laporan berdasar data yang telah melalui proses penyaringan. Data yang telah disaring dapat berupa rekapitulasi keuangan, transaksi penjualan atau pembelian berdasar tanggal, maupun informasi penting lainnya.

Dengan Program Pengolah Laporan ini mampu diaplikasikan pada segala macam format laporan dan data.

Program pengolah laporan ini bisa dijalankan di semua versi Microsoft Windows, kecuali Windows 3.1.x, dan kompatibel dengan segala merek printer dengan beragam resolusi.

Kompiler: Delphi 5, 6, 7 atau versi terbaru

Semua object dalam InsightReport melakukan drawing menggunakan scripting (Pascal), so siapa aja bisa dengan mudah membuat shape/object baru yg kemudian dapat langsung digunakan. Berikut snapshot ScriptEditor+Debugger :

Dan tidak lupa, seperti ReportEngine modern lainnya, terdapat window utk manipulasi properties objects:

Serta tidak lupa fasilitas wizard utk koneksi ke database (ADO & BDE based pada waktu itu), Query builder & Fields Explorer…

Snapshot diatas adalah Report Designer yg digunakan utk men-design report, dapat dipanggil langsung dari IDE (Delphi) atau pada waktu Runtime (persis macam Free/FastReport, siapa yg contekan ya xixix), So… beberapa komponen visual & non visual juga disertakan; jadi dapat diinstal dalam IDE, lagi2 mirip2 ama FreeReport <sebel>, cuman komponen report dibuat simple, support embedded report design data (compiled right to your Exe, ataupun load from external file)
Tidak ada embel2 TRLabel atau sejenisnya, karena semua object yg digunakan report engine adalah turunan dari 1 class, dimana semua instance of report object harus memberikan script (Pascal) yg otomatis akan dieksekusi oleh report-engine.

See sample, oh iya… utk ngeluarin Script-Debuger window, dikau musti tekan F9, jangan lupa select/pilih terlebih dahulu object yg ingin dilihat scriptnya.

Semua komponen visual/non visual dalam report designer/preview adalah murni buatan tangan daku. Kecuali utk script hightlight & pascal interpreter daku ambil dari free/opensource <lupa, pake punya siapa yaa… ntar deh diupdate xixixi>

Selamat mencoba… kita tunjukan pada dunia… saya juga bisa!!! wakakak…

Hosted by eSnips