* Re: Release plans
2008-07-21 4:49 ` Chong Yidong
@ 2008-07-21 8:06 ` Thien-Thi Nguyen
2008-07-21 13:32 ` Chong Yidong
2008-07-23 20:52 ` Michael Albinus
` (3 subsequent siblings)
4 siblings, 1 reply; 42+ messages in thread
From: Thien-Thi Nguyen @ 2008-07-21 8:06 UTC (permalink / raw
To: Chong Yidong; +Cc: emacs-devel
() Chong Yidong <cyd@stupidchicken.com>
() Mon, 21 Jul 2008 00:49:03 -0400
now would be a good time to ping
Ping! (I can't remember if this was accepted or not.)
thi
_______________________________________________
*** lisp/smerge-mode.el.~1.72~ 2008-07-21 09:58:34.000000000 +0200
--- lisp/smerge-mode.el 2008-06-24 09:17:57.000000000 +0200
***************
*** 44,50 ****
;;; Code:
! (eval-when-compile (require 'cl))
;;; The real definition comes later.
--- 44,50 ----
;;; Code:
! (eval-when-compile (require 'cl) (require 'diff-mode))
;;; The real definition comes later.
***************
*** 77,87 ****
:group 'smerge
:type 'boolean)
- (defcustom smerge-auto-refine t
- "Automatically highlight changes in detail as the user visits conflicts."
- :group 'smerge
- :type 'boolean)
-
(defface smerge-mine
'((((min-colors 88) (background light))
(:foreground "blue1"))
--- 77,82 ----
***************
*** 259,265 ****
;; Define smerge-next and smerge-prev
(easy-mmode-define-navigation smerge smerge-begin-re "conflict" nil nil
! (if smerge-auto-refine
(condition-case nil (smerge-refine) (error nil))))
(defconst smerge-match-names ["conflict" "mine" "base" "other"])
--- 254,260 ----
;; Define smerge-next and smerge-prev
(easy-mmode-define-navigation smerge smerge-begin-re "conflict" nil nil
! (if diff-auto-refine-mode
(condition-case nil (smerge-refine) (error nil))))
(defconst smerge-match-names ["conflict" "mine" "base" "other"])
*** lisp/diff-mode.el.~1.145~ 2008-07-21 09:56:54.000000000 +0200
--- lisp/diff-mode.el 2008-07-21 10:02:30.000000000 +0200
***************
*** 91,101 ****
:type 'boolean
:group 'diff-mode)
- (defcustom diff-auto-refine t
- "Automatically highlight changes in detail as the user visits hunks."
- :type 'boolean
- :group 'diff-mode)
-
(defcustom diff-mode-hook nil
"Run after setting up the `diff-mode' major mode."
:type 'hook
--- 91,96 ----
***************
*** 220,225 ****
--- 215,227 ----
`((,diff-minor-mode-prefix . ,diff-mode-shared-map))
"Keymap for `diff-minor-mode'. See also `diff-mode-shared-map'.")
+ (define-minor-mode diff-auto-refine-mode
+ "Automatically highlight changes in detail as the user visits hunks.
+ When transitioning from disabled to enabled,
+ try to refine the current hunk, as well."
+ :group 'diff-mode :init-value t :lighter " Auto-Refine"
+ (when diff-auto-refine-mode
+ (condition-case-no-debug nil (diff-refine-hunk) (error nil))))
;;;;
;;;; font-lock support
***************
*** 528,534 ****
;; Define diff-{hunk,file}-{prev,next}
(easy-mmode-define-navigation
diff-hunk diff-hunk-header-re "hunk" diff-end-of-hunk diff-restrict-view
! (if diff-auto-refine
(condition-case-no-debug nil (diff-refine-hunk) (error nil))))
(easy-mmode-define-navigation
--- 530,536 ----
;; Define diff-{hunk,file}-{prev,next}
(easy-mmode-define-navigation
diff-hunk diff-hunk-header-re "hunk" diff-end-of-hunk diff-restrict-view
! (if diff-auto-refine-mode
(condition-case-no-debug nil (diff-refine-hunk) (error nil))))
(easy-mmode-define-navigation
*** etc/NEWS.~1.1798.~ 2008-07-21 08:45:56.000000000 +0200
--- etc/NEWS 2008-07-21 10:03:32.000000000 +0200
***************
*** 579,585 ****
*** diff-refine-hunk highlights word-level details of changes in a diff hunk.
It's used automatically as you move through hunks, see
! diff-auto-refine. It is bound to `C-c C-b'.
*** diff-add-change-log-entries-other-window iterates through the diff
buffer and tries to create ChangeLog entries for each change.
--- 579,585 ----
*** diff-refine-hunk highlights word-level details of changes in a diff hunk.
It's used automatically as you move through hunks, see
! diff-auto-refine-mode. It is bound to `C-c C-b'.
*** diff-add-change-log-entries-other-window iterates through the diff
buffer and tries to create ChangeLog entries for each change.
***************
*** 784,790 ****
*** sgml-electric-tag-pair-mode lets you simultaneously edit matched tag pairs.
*** smerge-refine highlights word-level details of changes in conflict.
! It's used automatically as you move through conflicts, see smerge-auto-refine.
*** talk.el has been extended for multiple tty support.
--- 784,791 ----
*** sgml-electric-tag-pair-mode lets you simultaneously edit matched tag pairs.
*** smerge-refine highlights word-level details of changes in conflict.
! It's used automatically as you move through conflicts, see
! smerge-auto-refine-mode.
*** talk.el has been extended for multiple tty support.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-21 4:49 ` Chong Yidong
2008-07-21 8:06 ` Thien-Thi Nguyen
@ 2008-07-23 20:52 ` Michael Albinus
2008-07-23 21:42 ` Chong Yidong
2008-07-26 7:39 ` Release plans Eli Zaretskii
` (2 subsequent siblings)
4 siblings, 1 reply; 42+ messages in thread
From: Michael Albinus @ 2008-07-23 20:52 UTC (permalink / raw
To: Chong Yidong; +Cc: emacs-devel
Chong Yidong <cyd@stupidchicken.com> writes:
>> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
>> end of this month.
>
> If anyone on this list has a patch that is still waiting for approval or
> further comments, now would be a good time to ping.
I have a small package in the queue, xesam.el. It provides an interface
to search engines, who support the Xesam API(1). I've tested it with
beagle(2) and strigi(3) as well as with the demo script from the
xesam-tools(4), which implements an access to yahoo. tracker(5),
pinot(6) and recoll(7) are also said to support Xesam; this I haven't
tested (yet).
The package is functional, although it might need some polishing. Are
there any objections to install it at lisp/net?
Best regards, Michael.
(1): <http://xesam.org/main>
(2): <http://beagle-project.org/About>
(3): <http://strigi.sourceforge.net/?q=general>
(4): <http://xesam.org/people/kamstrup/xesam-tools/>
(5): <http://www.gnome.org/projects/tracker/>
(6): <http://pinot.berlios.de/index.html>
(7): <http://www.recoll.org/>
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-23 20:52 ` Michael Albinus
@ 2008-07-23 21:42 ` Chong Yidong
2008-07-24 22:07 ` xesam.el (was: Release plans) Michael Albinus
0 siblings, 1 reply; 42+ messages in thread
From: Chong Yidong @ 2008-07-23 21:42 UTC (permalink / raw
To: Michael Albinus; +Cc: emacs-devel
Michael Albinus <michael.albinus@gmx.de> writes:
> I have a small package in the queue, xesam.el. It provides an interface
> to search engines, who support the Xesam API(1). I've tested it with
> beagle(2) and strigi(3) as well as with the demo script from the
> xesam-tools(4), which implements an access to yahoo. tracker(5),
> pinot(6) and recoll(7) are also said to support Xesam; this I haven't
> tested (yet).
>
> The package is functional, although it might need some polishing. Are
> there any objections to install it at lisp/net?
Go ahead, if you feel that it is ready for inclusion (and please include
a NEWS entry).
^ permalink raw reply [flat|nested] 42+ messages in thread
* xesam.el (was: Release plans)
2008-07-23 21:42 ` Chong Yidong
@ 2008-07-24 22:07 ` Michael Albinus
0 siblings, 0 replies; 42+ messages in thread
From: Michael Albinus @ 2008-07-24 22:07 UTC (permalink / raw
To: Chong Yidong; +Cc: emacs-devel
Chong Yidong <cyd@stupidchicken.com> writes:
> Michael Albinus <michael.albinus@gmx.de> writes:
>
>> I have a small package in the queue, xesam.el. It provides an interface
>> to search engines, who support the Xesam API(1). I've tested it with
>> beagle(2) and strigi(3) as well as with the demo script from the
>> xesam-tools(4), which implements an access to yahoo. tracker(5),
>> pinot(6) and recoll(7) are also said to support Xesam; this I haven't
>> tested (yet).
>>
>> The package is functional, although it might need some polishing. Are
>> there any objections to install it at lisp/net?
>
> Go ahead, if you feel that it is ready for inclusion (and please include
> a NEWS entry).
done.
Best regards, Michael.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-21 4:49 ` Chong Yidong
2008-07-21 8:06 ` Thien-Thi Nguyen
2008-07-23 20:52 ` Michael Albinus
@ 2008-07-26 7:39 ` Eli Zaretskii
2008-07-26 21:33 ` Richard M Stallman
` (3 more replies)
2008-07-31 0:56 ` New `read-buffer-completion-ignore-case' variable? [was Re: Release plans] John Paul Wallington
2008-07-31 2:10 ` Release plans Bastien
4 siblings, 4 replies; 42+ messages in thread
From: Eli Zaretskii @ 2008-07-26 7:39 UTC (permalink / raw
To: Chong Yidong; +Cc: Roland Winkler, emacs-devel
> From: Chong Yidong <cyd@stupidchicken.com>
> Date: Mon, 21 Jul 2008 00:49:03 -0400
>
> > Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
> > end of this month.
>
> If anyone on this list has a patch that is still waiting for approval or
> further comments, now would be a good time to ping.
I've been working off-list with Roland Winkler on adding two
primitives to Emacs that would allow proced.el to avoid using external
programs such as `ps' to implement Process Editor mode. The GNU/Linux
part of the primitives is almost done; I need maybe one more weekend
to finish it and install the changes. The MS-Windows implementation
will follow.
I hope I will be allowed to install these changes on the trunk.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-26 7:39 ` Release plans Eli Zaretskii
@ 2008-07-26 21:33 ` Richard M Stallman
2008-07-27 3:22 ` Eli Zaretskii
2008-07-28 13:43 ` Juri Linkov
` (2 subsequent siblings)
3 siblings, 1 reply; 42+ messages in thread
From: Richard M Stallman @ 2008-07-26 21:33 UTC (permalink / raw
To: Eli Zaretskii; +Cc: cyd, emacs-devel, Roland.Winkler
I've been working off-list with Roland Winkler on adding two
primitives to Emacs that would allow proced.el to avoid using external
programs such as `ps' to implement Process Editor mode.
That is definitely a good contribution.
But if Emacs did not run on Windows, could you still have made
this contribution? Or perhaps even more contribution?
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-26 21:33 ` Richard M Stallman
@ 2008-07-27 3:22 ` Eli Zaretskii
2008-07-27 17:14 ` Richard M Stallman
0 siblings, 1 reply; 42+ messages in thread
From: Eli Zaretskii @ 2008-07-27 3:22 UTC (permalink / raw
To: rms; +Cc: cyd, emacs-devel, Roland.Winkler
> From: Richard M Stallman <rms@gnu.org>
> CC: cyd@stupidchicken.com, Roland.Winkler@physik.uni-erlangen.de,
> emacs-devel@gnu.org
> Date: Sat, 26 Jul 2008 17:33:58 -0400
>
> But if Emacs did not run on Windows, could you still have made
> this contribution? Or perhaps even more contribution?
Not really.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-27 3:22 ` Eli Zaretskii
@ 2008-07-27 17:14 ` Richard M Stallman
2008-07-27 19:14 ` Eli Zaretskii
0 siblings, 1 reply; 42+ messages in thread
From: Richard M Stallman @ 2008-07-27 17:14 UTC (permalink / raw
To: Eli Zaretskii; +Cc: cyd, Roland.Winkler, emacs-devel
> But if Emacs did not run on Windows, could you still have made
> this contribution? Or perhaps even more contribution?
Not really.
What if you did all your editing on a GNU/Linux machine?
In the first year of GNU development, before GNU Emacs, I didn't do
editing on Unix. I edited on another machine where there was an Emacs,
and saved the files to the Unix machine where I tested them.
It wasn't very inconvenient even then.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-27 17:14 ` Richard M Stallman
@ 2008-07-27 19:14 ` Eli Zaretskii
2008-07-28 21:46 ` Richard M Stallman
0 siblings, 1 reply; 42+ messages in thread
From: Eli Zaretskii @ 2008-07-27 19:14 UTC (permalink / raw
To: rms; +Cc: emacs-devel
> From: Richard M Stallman <rms@gnu.org>
> CC: cyd@stupidchicken.com, emacs-devel@gnu.org,
> Roland.Winkler@physik.uni-erlangen.de
> Date: Sun, 27 Jul 2008 13:14:45 -0400
>
> > But if Emacs did not run on Windows, could you still have made
> > this contribution? Or perhaps even more contribution?
>
> Not really.
>
> What if you did all your editing on a GNU/Linux machine?
It won't matter. My problem is a chronic lack of free time
(obviously, I cannot develop Emacs during my office hours), so I
mostly can do only simple Emacs jobs. When there are exceptions, like
on public holidays, I have access to both Windows and GNU/Linux.
That's how I coded the Proced support, for example.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-27 19:14 ` Eli Zaretskii
@ 2008-07-28 21:46 ` Richard M Stallman
2008-07-29 3:12 ` Eli Zaretskii
0 siblings, 1 reply; 42+ messages in thread
From: Richard M Stallman @ 2008-07-28 21:46 UTC (permalink / raw
To: Eli Zaretskii; +Cc: emacs-devel
It won't matter. My problem is a chronic lack of free time
(obviously, I cannot develop Emacs during my office hours), so I
mostly can do only simple Emacs jobs.
In that case, does the fact that Emacs runs on Windows
help you do these simple jobs?
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-28 21:46 ` Richard M Stallman
@ 2008-07-29 3:12 ` Eli Zaretskii
2008-07-30 3:47 ` Richard M Stallman
0 siblings, 1 reply; 42+ messages in thread
From: Eli Zaretskii @ 2008-07-29 3:12 UTC (permalink / raw
To: rms; +Cc: emacs-devel
> From: Richard M Stallman <rms@gnu.org>
> CC: emacs-devel@gnu.org
> Date: Mon, 28 Jul 2008 17:46:52 -0400
>
> It won't matter. My problem is a chronic lack of free time
> (obviously, I cannot develop Emacs during my office hours), so I
> mostly can do only simple Emacs jobs.
>
> In that case, does the fact that Emacs runs on Windows
> help you do these simple jobs?
It gives me more opportunities to look at problems that are not
specific to some platform.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-29 3:12 ` Eli Zaretskii
@ 2008-07-30 3:47 ` Richard M Stallman
2008-07-30 17:33 ` Eli Zaretskii
0 siblings, 1 reply; 42+ messages in thread
From: Richard M Stallman @ 2008-07-30 3:47 UTC (permalink / raw
To: Eli Zaretskii; +Cc: emacs-devel
> In that case, does the fact that Emacs runs on Windows
> help you do these simple jobs?
It gives me more opportunities to look at problems that are not
specific to some platform.
Sure, but it also consumes some of your time on Windows support issues.
If you simply did your editing on the GNU/Linux machine, and did not
pay attention to Windows support, would your contributions to
the platform-independent capabilities of Emacs be less, or more?
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-30 3:47 ` Richard M Stallman
@ 2008-07-30 17:33 ` Eli Zaretskii
0 siblings, 0 replies; 42+ messages in thread
From: Eli Zaretskii @ 2008-07-30 17:33 UTC (permalink / raw
To: rms; +Cc: emacs-devel
> From: Richard M Stallman <rms@gnu.org>
> CC: emacs-devel@gnu.org
> Date: Tue, 29 Jul 2008 23:47:30 -0400
>
> If you simply did your editing on the GNU/Linux machine, and did not
> pay attention to Windows support, would your contributions to
> the platform-independent capabilities of Emacs be less, or more?
It would probably be more, but only insignificantly so.
Anyway, this is purely academic question.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-26 7:39 ` Release plans Eli Zaretskii
2008-07-26 21:33 ` Richard M Stallman
@ 2008-07-28 13:43 ` Juri Linkov
2008-07-28 14:10 ` Chong Yidong
2008-07-29 15:21 ` Roland Winkler
2008-08-02 17:34 ` Eli Zaretskii
3 siblings, 1 reply; 42+ messages in thread
From: Juri Linkov @ 2008-07-28 13:43 UTC (permalink / raw
To: Eli Zaretskii; +Cc: Chong Yidong, emacs-devel, Roland Winkler
>> > Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
>> > end of this month.
>>
>> If anyone on this list has a patch that is still waiting for approval or
>> further comments, now would be a good time to ping.
>
> I've been working off-list with Roland Winkler on adding two
> primitives to Emacs that would allow proced.el to avoid using external
> programs such as `ps' to implement Process Editor mode. The GNU/Linux
> part of the primitives is almost done; I need maybe one more weekend
> to finish it and install the changes. The MS-Windows implementation
> will follow.
>
> I hope I will be allowed to install these changes on the trunk.
And we also need more time to finish and install code for multiple input
methods and a better locale system for the upcoming Unicode release.
--
Juri Linkov
http://www.jurta.org/emacs/
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-28 13:43 ` Juri Linkov
@ 2008-07-28 14:10 ` Chong Yidong
2008-07-28 14:33 ` Juri Linkov
0 siblings, 1 reply; 42+ messages in thread
From: Chong Yidong @ 2008-07-28 14:10 UTC (permalink / raw
To: Juri Linkov; +Cc: Eli Zaretskii, emacs-devel, Roland Winkler
Juri Linkov <juri@jurta.org> writes:
> And we also need more time to finish and install code for multiple
> input methods and a better locale system for the upcoming Unicode
> release.
And how long do you estimate this would take? If too long, this will
simply have to wait for the next cycle.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-28 14:10 ` Chong Yidong
@ 2008-07-28 14:33 ` Juri Linkov
2008-07-29 17:11 ` Chong Yidong
0 siblings, 1 reply; 42+ messages in thread
From: Juri Linkov @ 2008-07-28 14:33 UTC (permalink / raw
To: Chong Yidong; +Cc: Eli Zaretskii, Roland Winkler, emacs-devel
>> And we also need more time to finish and install code for multiple
>> input methods and a better locale system for the upcoming Unicode
>> release.
>
> And how long do you estimate this would take? If too long, this will
> simply have to wait for the next cycle.
I suppose not more than two weeks.
--
Juri Linkov
http://www.jurta.org/emacs/
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-28 14:33 ` Juri Linkov
@ 2008-07-29 17:11 ` Chong Yidong
2008-07-29 17:54 ` Stefan Monnier
0 siblings, 1 reply; 42+ messages in thread
From: Chong Yidong @ 2008-07-29 17:11 UTC (permalink / raw
To: Juri Linkov; +Cc: Eli Zaretskii, Roland Winkler, emacs-devel
Juri Linkov <juri@jurta.org> writes:
>>> And we also need more time to finish and install code for multiple
>>> input methods and a better locale system for the upcoming Unicode
>>> release.
>>
>> And how long do you estimate this would take? If too long, this will
>> simply have to wait for the next cycle.
>
> I suppose not more than two weeks.
I think it may be better to keep this for 23.2, but please do write up
the patch anyway; it'll be easier to decide once we have something to
look at.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-29 17:11 ` Chong Yidong
@ 2008-07-29 17:54 ` Stefan Monnier
0 siblings, 0 replies; 42+ messages in thread
From: Stefan Monnier @ 2008-07-29 17:54 UTC (permalink / raw
To: Chong Yidong; +Cc: Juri Linkov, Eli Zaretskii, emacs-devel, Roland Winkler
> I think it may be better to keep this for 23.2, but please do write up
Indeed, it doesn't matter much anyway: it is not a crucial fonctionality
(and it already works right now), so there's no strong reason to push it
for 23.1. At the same time, proced.el is new in Emacs-23, so we can be
a bit more permissive w.r.t late additions in that it won't be
a regression compared to Emacs-22 anyway.
Stefan
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-26 7:39 ` Release plans Eli Zaretskii
2008-07-26 21:33 ` Richard M Stallman
2008-07-28 13:43 ` Juri Linkov
@ 2008-07-29 15:21 ` Roland Winkler
2008-08-02 17:34 ` Eli Zaretskii
3 siblings, 0 replies; 42+ messages in thread
From: Roland Winkler @ 2008-07-29 15:21 UTC (permalink / raw
To: Eli Zaretskii; +Cc: Chong Yidong, emacs-devel
On Sat Jul 26 2008 Eli Zaretskii wrote:
> > From: Chong Yidong <cyd@stupidchicken.com>
> > Date: Mon, 21 Jul 2008 00:49:03 -0400
> >
> > > Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
> > > end of this month.
> >
> > If anyone on this list has a patch that is still waiting for approval or
> > further comments, now would be a good time to ping.
>
> I've been working off-list with Roland Winkler on adding two
> primitives to Emacs that would allow proced.el to avoid using external
> programs such as `ps' to implement Process Editor mode. The GNU/Linux
> part of the primitives is almost done; I need maybe one more weekend
> to finish it and install the changes. The MS-Windows implementation
> will follow.
>
> I hope I will be allowed to install these changes on the trunk.
I must greatly apologize because I need to say that I have not yet
been able to finalize the part of proced.el that will be able to use
Eli's primitives. Right now I am traveling (once more) and I cannot
do any programming. I'll return on Aug 11 when I will finish my part
with very high priority (i.e., not later than the end of that week).
Will that be acceptable?
Roland
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-26 7:39 ` Release plans Eli Zaretskii
` (2 preceding siblings ...)
2008-07-29 15:21 ` Roland Winkler
@ 2008-08-02 17:34 ` Eli Zaretskii
2008-08-09 18:29 ` Eli Zaretskii
3 siblings, 1 reply; 42+ messages in thread
From: Eli Zaretskii @ 2008-08-02 17:34 UTC (permalink / raw
To: Eli Zaretskii; +Cc: cyd, emacs-devel, Roland.Winkler
> Date: Sat, 26 Jul 2008 10:39:08 +0300
> From: Eli Zaretskii <eliz@gnu.org>
> Cc: Roland Winkler <Roland.Winkler@physik.uni-erlangen.de>, emacs-devel@gnu.org
>
> I've been working off-list with Roland Winkler on adding two
> primitives to Emacs that would allow proced.el to avoid using external
> programs such as `ps' to implement Process Editor mode. The GNU/Linux
> part of the primitives is almost done; I need maybe one more weekend
> to finish it and install the changes. The MS-Windows implementation
> will follow.
The GNU/Linux implementation is now done and installed. I didn't yet
write the documentation for the ELisp manual, but I assume this is not
urgent, since the code freeze does not affect the docs.
P.S. The GNU/Linux implementation uses /proc filesystem to get at the
list of processes and the attributes of a process. While I know that
other Unix systems support /proc, I don't have access to them, and
thus cannot verify that the code works on them, especially since I'm
quite sure the details vary. So for now the /proc method is only
enabled for GNU/Linux; users of other Unices will have to extend the
code for their systems.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-08-02 17:34 ` Eli Zaretskii
@ 2008-08-09 18:29 ` Eli Zaretskii
2008-08-09 18:34 ` Juanma Barranquero
0 siblings, 1 reply; 42+ messages in thread
From: Eli Zaretskii @ 2008-08-09 18:29 UTC (permalink / raw
To: cyd, Roland.Winkler, emacs-devel
> Date: Sat, 02 Aug 2008 20:34:40 +0300
> From: Eli Zaretskii <eliz@gnu.org>
> CC: cyd@stupidchicken.com, Roland.Winkler@physik.uni-erlangen.de,
> emacs-devel@gnu.org
>
> > Date: Sat, 26 Jul 2008 10:39:08 +0300
> > From: Eli Zaretskii <eliz@gnu.org>
> > Cc: Roland Winkler <Roland.Winkler@physik.uni-erlangen.de>, emacs-devel@gnu.org
> >
> > I've been working off-list with Roland Winkler on adding two
> > primitives to Emacs that would allow proced.el to avoid using external
> > programs such as `ps' to implement Process Editor mode. The GNU/Linux
> > part of the primitives is almost done; I need maybe one more weekend
> > to finish it and install the changes. The MS-Windows implementation
> > will follow.
>
> The GNU/Linux implementation is now done and installed.
The MS-Windows implementation is also installed.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-08-09 18:29 ` Eli Zaretskii
@ 2008-08-09 18:34 ` Juanma Barranquero
2008-08-09 19:06 ` Eli Zaretskii
0 siblings, 1 reply; 42+ messages in thread
From: Juanma Barranquero @ 2008-08-09 18:34 UTC (permalink / raw
To: Eli Zaretskii; +Cc: cyd, emacs-devel, Roland.Winkler
On Sat, Aug 9, 2008 at 20:29, Eli Zaretskii <eliz@gnu.org> wrote:
> The MS-Windows implementation is also installed.
It is expected that system-process-attributes returns a non-nil list
for nonexistent processes?
ELISP> (system-process-attributes -1)
((group . "None")
(egid . 513)
(user . "SYSTEM")
(euid . 18))
ELISP> (system-process-attributes (1+ (apply #'max (list-system-processes))))
((pmem . 0.4225325208687513)
(rss . 4424)
(vsize . 4228)
(majflt . 3894)
(group . "Ninguno")
(egid . 513)
(user . "Juanma")
(euid . 1006))
Juanma
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-08-09 18:34 ` Juanma Barranquero
@ 2008-08-09 19:06 ` Eli Zaretskii
0 siblings, 0 replies; 42+ messages in thread
From: Eli Zaretskii @ 2008-08-09 19:06 UTC (permalink / raw
To: Juanma Barranquero; +Cc: cyd, emacs-devel, Roland.Winkler
> Date: Sat, 9 Aug 2008 20:34:40 +0200
> From: "Juanma Barranquero" <lekktu@gmail.com>
> Cc: cyd@stupidchicken.com, Roland.Winkler@physik.uni-erlangen.de,
> emacs-devel@gnu.org
>
> On Sat, Aug 9, 2008 at 20:29, Eli Zaretskii <eliz@gnu.org> wrote:
>
> > The MS-Windows implementation is also installed.
>
> It is expected that system-process-attributes returns a non-nil list
> for nonexistent processes?
No, it's a bug, of course (had in mind to handle this case, but
forgot). Now fixed, thanks.
^ permalink raw reply [flat|nested] 42+ messages in thread
* New `read-buffer-completion-ignore-case' variable? [was Re: Release plans]
2008-07-21 4:49 ` Chong Yidong
` (2 preceding siblings ...)
2008-07-26 7:39 ` Release plans Eli Zaretskii
@ 2008-07-31 0:56 ` John Paul Wallington
2008-07-30 15:36 ` New `read-buffer-completion-ignore-case' variable? Chong Yidong
2008-07-31 2:10 ` Release plans Bastien
4 siblings, 1 reply; 42+ messages in thread
From: John Paul Wallington @ 2008-07-31 0:56 UTC (permalink / raw
To: Chong Yidong; +Cc: emacs-devel
Chong Yidong <cyd@stupidchicken.com> writes:
>> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
>> end of this month.
>
> If anyone on this list has a patch that is still waiting for approval or
> further comments, now would be a good time to ping.
Rats. I wish I had noticed this earlier:- I'm just catching up with
my emacs-devel backlog. How about this patch? I've been running with
it for awhile. Maybe the default value should be t for Windows
systems?
2008-07-30 John Paul Wallington <jpw@pobox.com>
* minibuf.c (read_buffer_completion_ignore_case): New variable.
(syms_of_minibuf): Declare and initialise it.
(Fread_buffer): Bind `completion-ignore-case' to respect it.
Index: src/minibuf.c
===================================================================
RCS file: /sources/emacs/emacs/src/minibuf.c,v
retrieving revision 1.354
diff -u -r1.354 minibuf.c
--- src/minibuf.c 10 Jun 2008 18:41:01 -0000 1.354
+++ src/minibuf.c 30 Jul 2008 00:34:44 -0000
@@ -109,6 +109,9 @@
/* Function to call to read a buffer name. */
Lisp_Object Vread_buffer_function;
+/* Nonzero means completion ignores case when reading buffer name. */
+int read_buffer_completion_ignore_case;
+
/* Nonzero means completion ignores case. */
int completion_ignore_case;
@@ -1178,17 +1181,25 @@
If DEF is a list of default values, return its first element.
If optional third arg REQUIRE-MATCH is non-nil,
only existing buffer names are allowed.
-The argument PROMPT should be a string ending with a colon and a space. */)
+The argument PROMPT should be a string ending with a colon and a space.
+
+See also `read-buffer-completion-ignore-case' and `read-buffer-function'. */)
(prompt, def, require_match)
Lisp_Object prompt, def, require_match;
{
Lisp_Object args[4];
+ Lisp_Object tem;
unsigned char *s;
int len;
+ int count = SPECPDL_INDEX ();
+
if (BUFFERP (def))
def = XBUFFER (def)->name;
-
+
+ specbind (Qcompletion_ignore_case,
+ read_buffer_completion_ignore_case ? Qt : Qnil);
+
if (NILP (Vread_buffer_function))
{
if (!NILP (def))
@@ -1218,9 +1229,9 @@
prompt = Fformat (3, args);
}
- return Fcompleting_read (prompt, intern ("internal-complete-buffer"),
- Qnil, require_match, Qnil, Qbuffer_name_history,
- def, Qnil);
+ tem = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
+ Qnil, require_match, Qnil, Qbuffer_name_history,
+ def, Qnil);
}
else
{
@@ -1228,8 +1239,9 @@
args[1] = prompt;
args[2] = def;
args[3] = require_match;
- return Ffuncall(4, args);
+ tem = Ffuncall(4, args);
}
+ return unbind_to (count, tem);
}
\f
static Lisp_Object
@@ -2111,6 +2123,10 @@
doc: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
Vread_buffer_function = Qnil;
+ DEFVAR_BOOL ("read-buffer-completion-ignore-case", &read_buffer_completion_ignore_case,
+ doc: /* *Non-nil means when reading a buffer name completion ignores case. */);
+ read_buffer_completion_ignore_case = 0;
+
DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
doc: /* Normal hook run just after entry to minibuffer. */);
Vminibuffer_setup_hook = Qnil;
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-21 4:49 ` Chong Yidong
` (3 preceding siblings ...)
2008-07-31 0:56 ` New `read-buffer-completion-ignore-case' variable? [was Re: Release plans] John Paul Wallington
@ 2008-07-31 2:10 ` Bastien
2008-07-31 2:43 ` Chong Yidong
4 siblings, 1 reply; 42+ messages in thread
From: Bastien @ 2008-07-31 2:10 UTC (permalink / raw
To: emacs-devel; +Cc: Chong Yidong, Lennart Borgman
[-- Attachment #1: Type: text/plain, Size: 986 bytes --]
Chong Yidong <cyd@stupidchicken.com> writes:
>> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
>> end of this month.
>
> If anyone on this list has a patch that is still waiting for approval or
> further comments, now would be a good time to ping.
A long time ago, Lennart proposed to integrate a library implementing an
easy way for resizing windows. See email <47BF64AF.1000105@gmail.com>
on [emacs-devel] to jump back into this discussion.
I attach the last version I'm aware of (0.96) of Lennart's windsize.el
-- maybe this is not the latest version, Lennart can you confirm?
As I had a slightly different approach and I coded windresize.el:
http://www.cognition.ens.fr/~guerry/u/windresize.el
Maybe one of these libraries could be part of Emacs at some point.
You might also want to have a look at register-list.el, which let the
user get a list of the registers, delete and edit them:
http://www.cognition.ens.fr/~guerry/u/register-list.el
[-- Attachment #2: windsize.el --]
[-- Type: text/plain, Size: 42888 bytes --]
;;; winsize.el --- Interactive window structure editing
;;
;; Author: Lennart Borgman <lennart dot borgman at gmail dot com >
;; Maintainer:
;; Created: Wed Dec 07 15:35:09 2005
;; Version: 0.96
;; Lxast-Updated: Sun Nov 18 02:14:52 2007 (3600 +0100)
;; Keywords:
;; Compatibility:
;;
;; Fxeatures that might be required by this library:
;;
;; None
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; This file contains functions for interactive resizing of Emacs
;; windows. To use it put it in your `load-path' and add the following
;; to your .emacs:
;;
;; (require 'winsize)
;; (global-set-key [(control x) ?+] 'resize-windows)
;;
;; For more information see `resize-windows'.
;;
;; These functions are a slightly rewritten version of the second part
;; of the second part my proposal for a new `balance-windows' function
;; for Emacs 22. The rewrite is mostly a restructure to more easily
;; add new functions. All functions and variables have been renamed.
;; The file was originally named bw-interactive.el.
;;
;; New ideas for functionality have been to a large part adopted from
;; the Emacs Devel mailing list. Probably most of them originated from
;; Drew Adams and Bastien.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Change log:
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;;
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;;
;; You should have received a copy of the GNU General Public License
;; along with this program; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; TODO: Change mouse pointer shape during resizing.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Code:
;;; Keymap, interactive functions etc
(defvar winsize-keymap nil
"Keymap used by `resize-windows'.")
(defun winsize-make-keymap (let-me-use)
"Build the keymap that should be used by `winsize-keymap'."
(let ((map (make-sparse-keymap "Window Resizing")))
(define-key map [menu-bar bw]
(cons "Resize" (make-sparse-keymap "second")))
(define-key map [menu-bar bw fit]
'("Fit Window to Buffer" . fit-window-to-buffer))
(define-key map [menu-bar bw fit]
'("Shring Window to Buffer" . shrink-window-if-larger-than-buffer))
(define-key map [menu-bar bw siblings]
'("Balance Window Siblings" . winsize-balance-siblings))
(define-key map [menu-bar bw balance]
'("Balance Windows" . balance-windows))
(define-key map [?+] 'balance-windows)
(define-key map [?.] 'winsize-balance-siblings)
(define-key map [?=] 'fit-window-to-buffer)
(define-key map [?-] 'shrink-window-if-larger-than-buffer)
(define-key map [(up)] 'winsize-move-border-up)
(define-key map [(down)] 'winsize-move-border-down)
(define-key map [(left)] 'winsize-move-border-left)
(define-key map [(right)] 'winsize-move-border-right)
(define-key map [(shift up)] 'winsize-move-other-border-up)
(define-key map [(shift down)] 'winsize-move-other-border-down)
(define-key map [(shift left)] 'winsize-move-other-border-left)
(define-key map [(shift right)] 'winsize-move-other-border-right)
(define-key map [(meta left)] 'winsize-to-border-or-window-left)
(define-key map [(meta up)] 'winsize-to-border-or-window-up)
(define-key map [(meta right)] 'winsize-to-border-or-window-right)
(define-key map [(meta down)] 'winsize-to-border-or-window-down)
(define-key map [?0] 'delete-window)
(define-key map [?1] 'delete-other-windows)
(define-key map [?2] 'split-window-vertically)
(define-key map [?3] 'split-window-horizontally)
(define-key map [?4] 'other-window)
(define-key map [?!] 'winsize-save-window-configuration)
(define-key map [?>] 'winsize-next-window-configuration)
(define-key map [?<] 'winsize-previous-window-configuration)
;; Fix-me: These keys could also be set to nil
(define-key map [mouse-1] 'mouse-set-point)
;;(define-key map [down-mouse-1] 'mouse-set-point)
(define-key map [(mode-line) (down-mouse-1)] 'mouse-drag-mode-line)
(define-key map [(vertical-line) (down-mouse-1)] 'mouse-drag-vertical-line)
(define-key map [(vertical-scroll-bar) (mouse-1)] 'scroll-bar-toolkit-scroll)
(define-key map [??] 'winsize-help)
(define-key map [(control ?g)] 'winsize-quit)
(define-key map [(control return)] 'winsize-stop-go-back)
(define-key map [(return)] 'winsize-stop)
(define-key map [t] 'winsize-stop-and-execute)
(dolist (ks let-me-use)
(if (and (not (vectorp ks))
(not (stringp ks))
(commandp ks))
(let ((ks-list (where-is-internal ks)))
(dolist (ks ks-list)
(unless (lookup-key map ks)
(define-key map ks nil))))
(unless (lookup-key map ks)
(define-key map ks nil))))
(setq winsize-keymap map)))
(defun winsize-pre-command ()
"Do this before every command.
Runs this in `pre-command-hook'.
Remember the currently used border sides for resizing. Also
remember position in message buffer to be able to see if next
command outputs some message.
For more information see `winsize-post-command'."
(setq winsize-message-end (winsize-message-end))
(setq winsize-border-hor (winsize-border-used-hor))
(setq winsize-border-ver (winsize-border-used-ver)))
(defun winsize-post-command ()
"Done after every command.
Run this in `post-command-hook'.
Check the border sides \(left/right, up/down) remembered in
`winsize-pre-command' and use the the same side if possible,
otherwise the opposite side if that is possible. \(This check is
of course not done if the last command changed the border side.)
The reason for selecting borders this way is to try to give the
user a coherent and easy picture of what is going on when
changing window or when window structure is changed. \(Note that
the commands moving to another window or changing the window
structure does not have to belong to this package. Those commands
can therefore not select the border sides.)
Give the user feedback about selected window and borders. Also
give a short help message unless last command gave some message."
(unless juris-way
(unless winsize-border-hor
(winsize-select-initial-border-hor))
(when winsize-border-hor
(winsize-set-border winsize-border-hor t))
(unless winsize-border-ver
(winsize-select-initial-border-ver))
(when winsize-border-ver
(winsize-set-border winsize-border-ver t)))
(winsize-tell-user))
(defun resize-windows ()
"Start window resizing.
During resizing a window is selected. You can move its
borders (by default with the arrow keys) and you can select other
borders or windows (by default with Meta-arrow keys).
You can also do other window operations, like splitting, deleting
and balancing the sizes. The keybindings below describes the key
bindings during resizing:\\<winsize-keymap>
`balance-windows' \\[balance-windows]
`winsize-balance-siblings' \\[winsize-balance-siblings]
`fit-window-to-buffer' \\[fit-window-to-buffer]
`shrink-window-if-larger-than-buffer' \\[shrink-window-if-larger-than-buffer]
`winsize-move-border-up' \\[winsize-move-border-up]
`winsize-move-border-down' \\[winsize-move-border-down]
`winsize-move-border-left' \\[winsize-move-border-left]
`winsize-move-border-right' \\[winsize-move-border-right]
`winsize-to-border-or-window-left' \\[winsize-to-border-or-window-left]
`winsize-to-border-or-window-up' \\[winsize-to-border-or-window-up]
`winsize-to-border-or-window-right' \\[winsize-to-border-or-window-right]
`winsize-to-border-or-window-down' \\[winsize-to-border-or-window-down]
Note that you can also use your normal keys for
`forward-char', `backward-char', `next-line', `previous-line'
and what you have on HOME and END to move in the windows. That
might sometimes be necessary to directly select a
window. \(You may however also use `other-window' or click
with the mouse, see below.)
`delete-window' \\[delete-window]
`delete-other-windows' \\[delete-other-windows]
`split-window-vertically' \\[split-window-vertically]
`split-window-horizontally' \\[split-window-horizontally]
`other-window' \\[other-window]
`winsize-save-window-configuration' \\[winsize-save-window-configuration]
`winsize-next-window-configuration' \\[winsize-next-window-configuration]
`winsize-previous-window-configuration' \\[winsize-previous-window-configuration]
`mouse-set-point' \\[mouse-set-point]
`winsize-quit' \\[winsize-quit]
`winsize-stop-go-back' \\[winsize-stop-go-back]
`winsize-stop' \\[winsize-stop]
`winsize-stop-and-execute' \\[winsize-stop-and-execute]
`winsize-help' \\[winsize-help]
`describe-key' \\[describe-key]
`describe-key-briefly' \\[describe-key-briefly]
(All the normal help keys work, and it least those above will
play well with resizing.)
Nearly all other keys exits window resizing and they are also
executed. However, the key sequences in `winsize-let-me-use' and
dito for commands there are also executed without exiting
resizing.
The colors of the modelines are changed to those given in
`winsize-mode-line-colors' to indicate that you are resizing
windows. To make this indication more prominent the text in the
selected window is marked with the face hold in the variable
`winsize-selected-window-face'.
As you select other borders or move to new a window the mouse
pointer is moved inside the selected window to show which borders
are beeing moved. The mouse jumps a little bit to make its
position more visible. You can turn this off by customizing
`winsize-make-mouse-prominent'.
Which borders initially are choosen are controlled by the
variable `winsize-autoselect-borders'.
** Example: Border selection, movements and windows.
Suppose you have a frame divided into windows like in the
figure below. If window B is selected when you start resizing
then \(with default settings) the borders marked with 'v' and
'h' will be the ones that the arrow keys moves. To indicate
this the mouse pointer is placed in the right lower corner of
the selected window B.
+----------+-----------+--------+
| | v |
| | v |
| A | _B_ v |
| | v |
| | v |
| | x v |
+hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
| | |
| | |
| | |
| | |
| | |
| | |
+----------+---------+----------+
Now if you press M-<left> then the picture below shows what has
happened. Note that the selected vertical border is now the one
between A and B. The mouse pointer has moved to the
corresponding corner in the window B, which is still selected.
+----------+-----------+--------+
| v | |
| v | |
| A v _B_ | |
| v | |
| v | |
| v x | |
+hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
| | |
| | |
| | |
| | |
| | |
| | |
+----------+---------+----------+
Press M-<left> once again. This gives this picture:
+----------+-----------+--------+
| v | |
| v | |
| _A_ v B | |
| v | |
| v | |
| x v | |
+hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
| | |
| | |
| | |
| | |
| | |
| | |
+----------+---------+----------+
Note that the window A is now selected. However there is no
border that could be moved to the left of this window \(which
would otherwise be chosen now) so the border between A and B is
still the one that <left> and <right> moves. The mouse has
moved to A.
If we now delete window A the new situation will look like
this:
+----------+-----------+--------+
| | |
| | |
| _B_ | |
| | |
| | |
| x | |
+hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
| | |
| | |
| | |
| | |
| | |
| | |
+----------+---------+----------+
>>>> testing stuff >>>>
`help-mode-hook'
`temp-buffer-show-function'
`view-exit-action'
<<<<<<<<<<<<<<<<<<<<<<<
"
(interactive)
(setq winsize-resizing t)
;; Save old values:
(unless winsize-old-temp-buffer-show-function
(when (eq temp-buffer-show-function 'winsize-temp-buffer-show-function)
(error "temp buffer show function is winsize value"))
(when (eq temp-buffer-show-function 'winsize-temp-buffer-show-function-1)
(error "temp buffer show function is winsize value -1"))
(setq winsize-old-temp-buffer-show-function temp-buffer-show-function))
(unless winsize-old-mouse-avoidance-mode
(setq winsize-old-mouse-avoidance-mode mouse-avoidance-mode))
;; Setup help hooks etc:
(setq temp-buffer-show-function 'winsize-temp-buffer-show-function)
;; Setup user feedback things:
(mouse-avoidance-mode 'none)
(winsize-set-mode-line-colors t)
(winsize-create-short-help-message)
(setq winsize-message-end (winsize-message-end))
;; Save config for exiting:
(setq winsize-window-config-init (current-window-configuration))
(setq winsize-window-at-entry (selected-window))
(setq winsize-frame (selected-frame))
;; Setup keymap and command hooks etc:
(winsize-setup-local-map)
(winsize-add-command-hooks)
(setq winsize-window-for-side-hor nil)
(setq winsize-window-for-side-ver nil))
(defun winsize-setup-local-map ()
"Setup an overriding keymap and use this during resizing.
Save current keymaps."
;; Fix-me: use copy-keymap for old?
(unless winsize-old-overriding-terminal-local-map
(setq winsize-old-overriding-terminal-local-map overriding-terminal-local-map))
(setq overriding-terminal-local-map (copy-keymap winsize-keymap))
(setq winsize-old-overriding-local-map-menu-flag overriding-local-map-menu-flag)
(setq overriding-local-map-menu-flag t))
(defun winsize-restore-local-map ()
"Restore keymaps saved by `winsize-setup-local-map'."
(setq overriding-terminal-local-map winsize-old-overriding-terminal-local-map)
(setq winsize-old-overriding-terminal-local-map nil)
(setq overriding-local-map-menu-flag winsize-old-overriding-local-map-menu-flag)
(setq winsize-old-overriding-local-map-menu-flag nil))
(defvar winsize-window-config-init nil
"Hold window configuration from resizing start.")
(defvar winsize-window-config-help nil
"Hold window configuration when help is shown.")
(defvar winsize-window-config-init-help nil
"Hold window configuration from resizing start during help.")
(defun winsize-restore-after-help (buffer)
"Restore window configuration after help.
Raise frame and reactivate resizing."
(remove-hook 'temp-buffer-setup-hook 'winsize-help-mode-hook-function)
(setq temp-buffer-show-function winsize-old-temp-buffer-show-function)
;; Get rid of the view exit action and the extra text in the help
;; buffer:
(with-current-buffer (help-buffer)
(setq view-exit-action winsize-old-view-exit-action)
(setq winsize-old-view-exit-action nil)
(let ((here (point-marker))
(inhibit-read-only t))
(goto-char (point-min))
(forward-line 2)
(delete-region (point-min) (point))
(goto-char (point-max))
(forward-line -2)
(delete-region (point) (point-max))
(goto-char here)))
;; Restart resizing, restoring window configurations:
(when (select-frame winsize-help-frame)
(raise-frame)
(set-window-configuration winsize-window-config-help)
(resize-windows)
(setq winsize-window-config-init winsize-window-config-init-help)))
(defvar winsize-help-frame nil
"The frame from which help was called.")
(defun winsize-help-mode-hook-function ()
"Setup temp buffer show function to only run second step.
The first step, `winsize-temp-buffer-show-function', has already been run."
(setq temp-buffer-show-function 'winsize-temp-buffer-show-function-1))
(defun winsize-temp-buffer-show-function (buffer)
"First step of setup for showing help during resizing.
This step is run when showing help during resizing.
Save window configuration etc to be able to resume resizing. Stop
resizing. Delete other windows.
Run second step (`winsize-temp-buffer-show-function-1') and
arrange so that second step is run when following help links."
(setq winsize-window-config-help (current-window-configuration))
(setq winsize-window-config-init-help winsize-window-config-init)
(setq winsize-help-frame (selected-frame))
(winsize-stop)
(delete-other-windows)
(winsize-temp-buffer-show-function-1 buffer)
(add-hook 'temp-buffer-setup-hook 'winsize-help-mode-hook-function))
(defun winsize-temp-buffer-show-function-1 (buffer)
"Second step of setup for showing help during resizing.
This is run after the first step when accessing help during
resizing. It is also when following help links."
(with-current-buffer buffer
(let ((inhibit-read-only t)
(buffer-read-only t) ;; It is reverted in `help-mode-finish'
)
(run-hooks 'temp-buffer-show-hook))
(let ((here (point-marker))
(str "*** Type q to return to window resizing ***"))
(put-text-property 0 (length str) 'face 'highlight str)
(goto-char (point-min))
(insert str "\n\n")
(goto-char (point-max))
(insert "\n\n" str)
(goto-char here)
(setq buffer-read-only t))
(unless winsize-old-view-exit-action
(setq winsize-old-view-exit-action view-exit-action))
(setq view-exit-action 'winsize-restore-after-help))
(set-window-buffer (selected-window) buffer)
(message "Type q to return to window resizing"))
;; Fix-me: Maybe take care of popup help too.
(defun winsize-help ()
"Give help during resizing.
Save current window configuration and pause resizing."
(interactive)
(with-output-to-temp-buffer (help-buffer)
(with-current-buffer (help-buffer)
(insert "resize-windows is ")
(describe-function-1 'resize-windows))))
(defun winsize-quit ()
"Quit resing, restore window configuration at start."
(interactive)
(set-window-configuration winsize-window-config-init)
(winsize-exit-resizing nil))
(defun winsize-stop-go-back ()
"Exit window resizing. Go back to the window started in."
(interactive)
(winsize-exit-resizing nil t))
(defun winsize-stop-and-execute ()
"Exit window resizing and put last key on the input queue.
Select the window marked during resizing before putting back the
last key."
;; Fix-me: maybe replace this with a check of this-command in
;; post-command-hook instead?
(interactive)
(winsize-exit-resizing t))
(defun winsize-stop ()
"Exit window resizing.
Select the window marked during resizing."
(interactive)
(winsize-exit-resizing nil))
(defun winsize-balance-siblings ()
"Make current window siblings the same height or width.
It works the same way as `balance-windows', but only for the
current window and its siblings."
(interactive)
(balance-windows (selected-window)))
(defun winsize-to-border-or-window-left ()
"Switch to border leftwards, maybe moving to next window.
If already at the left border, then move to left window, the same
way `windmove-left' does."
(interactive) (winsize-switch-border 'left t))
(defun winsize-to-border-or-window-right ()
"Switch to border rightwards, maybe moving to next window.
For more information see `winsize-to-border-or-window-left'."
(interactive) (winsize-switch-border 'right t))
(defun winsize-to-border-or-window-up ()
"Switch to border upwards, maybe moving to next window.
For more information see `winsize-to-border-or-window-left'."
(interactive) (winsize-switch-border 'up t))
(defun winsize-to-border-or-window-down ()
"Switch to border downwards, maybe moving to next window.
For more information see `winsize-to-border-or-window-left'."
(interactive) (winsize-switch-border 'down t))
(defun winsize-move-border-left ()
"Move border left, but select border first if not done."
(interactive) (winsize-resize 'left nil))
(defun winsize-move-border-right ()
"Move border right, but select border first if not done."
(interactive) (winsize-resize 'right nil))
(defun winsize-move-border-up ()
"Move border up, but select border first if not done."
(interactive) (winsize-resize 'up nil))
(defun winsize-move-border-down ()
"Move border down, but select border first if not done."
(interactive) (winsize-resize 'down nil))
(defun winsize-move-other-border-left ()
"Move border left, but select border first if not done."
(interactive) (winsize-resize 'left t))
(defun winsize-move-other-border-right ()
"Move border right, but select border first if not done."
(interactive) (winsize-resize 'right t))
(defun winsize-move-other-border-up ()
"Move border up, but select border first if not done."
(interactive) (winsize-resize 'up t))
(defun winsize-move-other-border-down ()
"Move border down, but select border first if not done."
(interactive) (winsize-resize 'down t))
;;; Custom variables
(defcustom winsize-autoselect-borders t
"Determines how borders are selected by default.
If nil hever select borders automatically (but keep them on the
same side while changing window). If 'when-single select border
automatically if there is only one possible choice. If t alwasy
select borders automatically if they are not selected."
:type '(choice (const :tag "Always" t)
(const :tag "When only one possbility" when-single)
(const :tag "Never" nil))
:group 'winsize)
(defcustom winsize-mode-line-colors (list t (list "green" "green4"))
"Mode line colors used during resizing."
:type '(list (boolean :tag "Enable mode line color changes during resizing")
(list
(color :tag "- Active window mode line color")
(color :tag "- Inactive window mode line color")))
:group 'winsize)
(defcustom winsize-mark-selected-window t
"Mark selected window if non-nil."
:type 'boolean
:group 'winsize)
(defcustom winsize-make-mouse-prominent t
"Try to make mouse more visible during resizing.
The mouse is positioned next to the borders that you can move.
It can however be hard to see if where it is. Setting this to on
makes the mouse jump a few times."
:type 'boolean
:group 'winsize)
(defvar widget-command-prompt-value-history nil
"History of input to `widget-function-prompt-value'.")
(define-widget 'command 'restricted-sexp
"A Lisp function."
:complete-function (lambda ()
(interactive)
(lisp-complete-symbol 'commandp))
:prompt-value 'widget-field-prompt-value
:prompt-internal 'widget-symbol-prompt-internal
:prompt-match 'commandp
:prompt-history 'widget-command-prompt-value-history
:action 'widget-field-action
:match-alternatives '(commandp)
:validate (lambda (widget)
(unless (commandp (widget-value widget))
(widget-put widget :error (format "Invalid command: %S"
(widget-value widget)))
widget))
:value 'ignore
:tag "Command")
(defcustom winsize-let-me-use '(next-line ;;[(control ?n)]
previous-line ;;[(control ?p)]
forward-char ;;[(control ?f)]
backward-char ;;[(control ?b)]
[(home)]
[(end)]
;; Fix-me: replace this with something
;; pulling in help-event-list:
[(f1)]
execute-extended-command
eval-expression)
"Key sequences or commands that should not be overriden during resize.
The purpose is to make it easier to switch windows. The functions
`windmove-left' etc depends on the position when chosing the
window to move to."
:type '(repeat
(choice
;; Note: key-sequence must be before command here, since
;; the key sequences seems to match command too.
key-sequence command))
:set (lambda (sym val)
(set-default sym val)
(winsize-make-keymap val))
:group 'winsize)
(defcustom winsize-selected-window-face 'winsize-selected-window-face
"Variable holding face for marking selected window.
This variable may be nil or a face symbol."
:type '(choice (const :tag "Do not mark selected window" nil)
face)
:group 'winsize)
(defface winsize-selected-window-face
'((t (:inherit 'secondary-selection)))
"Face for marking selected window."
:group 'winsize)
;;; Internals
;; These variables all holds values to be reset when exiting resizing:
(defvar winsize-old-mode-line-bg nil)
(defvar winsize-old-mode-line-inactive-bg nil)
(defvar winsize-old-overriding-terminal-local-map nil)
(defvar winsize-old-overriding-local-map-menu-flag nil)
(defvar winsize-old-temp-buffer-show-function nil)
(defvar winsize-old-mouse-avoidance-mode nil
"Hold the value of `mouse-avoidance-mode' at resizing start.")
(defvar winsize-old-view-exit-action nil)
(make-variable-buffer-local 'winsize-old-view-exit-action)
(defvar winsize-resizing nil
"t during resizing, nil otherwise.")
(defvar winsize-window-at-entry nil
"Window that was selected when `resize-windows' started.")
(defvar winsize-frame nil
"Frame that `resize-windows' is operating on.")
(defun winsize-exit-resizing (put-back-last-event &optional stay)
"Stop window resizing.
Put back mode line colors and keymaps that were changed.
Upon exit first select window. If STAY is non-nil then select
the window which was selected when `resize-windows' was called,
otherwise select the last window used during resizing. After
that, if PUT-BACK-LAST-EVENT is non-nil, put back the last input
event on the input queue."
(setq winsize-resizing nil)
;; Reset user feedback things:
(mouse-avoidance-mode winsize-old-mouse-avoidance-mode)
(setq winsize-old-mouse-avoidance-mode nil)
(winsize-set-mode-line-colors nil)
(winsize-mark-selected-window nil)
;; Remove all hooks etc for help:
(when (eq winsize-old-temp-buffer-show-function 'winsize-temp-buffer-show-function)
(error "winsize old temp buffer function is winsize value"))
(when (eq winsize-old-temp-buffer-show-function 'winsize-temp-buffer-show-function-1)
(error "winsize old temp buffer function is winsize value -1"))
(setq temp-buffer-show-function winsize-old-temp-buffer-show-function)
(setq winsize-old-temp-buffer-show-function nil)
(remove-hook 'help-mode-hook 'winsize-help-mode-hook-function)
(remove-hook 'temp-buffer-setup-hook 'winsize-help-mode-hook-function)
;; Restore keymap and command hooks:
(winsize-restore-local-map)
(winsize-remove-command-hooks)
;; Exit:
(when stay (select-window winsize-window-at-entry))
(message "Exited window resizing")
(when (and put-back-last-event)
;; Add this to the input queue again:
(isearch-unread last-command-event)))
(defun winsize-add-command-hooks ()
(add-hook 'pre-command-hook 'winsize-pre-command)
(add-hook 'post-command-hook 'winsize-post-command))
(defun winsize-remove-command-hooks ()
(remove-hook 'pre-command-hook 'winsize-pre-command)
(remove-hook 'post-command-hook 'winsize-post-command))
;;; Borders
(defvar winsize-window-for-side-hor nil
"Window used internally for resizing in vertical direction.")
(defvar winsize-window-for-side-ver nil
"Window used internally for resizing in horizontal direction.")
(defvar winsize-border-hor nil
"Use internally to remember border choice.
This is set by `winsize-pre-command' and checked by
`winsize-post-command', see the latter for more information.
The value should be either nil, 'left or 'right.")
(defvar winsize-border-ver nil
"Use internally to remember border choice.
This is set by `winsize-pre-command' and checked by
`winsize-post-command', see the latter for more information.
The value should be either nil, 'up or 'down.")
(defun winsize-border-used-hor()
"Return the border side used for horizontal resizing."
(let ((hor (when winsize-window-for-side-hor
(if (eq (selected-window) winsize-window-for-side-hor)
'right
'left))))
hor))
(defun winsize-border-used-ver()
"Return the border side used for vertical resizing."
(let ((ver (when winsize-window-for-side-ver
(if (eq (selected-window) winsize-window-for-side-ver)
'down
'up))))
ver))
(defun winsize-switch-border (dir allow-windmove)
"Switch border that is beeing resized.
Switch to border in direction DIR. If ALLOW-WINDMOVE is non-nil
then change window if necessary, otherwise stay and do not change
border."
(let* ((window-in-that-dir (windmove-find-other-window
dir nil (selected-window))))
(when (window-minibuffer-p window-in-that-dir)
(setq window-in-that-dir nil))
(if juris-way
(if (not window-in-that-dir)
(message "No window in that direction")
(windmove-do-window-select dir nil))
(if (not window-in-that-dir)
(message "No window or border in that direction")
(let* ((is-hor (memq dir '(left right)))
(border-used (if is-hor
(winsize-border-used-hor)
(winsize-border-used-ver)))
(using-dir-border (eq dir border-used)))
(if using-dir-border
(when allow-windmove
(setq winsize-window-for-side-hor nil)
(setq winsize-window-for-side-ver nil)
(windmove-do-window-select dir nil)
(message "Moved to new window"))
(winsize-select-border dir)
(message "Switched to border %swards" dir)))))))
(defun winsize-select-initial-border-hor ()
"Select a default border horizontally."
(if juris-way
(winsize-set-border 'right t)
(let ((has-left (winsize-window-beside (selected-window) 'left))
(has-right (winsize-window-beside (selected-window) 'right)))
(cond
((not winsize-autoselect-borders) t)
((eq winsize-autoselect-borders 'when-single)
(when (= 1 (length (delq nil (list has-left has-right))))
(winsize-select-border 'right)))
(t
(winsize-select-border 'right))))))
(defun winsize-select-initial-border-ver ()
"Select a default border vertically."
(if juris-way
(winsize-set-border 'up t)
(let ((has-up (winsize-window-beside (selected-window) 'up))
(has-down (winsize-window-beside (selected-window) 'down)))
(cond
((not winsize-autoselect-borders) t)
((eq winsize-autoselect-borders 'when-single)
(when (= 1 (length (delq nil (list has-up has-down))))
(winsize-select-border 'up)))
(t
(winsize-select-border 'up))))))
(defun winsize-select-border (dir)
"Select border to be set for resizing.
The actually setting is done in `post-command-hook'."
(cond
((memq dir '(left right))
(setq winsize-border-hor dir))
((memq dir '(up down))
(setq winsize-border-ver dir))
(t (error "Bad DIR=%s" dir))))
(defun winsize-set-border (dir allow-other-side)
"Set border for resizing."
(let ((window-beside (winsize-window-beside (selected-window) dir))
(horizontal (memq dir '(left right))))
(unless window-beside
(when allow-other-side
(setq dir (winsize-other-side dir))
(setq window-beside
(winsize-window-beside (selected-window) dir))))
(if horizontal
(progn
(setq winsize-border-hor nil)
(setq winsize-window-for-side-hor nil))
(setq winsize-border-ver nil)
(setq winsize-window-for-side-ver nil))
(when window-beside
(let ((window-for-side (if (memq dir '(right down))
(selected-window)
window-beside)))
(if horizontal
(setq winsize-window-for-side-hor window-for-side)
(setq winsize-window-for-side-ver window-for-side))))))
(defcustom juris-way t
""
:type 'boolean)
(defun winsize-resize (dir other-side)
"Choose border to move. Or if border is chosen move that border.
Used by `winsize-move-border-left' etc."
(when juris-way
(let ((bside (if (memq dir '(left right))
(if other-side 'left 'right)
(if other-side 'up 'down))))
(winsize-set-border bside t)))
(let* ((horizontal (memq dir '(left right)))
(arg (if (memq dir '(left up)) -1 1))
(window-for-side (if horizontal 'winsize-window-for-side-hor 'winsize-window-for-side-ver))
(window-for-side-val (symbol-value window-for-side)))
(if (not window-for-side-val)
(winsize-select-border dir)
(when (and winsize-resizing
(not (eq window-for-side-val 'checked)))
(condition-case err
(adjust-window-trailing-edge (symbol-value window-for-side) arg horizontal)
(error (message "%s" (error-message-string err))))))))
(defun winsize-other-side (side)
"Return other side for 'left etc, ie 'left => 'right."
(cond
((eq side 'left) 'right)
((eq side 'right) 'left)
((eq side 'up) 'down)
((eq side 'down) 'up)
(t (error "Invalid SIDE=%s" side))))
(defun winsize-window-beside (window side)
"Return a window directly beside WINDOW at side SIDE.
That means one whose edge on SIDE is touching WINDOW. SIDE
should be one of 'left, 'up, 'right and 'down."
(require 'windmove)
(let* ((windmove-wrap-around nil)
(win (windmove-find-other-window side nil window)))
(unless (window-minibuffer-p win)
win)))
;;; Window configs
(defconst winsize-window-configuration-ring (make-ring 20)
"Hold window configurations.")
(defun winsize-ring-rotate (ring forward)
(when (< 1 (ring-length ring))
(if forward
(ring-insert ring (ring-remove ring nil))
(ring-insert-at-beginning ring (ring-remove ring 0)))))
(defun winsize-ring-index (ring elem)
(let ((memb (member elem (ring-elements ring))))
(when memb
(- (ring-length ring)
(length memb)))))
(defun winsize-previous-window-configuration ()
(interactive)
(winsize-goto-window-configuration nil))
(defun winsize-next-window-configuration ()
(interactive)
(winsize-goto-window-configuration t))
(defun winsize-goto-window-configuration (forward)
(let* ((curr-conf (current-window-configuration))
(ring winsize-window-configuration-ring)
(idx (winsize-ring-index ring curr-conf)))
(if idx
(progn
(setq idx (if forward (1- idx) (1+ idx)))
(set-window-configuration (ring-ref ring idx)))
;; Unfortunately idx often seems to be nil so we will have to
;; rotate the ring (or something similar).
(winsize-ring-rotate ring forward)
(set-window-configuration (ring-ref ring 0)))))
(defun winsize-save-window-configuration ()
(interactive)
(let* ((curr-conf (current-window-configuration))
(ring winsize-window-configuration-ring))
(if (winsize-ring-index ring curr-conf)
(error "Current configuration was already stored")
(ring-insert ring curr-conf)
(message "Saved window config, use '<' or '>' to get it back"))))
;;; User feedback
(defun winsize-set-mode-line-colors (on)
"Turn mode line colors on if ON is non-nil, otherwise off."
(if on
(progn
(unless winsize-old-mode-line-inactive-bg
(setq winsize-old-mode-line-inactive-bg (face-attribute 'mode-line-inactive :background)))
(unless winsize-old-mode-line-bg
(setq winsize-old-mode-line-bg (face-attribute 'mode-line :background)))
(let* ((use-colors (car winsize-mode-line-colors))
(colors (cadr winsize-mode-line-colors))
(active-color (elt colors 0))
(inactive-color (elt colors 1)))
(when use-colors
(set-face-attribute 'mode-line-inactive nil :background inactive-color)
(set-face-attribute 'mode-line nil :background active-color))))
(set-face-attribute 'mode-line-inactive nil :background winsize-old-mode-line-inactive-bg)
(setq winsize-old-mode-line-inactive-bg nil)
(set-face-attribute 'mode-line nil :background winsize-old-mode-line-bg)
(setq winsize-old-mode-line-bg nil)))
(defvar winsize-short-help-message nil
"Short help message shown in echo area.")
(defun winsize-create-short-help-message ()
"Create short help message to show in echo area."
(let ((msg ""))
(mapc (lambda (rec)
(let ((fun (elt rec 0))
(desc (elt rec 1))
(etc (elt rec 2)))
(when (< 0 (length msg))
(setq msg (concat msg ", ")))
(setq msg (concat msg
desc
":"
(key-description
(where-is-internal fun winsize-keymap t))
(if etc " etc" "")))))
'(
(balance-windows "balance" nil)
(winsize-move-border-left "resize" t)
(winsize-to-border-or-window-left "border" nil)
))
(setq msg (concat msg ", exit:RET, help:?"))
(setq winsize-short-help-message msg)))
(defun winsize-move-mouse-to-resized ()
"Move mouse to show which border(s) are beeing moved."
(let* ((edges (window-edges (selected-window)))
(L (nth 0 edges))
(T (nth 1 edges))
(R (nth 2 edges))
(B (nth 3 edges))
(x (/ (+ L R) 2))
(y (/ (+ T B) 2)))
(when (and winsize-window-for-side-hor
(not (eq winsize-window-for-side-hor 'checked)))
(setq x (if (eq (selected-window) winsize-window-for-side-hor) (- R 6) (+ L 2))))
(when (and winsize-window-for-side-ver
(not (eq winsize-window-for-side-ver 'checked)))
(setq y (if (eq (selected-window) winsize-window-for-side-ver) (- B 2) (+ T 0))))
(set-mouse-position (selected-frame) x y)))
(defvar winsize-selected-window-overlay nil)
(defun winsize-mark-selected-window (active)
(when winsize-selected-window-overlay
(delete-overlay winsize-selected-window-overlay)
(setq winsize-selected-window-overlay nil))
(when active
(with-current-buffer (window-buffer (selected-window))
(let ((ovl (make-overlay (point-min) (point-max))))
(setq winsize-selected-window-overlay ovl)
(overlay-put ovl 'window (selected-window))
(overlay-put ovl 'pointer 'arrow)
(overlay-put ovl 'priority 1000)
(when winsize-selected-window-face
(overlay-put ovl 'face winsize-selected-window-face))))))
(defvar winsize-message-end nil
"Marker, maybe at end of message buffer.")
(defun winsize-message-end ()
"Return a marker at the end of the message buffer."
(with-current-buffer (get-buffer-create "*Messages*")
(point-max-marker)))
(defvar winsize-move-mouse 1)
(defun winsize-move-mouse ()
;;(setq winsize-move-mouse (- winsize-move-mouse))
(let* ((fxy (mouse-pixel-position))
(f (car fxy))
(x (cadr fxy))
(y (cddr fxy))
(m (mod winsize-move-mouse 2))
(d (* (if (= 0 m) 1 -1) 1)))
(set-mouse-pixel-position f (+ d x) (+ d y))
(when (< 1 winsize-move-mouse)
(setq winsize-move-mouse (1- winsize-move-mouse))
(setq winsize-make-mouse-prominent-timer
(run-with-timer 0.2 nil 'winsize-move-mouse)))))
(defvar winsize-make-mouse-prominent-timer nil)
(defun winsize-make-mouse-prominent-f (doit)
(when (and winsize-make-mouse-prominent-timer
(timerp winsize-make-mouse-prominent-timer))
(cancel-timer winsize-make-mouse-prominent-timer))
(when doit
(setq winsize-move-mouse 3)
(setq winsize-make-mouse-prominent-timer
(run-with-idle-timer 0.1 nil 'winsize-move-mouse))))
(defun winsize-tell-user ()
"Give the user feedback."
(when winsize-mark-selected-window
(winsize-mark-selected-window t))
(unless juris-way
(let ((move-mouse (not (member this-command
'(mouse-drag-mode-line
mouse-drag-vertical-line
scroll-bar-toolkit-scroll)))))
;;(message "%s, move-mouse=%s" this-command move-mouse);(sit-for 2)
(when move-mouse
(winsize-move-mouse-to-resized))
(when winsize-make-mouse-prominent
(winsize-make-mouse-prominent-f move-mouse))))
(when (= winsize-message-end (winsize-message-end))
(message "%s" winsize-short-help-message)))
(provide 'winsize)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; winsize.el ends here
[-- Attachment #3: Type: text/plain, Size: 13 bytes --]
--
Bastien
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-31 2:10 ` Release plans Bastien
@ 2008-07-31 2:43 ` Chong Yidong
2008-07-31 8:06 ` Lennart Borgman (gmail)
0 siblings, 1 reply; 42+ messages in thread
From: Chong Yidong @ 2008-07-31 2:43 UTC (permalink / raw
To: Bastien; +Cc: Lennart Borgman, emacs-devel
Bastien <bastienguerry@googlemail.com> writes:
> A long time ago, Lennart proposed to integrate a library implementing an
> easy way for resizing windows. See email <47BF64AF.1000105@gmail.com>
> on [emacs-devel] to jump back into this discussion.
>
> I attach the last version I'm aware of (0.96) of Lennart's windsize.el
> -- maybe this is not the latest version, Lennart can you confirm?
>
> As I had a slightly different approach and I coded windresize.el:
>
> http://www.cognition.ens.fr/~guerry/u/windresize.el
>
> Maybe one of these libraries could be part of Emacs at some point.
Please ping again after the release.
Thanks.
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-31 2:43 ` Chong Yidong
@ 2008-07-31 8:06 ` Lennart Borgman (gmail)
2008-08-01 2:53 ` Bastien
0 siblings, 1 reply; 42+ messages in thread
From: Lennart Borgman (gmail) @ 2008-07-31 8:06 UTC (permalink / raw
To: Chong Yidong; +Cc: Bastien, emacs-devel
Chong Yidong wrote:
> Bastien <bastienguerry@googlemail.com> writes:
>
>> A long time ago, Lennart proposed to integrate a library implementing an
>> easy way for resizing windows. See email <47BF64AF.1000105@gmail.com>
>> on [emacs-devel] to jump back into this discussion.
>>
>> I attach the last version I'm aware of (0.96) of Lennart's windsize.el
>> -- maybe this is not the latest version, Lennart can you confirm?
Yes, it is correct. I distribute it as part of the nXhtml package.
>> As I had a slightly different approach and I coded windresize.el:
>>
>> http://www.cognition.ens.fr/~guerry/u/windresize.el
>>
>> Maybe one of these libraries could be part of Emacs at some point.
>
> Please ping again after the release.
>
> Thanks.
Will do.
Bastien, I guess we both dropped out because the ideas were getting too
many and too wild. Can we continue after the release with the ideas we
really feel fits?
^ permalink raw reply [flat|nested] 42+ messages in thread
* Re: Release plans
2008-07-31 8:06 ` Lennart Borgman (gmail)
@ 2008-08-01 2:53 ` Bastien
0 siblings, 0 replies; 42+ messages in thread
From: Bastien @ 2008-08-01 2:53 UTC (permalink / raw
To: Lennart Borgman (gmail); +Cc: Chong Yidong, emacs-devel
"Lennart Borgman (gmail)" <lennart.borgman@gmail.com> writes:
> Bastien, I guess we both dropped out because the ideas were getting too
> many and too wild. Can we continue after the release with the ideas we
> really feel fits?
Yes, sure. I have a small TODO list for windresize.el, I'd happily hack
it a bit when I'm done with my current project. Let's get back on this
in late september.
Best,
--
Bastien
^ permalink raw reply [flat|nested] 42+ messages in thread