🚀 go-pugleaf

The original poster has things backwards.  Gosling invented the use of
permanent buffers for transient information.  It sounds as if Unipress
finally excised it.  Stallman's original EMACS for ITS and TOPS-20 did
not have it, neither did Multics Emacs nor Lisp Machine Zwei.  In the
Unix world, CCA EMACS doesn't have it either.  So, it seems as if
Unipress opted for compatibility.

Zwei, however, has a feature that solves the problem you have.  There is
a command (Execute Command To Buffer, I think it's called) which
redirects transient output to a buffer.
-- 
    Barry Margolin
    ARPA: barmar@MIT-Multics
    UUCP: ..!genrad!mit-eddie!barmar

>							    I, for one, got
> really tired of that stupid help buffer sucking up half the screen all the
> time.  Note, however, that the help buffer in Unipress 2.x is called "Help",
> and you can use it like any other buffer.  So if you want to look at the 
> help again, use your favorite "make buffer visible" function on it.
> -- 
>  Matt Landau      	 		BBN Laboratories, Inc.

I also am bugged by the way that pop-up windows operate in Gosmacs,
and went so far (when i had no alternatives) to run with
'pop-up-windows' 0, and use a refinement of split-window which
turns out to be much like the suite of functions bound to ^X-4 in
Gnu Emacs.  For instance, with pop-ups disabled (preventing them
from frequently disrupting my precious window-layout) the help window
*doesn't* show up when you do, say, an apropos (or completion
happens), so i could do a '^X-2-h', which produces the help window
in the second half of the current window (instead of superceding
one of my other windows).

Gnu Emacs' strategy of preserving a history of previously
superceded windows for easy recovery is the best answer i've
encountered, so that i don't hesitate to pop-up windows when using
it, knowing that i can recover displaced ones very easily.  One
further refinement i've developed is a 'preserve-excurse' function,
bound to ^X-' (with marginally mnemonic connotations as "quote-
environment"), that just does a recursive-edit within a
save-excursion so that i can go off, do arbitrary and incidental
things (sounds like fun, hmm?), and then pop back to the layout i
was working within.

In case anyone is interested, here are the functions i'm talking
about; first the mlisp refinement on split-current-window, called
'split-and', then the mlisp version of 'preserve-excurse', then the
elisp version of 'preserve-excurse'.  (In looking at split-and for
the first time in a while it strikes me i should have made the ^X-2
a prefix for a suite of functions, like Gnu-emacs ^X-4, but this
is good enough, i guess.)

Cheers!
Ken Manheimer.

