5 new commits in fsf-compat: https://bitbucket.org/xemacs/fsf-compat/commits/d414cdb8fd30/ Changeset: d414cdb8fd30 User: Norbert Koch Date: 2014-04-07 08:55:15 Summary: XEmacs Package Release 1.20 Affected #: 2 files diff -r 65d33b7ebc516f9bba2e936a6bdc005a2d806e7e -r d414cdb8fd30cd84cd9eb7006fadcbb78d211509 ChangeLog --- a/ChangeLog +++ b/ChangeLog ＠＠ -1,3 +1,7 ＠＠ +2014-04-07 Norbert Koch <viteno(a)xemacs.org&gt; + + * Makefile (VERSION): XEmacs package 1.20 released. + 2009-08-14 Norbert Koch <viteno(a)xemacs.org&gt; * Makefile (VERSION): XEmacs package 1.19 released. diff -r 65d33b7ebc516f9bba2e936a6bdc005a2d806e7e -r d414cdb8fd30cd84cd9eb7006fadcbb78d211509 Makefile --- a/Makefile +++ b/Makefile ＠＠ -19,7 +19,7 ＠＠ # This XEmacs package contains independent single file lisp packages -VERSION = 1.19 +VERSION = 1.20 AUTHOR_VERSION = MAINTAINER = XEmacs Development Team <xemacs-beta(a)xemacs.org&gt; PACKAGE = fsf-compat https://bitbucket.org/xemacs/fsf-compat/commits/cace3f09611d/ Changeset: cace3f09611d User: Norbert Koch Date: 2014-04-07 08:55:15 Summary: Added tag fsf-compat-1_20 for changeset d414cdb8fd30 Affected #: 1 file diff -r d414cdb8fd30cd84cd9eb7006fadcbb78d211509 -r cace3f09611d6b3a38ad56b87988333343ca9d1c .hgtags --- a/.hgtags +++ b/.hgtags ＠＠ -65,3 +65,4 ＠＠ b82b5434da4014c8e05b6b5bf8fd777fc8f5ff2c sumo-2003-02-05 60cc1e2c36f7bd00d43a2650966c1511cba21807 sumo-2006-05-10 6f862ed49f27e8160e7045316f0fb7453ae06eae fsf-compat-1_13 +d414cdb8fd30cd84cd9eb7006fadcbb78d211509 fsf-compat-1_20 https://bitbucket.org/xemacs/fsf-compat/commits/71fc676f87a2/ Changeset: 71fc676f87a2 User: Norbert Koch Date: 2014-05-12 09:04:04 Summary: Merge (forgotten push) Affected #: 6 files diff -r cace3f09611d6b3a38ad56b87988333343ca9d1c -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 ChangeLog --- a/ChangeLog +++ b/ChangeLog ＠＠ -1,3 +1,7 ＠＠ +2014-05-06 Jerry James <james(a)xemacs.org&gt; + + * button.el: New. From Emacs 24.3. + 2014-04-07 Norbert Koch <viteno(a)xemacs.org&gt; * Makefile (VERSION): XEmacs package 1.20 released. diff -r cace3f09611d6b3a38ad56b87988333343ca9d1c -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 Makefile --- a/Makefile +++ b/Makefile ＠＠ -29,6 +29,7 ＠＠ EXTRA_SOURCES = README -ELCS = overlay.elc thingatpt.elc timer.elc x-popup-menu.elc goto-addr.elc +ELCS = button.elc goto-addr.elc overlay.elc thingatpt.elc timer.elc \ + x-popup-menu.elc include ../../XEmacs.rules diff -r cace3f09611d6b3a38ad56b87988333343ca9d1c -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 button.el --- /dev/null +++ b/button.el ＠＠ -0,0 +1,520 ＠＠ +;;; button.el --- clickable buttons +;; +;; Copyright (C) 2001-2014 Free Software Foundation, Inc. +;; +;; Author: Miles Bader <miles(a)gnu.org&gt; +;; Keywords: extensions +;; Package: emacs +;; +;; This file is part of XEmacs. +;; +;; XEmacs 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 3 of the License, or +;; (at your option) any later version. + +;; XEmacs 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>;. + +;;; Commentary: +;; +;; This package defines functions for inserting and manipulating +;; clickable buttons in Emacs buffers, such as might be used for help +;; hyperlinks, etc. +;; +;; In some ways it duplicates functionality also offered by the +;; `widget' package, but the button package has the advantage that it +;; is (1) much faster, (2) much smaller, and (3) much, much, simpler +;; (the code, that is, not the interface). +;; +;; Buttons can either use extents, in which case the button is +;; represented by the extent itself, or text-properties, in which case +;; the button is represented by a marker or buffer-position pointing +;; somewhere in the button. In the latter case, no markers into the +;; buffer are retained, which is important for speed if there are are +;; extremely large numbers of buttons. Note however that if there is +;; an existing face text-property at the site of the button, the +;; button face may not be visible. Using extents avoids this. +;; +;; Using `define-button-type' to define default properties for buttons +;; is not necessary, but it is encouraged, since doing so makes the +;; resulting code clearer and more efficient. +;; + +;;; Code: + + +;; Globals + +(defface button '((t (:underline t))) + "Default face used for buttons." +:group 'faces) + +(defvar button-map + (let ((map (make-sparse-keymap 'button-map))) + ;; The following definition needs to avoid using escape sequences that + ;; might get converted to ^M when building loaddefs.el + (define-key map [(control ?m)] 'push-button) + (define-key map [button2] 'push-button) + map) + "Keymap used by buttons.") + +(defvar button-buffer-map + (let ((map (make-sparse-keymap 'button-buffer-map))) + (define-key map [?\t] 'forward-button) + (define-key map "\e\t" 'backward-button) + (define-key map [backtab] 'backward-button) + map) + "Keymap useful for buffers containing buttons. +Mode-specific keymaps may want to use this as their parent keymap.") + +;; Default properties for buttons +(put 'default-button 'face 'button) +(put 'default-button 'mouse-face 'highlight) +(put 'default-button 'keymap button-map) +(put 'default-button 'type 'button) +;; action may be either a function to call, or a marker to go to +(put 'default-button 'action 'ignore) +(put 'default-button 'help-echo "mouse-2, RET: Push this button") +;; Make extent buttons go away if their underlying text is deleted. +(put 'default-button 'detachable t) +;; Prevent insertions adjacent to the text-property buttons from +;; inheriting its properties. +(put 'default-button 'rear-nonsticky t) + +;; A `category-symbol' property for the default button type +(put 'button 'button-category-symbol 'default-button) + + +;; Button types (which can be used to hold default properties for buttons) + +;; Because button-type properties are inherited by buttons using the +;; special `category' property (implemented by both extents and +;; text-properties), we need to store them on a symbol to which the +;; `category' properties can point. Instead of using the symbol that's +;; the name of each button-type, however, we use a separate symbol (with +;; `-button' appended, and uninterned) to store the properties. This is +;; to avoid name clashes. + +;; [this is an internal function] +(defsubst button-category-symbol (type) + "Return the symbol used by button-type TYPE to store properties. +Buttons inherit them by setting their `category' property to that symbol." + (or (get type 'button-category-symbol) + (error "Unknown button type `%s'" type))) + +;;;###autoload +(defun define-button-type (name &rest properties) + "Define a `button type' called NAME (a symbol). +The remaining arguments form a sequence of PROPERTY VALUE pairs, +specifying properties to use as defaults for buttons with this type +\(a button's type may be set by giving it a `type' property when +creating the button, using the :type keyword argument). + +In addition, the keyword argument :supertype may be used to specify a +button-type from which NAME inherits its default property values +\(however, the inheritance happens only when NAME is defined; subsequent +changes to a supertype are not reflected in its subtypes)." + (let ((catsym (make-symbol (concat (symbol-name name) "-button"))) + (super-catsym + (button-category-symbol + (or (plist-get properties 'supertype) + (plist-get properties :supertype) + 'button)))) + ;; Provide a link so that it's easy to find the real symbol. + (put name 'button-category-symbol catsym) + ;; Initialize NAME's properties using the global defaults. + (let ((default-props (symbol-plist super-catsym))) + (while default-props + (put catsym (pop default-props) (pop default-props)))) + ;; Add NAME as the `type' property, which will then be returned as + ;; the type property of individual buttons. + (put catsym 'type name) + ;; Add the properties in PROPERTIES to the real symbol. + (while properties + (let ((prop (pop properties))) + (when (eq prop :supertype) + (setq prop 'supertype)) + (put catsym prop (pop properties)))) + ;; Make sure there's a `supertype' property + (unless (get catsym 'supertype) + (put catsym 'supertype 'button)) + name)) + +(defun button-type-put (type prop val) + "Set the button-type TYPE's PROP property to VAL." + (put (button-category-symbol type) prop val)) + +(defun button-type-get (type prop) + "Get the property of button-type TYPE named PROP." + (get (button-category-symbol type) prop)) + +(defun button-type-subtype-p (type supertype) + "Return t if button-type TYPE is a subtype of SUPERTYPE." + (or (eq type supertype) + (and type + (button-type-subtype-p (button-type-get type 'supertype) + supertype)))) + + +;; Button properties and other attributes + +(defun button-start (button) + "Return the position at which BUTTON starts." + (if (extentp button) + (extent-start-position button) + ;; Must be a text-property button. + (or (previous-single-property-change (1+ button) 'button) + (point-min)))) + +(defun button-end (button) + "Return the position at which BUTTON ends." + (if (extentp button) + (extent-end-position button) + ;; Must be a text-property button. + (or (next-single-property-change button 'button) + (point-max)))) + +(defun button-get (button prop) + "Get the property of button BUTTON named PROP." + (cond ((extentp button) + (or (extent-property button prop) + (let ((category (extent-property button 'category))) + (when category + (get category prop))))) + ((button--area-button-p button) + (get-text-property (cdr button) + prop (button--area-button-string button))) + (t ; Must be a text-property button. + (get-text-property button prop)))) + +(defun button-put (button prop val) + "Set BUTTON's PROP property to VAL." + ;; Treat some properties specially. + (cond ((memq prop '(type :type)) + ;; We translate a `type' property a `category' property, since + ;; that's what's actually used by extents/text-properties for + ;; inheriting properties. + (setq prop 'category) + (setq val (button-category-symbol val))) + ((eq prop 'category) + ;; Disallow updating the `category' property directly. + (error "Button `category' property may not be set directly"))) + ;; Add the property. + (cond ((extentp button) + (set-extent-property button prop val)) + ((button--area-button-p button) + (setq button (button--area-button-string button)) + (put-text-property 0 (length button) prop val button)) + (t ; Must be a text-property button. + (put-text-property + (or (previous-single-property-change (1+ button) 'button) + (point-min)) + (or (next-single-property-change button 'button) + (point-max)) + prop val)))) + +;;;###autoload +(defun button-activate (button &optional use-mouse-action) + "Call BUTTON's action property. +If USE-MOUSE-ACTION is non-nil, invoke the button's mouse-action +instead of its normal action; if the button has no mouse-action, +the normal action is used instead. + +The action can either be a marker or a function. If it's a +marker then goto it. Otherwise if it is a function then it is +called with BUTTON as only argument. BUTTON is either an +extent, a buffer position, or (for buttons in the mode-line or +header-line) a string." + (let ((action (or (and use-mouse-action (button-get button 'mouse-action)) + (button-get button 'action)))) + (if (markerp action) + (save-selected-window + (select-window (display-buffer (marker-buffer action))) + (goto-char action) + (recenter 0)) + (funcall action button)))) + +(defun button-label (button) + "Return BUTTON's text label." + (if (button--area-button-p button) + (substring-no-properties (button--area-button-string button)) + (buffer-substring-no-properties (button-start button) + (button-end button)))) + +(defsubst button-type (button) + "Return BUTTON's button-type." + (button-get button 'type)) + +(defun button-has-type-p (button type) + "Return t if BUTTON has button-type TYPE, or one of TYPE's subtypes." + (button-type-subtype-p (button-get button 'type) type)) + +(defun button--area-button-p (b) + "Return non-nil if BUTTON is an area button. +Such area buttons are used for buttons in the mode-line and header-line." + (stringp (car-safe b))) + +(defalias 'button--area-button-string #'car) + +;; Creating extent buttons + +;;;###autoload +(defun make-button (beg end &rest properties) + "Make a button from BEG to END in the current buffer. +The remaining arguments form a sequence of PROPERTY VALUE pairs, +specifying properties to add to the button. +In addition, the keyword argument :type may be used to specify a +button-type from which to inherit other properties; see +`define-button-type'. + +Also see `make-text-button', `insert-button'." + (when (> beg end) + (setq beg (prog1 end (setq end beg)))) + (let ((extent (make-extent beg end))) + (set-extent-property extent 'start-open t) + (while properties + (button-put extent (pop properties) (pop properties))) + ;; Put a pointer to the button in the extent, so it's easy to get + ;; when we don't actually have a reference to the extent. + (set-extent-property extent 'button extent) + ;; If the user didn't specify a type, use the default. + (unless (extent-property extent 'category) + (set-extent-property extent 'category 'default-button)) + ;; EXTENT is the button, so return it + extent)) + +;;;###autoload +(defun insert-button (label &rest properties) + "Insert a button with the label LABEL. +The remaining arguments form a sequence of PROPERTY VALUE pairs, +specifying properties to add to the button. +In addition, the keyword argument :type may be used to specify a +button-type from which to inherit other properties; see +`define-button-type'. + +Also see `insert-text-button', `make-button'." + (apply #'make-button + (prog1 (point) (insert label)) + (point) + properties)) + + +;; Creating text-property buttons + +;;;###autoload +(defun make-text-button (beg end &rest properties) + "Make a button from BEG to END in the current buffer. +The remaining arguments form a sequence of PROPERTY VALUE pairs, +specifying properties to add to the button. +In addition, the keyword argument :type may be used to specify a +button-type from which to inherit other properties; see +`define-button-type'. + +This function is like `make-button', except that the button is actually +part of the text instead of being a property of the buffer. That is, +this function uses text properties, the other uses extents. +Creating large numbers of buttons can also be somewhat faster +using `make-text-button'. Note, however, that if there is an existing +face property at the site of the button, the button face may not be visible. +You may want to use `make-button' in that case. + +BEG can also be a string, in which case it is made into a button. + +Also see `insert-text-button'." + (let ((object nil) + (type-entry + (or (plist-member properties 'type) + (plist-member properties :type)))) + (when (stringp beg) + (setq object beg beg 0 end (length object))) + ;; Disallow setting the `category' property directly. + (when (plist-get properties 'category) + (error "Button `category' property may not be set directly")) + (if (null type-entry) + ;; The user didn't specify a `type' property, use the default. + (setq properties (cons 'category (cons 'default-button properties))) + ;; The user did specify a `type' property. Translate it into a + ;; `category' property, which is what's actually used by + ;; text-properties for inheritance. + (setcar type-entry 'category) + (setcar (cdr type-entry) + (button-category-symbol (car (cdr type-entry))))) + ;; Now add all the text properties at once + (add-text-properties beg end + ;; Each button should have a non-eq `button' + ;; property so that next-single-property-change can + ;; detect boundaries reliably. + (cons 'button (cons (list t) properties)) + object) + ;; Return something that can be used to get at the button. + (or object beg))) + +(defun insert-text-button (label &rest properties) + "Insert a button with the label LABEL. +The remaining arguments form a sequence of PROPERTY VALUE pairs, +specifying properties to add to the button. +In addition, the keyword argument :type may be used to specify a +button-type from which to inherit other properties; see +`define-button-type'. + +This function is like `insert-button', except that the button is +actually part of the text instead of being a property of the buffer. +Creating large numbers of buttons can also be somewhat faster using +`insert-text-button'. + +Also see `make-text-button'." + (apply #'make-text-button + (prog1 (point) (insert label)) + (point) + properties)) + + +;; Finding buttons in a buffer + +;;;###autoload +(defun button-at (pos) + "Return the button at position POS in the current buffer, or nil. +If the button at POS is a text property button, the return value +is a marker pointing to POS." + (let ((button (get-char-property pos 'button))) + (if (or (extentp button) (null button)) + button + ;; Must be a text-property button; return a marker pointing to it. + (copy-marker pos t)))) + +;;;###autoload +(defun next-button (pos &optional count-current) + "Return the next button after position POS in the current buffer. +If COUNT-CURRENT is non-nil, count any button at POS in the search, +instead of starting at the next button." + (unless count-current + ;; Search for the next button boundary. + (setq pos (next-single-char-property-change pos 'button))) + (and (< pos (point-max)) + (or (button-at pos) + ;; We must have originally been on a button, and are now in + ;; the inter-button space. Recurse to find a button. + (next-button pos)))) + +;;;###autoload +(defun previous-button (pos &optional count-current) + "Return the previous button before position POS in the current buffer. +If COUNT-CURRENT is non-nil, count any button at POS in the search, +instead of starting at the next button." + (let ((button (button-at pos))) + (if button + (if count-current + button + ;; We started out on a button, so move to its start and look + ;; for the previous button boundary. + (setq pos (previous-single-char-property-change + (button-start button) 'button)) + (let ((new-button (button-at pos))) + (if new-button + ;; We are in a button again; this can happen if there + ;; are adjacent buttons (or at bob). + (unless (= pos (button-start button)) new-button) + ;; We are now in the space between buttons. + (previous-button pos)))) + ;; We started out in the space between buttons. + (setq pos (previous-single-char-property-change pos 'button)) + (or (button-at pos) + (and (> pos (point-min)) + (button-at (1- pos))))))) + + +;; User commands + +;;;###autoload +(defun push-button (&optional pos use-mouse-action) + "Perform the action specified by a button at location POS. +POS may be either a buffer position or a mouse-event. If +USE-MOUSE-ACTION is non-nil, invoke the button's mouse-action +instead of its normal action; if the button has no mouse-action, +the normal action is used instead. The action may be either a +function to call or a marker to display and is invoked using +`button-activate' (which see). + +POS defaults to point, except when `push-button' is invoked +interactively as the result of a mouse-event, in which case, the +mouse event is used. +If there's no button at POS, do nothing and return nil, otherwise +return t." + (interactive + (list (if (mouse-event-p last-command-event) last-command-event (point)))) + (if (and (not (integerp pos)) (eventp pos)) + ;; POS is a mouse event; switch to the proper window/buffer + (with-current-buffer (event-buffer pos) + (if (event-over-text-area-p pos) + (push-button (event-point pos) t) + (button-activate (event-point pos) t))) + ;; POS is just normal position + (let ((button (button-at (or pos (point))))) + (when button + (button-activate button use-mouse-action) + t)))) + +;;;###autoload +(defun forward-button (n &optional wrap display-message) + "Move to the Nth next button, or Nth previous button if N is negative. +If N is 0, move to the start of any button at point. +If WRAP is non-nil, moving past either end of the buffer continues from the +other end. +If DISPLAY-MESSAGE is non-nil, the button's help-echo string is displayed. +Any button with a non-nil `skip' property is skipped over. +Returns the button found." + (interactive "p\nd\nd") + (let (button) + (if (zerop n) + ;; Move to start of current button + (if (setq button (button-at (point))) + (goto-char (button-start button))) + ;; Move to Nth next button + (let ((iterator (if (> n 0) #'next-button #'previous-button)) + (wrap-start (if (> n 0) (point-min) (point-max))) + opoint fail) + (setq n (abs n)) + (setq button t) ; just to start the loop + (while (and (null fail) (> n 0) button) + (setq button (funcall iterator (point))) + (when (and (not button) wrap) + (setq button (funcall iterator wrap-start t))) + (when button + (goto-char (button-start button)) + ;; Avoid looping forever (e.g., if all the buttons have + ;; the `skip' property). + (cond ((null opoint) + (setq opoint (point))) + ((= opoint (point)) + (setq fail t))) + (unless (button-get button 'skip) + (setq n (1- n))))))) + (if (null button) + (error (if wrap "No buttons!" "No more buttons")) + (let ((msg (and display-message (button-get button 'help-echo)))) + (when msg + (message "%s" msg))) + button))) + +;;;###autoload +(defun backward-button (n &optional wrap display-message) + "Move to the Nth previous button, or Nth next button if N is negative. +If N is 0, move to the start of any button at point. +If WRAP is non-nil, moving past either end of the buffer continues from the +other end. +If DISPLAY-MESSAGE is non-nil, the button's help-echo string is displayed. +Any button with a non-nil `skip' property is skipped over. +Returns the button found." + (interactive "p\nd\nd") + (forward-button (- n) wrap display-message)) + + +(provide 'button) + +;;; button.el ends here diff -r cace3f09611d6b3a38ad56b87988333343ca9d1c -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 overlay.el --- a/overlay.el +++ b/overlay.el ＠＠ -291,6 +291,49 ＠＠ prop))) (set-extent-property overlay prop value)) +(defun copy-overlay (o) + "Return a copy of overlay O." + (let ((o1 (if (overlay-buffer o) + (make-overlay (overlay-start o) (overlay-end o) + ;; FIXME: there's no easy way to find the + ;; insertion-type of the two markers. + (overlay-buffer o)) + (let ((o1 (make-overlay (point-min) (point-min)))) + (delete-overlay o1) + o1))) + (props (overlay-properties o))) + (while props + (overlay-put o1 (pop props) (pop props))) + o1)) + +(defun remove-overlays (&optional beg end name val) + "Clear BEG and END of overlays whose property NAME has value VAL. +Overlays might be moved and/or split. +BEG and END default respectively to the beginning and end of buffer." + ;; This speeds up the loops over overlays. + (unless beg (setq beg (point-min))) + (unless end (setq end (point-max))) + (overlay-recenter end) + (if (< end beg) + (setq beg (prog1 end (setq end beg)))) + (save-excursion + (dolist (o (overlays-in beg end)) + (when (eq (overlay-get o name) val) + ;; Either push this overlay outside beg...end + ;; or split it to exclude beg...end + ;; or delete it entirely (if it is contained in beg...end). + (if (< (overlay-start o) beg) + (if (> (overlay-end o) end) + (progn + (move-overlay (copy-overlay o) + (overlay-start o) beg) + (move-overlay o end (overlay-end o))) + (move-overlay o (overlay-start o) beg)) + (if (> (overlay-end o) end) + (move-overlay o end (overlay-end o)) + (delete-overlay o))))))) + + (provide 'overlay) ;;; overlay.el ends here diff -r cace3f09611d6b3a38ad56b87988333343ca9d1c -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 subr-fsf.el --- /dev/null +++ b/subr-fsf.el ＠＠ -0,0 +1,29 ＠＠ +;;; subr-fsf.el --- Complement the core basic lisp subroutines for XEmacs + +;; Copyright (C) 2014 +;; Free Software Foundation, Inc. + +;; Maintainer: XEmacs Development Team + +;; This file is part of XEmacs. + +;; XEmacs 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. + +;; XEmacs 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 XEmacs; see the file COPYING. If not, write to the +;; Free Software Foundation, 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. + +;;;###autoload +(defalias 'wholenump 'natnump) + +;;;###autoload +(defmacro declare-function (fn file &optional arglist fileonly)) diff -r cace3f09611d6b3a38ad56b87988333343ca9d1c -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 timer.el --- a/timer.el +++ b/timer.el ＠＠ -113,8 +113,10 ＠＠ (defun timer-activate-when-idle (timer &optional dont-wait) "Arrange to activate TIMER whenever Emacs is next idle. DONT-WAIT is for Emacs compatibility and is currently ignored." - (set-itimer-is-idle timer t) - (activate-itimer timer)) + (when (and (not (itimer-live-p timer)) + (not (get-itimer (itimer-name timer)))) + (set-itimer-is-idle timer t) + (activate-itimer timer))) ;; can't do this, different kind of timer ;;(defalias 'disable-timeout 'cancel-timer) https://bitbucket.org/xemacs/fsf-compat/commits/d4571655f255/ Changeset: d4571655f255 User: Norbert Koch Date: 2014-05-12 09:04:49 Summary: XEmacs Package Release 1.21 Affected #: 2 files diff -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 -r d4571655f25538ad0ef7644226f78515f08c9f64 ChangeLog --- a/ChangeLog +++ b/ChangeLog ＠＠ -1,3 +1,7 ＠＠ +2014-05-12 Norbert Koch <viteno(a)xemacs.org&gt; + + * Makefile (VERSION): XEmacs package 1.21 released. + 2014-05-06 Jerry James <james(a)xemacs.org&gt; * button.el: New. From Emacs 24.3. diff -r 71fc676f87a217495d727f60b2ce8853cbbd5e31 -r d4571655f25538ad0ef7644226f78515f08c9f64 Makefile --- a/Makefile +++ b/Makefile ＠＠ -19,7 +19,7 ＠＠ # This XEmacs package contains independent single file lisp packages -VERSION = 1.20 +VERSION = 1.21 AUTHOR_VERSION = MAINTAINER = XEmacs Development Team <xemacs-beta(a)xemacs.org&gt; PACKAGE = fsf-compat https://bitbucket.org/xemacs/fsf-compat/commits/8fe8c2df42a1/ Changeset: 8fe8c2df42a1 User: Norbert Koch Date: 2014-05-12 09:04:49 Summary: Added tag fsf-compat-1_21 for changeset d4571655f255 Affected #: 1 file diff -r d4571655f25538ad0ef7644226f78515f08c9f64 -r 8fe8c2df42a169a88d984b46fcf699e588975d56 .hgtags --- a/.hgtags +++ b/.hgtags ＠＠ -66,3 +66,4 ＠＠ 60cc1e2c36f7bd00d43a2650966c1511cba21807 sumo-2006-05-10 6f862ed49f27e8160e7045316f0fb7453ae06eae fsf-compat-1_13 d414cdb8fd30cd84cd9eb7006fadcbb78d211509 fsf-compat-1_20 +d4571655f25538ad0ef7644226f78515f08c9f64 fsf-compat-1_21 Repository URL: https://bitbucket.org/xemacs/fsf-compat/ -- This is a commit notification from bitbucket.org. You are receiving this because you have the service enabled, addressing the recipient of this email. _______________________________________________ XEmacs-Patches mailing list XEmacs-Patches(a)xemacs.org http://lists.xemacs.org/mailman/listinfo/xemacs-patches