-- HORIZONTAL SCROLL (TEXT) --
--
-- © Nov 2OOO, James Newton <newton@planetb.fr>
--   May 2002 revised:
--            * copes with cut and pasted text
--            * scrolls faster when the left or right arrow keys are
--              pressed
--            * no longer garbles text when an addition is made
--              anywhere before the end
--   Sep 2002 * a callback instance can now be set in the SetText
--              call to validate the text on Return or Enter
--            * SetText will populate a property list with its
--              member number and <me> behavior reference, if a
--              propList is passed as a parameter.
--   Oct 2002 * ID parameter added, so that this can be used to
--              filter for the appropriate value during a SetText()
--              call if a propList is used as the first parameter.
--              If the first parameter of a GetText() call is a
--              propList then this ID symbol will be used as the
--              property name to which the full text of the behavior
--              is attached.  To use the member number is the property
--              (as in previous versions of this behavior), use TRUE
--              or #number as the second parameter (useMemberNumber).
--   Feb 2003 * choice of separate callback handlers for Return and
--              Enter keys (#validateHandler), and for every other key
--              press (#updateHandler)
--   Mar 2003 * Scroll() public method added
--            * SetCallback() public method added, and SetText()
--              adjusted to allow callback object and handlers to be
--              set from within a SetText() call.
--
-- Use with text members.  Makes an editable text member scroll
-- horizontally if the user enters more text than can be displayed in
-- the sprite.
--
-- LIMITATIONS:
-- - Command-A and Ctrl-A will only select the text from the beginning
--   of the visible section onwards.  To select the whole text, the
--   user will need either to:
--   * Triple-click on the sprite to select the entire text
--   * Press the home key to jump to the beginning of the text.
--
--   Attempting to detect the Edit | Select all menu item or the 
--   associated keyboard shortcut is beyond the scope of this
--   behavior.
--
-- - It is not possible to scroll the text by dragging a selection.
--   After a click on an editable field, the playback head does not
--   move until the mouse is released.  There are thus no frame
--   events which could be used to update the contents of the member.
--   Nor is there anyway to intercept copy, cut and paste commands
--   that would affect a selection which extends beyond what is
--   visible in the sprite (see above) so creating such an extended
--   selection is somewhat meaningless.
----------------------------------------------------------------------




-- PROPERTY DECLARATIONS --
property spriteNum
-- author-defined properties
property ID              -- symbol id for this sprite/text member
property validateHandler -- callback handler for Return and Enter keys
property updateHandler   -- callback for all other keys
--
property pSprite         -- sprite(spriteNum)
property pMember         -- pSprite.member
property pWidth          -- width of pMember
property pAutoTab        -- duplicate of the member's autotab property
--
property pVisibleText    -- text which appears in pMember
property pFullText       -- text as typed by the user
property pClippedChars   -- number of characters not shown before 
--                          pVisibleText starts
property pScrollTicks    -- the value of the ticks when accelerated
--                          scrolling will start with the arrow keys
property pTripleTicks    -- after a double-click, ticks before which
--                          user must click again for a triple-click
--                          which will select the entire text

property pCallback       -- instance to call on callback




-- EVENT HANDLERS --

on beginSprite(me) ---------------------------------------------------
  -- ACTION: Initializes the behavior and member properties
  --------------------------------------------------------------------
  
  pSprite          = sprite(spriteNum)
  pMember          = pSprite.member
  pWidth           = pMember.width
  pFullText        = pMember.text
  pVisibleText     = pFullText
  
  pClippedChars    = 0
  
  -- Convert callback handlers to symbols, as required
  if updateHandler <> "" then
    updateHandler = symbol(updateHandler)
  end if
  if validateHandler <> "" then
    validateHandler = symbol(validateHandler)
  end if
  
  -- Ensure the text member has the expected properties
  pMember.boxType  = #fixed
  -- pMember.editable = TRUE
  pMember.wordWrap = FALSE
  pAutoTab         = pMember.autotab
  pMember.autotab  = FALSE
end beginSprite



on endSprite(me) -----------------------------------------------------
  -- ACTION: Restores the full text of the member
  --------------------------------------------------------------------
  
  pMember.text = pFullText
  pMember.autotab = pAutoTab
end endSprite



on mouseUp(me) -------------------------------------------------------
  -- ACTION: Detects if the user has triple-clicked on the sprite and
  --         if so, selects the entire text of the member
  --------------------------------------------------------------------
  
  if the doubleClick then
    if pTripleTicks > the ticks then
      -- This is a tripleClick: select the whole text
      me.mJumpToBeginning()
      pMember.selection = [0, pFullText.char.count]
    end if
    
    pTripleTicks = the ticks + 20
  end if
end mouseUp



on exitFrame(me) -----------------------------------------------------
  -- ACTION: Accelerates the use of right and left arrows to scroll
  --         the contents of the text member, and detects the use of
  --         cut and paste
  --------------------------------------------------------------------
  
  if the clickOn = spriteNum then
    if pScrollTicks then
      me.mArrowScroll()
    else if pMember.text <> pVisibleText then
      me.mCutOrPaste()
    end if
  end if
end exitFrame



on keyDown(me) -------------------------------------------------------
  -- ACTION: Calls the appropriate handler depending on the user's
  --         input
  --------------------------------------------------------------------
  
  case the key of
    RETURN, ENTER: -- Call the callback instance if appropriate
      return me.mCallback(validateHandler) -- exit handler
      
    TAB:
      if pAutoTab then
        -- Call the callback instance...
        me.mCallback(validateHandler)
        -- ... and jump to next editable sprite
        return me.mAutoTab() -- exit handler
        
      else
        -- Allow the tab key through
        pass
      end if
  end case
  
  case the KeyCode of
    115, 116, 126: -- home, page up, up arrow
      me.mJumpToBeginning()
      
    119, 121, 125: -- end, page down, down arrow
      me.mJumpToEnd()
      
    123: -- left arrow
      me.mMoveBack()
      if not pScrollTicks then
        pScrollTicks = the ticks + 20
      end if
      
    124: -- right arrow
      me.mMoveForward()
      if not pScrollTicks then
        pScrollTicks = the ticks + 20
      end if
      
    51, 117:-- BACKSPACE, delete
      me.mDeleteChars(the keyCode = 117)
      
    otherwise -- alphanumeric key
      me.mTreatAlphaNumericKey()
  end case
end keyDown



on keyUp(me)
  case the keyCode of
    36, 76, 115, 116, 126, 119, 121, 125, 123,124:
      -- The text has not changed
      
    48:
      -- Only allow TAB key to trigger update callback if it is not
      -- used to trigger the validate callback
      if not pAutoTab then
        me.mCallback(updateHandler)
      end if
      
    otherwise: -- text has changed
      me.mCallback(updateHandler)
  end case
end keyUp




-- PUBLIC METHODS --

on GetText(me, aPropList, useMemberNumber) ---------------------------
  -- INPUT: <aPropList> may be VOID or a property list
  --        <useMemberNumber> has no effect unless it is TRUE or
  --         #number and <aPropList> is a propList.  In this case,
  --         this member number will be used as the key to the string
  --         in <aPropList> rather than the ID set for this sprite.
  -- OUTPUT: the full text of this behavior.  If a property list is
  --         passed as a parameter, the full text of a number of
  --         behavior instances can be collected in a single call.
  ---------------------------------------------------------------------
  
  if ilk(aPropList, #propList) then
    case useMemberNumber of
      TRUE, #number:
        -- Provide this member's number as a reference
        aPropList.addProp(pMember.number, pFullText)
        
      otherwise:
        -- Provide this sprite's ID as a reference
        aPropList.addProp(ID, pFullText)
    end case
    
    return aPropList
    
  else -- aPropList is not a propList
    return pFullText
  end if 
end GetText



on SetText(me, aStringOrList, aPropList) -----------------------------
  -- INPUT: <aStringOrList> can be a string or it can be a property
  --         list either of the following structures:
  --            [<integer member number>: <string>, ...]
  --         OR [<symbol ID>:             <string>, ...]
  -- NOTE:   The symbols #instance, #update and #validate have a
  --         special meaning as property names.   If the ilk of the
  --         values of such properties is #script, #instance or
  --         #symbol, they will be used to define the callback for
  --         this behavior. If you use these symbols as IDs, and
  --         supply string values for them, no callback changes will
  --         be made.  See the SetCallback() handler for details.
  --        <aPropList> is intended for output rather than input.  If
  --         it is a property list, it will be populated with the
  --         member number of the text member and <me> pointer of this
  --         behavior.
  -- ACTION: Sets the text of the member of this sprite.  If
  --         <aStringOrList> is a property list, the appropriate
  --         string is chosen from the list, allowing a single call to
  --         be sent to a number of sprites.
  --------------------------------------------------------------------
  
  case ilk(aPropList) of
    #propList:
      aPropList.setaProp(pMember.number, me)
  end case
  
  case ilk(aStringOrList) of
    #string: -- Continue after the case statement
    #propList:
      -- Check if the propList defines a callback object and handlers
      me.SetCallback(aStringOrList)
      
      -- Filter for this sprite's ID or the text member's number
      tIndex = aStringOrList.findPos(ID)
      if tIndex then
        -- This sprite's ID is present
        aStringOrList = aStringOrList[tIndex]
        
      else
        tIndex = aStringOrList.findPos(pMember.number)
        if tIndex then
          -- The number of this text member is present
          aStringOrList = aStringOrList[tIndex]
        end if
      end if
      
      if not stringP(aStringOrList) then
        -- No valid string is supplied for this sprite
        exit
      end if
  end case
  
  pFullText     = aStringOrList
  pVisibleText  = aStringOrList
  pClippedChars = 0
  pMember.text  = aStringOrList
end SetText



on SetCallback(me, aPropList) ----------------------------------------
  -- SENT BY SetText() and from other scripts
  -- INPUT: <aPropList> should be a property list which may contain
  --         one or more of the following properties:
  --          [#instance: <script | instance | 0>,
  --           #update:   <symbol | 0>,
  --           #validate: <symbol | 0>]
  --         If other ilks are used for these properties, they will
  --         be ignored.  (This means that you can use these symbols
  --         as IDs for this behavior, and the SetText() handler will
  --         still function as expected).
  -- ACTION: Sets the callback object and/or the handlers used to
  --         call it.  If 0 is used for a given property, the
  --         associated object or handler is disabled.
  --------------------------------------------------------------------
  
  tInstance = aPropList[#instance]
  tUpdate   = aPropList[#update]
  tValidate = aPropList[#validate]
  
  case ilk(tInstance) of
    #script, #instance:
      pCallback = tInstance
    #integer:
      if tInstance = 0 then
        pCallback = 0
      end if
  end case
  
  case ilk(tUpdate) of
    #symbol:
      updateHandler = tUpdate
    #integer:
      if tUpdate = 0 then
        updateHandler = tUpdate
      end if
  end case
  
  case ilk(tValidate) of
    #symbol:
      validateHandler = tValidate
    #integer:
      if tValidate = 0 then
        validateHandler = tValidate
      end if
  end case
end SetCallback



on Scroll(me, aScrollStep) -------------------------------------------
  -- INPUT: <aScrollStep> can be #up or #down
  -- ACTION: Allows an external control, such as an OSscrollbar, to
  --         scroll the text horizontally.  The text insertion point
  --         will move to the end where new text appears.
  --------------------------------------------------------------------
  
  case aScrollStep of
    #up:
      if the shiftDown then
        me.mJumpToBeginning()
      else
        pMember.selection = [0, 0]
        me.mMoveBack()
      end if
      
    #down:
      if the shiftDown then
        me.mJumpToEnd()
      else
        tRightChar = pMember.locToCharPos(point(pWidth, 0))
        pMember.selection = [tRightChar, tRightChar]
        me.mMoveForward()
      end if
  end case
end Scroll




-- PRIVATE METHODS --

on mJumpToBeginning(me) ----------------------------------------------
  -- SENT BY keyDown() if the key is Start, Page up, Up arrow or by
  --         mouseUp() if the user double-clicks and then releases the
  --         mouse button quickly.
  -- ACTION: Shows full text in member with insertion point before
  --         first character.
  --------------------------------------------------------------------
  
  pVisibleText = pFullText
  pMember.text = pVisibleText
  
  pClippedChars = 0
  pMember.selection = [0, 0]
end mJumpToBeginning



on mJumpToEnd(me) ----------------------------------------------------
  -- SENT BY keyDown() if the key is End, Page down, Down arrow 
  -- ACTION: Shows only the end of the full text string, with the
  --         insertion point after the last character
  --------------------------------------------------------------------
  
  -- Sum the width of each character starting from the last, until
  -- we have reached the width of the field member
  
  pMember.text   = pFullText
  tLastChar      = pFullText.char.count
  tFullWidth     = pMember.charPosToLoc(tLastChar + 1).locH
  pClippedChars  = tLastChar
  
  repeat while pClippedChars
    tStartWidth = pMember.charPosToLoc(pClippedChars).locH
    if tFullWidth - tStartWidth > pWidth then
      exit repeat
    end if
    pClippedChars = pClippedChars - 1
  end repeat
  
  me.mShowText(tLastChar)
  
  -- Place the insertion point at the end
  tLastChar = tLastChar - pClippedChars
  pMember.selection = [tLastChar, tLastChar]
end mJumpToEnd



on mMoveBack(me) -----------------------------------------------------
  -- SENT BY keyDown() and exitFrame() if the key is Left arrow
  -- ACTION: Moves the insertion point one place left, or moves the
  --         entire visible text string one place right if the
  --         insertion point is at the leftmost point in the member
  --------------------------------------------------------------------
  
  tStartChar = pMember.selection[1]
  
  if pMember.selection[2] <> tStartChar then
    -- Unhilite the text without moving the selection
    (pMember.selection)[2] = tStartChar
    
  else if tStartChar then
    -- Move the insertion point back manually
    pMember.selection = pMember.selection - 1
    
  else
    -- The insertion point is at the beginning of the visible text
    if pClippedChars then
      -- Move the visible text to the right
      pClippedChars = pClippedChars - 1
      me.mShowText(tStartChar) -- the selection does not move
    end if
  end if
end mMoveBack



on mMoveForward(me) --------------------------------------------------
  -- SENT BY mTreatAlphaNumericKey (), and by exitFrame() and
  --         keyDown() if the key is Right arrow
  -- INPUT: <shiftIsDown> may be TRUE if the user is holding down the
  --         shift key and scrolling using the arrow keys
  -- ACTION: Moves the insertion point one place right, or removes a
  --         character at the beginning of the visible text to move
  --         the visible text string one place left if the insertion
  --         point is at the rightmost point in the member
  --------------------------------------------------------------------
  
  tEndChar  = pMember.selection[2]
  tNextChar = tEndChar + 2
  
  if pMember.selection[1] <> tEndChar then
    -- Unhilite the text without moving the selection
    pMember.selection = [tEndChar, tEndChar]
    
  else if pMember.charPosToLoc(tNextChar).locH < pWidth then
    -- Move the insertion point forwards manually
    pMember.selection = pMember.selection + 1
    
  else
    -- The insertion point would disappear beyond the end of the
    -- visible text: move the visible text to the right
    tSlipBack = 0
    if pClippedChars < pFullText.char.count then
      repeat while tNextChar
        if pMember.charPosToLoc(tNextChar).locH < pWidth then
          exit repeat
        end if
        
        pClippedChars = pClippedChars + 1
        if tSlipBack then
          if pMember.selection[2] < pVisibleText.char.count then
            -- The text is scrolling because the user is adding text
            -- somewhere before the end.  Ensure that the insertion
            -- point follows the text.
            tEndChar = tEndChar - 1
          end if
        end if
        me.mShowText(pClippedChars + tEndChar)
        
        -- If the text is clipped more than once, then the insertion
        -- point should move back with it.
        tSlipBack = not pScrollTicks -- no slip when using arrow key        
        tNextChar = tNextChar - 1
      end repeat
    end if
  end if
end mMoveForward



on mDeleteChars(me, aDeleteKey) --------------------------------------
  -- SENT BY keyDown() if the key is BACKSPACE or Delete
  -- INPUT: <aDeleteKey> is TRUE if the last key pressed was Delete
  -- ACTION: Deletes the selected chunk or the character before the
  --         insertion point of no chunk is selected
  --------------------------------------------------------------------
  
  tStart     = pMember.selection[1]
  tStartChar = tStart + pClippedChars
  tEndChar   = pMember.selection[2] + pClippedChars
  
  if tStartChar = tEndChar then
    -- Insertion point is between two characters
    if aDeleteKey then
      -- "BACKSPACE" the following character if there is one
      tStartChar = tStartChar + 1
      if tStartChar > pFullText.char.count then
        exit
      else
        tStart  = tStart  + 1
      end if
    end if
    
    if tStartChar then
      delete pFullText.char[tStartChar]
      
      case tStart of
        0: pClippedChars = max(0, pClippedChars - 2)
          tStart = tStart + (pClippedChars <> 0)
        1: 
          if pClippedChars then
            pClippedChars = pClippedChars - 1
          else
            tStart = tStart - 1
          end if
          
        otherwise
          tStart = tStart - 1
      end case
    else
      exit
    end if
  else
    -- Delete the selected chunk
    delete pFullText.char[tStartChar + 1..tEndChar]
  end if
  
  me.mShowText(tStart + pClippedChars)
end mDeleteChars



on mTreatAlphaNumericKey(me) -----------------------------------------
  -- SENT BY keyDown() if the key is any other (i.e. alphaNumeric) key
  -- ACTION: Places the input text into the current selection or after
  --         the insertion point, and scrolls the visible text string
  --         to the left if necessary
  --------------------------------------------------------------------
  
  tStartChar = pMember.selection[1] + pClippedChars
  tEndChar   = pMember.selection[2] + pClippedChars
  
  if tStartChar = tEndChar then
    -- The insertion point is between two characters
    if tStartChar then
      put the key after char tStartChar of pFullText
      
    else
      put the key before char tStartChar + 1 of pFullText
      
    end if
  else
    -- A chunk of text is selected
    put the key into char tStartChar + 1 to tEndChar of pFullText
  end if
  
  me.mShowText(tStartChar)
  (pMember.selection)[2] = pMember.selection[1]
  me.mMoveForward()
end mTreatAlphaNumericKey



on mArrowScroll(me) --------------------------------------------------
  -- SENT BY exitFrame() if the user has been holding down the left or
  --         right arrow key for more than 20 ticks
  -- ACTION: Accelerates horizontal scrolling by calling mMove...()
  --         more often than the keyDown() handler receives input
  --------------------------------------------------------------------
  
  if the ticks > pScrollTicks then
    -- The user is holding an arrow key down: accelerate scrolling
    if keyPressed(123) then
      me.mMoveBack()      
    else if keyPressed(124) then
      me.mMoveForward()
    else
      pScrollTicks = 0
    end if
  end if
end mArrowScroll



on mCutOrPaste(me) ---------------------------------------------------
  -- SENT BY exitFrame() if the text of this member has changed since
  --         the last exitFrame, presumably because the user has cut
  --         or pasted text
  -- ACTION: Updates pFullText as appropriate
  --------------------------------------------------------------------
  
  pVisibleText = pMember.text
  if pClippedChars then
    tClippedChars = pFullText.char[1..pClippedChars]
    pFullText = tClippedChars&pVisibleText
  else -- All the text is visible
    pFullText = pVisibleText
  end if
end mCutOrPaste



on mShowText(me, anInsertPoint) --------------------------------------
  -- SENT BY mJumpToEnd(), mMoveBack(), mMoveForward(),
  --         mDeleteChars(), mTreatAlphaNumericKey(), mDragSelection()
  -- INPUT: <anInsertPoint> should be a positive integer indicating
  --         position of the current insertion point, starting at the
  --         beginning of the full text
  -- ACTION: Sets the text of pMember so that only characters to the
  --         left of the current start point are clipped, and shows
  --         the insertion point where it is expected
  --------------------------------------------------------------------
  
  pVisibleText = pFullText
  
  if pClippedChars then
    delete pVisibleText.char[1..pClippedChars]
    anInsertPoint = anInsertPoint - pClippedChars
  end if
  pMember.text = pVisibleText
  
  if integerP(anInsertPoint) then
    pMember.selection = [anInsertPoint, anInsertPoint]
  end if
end mShowText



on mCallback(me, aHandler) -------------------------------------------
  -- SENT BY keyDown() if input is RETURN, ENTER or TAB, or by keyUp()
  -- ACTION: Calls the designated handler in the designated callback
  --         object
  --------------------------------------------------------------------
  
  if not symbolP(aHandler) then
    exit
  end if
  
  case ilk(pCallback) of
    #script, #instance:
      tCallback = pCallback.handler(aHandler) -- fails if method is in
      --                                         object's ancestor
      
      -- tCallback = HasHandler(pCallback, aHandler) -- requires Get 
      --                                             Handlers script
      
      if tCallback then
        -- Send the event to the designated object...
        call(aHandler, pCallback, pFullText)
      end if
  end case
  
  if not tCallback then
    --  By default, call a handler on this sprite
    call(aHandler, pSprite.scriptInstanceList, pFullText)
  end if
end mCallback



on mAutoTab(me) ------------------------------------------------------
  -- SENT BY keyDown() if input TAB and the member is set to autotab
  -- ACTION: If the .autotab rroperty of the member is TRUE, no TAB
  --         input ever reaches this behavior.  As a result, the
  --         property is switched to FALSE on beginSprite, and this
  --         behavior's pAutoTab property is set to TRUE instead.
  --         This means that TAB input can be intercepted by this
  --         behavior and that user input can be validated before
  --         the focus moves to another sprite.  The down side is that
  --         moving the focus to the next editable sprite must be done
  --         manually... by this handler
  --------------------------------------------------------------------
  
  -- Look for the first editable sprite in a higher-numbered channel
  tFocusSprite = 0
  
  tStopChannel = the lastChannel
  repeat with i = spriteNum + 1 to tStopChannel
    tSprite = sprite(i)
    tMember = tSprite.member
    case tMember.type of
      #field, #text:
        if tMember.editable then
          tFocusSprite = i
          exit repeat
        else if tSprite.editable then
          tFocusSprite = i
          exit repeat
        end if
    end case
  end repeat
  
  if not tFocusSprite then
    tStopChannel = spriteNum - 1
    repeat with i = 1 to tStopChannel
      tSprite = sprite(i)
      tMember = tSprite.member
      case tMember.type of
        #field, #text:
          if tMember.editable then
            tFocusSprite = i
            exit repeat
          else if tSprite.editable then
            tFocusSprite = i
            exit repeat
          end if
      end case
    end repeat
  end if
  
  if tFocusSprite then
    the keyboardFocusSprite = tFocusSprite
  end if
end mAutoTab



-- BEHAVIOR DESCRIPTION AND PARAMETERS --

on isOKToAttach(me, aSpriteType, aSpriteNumber)
  if aSpriteType = #graphic then
    return sprite(aSpriteNumber).member.type = #text
  end if
  
  return FALSE
end isOKToAttach



on getPropertyDescriptionList(me)
  tPropertyList = [:]
  
  if the currentSpriteNum then
    tDefault = sprite(the currentSpriteNum).member.name
    if tDefault = "" then
      tDefault = #text
    else
      tDefault = symbol(tDefault)
    end if
  else
    tDefault = #text
  end if
  
  tPropertyList[ \
#ID] = [ \
 #comment: "One-word ID for this text member", \
 #format:  #symbol, \
 #default: tDefault \
]
  tPropertyList[ \
#validateHandler] = [ \
 #comment: "Handler to call when RETURN or ENTER is pressed", \
 #format:  #string, \
 #default: "validate" \
]
  tPropertyList[ \
#updateHandler] = [ \
 #comment: "Handler to call when any other key is pressed", \
 #format:  #string, \
 #default: "update" \
]
  
  return tPropertyList
end getPropertyDescriptionList



on getBehaviorTooltip(me)
  return \
"Use with text members."&RETURN&RETURN&\
"Makes a text member scroll horizontally"&RETURN&\
"if the user enters more text than can"&RETURN&\
"be displayed in the sprite."
end getBehaviorTooltip



on getBehaviorDescription(me)
  return \
"HORIZONTAL SCROLL (TEXT)"&RETURN&RETURN&\
"© 2OOO - 2003, OpenSpark Interactive Ltd <james.newton@openspark.come>"&\
RETURN&RETURN&\
"Use with text members."&RETURN&RETURN&\
"Makes an editable text member scroll horizontally if the user enters more text than can be displayed in the sprite."&RETURN&RETURN&\
"PARAMETERS"&RETURN&\
" * ID symbol for this behavior"&RETURN&\
" * [optional] Handler to call when RETURN/ENTER is pressed"&\
RETURN&\
" * [optional] Handler to call when any other key is pressed"&\
RETURN&RETURN&\
"By default, the optional calls are made to other behaviors on the same sprite.  To set a callback object, use the SetCallback() method.."&RETURN&RETURN&\
"PUBLIC METHODS"&RETURN&\
" => SetText()"&RETURN&\
" => GetText()"&RETURN&\
" => SetCallback()"&RETURN&\
" => Scroll()"
end getBehaviorDescription