Home > Current Works > Multimedia Framework – Interactive Designer

Multimedia Framework – Interactive Designer


Here is some interactive Designer’s interface…

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 😀
    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.
Advertisements
Categories: Current Works
  1. June 13, 2007 at 8:33 am

    Source-codenya harus di blok dulu biar kelihatan…
    Warna theme bertolak-belakang ama Pas2HTML xixixi

  2. June 13, 2007 at 11:36 am

    Good Good Good, Gwe makin cinta am DE, huahahhahaha

  3. June 14, 2007 at 4:44 am

    Hi Indra!
    Black text on black background is incredible hard to read ;o)
    Stefan

  4. June 14, 2007 at 5:09 am

    Hi Stef!
    I make it white just as yours 🙂

  5. Dhsnie
    July 5, 2007 at 1:59 pm

    Mas Indra itu buat apaan? dijelasin dikit yachhhh….

  6. July 31, 2007 at 11:42 am

    let’s go make delphi live

  7. Ali Andriana
    November 4, 2008 at 10:57 pm

    hi.. teman-teman…
    ada yang bisa minta tolong caranya deteksi pixel di image ngak…
    makaasih

  8. November 5, 2008 at 5:20 am

    >> ada yang bisa minta tolong caranya deteksi pixel di image ngak…

    http://delphi-id.org/dpr/index.php?name=PNphpBB2&file=viewtopic&t=5945

  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: