home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / jed098-4.zip / JED / DOC / YANKPOP.TXT < prev   
Text File  |  1997-02-01  |  5KB  |  79 lines

  1. This document discusses Jed's implementation of yank-pop.
  2.  
  3. Briefly, yank-pop allows one to use multiple paste buffers in a convenient
  4. way.  Jed's implementation provides 16 such pastebuffers.  The file,
  5. jed/lib/yankpop.sl provides the interface and in particular the following
  6. functions:
  7.  
  8.      yp_yank                        Ctrl-Y
  9.      yp_yank_pop                    ESC Y
  10.      yp_bkill_word                  ESC DEL
  11.      yp_kill_word                   ESC d
  12.      yp_kill_line                   Ctrl-K
  13.      yp_kill_region                 Ctrl-W
  14.      yp_copy_region_as_kill         ESC W
  15.      
  16. which are meant to be bound to keys.  The second column shows the default
  17. emacs bindings.
  18.  
  19. It should be obvious from the names of these functions that the can be
  20. grouped into two categories: those that ``kill'' and those that ``yank''.
  21. Associated with these two groups are two active pastebuffers--- one where
  22. text is ``killed'' into and one where previously killed text is ``yanked''
  23. from.  Most of the time these two pastebuffers are equivalent.  That is, a
  24. kill followed by a subsequent yank will result in the yank using the
  25. pastebuffer that was used for the kill.  In fact, whenever something is
  26. killed, the yank pastebuffer automatically is set to the one used for the
  27. kill.  Only the `yp_yank_pop' function can change the active yank
  28. pastebuffer to something different from the active kill one.
  29.  
  30. The kill functions put what they have killed into the currently active
  31. pastebuffer.  If the last key sequence entered from the keyboard did not
  32. invoke one of the kill functions, the currently active pastebuffer becomes
  33. the next one in the ring of pastebuffers and the killed text is placed in
  34. it.  Otherwise the last key sequence invoked one of the kill functions and
  35. the text from the kill will be appended to the text from the last kill. It
  36. is important to note that the act of killing something sets the pastebuffer
  37. for a subsequent yank to the pastebuffer used for the kill.
  38.  
  39.    {Terminology: By a ring of pastebuffers, it is meant that when the all
  40.     the pastebuffers become used, the contents of the oldest one will be
  41.     discarded and that one will become the active one.}
  42.  
  43. This sounds more complex than it really is.  Consider the act of moving
  44. somewhere and pressing the sequence `ESC d' three times in a row to execute
  45. the `yp_kill_word' function.  The first `ESC d' sequence results in deleting
  46. a word and placing it in a new currently active pastebuffer since the
  47. previous key sequence was not a kill sequence.  The other two `ESC d'
  48. sequences follow a kill sequence, namely, the first `ESC d'.  This means
  49. that the next two words will be appended to the first one that was killed.
  50. So, if the `yp_yank' function is invoked via Ctrl-Y, the three killed words
  51. will be pasted back as if they had been killed together.
  52.  
  53. There are two yank functions: `yp_yank' and `yp_yank_pop'.  The `yp_yank'
  54. function simply pastes text into the buffer from the the current pastebuffer
  55. for yanking.  One the other hand, the `yp_yank_pop' function must immediately
  56. follow the `yp_yank' function or another `yp_yank_pop'.  It will delete (not
  57. kill) the previously pasted text with the text in the pastebuffer that
  58. comes immediately before the current yank pastebuffer in the ring of
  59. pastebuffers.  The current yank pastebuffer will then become the one
  60. selected by `yp_yank_pop'.  Simply stated, the `yp_yank_pop' allows the user
  61. to cycle through the set of pastebuffers.
  62.  
  63. Again, this is best illustrated with an example.  We will continue with the
  64. previous one.  After killing the three words as previously described,
  65. consider moving to the top of the buffer and deleting the top line by
  66. pressing Ctrl-K to invoke the `yp_kill_line' function.  In doing so, we are
  67. left with two used pastebuffers: the most recent contains the line killed at
  68. the top of the buffer and the other contains the three words that were
  69. killed earlier.  Now move somewhere else and press Ctrl-Y to invoke the
  70. function `yp_yank'.  This results in the pasting of the line killed at the
  71. top of the buffer at the current position.  Now, press `ESC y' to invoke the
  72. `yp_yank_pop' function.  This replaces the the text that was just pasted
  73. with the three words that were kill earlier.   Continue to press the `ESC y'
  74. key sequence.  This will result in cycling between the two pastebuffers and
  75. replacing the text that was most recently pasted with the text from the
  76. other pastebuffer.   The last pastebuffer for the paste will become the
  77. active one for future yanks until the next kill.
  78.  
  79.