(defun    
    ; this helper necessary for 'split-and'; it's true when the named buffer
    ; already exists.  This is necessary because use-old-buffer always will
    ; do completion, so plain (use-old-buffer "mai") can succeed with, eg, the 
    ; buffer "main", even when/though a buffer called "mai" doesn't exist.
    (buffer-exists q-buff
	(setq q-buff (arg 1 "Buffer: "))
	(save-window-excursion
	    (& (! (error-occurred (use-old-buffer q-buff)))
	       (= q-buff (current-buffer-name))))
	)
    (split-and suffix tobuf was-pop-ups
; This function is intended to provide an alternative to pop-up-windows.  It
; provides a refinement of the split-current-window functionality, and I
; suggest binding it to ^X2.
; I can't stand the way windows are mis-juggled with pop-up-windows engaged
; (in particular, the way help windows are left around and visit-files
; occlude an incidental buffer if more than two are on the screen), so I use 
; this function to put those behaviors at my discretion.  I find this scheme 
; *much* more convenient.
	(message
 "split-and: {`o'ld-`b'uffer, `s'ame; & `t'iny, `v'isit, `h'elp buffer, `!'}")
	(setq suffix (get-tty-character))
	(if (= suffix 111) 	; o
	    ; pop to an established buffer in the other half of current window:
	    (progn (setq tobuf (get-tty-buffer "(extant) Buffer: "))
		   (split-current-window)
		   (switch-to-buffer tobuf))
	    (= suffix 98)	; b
	    ; pop to an arbitrary buffer in the other half of current window:
	    (progn (setq tobuf (arg 1 "Buffer: "))
		   (split-current-window)
		   (switch-to-buffer tobuf))
	    (= suffix 115)	; s
	    ; split the current buffer in current window:
	    (split-current-window)
	    (= suffix 116)	; t
	    ; split the current buffer, tiny/large, in current window:
	    (progn  (split-current-window)
		    (previous-window)
		    (while (! (error-occurred (shrink-window))))
		    (enlarge-window))
	    (= suffix 118)	; v
	    ; Visit a file in other half of current window:
	    (progn (setq tobuf (arg 1 "File: "))
		   (split-current-window)
		   (if (buffer-exists tobuf)
		       (switch-to-buffer tobuf)
		       (visit-file tobuf)))
	    (= suffix 104)	; h
	    ; Expose the help window in other half of current window:
	    (progn (split-current-window)
		   (switch-to-buffer "Help"))
	    (= suffix 33)	; !
	    ; Execute cmd and expose results in other half of current window:
	    ; (Sorta silly finagling to prompt for command)
	    (progn (setq was-pop-ups pop-up-windows)
		   (setq pop-up-windows 1)
		   (pop-to-buffer "Command execution")
		   (setq needs-checkpointing 0)
		   (previous-window)
		   (setq pop-up-windows was-pop-ups)
		   (push-back-string "\^X!"))
	    (= suffix 112)	; p
	    ; Pop to shell in other half of current window
	    (progn (split-current-window)
		   (shell))
	    ; No such suffix:
	    (error-message "Aborted.")
	)
    ; Simple but useful:
    (preserve-excurse (save-window-excursion
			  (message "`^C' will resume pending window state")
			  (recursive-edit)))
)

Elisp code:
(defun preserve-excurse ()
  "Embark on a recursive edit within a save-window-excursion"
  (interactive)
  (save-window-excursion (recursive-edit)))

I haven't really used Unipress emacs enough to have a strong
feeling about transient windows, but they SEEm like a good
idea to me, as I'm sure they do to Unipress.

I HATE having the help system scrozzle the windows I have
on screen.  I often expend silly amounts of effort on having
the windows int the relationship to each other than I want
them to have (size and position both count).  Most emacses
seem rather cavalier about this -- anything that emacs wants
to get your attention about causes it to use one of your
windows, generally with no thought to getting back to
exactly the screen layout you had.  Unipress's transient
windows are at least trying to go that way -- they only
appear temporarily and don't screw up what's underneath.
I consider that thoughtful. [I make no representations
about whether they work or not...]

I have always been of the "messy-desk" persuasion -- my desk
has many piles, but I know where most everything in them is.
If the janitors re-arranged my piles every night I would be
mightily displeased.  My video desktop is just as important
to me; I don't like emacs screwing with my windows.

-- 
scott preece
gould/csd - urbana
uucp:	ihnp4!uiucdcs!ccvaxa!preece
arpa:	preece@gswd-vms

The original poster has things backwards.  Gosling invented the use of
permanent buffers for transient information.  It sounds as if Unipress
finally excised it.  Stallman's original EMACS for ITS and TOPS-20 did
not have it, neither did Multics Emacs nor Lisp Machine Zwei.  In the
Unix world, CCA EMACS doesn't have it either.  So, it seems as if
Unipress opted for compatibility.

Zwei, however, has a feature that solves the problem you have.  There is
a command (Execute Command To Buffer, I think it's called) which
redirects transient output to a buffer.
-- 
    Barry Margolin
    ARPA: barmar@MIT-Multics
    UUCP: ..!genrad!mit-eddie!barmar

It's true that Unipress 2.xx moved help information into a transient window,
making it act like almost all other Emacses in existence.  I, for one, got
really tired of that stupid help buffer sucking up half the screen all the
time.  Note, however, that the help buffer in Unipress 2.x is called "Help",
and you can use it like any other buffer.  So if you want to look at the 
help again, use your favorite "make buffer visible" function on it.
-- 
 Matt Landau      	 		BBN Laboratories, Inc.
    mlandau@diamond.bbn.com		10 Moulton Street, Cambridge MA 02238
 ...seismo!diamond.bbn.com!mlandau      (617) 497-2429

 "Go away, or Cerebus is going to strip-mine your face."

Why isn't there a variable called "send-typeout-to-buffer".  When it's on
it creates a window and sends the output to a buffer (and it can still do
the stuff about remembering the previous context, and all), and when the
variable is off it just sends output to the screen the way the original
EMACS did.  Seems to me that most of the time THAT is the desired
behavior (sending just to the screen, until the user hits Space or
something).  Nobody really ever wants a list of the buffers to take up a
window.  If you want a dump of the keybindings so that you can print them
out, you turn the variable on and presto, you have a buffer full of
keybindings.  And the other 99% of the time you leave the variable off,
thus increasing the life expectancy of your keyboard as you no longer
feel the need to break something when your carefully laid out windows are
no longer what they were spozed to be.

That's my opinion, anyway ...