frames dedicated to buffers, or, always see specific buffers in a specific frame

frames dedicated to buffers, or, always see specific buffers in a specific frame

[João Távora]

So I needed to scratch a code-browsing itch and came up with this monster:

(defvar joaot/browse-frame)
(setq joaot/browse-frame (new-frame))
(setq display-buffer-alist
      `((joaot/browse-buffer-p . (joaot/browse-buffer-in-special-frame . nil))))

(defun joaot/browse-buffer-p (buffer action)
  (declare (ignore action))
  (let ((buffer (and buffer
                     (get-buffer buffer))))
    (and (frame-live-p joaot/browse-frame)
         buffer
         (buffer-file-name buffer)
         (string-match "someproject" (buffer-file-name buffer)))))

(defun joaot/browse-buffer-in-special-frame (buffer alist)
  (let ((window (frame-selected-window joaot/browse-frame)))
    (window--display-buffer buffer window 'reuse alist)))

(defadvice switch-to-buffer (around joaot/browse-buffer-maybe activate)
  (if (joaot/browse-buffer-p buffer-or-name nil)
      (display-buffer buffer-or-name)
    ad-do-it))

Do you see what it is doing? Whenever I switch to a buffer or file
belonging to "someproject", which I only want to read, it makes sure
the buffer is displayed in a special "browse-frame" created beforehand
and that lives in my secondary monitor.

This is not quite "dedicated windows". It's sort of frames dedicated
to buffers.

Does anyone know of a less hackish way to do this? The defadvice is
particularly nasty... Do you see this breaking anything important that
I'm not seeing??

Thanks in advance,
J

PS: yes I refuse to open a secondary emacs instance on principle :-)

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[Steven Degutis]

[-- Attachment #1: Type: text/plain, Size: 1832 bytes --]

Depending on why you want this behavior, you might find this project
useful: https://github.com/sdegutis/project-buffers.el

-Steven


On Wed, Apr 10, 2013 at 3:52 PM, João Távora <joaotavora@gmail.com> wrote:

> So I needed to scratch a code-browsing itch and came up with this monster:
>
> (defvar joaot/browse-frame)
> (setq joaot/browse-frame (new-frame))
> (setq display-buffer-alist
>       `((joaot/browse-buffer-p . (joaot/browse-buffer-in-special-frame .
> nil))))
>
> (defun joaot/browse-buffer-p (buffer action)
>   (declare (ignore action))
>   (let ((buffer (and buffer
>                      (get-buffer buffer))))
>     (and (frame-live-p joaot/browse-frame)
>          buffer
>          (buffer-file-name buffer)
>          (string-match "someproject" (buffer-file-name buffer)))))
>
> (defun joaot/browse-buffer-in-special-frame (buffer alist)
>   (let ((window (frame-selected-window joaot/browse-frame)))
>     (window--display-buffer buffer window 'reuse alist)))
>
> (defadvice switch-to-buffer (around joaot/browse-buffer-maybe activate)
>   (if (joaot/browse-buffer-p buffer-or-name nil)
>       (display-buffer buffer-or-name)
>     ad-do-it))
>
> Do you see what it is doing? Whenever I switch to a buffer or file
> belonging to "someproject", which I only want to read, it makes sure
> the buffer is displayed in a special "browse-frame" created beforehand
> and that lives in my secondary monitor.
>
> This is not quite "dedicated windows". It's sort of frames dedicated
> to buffers.
>
> Does anyone know of a less hackish way to do this? The defadvice is
> particularly nasty... Do you see this breaking anything important that
> I'm not seeing??
>
> Thanks in advance,
> J
>
> PS: yes I refuse to open a secondary emacs instance on principle :-)
>
>

[-- Attachment #2: Type: text/html, Size: 2351 bytes --]

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[João Távora]

On Wed, Apr 10, 2013 at 10:30 PM, Steven Degutis <sbdegutis@gmail.com> wrote:
> Depending on why you want this behavior, you might find this project useful:
> https://github.com/sdegutis/project-buffers.el

Thanks, but this quite unrelated to what I'm asking for.

I want Emacs to always display certain buffers in a different Emacs
frame. The (string-match "someproject" ...) dummy example I provided
is just one of many possible criteria for selecting buffers, it could
be something completely different, like read-only buffers, for
example.


>
> On Wed, Apr 10, 2013 at 3:52 PM, João Távora <joaotavora@gmail.com> wrote:
>>
>> So I needed to scratch a code-browsing itch and came up with this monster:
>>
>> (defvar joaot/browse-frame)
>> (setq joaot/browse-frame (new-frame))
>> (setq display-buffer-alist
>>       `((joaot/browse-buffer-p . (joaot/browse-buffer-in-special-frame .
>> nil))))
>>
>> (defun joaot/browse-buffer-p (buffer action)
>>   (declare (ignore action))
>>   (let ((buffer (and buffer
>>                      (get-buffer buffer))))
>>     (and (frame-live-p joaot/browse-frame)
>>          buffer
>>          (buffer-file-name buffer)
>>          (string-match "someproject" (buffer-file-name buffer)))))
>>
>> (defun joaot/browse-buffer-in-special-frame (buffer alist)
>>   (let ((window (frame-selected-window joaot/browse-frame)))
>>     (window--display-buffer buffer window 'reuse alist)))
>>
>> (defadvice switch-to-buffer (around joaot/browse-buffer-maybe activate)
>>   (if (joaot/browse-buffer-p buffer-or-name nil)
>>       (display-buffer buffer-or-name)
>>     ad-do-it))
>>
>> Do you see what it is doing? Whenever I switch to a buffer or file
>> belonging to "someproject", which I only want to read, it makes sure
>> the buffer is displayed in a special "browse-frame" created beforehand
>> and that lives in my secondary monitor.
>>
>> This is not quite "dedicated windows". It's sort of frames dedicated
>> to buffers.
>>
>> Does anyone know of a less hackish way to do this? The defadvice is
>> particularly nasty... Do you see this breaking anything important that
>> I'm not seeing??
>>
>> Thanks in advance,
>> J
>>
>> PS: yes I refuse to open a secondary emacs instance on principle :-)
>>
>



-- 
João Távora

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[Stefan Monnier]

> Does anyone know of a less hackish way to do this? The defadvice is
> particularly nasty... Do you see this breaking anything important that
> I'm not seeing??

Have you tried to an an appropriate entry in `display-buffer-alist'?

Admittedly, C-x b doesn't make much use of it, but that's just because
this binding is supposed to only affect the selected window.
So you would need to additionally do

   (defun my-switch-to-buffer (buf)
     (interactive (list (read-buffer-to-switch "Switch to buffer: ")))
     (if (joaot/browse-buffer-p buffer-or-name nil)
         (display-buffer buf)
       (switch-to-buffer buf)))

   (global-set-key [remap switch-to-buffer] 'my-witch-to-buffer)


        Stefan

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[Stefan Monnier]

OK, I guess I should refrain from posting messages in the morning.
Sorry 'bout that.


        Stefan

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[martin rudalics]

 > (defadvice switch-to-buffer (around joaot/browse-buffer-maybe activate)
 >   (if (joaot/browse-buffer-p buffer-or-name nil)
 >       (display-buffer buffer-or-name)
 >     ad-do-it))
 >
 > Does anyone know of a less hackish way to do this? The defadvice is
 > particularly nasty... Do you see this breaking anything important that
 > I'm not seeing??

`switch-to-buffer' uses `pop-to-buffer' to make sure the window
displaying the buffer is selected.  You use `display-buffer' which
doesn't necessarily make the window selected - IIUC you rely on the
window manager to select the window.

Other from that I don't see anything hackish with your approach if the
idea is to make `switch-to-buffer' do what you want when it's called
from other code (which ideally should not happen).  In this case you
might also want to advice `switch-to-buffer-other-window' accordingly.

Interactively, you obviously should define your own function and bind it
to C-x b.

martin

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[João Távora]

On Fri, Apr 12, 2013 at 10:28 AM, martin rudalics <rudalics@gmx.at> wrote:

> `switch-to-buffer' uses `pop-to-buffer' to make sure the window
> displaying the buffer is selected.  You use `display-buffer' which
> doesn't necessarily make the window selected - IIUC you rely on the
> window manager to select the window.

yes, you understand correctly.

> Other from that I don't see anything hackish with your approach if the
> idea is to make `switch-to-buffer' do what you want when it's called
> from other code (which ideally should not happen).  In this case you
> might also want to advice `switch-to-buffer-other-window' accordingly.

I do want that precisely. `display-buffer-alist' apparently allows me (a LOT of)
control how `display-buffer' but not when it is called. The advice is because I
want ibuffer and ido to work with this as well.

The hackish part is was also that I call the predicate twice, but I can simplify
that...

(defadvice switch-to-buffer (around joaot/browse-buffer-maybe activate)
  (if (joaot/browse-buffer-p buffer-or-name nil)
      (let ((display-buffer-alist `(("" .
(joaot/browse-buffer-in-special-frame . nil)))))
        (display-buffer buffer-or-name))
    ad-do-it))

