From 0f3f685f46e4777f92082cc11cdaa706c9609bd7 Mon Sep 17 00:00:00 2001 From: kj Date: Thu, 13 Aug 2020 20:49:06 -0400 Subject: [PATCH] Mejorado el scroll. --- .../smooth-scrolling-autoloads.el | 90 +++++ .../smooth-scrolling-pkg.el | 2 + .../smooth-scrolling.el | 329 ++++++++++++++++++ .../smooth-scrolling.elc | Bin 0 -> 11563 bytes init.el | 8 +- 5 files changed, 428 insertions(+), 1 deletion(-) create mode 100644 elpa/smooth-scrolling-20161002.1949/smooth-scrolling-autoloads.el create mode 100644 elpa/smooth-scrolling-20161002.1949/smooth-scrolling-pkg.el create mode 100644 elpa/smooth-scrolling-20161002.1949/smooth-scrolling.el create mode 100644 elpa/smooth-scrolling-20161002.1949/smooth-scrolling.elc diff --git a/elpa/smooth-scrolling-20161002.1949/smooth-scrolling-autoloads.el b/elpa/smooth-scrolling-20161002.1949/smooth-scrolling-autoloads.el new file mode 100644 index 0000000..e6752a7 --- /dev/null +++ b/elpa/smooth-scrolling-20161002.1949/smooth-scrolling-autoloads.el @@ -0,0 +1,90 @@ +;;; smooth-scrolling-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "smooth-scrolling" "smooth-scrolling.el" (0 +;;;;;; 0 0 0)) +;;; Generated autoloads from smooth-scrolling.el + +(defvar smooth-scrolling-mode nil "\ +Non-nil if Smooth-Scrolling mode is enabled. +See the `smooth-scrolling-mode' command +for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `smooth-scrolling-mode'.") + +(custom-autoload 'smooth-scrolling-mode "smooth-scrolling" nil) + +(autoload 'smooth-scrolling-mode "smooth-scrolling" "\ +Make emacs scroll smoothly + +\(fn &optional ARG)" t nil) + +(defvar smooth-scroll-margin 10 "\ +Number of lines of visible margin at the top and bottom of a window. +If the point is within these margins, then scrolling will occur +smoothly for `previous-line' at the top of the window, and for +`next-line' at the bottom. + +This is very similar in its goal to `scroll-margin'. However, it +is implemented by activating `smooth-scroll-down' and +`smooth-scroll-up' advise via `defadvice' for `previous-line' and +`next-line' respectively. As a result it avoids problems +afflicting `scroll-margin', such as a sudden jump and unexpected +highlighting of a region when the mouse is clicked in the margin. + +Scrolling only occurs when the point is closer to the window +boundary it is heading for (top or bottom) than the middle of the +window. This is to intelligently handle the case where the +margins cover the whole buffer (e.g. `smooth-scroll-margin' set +to 5 and `window-height' returning 10 or less). + +See also `smooth-scroll-strict-margins'.") + +(custom-autoload 'smooth-scroll-margin "smooth-scrolling" t) + +(defvar smooth-scroll-strict-margins t "\ +If true, the advice code supporting `smooth-scroll-margin' +will use `count-screen-lines' to determine the number of +*visible* lines between the point and the window top/bottom, +rather than `count-lines' which obtains the number of actual +newlines. This is because there might be extra newlines hidden +by a mode such as folding-mode, outline-mode, org-mode etc., or +fewer due to very long lines being displayed wrapped when +`truncate-lines' is nil. + +However, using `count-screen-lines' can supposedly cause +performance issues in buffers with extremely long lines. Setting +`cache-long-line-scans' may be able to address this; +alternatively you can set this variable to nil so that the advice +code uses `count-lines', and put up with the fact that sometimes +the point will be allowed to stray into the margin.") + +(custom-autoload 'smooth-scroll-strict-margins "smooth-scrolling" t) + +(autoload 'enable-smooth-scroll-for-function "smooth-scrolling" "\ +Define advice on FUNC to do smooth scrolling. + +This adds after advice with name `smooth-scroll' to FUNC. + +Note that the advice will not have an effect unless +`smooth-scrolling-mode' is enabled. + +\(fn FUNC)" nil t) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "smooth-scrolling" '("do-smooth-scroll" "disable-smooth-scroll-for-function" "enable-smooth-scroll-for-function-conditionally" "window-is-at-bob-p" "smooth-scroll-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; smooth-scrolling-autoloads.el ends here diff --git a/elpa/smooth-scrolling-20161002.1949/smooth-scrolling-pkg.el b/elpa/smooth-scrolling-20161002.1949/smooth-scrolling-pkg.el new file mode 100644 index 0000000..b567db7 --- /dev/null +++ b/elpa/smooth-scrolling-20161002.1949/smooth-scrolling-pkg.el @@ -0,0 +1,2 @@ +;;; -*- no-byte-compile: t -*- +(define-package "smooth-scrolling" "20161002.1949" "Make emacs scroll smoothly" 'nil :commit "2462c13640aa4c75ab3ddad443fedc29acf68f84" :keywords '("convenience") :authors '(("Adam Spiers" . "emacs-ss@adamspiers.org") ("Jeremy Bondeson" . "jbondeson@gmail.com") ("Ryan C. Thompson" . "rct+github@thompsonclan.org")) :maintainer '("Adam Spiers" . "emacs-ss@adamspiers.org") :url "http://github.com/aspiers/smooth-scrolling/") diff --git a/elpa/smooth-scrolling-20161002.1949/smooth-scrolling.el b/elpa/smooth-scrolling-20161002.1949/smooth-scrolling.el new file mode 100644 index 0000000..bc98826 --- /dev/null +++ b/elpa/smooth-scrolling-20161002.1949/smooth-scrolling.el @@ -0,0 +1,329 @@ +;;; smooth-scrolling.el --- Make emacs scroll smoothly +;; +;; Copyright (c) 2007-2016 Adam Spiers +;; +;; Filename: smooth-scrolling.el +;; Description: Make emacs scroll smoothly +;; Author: Adam Spiers +;; Jeremy Bondeson +;; Ryan C. Thompson +;; Maintainer: Adam Spiers +;; Homepage: http://github.com/aspiers/smooth-scrolling/ +;; Version: 2.0.0 +;; Package-Version: 20161002.1949 +;; Package-Commit: 2462c13640aa4c75ab3ddad443fedc29acf68f84 +;; Keywords: convenience +;; GitHub: http://github.com/aspiers/smooth-scrolling/ + +;; This file is not part of GNU Emacs + +;;; License: +;; +;; 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 +;; of the License, 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; if not, write to the Free Software +;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +;;; Commentary: + +;; To interactively toggle the mode on / off: +;; +;; M-x smooth-scrolling-mode +;; +;; To make the mode permanent, put this in your .emacs: +;; +;; (require 'smooth-scrolling) +;; (smooth-scrolling-mode 1) +;; +;; This package offers a global minor mode which make emacs scroll +;; smoothly. It keeps the point away from the top and bottom of the +;; current buffer's window in order to keep lines of context around +;; the point visible as much as possible, whilst minimising the +;; frequency of sudden scroll jumps which are visually confusing. +;; +;; This is a nice alternative to all the native `scroll-*` custom +;; variables, which unfortunately cannot provide this functionality +;; perfectly. For example, when using the built-in variables, clicking +;; with the mouse in the margin will immediately scroll the window to +;; maintain the margin, so the text that you clicked on will no longer be +;; under the mouse. This can be disorienting. In contrast, this mode +;; will not do any scrolling until you actually move up or down a line. +;; +;; Also, the built-in margin code does not interact well with small +;; windows. If the margin is more than half the window height, you get +;; some weird behavior, because the point is always hitting both the top +;; and bottom margins. This package auto-adjusts the margin in each +;; buffer to never exceed half the window height, so the top and bottom +;; margins never overlap. + +;; See the README.md for more details. + +;;; Change Log: +;; 27 Feb 2016 -- v2.0.0 +;; * Converted to global minor mode "smooth-scrolling-mode". This +;; means that simply loading the file no longer enables smooth +;; scrolling; you must also enable the mode. +;; * Internal code restructuring that should improve some edge +;; cases, but otherwise have no user-visible effects. +;; 19 Dec 2013 -- v1.0.4 +;; * Disabled scrolling while a keyboard macro is executing in +;; order to prevent a premature termination of the macro by +;; the mode throwing an error such as "End of Buffer" +;; 02 Jun 2013 -- v1.0.3 +;; * Fixed Issue #3 where bounds checking was not being performed +;; prior to calls to 'count-lines' and 'count-screen-lines' +;; functions. +;; 14 Apr 2013 -- v1.0.2 +;; * Adam Spiers GitHub account now houses the canonical +;; repository. +;; 06 Dec 2011 -- v1.0.1 +;; * Altered structure to conform to package.el standards. +;; * Restructured code to group settings changes +;; * Set "redisplay-dont-pause" to true. +;; ?? ??? 2007 -- v1.0.0 +;; * Original version from Adam Spiers + +;;; Code: + +;;;_ + internal variables +(defvar smooth-scroll-orig-scroll-margin nil) + +;;;_ + defcustoms + +(defgroup smooth-scrolling nil + "Make emacs scroll smoothly" + :group 'convenience) + +;;;###autoload +(define-minor-mode smooth-scrolling-mode + "Make emacs scroll smoothly" + :init-value nil + :global t + :group 'smooth-scrolling + (if smooth-scrolling-mode + (setq smooth-scroll-orig-scroll-margin scroll-margin + scroll-margin 0) + (setq scroll-margin smooth-scroll-orig-scroll-margin + smooth-scroll-orig-scroll-margin nil))) + +;;;###autoload +(defcustom smooth-scroll-margin 10 + "Number of lines of visible margin at the top and bottom of a window. +If the point is within these margins, then scrolling will occur +smoothly for `previous-line' at the top of the window, and for +`next-line' at the bottom. + +This is very similar in its goal to `scroll-margin'. However, it +is implemented by activating `smooth-scroll-down' and +`smooth-scroll-up' advise via `defadvice' for `previous-line' and +`next-line' respectively. As a result it avoids problems +afflicting `scroll-margin', such as a sudden jump and unexpected +highlighting of a region when the mouse is clicked in the margin. + +Scrolling only occurs when the point is closer to the window +boundary it is heading for (top or bottom) than the middle of the +window. This is to intelligently handle the case where the +margins cover the whole buffer (e.g. `smooth-scroll-margin' set +to 5 and `window-height' returning 10 or less). + +See also `smooth-scroll-strict-margins'." + :type 'integer + :group 'smooth-scrolling) + +;;;###autoload +(defcustom smooth-scroll-strict-margins t + "If true, the advice code supporting `smooth-scroll-margin' +will use `count-screen-lines' to determine the number of +*visible* lines between the point and the window top/bottom, +rather than `count-lines' which obtains the number of actual +newlines. This is because there might be extra newlines hidden +by a mode such as folding-mode, outline-mode, org-mode etc., or +fewer due to very long lines being displayed wrapped when +`truncate-lines' is nil. + +However, using `count-screen-lines' can supposedly cause +performance issues in buffers with extremely long lines. Setting +`cache-long-line-scans' may be able to address this; +alternatively you can set this variable to nil so that the advice +code uses `count-lines', and put up with the fact that sometimes +the point will be allowed to stray into the margin." + :type 'boolean + :group 'smooth-scrolling) + +;;;_ + helper functions +(defmacro smooth-scroll-ignore-scroll-errors (&rest body) + "Like `progn', but ignores beginning/end of line errors. + +If BODY encounters such an error, further evaluation is stopped +and this form returns nil. Any other error is raised as normal." + (declare (indent 0)) + `(condition-case err + (progn ,@body) + (end-of-buffer nil) + (beginning-of-buffer nil) + (error (signal (car err) (cdr err))))) + +(defun smooth-scroll-line-beginning-position () + "Return position at beginning of (logical/visual) line. + +If `smooth-scroll-strict-margins' is non-nil, this looks to the +beginning of the visual line. Otherwise it uses the beginning of +the logical line." + (save-excursion + ;; Cannot use `line-beginning-position' here because there is no + ;; visual-line equivalent. + (funcall (if smooth-scroll-strict-margins + #'beginning-of-visual-line + #'beginning-of-line)) + (point))) + +(defun smooth-scroll-count-lines (start end) + "Return number of (logical/visual) lines between START and END. + +If `smooth-scroll-strict-margins' is non-nil, this counts visual +lines. Otherwise it counts logical lines. + +If END is less than START, this returns zero, so it is important +to pass them in order." + (if (< end start) + 0 + (funcall (if smooth-scroll-strict-margins + #'count-screen-lines + #'count-lines) + start end))) + +(defun smooth-scroll-lines-above-point () + "Return the number of lines in window above point. + +This does not include the line that point is on." + (smooth-scroll-count-lines (window-start) + (smooth-scroll-line-beginning-position))) + +(defun smooth-scroll-lines-below-point () + "Return the number of lines in window above point. + +This does not include the line that point is on." + ;; We don't rely on `window-end' because if we are scrolled near the + ;; end of the buffer, it will only give the number of lines + ;; remaining in the file, not the number of lines to the bottom of + ;; the window. + (- (window-height) 2 (smooth-scroll-lines-above-point))) + +(defun smooth-scroll-window-allowed-margin () + "Return the maximum allowed margin above or below point. + +This only matters for windows whose height is +`smooth-scroll-margin' * 2 lines or less." + ;; We subtract 1 for the modeline, which is counted in + ;; `window-height', and one more for the line that point is on. Then + ;; we divide by 2, rouding down. + (/ (- (window-height) 2) 2)) + +(defsubst window-is-at-bob-p () + "Returns non-nil if `(window-start)' is 1 (or less)." + (<= (window-start) 1)) + +;;;_ + main function +(defun do-smooth-scroll () + "Ensure that point is not to close to window edges. + +This function scrolls the window until there are at least +`smooth-scroll-margin' lines between the point and both the top +and bottom of the window. If this is not possible because the +window is too small, th window is scrolled such that the point is +roughly centered within the window." + (interactive) + (when smooth-scrolling-mode + (let* ((desired-margin + ;; For short windows, we reduce `smooth-scroll-margin' to + ;; half the window height minus 1. + (min (smooth-scroll-window-allowed-margin) + smooth-scroll-margin)) + (upper-margin (smooth-scroll-lines-above-point)) + (lower-margin (smooth-scroll-lines-below-point))) + (smooth-scroll-ignore-scroll-errors + (cond + ((< upper-margin desired-margin) + (save-excursion + (dotimes (i (- desired-margin upper-margin)) + (scroll-down 1)))) + ((< lower-margin desired-margin) + (save-excursion + (dotimes (i (- desired-margin lower-margin)) + (scroll-up 1))))))))) + +;;;_ + advice setup + +;;;###autoload +(defmacro enable-smooth-scroll-for-function (func) + "Define advice on FUNC to do smooth scrolling. + +This adds after advice with name `smooth-scroll' to FUNC. + +Note that the advice will not have an effect unless +`smooth-scrolling-mode' is enabled." + `(defadvice ,func (after smooth-scroll activate) + "Do smooth scrolling after command finishes. + +This advice only has an effect when `smooth-scrolling-mode' is +enabled. See `smooth-scrolling-mode' for details. To remove this +advice, use `disable-smooth-scroll-for-function'." + (do-smooth-scroll))) + +(defmacro enable-smooth-scroll-for-function-conditionally (func cond) + "Define advice on FUNC to do smooth scrolling conditionally. + +This adds after advice with name `smooth-scroll' to FUNC. The +advice runs smooth scrolling if expression COND evaluates to +true. COND is included within the advice and therefore has access +to all of FUNC's arguments. + +Note that the advice will not have an effect unless +`smooth-scrolling-mode' is enabled." + (declare (indent 1)) + `(defadvice ,func (after smooth-scroll activate) + ,(format "Do smooth scrolling conditionally after command finishes. + +Smooth sccrolling will only be performed if the following +expression evaluates to true after the function has run: + +%s +This advice only has an effect when `smooth-scrolling-mode' is +enabled. See `smooth-scrolling-mode' for details. To remove this +advice, use `disable-smooth-scroll-for-function'." + (pp-to-string cond)) + (when ,cond + (do-smooth-scroll)))) + +(defmacro disable-smooth-scroll-for-function (func) + "Delete smooth-scroll advice for FUNC." + ;; This doesn't actually need to be a macro, but it is one for + ;; consistency with the enabling macro. Errors are ignored in case + ;; the advice has already been removed. + `(ignore-errors + (ad-remove-advice ',func 'after 'smooth-scroll) + (ad-activate ',func))) + +(progn + (enable-smooth-scroll-for-function previous-line) + (enable-smooth-scroll-for-function next-line) + (enable-smooth-scroll-for-function dired-previous-line) + (enable-smooth-scroll-for-function dired-next-line) + (enable-smooth-scroll-for-function isearch-repeat) + (enable-smooth-scroll-for-function-conditionally scroll-up-command + (not (window-is-at-bob-p))) + (enable-smooth-scroll-for-function-conditionally scroll-down-command + (not (window-is-at-bob-p)))) + +;;;_ + provide +(provide 'smooth-scrolling) +;;; smooth-scrolling.el ends here diff --git a/elpa/smooth-scrolling-20161002.1949/smooth-scrolling.elc b/elpa/smooth-scrolling-20161002.1949/smooth-scrolling.elc new file mode 100644 index 0000000000000000000000000000000000000000..1250103b7e7f911fa86bb52e57c8dcaca2804f61 GIT binary patch literal 11563 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 literal 0 HcmV?d00001 diff --git a/init.el b/init.el index 2f3473e..80f08e0 100644 --- a/init.el +++ b/init.el @@ -51,7 +51,7 @@ '(magit-diff-use-overlays nil) '(package-selected-packages (quote - (web-mode multi-web-mode spacemacs-theme flycheck ac-emmet markdown-preview-mode multiple-cursors git-gutter powerline ample-zen-theme monokai-theme dracula-theme auto-complete neotree all-the-icons spinner markdown-mode lv ht f evil dash-functional))) + (smooth-scrolling web-mode multi-web-mode spacemacs-theme flycheck ac-emmet markdown-preview-mode multiple-cursors git-gutter powerline ample-zen-theme monokai-theme dracula-theme auto-complete neotree all-the-icons spinner markdown-mode lv ht f evil dash-functional))) '(pdf-view-midnight-colors (quote ("#b2b2b2" . "#292b2e"))) '(pos-tip-background-color "#FFFACE") '(pos-tip-foreground-color "#272822") @@ -140,6 +140,12 @@ (global-set-key (kbd "C-S-d") 'mc/mark-all-like-this) ;Cursor en todos como el actual selecionado. (global-set-key (kbd "C-S-") 'mc/add-cursor-on-click) ;Añadir cursor con clics (Shift+CTRL+Clic). +;Mejorando el scroll +(require 'smooth-scrolling) +(smooth-scrolling-mode 1) ;Cambia el salto de líneas cuando el cursor llega al final. +(setq mouse-wheel-scroll-amount '(8 ((shift) . 1) ((control) . nil))) ;Cambia el scroll a 8 líneas a la vez, 1 cuando se preciona SHIFT y saltos de página cuando presionas CTRL +(setq mouse-wheel-progressive-speed nil) ;Deshabilita la velocidad progresiva del scroll (mientras más scroll haces, mas rápido va) + ;Neotree con iconitos y con tamaño dinámico y sin número de líneas. (require 'all-the-icons) (require 'neotree)