Re: xref and displaying locations in appropriate window or frame

[martin rudalics <rudalics@gmx.at>]

 > Could we decouple temp-buffer-resize-mode from the "write to
 > standard-output" mode of operation? Can I just call
 > resize-temp-buffer-window once after the xref buffer is displayed?

Hopefully.  Just add

(when temp-buffer-resize-mode (resize-temp-buffer-window window))

at some suitable place.

 > If won't make any difference if *xref* is tall enough (like when we
 > display Grep results in it).

If the *xref* buffer usually fills its window in both dimensions there's
no need to do anything.

 > And anyway, *xref* window getting split is not a problem, as far as
 > I'm concerned. Keeping *xref* buffer visible is the goal.

So the main problem is that showing the target buffer uses the *xref*
window and you want to avoid that.  In the following let's assume that
"O" is the originally selected window, "X" is the *xref* window, "T" is
the target window that shows the defined object and "N" is some other
non-selected window.

Suppose O is the sole window on its frame.  In a "vertically oriented"
frame you would go from

  -----
|  O  |
|     |
|     |
|     |
|     |
  -----

via

  -----
|  O  |
|     |
|     |
|-----|
|  X  |
  -----

to

  -----
|  O  |
|-----|
|  T  |
|-----|
|  X  |
  -----

and subsequently T should be reused for the remaining targets.  This
will work when the user has customized ‘split-height-threshold’
appropriately - otherwise O will be used for showing T.

In a "horizontally" orientd frame you would go from

  ------------
|     O      |
|            |
|            |
|            |
  ------------

via

  ------------
|     O      |
|            |
|------------|
|     X      |
  ------------

to

  ------------
|  O  |   T  |
|     |      |
|------------|
|     X      |
  ------------

This will usually work with the default ‘split-width-threshold’,
otherwise O gets used for showing T.

Now suppose that both O and N exist.  In this case you would, in the
vertically oriented case, go from

  -----
|  O  |
|     |
|-----|
|  N  |
|     |
  -----

via

  -----
|  O  |
|-----|
|  N  |
|-----|
|  X  |
  -----

to

  -----
|  O  |
|-----|
|  T  |
|-----|
|  X  |
  -----

Horizontally from

  ------------
|  O  |   N  |
|     |      |
|     |      |
|     |      |
  ------------

via

  ------------
|  O  |   N  |
|     |      |
|------------|
|     X      |
  ------------

to

  ------------
|  O  |   T  |
|     |      |
|------------|
|     X      |
  ------------

One tricky case is to set up X when O and N exist already.  If you reuse
N for showing X you will find it difficult to subsequently show T
without reusing X.  That's why I would try to always create a new,
hopefully smaller, window for X.

The second tricky case is to make sure that for a new target always the
previous T window gets used via ‘display-buffer-use-some-window’.  To
make this happen you will either have to mark the O and X windows as
dedicated or make sure the T window is the LRU window when displaying
the next target.  (I silently assumed that N will be automatically used
for displaying T initially because O was selected and X would have to be
selected by you when it's created.)

Hopefully, this covers the most common cases we will see in the wild.

 > Maybe the actual solution is indeed to use a different display
 > mechanism for xref-find-definitions with several options. Then it
 > could use an actual temporary electric window at the bottom of the
 > current window that gets deleted as soon as we're done.

At least that's how I would customize the display of *xref*.  Whatever
you choose for the default might be entirely different based on the
needs of a majority of users.

 > We don't use temp-buffer-resize-mode in Compilation or Grep buffers,
 > right? Even though Grep likewise might return only a few matches.

IIUC these buffers get filled asynchronously.  How should
‘temp-buffer-resize-mode’ work with such buffers?  Do you produce *xref*
asynchronously?

 > Were the Help windows actually _temporary_ sometime?

Depends on the semantics of "temporary".

 > If I have a frame with two full-height windows side-by-side, and I'm
 > calling project-find-regexp which returns a lot of results, I'd want
 > it to be displayed in the "other" window, rather than necessarily
 > split the current one.

I thought the other window is where you eventually wanted to show the
target buffer.

 > Or, if I have just one window in a maximized frame, and do the search,
 > and I've customized the split thresholds appropriately, I want
 > split-window-right to be called, and see *xref* to the right.

Once more: Where would you show the target buffer then?  I think what
you say makes perfect sense in a setup where the *xref* buffer is
replaced by the target buffer.  But we're talking about the scenario
where the *xref* buffer should remain visible after displaying the
target buffer.

 > Instead of having the "split below" performed, and seeing *xref* use
 > full width, and only half the height of the current frame.

Hopefully less than half the height when you fit the window to its
buffer.

 >> Yes.  But the one-window-per-frame user might get a new frame then.
 >> She's not your target (because of the assumption that the original
 >> window and the *xref* window are already there when you want to display
 >> the other buffer).
 >
 > Wouldn't she want a new frame anyway?

I thought about people who work with one and only one window.  We
shouldn't create a no-way-out situation for them.

 >> But even softly (that's all you need here) dedicated
 >> windows sometimes behave erratically.
 >
 > Can we fix that? So far using dedicated buffers sounds like the most
 > appropriate solution.

One problem with dedicated windows is that if an application and the
user both start dedicating the same window to its buffer there might be
conflicts.  I doubt that such conflicts can be "fixed" easily.

 >> If the other window is the *xref* window and the *xref* window was
 >> "used" later.  You might have to "touch" it from time to time ;-)
 >
 > That doesn't sound like something a display-buffer consumer should
 > do. Should it?

It's a hack, indeed.

 >> A threshold that is more than twice as large as the default value?
 >
 > (frame-height) evaluates to 58 here.

Less than 80, still.

 > Maybe it does make sense, maybe it doesn't. I'm fine with it, though,
 > because I don't mind doing doing my vertical splits manually.

‘display-buffer’ can't split it.  The very first example above will work
only if the user has customized ‘split-height-threshold’.  Otherwise, T
will be shown in the O window.

 > But *Grep* works fine in that situation, doesn't it?

I never use it.  My grep hits appear in a side window where I just list
the files where at least one hit occurred.  Selecting a file shows all
hits in that file.  Selecting a particular hit shows that hit in the
window on the right.

 > quit-window is different, and it works as expected anyway, I'd say: if
 > the window configuration hasn't changed too much, it will undo the
 > action that displayed it. If the window configuration did change too
 > much, it will just bury the current buffer. Everybody happy.

Did you try it after manually switching to such a buffer?

 >> Maybe
 >> some command to "bring back" the *xref* buffer would be more useful than
 >> simply switching to it.
 >
 > I can easily imagine having several *xref* buffers at the same time
 > (we'll just have to add more coherent naming).

Then I'd say: Maybe some prefixed command to "bring back" an existing
*xref* buffer would be more useful than simply switching to it.

martin