However, I still have to have to set `display-buffer-alist' globally for those
functions who call `display-buffer' directly, like `describe-function' does for
"*Help*" buffers, for example.

(setq display-buffer-alist
      `((joaot/browse-buffer-p . (joaot/browse-buffer-in-special-frame . nil))))

I'm quite happy with this functionally, and find this feature is quite useful to
keep focus on one frame, but be able to look at a secondary frame on a second
monitor for reference and only switching to it occasionally.

Ideally I would want anywthing with the meaning "switch to some buffer" (be it
`pop-to-buffer', `switch-to-buffer-other-window`, `display-buffer`, etc...) to
be be hookable at some common point, much as is already done with `display-
buffer'.

Or alternatively, and maybe simpler, if `display-buffer' is so powerful, why
can't it be used by `switch-to-buffer' and friends? I know `diplay-buffer''s
semantics are "display without selecting", but can't those be relaxed and the
"without selecting" part be just the default?

Another, distinct, small problem persists, and I suspect it has to do with not
understanding what the various alists are in the documentation of
`display-buffer'
and `display-buffer-alist'...

Specifically, how can I prevent `display-buffer' from stopping at one of
the actions that I specify in `display-buffer-alist'? For example,
`describe-function' shows me the buffer on the secondary "browse" frame" but
still keeps the current pop-to-frame behaviour. I'm going to have a look at
`display-buffer-overriding-alist', maybe that will do it.

Thanks
--
João Távora

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[João Távora]

just a small update, this is the code I'm currently working with on
emacs 24.1.1 on windows:

(setq display-buffer-alist
      `((joaot/browse-buffer-p . (joaot/browse-buffer-in-special-frame . nil))))

