home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / tpw / custcntl.pas < prev    next >
Pascal/Delphi Source File  |  1991-09-08  |  8KB  |  213 lines
  1. {*******************************************************}
  2. {                                                       }
  3. {       Turbo Pascal                                    }
  4. {       Custom Control API Interface Unit               }
  5. {                                                       }
  6. {       Copyright (c) 1991 Borland International        }
  7. {                                                       }
  8. {*******************************************************}
  9.  
  10. unit CustCntl;
  11.  
  12. interface
  13.  
  14. uses WinTypes;
  15.  
  16. const
  17.   ctlTypes = 12;
  18.   ctlDescr = 22;
  19.   ctlClass = 20;
  20.   ctlTitle = 94;
  21.  
  22. { CONTROL STYLE DATA STRUCTURE
  23.  
  24.   This data structure is used by the class style dialog function
  25.   to set and/or reset various control attributes.}
  26.  
  27. type
  28.   PCtlStyle = ^TCtlStyle;
  29.   TCtlStyle = record
  30.     wX:   Word;                             { x origin of control }
  31.     wY:   Word;                             { y origin of control }
  32.     wCx:  Word;                             { width of control }
  33.     wCy:  Word;                             { height of control }
  34.     wId:  Word;                             { control child id }
  35.     dwStyle: LongInt;                       { control style }
  36.     szClass: array[0..ctlClass-1] of Char;  { name of control class }
  37.     szTitle: array[0..ctlTitle-1] of Char;  { control text }
  38.   end;
  39.  
  40. { CONTROL DATA STRUCTURE
  41.  
  42.   This data structure is returned by the control options function
  43.   when inquiring about the capabilities of a particular control.
  44.   Each control may contain various types (with predefined style
  45.   bits) under one general class.
  46.  
  47.  
  48.   The width and height fields provide the application with
  49.   a suggested size. Use pixels or dialog units for the values
  50.   in these fields. If you use pixels, turn on the most significant
  51.   bit (MSB). If you use dialog units, turn off the MSB.}
  52.  
  53.   PCtlType = ^TCtlType;
  54.   TCtlType = record
  55.     wType:   Word;                          { type style }
  56.     wWidth:  Word;                          { suggested width }
  57.     wHeight: Word;                          { suggested height }
  58.     dwStyle: LongInt;                       { default style }
  59.     szDescr: array[0..ctlDescr-1] of Char;  { menu name }
  60.   end;
  61.  
  62.   PCtlInfo = ^TCtlInfo;
  63.   TCtlInfo = record
  64.     wVersion:   Word;                           { control version }
  65.     wCtlTypes:  Word;                           { control types }
  66.     szClass:    array[0..ctlClass-1] of Char;   { control class name }
  67.     szTitle:    array[0..ctlTitle-1] of Char;   { control title }
  68.     szReserved: array[0..9] of Char;            { reserved for future use }
  69.     ctType:     array[0..ctlTypes] of TCtlType; { control type list }
  70.   end;
  71.  
  72. { These two function variable types are used by dialog editor }
  73.  
  74.   TStrToId = function (Str: PChar): LongInt;
  75.   TIdToStr = function (Id: Word; Str: PChar; StrLen: Word): Word;
  76.  
  77. { Resource Workshop extensions follow here }
  78.  
  79.   TFnList  = function : THandle;
  80.   TFnInfo  = function : THandle;
  81.   TFnStyle = function(hWindow: HWnd; CntlStyle: THandle;
  82.     StrToId: TStrToId; IdToStr: TIdToStr): Bool;
  83.   TFnFlags = function(Style: LongInt; Buff: PChar; BuffLength: Word): Word;
  84.  
  85. { Resource Workshop has extended the MS Dialog editor's custom control
  86.   API in three main areas:
  87.  
  88.   1) More than 1 custom control can be placed in a single DLL.
  89.  
  90.   2) The "Info" data structure has been extended to allow custom controls
  91.      to be added to the RW toolbox.
  92.  
  93.   3) The style data structure has been extended to allow custom controls
  94.      access to the CTLDATA field. This field contains up to 255 bytes
  95.      of binary data. A pointer to this data is passed to the control
  96.      in the WM_CREATE message at runtime.
  97. }
  98.  
  99. { Two new fields have been added to the TCtlType data structure to
  100.   make the TRWCtlType structure:
  101.  
  102.   hToolBit is a handle to a 24X24 bitmap which is added to the
  103.   RW toolbox. If this field is 0, no button will be added for this style,
  104.   and it will only be selectable via the Custom control dialog. This bitmap
  105.   is "owned" by RW, and will be freed by RW when the dialog editor is
  106.   unloaded.
  107.  
  108.   hDropCurs is a handle to a cursor which is used by RW when a user selects
  109.   the control from the toolbox. If 0, a "cross" cursor will be used.
  110. }
  111.  
  112. const
  113.   ToolBitSize = 24;
  114.  
  115. type
  116.   PRWCtlType = ^TRWCtlType;
  117.   TRWCtlType = record
  118.     wType:     Word;                          { type style }
  119.     wWidth:    Word;                          { suggested width }
  120.     wHeight:   Word;                          { suggested height }
  121.     dwStyle:   LongInt;                       { default style }
  122.     szDescr:   array[0..ctlDescr-1] of Char;  { menu name }
  123.     hToolBit:  HBitmap;                       { toolbox bitmap }
  124.     hDropCurs: HCursor;                       { drag and drop cursor }
  125.   end;
  126.  
  127. { This structure reflects the RWCTLTYPE data structure }
  128.  
  129.   PRWCtlInfo = ^TRWCtlInfo;
  130.   TRWCtlInfo = record
  131.     wVersion:   Word;                             { control version }
  132.     wCtlTypes:  Word;                             { control types }
  133.     szClass:    array[0..ctlClass-1] of Char;     { control class name }
  134.     szTitle:    array[0..ctlTitle-1] of Char;     { control title }
  135.     szReserved: array[0..9] of Char;              { reserved for future use }
  136.     ctType:     array[0..ctlTypes] of TRWCtlType; { control type list }
  137.   end;
  138.  
  139. { Two new fields have been added to the CTLSTYLE data structure to make
  140.   the RWCTLSTYLE data structure:
  141.  
  142.   CtlDataSize is the size of
  143.   CtlData, which is an array of bytes passed to the control in the
  144.   WM_CREATE message.
  145. }
  146.  
  147. const
  148.   ctlDataLength = 255;
  149.  
  150. type
  151.   PRWCtlStyle = ^TRWCtlStyle;
  152.   TRWCtlStyle = record
  153.     wX:   Word;                                 { x origin of control }
  154.     wY:   Word;                                 { y origin of control }
  155.     wCx:  Word;                                 { width of control }
  156.     wCy:  Word;                                 { height of control }
  157.     wId:  Word;                                 { control child id }
  158.     dwStyle: LongInt;                           { control style }
  159.     szClass: array[0..ctlClass-1] of Char;      { name of control class }
  160.     szTitle: array[0..ctlTitle-1] of Char;      { control text }
  161.     CtlDataSize: Byte;                          { control data size }
  162.     CtlData: array[0..ctlDataLength-1] of Char; { control data }
  163.   end;
  164.  
  165. { In order to use RW's extensions to the custom controls, a custom
  166.   control DLL *must* implement the ListClasses function. This function
  167.   returns a global memory handle to an initialized CTLCLASSLIST data
  168.   structure. All function pointers *must* point to valid functions.
  169. }
  170.  
  171.   PRWCtlClass = ^TRWCtlClass;
  172.   TRWCtlClass = record
  173.     fnInfo:  TFnInfo;                       { Info function }
  174.     fnStyle: TFnStyle;                      { Style function }
  175.     fnFlags: TFnFlags;                      { Flags function }
  176.     szClass: array[0..ctlClass-1] of Char;  { Class name }
  177.   end;
  178.  
  179.   PCtlClassList = ^TCtlClassList;
  180.   TCtlClassList = record
  181.     nClasses: Integer;                       { Number of classes in list }
  182.     Classes: array[0..0] of TRWCtlClass;     { Class list }
  183.   end;
  184.  
  185. { The ListClasses function has the formal definition:
  186.  
  187.     function ListClasses(szAppName: PChar; wVersion: Word;
  188.       fnLoad: TLoad; fnEdit: TEdit): THandle; export;
  189.  
  190.   where the parameters are
  191.  
  192.     szAppName         The class name for the applications main window
  193.  
  194.     wVersion          Major and minor version number of the application
  195.  
  196.     fnLoad            A procedure variable which, when called, acts like
  197.                       a LoadResource on the current resource being edited.
  198.                       This allows controls access to resource from the
  199.                       resource file they are apart of (for example, access
  200.                       to bitmaps).
  201.  
  202.     fnEdit            Causes a resource editor to be invoked for the given
  203.                       resource.
  204. }
  205.  
  206.   TLoad = function (szType, szId: PChar): THandle;
  207.   TEdit = function (szType, szId: PChar): Bool;
  208.  
  209. implementation
  210.  
  211. end.
  212. 
  213.