Release plans

Release plans

[Chong Yidong]

Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
end of this month.

The original plan was to merge CEDET in time for the freeze.  However,
this isn't going to happen because of a delay in legal paperwork;
hopefully, CEDET will be included in 23.2.

Emacs.app (the new Cocoa port) will be merged sometime this week.

As for Emacs 22.3, bugfixes made to the trunk should be backported,
where safe and appropriate, to the Emacs 22 branch.  This backporting of
fixes will carry on throughout the Emacs 23 testing period, so that both
the trunk and the branch can benefit from the bugfixing effort.  If
things work out, we can make the Emacs 22.3 minor release during the
Emacs 23 pretest.  If you see an existing bugfix in the trunk that you
think should go into the Emacs 22 branch, please email the commiter with
a reminder to check it into the branch (or email emacs-devel).

I'd like to request volunteers for going through the Emacs 23
documentation.  The Emacs manual and Emacs Lisp manual need to be
updated with the information in etc/NEWS.  If you would like to help,
please email me.

Finally, if you are a naughty person who has not added a proper entry to
etc/NEWS for your new code, please do it as soon as possible (or ask
someone for help).

Thanks.

Re: Release plans

[Juri Linkov]

> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
> end of this month.
>
> The original plan was to merge CEDET in time for the freeze.  However,
> this isn't going to happen because of a delay in legal paperwork;
> hopefully, CEDET will be included in 23.2.

I have doubts that CEDET can be included in Emacs 23 without adding
more features because some parts have to be rewritten to be more clean
(like replacing defadvices with Emacs native features etc.)

Emacs 23.1 has enough major features, so maybe it makes sense to include
CEDET in the next major release after 23.1 with more related Emacs features
(like tabbed UI and others), and advertise it as Emacs IDE.

-- 
Juri Linkov
http://www.jurta.org/emacs/

Re: Release plans

[David Kastrup]

Juri Linkov <juri@jurta.org> writes:

>> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
>> end of this month.
>>
>> The original plan was to merge CEDET in time for the freeze.  However,
>> this isn't going to happen because of a delay in legal paperwork;
>> hopefully, CEDET will be included in 23.2.
>
> I have doubts that CEDET can be included in Emacs 23 without adding
> more features because some parts have to be rewritten to be more clean
> (like replacing defadvices with Emacs native features etc.)

"delay in legal paperwork" is ringing all my alarm bells.  Paper work
that won't get done in a month is not likely to get done in a year.  I
don't see that dropping the ball now will make it easier to pick it up
next time round.

> Emacs 23.1 has enough major features, so maybe it makes sense to
> include CEDET in the next major release after 23.1 with more related
> Emacs features (like tabbed UI and others), and advertise it as Emacs
> IDE.

I'd really much prefer if we could get this over with.

-- 
David Kastrup, Kriemhildstr. 15, 44793 Bochum

Re: Release plans

[Chong Yidong]

> 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.

Re: Release plans

[Thien-Thi Nguyen]

() 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.
  

Re: Release plans

[Chong Yidong]

Thien-Thi Nguyen <ttn@gnuvola.org> writes:

> Ping!  (I can't remember if this was accepted or not.)
>
> *** 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

Looks OK to me.  Go ahead and check it in.

Re: Release plans

[Thien-Thi Nguyen]

() Chong Yidong <cyd@stupidchicken.com>
() Mon, 21 Jul 2008 09:32:01 -0400

   Looks OK to me.  Go ahead and check it in.

OK, done.

thi

Re: Release plans

[Michael Albinus]

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/>

Re: Release plans

[Chong Yidong]

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).

xesam.el (was: Release plans)

[Michael Albinus]

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.

Re: Release plans

[Eli Zaretskii]

> 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.

Re: Release plans

[Richard M Stallman]

    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?

Re: Release plans

[Eli Zaretskii]

> 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.

Re: Release plans

[Richard M Stallman]

    > 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.

Re: Release plans

[Eli Zaretskii]

> 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.

Re: Release plans

[Richard M Stallman]

    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?

Re: Release plans

[Eli Zaretskii]

> 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.

Re: Release plans

[Richard M Stallman]

    > 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?

Re: Release plans

[Eli Zaretskii]

> 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.

Re: Release plans

[Juri Linkov]

>> > 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/

Re: Release plans

[Chong Yidong]

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.

Re: Release plans

[Juri Linkov]

>> 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/

Re: Release plans

[Chong Yidong]

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.

Re: Release plans

[Stefan Monnier]

> 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

Re: Release plans

[Roland Winkler]

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

Re: Release plans

[Eli Zaretskii]

> 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.

Re: Release plans

[Eli Zaretskii]

> 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.

Re: Release plans

[Juanma Barranquero]

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

Re: Release plans

[Eli Zaretskii]

> 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.

New `read-buffer-completion-ignore-case' variable? [was Re: Release plans]

[John Paul Wallington]

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;

Re: New `read-buffer-completion-ignore-case' variable?

[Chong Yidong]

jpw@pobox.com (John Paul Wallington) writes:

> Rats.  I wish I had noticed this earlier:- I'm just catching up with
> my emacs-devel backlog.  How about this patch?

Looks OK.  Checked in.

Re: New `read-buffer-completion-ignore-case' variable?

[John Paul Wallington]

Chong Yidong <cyd@stupidchicken.com> writes:

> jpw@pobox.com (John Paul Wallington) writes:
>
>> Rats.  I wish I had noticed this earlier:- I'm just catching up with
>> my emacs-devel backlog.  How about this patch?
>
> Looks OK.  Checked in.

Thanks!

Re: Release plans

[Bastien]

[-- 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

Re: Release plans

[Chong Yidong]

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.

Re: Release plans

[Lennart Borgman (gmail)]

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?

Re: Release plans

[Bastien]

"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

Re: Release plans

[Jay Belanger]

> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
> end of this month.

A while back, I came across a note saying that any package that is
developed within Emacs shouldn't have it's own version numbering.  I've
looked in vain for that note, but have been unable to find it.  However,
Calc is now a fully owned subsidiary of Emacs, Inc., so is there any
reason why Calc should have its own version number?

Jay

Re: Release plans

[Chong Yidong]

Jay Belanger <jay.p.belanger@gmail.com> writes:

>> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
>> end of this month.
>
> A while back, I came across a note saying that any package that is
> developed within Emacs shouldn't have it's own version numbering.  I've
> looked in vain for that note, but have been unable to find it.  However,
> Calc is now a fully owned subsidiary of Emacs, Inc., so is there any
> reason why Calc should have its own version number?

Quite a few packages use their own version numbers.  I think some
maintainers find these helpful for, e.g., distinguishing between the
versions in the Emacs tree and those distributed seperately.

Re: Release plans

[Jay Belanger]

Chong Yidong <cyd@stupidchicken.com> writes:
...
>> A while back, I came across a note saying that any package that is
>> developed within Emacs shouldn't have it's own version numbering.  I've
>> looked in vain for that note, but have been unable to find it.  However,
>> Calc is now a fully owned subsidiary of Emacs, Inc., so is there any
>> reason why Calc should have its own version number?
>
> Quite a few packages use their own version numbers.  I think some
> maintainers find these helpful for, e.g., distinguishing between the
> versions in the Emacs tree and those distributed seperately.

But in this case, Emacs Calc is developed within Emacs.
Referring to Calc 2.2, for example, gives no indication of where to get
it, referring to Calc in Emacs 23.1 does.  (As does referring to Calc
2.2 in Emacs 23.1, but I don't see the point of the 2.2 here.)
As it is, since Emacs Calc is continually being modified but only
released when Emacs is released, the Emacs Calc version will simply be
bumped up for every Emacs release; that's not that big of a deal, but I
don't really see the point.

"Stephen J. Turnbull" <stephen@xemacs.org> writes:
>
> XEmacs packages it separately, and will continue to do so for the
> foreseeable future.  Until y'all move to a tree-oriented VCS version
> numbers (and tags in the Calc portion of the tree) would be helpful in
> comparing what we got to upstream.

XEmacs Calc is a separate branch, and not even the version numbering is
kept in sync.  I don't see how the Emacs Calc version number is more
helpful than the Emacs version number when referring to Emacs Calc.
(I could be missing something, of course.)

Jay

Re: Release plans

[Stephen J. Turnbull]

Jay Belanger writes:

 > A while back, I came across a note saying that any package that is
 > developed within Emacs shouldn't have it's own version numbering.  I've
 > looked in vain for that note, but have been unable to find it.  However,
 > Calc is now a fully owned subsidiary of Emacs, Inc., so is there any
 > reason why Calc should have its own version number?

XEmacs packages it separately, and will continue to do so for the
foreseeable future.  Until y'all move to a tree-oriented VCS version
numbers (and tags in the Calc portion of the tree) would be helpful in
comparing what we got to upstream.

Re: Release plans

[Richard M Stallman]

    A while back, I came across a note saying that any package that is
    developed within Emacs shouldn't have it's own version numbering.

The reason I started asking people not to put version numbers in the
Lisp programs included in Emacs is that they tend to be time wasters.
But that problem happens mainly when the program's maintainer sends
patches for us to install.  But since you maintain Calc directly in
the Emacs repository, the only person whose time it costs is yours.
So you may as well do whatever you prefer about this.

Re: Release plans

[Bill Wohler]

Jay Belanger <jay.p.belanger@gmail.com> writes:

>> Just a reminder: we will begin the feature freeze for Emacs 23.1 at the
>> end of this month.
>
> A while back, I came across a note saying that any package that is
> developed within Emacs shouldn't have it's own version numbering.  I've
> looked in vain for that note, but have been unable to find it.  However,
> Calc is now a fully owned subsidiary of Emacs, Inc., so is there any
> reason why Calc should have its own version number?

It would be bad if MH-E was restricted to Emacs' releases. MH-E's
release schedule often has many releases between Emacs releases
(unfortunately, this cycle was an exception).

-- 
Bill Wohler <wohler@newt.com>  http://www.newt.com/wohler/  GnuPG ID:610BD9AD