wasamasa / shackle Goto Github PK

Hi,

Thanks for the great package which helped me get rid of popwin! But now I have a small issue when working with company.

I use both company and shackle and my shackle config is

(use-package shackle
  :ensure t
  :diminish (shackle-mode)
  :init
  (setq shackle-default-size 28
        shackle-default-alignment 'below
        shackle-rules
        `(;; Util
          ("*esup*"                 :align below :noselect t)
          ("*minor-modes*"          :align below :noselect t)
          ("*eval*"                 :align below :noselect t)
          ("*helm-descbinds*"       :same t)
          ("*helm top*"             :same t)
          ("\\`\\*helm.*?\\*\\'"    :align below :regexp t)

          ;; Minor modes
          ("*RTags*"                :align below :select t)
          ("*RTags Log*"            :align below :noselect t)
          ("*rdm*"                  :align below :noselect pt)
          ("*TeX Help*"             :align below :noselect t)
          ("*Flycheck errors*"      :align below :select t)
          ("*magit-process"         :align below :select t :regexp t)
          ("*git-messenger*"        :align below :select t)

          ;; Python
          ("*ob-ipython-traceback*" :align below :select t)
          ("*ob-ipython-stdout*"    :align below :select t)
          ("*Python*"               :align below :select t)
          ("*Python Help*"          :align below :select t)
          ("*Python Doc*"           :align below :select t)
          ("*Virtualenvs*"          :align below :select t)
          ("*jedi:doc*"             :align below :select t)
          ("*nosetests*"            :align below :select t)

          ;; Emacs
          ("*Pp Eval Output*"       :align below)
          ("*Apropos*"              :align below :select t)
          ("*Backtrace*"            :align below :select t)
          ("*Help*"                 :align below :select t)
          ("*Messages*"             :align below :select t)
          ("*Warnings*"             :align below :select t)
          ("*Compile-Log*"          :align below :select t)
          ("*compilation*"          :align below :select t)
          ("*Completions*"          :align below :select t)
          ("*command-log*"          :align below :select t)
          ("*Process List*"         :align below :select t)
          ("*Occur*"                :align below :select t)
          ("*Elint*"                :align below :select t)

          ;; vcs
          ("*vc-diff*"              :align below :select t)
          ("*vc-change-log*"        :align below :select t)
          (vc-annotate-mode         :same t)))

  :config (shackle-mode 1)

When company is show the tooltip of candidates, I use the default company-active-map binding C-h to invoke company-show-doc-buffer. The *Help* is pop up and I use q to quit doc window after reading it. Soon as the *Help* window is close the current buffer is switch to another buffer.

If I use C-g to terminate the company, everything goes fine. But I'd like to use q to quit the help window since hardly I left the C-g of popwin after I get into shackle. Also removing the ("*Help*" :align below :select t) line, the issue is gone.

Any help will be appreciated !

From the readme,

:same and t: Display buffer in the current window.
:popup and t: Pop up a new window instead of displaying the buffer in the current one.

It feels as if :same t is the same as :popup nil and vice-versa.

Can you please give some examples to better understand these keywords? Probably an example where you would want to set both to nil or both to t?

I tried the below and it did not work:

Snippet 1

