removing straight and adding gitignore

This commit is contained in:
Chris Cochrun 2022-02-15 17:29:31 -06:00
parent 7a517ce353
commit 8838ad609b
2823 changed files with 2 additions and 115855 deletions

368
%backup%~
View file

@ -1,368 +0,0 @@
/*
SPDX-FileCopyrightText: 2014 Marco Martin <mart@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
import QtQuick 2.6
import QtQuick.Layouts 1.1
import QtQuick.Window 2.1
import org.kde.plasma.core 2.0 as PlasmaCore
import org.kde.plasma.components 2.0 as PlasmaComponents // For Highlight
import org.kde.plasma.components 3.0 as PlasmaComponents3
import org.kde.plasma.extras 2.0 as PlasmaExtras
import org.kde.milou 0.1 as Milou
ColumnLayout {
id: root
property string query
property string runner
property bool showHistory: false
property alias runnerManager: results.runnerManager
LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft
LayoutMirroring.childrenInherit: true
onQueryChanged: {
queryField.text = query;
}
Connections {
target: runnerWindow
function onVisibleChanged() {
if (runnerWindow.visible) {
queryField.forceActiveFocus();
listView.currentIndex = -1
if (runnerManager.retainPriorSearch) {
// If we manually specified a query(D-Bus invocation) we don't want to retain the prior search
if (!query) {
queryField.text = runnerManager.priorSearch
queryField.select(root.query.length, 0)
}
}
} else {
if (runnerManager.retainPriorSearch) {
runnerManager.priorSearch = root.query
}
root.runner = ""
root.query = ""
root.showHistory = false
}
}
}
Connections {
target: root
function onShowHistoryChanged() {
if (showHistory) {
// we store 50 entries in the history but only show 20 in the UI so it doesn't get too huge
listView.model = runnerManager.history.slice(0, 20)
} else {
listView.model = []
}
}
}
RowLayout {
Layout.alignment: Qt.AlignTop
PlasmaComponents3.ToolButton {
icon.name: "configure"
onClicked: {
runnerWindow.visible = false
runnerWindow.displayConfiguration()
}
Accessible.name: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Configure")
Accessible.description: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Configure Search Plugins")
visible: runnerWindow.canConfigure
PlasmaComponents3.ToolTip {
text: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Configure KRunner…")
}
}
PlasmaComponents3.TextField {
id: queryField
property bool allowCompletion: false
clearButtonShown: true
Layout.minimumWidth: PlasmaCore.Units.gridUnit * 25
Layout.maximumWidth: PlasmaCore.Units.gridUnit * 25
inputMethodHints: Qt.ImhNoPredictiveText
activeFocusOnPress: true
placeholderText: results.runnerName ? i18ndc("plasma_lookandfeel_org.kde.lookandfeel",
"Textfield placeholder text, query specific KRunner",
"Search '%1'…", results.runnerName)
: i18ndc("plasma_lookandfeel_org.kde.lookandfeel",
"Textfield placeholder text", "Search…")
PlasmaComponents3.BusyIndicator {
anchors {
right: parent.right
top: parent.top
bottom: parent.bottom
margins: PlasmaCore.Units.smallSpacing
rightMargin: height
}
Timer {
id: queryTimer
property bool queryDisplay: false
running: results.querying
repeat: true
onRunningChanged: if (queryDisplay && !running) {
queryDisplay = false
}
onTriggered: if (!queryDisplay) {
queryDisplay = true
}
interval: 500
}
running: queryTimer.queryDisplay
}
function move_up() {
if (length === 0) {
root.showHistory = true;
if (listView.count > 0) {
listView.forceActiveFocus();
}
} else if (results.count > 0) {
results.forceActiveFocus();
results.decrementCurrentIndex();
}
}
function move_down() {
if (length === 0) {
root.showHistory = true;
if (listView.count > 0) {
listView.forceActiveFocus();
}
} else if (results.count > 0) {
results.forceActiveFocus();
results.incrementCurrentIndex();
}
}
onTextChanged: {
root.query = queryField.text
if (allowCompletion && length > 0 && runnerManager.historyEnabled) {
var oldText = text
var suggestedText = runnerManager.getHistorySuggestion(text);
if (suggestedText.length > 0) {
text = text + suggestedText.substr(oldText.length)
select(text.length, oldText.length)
}
}
}
Keys.onPressed: {
allowCompletion = (event.key !== Qt.Key_Backspace && event.key !== Qt.Key_Delete)
if (event.modifiers & Qt.ControlModifier) {
if (event.key === Qt.Key_J) {
move_down()
event.accepted = true;
} else if (event.key === Qt.Key_K) {
move_up()
event.accepted = true;
}
}
}
Keys.onUpPressed: move_up()
Keys.onDownPressed: move_down()
function closeOrRun(event) {
// Close KRunner if no text was typed and enter was pressed, FEATURE: 211225
if (!root.query) {
runnerWindow.visible = false
} else {
results.runCurrentIndex(event)
}
}
Keys.onEnterPressed: closeOrRun(event)
Keys.onReturnPressed: closeOrRun(event)
Keys.onEscapePressed: {
runnerWindow.visible = false
}
PlasmaCore.SvgItem {
anchors {
right: parent.right
rightMargin: 6 // from PlasmaStyle TextFieldStyle
verticalCenter: parent.verticalCenter
}
// match clear button
width: Math.max(parent.height * 0.8, PlasmaCore.Units.iconSizes.small)
height: width
svg: PlasmaCore.Svg {
imagePath: "widgets/arrows"
colorGroup: PlasmaCore.Theme.ButtonColorGroup
}
elementId: "down-arrow"
visible: queryField.length === 0 && runnerManager.historyEnabled
MouseArea {
anchors.fill: parent
onPressed: {
root.showHistory = !root.showHistory
if (root.showHistory) {
listView.forceActiveFocus(); // is the history list
} else {
queryField.forceActiveFocus();
}
}
}
}
}
PlasmaComponents3.ToolButton {
checkable: true
checked: runnerWindow.pinned
onToggled: runnerWindow.pinned = checked
icon.name: "window-pin"
Accessible.name: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Pin")
Accessible.description: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Pin Search")
PlasmaComponents3.ToolTip {
text: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Keep Open")
}
}
}
PlasmaExtras.ScrollArea {
Layout.alignment: Qt.AlignTop
visible: results.count > 0
enabled: visible
Layout.fillWidth: true
Layout.preferredHeight: Math.min(Screen.height, results.contentHeight)
Milou.ResultsView {
id: results
queryString: root.query
runner: root.runner
Keys.onPressed: {
var ctrl = event.modifiers & Qt.ControlModifier;
if (ctrl && event.key === Qt.Key_J) {
incrementCurrentIndex()
} else if (ctrl && event.key === Qt.Key_K) {
decrementCurrentIndex()
} else if (event.text !== "") {
// This prevents unprintable control characters from being inserted
if (!/[\x00-\x1F\x7F]/.test(event.text)) {
queryField.text += event.text;
}
queryField.cursorPosition = queryField.text.length
queryField.focus = true;
}
}
Keys.onEscapePressed: {
runnerWindow.visible = false
}
onActivated: {
runnerWindow.visible = false
}
onUpdateQueryString: {
queryField.text = text
queryField.cursorPosition = cursorPosition
}
}
}
PlasmaExtras.ScrollArea {
Layout.alignment: Qt.AlignTop
Layout.fillWidth: true
visible: root.query.length === 0 && listView.count > 0
// don't accept keyboard input when not visible so the keys propagate to the other list
enabled: visible
Layout.preferredHeight: Math.min(Screen.height, listView.contentHeight)
ListView {
id: listView // needs this id so the delegate can access it
keyNavigationWraps: true
highlight: PlasmaComponents.Highlight {}
highlightMoveDuration: 0
activeFocusOnTab: true
model: []
delegate: Milou.ResultDelegate {
id: resultDelegate
width: listView.width
typeText: index === 0 ? i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Recent Queries") : ""
additionalActions: [{
icon: "list-remove",
text: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Remove")
}]
Accessible.description: i18n("in category recent queries")
}
onActiveFocusChanged: {
if (!activeFocus && currentIndex == listView.count-1) {
currentIndex = 0;
}
}
Keys.onReturnPressed: runCurrentIndex(event)
Keys.onEnterPressed: runCurrentIndex(event)
Keys.onTabPressed: {
if (currentIndex == listView.count-1) {
listView.nextItemInFocusChain(true).forceActiveFocus();
} else {
incrementCurrentIndex()
}
}
Keys.onBacktabPressed: {
if (currentIndex == 0) {
listView.nextItemInFocusChain(false).forceActiveFocus();
} else {
decrementCurrentIndex()
}
}
Keys.onPressed: {
var ctrl = event.modifiers & Qt.ControlModifier;
if (ctrl && event.key === Qt.Key_J) {
incrementCurrentIndex()
} else if (ctrl && event.key === Qt.Key_K) {
decrementCurrentIndex()
} else if (event.text !== "") {
// This prevents unprintable control characters from being inserted
if (event.key == Qt.Key_Escape) {
root.showHistory = false
} else if (!/[\x00-\x1F\x7F]/.test(event.text)) {
queryField.text += event.text;
}
queryField.focus = true;
}
}
Keys.onUpPressed: decrementCurrentIndex()
Keys.onDownPressed: incrementCurrentIndex()
function runCurrentIndex(event) {
var entry = runnerManager.history[currentIndex]
if (entry) {
// If user presses Shift+Return to invoke an action, invoke the first runner action
if (event && event.modifiers === Qt.ShiftModifier
&& currentItem.additionalActions && currentItem.additionalActions.length > 0) {
runAction(0);
return
}
queryField.text = entry
queryField.forceActiveFocus();
}
}
function runAction(actionIndex) {
if (actionIndex === 0) {
// QStringList changes just reset the model, so we'll remember the index and set it again
var currentIndex = listView.currentIndex
runnerManager.removeFromHistory(currentIndex)
model = runnerManager.history
listView.currentIndex = currentIndex
}
}
}
}
}

11
.gitignore vendored
View file

@ -1,11 +0,0 @@
straight
var
url
transient
tmp
org-roam.db
network-security.data
eshell
etc
tramp
bookmarks

2420
README.org

File diff suppressed because it is too large Load diff

1748
init.el

File diff suppressed because it is too large Load diff

File diff suppressed because one or more lines are too long

View file

@ -1,109 +0,0 @@
;;; ace-link-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "ace-link" "ace-link.el" (0 0 0 0))
;;; Generated autoloads from ace-link.el
(autoload 'ace-link "ace-link" "\
Call the ace link function for the current `major-mode'" t nil)
(autoload 'ace-link-info "ace-link" "\
Open a visible link in an `Info-mode' buffer." t nil)
(autoload 'ace-link-help "ace-link" "\
Open a visible link in a `help-mode' buffer." t nil)
(autoload 'ace-link-man "ace-link" "\
Open a visible link in a `man' buffer." t nil)
(autoload 'ace-link-woman "ace-link" "\
Open a visible link in a `woman-mode' buffer." t nil)
(autoload 'ace-link-eww "ace-link" "\
Open a visible link in an `eww-mode' buffer.
If EXTERNAL is single prefix, browse the URL using
`browse-url-secondary-browser-function'.
If EXTERNAL is double prefix, browse in new buffer.
\(fn &optional EXTERNAL)" t nil)
(autoload 'ace-link-w3m "ace-link" "\
Open a visible link in an `w3m-mode' buffer." t nil)
(autoload 'ace-link-compilation "ace-link" "\
Open a visible link in a `compilation-mode' buffer." t nil)
(autoload 'ace-link-gnus "ace-link" "\
Open a visible link in a `gnus-article-mode' buffer." t nil)
(autoload 'ace-link-mu4e "ace-link" "\
Open a visible link in an `mu4e-view-mode' buffer." t nil)
(autoload 'ace-link-notmuch-plain "ace-link" "\
Open a visible link in a `notmuch-show' buffer.
Only consider the 'text/plain' portion of the buffer." t nil)
(autoload 'ace-link-notmuch-html "ace-link" "\
Open a visible link in a `notmuch-show' buffer.
Only consider the 'text/html' portion of the buffer." t nil)
(autoload 'ace-link-notmuch "ace-link" "\
Open a visible link in `notmuch-show' buffer.
Consider both the links in 'text/plain' and 'text/html'." t nil)
(autoload 'ace-link-org "ace-link" "\
Open a visible link in an `org-mode' buffer." t nil)
(autoload 'ace-link-org-agenda "ace-link" "\
Open a visible link in an `org-mode-agenda' buffer." t nil)
(autoload 'ace-link-xref "ace-link" "\
Open a visible link in an `xref--xref-buffer-mode' buffer." t nil)
(autoload 'ace-link-custom "ace-link" "\
Open a visible link in an `Custom-mode' buffer." t nil)
(autoload 'ace-link-addr "ace-link" "\
Open a visible link in a goto-address buffer." t nil)
(autoload 'ace-link-sldb "ace-link" "\
Interact with a frame or local variable in a sldb buffer." t nil)
(autoload 'ace-link-slime-xref "ace-link" "\
Open a visible link in an `slime-xref-mode' buffer." t nil)
(autoload 'ace-link-slime-inspector "ace-link" "\
Interact with a value, an action or a range button in a
`slime-inspector-mode' buffer." t nil)
(autoload 'ace-link-indium-inspector "ace-link" "\
Interact with a value, an action or a range button in a
`indium-inspector-mode' buffer." t nil)
(autoload 'ace-link-indium-debugger-frames "ace-link" "\
Interact with a value, an action or a range button in a
`indium-debugger-frames-mode' buffer." t nil)
(autoload 'ace-link-cider-inspector "ace-link" "\
Open a visible link in a `cider-inspector-mode' buffer." t nil)
(autoload 'ace-link-setup-default "ace-link" "\
Bind KEY to appropriate functions in appropriate keymaps.
\(fn &optional KEY)" nil nil)
(register-definition-prefixes "ace-link" '("ace-link-"))
;;;***
(provide 'ace-link-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; ace-link-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/ace-link/ace-link.el

Binary file not shown.

View file

@ -1,86 +0,0 @@
;;; ace-window-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "ace-window" "ace-window.el" (0 0 0 0))
;;; Generated autoloads from ace-window.el
(autoload 'ace-select-window "ace-window" "\
Ace select window." t nil)
(autoload 'ace-delete-window "ace-window" "\
Ace delete window." t nil)
(autoload 'ace-swap-window "ace-window" "\
Ace swap window." t nil)
(autoload 'ace-delete-other-windows "ace-window" "\
Ace delete other windows." t nil)
(autoload 'ace-display-buffer "ace-window" "\
Make `display-buffer' and `pop-to-buffer' select using `ace-window'.
See sample config for `display-buffer-base-action' and `display-buffer-alist':
https://github.com/abo-abo/ace-window/wiki/display-buffer.
\(fn BUFFER ALIST)" nil nil)
(autoload 'ace-window "ace-window" "\
Select a window.
Perform an action based on ARG described below.
By default, behaves like extended `other-window'.
See `aw-scope' which extends it to work with frames.
Prefixed with one \\[universal-argument], does a swap between the
selected window and the current window, so that the selected
buffer moves to current window (and current buffer moves to
selected window).
Prefixed with two \\[universal-argument]'s, deletes the selected
window.
\(fn ARG)" t nil)
(defvar ace-window-display-mode nil "\
Non-nil if Ace-Window-Display mode is enabled.
See the `ace-window-display-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 `ace-window-display-mode'.")
(custom-autoload 'ace-window-display-mode "ace-window" nil)
(autoload 'ace-window-display-mode "ace-window" "\
Minor mode for showing the ace window key in the mode line.
This is a minor mode. If called interactively, toggle the
`Ace-Window-Display mode' mode. If the prefix argument is
positive, enable the mode, and if it is zero or negative, disable
the mode.
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.
To check whether the minor mode is enabled in the current buffer,
evaluate `(default-value \\='ace-window-display-mode)'.
The mode's hook is called both when the mode is enabled and when
it is disabled.
\(fn &optional ARG)" t nil)
(register-definition-prefixes "ace-window" '("ace-window-mode" "aw-"))
;;;***
(provide 'ace-window-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; ace-window-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/ace-window/ace-window.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/adaptive-wrap/.gitignore

View file

@ -1,40 +0,0 @@
;;; adaptive-wrap-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "adaptive-wrap" "adaptive-wrap.el" (0 0 0 0))
;;; Generated autoloads from adaptive-wrap.el
(autoload 'adaptive-wrap-prefix-mode "adaptive-wrap" "\
Wrap the buffer text with adaptive filling.
This is a minor mode. If called interactively, toggle the
`Adaptive-Wrap-Prefix mode' mode. If the prefix argument is
positive, enable the mode, and if it is zero or negative, disable
the mode.
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.
To check whether the minor mode is enabled in the current buffer,
evaluate `adaptive-wrap-prefix-mode'.
The mode's hook is called both when the mode is enabled and when
it is disabled.
\(fn &optional ARG)" t nil)
(register-definition-prefixes "adaptive-wrap" '("adaptive-wrap-" "lookup-key"))
;;;***
(provide 'adaptive-wrap-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; adaptive-wrap-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/adaptive-wrap/adaptive-wrap.el

View file

@ -1,88 +0,0 @@
;;; aggressive-indent-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "aggressive-indent" "aggressive-indent.el"
;;;;;; (0 0 0 0))
;;; Generated autoloads from aggressive-indent.el
(autoload 'aggressive-indent-indent-defun "aggressive-indent" "\
Indent current defun.
Throw an error if parentheses are unbalanced.
If L and R are provided, use them for finding the start and end of defun.
\(fn &optional L R)" t nil)
(autoload 'aggressive-indent-indent-region-and-on "aggressive-indent" "\
Indent region between L and R, and then some.
Call `aggressive-indent-region-function' between L and R, and
then keep indenting until nothing more happens.
\(fn L R)" t nil)
(autoload 'aggressive-indent-mode "aggressive-indent" "\
Toggle Aggressive-Indent mode on or off.
This is a minor mode. If called interactively, toggle the
`Aggressive-Indent mode' mode. If the prefix argument is
positive, enable the mode, and if it is zero or negative, disable
the mode.
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.
To check whether the minor mode is enabled in the current buffer,
evaluate `aggressive-indent-mode'.
The mode's hook is called both when the mode is enabled and when
it is disabled.
\\{aggressive-indent-mode-map}
\(fn &optional ARG)" t nil)
(put 'global-aggressive-indent-mode 'globalized-minor-mode t)
(defvar global-aggressive-indent-mode nil "\
Non-nil if Global Aggressive-Indent mode is enabled.
See the `global-aggressive-indent-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 `global-aggressive-indent-mode'.")
(custom-autoload 'global-aggressive-indent-mode "aggressive-indent" nil)
(autoload 'global-aggressive-indent-mode "aggressive-indent" "\
Toggle Aggressive-Indent mode in all buffers.
With prefix ARG, enable Global Aggressive-Indent mode if ARG is
positive; otherwise, disable it.
If called from Lisp, toggle the mode if ARG is `toggle'.
Enable the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.
Aggressive-Indent mode is enabled in all buffers where
`aggressive-indent-mode' would do it.
See `aggressive-indent-mode' for more information on Aggressive-Indent
mode.
\(fn &optional ARG)" t nil)
(defalias 'aggressive-indent-global-mode #'global-aggressive-indent-mode)
(register-definition-prefixes "aggressive-indent" '("aggressive-indent-"))
;;;***
(provide 'aggressive-indent-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; aggressive-indent-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/aggressive-indent-mode/aggressive-indent.el

View file

@ -1,98 +0,0 @@
;;; alert-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "alert" "alert.el" (0 0 0 0))
;;; Generated autoloads from alert.el
(autoload 'alert-add-rule "alert" "\
Programmatically add an alert configuration rule.
Normally, users should custoimze `alert-user-configuration'.
This facility is for module writers and users that need to do
things the Lisp way.
Here is a rule the author currently uses with ERC, so that the
fringe gets colored whenever people chat on BitlBee:
\(alert-add-rule :status \\='(buried visible idle)
:severity \\='(moderate high urgent)
:mode \\='erc-mode
:predicate
#\\='(lambda (info)
(string-match (concat \"\\\\`[^&].*@BitlBee\\\\\\='\")
(erc-format-target-and/or-network)))
:persistent
#\\='(lambda (info)
;; If the buffer is buried, or the user has been
;; idle for `alert-reveal-idle-time' seconds,
;; make this alert persistent. Normally, alerts
;; become persistent after
;; `alert-persist-idle-time' seconds.
(memq (plist-get info :status) \\='(buried idle)))
:style \\='fringe
:continue t)
\(fn &key SEVERITY STATUS MODE CATEGORY TITLE MESSAGE PREDICATE ICON (STYLE alert-default-style) PERSISTENT CONTINUE NEVER-PERSIST APPEND)" nil nil)
(autoload 'alert "alert" "\
Alert the user that something has happened.
MESSAGE is what the user will see. You may also use keyword
arguments to specify additional details. Here is a full example:
\(alert \"This is a message\"
:severity \\='high ;; The default severity is `normal'
:title \"Title\" ;; An optional title
:category \\='example ;; A symbol to identify the message
:mode \\='text-mode ;; Normally determined automatically
:buffer (current-buffer) ;; This is the default
:data nil ;; Unused by alert.el itself
:persistent nil ;; Force the alert to be persistent;
;; it is best not to use this
:never-persist nil ;; Force this alert to never persist
:id \\='my-id) ;; Used to replace previous message of
;; the same id in styles that support it
:style \\='fringe) ;; Force a given style to be used;
;; this is only for debugging!
If no :title is given, the buffer-name of :buffer is used. If
:buffer is nil, it is the current buffer at the point of call.
:data is an opaque value which modules can pass through to their
own styles if they wish.
Here are some more typical examples of usage:
;; This is the most basic form usage
(alert \"This is an alert\")
;; You can adjust the severity for more important messages
(alert \"This is an alert\" :severity \\='high)
;; Or decrease it for purely informative ones
(alert \"This is an alert\" :severity \\='trivial)
;; Alerts can have optional titles. Otherwise, the title is the
;; buffer-name of the (current-buffer) where the alert originated.
(alert \"This is an alert\" :title \"My Alert\")
;; Further, alerts can have categories. This allows users to
;; selectively filter on them.
(alert \"This is an alert\" :title \"My Alert\"
:category \\='some-category-or-other)
\(fn MESSAGE &key (SEVERITY \\='normal) TITLE ICON CATEGORY BUFFER MODE DATA STYLE PERSISTENT NEVER-PERSIST ID)" nil nil)
(register-definition-prefixes "alert" '("alert-" "x-urgen"))
;;;***
(provide 'alert-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; alert-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/alert/alert.el

Binary file not shown.

View file

@ -1,41 +0,0 @@
;;; all-the-icons-dired-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "all-the-icons-dired" "all-the-icons-dired.el"
;;;;;; (0 0 0 0))
;;; Generated autoloads from all-the-icons-dired.el
(autoload 'all-the-icons-dired-mode "all-the-icons-dired" "\
Display all-the-icons icon for each file in a dired buffer.
This is a minor mode. If called interactively, toggle the
`All-The-Icons-Dired mode' mode. If the prefix argument is
positive, enable the mode, and if it is zero or negative, disable
the mode.
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.
To check whether the minor mode is enabled in the current buffer,
evaluate `all-the-icons-dired-mode'.
The mode's hook is called both when the mode is enabled and when
it is disabled.
\(fn &optional ARG)" t nil)
(register-definition-prefixes "all-the-icons-dired" '("all-the-icons-dired-"))
;;;***
(provide 'all-the-icons-dired-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; all-the-icons-dired-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons-dired/all-the-icons-dired.el

View file

@ -1,72 +0,0 @@
;;; all-the-icons-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "all-the-icons" "all-the-icons.el" (0 0 0 0))
;;; Generated autoloads from all-the-icons.el
(autoload 'all-the-icons-icon-for-dir "all-the-icons" "\
Get the formatted icon for DIR.
ARG-OVERRIDES should be a plist containining `:height',
`:v-adjust' or `:face' properties like in the normal icon
inserting functions.
Note: You want chevron, please use `all-the-icons-icon-for-dir-with-chevron'.
\(fn DIR &rest ARG-OVERRIDES)" nil nil)
(autoload 'all-the-icons-icon-for-file "all-the-icons" "\
Get the formatted icon for FILE.
ARG-OVERRIDES should be a plist containining `:height',
`:v-adjust' or `:face' properties like in the normal icon
inserting functions.
\(fn FILE &rest ARG-OVERRIDES)" nil nil)
(autoload 'all-the-icons-icon-for-mode "all-the-icons" "\
Get the formatted icon for MODE.
ARG-OVERRIDES should be a plist containining `:height',
`:v-adjust' or `:face' properties like in the normal icon
inserting functions.
\(fn MODE &rest ARG-OVERRIDES)" nil nil)
(autoload 'all-the-icons-icon-for-url "all-the-icons" "\
Get the formatted icon for URL.
If an icon for URL isn't found in `all-the-icons-url-alist', a globe is used.
ARG-OVERRIDES should be a plist containining `:height',
`:v-adjust' or `:face' properties like in the normal icon
inserting functions.
\(fn URL &rest ARG-OVERRIDES)" nil nil)
(autoload 'all-the-icons-install-fonts "all-the-icons" "\
Helper function to download and install the latests fonts based on OS.
When PFX is non-nil, ignore the prompt and just install
\(fn &optional PFX)" t nil)
(autoload 'all-the-icons-insert "all-the-icons" "\
Interactive icon insertion function.
When Prefix ARG is non-nil, insert the propertized icon.
When FAMILY is non-nil, limit the candidates to the icon set matching it.
\(fn &optional ARG FAMILY)" t nil)
(register-definition-prefixes "all-the-icons" '("all-the-icons-"))
;;;***
;;;### (autoloads nil nil ("all-the-icons-faces.el") (0 0 0 0))
;;;***
(provide 'all-the-icons-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; all-the-icons-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/all-the-icons-faces.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/all-the-icons.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/data/data-alltheicons.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/data/data-faicons.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/data/data-fileicons.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/data/data-material.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/data/data-octicons.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/all-the-icons.el/data/data-weathericons.el

View file

@ -1,41 +0,0 @@
;;; annalist-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "annalist" "annalist.el" (0 0 0 0))
;;; Generated autoloads from annalist.el
(autoload 'annalist-record "annalist" "\
In the store for ANNALIST, TYPE, and LOCAL, record RECORD.
ANNALIST should correspond to the package/user recording this information (e.g.
'general, 'me, etc.). TYPE is the type of information being recorded (e.g.
'keybindings). LOCAL corresponds to whether to store RECORD only for the current
buffer. This information together is used to select where RECORD should be
stored in and later retrieved from with `annalist-describe'. RECORD should be a
list of items to record and later print as org headings and column entries in a
single row. If PLIST is non-nil, RECORD should be a plist instead of an ordered
list (e.g. '(keymap org-mode-map key \"C-c a\" ...)). The plist keys should be
the symbols used for the definition of TYPE.
\(fn ANNALIST TYPE RECORD &key LOCAL PLIST)" nil nil)
(autoload 'annalist-describe "annalist" "\
Describe information recorded by ANNALIST for TYPE.
For example: (annalist-describe 'general 'keybindings) If VIEW is non-nil, use
those settings for displaying recorded information instead of the defaults.
\(fn ANNALIST TYPE &optional VIEW)" nil nil)
(register-definition-prefixes "annalist" '("annalist-"))
;;;***
(provide 'annalist-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; annalist-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/annalist.el/annalist.el

Binary file not shown.

View file

@ -1,546 +0,0 @@
This is annalist.info, produced by makeinfo version 6.8 from
annalist.texi.
INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Annalist: (annalist). Record and display information such as keybindings.
END-INFO-DIR-ENTRY

File: annalist.info, Node: Top, Next: Usage, Up: (dir)
Annalist User Manual
********************
file:https://melpa.org/packages/annalist-badge.svg
(https://melpa.org/#/annalist)
https://travis-ci.org/noctuid/annalist.el.svg?branch=master
(https://travis-ci.org/noctuid/annalist.el)
Incessant wind sweeps the plain. It murmurs on across grey stone,
carrying dust from far climes to nibble eternally at the memorial
pillars. There are a few shadows out there still but they are the
weak and the timid and the hopelessly lost.
It is immortality of a sort.
Memory is immortality of a sort.
In the night, when the wind dies and silence rules the place of
glittering stone, I remember. And they all live again.
annalist.el is a library that can be used to record information and
later print that information using org-mode headings and tables. It
allows defining different types of things that can be recorded (e.g.
keybindings, settings, hooks, and advice) and supports custom filtering,
sorting, and formatting. annalist is primarily intended for use in
other packages like general and evil-collection, but it can also be
used directly in a users configuration.
[https://user-images.githubusercontent.com/4250696/63480582-64e2cb00-c460-11e9-9571-706b5b96992c]
* Menu:
* Usage::
— The Detailed Node Listing —
Usage
* Disabling Annalist::
* Terminology::
* Settings::
* Defining New Types::
* Defining Views::
* Recording::
* Describing::
* Helper Functions::
* Builtin Types::
Defining New Types
* Type Top-level Settings::
* Type Item Settings::
* :record-update, :preprocess, and :postprocess Settings Argument: record-update preprocess and postprocess Settings Argument.
Defining Views
* View Top-level Settings::
* View Item Settings::
Helper Functions
* List Helpers::
* Formatting Helpers::
* Sorting Helpers::
Builtin Types
* Keybindings Type::

File: annalist.info, Node: Usage, Prev: Top, Up: Top
1 Usage
*******
* Menu:
* Disabling Annalist::
* Terminology::
* Settings::
* Defining New Types::
* Defining Views::
* Recording::
* Describing::
* Helper Functions::
* Builtin Types::

File: annalist.info, Node: Disabling Annalist, Next: Terminology, Up: Usage
1.1 Disabling Annalist
======================
What fool always has his nose in everywhere because he thinks he
has to know so he can record it in his precious Annals?
If you use a library that uses annalist (e.g. evil-collection or
general) but dont need its functionality during init or at all, you
can set annalist-record to nil to shave some milliseconds off of your
init time (especially if you have a lot of keybindings). Alternatively,
if you only want to prevent annalist from recording certain things or
have it only record certain things, you can configure
annalist-record-blacklist or annalist-record-whitelist respectively.

File: annalist.info, Node: Terminology, Next: Settings, Prev: Disabling Annalist, Up: Usage
1.2 Terminology
===============
• item - and individual recorded item; may be displayed as a heading
or as a table column entry (e.g. a key such as C-c)
• record - a list of related, printable items corresponding to one
piece of information (e.g. a single keybinding: a list of a
keymap, key, and definition)
• metadata - a plist of information about a data list that should not
be printed; appears as the last item in a record
• tome - a collection of records of a specific type

File: annalist.info, Node: Settings, Next: Defining New Types, Prev: Terminology, Up: Usage
1.3 Settings
============
Annalist provides annalist-describe-hook which is run in annalist
description buffers after they have been populated but before they are
marked read-only:
(add-hook 'annalist-describe-hook
(lambda () (visual-fill-column-mode -1)))

File: annalist.info, Node: Defining New Types, Next: Defining Views, Prev: Settings, Up: Usage
1.4 Defining New Types
======================
Three huge tomes bound in worn, cracked dark leather rested on a
large, long stone lectern, as though waiting for three speakers to
step up and read at the same time.
Annalist provides the function annalist-define-tome for defining
new types of tomes:
(annalist-define-tome 'battles
'(:primary-key (year name)
:table-start-index 1
year
name
casualties
...))
At minimum, a type definition must include :primary-key,
:table-start-index, and a symbol for each item records should store.
Items should be defined in the order they should appear in org headings
and then in the table.
* Menu:
* Type Top-level Settings::
* Type Item Settings::
* :record-update, :preprocess, and :postprocess Settings Argument: record-update preprocess and postprocess Settings Argument.

File: annalist.info, Node: Type Top-level Settings, Next: Type Item Settings, Up: Defining New Types
1.4.1 Type Top-level Settings
-----------------------------
These settings apply to the entirety of the recorded information.
:table-start-index - the index of the first item to be printed in
an org table; previous items are printed as headings (default:
none)
:primary-key - the item or list of items that uniquely identifies
the record; used with the :test values for those items to check
for an old record that should be replaced/updated (default: none)
:record-update - a function used to update a record before
recording it; this can be used to, for example, set the value of an
item to store the previous value of another item; the function is
called with old-record (nil if none), new-record, and
settings; see annalist--update-keybindings for an example of
how to create such a function (default: none)
:preprocess - a function used to alter a record before doing
anything with it; it is passed record and settings and should
return the altered record; see the default keybindings type for an
example (default: none)
:test - test function used for comparing the primary key (as a
list of each item in the order it appears in the definition); you
will need to create the test with define-hash-table-test if it
does not exist (default: equal; generally should be unnecessary
to change)
:defaults - a plist of default item settings; see below for valid
item settings (default: none)

File: annalist.info, Node: Type Item Settings, Next: record-update preprocess and postprocess Settings Argument, Prev: Type Top-level Settings, Up: Defining New Types
1.4.2 Type Item Settings
------------------------
Item settings only apply to a specific item. Defaults for items that
dont explicitly specify a setting can be set using the top-level
:defaults keyword.
:test - test function used for comparing items; only applicable
to heading items; you will need to create the test with
define-hash-table-test if it does not exist (default: equal;
generally should be unnecessary to change)

File: annalist.info, Node: record-update preprocess and postprocess Settings Argument, Prev: Type Item Settings, Up: Defining New Types
1.4.3 :record-update, :preprocess, and :postprocess Settings Argument
---------------------------------------------------------------------------
The settings plist past to the :record-update function contains all
information for both the tome type and view. The information is
converted into a valid plist and some extra keywords are added. Here is
an example:
'(:table-start-index 2
:primary-key (keymap state key)
;; the following keywords are generated for convenience
:type keybindings
:key-indices (2 1 0)
:final-index 4
:metadata-index 5
;; item settings can be accessed by their symbol or their index
keymap (:name keymap :index 0 :format annalist-code)
0 (:name keymap :index 0 :format annalist-code)
...)

File: annalist.info, Node: Defining Views, Next: Recording, Prev: Defining New Types, Up: Usage
1.5 Defining Views
==================
In those days the company was in service to…
Views contain settings for formatting and displaying recorded
information. Settings from the type definition cannot be changed later.
On the other hand, views are for all settings that a user may want to
change for a particular annalist-describe call. They are defined
using the same format as tome types:
(annalist-define-view 'battles 'default
'(:defaults (:format capitalize)
year
name
(casualties :title "Deaths")
...))
The default view is what annalist-describe will use if no view
name is explicitly specified. To prevent naming conflicts, external
packages that create views should prefix the views with their symbol
(e.g. general-alternate-view).
* Menu:
* View Top-level Settings::
* View Item Settings::

File: annalist.info, Node: View Top-level Settings, Next: View Item Settings, Up: Defining Views
1.5.1 View Top-level Settings
-----------------------------
These settings apply to the entirety of the recorded information.
:predicate - a function that is passed the entire record and
returns non-nil if the record should be printed (default: none)
:sort - a function used to sort records in each printed table;
the function is passed two records and and should return non-nil if
the first record should come first (default: none; tables are
printed in recorded order)
:hooks - a function or a list of functions to run in the describe
buffer after printing all headings and tables before making the
buffer readonly; these run before annalist-describe-hook
(default: none)
:postprocess - a function used to alter a record just before
printing it; it is passed record and settings and should return
the altered record; an example use case would be to alter the
record using its metadata (e.g. by replacing a keybinding
definition with a which-key description, if one exists) (default:
none)
:defaults - a plist of default item settings; see below for valid
item settings (default: none)
There is also a special :inherit keyword that can be used to create
a new type of tome that is based on another type:
(annalist-define-view 'keybindings 'alternate
;; override title for key column
'((key :title "Keybinding")
...)
:inherit 'keybindings)

File: annalist.info, Node: View Item Settings, Prev: View Top-level Settings, Up: Defining Views
1.5.2 View Item Settings
------------------------
Item settings only apply to a specific item. Defaults for items that
dont explicitly specify a setting can be set using the top-level
:defaults keyword.
(annalist-define-view 'keybindings 'my-view
'(:defaults (:format #'capitalize)
;; surround key with = instead of capitalizing
(key :format #'annalist-verbatim)
;; perform no formatting on definition
(definition :format nil)))
Sorting/filtering (only for items displayed in headings):
:predicate - a function that is passed the item and returns
non-nil if it should be printed; only applicable to heading items
(default: none)
:prioritize - list of items that should be printed before any
others; only applicable to heading items (default: none)
:sort - a function used to sort records; only applicable to
heading items; the function is passed two items and and should
return non-nil if the first item should come first (default: none;
printed in recorded order)
Formatting:
:title - a description of the item; used as the column title
(default: capitalize the symbol name; local only)
:format - function to run on the item value before it is printed
(e.g. #'capitalize, #'annalist-code, #'annalist-verbatim,
etc.); note that this is run on the item as-is if it has not been
truncated, so the function may need to convert the item to a string
first; has no effect if the item is extracted to a footnote/source
block (default: none)
:max-width - the max character width for an item; note that this
is compared to the item as-is before any formatting (default: 50)
:extractp - function to determine whether to extract longer
entries into footnotes instead of truncating them; (default:
listp)
:src-block-p function to determine whether to extract to a source
block when the :extractp function returns non-nil (default:
listp)

File: annalist.info, Node: Recording, Next: Describing, Prev: Defining Views, Up: Usage
1.6 Recording
=============
The Lady said, “I wanted you to see this, Annalist.” […] “What is
about to transpire. So that it is properly recorded in at least
one place.”
annalist-record is used to record information. It requires three
arguments: annalist type record. The annalist argument will
usually be the same as the package prefix that is recording the data.
annalist and any other names prefixed by annalist are reserved for
this package. type is the type of data to record, and record is the
actual data. Optionally, the user can also specify metadata that wont
be printed after the final item. Buffer-local records should
additionally specify :local t. Here is an example:
(annalist-record 'me 'keybindings
(list
;; keymap state key definition previous-definition
'global-map nil (kbd "C-+") #'text-scale-increase nil
;; metadata can be specified after final item
(list :zoom-related-binding t)))
;; alternatively, record using plist instead of ordered list
(annalist-record 'me 'keybindings
(list
'keymap 'global-map
'state nil
'key (kbd "C-+")
'definition #'text-scale-increase
;; metadata can be specified with `t' key
t (list :zoom-related-binding t))
:plist t)
Some items can potentially be recorded as nil. In the previous
example, the evil state is recorded as nil (which will always be the
case for non-evil users). When a heading item is nil, the heading at
that level will just be skipped/not printed.

File: annalist.info, Node: Describing, Next: Helper Functions, Prev: Recording, Up: Usage
1.7 Describing
==============
Once each month, in the evening, the entire Company assembles so
the Annalist can read from his predecessors.
annalist-describe is used to describe information. It takes three
arguments: name type view. view is optional (defaults to
default). For example:
(annalist-describe 'me 'keybindings)
It is possible to have custom filtering/sorting behavior by using a
custom view:
(annalist-define-view 'keybindings 'active-keybindings-only
'((keymap
;; only show keys bound in active keymaps
:predicate #'annalist--active-keymap
;; sort keymaps alphabetically
:sort #'annalist--string-<)))
(annalist-describe 'my 'keybindings 'active-keybindings-only)
annalist-org-startup-folded will determine what
org-startup-folded setting to use (defaults to nil; all headings will
be unfolded).

File: annalist.info, Node: Helper Functions, Next: Builtin Types, Prev: Describing, Up: Usage
1.8 Helper Functions
====================
* Menu:
* List Helpers::
* Formatting Helpers::
* Sorting Helpers::

File: annalist.info, Node: List Helpers, Next: Formatting Helpers, Up: Helper Functions
1.8.1 List Helpers
------------------
annalist-plistify-record can be used to convert a record that is an
ordered list to a plist. annalist-listify-record can be used to do
the opposite. This is what the :plist argument for annalist-record
uses internally. These functions can be useful, for example, inside a
:record-update function, so that you can get record items by their
name instead of by their index. However, if there will be a lot of data
recorded for a type during Emacs initialization time, the extra time to
convert between list types can add up, so its recommended that you
dont use these functions or :plist in such cases.

File: annalist.info, Node: Formatting Helpers, Next: Sorting Helpers, Prev: List Helpers, Up: Helper Functions
1.8.2 Formatting Helpers
------------------------
1. :format Helpers
Annalist provides annalist-verbatim (e.g. =verbatim text=),
annalist-code (e.g. ~my-function~), and annalist-capitalize.
There is also an annalist-compose helper for combining different
formatting functions.
2. Formatting Emacs Lisp Source Blocks
By default, Emacs Lisp extracted into source blocks will just be
one long line. You can add annalist-multiline-source-blocks to a
views :hooks keyword or to annalist-describe-hook to
autoformat org source blocks if lispy is installed. By default, it
uses lispy-alt-multiline. To use lispy-multiline instead,
customize annalist-multiline-function.
The builtin types have annlist-multiline-source-blocks in their
:hooks setting by default.
Here is an example of what this looks like:
[https://user-images.githubusercontent.com/4250696/62338313-1025e300-b4a6-11e9-845f-179c02abef35]

File: annalist.info, Node: Sorting Helpers, Prev: Formatting Helpers, Up: Helper Functions
1.8.3 Sorting Helpers
---------------------
Annalist provides annalist-string-< and annalist-key-< (e.g. (kbd
"C-c a") vs (kbd "C-c b")).

File: annalist.info, Node: Builtin Types, Prev: Helper Functions, Up: Usage
1.9 Builtin Types
=================
* Menu:
* Keybindings Type::

File: annalist.info, Node: Keybindings Type, Up: Builtin Types
1.9.1 Keybindings Type
----------------------
Annalist provides a type for recording keybindings that is used by
evil-collection and general. When recording a keybinding, the
keymap must be provided as a symbol. Here is an example:
(annalist-record 'annalist 'keybindings
(list 'org-mode-map nil (kbd "C-c g") #'counsel-org-goto))
In addition to the default view, it has a valid to only show
keybindings for keymaps/states that exist (since some keybindings may be
in a with-eval-after-load). It also has an active view to only show
keybindings that are currently active.

Tag Table:
Node: Top217
Node: Usage2196
Node: Disabling Annalist2444
Node: Terminology3227
Node: Settings3856
Node: Defining New Types4240
Node: Type Top-level Settings5273
Node: Type Item Settings6988
Node: record-update preprocess and postprocess Settings Argument7642
Node: Defining Views8602
Node: View Top-level Settings9597
Node: View Item Settings11237
Node: Recording13460
Node: Describing15401
Node: Helper Functions16438
Node: List Helpers16652
Node: Formatting Helpers17432
Node: Sorting Helpers18621
Node: Builtin Types18883
Node: Keybindings Type19033

End Tag Table

Local Variables:
coding: utf-8
End:

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/annalist.el/annalist.texi

View file

@ -1,19 +0,0 @@
This is the file .../info/dir, which contains the
topmost node of the Info hierarchy, called (dir)Top.
The first time you invoke Info you start off looking at this node.

File: dir, Node: Top This is the top of the INFO tree
This (the Directory node) gives a menu of major topics.
Typing "q" exits, "H" lists all Info commands, "d" returns here,
"h" gives a primer for first-timers,
"mEmacs<Return>" visits the Emacs manual, etc.
In Emacs, you can click mouse button 2 on a menu item or cross reference
to select it.
* Menu:
Emacs
* Annalist: (annalist). Record and display information such as
keybindings.

View file

@ -1,208 +0,0 @@
;;; async-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "async" "async.el" (0 0 0 0))
;;; Generated autoloads from async.el
(autoload 'async-start-process "async" "\
Start the executable PROGRAM asynchronously named NAME. See `async-start'.
PROGRAM is passed PROGRAM-ARGS, calling FINISH-FUNC with the
process object when done. If FINISH-FUNC is nil, the future
object will return the process object when the program is
finished. Set DEFAULT-DIRECTORY to change PROGRAM's current
working directory.
\(fn NAME PROGRAM FINISH-FUNC &rest PROGRAM-ARGS)" nil nil)
(autoload 'async-start "async" "\
Execute START-FUNC (often a lambda) in a subordinate Emacs process.
When done, the return value is passed to FINISH-FUNC. Example:
(async-start
;; What to do in the child process
(lambda ()
(message \"This is a test\")
(sleep-for 3)
222)
;; What to do when it finishes
(lambda (result)
(message \"Async process done, result should be 222: %s\"
result)))
If FINISH-FUNC is nil or missing, a future is returned that can
be inspected using `async-get', blocking until the value is
ready. Example:
(let ((proc (async-start
;; What to do in the child process
(lambda ()
(message \"This is a test\")
(sleep-for 3)
222))))
(message \"I'm going to do some work here\") ;; ....
(message \"Waiting on async process, result should be 222: %s\"
(async-get proc)))
If you don't want to use a callback, and you don't care about any
return value from the child process, pass the `ignore' symbol as
the second argument (if you don't, and never call `async-get', it
will leave *emacs* process buffers hanging around):
(async-start
(lambda ()
(delete-file \"a remote file on a slow link\" nil))
\\='ignore)
Special case:
If the output of START-FUNC is a string with properties
e.g. (buffer-string) RESULT will be transformed in a list where the
car is the string itself (without props) and the cdr the rest of
properties, this allows using in FINISH-FUNC the string without
properties and then apply the properties in cdr to this string (if
needed).
Properties handling special objects like markers are returned as
list to allow restoring them later.
See <https://github.com/jwiegley/emacs-async/issues/145> for more infos.
Note: Even when FINISH-FUNC is present, a future is still
returned except that it yields no value (since the value is
passed to FINISH-FUNC). Call `async-get' on such a future always
returns nil. It can still be useful, however, as an argument to
`async-ready' or `async-wait'.
\(fn START-FUNC &optional FINISH-FUNC)" nil nil)
(register-definition-prefixes "async" '("async-"))
;;;***
;;;### (autoloads nil "async-bytecomp" "async-bytecomp.el" (0 0 0
;;;;;; 0))
;;; Generated autoloads from async-bytecomp.el
(autoload 'async-byte-recompile-directory "async-bytecomp" "\
Compile all *.el files in DIRECTORY asynchronously.
All *.elc files are systematically deleted before proceeding.
\(fn DIRECTORY &optional QUIET)" nil nil)
(defvar async-bytecomp-package-mode nil "\
Non-nil if Async-Bytecomp-Package mode is enabled.
See the `async-bytecomp-package-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 `async-bytecomp-package-mode'.")
(custom-autoload 'async-bytecomp-package-mode "async-bytecomp" nil)
(autoload 'async-bytecomp-package-mode "async-bytecomp" "\
Byte compile asynchronously packages installed with package.el.
Async compilation of packages can be controlled by
`async-bytecomp-allowed-packages'.
This is a minor mode. If called interactively, toggle the
`Async-Bytecomp-Package mode' mode. If the prefix argument is
positive, enable the mode, and if it is zero or negative, disable
the mode.
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.
To check whether the minor mode is enabled in the current buffer,
evaluate `(default-value \\='async-bytecomp-package-mode)'.
The mode's hook is called both when the mode is enabled and when
it is disabled.
\(fn &optional ARG)" t nil)
(autoload 'async-byte-compile-file "async-bytecomp" "\
Byte compile Lisp code FILE asynchronously.
Same as `byte-compile-file' but asynchronous.
\(fn FILE)" t nil)
(register-definition-prefixes "async-bytecomp" '("async-"))
;;;***
;;;### (autoloads nil "dired-async" "dired-async.el" (0 0 0 0))
;;; Generated autoloads from dired-async.el
(defvar dired-async-mode nil "\
Non-nil if Dired-Async mode is enabled.
See the `dired-async-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 `dired-async-mode'.")
(custom-autoload 'dired-async-mode "dired-async" nil)
(autoload 'dired-async-mode "dired-async" "\
Do dired actions asynchronously.
This is a minor mode. If called interactively, toggle the
`Dired-Async mode' mode. If the prefix argument is positive,
enable the mode, and if it is zero or negative, disable the mode.
If called from Lisp, toggle the mode if ARG is `toggle'. Enable
the mode if ARG is nil, omitted, or is a positive number.
Disable the mode if ARG is a negative number.
To check whether the minor mode is enabled in the current buffer,
evaluate `(default-value \\='dired-async-mode)'.
The mode's hook is called both when the mode is enabled and when
it is disabled.
\(fn &optional ARG)" t nil)
(autoload 'dired-async-do-copy "dired-async" "\
Run dired-do-copy asynchronously.
\(fn &optional ARG)" t nil)
(autoload 'dired-async-do-symlink "dired-async" "\
Run dired-do-symlink asynchronously.
\(fn &optional ARG)" t nil)
(autoload 'dired-async-do-hardlink "dired-async" "\
Run dired-do-hardlink asynchronously.
\(fn &optional ARG)" t nil)
(autoload 'dired-async-do-rename "dired-async" "\
Run dired-do-rename asynchronously.
\(fn &optional ARG)" t nil)
(register-definition-prefixes "dired-async" '("dired-async-"))
;;;***
;;;### (autoloads nil "smtpmail-async" "smtpmail-async.el" (0 0 0
;;;;;; 0))
;;; Generated autoloads from smtpmail-async.el
(register-definition-prefixes "smtpmail-async" '("async-smtpmail-"))
;;;***
(provide 'async-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; async-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/emacs-async/async-bytecomp.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/emacs-async/async.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/emacs-async/dired-async.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/emacs-async/smtpmail-async.el

View file

@ -1,273 +0,0 @@
;;; avy-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "avy" "avy.el" (0 0 0 0))
;;; Generated autoloads from avy.el
(autoload 'avy-process "avy" "\
Select one of CANDIDATES using `avy-read'.
Use OVERLAY-FN to visualize the decision overlay.
CLEANUP-FN should take no arguments and remove the effects of
multiple OVERLAY-FN invocations.
\(fn CANDIDATES &optional OVERLAY-FN CLEANUP-FN)" nil nil)
(autoload 'avy-goto-char "avy" "\
Jump to the currently visible CHAR.
The window scope is determined by `avy-all-windows' (ARG negates it).
\(fn CHAR &optional ARG)" t nil)
(autoload 'avy-goto-char-in-line "avy" "\
Jump to the currently visible CHAR in the current line.
\(fn CHAR)" t nil)
(autoload 'avy-goto-char-2 "avy" "\
Jump to the currently visible CHAR1 followed by CHAR2.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
\(fn CHAR1 CHAR2 &optional ARG BEG END)" t nil)
(autoload 'avy-goto-char-2-above "avy" "\
Jump to the currently visible CHAR1 followed by CHAR2.
This is a scoped version of `avy-goto-char-2', where the scope is
the visible part of the current buffer up to point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn CHAR1 CHAR2 &optional ARG)" t nil)
(autoload 'avy-goto-char-2-below "avy" "\
Jump to the currently visible CHAR1 followed by CHAR2.
This is a scoped version of `avy-goto-char-2', where the scope is
the visible part of the current buffer following point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn CHAR1 CHAR2 &optional ARG)" t nil)
(autoload 'avy-isearch "avy" "\
Jump to one of the current isearch candidates." t nil)
(autoload 'avy-goto-word-0 "avy" "\
Jump to a word start.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
\(fn ARG &optional BEG END)" t nil)
(autoload 'avy-goto-whitespace-end "avy" "\
Jump to the end of a whitespace sequence.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
\(fn ARG &optional BEG END)" t nil)
(autoload 'avy-goto-word-1 "avy" "\
Jump to the currently visible CHAR at a word start.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
BEG and END narrow the scope where candidates are searched.
When SYMBOL is non-nil, jump to symbol start instead of word start.
\(fn CHAR &optional ARG BEG END SYMBOL)" t nil)
(autoload 'avy-goto-word-1-above "avy" "\
Jump to the currently visible CHAR at a word start.
This is a scoped version of `avy-goto-word-1', where the scope is
the visible part of the current buffer up to point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn CHAR &optional ARG)" t nil)
(autoload 'avy-goto-word-1-below "avy" "\
Jump to the currently visible CHAR at a word start.
This is a scoped version of `avy-goto-word-1', where the scope is
the visible part of the current buffer following point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn CHAR &optional ARG)" t nil)
(autoload 'avy-goto-symbol-1 "avy" "\
Jump to the currently visible CHAR at a symbol start.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn CHAR &optional ARG)" t nil)
(autoload 'avy-goto-symbol-1-above "avy" "\
Jump to the currently visible CHAR at a symbol start.
This is a scoped version of `avy-goto-symbol-1', where the scope is
the visible part of the current buffer up to point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn CHAR &optional ARG)" t nil)
(autoload 'avy-goto-symbol-1-below "avy" "\
Jump to the currently visible CHAR at a symbol start.
This is a scoped version of `avy-goto-symbol-1', where the scope is
the visible part of the current buffer following point.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn CHAR &optional ARG)" t nil)
(autoload 'avy-goto-subword-0 "avy" "\
Jump to a word or subword start.
The window scope is determined by `avy-all-windows' (ARG negates it).
When PREDICATE is non-nil it's a function of zero parameters that
should return true.
BEG and END narrow the scope where candidates are searched.
\(fn &optional ARG PREDICATE BEG END)" t nil)
(autoload 'avy-goto-subword-1 "avy" "\
Jump to the currently visible CHAR at a subword start.
The window scope is determined by `avy-all-windows' (ARG negates it).
The case of CHAR is ignored.
\(fn CHAR &optional ARG)" t nil)
(autoload 'avy-goto-word-or-subword-1 "avy" "\
Forward to `avy-goto-subword-1' or `avy-goto-word-1'.
Which one depends on variable `subword-mode'." t nil)
(autoload 'avy-goto-line "avy" "\
Jump to a line start in current buffer.
When ARG is 1, jump to lines currently visible, with the option
to cancel to `goto-line' by entering a number.
When ARG is 4, negate the window scope determined by
`avy-all-windows'.
Otherwise, forward to `goto-line' with ARG.
\(fn &optional ARG)" t nil)
(autoload 'avy-goto-line-above "avy" "\
Goto visible line above the cursor.
OFFSET changes the distance between the closest key to the cursor and
the cursor
When BOTTOM-UP is non-nil, display avy candidates from top to bottom
\(fn &optional OFFSET BOTTOM-UP)" t nil)
(autoload 'avy-goto-line-below "avy" "\
Goto visible line below the cursor.
OFFSET changes the distance between the closest key to the cursor and
the cursor
When BOTTOM-UP is non-nil, display avy candidates from top to bottom
\(fn &optional OFFSET BOTTOM-UP)" t nil)
(autoload 'avy-goto-end-of-line "avy" "\
Call `avy-goto-line' and move to the end of the line.
\(fn &optional ARG)" t nil)
(autoload 'avy-copy-line "avy" "\
Copy a selected line above the current line.
ARG lines can be used.
\(fn ARG)" t nil)
(autoload 'avy-move-line "avy" "\
Move a selected line above the current line.
ARG lines can be used.
\(fn ARG)" t nil)
(autoload 'avy-copy-region "avy" "\
Select two lines and copy the text between them to point.
The window scope is determined by `avy-all-windows' or
`avy-all-windows-alt' when ARG is non-nil.
\(fn ARG)" t nil)
(autoload 'avy-move-region "avy" "\
Select two lines and move the text between them above the current line." t nil)
(autoload 'avy-kill-region "avy" "\
Select two lines and kill the region between them.
The window scope is determined by `avy-all-windows' or
`avy-all-windows-alt' when ARG is non-nil.
\(fn ARG)" t nil)
(autoload 'avy-kill-ring-save-region "avy" "\
Select two lines and save the region between them to the kill ring.
The window scope is determined by `avy-all-windows'.
When ARG is non-nil, do the opposite of `avy-all-windows'.
\(fn ARG)" t nil)
(autoload 'avy-kill-whole-line "avy" "\
Select line and kill the whole selected line.
With a numerical prefix ARG, kill ARG line(s) starting from the
selected line. If ARG is negative, kill backward.
If ARG is zero, kill the selected line but exclude the trailing
newline.
\\[universal-argument] 3 \\[avy-kil-whole-line] kill three lines
starting from the selected line. \\[universal-argument] -3
\\[avy-kill-whole-line] kill three lines backward including the
selected line.
\(fn ARG)" t nil)
(autoload 'avy-kill-ring-save-whole-line "avy" "\
Select line and save the whole selected line as if killed, but dont kill it.
This command is similar to `avy-kill-whole-line', except that it
saves the line(s) as if killed, but does not kill it(them).
With a numerical prefix ARG, kill ARG line(s) starting from the
selected line. If ARG is negative, kill backward.
If ARG is zero, kill the selected line but exclude the trailing
newline.
\(fn ARG)" t nil)
(autoload 'avy-setup-default "avy" "\
Setup the default shortcuts." nil nil)
(autoload 'avy-goto-char-timer "avy" "\
Read one or many consecutive chars and jump to the first one.
The window scope is determined by `avy-all-windows' (ARG negates it).
\(fn &optional ARG)" t nil)
(autoload 'avy-transpose-lines-in-region "avy" "\
Transpose lines in the active region." t nil)
(register-definition-prefixes "avy" '("avy-"))
;;;***
(provide 'avy-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; avy-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/avy/avy.el

Binary file not shown.

View file

@ -1,82 +0,0 @@
;;; bind-key-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "bind-key" "bind-key.el" (0 0 0 0))
;;; Generated autoloads from bind-key.el
(autoload 'bind-key "bind-key" "\
Bind KEY-NAME to COMMAND in KEYMAP (`global-map' if not passed).
KEY-NAME may be a vector, in which case it is passed straight to
`define-key'. Or it may be a string to be interpreted as
spelled-out keystrokes, e.g., \"C-c C-z\". See documentation of
`edmacro-mode' for details.
COMMAND must be an interactive function or lambda form.
KEYMAP, if present, should be a keymap variable or symbol.
For example:
(bind-key \"M-h\" #'some-interactive-function my-mode-map)
(bind-key \"M-h\" #'some-interactive-function 'my-mode-map)
If PREDICATE is non-nil, it is a form evaluated to determine when
a key should be bound. It must return non-nil in such cases.
Emacs can evaluate this form at any time that it does redisplay
or operates on menu data structures, so you should write it so it
can safely be called at any time.
\(fn KEY-NAME COMMAND &optional KEYMAP PREDICATE)" nil t)
(autoload 'unbind-key "bind-key" "\
Unbind the given KEY-NAME, within the KEYMAP (if specified).
See `bind-key' for more details.
\(fn KEY-NAME &optional KEYMAP)" nil t)
(autoload 'bind-key* "bind-key" "\
Similar to `bind-key', but overrides any mode-specific bindings.
\(fn KEY-NAME COMMAND &optional PREDICATE)" nil t)
(autoload 'bind-keys "bind-key" "\
Bind multiple keys at once.
Accepts keyword arguments:
:map MAP - a keymap into which the keybindings should be
added
:prefix KEY - prefix key for these bindings
:prefix-map MAP - name of the prefix map that should be created
for these bindings
:prefix-docstring STR - docstring for the prefix-map variable
:menu-name NAME - optional menu string for prefix map
:filter FORM - optional form to determine when bindings apply
The rest of the arguments are conses of keybinding string and a
function symbol (unquoted).
\(fn &rest ARGS)" nil t)
(autoload 'bind-keys* "bind-key" "\
\(fn &rest ARGS)" nil t)
(autoload 'describe-personal-keybindings "bind-key" "\
Display all the personal keybindings defined by `bind-key'." t nil)
(register-definition-prefixes "bind-key" '("bind-key" "compare-keybindings" "get-binding-description" "override-global-m" "personal-keybindings"))
;;;***
(provide 'bind-key-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; bind-key-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/use-package/bind-key.el

Binary file not shown.

View file

@ -1,71 +0,0 @@
;;; bongo-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "bongo" "bongo.el" (0 0 0 0))
;;; Generated autoloads from bongo.el
(autoload 'bongo-start "bongo" "\
Start playing the current track in the nearest playlist buffer.
If there is no current track, perform the action appropriate for the current
playback mode (for example, for regressive playback, play the last track).
However, if something is already playing, do nothing.
When called interactively and the current track is a stop action track,
continue playback as if the action track had finished playing.
CALLED-INTERACTIVELY-P is non-nil when called interactively.
\(fn &optional CALLED-INTERACTIVELY-P)" t nil)
(autoload 'bongo-start/stop "bongo" "\
Start or stop playback in the nearest Bongo playlist buffer.
With prefix ARGUMENT, call `bongo-stop' even if already stopped.
CALLED-INTERACTIVELY-P is non-nil when called interactively.
\(fn &optional ARGUMENT CALLED-INTERACTIVELY-P)" t nil)
(autoload 'bongo-show "bongo" "\
Display what Bongo is playing in the minibuffer.
If INSERT-FLAG (prefix argument if interactive) is non-nil,
insert the description at point.
Return the description string.
\(fn &optional INSERT-FLAG)" t nil)
(autoload 'bongo-playlist "bongo" "\
Switch to a Bongo playlist buffer.
See the function `bongo-playlist-buffer'." t nil)
(autoload 'bongo-library "bongo" "\
Switch to a Bongo library buffer.
See the function `bongo-library-buffer'." t nil)
(autoload 'bongo-switch-buffers "bongo" "\
In Bongo, switch from a playlist to a library, or vice versa.
With prefix argument PROMPT, prompt for the buffer to switch to.
\(fn &optional PROMPT)" t nil)
(autoload 'bongo "bongo" "\
Switch to a Bongo buffer.
See the function `bongo-buffer'." t nil)
(register-definition-prefixes "bongo" '("afplay" "bongo-" "define-bongo-backend" "mikmod" "ogg123" "speexdec" "timidity" "vlc" "with-"))
;;;***
;;;### (autoloads nil "lastfm-submit" "lastfm-submit.el" (0 0 0 0))
;;; Generated autoloads from lastfm-submit.el
(register-definition-prefixes "lastfm-submit" '("lastfm"))
;;;***
(provide 'bongo-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; bongo-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/bongo.el

Binary file not shown.

File diff suppressed because it is too large Load diff

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/bongo.texi

View file

@ -1,18 +0,0 @@
This is the file .../info/dir, which contains the
topmost node of the Info hierarchy, called (dir)Top.
The first time you invoke Info you start off looking at this node.

File: dir, Node: Top This is the top of the INFO tree
This (the Directory node) gives a menu of major topics.
Typing "q" exits, "H" lists all Info commands, "d" returns here,
"h" gives a primer for first-timers,
"mEmacs<Return>" visits the Emacs manual, etc.
In Emacs, you can click mouse button 2 on a menu item or cross reference
to select it.
* Menu:
Emacs
* Bongo: (bongo). Play music with Emacs.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/action-track-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/audio-cd-track-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/bongo-logo.pbm

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/collapsed-header-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/expanded-header-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/local-audio-file-track-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/local-video-file-track-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/track-mark-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/unknown-local-file-track-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/images/uri-track-icon.png

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/lastfm-submit.el

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bongo/tree-from-tags.rb

View file

@ -1,69 +0,0 @@
;;; bui-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "bui" "bui.el" (0 0 0 0))
;;; Generated autoloads from bui.el
(register-definition-prefixes "bui" '("bui-define-"))
;;;***
;;;### (autoloads nil "bui-button" "bui-button.el" (0 0 0 0))
;;; Generated autoloads from bui-button.el
(register-definition-prefixes "bui-button" '("bui"))
;;;***
;;;### (autoloads nil "bui-core" "bui-core.el" (0 0 0 0))
;;; Generated autoloads from bui-core.el
(register-definition-prefixes "bui-core" '("bui-"))
;;;***
;;;### (autoloads nil "bui-entry" "bui-entry.el" (0 0 0 0))
;;; Generated autoloads from bui-entry.el
(register-definition-prefixes "bui-entry" '("bui-"))
;;;***
;;;### (autoloads nil "bui-history" "bui-history.el" (0 0 0 0))
;;; Generated autoloads from bui-history.el
(register-definition-prefixes "bui-history" '("bui-history"))
;;;***
;;;### (autoloads nil "bui-info" "bui-info.el" (0 0 0 0))
;;; Generated autoloads from bui-info.el
(register-definition-prefixes "bui-info" '("bui-info-"))
;;;***
;;;### (autoloads nil "bui-list" "bui-list.el" (0 0 0 0))
;;; Generated autoloads from bui-list.el
(register-definition-prefixes "bui-list" '("bui-list-"))
;;;***
;;;### (autoloads nil "bui-utils" "bui-utils.el" (0 0 0 0))
;;; Generated autoloads from bui-utils.el
(register-definition-prefixes "bui-utils" '("bui-"))
;;;***
(provide 'bui-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; bui-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui-button.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui-core.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui-entry.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui-history.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui-info.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui-list.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui-utils.el

Binary file not shown.

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/bui.el/bui.el

Binary file not shown.

View file

@ -1,20 +0,0 @@
;;; calfw-ical-autoloads.el --- automatically extracted autoloads -*- lexical-binding: t -*-
;;
;;; Code:
;;;### (autoloads nil "calfw-ical" "calfw-ical.el" (0 0 0 0))
;;; Generated autoloads from calfw-ical.el
(register-definition-prefixes "calfw-ical" '("cfw:"))
;;;***
(provide 'calfw-ical-autoloads)
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; calfw-ical-autoloads.el ends here

View file

@ -1 +0,0 @@
/home/chris/.emacs.d/straight/repos/emacs-calfw/calfw-ical.el

Some files were not shown because too many files have changed in this diff Show more