home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / Runimage / Delphi50 / Source / Toolsapi / TOOLINTF.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1999-08-11  |  25.5 KB  |  519 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Borland Delphi Visual Component Library         }
  5. {                                                       }
  6. {       Copyright (c) 1995,99 Inprise Corporation       }
  7. {                                                       }
  8. {*******************************************************}
  9.  
  10. unit ToolIntf;
  11.  
  12. interface
  13.  
  14. uses Windows, ActiveX, Classes, VirtIntf, EditIntf, FileIntf;
  15.  
  16. type
  17.   TIMenuItemIntf = class;
  18.  
  19.   TIMenuFlag = (mfInvalid, mfEnabled, mfVisible, mfChecked, mfBreak, mfBarBreak,
  20.     mfRadioItem);
  21.   TIMenuFlags = set of TIMenuFlag;
  22.  
  23.   TIMenuClickEvent = procedure (Sender: TIMenuItemIntf) of object;
  24.  
  25.   { The TIMenuItemIntf class is created by Delphi.  This is simply a virtual
  26.     interface to an actual menu item found in the IDE. It is the responsibility
  27.     of the client to destroy *all* menu items which it created.  Failure to
  28.     properly clean-up will result in unpredictable behaviour.
  29.  
  30.     NOTE: Using functions that returns a TIMenuItemIntf should be done with
  31.           care. Unless created by a particular add-in tool, do not hold these
  32.           interfaces for long as the underlying actual VCL TMenuItem may be
  33.           destroyed without any notification.  In practice, this only pertains
  34.           to Delphi created menus or menus created by other add-in tools.
  35.           It is also the responsibility of the user to free these interfaces
  36.           when finished. Any attempt to modify a menu item that was created
  37.           by Delphi will fail.
  38.  
  39.     DestroyMenuItem  - If this menu was created by through the interface, use
  40.                        this function to destroy the associated menu item.  This
  41.                        function will *not* allow any Delphi created menus to
  42.                        be destroyed.
  43.  
  44.     GetItemCount
  45.     GetItem          - Use these functions to iterate through the menu tree.
  46.                        All TIMenuItemIntfs must be freed by the caller.
  47.  
  48.     GetName          - Returns the menu item name associated with the VCL menu
  49.                        object. (Including internal Delphi menu names).
  50.  
  51.     GetParent        - Returns an interface to the parent menu item.
  52.  
  53.     GetCaption
  54.     SetCaption       - Methods to get/set the caption of the menu item.
  55.  
  56.     GetShortCut
  57.     SetShortCut      - Methods to get/set the short cut of the menu item.
  58.  
  59.     GetFlags
  60.     SetFlags         - Use GetFlags and SetFlags to query and set the state of
  61.                        the menu item.  For SetFlags, a mask indicating which
  62.                        items to affect must be passed along with the actual
  63.                        value of the flag.
  64.  
  65.     GetGroupIndex
  66.     SetGroupIndex    - Methods to get/set the GroupIndex property of a
  67.                        TMenuItem. This is useful for specifying values for
  68.                        grouped radio menus.
  69.     GetHint
  70.     SetHint          - Methods to get/set the Hint proeprty of a TMenuItem.
  71.                        NOTE: The IDE currently ignores this property.
  72.  
  73.     GetContext
  74.     SetContext       - Methods to get/set the help context ID of a TMenuItem.
  75.  
  76.     GetOnClick
  77.     SetOnClick       - Methods to get/set the OnClick property if the TMenuItem.
  78.  
  79.     InsertItem       - Creates and inserts a new sub menu item into the menu.
  80.                        If (Index < 0) or (Index >= ItemCount) then the
  81.                        operation is an append.
  82.   }
  83.  
  84.   TIMenuItemIntf = class(TInterface)
  85.   public
  86.     function DestroyMenuItem: Boolean; virtual; stdcall; abstract;
  87.     function GetIndex: Integer; virtual; stdcall; abstract;
  88.     function GetItemCount: Integer; virtual; stdcall; abstract;
  89.     function GetItem(Index: Integer): TIMenuItemIntf; virtual; stdcall; abstract;
  90.     function GetName: string; virtual; stdcall; abstract;
  91.     function GetParent: TIMenuItemIntf; virtual; stdcall; abstract;
  92.     function GetCaption: string; virtual; stdcall; abstract;
  93.     function SetCaption(const Caption: string): Boolean; virtual; stdcall; abstract;
  94.     function GetShortCut: Integer; virtual; stdcall; abstract;
  95.     function SetShortCut(ShortCut: Integer): Boolean; virtual; stdcall; abstract;
  96.     function GetFlags: TIMenuFlags; virtual; stdcall; abstract;
  97.     function SetFlags(Mask, Flags: TIMenuFlags): Boolean; virtual; stdcall; abstract;
  98.     function GetGroupIndex: Integer; virtual; stdcall; abstract;
  99.     function SetGroupIndex(GroupIndex: Integer): Boolean; virtual; stdcall; abstract;
  100.     function GetHint: string; virtual; stdcall; abstract;
  101.     function SetHint(Hint: string): Boolean; virtual; stdcall; abstract;
  102.     function getContext: Integer; virtual; stdcall; abstract;
  103.     function setContext(Context: Integer): Boolean; virtual; stdcall; abstract;
  104.     function GetOnClick: TIMenuClickEvent; virtual; stdcall; abstract;
  105.     function SetOnClick(Click: TIMenuClickEvent): Boolean; virtual; stdcall; abstract;
  106.     function InsertItem(Index: Integer; Caption, Name, Hint: string;
  107.       ShortCut, Context, GroupIndex: Integer; Flags: TIMenuFlags;
  108.       EventHandler: TIMenuClickEvent): TIMenuItemIntf; virtual; stdcall; abstract;
  109.   end;
  110.  
  111.   { The TIMainMenuIntf class represents the Delphi main menu.
  112.  
  113.     GetMenuItems     - Returns the menu representing the top level menus.
  114.  
  115.     FinMenuItem      - Given the VCL component name, returns the corresponding
  116.                        TIMenuItemIntf.
  117.   }
  118.  
  119.   TIMainMenuIntf = class(TInterface)
  120.   public
  121.     function GetMenuItems: TIMenuItemIntf; virtual; stdcall; abstract;
  122.     function FindMenuItem(const Name: string): TIMenuItemIntf; virtual; stdcall; abstract;
  123.   end;
  124.  
  125.   { The TIAddInNotifier allows an add-in tool to register a descendant of this
  126.     type with Delphi in order to receive notifications about certian events
  127.     within Delphi.  It is the resposibility of the add-in tool to unregister
  128.     and free this class when shutting down.
  129.  
  130.     FileNotification   - Called whenever an operation is performed from the
  131.                          FileMenu (or through the TIToolInterface).
  132.       fnFileOpening    - The given filename is about to be opened. Set
  133.                          Cancel to True to prevent the operation.
  134.       fnFileOpened     - The given file has been successfully opened.
  135.                          Modifications to Cancel have no effect.
  136.       fnFileClosing    - The given file is about to be closed.  Set Cancel
  137.                          to True to prevent the file from closing.
  138.       fnProjectOpening - The given project is about to be opened.  Set
  139.                          Cancel to True to prevent the operation.
  140.       fnProjectOpened  - The given project has been successfully opened.
  141.                          Modifications to Cancel have no effect.
  142.       fnProjectClosing - The given project is about to be closed.  Set
  143.                          Cancel to True to prevent the project from closing.
  144.       fnAddedToProject - The given file was added to the project.
  145.       fnRemovedFromProject - The given file was removed from the project.
  146.       fnDefaultDesktopSave
  147.       fnDefaultDekstopLoad
  148.       fnProjectDesktopSave
  149.       fnProjectDesktopLoad - The given filename represents a desktop is
  150.                              being loaded or saved.  The desktop file is
  151.                              in standard .INI file format. Add in written
  152.                              using Delphi can use the TIniFile component
  153.                              to add and retrieve information from this file.
  154.                              Modifying Cancel has no effect.
  155.  
  156.       fnPackageInstalled - Sent when a package has been installed/uninstalled.
  157.                            Modifying Cancel has no effect.
  158.  
  159.       EventNotification - Called whenever various non-file related events occur.
  160.  
  161.       enBeforeCompile - Called right before a project compile is started.  All
  162.                         source modules have been updated. Set Cancel to True to
  163.                         cancel the compile.
  164.       enAfterCompile  - Called right after the compile is completed.  Cancel
  165.                         will be True if successful, False otherwise.
  166.  
  167.       NOTE: Modifying Cancel should be done with care.  Multiple notifiers
  168.             could interact, yielding unpredictable results.  Notifiers are
  169.             called in the reverse order in which they are registered.  There
  170.             is also no way to guarantee the registration order of the
  171.             notifiers.
  172.   }
  173.  
  174.   TFileNotification = (fnFileOpening, fnFileOpened, fnFileClosing,
  175.     fnProjectOpening, fnProjectOpened, fnProjectClosing, fnAddedToProject,
  176.     fnRemovedFromProject, fnDefaultDesktopLoad, fnDefaultDesktopSave,
  177.     fnProjectDesktopLoad, fnprojectDesktopSave, fnPackageInstalled,
  178.     fnPackageUninstalled);
  179.  
  180.   TEventNotification = (enBeforeCompile, enAfterCompile);  
  181.  
  182.   TIAddInNotifier = class(TInterface)
  183.   public
  184.     procedure FileNotification(NotifyCode: TFileNotification;
  185.       const FileName: string; var Cancel: Boolean); virtual; stdcall; abstract;
  186.     procedure EventNotification(NotifyCode: TEventNotification;
  187.       var Cancel: Boolean); virtual; stdcall; abstract;
  188.   end;
  189.  
  190.   { The Tool services object is created on the application side, and is
  191.     passed to the VCS/Expert Manager DLL during initialization.  Note that
  192.     the application is responsible for creating and freeing the interface
  193.     object, and the client should never free the interface.
  194.  
  195.     The following functions are available to the client:
  196.  
  197.     ( Actions )
  198.  
  199.     CloseProject     - returns True if no project open, or if the currently
  200.                        open project can be closed.
  201.  
  202.     OpenProject      - returns True if the named project can be opened.  Pass an
  203.                        empty string to create a new project and main form.
  204.  
  205.     OpenProjectInfo  - returns True if the named project file can be opened.
  206.                        This routine bypasses all the normal project load
  207.                        features (such as loading a desktop file, showing
  208.                        the source code, etc), and simply opens the .DPR and
  209.                        .DOF files.
  210.  
  211.     SaveProject      - returns True if the project is unmodified, if there
  212.                        is no project open, or if the open project can be saved.
  213.  
  214.     CloseFile        - returns True if the specified file is not currently
  215.                        open, or if it can be closed.
  216.  
  217.     OpenFile         - returns True if the specified file is already open
  218.                        or can be opened.
  219.  
  220.     ReloadFile       - returns True if the file is already open and was
  221.                        reloaded from disk.  (NOTE: This will not perform any
  222.                        checking of the current editor state).
  223.  
  224.     ModalDialogBox   - used by non-VCL DLL's to present a dialog box which is
  225.                        modal.  Note that DLLs written using VCL can simply call
  226.                        a form's ShowModal function.
  227.  
  228.     CreateModule     - Will create new module from memory images of the source
  229.                        and, optionally, the form file.  The TCreateModuleFlags are:
  230.       cmAddToProject - Add the new module to the currently open project.
  231.       cmShowSource   - Show the source file in the top-most editor window.
  232.       cmShowForm     - If a form is created, show it above the source.
  233.       cmUnNamed      - Will mark the module as unnamed which will cause the
  234.                        SaveAs dialog to show the first time the user attempts to
  235.                        save the file.
  236.       cmNewUnit      - Creates a new unit and adds it to the current project.
  237.                        NOTE: all other parameters are ignored.
  238.       cmNewForm      - Creates a new form and adds it to the current project.
  239.                        NOTE: all other parameters are ignored.
  240.       cmNewModel     - Creates a new Data Model and adds it to the current
  241.                        project. NOTE: all other parameters are ignored.
  242.       cmMainForm     - If the module includes a form, make it the main form of
  243.                        the currently open project. Only valid with the
  244.                        cmAddToProject option.
  245.       cmMarkModified - Will insure that the new module is marked as modified.
  246.       cmExisting     - Will Create a module from an existing file on disk
  247.  
  248.     CreateModuleEx   - New extended form of CreateModule.  This will return a
  249.                        TIModuleInterface. All CreateModes from CreateModule are
  250.                        supported with only the following differences:
  251.       cmExisting     - Will create an existing module from the given file
  252.                        system.
  253.       AncestorClass  - This must specify an existing base class in the project.
  254.                        (use the cmAddToProject flag to add a module to the
  255.                         project first).
  256.  
  257.  
  258.               NOTES:   Pass an empty string for the file system parameter in
  259.                        order to use the default file system.  The file system
  260.                        parameter *must* be a valid file system previously
  261.                        registered through the RegisiterFilesystem API.
  262.  
  263.     ( Informational )
  264.  
  265.     GetParentHandle  - returns a HWND, which should be used as the parent for
  266.                        any windows created by the client.
  267.  
  268.     GetProjectName   - returns a fully qualified path name of the currently
  269.                        open project file, or an empty string if no project is
  270.                        open.
  271.  
  272.     GetUnitCount     - returns the current number of units belonging to the
  273.                        project.
  274.  
  275.     GetUnitName      - returns a fully qualified name of the specified unit.
  276.  
  277.     EnumProjectUnits - Calls EnumProc once for each unit in the project.
  278.  
  279.     GetFormCount     - returns the current number of forms belonging to the
  280.                        project.
  281.  
  282.     GetFormName      - returns a fully qualified name of the specified form
  283.                        file.
  284.  
  285.     GetCurrentFile   - returns a fully qualified name of the current file,
  286.                        which could either be a form or unit (.PAS).
  287.                        Returns a blank string if no file is currently selected.
  288.  
  289.     IsFileOpen       - returns True if the named file is currently open.
  290.  
  291.     GetNewModuleName - Automatically generates a valid Filename and Unit
  292.                        identifier.  Uses the same mechanism as used by the IDE.
  293.  
  294.     ( Component library interface )
  295.  
  296.     GetModuleCount   - Returns the number of currently installed modules in the
  297.                        component library.
  298.  
  299.     GetModuleName    - Returns then name of the module given its index.
  300.  
  301.     GetComponentCount- Returns the number of components installed in a particular
  302.                        module.
  303.  
  304.     GetComponentName - Returns the name of the component given its module index
  305.                        and index in that mnodule.
  306.  
  307.     ( Virtual file system interface )
  308.  
  309.     RegisterFileSystem   - Registers an externally defined file system.
  310.     UnRegisterFileSystem - UnRegisters an externally defined file system.
  311.  
  312.     ( Module Interfaces )
  313.  
  314.     GetModuleInterface - Return an module interface associated with the given
  315.                          file.  NOTE: This function returns the same interface
  316.                          instance for a given module, only the reference count
  317.                          is adjusted.  The user of this interface owns it and
  318.                          must call release when finished.
  319.  
  320.     GetFormModuleInterface - Return an module interface associated with the
  321.                             given form.  NOTE: See GetModuleInterface.
  322.  
  323.     ( Menu Interface )
  324.  
  325.     GetMainMenu        - Returns an interface to the IDE's main menu.
  326.                          See TIMainMenuIntf for details.
  327.  
  328.     ( Notification registration )
  329.  
  330.     AddNotifier        - Registers an instance of a descendant to TIAddIn-
  331.                          Notifier.
  332.     RemoveNotifier     - Removes a registered instance of a TIAddInNotifier.
  333.  
  334.     ( Pascal string handling functions )
  335.  
  336.     NOTE: These functions are provided for IDE add-in writers to use a language
  337.           other than Pascal. (C++, for example).  Add-in writers using Delphi
  338.           will never need to use these functions  (see doc about the ShareMem
  339.           unit and DELPHIMM.DLL)
  340.  
  341.     NewPascalString    - Allocates and returns a pascal long string from the
  342.                          provided PChar (char *, in C parlance).  Passing an
  343.                          empty string or nil for the PChar will return nil for
  344.                          the string (Pascal's equivilant of an empty string).
  345.  
  346.     FreePascalString   - Attempts to free the given Pascal string by
  347.                          decrementing the internal reference count and
  348.                          releasing the memory if the count returns to zero.
  349.  
  350.     ReferencePascalString - Increments the reference count of the given Pascal
  351.                             string.  This allows the calling function to
  352.                             manually extend the lifetime of the string.  NOTE:
  353.                             a corresponding call to FreePascalString must be
  354.                             made in order to actually release the string's
  355.                             memory.
  356.  
  357.     AssignPascalString - Assigns one Pascal string to another.  NOTE: NEVER
  358.                          directly assign Pascal strings to each other.  Doing
  359.                          so will orphan memory and cause a memory leak.  The
  360.                          destination may be referencing another string, so
  361.                          the reference count of that string must be decremented.
  362.                          Likewise, the reference count of the source string
  363.                          must be incremented.
  364.  
  365.     ( Error handling )
  366.  
  367.     RaiseException   - This will cause an Exception to be raised with the IDE
  368.                        with the string passed to this function.  ***NOTE: This
  369.                        will cause the stack to unwind and control will **NOT**
  370.                        return to this point.  It is the resposibility of the
  371.                        Library to be sure it has correctly handled the error
  372.                        condition before calling this procedure.
  373.  
  374.     ( Configuration Access )
  375.  
  376.     GetBaseRegistryKey - returns a string representing the full path to
  377.                          Delphi's base registry key.  This key is relative
  378.                          to HKEY_CURRENT_USER.
  379.  
  380.     ( Extensions )
  381.  
  382.     GetFormBounds - Returns the default bounds of an initial form or custom
  383.                     module.
  384.  
  385.     ProjectCreate - Creates a project using the new TIProjectCreator interface.
  386.                     This allows finer control over the creation process
  387.  
  388.     ModuleCreate  - Creates a module using the new TIModuleCreator interface.
  389.                     Same as above.
  390.  
  391.     ( Extended Notification registration )
  392.  
  393.     AddNotifierEx      - Registers an instance of a descendant to TIAddIn-
  394.                          Notifier.  Only notifiers registered using this
  395.                          function will have EventNotification interface
  396.                          function called.
  397.   }
  398.  
  399.   TCreateModuleFlag = (cmAddToProject, cmShowSource, cmShowForm,
  400.     cmUnNamed, cmNewUnit, cmNewForm, cmMainForm, cmMarkModified,
  401.     cmNewFile, cmExisting);
  402.   TCreateModuleFlags = set of TCreateModuleFlag;
  403.   TCreateProjectFlag = (cpCustom, cpApplication, cpLibrary, cpCanShowSource,
  404.     cpExisting, cpConsole);
  405.   TCreateProjectFlags = set of TCreateProjectFlag;
  406.   TBoundsType = (btForm, btCustomModule);
  407.   TProjectEnumProc = function (Param: Pointer; const FileName, UnitName,
  408.     FormName: string): Boolean stdcall;
  409.   TProjectEnumModuleProc = function (Param: Pointer; const FileName, UnitName,
  410.     FormName, DesignClass: string): Boolean stdcall;
  411.  
  412.   TIToolServices = class(TInterface)
  413.   public
  414.     { Action interfaces }
  415.     function CloseProject: Boolean; virtual; stdcall; abstract;
  416.     function OpenProject(const ProjName: string): Boolean; virtual; stdcall; abstract;
  417.     function OpenProjectInfo(const ProjName: string): Boolean; virtual; stdcall; abstract;
  418.     function SaveProject: Boolean; virtual; stdcall; abstract;
  419.     function CloseFile(const FileName: string): Boolean; virtual; stdcall; abstract;
  420.     function SaveFile(const FileName: string): Boolean; virtual; stdcall; abstract;
  421.     function OpenFile(const FileName: string): Boolean; virtual; stdcall; abstract;
  422.     function ReloadFile(const FileName: string): Boolean; virtual; stdcall; abstract;
  423.     function ModalDialogBox(Instance: THandle; TemplateName: PChar;  WndParent: HWnd;
  424.       DialogFunc: TFarProc; InitParam: LongInt): Integer; virtual; stdcall; abstract;
  425.     function CreateModule(const ModuleName: string;
  426.       Source, Form: IStream; CreateFlags: TCreateModuleFlags): Boolean;
  427.       virtual; stdcall; abstract;
  428.     function CreateModuleEx(const ModuleName, FormName, AncestorClass,
  429.       FileSystem: string; Source, Form: IStream;
  430.       CreateFlags: TCreateModuleFlags): TIModuleInterface; virtual; stdcall; abstract;
  431.  
  432.     { Project/UI information }
  433.     function GetParentHandle: HWND; virtual; stdcall; abstract;
  434.     function GetProjectName: string; virtual; stdcall; abstract;
  435.     function GetUnitCount: Integer; virtual; stdcall; abstract;
  436.     function GetUnitName(Index: Integer): string; virtual; stdcall; abstract;
  437.     function EnumProjectUnits(EnumProc: TProjectEnumProc; Param: Pointer): Boolean;
  438.       virtual; stdcall; abstract;
  439.     function GetFormCount: Integer; virtual; stdcall; abstract;
  440.     function GetFormName(Index: Integer): string; virtual; stdcall; abstract;
  441.     function GetCurrentFile: string; virtual; stdcall; abstract;
  442.     function IsFileOpen(const FileName: string): Boolean; virtual; stdcall; abstract;
  443.     function GetNewModuleName(var UnitIdent, FileName: string): Boolean; virtual; stdcall; abstract;
  444.  
  445.     { Component Library interface }
  446.     function GetModuleCount: Integer; virtual; stdcall; abstract;
  447.     function GetModuleName(Index: Integer): string; virtual; stdcall; abstract;
  448.     function GetComponentCount(ModIndex: Integer): Integer; virtual; stdcall; abstract;
  449.     function GetComponentName(ModIndex, CompIndex: Integer): string; virtual; stdcall; abstract;
  450.     {function InstallModule(const ModuleName: string): Boolean; virtual; stdcall; abstract;
  451.     function CompileLibrary: Boolean; virtual; stdcall; abstract;}
  452.  
  453.     { Virtual File system interfaces }
  454.     function RegisterFileSystem(AVirtualFileSystem: TIVirtualFileSystem): Boolean; virtual; stdcall; abstract;
  455.     function UnRegisterFileSystem(const Ident: string): Boolean; virtual; stdcall; abstract;
  456.     function GetFileSystem(const Ident: string): TIVirtualFileSystem; virtual; stdcall; abstract;
  457.  
  458.     { Editor Interfaces }
  459.     function GetModuleInterface(const FileName: string): TIModuleInterface;
  460.       virtual; stdcall; abstract;
  461.     function GetFormModuleInterface(const FormName: string): TIModuleInterface;
  462.       virtual; stdcall; abstract;
  463.  
  464.     { Menu Interfaces }
  465.     function GetMainMenu: TIMainMenuIntf; virtual; stdcall; abstract;
  466.  
  467.     { Notification registration }
  468.     function AddNotifier(AddInNotifier: TIAddInNotifier): Boolean;
  469.       virtual; stdcall; abstract;
  470.     function RemoveNotifier(AddInNotifier: TIAddInNotifier): Boolean;
  471.       virtual; stdcall; abstract;
  472.  
  473.     { Pascal string handling functions }
  474.     function NewPascalString(Str: PChar): Pointer; virtual; stdcall; abstract;
  475.     procedure FreePascalString(var Str: Pointer); virtual; stdcall; abstract;
  476.     procedure ReferencePascalString(var Str: Pointer); virtual; stdcall; abstract;
  477.     procedure AssignPascalString(var Dest, Src: Pointer); virtual; stdcall; abstract;
  478.  
  479.     { Error handling }
  480.     procedure RaiseException(const Message: string); virtual; stdcall; abstract;
  481.  
  482.     { Configuration Access }
  483.     function GetBaseRegistryKey: string; virtual; stdcall; abstract;
  484.  
  485.     { Extensions }
  486.     function GetFormBounds(BoundsType: TBoundsType): TRect; virtual; stdcall; abstract;
  487.     function ProjectCreate(ProjectCreator: TIProjectCreator;
  488.       CreateFlags: TCreateProjectFlags): TIModuleInterface; virtual; stdcall; abstract;
  489.     function ModuleCreate(ModuleCreator: TIModuleCreator;
  490.       CreateFlags: TCreateModuleFlags): TIModuleInterface; virtual; stdcall; abstract;
  491.  
  492.     { Extended Notification registration }
  493.     function AddNotifierEx(AddInNotifier: TIAddInNotifier): Boolean;
  494.       virtual; stdcall; abstract;
  495.  
  496.     { Create a unique unit name and class name }
  497.     function GetNewModuleAndClassName(const Prefix: string; var UnitIdent,
  498.       ClassName, FileName: string): Boolean; virtual; stdcall; abstract;
  499.  
  500.     function CreateCppModule(const ModuleName, FormName, AncestorClass,
  501.       FileSystem: string; HdrSource, Source, Form: IStream;
  502.       CreateFlags: TCreateModuleFlags): TIModuleInterface; virtual; stdcall; abstract;
  503.     function GetVcsCount: Integer; virtual; stdcall; abstract;
  504.     procedure GetVcsList(List: TStringList); virtual; stdcall; abstract;
  505.     function GetVcsName(Index: Integer): string; virtual; stdcall; abstract;
  506.  
  507.     function EnumProjectModules(EnumProc: TProjectEnumModuleProc; Param: Pointer): Boolean;
  508.       virtual; stdcall; abstract;
  509.  
  510.     function ProjectCreateEx(ProjectCreator: TIProjectCreatorEx;
  511.       CreateFlags: TCreateProjectFlags): TIModuleInterface; virtual; stdcall; abstract;
  512.     function ModuleCreateEx(ModuleCreator: TIModuleCreatorEx;
  513.       CreateFlags: TCreateModuleFlags): TIModuleInterface; virtual; stdcall; abstract;
  514.   end;
  515.  
  516. implementation
  517.  
  518. end.
  519.