(setq shackle-rules
      '(("*Help*" :select t :ratio 0.3 :align right :other t))

The Help buffer was always opened in a new window.

But the below, as suggested by you, worked:

Snippet 2

(setq shackle-rules
      '(("*Help*" :select t :other t))

So the questions I have are:

1. If I use :ratio and :align, will a new window be popped, always?
2. How can I get the :other functionality in addition to controlling the :ratio of a new popped up window (if a new window needs to be created, as in the (one-window-p) case)?
3. Should :ratio and :align be not used with :other?

While popping up a window is what happens by default when a function is using display-buffer directly, not all functions are doing that. run-scheme for instance does use pop-to-buffer-same-window instead of pop-to-buffer like run-python. The only way of avoiding this currently would be forfeiting the defaults entirely with shackle-preserve-defaults set to nil, but that would be inconvenient for everything else we're relying on to behave "normally".

Therefore, we need a new option. Maybe get rid of shackle-preserve-defaults since it's rather confusing and not needed by anything yet (would make :reuse obsolete?). As for the key and value, :pop and t as exclusive option to the existing :same and t could work.

See title. Must be faulty interaction between multiple invocations of display-buffer.

I tried all the variants but still can not make it work with helm-swoop package... I found those examples but they do nothing to helm-swoop sorry for japanese, don't know what its saying. I tried also the variant with reqexp as suggested in example:

(use-package shackle
  :ensure t
  :init (progn
          (require 'shackle)
          (add-to-list 'shackle-rules
                       '("\\`\\*helm.*?\\*\\'" :regexp t :align t :size 0.4))
          (add-to-list 'shackle-rules
                       '("\\`\\*Helm.*?\\*\\'" :regexp t :align t :size 0.4))))

But this still doesn't make nothing to swoop window but working with helm window though. Do I loose smth? thx.

I need to investigate this further, but I was wondering if anyone else is encountering this or if @wasamasa has any ideas about why this might be happening.

I think some special character is in that lighter string

• my complete environment

I'm using the following configuration:

(use-package shackle
  :ensure t
  :delight
  :init
  (setq shackle-rules '((compilation-mode :noselect t)
          ("\\`\\*Occur.*?\\*\\'" :regexp t :align t :select t :size 0.4)
          ("\\`\\*Help.*?\\*\\'" :regexp t :align t :select t :size 0.4)
          ("\\`\\*Register Preview.*?\\*\\'" :regexp t :align t :select t :size 0.4)
          ("\\`\\*Agenda Commands.*?\\*\\'" :regexp t :align 'below :popup t :select t :size 0.4)
          shackle-default-rule '(:select t)))
  :config
  (shackle-mode 1))

Shackle works with everything, except for the Agenda Commands window. I tried using org-agenda-mode but it didn't work either. Any suggestions?

And the location can not be determined by :align?

Hi,

With the following test snippet on emacs -Q

(package-initialize)
(require 'shackle)
(setq shackle-default-alignment 'below
      shackle-rules `(("*Help*" :align below :select t)
		      ("*Messages*" :align below :select t)
		      ("*Pp Eval Output*" :align below :select t)))
(shackle-mode 1)

;; Eval the following sexp to get a *Pp Eval Output* buffer
;; (pp-eval-expression `,(print 'shackle-rules))

the *Pp Eval Output* buffer seems can not be selected. I want to select the window because I've added an advice to enable view mode on it so that I can close the window by q.

Could you help me on this ? Thanks !

I've tried all of the following in shackle-rules but can't seem to get shackle to work with calc-mode:

(calc-mode                       :align below :select t)
(" *Calculator*"                 :align below :select t)
("*Calculator*"                  :align below :select t)
("*Calc Trail"                   :align below :select t)

Running M-x calc seems to produce a Calculator buffer within another window, seemingly arbitrarily.

Ideally running calc would change windows from this:

| Window 1 | Window 2 |
|          |          |
|          |          |
|          |          |
|----------+----------|
| Window 3            |
|---------------------|

to this:

| Window 1 | Window 2 |
|          |          |
|----------+----------|
| Window 3            |
|----------+----------|
| Calc     | Tail     |
|----------+----------|

Any ideas? I'm definitely willing to put in some of the leg work if necessary!

I couldn't see a way to get the default emacs behavior in the sequence below. [#] denote points in time for the table below and are not keystrokes.

[1] C-h v argv RET [2] C-x o q [3]

If starting with two windows, in the table below are the number of windows at different points and which window is focused at the end. I have noted discrepancies from the default emacs behavior.

| configuration                 | #1 window count | #2 window count | #3 window count | #3 focused window |
|-------------------------------+-----------------+-----------------+-----------------+-------------------|
| emacs default                 |               2 |               2 |               2 |                 1 |
| :other t                      |               2 |               2 |             *1* |                 1 |
| :other t :inhibit-window-quit |               2 |               2 |               2 |               *2* |
| shackle default (nil)         |               2 |             *3* |               2 |                 1 |

I'm not sure the shackle defaults should change, but it would be nice if the emacs default were supported somehow.

My goal is a way to support a default rule where:

• starting and ending number of windows are the same
• new windows are only created if starting with a single window (i.e. never more than two windows unless starting with more than two)
• displayed buffers are not shown in the starting window
• displayed buffers are selected
• quitting displayed buffers returns focus to the starting window

| #1 window count | #1 focused window | #2 window count | #2 focused window | #3 window count | #3 focused window |
|-----------------+-------------------+-----------------+-------------------+-----------------+-------------------|
|               2 |                 1 |               2 |                 2 |               2 |                 1 |
|               1 |                 1 |               2 |                 2 |               1 |                 1 |

In other words, if starting with two windows, the new buffer is displayed in the non-focused window, the new buffer is selected, and when quitting the new buffer there are still two windows and the focus is in the original window.

If starting with one window, the new buffer is displayed in a new window, the new window is selected, and when quiting the new buffer the new window is closed and the focus is in the original window.

Sorry about the weak issue name.

Thanks for any help.

You have

(setq shackle-rules
      '((compilation-mode :noselect t)
        (t :select t)))

Should it be:

(setq shackle-rules
      '((compilation-mode :select nil) ; No keyword called :noselect
        (t :select t)))

If a rule specifies :fit t, then fit the window size to the buffer contents. If :size is also specified, this becomes a maximum size for the buffer, but it may be smaller after fitting.

I'm sorry if I'm just too much of an Emacs rookie, but I can't get Shackle to work at all.

(setq shackle-rules '((help-mode :select t)))

Then I do C-h f RET (using Helm), and a window for a help-mode buffer comes up. But it's not selected. I have to C-x o to select the window, and C-x 1 to close it, as usual.

I've also tried (setq shackle-rules '(("*Help*" :select t))), but it still doesn't work.

I first tried using customize to configure it, but that didn't work either.

Am I doing something wrong?

Thanks.

(display-buffer
       buffer
       '(nil (inhibit-same-window . t))

I'd like to override such a call (in a 3rd party mode) with an advice or some other way in code.

@wgreenhouse showed me part of his Emacs configuration responsible for setting up display-buffer-alist which set up a rule for many different buffers by turning their names into a regular expression with regexp-opt. shackle could do better by allowing for lists as condition, that way you could specify a list of symbols or strings and upon match on any of its members execute the corresponding action.

The question is how regexp matching would be dealt with. I guess using it on all strings present would be fine.

It looks like helm sometimes creates windows using display-buffer that are not specific to it which doesn't seem to play well if you use a rule like ("*Help*" :align t :select t) along with helm-apropos and repeated hitting of C-z.

Hi, I've tried playing around with this package a bit and I want to switch from popwin, unfortunately I can't even get started.

I tried debugging by running emacs -nw -q then evaluating the following in the scratch buffer

(setq package-user-dir "~/.emacs.d/elpa/")
(package-initialize)
(require 'shackle)
(setq shackle-rules
      '((t :same t)))
(shackle-mode 1)

Then a command that pops up a new window such as M-x help-for-help does in fact pop up a new window.

My emacs version

GNU Emacs 25.0.50.2 (x86_64-unknown-linux-gnu, GTK+ Version 3.16.3) of 2015-06-04 on \
church

Hi!

Could you show me how i can disable shackle for some specifics buffers (like OCaml, or Make,..) ?

Thanks!
regards,
rotsix

@kovrik suggested a change for allowing more fine-grained behaviour for their ERC setup. Using the :same keyword is a good start, but is somewhat icky as selecting a non-ERC window while it is still loading up will switch its buffer out for an ERC buffer. A possible solution to this is linking a predicate to the keyword so that the keyword is only considered if the predicate holds true.

I can imagine a syntax along the lines of the alternatives syntax in conditions which is simply a list of symbols or strings (instead of a symbol or string). Doing something similiar in an action could work by simply wrapping the keyword in a list and letting a predicate follow. I'm not sure on the specific syntax of the predicate, but a rule could look like (erc-mode (:same erc-window-selected) (:other erc-window-not-selected)).

for example, run helm-mini from only one *scratch* window:

I install helm and shackle from melpa recently, by using the config:

  (setq shackle-rules
        '(("\\`\\*helm.*?\\*\\'" :regexp t :align t :ratio 0.4)))
  (shackle-mode)

am I missing something? (I'm new to shackle) BTW, it works as expected when there are more than one exiting windows.

I'm currently using shackle mode with neotree. Neotree sets window-side parameter. Thus, whenever shackle tries to split the window, I get the following error message: "split-window: Cannot split side window or parent of side window." I think Shackle should probably set ignore-window-parameters to t, split the window, and then reset this parameter when you quit the window.

This is by far the most useful feature this package could steal from popwin. As demonstrated in its screenshots, popwin offers an alignment and size option that makes a window appear at the specified side and ratio, no matter whether the current window configuration allows to do that easily or not.

First I'd need to figure out how to detect whether the splitting and resizing could be done easily. If that isn't possible, a different approach must be used. I need to figure out whether popwin is wrapping all currently visible windows into a new one and splitting that window or using an entirely different approach. Then, after that is done, the change needs to get cleaned up, how that is detected (adding a temporary function to the window changes hook, then doing something and removing it after the window disappeared) and cleaned up (reset to a previously saved window configuration?) is something left for me to investigate.

If clean-up has to be done, it's important to detect it in a way that isn't annoying (since popwin had the annoying default of killing the window once focus was switched away unless you configured it to never receive focus).

Starting Emacs in windowed mode with this simple init.el:

(setq package-archives '(("gnu" . "http://elpa.gnu.org/packages/")
                         ("melpa" . "http://melpa.milkbox.net/packages/")))

(package-initialize)
(require 'shackle)
(shackle-mode)

lead to unresponsive behavior of Emacs: every operation takes too long to perform. For example running erc takes like 8 seconds.
No problem with Emacs started with -nw option.
Emacs from MacPorts on OSX 10.10

/Applications/MacPorts/Emacs.app/Contents/MacOS/Emacs --version
GNU Emacs 24.4.1
Copyright (C) 2014 Free Software Foundation, Inc.
GNU Emacs comes with ABSOLUTELY NO WARRANTY.
You may redistribute copies of Emacs
under the terms of the GNU General Public License.
For more information about these matters, see the file named COPYING.

This causes the modeline to almost double in height because it prints as a box with "2603" in it. This character is not present in Consolas, for example. Please default to something less esoteric like "sm".

I can not figure out why does shackle failing recognizing dired-mode. Here's my config:

(use-package shackle
  :ensure t
  :config (progn
            (setq shackle-rules
                  '(
                    (help-mode :custom sandric/shackle-in-right-pane)
                    (dired-mode :custom sandric/shackle-in-right-pane)
                    ("*Ibuffer*" :align below :ratio 0.3)
                    ))
            (shackle-mode t)))

For help-mode everything works fine - function evaluated. For dired-mode its strangely not. I checked the major-mode output for buffer I open with dired-jump shortcut - its dired-mode, but it does not a match for shackle. Can smbd reproduce that?

Hi,

Sorry for the stream of issues I am opening today.

I am trying to see if I can use this to replace all of the display-buffer-alist and popwin customizations in my emacs init.

For this request, I was trying to get rid of the below from my init but I see that currently shackle doesn't have an option to open a buffer in the background (or does it?). For example, I would always like to open the Async Shell Command buffers to open in the background and not occupy any of the visible windows:

;; Don't display async command execution windows
;; http://emacs.stackexchange.com/a/5554/115
(add-to-list 'display-buffer-alist
             (cons "\\*Async Shell Command\\*.*"
                   (cons #'display-buffer-no-window nil)))

Tried setting it the same way as shell and eshell, both of which work as expected:

(setq shackle-default-rule '(:select t)
      shackle-rules
      '((("*shell*" "*eshell*" "*ielm*") :popup t)
        (compilation-mode :noselect t)))

Did not work, also tried setting it for (emacs-)lisp-interacton-mode and comint-mode, but still it switches the current window to ielm buffer instead of poping up. Not sure whether this is an issue with shackle or ielm.

it should be at https://github.com/wasamasa/shackle/blob/master/shackle.el#L292. (it seems package.el added one extract line during installation)

@Benaiah suggested a backwards-incompatible change on #emacs to fix the confusion with fallback rules as he tried setting up normal rules in the customization interface and it wasn't obvious to him how to enter a fallback rule (since Emacs put in nil instead of t as symbol for the key).

The proposed solution involves separating the rules from the fallback rule by introducing a new variable for it. I'm not sure about the naming yet, shackle-fallback-rule would be the most obvious.

With that change shackle--match would no longer check for the fallback case, instead a failing match would check whether shackle-fallback-rule has a meaningful value and use it or the popup rule. Perhaps it would make more sense to set the fallback rule to the :popup value instead and remove the default case in shackle-display-buffer.

As for breaking backwards compatibility, maybe it can be avoided by not taking out the check. It should be no problem to break it now since I haven't reached 1.0 and just display warnings when using it additionally to a notice in the README.

The package is not showing up on melpa.

I've been experimenting with shackle and popwin. Although I prefer shackle, there's a feature I really miss, which is the closing of the temporary buffers with C-g or the other popwin rules. I think this would be a great addition to shackle.

Would it be possible to allow the :align keyword in shackle rules or the shackle-default-alignment variable to take a function like (if (> (window-width) 160) 'right 'below), so that alignment is bottom most of the time, unless fullscreen, in which case it becomes right?

By default, helm add its buffers to winner-boring-buffers with this hook.

(add-hook 'helm-cleanup-hook #'helm-handle-winner-boring-buffers)

If I have this rule for helm in shackle:

(setq shackle-rules
'( ("\\`\\*helm.*?\\*\\'" :regexp t :align t :ratio 0.4)))

then helm buffers are not exclude from winner undo. You can try it with:

1 some buffer switching in one window layout
2 run helm-M-x
3 some buffer switching in one window layout
4 use winner undo and you will get a two window layout

I would like it if I could have a rule like (pdf-view-mode :align right :size 0.6 :reuse t) where the meaning of :reuse is that if there exists a window to the right, use that window and resize it if possible. :reuse could also be smarter and only use the window if there is currently a buffer in it to which that rule applies. In my example, if we already have a buffer in pdf-view-mode, I'd like to just reuse that buffer instead of popping open a new one.

Perhaps this is possible already, but it wasn't clear to me how to achieve it.

In mu4e, I am trying to get the mu4e-view buffer, when opened from the mu4e-headers buffer, to only take up 40% of the screen.

I have seemingly tried every possible combination of regex and I can't seem to apply shackle rules to windows/buffers in mu4e. So at this point, I'm concerned it might be a bug in Shackle.

My concern is that mu4e might be opening intermiddiate buffers, and so the Shackle rules would not apply? Would buffers changing disable certain Shackle rules?

For example, I've tried the following rules:

(setq shackle-rules '(("\\`\\*mu4e.*?\\*\\'" :regexp t :align t :size 0.4)
                      ("mu4e-loading" :regexp t :popup t :select t :same t size: 0.4)
                      ("mu4e-view" :regexp t size: 0.4)
                      ("mu4e" :regexp t :popup t :select t :same t size: 0.4)
                      ("view" :regexp t :popup t :select t :same t size: 0.4)))

And none seem to have any effect on the mu4e-view buffer when its opened in a new window.

I did notice that mu4e opens an intermiddiate buffer right before mu4e-view loads ( but in the same window ). i.e. mu4e-loading is sometimes shown first. but I figured my regex for mu4e would catch that.

Let me know if there are other ways I can debug this, or if you need any more information.

Thanks for the great work on this package so far.

Hi!

I have the following shackle setup:

(use-package shackle :ensure t
  :defines shackle-rules
  :init
  (setq shackle-rules '(("\\`\\*helm.*?\\*\\'" :regexp t :align t :size 0.4)
                        ("\\`\\*swiper*?\\*\\'" :regexp t :align t :size 0.4)))
  :config
  (shackle-mode))

If I have a window layout consisting of a single window, then after say helm-M-x the layout will consist of three windows, like this:

+-----------------------------+                 +-----------------------------+
|                             |                 | Original window             |
| Original window             | helm-M-x        +-----------------------------+
|                             |                 | Original window             |
|                             +---------------->|                             |
|                             |                 +-----------------------------+
|                             |                 | Helm                        |
|                             |                 |                             |
|                             |                 |                             |
+-----------------------------+                 +-----------------------------+

Why is this? Shouldn't I get only two windows?

If I have three windows, configured like below, it works fine:

+---------------+-------------+                 +--------------+--------------+
| Window 1      | Window 3    |                 | Window 1     | Window 3     |
|               |             | helm-M-x        +--------------+              |
|               |             |                 | Window 2     |              |
+---------------+             +---------------->|              |              |
| Window 2      |             |                 +--------------+--------------+
| (active)      |             |                 | Helm                        |
|               |             |                 |                             |
|               |             |                 |                             |
+---------------+-------------+                 +-----------------------------+

But if I have the same layout, but Window 3 as the active window, the result will be this:

+---------------+-------------+                 +-----------------------------+
| Window 1      | Window 3    |                 | Window 3                    |
|               | (active)    | helm-M-x        |                             |
|               |             |                 |                             |
+---------------+             +---------------->|                             |
| Window 2      |             |                 +-----------------------------+
|               |             |                 | Helm                        |
|               |             |                 |                             |
|               |             |                 |                             |
+---------------+-------------+                 +-----------------------------+

To me it feels like this configuration should be the same as the previous example?

Thank you for a great package!

I'm using 64-bit GNU Emacs 25.0.94.2 on a Windows machine.

If one uses Silex/emacs-config@a7c1eb0 and M-x man, the popped up window doesn't get the focus. My own config doesn't exhibit the issue for whatever reason.

I suspect that this is because helm wants to run in a buffer that is not the mini buffer and shackle is not allowing this.

Perhaps this makes sense/is desired behavior/another setting should be used, but I could see an argument that :same should not affect behavior from the mini buffer

EDIT: I suppose it wouldn't be too hard to write a custom rule for this...

An ignore action that just refuses to display the buffer would be a start. It would be worth it inspecting the remaining ones as defined in window.el and the advanced invocation forms supported by display-buffer as described on reddit:

(add-to-list 'display-buffer-alist
                    `(,(rx bos "*helm" (* not-newline) "*" eos)
                         (display-buffer-in-side-window)
                         (inhibit-same-window . t)
                         (window-height . 0.4)))

When I have shackle up and running and try to open ranger.el, all the windows get scrambled.

I tried to add:

  (dired-mode  :ignore t)
  (ranger-mode :ignore t)

to shackle-rules but that does not seem to have any effect.

Here is my shackle configuration:

  (use-package shackle
    :init
    (setq shackle-default-rule '(:select t :align t)
          shackle-rules '((help-mode :align below :size 0.4)
                          (helpful-mode                     :align below  :size 0.4)
                          (dired-mode          :ignore t)
                          (ranger-mode         :ignore t)
                          ("evil-ranger"       :ignore t)

                          (compilation-mode    :select nil  :align below  :size 0.25)
                          ("*compilation*"     :select nil  :align below  :size 0.25)
                          (grep-mode           :select nil  :align below  :size 0.25)
                          (occur-mode          :select nil  :align below  :size 0.25)
                          ("*ag search*"       :select nil  :align below  :size 0.25)
                          ("*Flycheck errors*" :select nil  :align below  :size 0.25)
                          ("*Warnings*"        :select nil  :align below  :size 0.25)
                          ("*Error*"           :select nil  :align below  :size 0.25)

                          (" *undo-tree*"                   :align right  :size 0.3)
                          ("*PLANTUML Preview*" :select nil               :size 25    :autokill t)

                          (neotree-mode                     :align left)
                          ("twittering-mode"                :align left   :size 0.4)

                          (magit-status-mode                :align bottom :size 0.5  :inhibit-window-quit t)
                          (magit-log-mode                   :same t                  :inhibit-window-quit t)
                          (magit-commit-mode                :ignore t)
                          (magit-diff-mode     :select nil  :align left   :size 0.5)
                          (git-commit-mode                  :same t)
                          (vc-annotate-mode                 :same t)
                          ("^\\*git-gutter.+\\*$" :regexp t :size 15 :noselect t)
                          ))
    :config
    (defun my/shackle-defaults (plist)
      "Ensure popups are always aligned and selected by default. Eliminates the need
   for :align t on every rule."
      (when plist
        (unless (or (plist-member plist :align)
                    (plist-member plist :same)
                    (plist-member plist :frame))
          (plist-put plist :align t))
        (unless (or (plist-member plist :select)
                    (plist-member plist :noselect))
          (plist-put plist :select t)))
      plist)
    (advice-add #'shackle--match :filter-return #'my/shackle-defaults)

    (add-hook 'my/after-init-hook 'shackle-mode))

I've heard of people who use window managers like StumpWM and prefer letting these manage Emacs frames. Therefore it would be useful if shackle would support popping up a frame instead of a window, ideally with size and alignment options.

I incidentally found out that it's not only possible to split the parent of the currently selected window via (split-window (window-parent) nil 'above), but to split the root window too with (split-window (frame-root-window) nil 'above). For the latter there's no need to do special trickery even simply because closing the newly opened window automatically restores the old proportions. There's a need for more testing to see whether it will generally work and how much extra code is necessary. If the resulting downsides are miniscule, the current method could be trashed even. Otherwise a switch for choosing the implementation can be offered.

First off, thank you for shackle. Popwin's been a bad itch for years and emacs feels much snappier without it.

Anyhow: one thing I miss from popwin are :height and :width, would you consider adding them? Either as a fall-through on :ratio when N > 1 (was mentioned in #8) or as separate keys. I'd be happy to do a PR for it myself if you prefer.

A ratio size is uncomfortable working across systems with drastically different resolutions like I do (2560x1600 at home and 1280x800 away from home). I also don't think a ratio is meaningful for some windows (like the 2-3 line popups org-link or org-todo throws up).

I'd like to open the Help buffers in an already open window to the right/left but not the current one. Is that possible? Or can you implement that feature?

This is what I have (I am not showing the other rules I have for simplicity):

(setq shackle-rules '(
                          ;; Help
                          ("*Help*"
                           :align right
                           :popup nil
                           :select t)))

Here is the desired behavior in more detail:

• Select the Help buffer when it opens
• If the frame has only one window, split a window to the right and show Help buffer in that. Close that window when I quit Help.
• If the frame has more than one window, do NOT split any more windows. Instead, show Help in one of the open windows (other than the current one). Quitting Help in that case should not close that window.

I use the following in shackle-rules:
("*Help*" :align below :ratio 0.33 :select t)
which works great. Unfortunately, when I follow a link to, for example, go to the function definition in an elisp file, it opens the file in the window spawned by shackle.

Any idea would I modify my configuration to instead open the file in the original window I called help from similar to helm-buffers-list?

Any help is appreciated. Thanks for making an awesome package that's pivotal to my workflow!

Hello,
Some buffers can be read only and if they are put in special-mode, we can quit them with q.
Is it possible to add another keyword :special?
Thank you for your consideration.

You have this at the following lines (as of the current version).

                                   (:same boolean)
                                    (:popup boolean)
                                    (:same boolean)

Also that defcustom docstring and :value-type are missing the new :other keyword.