Sage-ST ä

Ctrltree

Documentation

AddItem ControlCommand CurrentControlID CurrentDialogID
DeleteItem DisableControl EnableControl ExpandTheItem
GetBmpIndex GetChild GetItemHandle GetItemInfo
GetSelectedItemChild GetSelectedItemInfo HideControl IsEnabled
ModifyItem ModifyItemBitmaps RedrawControl STRAddItem
STRGetItemInfo STRGetSelectedItemInfo STRModifyItem SelectItem
SetBmpID SetBmpIDInstance SetFocus SetRange
ShowControl




  function ControlCommand
             (const msgType : DWSpec.DisplayMessageType;
              const msgData : pointer) : ControlMessage; stdcall;

  exports ControlCommand name 'CtrlTree_ControlCommand';

  //*
  //  ControlCommand - Retrieves a command which has been sent from a control.
  //
  //
  //  This routine will retrieve a command which has been sent from the
  //  control to the ActionProc.
  //
  //  CALLING SEQUENCE -
  //
  //    command := ControlCommand (msgType, msgData)
  //
  //  ENTRY -
  //
  //    msgType : DWSpec.DisplayMessageType
  //      The msgType parameter which was passed into the ActionProc.
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //  EXIT -
  //
  //    command : ControlMessage
  //      The command which has been sent.  Must be one of the Control
  //      Messages defined for the control receiving the command.  The
  //      command Unknown indicates an undefined command has been sent.
  //




  function CurrentDialogID
             (const msgData : pointer) : cardinal; stdcall;

  exports CurrentDialogID name 'CtrlTree_CurrentDialogID';

  //*
  //  CurrentDialogID - Retrieves the ID of a dialog to which a message was sent.
  //
  //
  //  This routine will retrieve a the ID of a dialog to which a message
  //  has been sent.
  //
  //  CALLING SEQUENCE -
  //
  //    dialogID := CurrentDialogID (msgData)
  //
  //  ENTRY -
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //  EXIT -
  //
  //    dialogID : cardinal
  //      The ID of the dialog receiving a message.
  //




  function CurrentControlID
             (const msgData : pointer) : cardinal; stdcall;

  exports CurrentControlID name 'CtrlTree_CurrentControlID';

  //*
  //  CurrentControlID - Retrieves ID of control for which a message is intended.
  //
  //
  //  This routine will retrieve the ID of a control for which a message
  //  is intended.
  //
  //  CALLING SEQUENCE -
  //
  //    controlID := CurrentControlID (msgData)
  //
  //  ENTRY -
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //  EXIT -
  //
  //    controlID : cardinal
  //      The ID of the control.
  //




  function IsEnabled
             (const dialogID  : cardinal;
              const controlID : cardinal) : boolean; stdcall;

  exports IsEnabled name 'CtrlTree_IsEnabled';

  //*
  //  IsEnabled - Checks to see if a control is enabled.
  //
  //
  //  This routine will determine whether a control is enabled or
  //  disabled (grayed).
  //
  //  CALLING SEQUENCE -
  //
  //    status := IsEnabled (dialogID, controlID)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //  EXIT -
  //
  //    status : boolean
  //      True if the control is enabled.
  //




  procedure EnableControl
             (const dialogID  : cardinal;
              const controlID : cardinal); stdcall;

  exports EnableControl name 'CtrlTree_EnableControl';

  //*
  //  EnableControl - Enables a control.
  //
  //
  //  This routine will enable the specified control.
  //
  //  CALLING SEQUENCE -
  //
  //    EnableControl (dialogID, controlID)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //




  procedure DisableControl
             (const dialogID  : cardinal;
              const controlID : cardinal); stdcall;

  exports DisableControl name 'CtrlTree_DisableControl';

  //*
  //  DisableControl - Disables a control.
  //
  //
  //  This routine will disable (gray) the specified control.
  //
  //  CALLING SEQUENCE -
  //
  //    DisableControl (dialogID, controlID)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //




  procedure HideControl
             (const dialogID  : cardinal;
              const controlID : cardinal); stdcall;

  exports HideControl name 'CtrlTree_HideControl';

  //*
  //  HideControl - Hides a control.
  //
  //
  //  This routine will hide the specified control.
  //
  //  CALLING SEQUENCE -
  //
  //    HideControl (dialogID, controlID)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //




  procedure ShowControl
             (const dialogID  : cardinal;
              const controlID : cardinal); stdcall;

  exports ShowControl name 'CtrlTree_ShowControl';

  //*
  //  ShowControl - Shows a control.
  //
  //
  //  This routine will show the specified control.
  //
  //  CALLING SEQUENCE -
  //
  //    ShowControl (dialogID, controlID)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //




  procedure SetFocus
             (const dialogID  : cardinal;
              const controlID : cardinal); stdcall;

  exports SetFocus name 'CtrlTree_SetFocus';

  //*
  //  SetFocus - Sets to focus to a control.
  //
  //
  //  This routine will give the specified control focus.
  //
  //  CALLING SEQUENCE -
  //
  //    SetFocus (dialogID, controlID)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //




  procedure RedrawControl
             (const dialogID  : cardinal;
              const controlID : cardinal); stdcall;

  exports RedrawControl name 'CtrlTree_RedrawControl';

  //*
  //  RedrawControl - Redraws a control.
  //
  //
  //  This routine will redraw the specified control.
  //
  //  CALLING SEQUENCE -
  //
  //    RedrawControl (dialogID, controlID)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //




  procedure AddItem
             (const dialogID      : cardinal;
              const controlID     : cardinal;
              const Parent        : TreeItemHandle;
              const insAfter      : TreeItemHandle;
              const Value         : array of char;
              const bitmapIndex   : cardinal;
              const selectedIndex : cardinal;
              var   thisItem      : TreeItemHandle); overload; stdcall;

  exports AddItem (const dialogID      : cardinal;
                   const controlID     : cardinal;
                   const Parent        : TreeItemHandle;
                   const insAfter      : TreeItemHandle;
                   const Value         : array of char;
                   const bitmapIndex   : cardinal;
                   const selectedIndex : cardinal;
                   var   thisItem      : TreeItemHandle) name 'CtrlTree_AddItem';

  //*
  //  AddItem - Adds an item to a SageTree.
  //
  //
  //  This routine will add an item to a SageTree.
  //
  //  CALLING SEQUENCE -
  //
  //    AddItem (dialogID, controlID, parent, insAfter, value, bitmapIndex,
  //             thisItem)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    parent : TreeItemHandle
  //      The handle of the parent of the item to add.  Set to NIL
  //      if adding an item to the root of the tree.
  //
  //    insAfter : TreeItemHandle
  //      The handle of the sibling prior to the item to add.  Mey be
  //      one of the following types -
  //
  //        TreeRoot  The start of the tree.
  //        TreeFirst The first item in the tree.
  //        TreeLast  The last item in the tree.
  //
  //    value : array of char
  //      The item text.
  //
  //    bitmapIndex : cardinal
  //      If the bitmap style in the resource is set to <user defined>,
  //      then set this to the List ID of the bitmap to show with the
  //      item.  Otherwise, set to 0.
  //
  //    selectedIndex : cardinal
  //      If the bitmap style in the resource is set to <user defined>,
  //      then set this to the List ID of the bitmap to show with when
  //      the item is selected.  Otherwise, set to bitmapIndex.
  //
  //  EXIT -
  //
  //    thisItem : TreeItemHandle
  //      The handle of the item which has been added.
  //




  procedure AddItem
             (const dialogID      : cardinal;
              const controlID     : cardinal;
              const Parent        : TreeItemHandle;
              const insAfter      : TreeItemHandle;
              const Value         : string;
              const bitmapIndex   : cardinal;
              const selectedIndex : cardinal;
              var   thisItem      : TreeItemHandle); overload; stdcall;

  exports AddItem (const dialogID      : cardinal;
                   const controlID     : cardinal;
                   const Parent        : TreeItemHandle;
                   const insAfter      : TreeItemHandle;
                   const Value         : string;
                   const bitmapIndex   : cardinal;
                   const selectedIndex : cardinal;
                   var   thisItem      : TreeItemHandle) name 'CtrlTree_STRAddItem';

  //*
  //  STRAddItem - See documentation of AddItem.
  //




  procedure DeleteItem
             (const dialogID  : cardinal;
              const controlID : cardinal;
              const thisItem  : TreeItemHandle); stdcall;

  exports DeleteItem name 'CtrlTree_DeleteItem';

  //*
  //  DeleteItem - Deletes an item from a SageTree.
  //
  //
  //  This routine will delete an item from a SageTree.
  //
  //  CALLING SEQUENCE -
  //
  //    DeleteItem (dialogID, controlID, thisItem)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    thisItem : TreeItemHandle
  //      The handle of the item to delete.
  //




  function GetBmpIndex
             (const msgType : DWSpec.DisplayMessageType;
              const msgData : pointer) : cardinal; stdcall;

  exports GetBmpIndex name 'CtrlTree_GetBmpIndex';

  //*
  //  GetBmpIndex - Get the index position of bitmap requested by a FindItem message.
  //
  //
  //  The FindItem message is sent when the programmer has specified in
  //  the resource file that they wish to use user defined bitmaps.
  //  The SageTree will build a list of all the bitmaps to be used with
  //  the SageTree control.  This list will contain a list index (0 .. n-1)
  //  and its associated bitmap ID from the resource file.  The programmer
  //  will use the list index to refer to the bitmap when adding items
  //  to the tree.  The FindItem message is received once for each bitmap
  //  the programmer specified in the SetRange routine.  This routine is
  //  used to get the list index of the bitmap that the SageTree is
  //  requesting.  The programmer uses this index to determine which bitmap
  //  ID should be sent to the SageTree using the SetBmpID routine.  Note :
  //  the bitmaps defined in the resource must be of size 16X16.
  //
  //  CALLING SEQUENCE -
  //
  //    index := GetBmpIndex (msgType, msgData)
  //
  //  ENTRY -
  //
  //    msgType : DWSpec.DisplayMessageType
  //      The msgType parameter which was passed into the ActionProc.
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //  EXIT -
  //
  //    index : cardinal
  //      The list index of the bitmap that the SageTree is requesting.
  //




  procedure GetItemHandle
             (const dialogID    : cardinal;
              const controlID   : cardinal;
              const thisItem    : TreeItemHandle;
              const itemRequest : ItemRequestType;
              var   returnItem  : TreeItemHandle); stdcall;

  exports GetItemHandle name 'CtrlTree_GetItemHandle';

  //*
  //  GetItemHandle - Gets the handle of the specified tree item.
  //
  //
  //  This routine provides the ability to retreive the handle to an item
  //  in the tree control.
  //
  //  CALLING SEQUENCE -
  //
  //    GetItemHandle (dialogID, controlID, thisItem, itemRequest, returnItem)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    thisItem : TreeItemHandle
  //      The handle to a tree item which may be used as a point of
  //      reference in performing the search requested by the
  //      itemRequest flag.
  //
  //    itemRequest : ItemRequestType
  //      Must be one of the following -
  //          Selected - Returns the handle of the currently selected
  //                            tree item.
  //          FirstChild - Returns the handle of the first child item.
  //          DropTarget - Returns the handle of the item which is the target
  //                            of a drag and drop operation.
  //          FirstVisible - Returns the handle of the first visible item.
  //          NextSibling - Returns the handle of the next sibling of the
  //                            item identified by the thisItem handle.
  //          NextVisible - Returns the handle of the next visible item
  //                            following the item specified by the thisItem
  //                            handle.
  //          Parent - Returns the handle of the parent of the item
  //                            specified by the thisItem handle.
  //          PreviousSibling - Returns the handle of the previous sibling of
  //                            the item identified by the thisItem handle.
  //          PreviousVisible - Returns the handle of the visible item previous
  //                            to the item specified by the thisITem handle.
  //          Root - Returns the handle of the topmost item in the
  //                            tree control.
  //
  //  EXIT -
  //
  //    returnItem : TreeItemHandle
  //      The handle of the requested tree item.
  //




  procedure GetChild
             (const dialogID  : cardinal;
              const controlID : cardinal;
              const thisItem  : TreeItemHandle;
              var   child     : TreeItemHandle); stdcall;

  exports GetChild name 'CtrlTree_GetChild';




  procedure GetItemInfo
             (const dialogID  : cardinal;
              const controlID : cardinal;
              const thisItem  : TreeItemHandle;
              var   Parent    : TreeItemHandle;
              var   insAfter  : TreeItemHandle;
              var   Value     : array of char); overload; stdcall;

  exports GetItemInfo (const dialogID  : cardinal;
                       const controlID : cardinal;
                       const thisItem  : TreeItemHandle;
                       var   Parent    : TreeItemHandle;
                       var   insAfter  : TreeItemHandle;
                       var   Value     : array of char) name 'CtrlTree_GetItemInfo';

  //*
  //  GetItemInfo - Get information about a SageTree item.
  //
  //
  //  This routine will return the parent, sibling, and value of an
  //  item in a SageTree.
  //
  //  CALLING SEQUENCE -
  //
  //    GetItemInfo (dialogID, controlID, thisItem, parent, insAfter, value)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    thisItem : TreeItemHandle
  //      The handle of the item to get information about.
  //
  //  EXIT -
  //
  //    parent : TreeItemHandle
  //      The handle of the parent of the item.
  //
  //    insAfter : TreeItemHandle
  //      The handle of the sibling prior to the item.
  //
  //    value : array of char
  //      The text string associated with the tree item.
  //




  procedure GetItemInfo
             (const dialogID  : cardinal;
              const controlID : cardinal;
              const thisItem  : TreeItemHandle;
              var   Parent    : TreeItemHandle;
              var   insAfter  : TreeItemHandle;
              var   Value     : string); overload; stdcall;

  exports GetItemInfo (const dialogID  : cardinal;
                       const controlID : cardinal;
                       const thisItem  : TreeItemHandle;
                       var   Parent    : TreeItemHandle;
                       var   insAfter  : TreeItemHandle;
                       var   Value     : string) name 'CtrlTree_STRGetItemInfo';

  //*
  //  STRGetItemInfo - See documentation of GetItemInfo.
  //




  procedure GetSelectedItemInfo
             (const msgType       : DWSpec.DisplayMessageType;
              const msgData       : pointer;
              var   Parent        : TreeItemHandle;
              var   insAfter      : TreeItemHandle;
              var   thisItem      : TreeItemHandle;
              var   Value         : array of char;
              var   bitmapIndex   : cardinal;
              var   selectedIndex : cardinal); overload; stdcall;

  exports GetSelectedItemInfo (const msgType       : DWSpec.DisplayMessageType;
                               const msgData       : pointer;
                               var   Parent        : TreeItemHandle;
                               var   insAfter      : TreeItemHandle;
                               var   thisItem      : TreeItemHandle;
                               var   Value         : array of char;
                               var   bitmapIndex   : cardinal;
                               var   selectedIndex : cardinal) name 'CtrlTree_GetSelectedItemInfo';

  //*
  //  GetSelectedItemInfo - Get information about the selected SageTree item.
  //
  //
  //  The SelectedChange, ExpandItem, or CollapseItem message is sent when the user
  //  has selected, expanded, or collapsed an item in the SageTree.  This routine can
  //  be used to get information about the item which has been selected.
  //
  //  CALLING SEQUENCE -
  //
  //    GetSelectedITemInfo (msgType, msgData, parent, insAfter, thisItem, value,
  //                         bitmapIndex)
  //
  //  ENTRY -
  //
  //    msgType : DWSpec.DisplayMessageType
  //      The msgType parameter which was passed into the ActionProc.
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //  EXIT -
  //
  //    parent : TreeItemHandle
  //      The handle of the parent of the selected item.
  //
  //    insAfter : TreeItemHandle
  //      The handle of the sibling prior to the selected item.
  //
  //    thisItem : TreeItemHandle
  //      The handle of the selected item.
  //
  //    value : array of char
  //      The text string associated with the selected item.
  //
  //    bitmapIndex : cardinal
  //      The bitmap list index of the selected item.
  //
  //    selectedIndex : cardinal
  //      The bitmap list index of the bitmap used when the selected item is in the
  //      selected state.
  //




  procedure GetSelectedItemInfo
             (const msgType       : DWSpec.DisplayMessageType;
              const msgData       : pointer;
              var   Parent        : TreeItemHandle;
              var   insAfter      : TreeItemHandle;
              var   thisItem      : TreeItemHandle;
              var   Value         : string;
              var   bitmapIndex   : cardinal;
              var   selectedIndex : cardinal); overload; stdcall;

  exports GetSelectedItemInfo (const msgType       : DWSpec.DisplayMessageType;
                               const msgData       : pointer;
                               var   Parent        : TreeItemHandle;
                               var   insAfter      : TreeItemHandle;
                               var   thisItem      : TreeItemHandle;
                               var   Value         : string;
                               var   bitmapIndex   : cardinal;
                               var   selectedIndex : cardinal) name 'CtrlTree_STRGetSelectedItemInfo';

  //*
  //  STRGetSelectedItemInfo - See documentation of GetSelectedItemInto.
  //




  procedure GetSelectedItemChild
             (const msgType : DWSpec.DisplayMessageType;
              const msgData : pointer;
              var   child   : TreeItemHandle); stdcall;

  exports GetSelectedItemChild name 'CtrlTree_GetSelectedItemChild';




  procedure ModifyItemBitmaps
             (const dialogID      : cardinal;
              const controlID     : cardinal;
              const thisItem      : TreeItemHandle;
              const bitmapIndex   : cardinal;
              const selectedIndex : cardinal); stdcall;

  exports ModifyItemBitmaps name 'CtrlTree_ModifyItemBitmaps';

  //*
  //  ModifyItemBitmaps - Modifies item bitmaps in a SageTree.
  //
  //
  //  This routine will replace the bitmaps in an item in
  //  a SageTree.
  //
  //  CALLING SEQUENCE -
  //
  //    ModifyItemBitmaps (dialogID, controlID, thisItem, bitmapIndex, selectedIndex)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    thisItem : TreeItemHandle
  //      The handle of the item to modify.
  //
  //    bitmapIndex : cardinal
  //      The bitmap list index of the item.
  //
  //    selectedIndex : cardinal
  //      The bitmap list index of the bitmap used when the item is in the
  //      selected state.
  //




  procedure ModifyItem
             (const dialogID  : cardinal;
              const controlID : cardinal;
              const thisItem  : TreeItemHandle;
              const Value     : array of char); overload; stdcall;

  exports ModifyItem (const dialogID  : cardinal;
                      const controlID : cardinal;
                      const thisItem  : TreeItemHandle;
                      const Value     : array of char) name 'CtrlTree_ModifyItem';

  //*
  //  ModifyItem - Modifies an item in a SageTree.
  //
  //
  //  This routine will replace the text in an item in
  //  a SageTree.
  //
  //  CALLING SEQUENCE -
  //
  //    ModifyItem (dialogID, controlID, thisItem, value)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    thisItem : TreeItemHandle
  //      The handle of the item to modify.
  //
  //    value : array of char
  //      The text string to be associated with the tree item.
  //




  procedure ModifyItem
             (const dialogID  : cardinal;
              const controlID : cardinal;
              const thisItem  : TreeItemHandle;
              const Value     : string); overload; stdcall;

  exports ModifyItem (const dialogID  : cardinal;
                      const controlID : cardinal;
                      const thisItem  : TreeItemHandle;
                      const Value     : string) name 'CtrlTree_STRModifyItem';

  //*
  //  STRModifyItem - See documentation of ModifyItem.
  //




  procedure SelectItem
             (const dialogID  : cardinal;
              const controlID : cardinal;
              const thisItem  : TreeItemHandle); stdcall;

  exports SelectItem name 'CtrlTree_SelectItem';

  //*
  //  SelectItem - Selects an item in a SageTree.
  //
  //
  //  This routine will select an item in a SageTree.  The SageTree will
  //  be scrolled so that the item is visible.
  //
  //  CALLING SEQUENCE -
  //
  //    SelectItem (dialogID, controlID, thisItem)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    thisItem : TreeItemHandle
  //      The handle of the item to select.
  //




  procedure ExpandTheItem
             (const dialogID   : cardinal;
              const controlID  : cardinal;
              const thisItem   : TreeItemHandle;
              const expandType : ExpandMethod); stdcall;

  exports ExpandTheItem name 'CtrlTree_ExpandTheItem';

  //*
  //  ExpandTheItem - Expands or collapse the specified item in a SageTree.
  //
  //
  //  This routine will ex[and the specified item in a SageTree.
  //
  //  CALLING SEQUENCE -
  //
  //    ExpandTheItem (dialogID, controlID, thisItem, expandType)
  //
  //  ENTRY -
  //
  //    dialogID : cardinal
  //      The number of the dialog box or window containing the
  //      control.
  //
  //    controlID : cardinal
  //      The control resource identifier.
  //
  //    thisItem : TreeItemHandle
  //      The handle of the item to select.
  //
  //    expandType : ExpandMethod
  //      The method to be used to expand/collapse the tree.
  //      If expandType is 'Collapse' then the item is collapsed.
  //      If expandType is 'CollapseReset' then the item is collapsed and children removed.
  //      If expandType is 'Expand' then the item is expanded.
  //      If expandType is 'Toggle' then the item is toggled.
  //




  procedure SetBmpID
             (const msgType   : DWSpec.DisplayMessageType;
              const msgData   : pointer;
              const userBmpID : cardinal); stdcall;

  exports SetBmpID name 'CtrlTree_SetBmpID';

  //*
  //  SetBmpID - Set the bitmap ID of the bitmap requested by a FindItem message.
  //
  //
  //  The FindItem message is sent when the programmer has specified in
  //  the resource file that they wish to use user defined bitmaps.
  //  The SageTree will build a list of all the bitmaps to be used with
  //  the SageTree control.  This list will contain a list index (0 .. n-1)
  //  and their associated bitmap IDs from the resource file.  The
  //  programmer will use the list index to refer to the bitmap when
  //  adding items to the tree.  The FindItem message is received once
  //  for each bitmap the programmer specified in the SetRange routine.
  //  This routine is used to set the bitmap ID at the list position
  //  specified by the return value of the routine GetBmpIndex.
  //
  //  CALLING SEQUENCE -
  //
  //    SetBmpID (msgType, msgData, userBmpID)
  //
  //  ENTRY -
  //
  //    msgType : DWSpec.DisplayMessageType
  //      The msgType parameter which was passed into the ActionProc.
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //    userBmpID : cardinal
  //      The resource ID of the bitmap to be placed in the bitmap list
  //      at the position indicated by GetBmpIndex.
  //
  //  EXIT -
  //
  //    None
  //      N/A
  //




  procedure SetBmpIDInstance
             (const msgType   : DWSpec.DisplayMessageType;
              const msgData   : pointer;
              const userBmpID : cardinal;
              const bInstance : Windows.hInst); stdcall;

  exports SetBmpIDInstance name 'CtrlTree_SetBmpIDInstance';

  //*
  //  SetBmpIDInstance - Set the bitmap ID of the bitmap requested by a FindItem message.
  //
  //  The FindItem message is sent when the programmer has specified in
  //  the resource file that they wish to use user defined bitmaps.
  //  The SageTree will build a list of all the bitmaps to be used with
  //  the SageTree control.  This list will contain a list index (0 .. n-1)
  //  and their associated bitmap IDs from the resource file.  The
  //  programmer will use the list index to refer to the bitmap when
  //  adding items to the tree.  The FindItem message is received once
  //  for each bitmap the programmer specified in the SetRange routine.
  //  This routine is used to set the bitmap ID at the list position
  //  specified by the return value of the routine GetBmpIndex.
  //
  //  This procedure differs from the 'SetBmpID' procedure by allowing
  //  the specification of the program or DLL instance handle associated
  //  with the BMP ID if other than the current program.
  //
  //  CALLING SEQUENCE -
  //
  //    SetBmpIDInstance (msgType, msgData, userBmpID, bInstance))
  //
  //  ENTRY -
  //
  //    msgType : DWSpec.DisplayMessageType
  //      The msgType parameter which was passed into the ActionProc.
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //    userBmpID : cardinal
  //      The resource ID of the bitmap to be placed in the bitmap list
  //      at the position indicated by GetBmpIndex.
  //
  //    bInstance : Windows.HINST
  //      The instance handle of the program/DLL containing the
  //      referenced BMP ID.
  //
  //  EXIT -
  //
  //    None
  //      N/A
  //




  procedure SetRange
             (const msgType      : DWSpec.DisplayMessageType;
              const msgData      : pointer;
              const userBmpTotal : cardinal); stdcall;

  exports SetRange name 'CtrlTree_SetRange';

  //*
  //  SetRange - Set the number of user defined bitmaps to be used with a SageTree.
  //
  //
  //  The Range message is sent when the programmer has specified in the
  //  resource file that they wish to use user defined bitmaps.  This
  //  routine is used to return the number of bitmaps that they plan to use
  //  for the SageTree.
  //
  //  CALLING SEQUENCE -
  //
  //    SetRange (msgType, msgData, userBMPTotal)
  //
  //  ENTRY -
  //
  //    msgType : DWSpec.DisplayMessageType
  //      The msgType parameter which was passed into the ActionProc.
  //
  //    msgData : pointer
  //      The msgData parameter which was passed into the ActionProc.
  //
  //    userBMPTotal : cardinal
  //      The number of user defined bitmaps that will be used with the
  //      SageTree.
  //




Send mail to   warren.merrill@inl.gov with questions or comments about this web site.
Copyright © 1989-2006 Battelle Energy Alliance