(defvar joaot/browse-frame)
(setq joaot/browse-frame (new-frame))
(defun joaot/browse-buffer-p (buffer action)
  (declare (ignore action))
  (let ((buffer (and buffer
                     (get-buffer buffer))))
    (and (frame-live-p joaot/browse-frame)
         buffer
         (string-match "^\\*Help\\*$" (buffer-name buffer)) ;; or some
other predicate
         )))

(defun joaot/browse-buffer-in-special-frame (buffer alist)
  (set-window-buffer (frame-selected-window joaot/browse-frame) buffer))

(defadvice switch-to-buffer (around joaot/browse-buffer-maybe activate)
  (if (joaot/browse-buffer-p buffer-or-name nil)
      (let ((display-buffer-alist `(("" .
(joaot/browse-buffer-in-special-frame . nil)))))
        (display-buffer buffer-or-name))
    ad-do-it))

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[martin rudalics]

 >> `switch-to-buffer' uses `pop-to-buffer' to make sure the window
 >> displaying the buffer is selected.  You use `display-buffer' which
 >> doesn't necessarily make the window selected - IIUC you rely on the
 >> window manager to select the window.
 >
 > yes, you understand correctly.

So for making this general purpose you should use `pop-to-buffer'
instead of `display-buffer'.

 >> Other from that I don't see anything hackish with your approach if the
 >> idea is to make `switch-to-buffer' do what you want when it's called
 >> from other code (which ideally should not happen).  In this case you
 >> might also want to advice `switch-to-buffer-other-window' accordingly.
 >
 > I do want that precisely. `display-buffer-alist' apparently allows me (a LOT of)
 > control how `display-buffer' but not

... only, I presume ...

 > when it is called. The advice is because I
 > want ibuffer and ido to work with this as well.

These should refrain from using `switch-to-buffer(-...)' and use
`pop-to-buffer' with the `display-buffer-same-window' directive instead.
Wherever this bothers you, file a bug report so it gets fixed.

 > The hackish part is was also that I call the predicate twice, but I can simplify
 > that...
 >
 > (defadvice switch-to-buffer (around joaot/browse-buffer-maybe activate)
 >   (if (joaot/browse-buffer-p buffer-or-name nil)
 >       (let ((display-buffer-alist `(("" .
 > (joaot/browse-buffer-in-special-frame . nil)))))
 >         (display-buffer buffer-or-name))
 >     ad-do-it))
 >
 > However, I still have to have to set `display-buffer-alist' globally for those
 > functions who call `display-buffer' directly, like `describe-function' does for
 > "*Help*" buffers, for example.
 >
 > (setq display-buffer-alist
 >       `((joaot/browse-buffer-p . (joaot/browse-buffer-in-special-frame . nil))))
 >
 > I'm quite happy with this functionally, and find this feature is quite useful to
 > keep focus on one frame, but be able to look at a secondary frame on a second
 > monitor for reference and only switching to it occasionally.

I just don't understand whether you deliberately name buffers specially
to exploit this feature.  Couldn't you use some more human predicate for
this purpose?

 > Ideally I would want anywthing with the meaning "switch to some buffer" (be it
 > `pop-to-buffer', `switch-to-buffer-other-window`, `display-buffer`, etc...) to
 > be be hookable at some common point, much as is already done with `display-
 > buffer'.

This was the intention of `display-buffer-alist' and IIRC at some time I
had already removed all calls of `switch-to-buffer' from the Emacs code
base.  Somehow this got reverted later.

 > Or alternatively, and maybe simpler, if `display-buffer' is so powerful, why
 > can't it be used by `switch-to-buffer' and friends? I know `diplay-buffer''s
 > semantics are "display without selecting", but can't those be relaxed and the
 > "without selecting" part be just the default?

`switch-to-buffer' is the traditional means to interactively show a
buffer in the selected window.  It shouldn't be used in Lisp code.

 > Another, distinct, small problem persists, and I suspect it has to do with not
 > understanding what the various alists are in the documentation of
 > `display-buffer'
 > and `display-buffer-alist'...
 >
 > Specifically, how can I prevent `display-buffer' from stopping at one of
 > the actions that I specify in `display-buffer-alist'? For example,
 > `describe-function' shows me the buffer on the secondary "browse" frame" but
 > still keeps the current pop-to-frame behaviour. I'm going to have a look at
 > `display-buffer-overriding-alist', maybe that will do it.

This doesn't sound right.  When `display-buffer' has found a window it
should stop right there.  Anything else would constitute a bug.  If you
can reproduce it, step through it with the debugger to find out what
goes wrong.

martin

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[Stefan Monnier]

>> Other from that I don't see anything hackish with your approach if the
>> idea is to make `switch-to-buffer' do what you want when it's called
>> from other code (which ideally should not happen).  In this case you
>> might also want to advice `switch-to-buffer-other-window' accordingly.

I don't see why that would be necessary: switch-to-buffer-other-window
calls display-buffer (well, pop-to-buffer) so it should honor
display-buffer-alist.

> Ideally I would want anywthing with the meaning "switch to some
> buffer" (be it `pop-to-buffer', `switch-to-buffer-other-window`,
> `display-buffer`, etc...) to be be hookable at some common point, much
> as is already done with `display- buffer'.

Other than switch-to-buffer they all go through display-buffer and obey
the display-buffer-* hooks.

switch-to-buffer is special because there are various circumstances
where it's more important for it to only affect the selected-window then
it is to display the specified buffer.

> Specifically, how can I prevent `display-buffer' from stopping at one of
> the actions that I specify in `display-buffer-alist'?

Don't return nil?

More specifically, your joaot/browse-buffer-in-special-frame should
return the window it used to display the buffer.


        Stefan

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[martin rudalics]

 > I don't see why that would be necessary: switch-to-buffer-other-window
 > calls display-buffer (well, pop-to-buffer) so it should honor
 > display-buffer-alist.

Correct, obviously.

 > Other than switch-to-buffer they all go through display-buffer and obey
 > the display-buffer-* hooks.
 >
 > switch-to-buffer is special because there are various circumstances
 > where it's more important for it to only affect the selected-window then
 > it is to display the specified buffer.

Ideally, `switch-to-buffer' does not get called from Lisp code.
Unfortunately, there are too many instances of such calls to change them
all.

martin

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[João Távora]

On Fri, Apr 12, 2013 at 5:45 PM, Stefan Monnier
<monnier@iro.umontreal.ca> wrote:
> switch-to-buffer is special because there are various circumstances
> where it's more important for it to only affect the selected-window then
> it is to display the specified buffer.
>

Yes I see. And, according to Martin, it should only be called
interactively, and therefore you simple rebinding would work, but in
reality it isn't.

> More specifically, your joaot/browse-buffer-in-special-frame should
> return the window it used to display the buffer.

Thanks! that does it, should have read `display-buffer''s doc more
carefully. Shouldn't its machinery assert `windowp' somewhere?

-- 
João Távora

frames dedicated to buffers, or, always see specific buffers in a specific frame

[João Távora]

>> yes, you understand correctly.
>
> So for making this general purpose you should use `pop-to-buffer'
> instead of `display-buffer'.

Yes, that works too. Why exactly is this more general purpose?

>> control how `display-buffer' but not
>
> ... only, I presume ...

Sorry I mean "a lot of control over how it gets called, but not when
it gets called"

>> when it is called. The advice is because I
>> want ibuffer and ido to work with this as well.
>
> These should refrain from using `switch-to-buffer(-...)' and use
> `pop-to-buffer' with the `display-buffer-same-window' directive instead.
> Wherever this bothers you, file a bug report so it gets fixed.

it didn't bother me until now, let's see if I use this frequently...

 Also, ido has these `ido-default-buffer-method' and
`ido-default-file-method' that can be set to various options to
control how buffer appears.

But the way these options implemented does not bring them all to
`display-buffer', which sometimes precludes user's control. Should't
they be implemented via `display-buffer-alist', keeping any of the
user's entries on top?

> [...]  Couldn't you use some more human predicate for this purpose?

Yes, I could of course, but was too lazy. I could use any
buffer-checking predicate. There could be some kind of var
`joaot/browse-buffer-predicates' tried in order by
`joaot/browse-buffer-p'.

>
> This was the intention of `display-buffer-alist' and IIRC at some time I
> had already removed all calls of `switch-to-buffer' from the Emacs code
> base.  Somehow this got reverted later.

Pity. But what about making `switch-to-buffer' delegate to
`display-buffer' too? It could dinamically bind `display-buffer-alist'
to display and select the buffer, but keeping any existing entries
(probably set by the user, or other programs) on top.

If that resulted in `switch-to-buffer' not switching to the buffer's
window, it could not be considered unexpected behaviour, since
ultimately the user set `display-buffer-alist' himself.

> `switch-to-buffer' is the traditional means to interactively show a
> buffer in the selected window.  It shouldn't be used in Lisp code.

Yes I see. But see above for a (possibly naive) fix.

> This doesn't sound right.  When `display-buffer' has found a window it
> should stop right there.  Anything else would constitute a bug.  If you
> can reproduce it, step through it with the debugger to find out what
> goes wrong.

My fault, sorry. The function displaying the buffer must return a
window object, anything else results in funny behaviour.

Anyway, it's working nicely now, thanks for the help.

--
João Távora

Re: frames dedicated to buffers, or, always see specific buffers in a specific frame

[martin rudalics]

 >> So for making this general purpose you should use `pop-to-buffer'
 >> instead of `display-buffer'.
 >
 > Yes, that works too. Why exactly is this more general purpose?

I meant that if you really want to use this as a subtitute for
`switch-to-buffer' you should make sure the window and frame get
selected.  They don't necessarily using `display-buffer' alone.

 >  Also, ido has these `ido-default-buffer-method' and
 > `ido-default-file-method' that can be set to various options to
 > control how buffer appears.
 >
 > But the way these options implemented does not bring them all to
 > `display-buffer', which sometimes precludes user's control. Should't
 > they be implemented via `display-buffer-alist', keeping any of the
 > user's entries on top?

Doesn't setting `ido-default-buffer-method' to `display' work?  Maybe we
could add `pop-to-buffer' to the default methods.

 > Pity. But what about making `switch-to-buffer' delegate to
 > `display-buffer' too? It could dinamically bind `display-buffer-alist'
 > to display and select the buffer, but keeping any existing entries
 > (probably set by the user, or other programs) on top.
 >
 > If that resulted in `switch-to-buffer' not switching to the buffer's
 > window, it could not be considered unexpected behaviour, since
 > ultimately the user set `display-buffer-alist' himself.

The basic idea of the `switch-to-buffer' functions is to bypass the
`display-buffer' customizations.  That is, by default you display a
buffer in a certain manner but always can use `switch-to-buffer' to
override that default behavior.

martin