1 ;; Autoloads for nXthml
3 ;; This file should be updated by `nxhtmlmaint-get-file-autoloads',
4 ;; `nxhtmlmaint-get-dir-autoloads' or `nxhtmlmaint-get-all-autoloads'.
5 (eval-when-compile (require 'nxhtml-base))
6 (eval-when-compile (require 'web-vcs))
8 ;;;### (autoloads (cancel-secondary-selection set-secondary-selection
9 ;;;;;; anchored-transpose) "anchored-transpose" "util/anchored-transpose.el"
11 ;;; Generated autoloads from util/anchored-transpose.el
12 (web-autoload-require 'anchored-transpose 'lp '(nxhtml-download-root-url nil) "util/anchored-transpose" nxhtml-install-dir 'nxhtml-byte-compile-file)
15 (nxhtml-autoload 'anchored-transpose `(lp '(nxhtml-download-root-url nil) "util/anchored-transpose" nxhtml-install-dir) "\
16 Transpose portions of the region around an anchor phrase.
18 `this phrase but not that word' can be transposed into
19 `that word but not this phrase'
21 I want this phrase but not that word.
22 |----------------------------|. .This is the entire phrase.
23 |-------|. . . . . . .This is the anchor phrase.
25 First select the entire phrase and type \\[anchored-transpose].
26 This set the secondary selection.
28 Then select the anchor phrase and type \\[anchored-transpose]
29 again. Alternatively you can do the selections like this:
31 I want this phrase but not that word.
32 |----------| |---------| Separate phrase selection.
34 By default the anchor phrase will automatically include
35 any surrounding whitespace even if you don't explicitly select
36 it. Also, it won't include certain trailing punctuation. See
37 `anchored-transpose-do-fuzzy' for details. A prefix arg prior to
38 either selection means `no fuzzy logic, use selections
41 You can select the regions to be swapped separately in any
44 After swapping both primary and secondary selection are still
45 active. They will be canceled after second next command if you
46 do not swap regions again. (Second because this allow you to
47 adjust the regions and try again.)
49 You can also swap text between different buffers this way.
51 Typing \\[anchored-transpose] with nothing selected clears any
52 prior selection, ie secondary selection.
54 \(fn BEG1 END1 FLG1 &optional BEG2 END2 FLG2 WIN2)" t nil)
56 (nxhtml-autoload 'set-secondary-selection `(lp '(nxhtml-download-root-url nil) "util/anchored-transpose" nxhtml-install-dir) "\
57 Set the secondary selection to the current region.
58 This must be bound to a mouse drag event.
62 (nxhtml-autoload 'cancel-secondary-selection `(lp '(nxhtml-download-root-url nil) "util/anchored-transpose" nxhtml-install-dir) "\
69 ;;;### (autoloads (appmenu-mode appmenu-add appmenu) "appmenu" "util/appmenu.el"
71 ;;; Generated autoloads from util/appmenu.el
72 (web-autoload-require 'appmenu 'lp '(nxhtml-download-root-url nil) "util/appmenu" nxhtml-install-dir 'nxhtml-byte-compile-file)
75 (let ((loads (get 'appmenu 'custom-loads))) (if (member '"appmenu" loads) nil (put 'appmenu 'custom-loads (cons '"appmenu" loads))))
77 (nxhtml-autoload 'appmenu-add `(lp '(nxhtml-download-root-url nil) "util/appmenu" nxhtml-install-dir) "\
78 Add entry to `appmenu-alist'.
79 Add an entry to this list with ID, PRIORITY, TEST, TITLE and
80 DEFINITION as explained there.
82 \(fn ID PRIORITY TEST TITLE DEFINITION)" nil nil)
84 (defvar appmenu-mode nil "\
85 Non-nil if Appmenu mode is enabled.
86 See the command `appmenu-mode' for a description of this minor mode.
87 Setting this variable directly does not take effect;
88 either customize it (see the info node `Easy Customization')
89 or call the function `appmenu-mode'.")
91 (nxhtml-custom-autoload 'appmenu-mode 'appmenu nil)
93 (nxhtml-autoload 'appmenu-mode `(lp '(nxhtml-download-root-url nil) "util/appmenu" nxhtml-install-dir) "\
94 Use a context sensitive popup menu.
95 AppMenu (appmenu.el) is a framework for creating cooperative
96 context sensitive popup menus with commands from different major
97 and minor modes. Using this different modes may cooperate about
98 the use of popup menus.
100 There is also the command `appmenu-as-help' that shows the key
101 bindings at current point in the help buffer.
103 The popup menu and the help buffer version are on these keys:
107 The variable `appmenu-alist' is where the popup menu entries
110 If there is a `keymap' property at point then relevant bindings
111 from this is also shown in the popup menu.
113 You can write functions that use whatever information you want in
114 Emacs to construct these entries. Since this information is only
115 collected when the popup menu is shown you do not have to care as
116 much about computation time as for entries in the menu bar.
118 \(fn &optional ARG)" t nil)
122 ;;;### (autoloads (as-external-mode as-external-for-wiki as-external-for-mail-mode
123 ;;;;;; as-external-for-xhtml as-external) "as-external" "util/as-external.el"
124 ;;;;;; (19292 49706))
125 ;;; Generated autoloads from util/as-external.el
126 (web-autoload-require 'as-external 'lp '(nxhtml-download-root-url nil) "util/as-external" nxhtml-install-dir 'nxhtml-byte-compile-file)
129 (let ((loads (get 'as-external 'custom-loads))) (if (member '"as-external" loads) nil (put 'as-external 'custom-loads (cons '"as-external" loads))))
131 (nxhtml-autoload 'as-external-for-xhtml `(lp '(nxhtml-download-root-url nil) "util/as-external" nxhtml-install-dir) "\
132 Setup for Firefox addon It's All Text to edit XHTML.
133 It's All Text is a Firefox add-on for editing textareas with an
135 See URL `https://addons.mozilla.org/en-US/firefox/addon/4125'.
137 In this case Emacs is used to edit textarea fields on a web page.
138 The text will most often be part of a web page later, like on a
139 blog. Therefore turn on these:
141 - `nxhtml-mode' since some XHTML tags may be allowed.
142 - `nxhtml-validation-header-mode' since it is not a full page.
143 - `wrap-to-fill-column-mode' to see what you are writing.
144 - `html-write-mode' to see it even better.
146 Also bypass the question for line end conversion when using
151 (nxhtml-autoload 'as-external-for-mail-mode `(lp '(nxhtml-download-root-url nil) "util/as-external" nxhtml-install-dir) "\
152 Setup for Firefox addon It's All Text to edit mail.
153 Set normal mail comment markers in column 1 (ie >).
155 Set `fill-column' to 90 and enable `wrap-to-fill-column-mode' so
156 that it will look similar to how it will look in the sent plain
159 See also `as-external-mode'.
163 (nxhtml-autoload 'as-external-for-wiki `(lp '(nxhtml-download-root-url nil) "util/as-external" nxhtml-install-dir) "\
164 Setup for Firefox addon It's All Text to edit MediaWikis.
168 (defvar as-external-mode nil "\
169 Non-nil if As-External mode is enabled.
170 See the command `as-external-mode' for a description of this minor mode.
171 Setting this variable directly does not take effect;
172 either customize it (see the info node `Easy Customization')
173 or call the function `as-external-mode'.")
175 (nxhtml-custom-autoload 'as-external-mode 'as-external nil)
177 (nxhtml-autoload 'as-external-mode `(lp '(nxhtml-download-root-url nil) "util/as-external" nxhtml-install-dir) "\
178 If non-nil check if Emacs is called as external editor.
179 When Emacs is called as an external editor for example to edit
180 text areas on a web page viewed with Firefox this library tries
181 to help to setup the buffer in a useful way. It may for example
182 set major and minor modes for the buffer.
184 This can for example be useful when blogging or writing comments
187 See `as-external-alist' for more information.
189 \(fn &optional ARG)" t nil)
193 ;;;### (autoloads (buffer-bg-set-color) "buffer-bg" "util/buffer-bg.el"
194 ;;;;;; (19254 64104))
195 ;;; Generated autoloads from util/buffer-bg.el
196 (web-autoload-require 'buffer-bg 'lp '(nxhtml-download-root-url nil) "util/buffer-bg" nxhtml-install-dir 'nxhtml-byte-compile-file)
199 (nxhtml-autoload 'buffer-bg-set-color `(lp '(nxhtml-download-root-url nil) "util/buffer-bg" nxhtml-install-dir) "\
200 Add an overlay with background color COLOR to buffer BUFFER.
201 If COLOR is nil remove previously added overlay.
203 \(fn COLOR BUFFER)" t nil)
207 ;;;### (autoloads (chartg-make-chart chartg-complete) "chartg" "util/chartg.el"
208 ;;;;;; (19278 15746))
209 ;;; Generated autoloads from util/chartg.el
210 (web-autoload-require 'chartg 'lp '(nxhtml-download-root-url nil) "util/chartg" nxhtml-install-dir 'nxhtml-byte-compile-file)
213 (nxhtml-autoload 'chartg-complete `(lp '(nxhtml-download-root-url nil) "util/chartg" nxhtml-install-dir) "\
218 (nxhtml-autoload 'chartg-make-chart `(lp '(nxhtml-download-root-url nil) "util/chartg" nxhtml-install-dir) "\
219 Try to make a new chart.
220 If region is active then make a new chart from data in the
223 Else if current buffer is in `chartg-mode' then do it from the
224 chart specifications in this buffer. Otherwise create a new
225 buffer and initialize it with `chartg-mode'.
227 If the chart specifications are complete enough to make a chart
228 then do it and show the resulting chart image. If not then tell
229 user what is missing.
231 NOTE: This is beta, no alpha code. It is not ready.
233 Below are some examples. To test them mark an example and do
235 M-x chartg-make-chart
237 * Example, simple x-y chart:
239 Output-file: \"~/temp-chart.png\"
241 Data: 3 8 5 | 10 20 30
246 Output-file: \"~/temp-depression.png\"
257 Type: pie-3-dimensional
258 Chartg-title: \"Depression hits on Google\"
272 Output-file: \"~/temp-panic.png\"
283 Type: pie-3-dimensional
284 Chartg-title: \"Depression hits on Google\"
298 Output-file: \"~/temp-chartg-slipsen-kostar.png\"
301 Type: bar-chartg-horizontal
302 Chartg-title: \"Vad killen i slips tjänar jämfört med dig och mig\"
303 Google-chartg-raw: \"&chds=0,30000&chco=00cd00|ff4500|483d8b&chxt=y,x&chxl=0:|Killen+i+slips|Partiledarna|Du+och+jag&chf=bg,s,ffd700\"
310 ;;;### (autoloads (css-color-test css-color-global-mode css-color-mode
311 ;;;;;; css-color) "css-color" "util/css-color.el" (19386 34254))
312 ;;; Generated autoloads from util/css-color.el
313 (web-autoload-require 'css-color 'lp '(nxhtml-download-root-url nil) "util/css-color" nxhtml-install-dir 'nxhtml-byte-compile-file)
316 (let ((loads (get 'css-color 'custom-loads))) (if (member '"css-color" loads) nil (put 'css-color 'custom-loads (cons '"css-color" loads))))
318 (nxhtml-autoload 'css-color-mode `(lp '(nxhtml-download-root-url nil) "util/css-color" nxhtml-install-dir) "\
319 Show hex color literals with the given color as background.
320 In this mode hexadecimal colour specifications like #6600ff are
321 displayed with the specified colour as background.
323 Certain keys are bound to special colour editing commands when
324 point is at a hexadecimal colour:
328 \(fn &optional ARG)" t nil)
330 (defvar css-color-global-mode nil "\
331 Non-nil if Css-Color-Global mode is enabled.
332 See the command `css-color-global-mode' for a description of this minor mode.
333 Setting this variable directly does not take effect;
334 either customize it (see the info node `Easy Customization')
335 or call the function `css-color-global-mode'.")
337 (nxhtml-custom-autoload 'css-color-global-mode 'css-color nil)
339 (nxhtml-autoload 'css-color-global-mode `(lp '(nxhtml-download-root-url nil) "util/css-color" nxhtml-install-dir) "\
340 Toggle Css-Color mode in every possible buffer.
341 With prefix ARG, turn Css-Color-Global mode on if and only if
343 Css-Color mode is enabled in all buffers where
344 `css-color-turn-on-in-buffer' would do it.
345 See `css-color-mode' for more information on Css-Color mode.
347 \(fn &optional ARG)" t nil)
349 (nxhtml-autoload 'css-color-test `(lp '(nxhtml-download-root-url nil) "util/css-color" nxhtml-install-dir) "\
350 Test colors interactively.
351 The colors are displayed in the echo area. You can specify the
352 colors as any viable css color. Example:
361 \(fn FG-COLOR BG-COLOR)" t nil)
365 ;;;### (autoloads (css-palette-global-mode css-palette css-palette-mode)
366 ;;;;;; "css-palette" "util/css-palette.el" (19235 1650))
367 ;;; Generated autoloads from util/css-palette.el
368 (web-autoload-require 'css-palette 'lp '(nxhtml-download-root-url nil) "util/css-palette" nxhtml-install-dir 'nxhtml-byte-compile-file)
371 (nxhtml-autoload 'css-palette-mode `(lp '(nxhtml-download-root-url nil) "util/css-palette" nxhtml-install-dir) "\
372 Minor mode for palettes in CSS.
374 The mode `css-palette-mode' acts on the first COLORS declaration in your
379 c0 \"#6f5d25\" ;tainted sand
380 c1 \"#000000\" ;Black
381 c2 \"#cca42b\" ;goldenslumber
382 c3 \"#6889cb\" ;far off sky
383 c4 \"#fff\" ;strange aeons
386 Such declarations should appear inside a block comment, in order
387 to be parsed properly by the LISP reader.
389 Type \\[css-palette-update-all], and any occurence of
391 color: #f55; /*[c3]*/
395 color: #6899cb; /*[c3]*/
397 The following commands are available to insert key-value pairs
398 and palette declarations:
399 \\{css-palette-mode-map}
401 You can extend or redefine the types of palettes by defining a
402 new palette specification of the form (PATTERN REGEXP
403 REF-FOLLOWS-VALUE), named according to the naming scheme
404 css-palette:my-type, where
406 PATTERN is a pattern containing two (%s) format directives which
407 will be filled in with the variable and its value,
409 REGEXP is a regular expression to match a value - variable
412 and REF-FOLLOWS-VALUE defined whether or not the reference comes
413 after the value. This allows for more flexibility.
415 Note that, although the w3c spec at URL
416 `http://www.w3.org/TR/CSS2/syndata.html#comments' says that
417 comments \" may occur anywhere between tokens, and their
418 contents have no influence on the rendering\", Internet
419 Explorer does not think so. Better keep all your comments after
420 a \"statement\", as per the default. This means `css-palette'
421 is ill-suited for use within shorthands.
423 See variable `css-palette:colors' for an example of a palette
426 The extension mechanism means that palette types can be used to
427 contain arbitrary key-value mappings.
429 Besides the colors palette, css-palette defines the palette
430 definition variables `css-palette:colors-outside' and
431 `css-palette:files', for colors with the reference outside and
432 for file url()'s respectively.
434 You can fine-control which palette types css-palette should look
435 at via the variable `css-palette-types'.
437 \(fn &optional ARG)" t nil)
439 (let ((loads (get 'css-palette 'custom-loads))) (if (member '"css-palette" loads) nil (put 'css-palette 'custom-loads (cons '"css-palette" loads))))
441 (defvar css-palette-global-mode nil "\
442 Non-nil if Css-Palette-Global mode is enabled.
443 See the command `css-palette-global-mode' for a description of this minor mode.
444 Setting this variable directly does not take effect;
445 either customize it (see the info node `Easy Customization')
446 or call the function `css-palette-global-mode'.")
448 (nxhtml-custom-autoload 'css-palette-global-mode 'css-palette nil)
450 (nxhtml-autoload 'css-palette-global-mode `(lp '(nxhtml-download-root-url nil) "util/css-palette" nxhtml-install-dir) "\
451 Toggle Css-Palette mode in every possible buffer.
452 With prefix ARG, turn Css-Palette-Global mode on if and only if
454 Css-Palette mode is enabled in all buffers where
455 `css-palette-turn-on-in-buffer' would do it.
456 See `css-palette-mode' for more information on Css-Palette mode.
458 \(fn &optional ARG)" t nil)
462 ;;;### (autoloads (cusnu-export-my-skin-options customize-for-new-user)
463 ;;;;;; "cus-new-user" "util/cus-new-user.el" (19173 56140))
464 ;;; Generated autoloads from util/cus-new-user.el
465 (web-autoload-require 'cus-new-user 'lp '(nxhtml-download-root-url nil) "util/cus-new-user" nxhtml-install-dir 'nxhtml-byte-compile-file)
468 (nxhtml-autoload 'customize-for-new-user `(lp '(nxhtml-download-root-url nil) "util/cus-new-user" nxhtml-install-dir) "\
469 Show special customization page for new user.
471 \(fn &optional NAME)" t nil)
473 (nxhtml-autoload 'cusnu-export-my-skin-options `(lp '(nxhtml-download-root-url nil) "util/cus-new-user" nxhtml-install-dir) "\
474 Export to file FILE custom options in `cusnu-my-skin-options'.
475 The options is exported to elisp code that other users can run to
476 set the options that you have added to `cusnu-my-skin-options'.
478 For more information about this see `cusnu-export-cust-group'.
484 ;;;### (autoloads (ediff-url) "ediff-url" "util/ediff-url.el" (19362
486 ;;; Generated autoloads from util/ediff-url.el
487 (web-autoload-require 'ediff-url 'lp '(nxhtml-download-root-url nil) "util/ediff-url" nxhtml-install-dir 'nxhtml-byte-compile-file)
490 (nxhtml-autoload 'ediff-url `(lp '(nxhtml-download-root-url nil) "util/ediff-url" nxhtml-install-dir) "\
491 Compare current buffer to a web URL using `ediff-buffers'.
492 Check URL using `ediff-url-redirects' before fetching the file.
494 This is for checking downloaded file. A the file may have a comment
495 telling the download URL of thise form in the header:
497 ;; URL: http://the-server.net/the-path/the-file.el
499 If not the user is asked for the URL.
505 ;;;### (autoloads (ffip-find-file-in-dirtree ffip-set-current-project)
506 ;;;;;; "ffip" "util/ffip.el" (19257 25432))
507 ;;; Generated autoloads from util/ffip.el
508 (web-autoload-require 'ffip 'lp '(nxhtml-download-root-url nil) "util/ffip" nxhtml-install-dir 'nxhtml-byte-compile-file)
511 (nxhtml-autoload 'ffip-set-current-project `(lp '(nxhtml-download-root-url nil) "util/ffip" nxhtml-install-dir) "\
512 Setup ffip project NAME with top directory ROOT of type TYPE.
513 ROOT can either be just a directory or a list of directory where
514 the first used just for prompting purposes and the files in the
515 rest are read into the ffip project.
517 Type is a type in `ffip-project-file-types'.
519 \(fn NAME ROOT TYPE)" nil nil)
521 (nxhtml-autoload 'ffip-find-file-in-dirtree `(lp '(nxhtml-download-root-url nil) "util/ffip" nxhtml-install-dir) "\
522 Find files in directory tree ROOT.
528 ;;;### (autoloads (fold-dwim-turn-on-outline-and-hide-all fold-dwim-turn-on-hs-and-hide
529 ;;;;;; fold-dwim-unhide-hs-and-outline fold-dwim-mode fold-dwim-toggle
530 ;;;;;; fold-dwim) "fold-dwim" "util/fold-dwim.el" (19218 42180))
531 ;;; Generated autoloads from util/fold-dwim.el
532 (web-autoload-require 'fold-dwim 'lp '(nxhtml-download-root-url nil) "util/fold-dwim" nxhtml-install-dir 'nxhtml-byte-compile-file)
535 (let ((loads (get 'fold-dwim 'custom-loads))) (if (member '"fold-dwim" loads) nil (put 'fold-dwim 'custom-loads (cons '"fold-dwim" loads))))
537 (nxhtml-autoload 'fold-dwim-toggle `(lp '(nxhtml-download-root-url nil) "util/fold-dwim" nxhtml-install-dir) "\
538 Toggle visibility or some other visual things.
539 Try toggling different visual things in this order:
541 - Images shown at point with `inlimg-mode'
542 - Text at point prettified by `html-write-mode'.
544 For the rest it unhides if possible, otherwise hides in this
547 - `org-mode' header or something else using that outlines.
548 - Maybe `fold-dwim-toggle-selective-display'.
549 - `Tex-fold-mode' things.
550 - In html if `outline-minor-mode' and after heading hide content.
551 - `hs-minor-mode' things.
552 - `outline-minor-mode' things. (Turns maybe on this.)
554 It uses `fold-dwim-show' to show any hidden text at point; if no
555 hidden fold is found, try `fold-dwim-hide' to hide the
556 construction at the cursor.
558 Note: Also first turn on `fold-dwim-mode' to get the keybinding
559 for this function from it.
563 (defvar fold-dwim-mode nil "\
564 Non-nil if Fold-Dwim mode is enabled.
565 See the command `fold-dwim-mode' for a description of this minor mode.
566 Setting this variable directly does not take effect;
567 either customize it (see the info node `Easy Customization')
568 or call the function `fold-dwim-mode'.")
570 (nxhtml-custom-autoload 'fold-dwim-mode 'fold-dwim nil)
572 (nxhtml-autoload 'fold-dwim-mode `(lp '(nxhtml-download-root-url nil) "util/fold-dwim" nxhtml-install-dir) "\
573 Key binding for `fold-dwim-toggle'.
575 \(fn &optional ARG)" t nil)
577 (nxhtml-autoload 'fold-dwim-unhide-hs-and-outline `(lp '(nxhtml-download-root-url nil) "util/fold-dwim" nxhtml-install-dir) "\
578 Unhide everything hidden by Hide/Show and Outline.
579 Ie everything hidden by `hs-minor-mode' and
580 `outline-minor-mode'.
584 (nxhtml-autoload 'fold-dwim-turn-on-hs-and-hide `(lp '(nxhtml-download-root-url nil) "util/fold-dwim" nxhtml-install-dir) "\
585 Turn on minor mode `hs-minor-mode' and hide.
586 If major mode is derived from `nxml-mode' call `hs-hide-block'
587 else call `hs-hide-all'.
591 (nxhtml-autoload 'fold-dwim-turn-on-outline-and-hide-all `(lp '(nxhtml-download-root-url nil) "util/fold-dwim" nxhtml-install-dir) "\
592 Turn on `outline-minor-mode' and call `hide-body'.
598 ;;;### (autoloads (foldit-global-mode foldit-mode foldit) "foldit"
599 ;;;;;; "util/foldit.el" (19275 63380))
600 ;;; Generated autoloads from util/foldit.el
601 (web-autoload-require 'foldit 'lp '(nxhtml-download-root-url nil) "util/foldit" nxhtml-install-dir 'nxhtml-byte-compile-file)
604 (let ((loads (get 'foldit 'custom-loads))) (if (member '"foldit" loads) nil (put 'foldit 'custom-loads (cons '"foldit" loads))))
606 (nxhtml-autoload 'foldit-mode `(lp '(nxhtml-download-root-url nil) "util/foldit" nxhtml-install-dir) "\
607 Minor mode providing visual aids for folding.
608 Shows some hints about what you have hidden and how to reveal it.
610 Supports `hs-minor-mode', `outline-minor-mode' and major modes
611 derived from `outline-mode'.
613 \(fn &optional ARG)" t nil)
615 (defvar foldit-global-mode nil "\
616 Non-nil if Foldit-Global mode is enabled.
617 See the command `foldit-global-mode' for a description of this minor mode.
618 Setting this variable directly does not take effect;
619 either customize it (see the info node `Easy Customization')
620 or call the function `foldit-global-mode'.")
622 (nxhtml-custom-autoload 'foldit-global-mode 'foldit nil)
624 (nxhtml-autoload 'foldit-global-mode `(lp '(nxhtml-download-root-url nil) "util/foldit" nxhtml-install-dir) "\
625 Toggle Foldit mode in every possible buffer.
626 With prefix ARG, turn Foldit-Global mode on if and only if
628 Foldit mode is enabled in all buffers where
629 `(lambda nil (foldit-mode 1))' would do it.
630 See `foldit-mode' for more information on Foldit mode.
632 \(fn &optional ARG)" t nil)
636 ;;;### (autoloads (gimpedit-can-edit gimpedit-edit-buffer gimpedit-edit-file
637 ;;;;;; gimpedit) "gimpedit" "util/gimpedit.el" (19275 63380))
638 ;;; Generated autoloads from util/gimpedit.el
639 (web-autoload-require 'gimpedit 'lp '(nxhtml-download-root-url nil) "util/gimpedit" nxhtml-install-dir 'nxhtml-byte-compile-file)
642 (let ((loads (get 'gimpedit 'custom-loads))) (if (member '"gimpedit" loads) nil (put 'gimpedit 'custom-loads (cons '"gimpedit" loads))))
644 (nxhtml-autoload 'gimpedit-edit-file `(lp '(nxhtml-download-root-url nil) "util/gimpedit" nxhtml-install-dir) "\
645 Edit IMAGE-FILE with GIMP.
646 See also `gimpedit-edit-file'.
648 \(fn IMAGE-FILE &optional EXTRA-ARGS)" t nil)
650 (nxhtml-autoload 'gimpedit-edit-buffer `(lp '(nxhtml-download-root-url nil) "util/gimpedit" nxhtml-install-dir) "\
651 Edit image file in current buffer with GIMP.
652 See also `gimpedit-edit-file'.
654 You may also be interested in gimpedit-mode with which you can edit
655 gimp files from within Emacs using GIMP's scripting
658 URL `http://www.emacswiki.org/emacs/GimpMode'
662 (nxhtml-autoload 'gimpedit-can-edit `(lp '(nxhtml-download-root-url nil) "util/gimpedit" nxhtml-install-dir) "\
665 \(fn FILE-NAME)" nil nil)
669 ;;;### (autoloads (gpl-mode) "gpl" "util/gpl.el" (18795 27308))
670 ;;; Generated autoloads from util/gpl.el
671 (web-autoload-require 'gpl 'lp '(nxhtml-download-root-url nil) "util/gpl" nxhtml-install-dir 'nxhtml-byte-compile-file)
674 (nxhtml-autoload 'gpl-mode `(lp '(nxhtml-download-root-url nil) "util/gpl" nxhtml-install-dir) "\
675 Mode for font-locking and editing color palettes of the GPL format.
677 Such palettes are used and produced by free software applications
678 such as the GIMP, Inkscape, Scribus, Agave and on-line tools such
679 as http://colourlovers.com.
682 URL `http://niels.kicks-ass.org/public/elisp/css-palette.el' to import
683 such palette into a css-file as hexadecimal color palette.
689 ;;;### (autoloads (hfyview-frame hfyview-window hfyview-region hfyview-buffer
690 ;;;;;; hfyview-quick-print-in-files-menu) "hfyview" "util/hfyview.el"
691 ;;;;;; (19400 17335))
692 ;;; Generated autoloads from util/hfyview.el
693 (web-autoload-require 'hfyview 'lp '(nxhtml-download-root-url nil) "util/hfyview" nxhtml-install-dir 'nxhtml-byte-compile-file)
696 (defvar hfyview-quick-print-in-files-menu nil "\
697 Add Quick print entries to File menu if non-nil.
698 If you set this to nil you have to restart Emacs to get rid of
699 the Quick Print entry.")
701 (nxhtml-custom-autoload 'hfyview-quick-print-in-files-menu 'hfyview nil)
703 (nxhtml-autoload 'hfyview-buffer `(lp '(nxhtml-download-root-url nil) "util/hfyview" nxhtml-install-dir) "\
704 Convert buffer to html preserving faces and show in web browser.
705 With command prefix ARG also show html source in other window.
709 (nxhtml-autoload 'hfyview-region `(lp '(nxhtml-download-root-url nil) "util/hfyview" nxhtml-install-dir) "\
710 Convert region to html preserving faces and show in web browser.
711 With command prefix ARG also show html source in other window.
715 (nxhtml-autoload 'hfyview-window `(lp '(nxhtml-download-root-url nil) "util/hfyview" nxhtml-install-dir) "\
716 Convert window to html preserving faces and show in web browser.
717 With command prefix ARG also show html source in other window.
721 (nxhtml-autoload 'hfyview-frame `(lp '(nxhtml-download-root-url nil) "util/hfyview" nxhtml-install-dir) "\
722 Convert frame to html preserving faces and show in web browser.
723 Make an XHTML view of the current Emacs frame. Put it in a buffer
724 named *hfyview-frame* and show that buffer in a web browser.
726 If WHOLE-BUFFERS is non-nil then the whole content of the buffers
727 is shown in the XHTML page, otherwise just the part that is
728 visible currently on the frame.
730 If you turn on the minor mode `hfyview-frame-mode' you can also
731 get the minibuffer/echo area in the output. See this mode for
734 With command prefix also show html source in other window.
736 \(fn WHOLE-BUFFERS)" t nil)
740 ;;;### (autoloads (hl-needed-mode hl-needed) "hl-needed" "util/hl-needed.el"
741 ;;;;;; (19394 16942))
742 ;;; Generated autoloads from util/hl-needed.el
743 (web-autoload-require 'hl-needed 'lp '(nxhtml-download-root-url nil) "util/hl-needed" nxhtml-install-dir 'nxhtml-byte-compile-file)
746 (let ((loads (get 'hl-needed 'custom-loads))) (if (member '"hl-needed" loads) nil (put 'hl-needed 'custom-loads (cons '"hl-needed" loads))))
748 (defvar hl-needed-mode nil "\
749 Non-nil if Hl-Needed mode is enabled.
750 See the command `hl-needed-mode' for a description of this minor mode.
751 Setting this variable directly does not take effect;
752 either customize it (see the info node `Easy Customization')
753 or call the function `hl-needed-mode'.")
755 (nxhtml-custom-autoload 'hl-needed-mode 'hl-needed nil)
757 (nxhtml-autoload 'hl-needed-mode `(lp '(nxhtml-download-root-url nil) "util/hl-needed" nxhtml-install-dir) "\
758 Try to highlight current line and column when needed.
759 This is a global minor mode. It can operate in some different
762 - Highlighting can be on always, see `hl-needed-always'.
764 Or, it can be turned on depending on some conditions. In this
765 case highlighting is turned off after each command and turned on
766 again in the current window when either:
768 - A new window was selected, see `hl-needed-on-new-window'.
769 - A new buffer was selected, see `hl-needed-on-new-buffer'.
770 - Window configuration was changed, see `hl-needed-on-config-change'.
771 - Buffer was scrolled see `hl-needed-on-scrolling'.
772 - A window was clicked with the mouse, see `hl-needed-on-mouse'.
774 After this highlighting may be turned off again, normally after a
775 short delay, see `hl-needed-flash'.
777 If either highlighting was not turned on or was turned off again
778 it will be turned on when
780 - Emacs has been idle for `hl-needed-idle-time' seconds.
782 See also `hl-needed-not-in-modes' and `hl-needed-currently-fun'.
784 Note 1: For columns to be highlighted vline.el must be available.
786 Note 2: This mode depends on `hl-line-mode' and `vline-mode' and
787 tries to cooperate with them. If you turn on either of these that
788 overrides the variables for turning on the respective
791 \(fn &optional ARG)" t nil)
795 ;;;### (autoloads (html-write-mode html-write) "html-write" "util/html-write.el"
796 ;;;;;; (19275 63380))
797 ;;; Generated autoloads from util/html-write.el
798 (web-autoload-require 'html-write 'lp '(nxhtml-download-root-url nil) "util/html-write" nxhtml-install-dir 'nxhtml-byte-compile-file)
801 (let ((loads (get 'html-write 'custom-loads))) (if (member '"html-write" loads) nil (put 'html-write 'custom-loads (cons '"html-write" loads))))
803 (nxhtml-autoload 'html-write-mode `(lp '(nxhtml-download-root-url nil) "util/html-write" nxhtml-install-dir) "\
804 Minor mode for convenient display of some HTML tags.
805 When this mode is on a tag in `html-write-tag-list' is displayed as
806 the inner text of the tag with a face corresponding to the tag.
807 By default for example <i>...</i> is displayed as italic and
808 <a>...</a> is displayed as an underlined clickable link.
810 Only non-nested tags are hidden. The idea is just that it should
811 be easier to read and write, not that it should look as html
814 See the customization group `html-write' for more information about
817 The following keys are defined when you are on a tag handled by
820 \\{html-write-keymap}
822 IMPORTANT: Most commands you use works also on the text that is
823 hidden. The movement commands is an exception, but as soon as
824 you edit the buffer you may also change the hidden parts.
826 Hint: Together with `wrap-to-fill-column-mode' this can make it
827 easier to see what text you are actually writing in html parts of
830 \(fn &optional ARG)" t nil)
834 ;;;### (autoloads (inlimg-toggle-slicing inlimg-toggle-display inlimg-global-mode
835 ;;;;;; inlimg-mode inlimg) "inlimg" "util/inlimg.el" (19269 33008))
836 ;;; Generated autoloads from util/inlimg.el
837 (web-autoload-require 'inlimg 'lp '(nxhtml-download-root-url nil) "util/inlimg" nxhtml-install-dir 'nxhtml-byte-compile-file)
840 (let ((loads (get 'inlimg 'custom-loads))) (if (member '"inlimg" loads) nil (put 'inlimg 'custom-loads (cons '"inlimg" loads))))
842 (nxhtml-autoload 'inlimg-mode `(lp '(nxhtml-download-root-url nil) "util/inlimg" nxhtml-install-dir) "\
843 Display images inline.
844 Search buffer for image tags. Display found images.
846 Image tags are setup per major mode in `inlimg-mode-specs'.
848 Images are displayed on a line below the tag referencing them.
849 The whole image or a slice of it may be displayed, see
850 `inlimg-slice'. Margins relative text are specified in
853 See also the commands `inlimg-toggle-display' and
854 `inlimg-toggle-slicing'.
856 Note: This minor mode uses `font-lock-mode'.
858 \(fn &optional ARG)" t nil)
860 (defvar inlimg-global-mode nil "\
861 Non-nil if Inlimg-Global mode is enabled.
862 See the command `inlimg-global-mode' for a description of this minor mode.
863 Setting this variable directly does not take effect;
864 either customize it (see the info node `Easy Customization')
865 or call the function `inlimg-global-mode'.")
867 (nxhtml-custom-autoload 'inlimg-global-mode 'inlimg nil)
869 (nxhtml-autoload 'inlimg-global-mode `(lp '(nxhtml-download-root-url nil) "util/inlimg" nxhtml-install-dir) "\
870 Toggle Inlimg mode in every possible buffer.
871 With prefix ARG, turn Inlimg-Global mode on if and only if
873 Inlimg mode is enabled in all buffers where
874 `inlimg--global-turn-on' would do it.
875 See `inlimg-mode' for more information on Inlimg mode.
877 \(fn &optional ARG)" t nil)
879 (nxhtml-autoload 'inlimg-toggle-display `(lp '(nxhtml-download-root-url nil) "util/inlimg" nxhtml-install-dir) "\
880 Toggle display of image at point POINT.
881 See also the command `inlimg-mode'.
885 (nxhtml-autoload 'inlimg-toggle-slicing `(lp '(nxhtml-download-root-url nil) "util/inlimg" nxhtml-install-dir) "\
886 Toggle slicing of image at point POINT.
887 See also the command `inlimg-mode'.
893 ;;;### (autoloads (majmodpri majmodpri-apply-priorities majmodpri-apply
894 ;;;;;; majmodpri-sort-lists) "majmodpri" "util/majmodpri.el" (19407
896 ;;; Generated autoloads from util/majmodpri.el
897 (web-autoload-require 'majmodpri 'lp '(nxhtml-download-root-url nil) "util/majmodpri" nxhtml-install-dir 'nxhtml-byte-compile-file)
900 (nxhtml-autoload 'majmodpri-sort-lists `(lp '(nxhtml-download-root-url nil) "util/majmodpri" nxhtml-install-dir) "\
901 Sort the list used when selecting major mode.
902 Only sort those lists choosen in `majmodpri-lists-to-sort'.
903 Sort according to priorities in `majmodpri-mode-priorities'.
904 Keep the old order in the list otherwise.
906 The lists can be sorted when loading elisp libraries, see
907 `majmodpri-sort-after-load'.
909 See also `majmodpri-apply-priorities'.
913 (nxhtml-autoload 'majmodpri-apply `(lp '(nxhtml-download-root-url nil) "util/majmodpri" nxhtml-install-dir) "\
914 Sort major mode lists and apply to existing buffers.
915 Note: This function is suitable to add to
916 `desktop-after-read-hook'. It will restore the multi major modes
921 (nxhtml-autoload 'majmodpri-apply-priorities `(lp '(nxhtml-download-root-url nil) "util/majmodpri" nxhtml-install-dir) "\
922 Apply major mode priorities.
923 First run `majmodpri-sort-lists' and then if CHANGE-MODES is
924 non-nil apply to existing file buffers. If interactive ask
927 \(fn CHANGE-MODES)" t nil)
929 (let ((loads (get 'majmodpri 'custom-loads))) (if (member '"majmodpri" loads) nil (put 'majmodpri 'custom-loads (cons '"majmodpri" loads))))
933 ;;;### (autoloads (markchars-global-mode markchars-mode markchars)
934 ;;;;;; "markchars" "util/markchars.el" (19372 5886))
935 ;;; Generated autoloads from util/markchars.el
936 (web-autoload-require 'markchars 'lp '(nxhtml-download-root-url nil) "util/markchars" nxhtml-install-dir 'nxhtml-byte-compile-file)
939 (let ((loads (get 'markchars 'custom-loads))) (if (member '"markchars" loads) nil (put 'markchars 'custom-loads (cons '"markchars" loads))))
941 (nxhtml-autoload 'markchars-mode `(lp '(nxhtml-download-root-url nil) "util/markchars" nxhtml-install-dir) "\
942 Mark special characters.
943 Which characters to mark are defined by `markchars-keywords'.
945 The default is to mark non-IDN, non-ascii chars with a magenta
948 For information about IDN chars see `idn-is-recommended'.
950 If you change anything in the customization group `markchars' you
951 must restart this minor mode for the changes to take effect.
953 \(fn &optional ARG)" t nil)
955 (defvar markchars-global-mode nil "\
956 Non-nil if Markchars-Global mode is enabled.
957 See the command `markchars-global-mode' for a description of this minor mode.
958 Setting this variable directly does not take effect;
959 either customize it (see the info node `Easy Customization')
960 or call the function `markchars-global-mode'.")
962 (nxhtml-custom-autoload 'markchars-global-mode 'markchars nil)
964 (nxhtml-autoload 'markchars-global-mode `(lp '(nxhtml-download-root-url nil) "util/markchars" nxhtml-install-dir) "\
965 Toggle Markchars mode in every possible buffer.
966 With prefix ARG, turn Markchars-Global mode on if and only if
968 Markchars mode is enabled in all buffers where
969 `(lambda nil (markchars-mode 1))' would do it.
970 See `markchars-mode' for more information on Markchars mode.
972 \(fn &optional ARG)" t nil)
976 ;;;### (autoloads (mlinks-global-mode mlinks-mode mlinks) "mlinks"
977 ;;;;;; "util/mlinks.el" (19364 56214))
978 ;;; Generated autoloads from util/mlinks.el
979 (web-autoload-require 'mlinks 'lp '(nxhtml-download-root-url nil) "util/mlinks" nxhtml-install-dir 'nxhtml-byte-compile-file)
982 (let ((loads (get 'mlinks 'custom-loads))) (if (member '"mlinks" loads) nil (put 'mlinks 'custom-loads (cons '"mlinks" loads))))
984 (nxhtml-autoload 'mlinks-mode `(lp '(nxhtml-download-root-url nil) "util/mlinks" nxhtml-install-dir) "\
985 Recognizes certain parts of a buffer as hyperlinks.
986 The hyperlinks are created in different ways for different major
987 modes with the help of the functions in the list
988 `mlinks-mode-functions'.
990 The hyperlinks can be hilighted when point is over them. Use
991 `mlinks-toggle-hilight' to toggle this feature for the current
994 All keybindings in this mode are by default done under the prefi§x
999 which is supposed to be a kind of mnemonic for link (alluding to
1000 the RET key commonly used in web browser to follow a link).
1001 \(Unfortunately this breaks the rules in info node `Key Binding
1002 Conventions'.) Below are the key bindings defined by this mode:
1006 For some major modes `mlinks-backward-link' and
1007 `mlinks-forward-link' will take you to the previous/next link.
1008 By default the link moved to will be active, see
1009 `mlinks-active-links'.
1011 \(fn &optional ARG)" t nil)
1013 (defvar mlinks-global-mode nil "\
1014 Non-nil if Mlinks-Global mode is enabled.
1015 See the command `mlinks-global-mode' for a description of this minor mode.
1016 Setting this variable directly does not take effect;
1017 either customize it (see the info node `Easy Customization')
1018 or call the function `mlinks-global-mode'.")
1020 (nxhtml-custom-autoload 'mlinks-global-mode 'mlinks nil)
1022 (nxhtml-autoload 'mlinks-global-mode `(lp '(nxhtml-download-root-url nil) "util/mlinks" nxhtml-install-dir) "\
1023 Toggle Mlinks mode in every possible buffer.
1024 With prefix ARG, turn Mlinks-Global mode on if and only if
1026 Mlinks mode is enabled in all buffers where
1027 `mlinks-turn-on-in-buffer' would do it.
1028 See `mlinks-mode' for more information on Mlinks mode.
1030 \(fn &optional ARG)" t nil)
1034 ;;;### (autoloads (mumamo-multi-major-modep mumamo-list-defined-multi-major-modes
1035 ;;;;;; mumamo-mark-for-refontification mumamo-hi-lock-faces mumamo
1036 ;;;;;; mumamo-add-to-defined-multi-major-modes define-mumamo-multi-major-mode)
1037 ;;;;;; "mumamo" "util/mumamo.el" (19412 26290))
1038 ;;; Generated autoloads from util/mumamo.el
1039 (web-autoload-require 'mumamo 'lp '(nxhtml-download-root-url nil) "util/mumamo" nxhtml-install-dir 'nxhtml-byte-compile-file)
1042 (nxhtml-autoload 'define-mumamo-multi-major-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo" nxhtml-install-dir) "\
1043 Define a function that turn on support for multiple major modes.
1044 Define a function FUN-SYM that set up to divide the current
1045 buffer into chunks with different major modes.
1047 The documentation string for FUN-SYM should contain the special
1048 documentation in the string SPEC-DOC, general documentation for
1049 functions of this type and information about chunks.
1051 The new function will use the definitions in CHUNKS (which is
1052 called a \"chunk family\") to make the dividing of the buffer.
1054 The function FUN-SYM can be used to setup a buffer instead of a
1055 major mode function:
1057 - The function FUN-SYM can be called instead of calling a major
1058 mode function when you want to use multiple major modes in a
1061 - The defined function can be used instead of a major mode
1062 function in for example `auto-mode-alist'.
1064 - As the very last thing FUN-SYM will run the hook FUN-SYM-hook,
1065 just as major modes do.
1067 - There is also a general hook, `mumamo-turn-on-hook', which is
1068 run when turning on mumamo with any of these functions. This
1069 is run right before the hook specific to any of the functions
1070 above that turns on the multiple major mode support.
1072 - The multi major mode FUN-SYM has a keymap named FUN-SYM-map.
1073 This overrides the major modes' keymaps since it is handled as
1074 a minor mode keymap.
1076 - There is also a special mumamo keymap, `mumamo-map' that is
1077 active in every buffer with a multi major mode. This is also
1078 handled as a minor mode keymap and therefor overrides the major
1081 - However when this support for multiple major mode is on the
1082 buffer is divided into chunks, each with its own major mode.
1084 - The chunks are fontified according the major mode assigned to
1087 - Indenting is also done according to the major mode assigned to
1090 - The actual major mode used in the buffer is changed to the one
1091 in the chunk when moving point between these chunks.
1093 - When major mode is changed the hooks for the new major mode,
1094 `after-change-major-mode-hook' and `change-major-mode-hook' are
1097 - There will be an alias for FUN-SYM called mumamo-alias-FUN-SYM.
1098 This can be used to check whic multi major modes have been
1101 ** A little bit more technical description:
1103 The dividing of a buffer into chunks is done during fontification
1104 by `mumamo-get-chunk-at'.
1106 The name of the function is saved in in the buffer local variable
1107 `mumamo-multi-major-mode' when the function is called.
1109 All functions defined by this macro is added to the list
1110 `mumamo-defined-multi-major-modes'.
1112 Basically Mumamo handles only major modes that uses jit-lock.
1113 However as a special effort also `nxml-mode' and derivatives
1114 thereof are handled. Since it seems impossible to me to restrict
1115 those major modes fontification to only a chunk without changing
1116 `nxml-mode' the fontification is instead done by
1117 `html-mode'/`sgml-mode' for chunks using `nxml-mode' and its
1120 CHUNKS is a list where each entry have the format
1122 (CHUNK-DEF-NAME MAIN-MAJOR-MODE SUBMODE-CHUNK-FUNCTIONS)
1124 CHUNK-DEF-NAME is the key name by which the entry is recognized.
1125 MAIN-MAJOR-MODE is the major mode used when there is no chunks.
1126 If this is nil then `major-mode' before turning on this mode will
1129 SUBMODE-CHUNK-FUNCTIONS is a list of the functions that does the
1130 chunk division of the buffer. They are tried in the order they
1131 appear here during the chunk division process.
1133 If you want to write new functions for chunk divisions then
1134 please see `mumamo-find-possible-chunk'. You can perhaps also
1135 use `mumamo-quick-static-chunk' which is more easy-to-use
1136 alternative. See also the file mumamo-fun.el where there are
1137 many routines for chunk division.
1139 When you write those new functions you may want to use some of
1140 the functions for testing chunks:
1142 `mumamo-test-create-chunk-at' `mumamo-test-create-chunks-at-all'
1143 `mumamo-test-easy-make' `mumamo-test-fontify-region'
1145 These are in the file mumamo-test.el.
1147 \(fn FUN-SYM SPEC-DOC CHUNKS)" nil (quote macro))
1149 (nxhtml-autoload 'mumamo-add-to-defined-multi-major-modes `(lp '(nxhtml-download-root-url nil) "util/mumamo" nxhtml-install-dir) "\
1152 \(fn ENTRY)" nil nil)
1154 (let ((loads (get 'mumamo 'custom-loads))) (if (member '"mumamo" loads) nil (put 'mumamo 'custom-loads (cons '"mumamo" loads))))
1156 (let ((loads (get 'mumamo-hi-lock-faces 'custom-loads))) (if (member '"mumamo" loads) nil (put 'mumamo-hi-lock-faces 'custom-loads (cons '"mumamo" loads))))
1158 (nxhtml-autoload 'mumamo-mark-for-refontification `(lp '(nxhtml-download-root-url nil) "util/mumamo" nxhtml-install-dir) "\
1159 Mark region between MIN and MAX for refontification.
1161 \(fn MIN MAX)" nil nil)
1163 (nxhtml-autoload 'mumamo-list-defined-multi-major-modes `(lp '(nxhtml-download-root-url nil) "util/mumamo" nxhtml-install-dir) "\
1164 List currently defined multi major modes.
1165 If SHOW-DOC is non-nil show the doc strings added when defining
1166 them. (This is not the full doc string. To show the full doc
1167 string you can click on the multi major mode in the list.)
1169 If SHOW-CHUNKS is non-nil show the names of the chunk dividing
1170 functions each multi major mode uses.
1172 If MATCH then show only multi major modes whos names matches.
1174 \(fn SHOW-DOC SHOW-CHUNKS MATCH)" t nil)
1176 (nxhtml-autoload 'mumamo-multi-major-modep `(lp '(nxhtml-download-root-url nil) "util/mumamo" nxhtml-install-dir) "\
1177 Return t if VALUE is a multi major mode function.
1179 \(fn VALUE)" nil nil)
1183 ;;;### (autoloads (python-rst-mumamo-mode latex-haskell-mumamo-mode
1184 ;;;;;; latex-clojure-mumamo-mode markdown-html-mumamo-mode xsl-sgml-mumamo-mode
1185 ;;;;;; xsl-nxml-mumamo-mode mako-html-mumamo-mode org-mumamo-mode
1186 ;;;;;; asp-html-mumamo-mode noweb2-mumamo-mode mumamo-noweb2 csound-sgml-mumamo-mode
1187 ;;;;;; laszlo-nxml-mumamo-mode metapost-mumamo-mode ruby-heredoc-mumamo-mode
1188 ;;;;;; python-heredoc-mumamo-mode cperl-heredoc-mumamo-mode perl-heredoc-mumamo-mode
1189 ;;;;;; php-heredoc-mumamo-mode sh-heredoc-mumamo-mode eruby-javascript-mumamo-mode
1190 ;;;;;; eruby-html-mumamo-mode eruby-mumamo-mode jsp-html-mumamo-mode
1191 ;;;;;; gsp-html-mumamo-mode ssjs-html-mumamo-mode smarty-html-mumamo-mode
1192 ;;;;;; mjt-html-mumamo-mode genshi-html-mumamo-mode django-html-mumamo-mode
1193 ;;;;;; embperl-html-mumamo-mode mason-html-mumamo-mode nxml-mumamo-mode
1194 ;;;;;; html-mumamo-mode mumamo-define-html-file-wide-keys) "mumamo-fun"
1195 ;;;;;; "util/mumamo-fun.el" (19410 22971))
1196 ;;; Generated autoloads from util/mumamo-fun.el
1197 (web-autoload-require 'mumamo-fun 'lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir 'nxhtml-byte-compile-file)
1200 (nxhtml-autoload 'mumamo-define-html-file-wide-keys `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1201 Define keys in multi major mode keymap for html files.
1205 (nxhtml-autoload 'html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1206 Turn on multiple major modes for (X)HTML with main mode `html-mode'.
1207 This covers inlined style and javascript and PHP." t)
1209 (nxhtml-autoload 'nxml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1210 Turn on multiple major modes for (X)HTML with main mode `nxml-mode'.
1211 This covers inlined style and javascript and PHP.
1213 See also `mumamo-alt-php-tags-mode'." t)
1215 (nxhtml-autoload 'mason-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1216 Turn on multiple major modes for Mason using main mode `html-mode'.
1217 This covers inlined style and javascript." t)
1219 (nxhtml-autoload 'embperl-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1220 Turn on multiple major modes for Embperl files with main mode `html-mode'.
1221 This also covers inlined style and javascript." t)
1223 (nxhtml-autoload 'django-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1224 Turn on multiple major modes for Django with main mode `html-mode'.
1225 This also covers inlined style and javascript." t)
1227 (nxhtml-autoload 'genshi-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1228 Turn on multiple major modes for Genshi with main mode `html-mode'.
1229 This also covers inlined style and javascript." t)
1231 (nxhtml-autoload 'mjt-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1232 Turn on multiple major modes for MJT with main mode `html-mode'.
1233 This also covers inlined style and javascript." t)
1235 (nxhtml-autoload 'smarty-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1236 Turn on multiple major modes for Smarty with main mode `html-mode'.
1237 This also covers inlined style and javascript." t)
1239 (nxhtml-autoload 'ssjs-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1240 Turn on multiple major modes for SSJS with main mode `html-mode'.
1241 This covers inlined style and javascript." t)
1243 (nxhtml-autoload 'gsp-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1244 Turn on multiple major modes for GSP with main mode `html-mode'.
1245 This also covers inlined style and javascript." t)
1247 (nxhtml-autoload 'jsp-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1248 Turn on multiple major modes for JSP with main mode `html-mode'.
1249 This also covers inlined style and javascript." t)
1251 (nxhtml-autoload 'eruby-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1252 Turn on multiple major mode for eRuby with unspecified main mode.
1253 Current major-mode will be used as the main major mode." t)
1255 (nxhtml-autoload 'eruby-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1256 Turn on multiple major modes for eRuby with main mode `html-mode'.
1257 This also covers inlined style and javascript." t)
1259 (nxhtml-autoload 'eruby-javascript-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1260 Turn on multiple major modes for eRuby with main mode `javascript-mode'." t)
1262 (nxhtml-autoload 'sh-heredoc-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1263 Turn on multiple major modes for sh heredoc document.
1264 See `mumamo-heredoc-modes' for how to specify heredoc major modes." t)
1266 (nxhtml-autoload 'php-heredoc-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1267 Turn on multiple major modes for PHP heredoc document.
1268 See `mumamo-heredoc-modes' for how to specify heredoc major modes." t)
1270 (nxhtml-autoload 'perl-heredoc-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1271 Turn on multiple major modes for Perl heredoc document.
1272 See `mumamo-heredoc-modes' for how to specify heredoc major modes." t)
1274 (nxhtml-autoload 'cperl-heredoc-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1275 Turn on multiple major modes for Perl heredoc document.
1276 See `mumamo-heredoc-modes' for how to specify heredoc major modes." t)
1278 (nxhtml-autoload 'python-heredoc-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1279 Turn on multiple major modes for Perl heredoc document.
1280 See `mumamo-heredoc-modes' for how to specify heredoc major modes." t)
1282 (nxhtml-autoload 'ruby-heredoc-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1283 Turn on multiple major modes for Ruby heredoc document.
1284 See `mumamo-heredoc-modes' for how to specify heredoc major modes." t)
1286 (nxhtml-autoload 'metapost-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1287 Turn on multiple major modes for MetaPost." t)
1289 (nxhtml-autoload 'laszlo-nxml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1290 Turn on multiple major modes for OpenLaszlo." t)
1292 (nxhtml-autoload 'csound-sgml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1293 Turn on mutiple major modes for CSound orc/sco Modes." t)
1295 (let ((loads (get 'mumamo-noweb2 'custom-loads))) (if (member '"mumamo-fun" loads) nil (put 'mumamo-noweb2 'custom-loads (cons '"mumamo-fun" loads))))
1297 (nxhtml-autoload 'noweb2-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1298 Multi major mode for noweb files." t)
1300 (nxhtml-autoload 'asp-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1301 Turn on multiple major modes for ASP with main mode `html-mode'.
1302 This also covers inlined style and javascript." t)
1304 (nxhtml-autoload 'org-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1305 Turn on multiple major modes for `org-mode' files with main mode `org-mode'.
1306 ** Note about HTML subchunks:
1307 Unfortunately this only allows `html-mode' (not `nxhtml-mode') in
1310 (nxhtml-autoload 'mako-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1311 Turn on multiple major modes for Mako with main mode `html-mode'.
1312 This also covers inlined style and javascript." t)
1314 (nxhtml-autoload 'xsl-nxml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1315 Turn on multi major mode for XSL with main mode `nxml-mode'.
1316 This covers inlined style and javascript." t)
1318 (nxhtml-autoload 'xsl-sgml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1319 Turn on multi major mode for XSL with main mode `sgml-mode'.
1320 This covers inlined style and javascript." t)
1322 (nxhtml-autoload 'markdown-html-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1323 Turn on multi major markdown mode in buffer.
1324 Main major mode will be `markdown-mode'.
1325 Inlined html will be in `html-mode'.
1327 You need `markdown-mode' which you can download from URL
1328 `http://jblevins.org/projects/markdown-mode/'." t)
1330 (nxhtml-autoload 'latex-clojure-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1331 Turn on multi major mode latex+clojure.
1332 Main major mode will be `latex-mode'.
1333 Subchunks will be in `clojure-mode'.
1335 You will need `clojure-mode' which you can download from URL
1336 `http://github.com/jochu/clojure-mode/tree'." t)
1338 (nxhtml-autoload 'latex-haskell-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1339 Turn on multi major mode latex+haskell.
1340 Main major mode will be `latex-mode'.
1341 Subchunks will be in `haskell-mode'.
1343 You will need `haskell-mode' which you can download from URL
1344 `http://projects.haskell.org/haskellmode-emacs/'." t)
1346 (nxhtml-autoload 'python-rst-mumamo-mode `(lp '(nxhtml-download-root-url nil) "util/mumamo-fun" nxhtml-install-dir) "\
1347 Turn on multiple major modes for Python with RestructuredText docstrings." t)
1351 ;;;### (autoloads (mumamo-add-region-from-string mumamo-add-region)
1352 ;;;;;; "mumamo-regions" "util/mumamo-regions.el" (19275 63380))
1353 ;;; Generated autoloads from util/mumamo-regions.el
1354 (web-autoload-require 'mumamo-regions 'lp '(nxhtml-download-root-url nil) "util/mumamo-regions" nxhtml-install-dir 'nxhtml-byte-compile-file)
1357 (nxhtml-autoload 'mumamo-add-region `(lp '(nxhtml-download-root-url nil) "util/mumamo-regions" nxhtml-install-dir) "\
1358 Add a mumamo region from selection.
1359 Mumamo regions are like another layer of chunks above the normal chunks.
1360 They does not affect the normal chunks, but they overrides them.
1362 To create a mumamo region first select a visible region and then
1365 If the buffer is not in a multi major mode a temporary multi
1366 major mode will be created applied to the buffer first.
1367 To get out of this and get back to a single major mode just use
1373 (nxhtml-autoload 'mumamo-add-region-from-string `(lp '(nxhtml-download-root-url nil) "util/mumamo-regions" nxhtml-install-dir) "\
1374 Add a mumamo region from string at point.
1375 Works as `mumamo-add-region' but for string or comment at point.
1377 Buffer must be fontified.
1383 ;;;### (autoloads (n-back-game n-back) "n-back" "util/n-back.el"
1384 ;;;;;; (19278 15746))
1385 ;;; Generated autoloads from util/n-back.el
1386 (web-autoload-require 'n-back 'lp '(nxhtml-download-root-url nil) "util/n-back" nxhtml-install-dir 'nxhtml-byte-compile-file)
1389 (let ((loads (get 'n-back 'custom-loads))) (if (member '"n-back" loads) nil (put 'n-back 'custom-loads (cons '"n-back" loads))))
1391 (nxhtml-autoload 'n-back-game `(lp '(nxhtml-download-root-url nil) "util/n-back" nxhtml-install-dir) "\
1393 This game is supposed to increase your working memory and fluid
1396 In this game something is shown for half a second on the screen
1397 and maybe a sound is played. You should then answer if parts of
1398 it is the same as you have seen or heard before. This is
1399 repeated for about 20 trials.
1401 You answer with the keys shown in the bottom window.
1403 In the easiest version of the game you should answer if you have
1404 just seen or heard what is shown now. By default the game gets
1405 harder as you play it with success. Then first the number of
1406 items presented in a trial grows. After that it gets harder by
1407 that you have to somehow remember not the last item, but the item
1408 before that (or even earlier). That is what \"n-Back\" stands
1411 Note that remember does not really mean remember clearly. The
1412 game is for training your brain getting used to keep those things
1413 in the working memory, maybe as a cross-modal unit. You are
1414 supposed to just nearly be able to do what you do in the game.
1415 And you are supposed to have fun, that is what your brain like.
1417 You should probably not overdue this. Half an hour a day playing
1418 might be an optimal time according to some people.
1420 The game is shamelessly modeled after Brain Workshop, see URL
1421 `http://brainworkshop.sourceforge.net/' just for the fun of
1422 getting it into Emacs. The game resembles but it not the same as
1423 that used in the report by Jaeggi mentioned at the above URL.
1425 Not all features in Brain Workshop are implemented here, but some
1426 new are maybe ... - and you have it available here in Emacs.
1432 ;;;### (autoloads (nxhtmltest-run nxhtmltest-run-indent) "nxhtmltest-suites"
1433 ;;;;;; "tests/nxhtmltest-suites.el" (19360 6294))
1434 ;;; Generated autoloads from tests/nxhtmltest-suites.el
1435 (web-autoload-require 'nxhtmltest-suites 'lp '(nxhtml-download-root-url nil) "tests/nxhtmltest-suites" nxhtml-install-dir 'nxhtml-byte-compile-file)
1438 (nxhtml-autoload 'nxhtmltest-run-indent `(lp '(nxhtml-download-root-url nil) "tests/nxhtmltest-suites" nxhtml-install-dir) "\
1439 Run indentation tests.
1443 (nxhtml-autoload 'nxhtmltest-run `(lp '(nxhtml-download-root-url nil) "tests/nxhtmltest-suites" nxhtml-install-dir) "\
1444 Run all tests defined for nXhtml.
1445 Currently there are only tests using ert.el defined.
1447 Note that it is currently expected that the following tests will
1448 fail (they corresponds to known errors in nXhtml/Emacs):
1450 `nxhtml-ert-nxhtml-changes-jump-back-10549'
1451 `nxhtml-ert-nxhtml-changes-jump-back-7014'
1457 ;;;### (autoloads (nxhtmltest-run-Q) "nxhtmltest-Q" "tests/nxhtmltest-Q.el"
1458 ;;;;;; (19264 36684))
1459 ;;; Generated autoloads from tests/nxhtmltest-Q.el
1460 (web-autoload-require 'nxhtmltest-Q 'lp '(nxhtml-download-root-url nil) "tests/nxhtmltest-Q" nxhtml-install-dir 'nxhtml-byte-compile-file)
1463 (nxhtml-autoload 'nxhtmltest-run-Q `(lp '(nxhtml-download-root-url nil) "tests/nxhtmltest-Q" nxhtml-install-dir) "\
1464 Run all tests defined for nXhtml in fresh Emacs.
1465 See `nxhtmltest-run' for more information about the tests.
1471 ;;;### (autoloads (ert-run-tests-interactively ert-deftest) "ert"
1472 ;;;;;; "tests/ert.el" (19173 56140))
1473 ;;; Generated autoloads from tests/ert.el
1474 (web-autoload-require 'ert 'lp '(nxhtml-download-root-url nil) "tests/ert" nxhtml-install-dir 'nxhtml-byte-compile-file)
1477 (nxhtml-autoload 'ert-deftest `(lp '(nxhtml-download-root-url nil) "tests/ert" nxhtml-install-dir) "\
1478 Define NAME (a symbol) as a test.
1480 \(fn NAME () [:documentation DOCSTRING] [:expected-result TYPE] BODY...)" nil (quote macro))
1482 (nxhtml-autoload 'ert-run-tests-interactively `(lp '(nxhtml-download-root-url nil) "tests/ert" nxhtml-install-dir) "\
1483 Run the tests specified by SELECTOR and display the results in a buffer.
1485 \(fn SELECTOR &optional OUTPUT-BUFFER-NAME MESSAGE-FN)" t nil)
1489 ;;;### (autoloads (ocr-user-mode) "ocr-user" "util/ocr-user.el" (19290
1491 ;;; Generated autoloads from util/ocr-user.el
1492 (web-autoload-require 'ocr-user 'lp '(nxhtml-download-root-url nil) "util/ocr-user" nxhtml-install-dir 'nxhtml-byte-compile-file)
1495 (nxhtml-autoload 'ocr-user-mode `(lp '(nxhtml-download-root-url nil) "util/ocr-user" nxhtml-install-dir) "\
1496 Color up digits three by three.
1498 \(fn &optional ARG)" t nil)
1502 ;;;### (autoloads (ourcomments-warning ourcomments-M-x-menu-mode
1503 ;;;;;; ourcomments-paste-with-convert-mode use-custom-style info-open-file
1504 ;;;;;; replace-read-files rdir-query-replace ldir-query-replace
1505 ;;;;;; grep-query-replace emacs-Q-nxhtml emacs-Q emacs--no-desktop
1506 ;;;;;; emacs--debug-init emacs-buffer-file emacs emacs-restart ourcomments-ido-ctrl-tab
1507 ;;;;;; ourcomments-ido-buffer-raise-frame ourcomments-ido-buffer-other-frame
1508 ;;;;;; ourcomments-ido-buffer-other-window describe-symbol describe-defstruct
1509 ;;;;;; describe-custom-group narrow-to-comment buffer-narrowed-p
1510 ;;;;;; describe-command ourcomments-ediff-files find-emacs-other-file
1511 ;;;;;; ourcomments-insert-date-and-time describe-timers ourcomments-copy+paste-set-point
1512 ;;;;;; better-fringes-mode describe-key-and-map-briefly ourcomments-move-end-of-line
1513 ;;;;;; ourcomments-move-beginning-of-line ourcomments-mark-whole-buffer-or-field
1514 ;;;;;; fill-dwim unfill-individual-paragraphs unfill-region unfill-paragraph
1515 ;;;;;; define-toggle-old define-toggle popup-menu-at-point ourcomments-indirect-fun)
1516 ;;;;;; "ourcomments-util" "util/ourcomments-util.el" (19411 29548))
1517 ;;; Generated autoloads from util/ourcomments-util.el
1518 (web-autoload-require 'ourcomments-util 'lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir 'nxhtml-byte-compile-file)
1521 (nxhtml-autoload 'ourcomments-indirect-fun `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1522 Get the alias symbol for function FUN if any.
1526 (nxhtml-autoload 'popup-menu-at-point `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1527 Popup the given menu at point.
1528 This is similar to `popup-menu' and MENU and PREFIX has the same
1529 meaning as there. The position for the popup is however where
1530 the window point is.
1532 \(fn MENU &optional PREFIX)" nil nil)
1534 (nxhtml-autoload 'define-toggle `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1535 Declare SYMBOL as a customizable variable with a toggle function.
1536 The purpose of this macro is to define a defcustom and a toggle
1537 function suitable for use in a menu.
1539 The arguments have the same meaning as for `defcustom' with these
1542 - The :type keyword cannot be used. Type is always 'boolean.
1543 - VALUE must be t or nil.
1545 DOC and ARGS are just passed to `defcustom'.
1547 A `defcustom' named SYMBOL with doc-string DOC and a function
1548 named SYMBOL-toggle is defined. The function toggles the value
1549 of SYMBOL. It takes no parameters.
1551 To create a menu item something similar to this can be used:
1553 (define-key map [SYMBOL]
1554 (list 'menu-item \"Toggle nice SYMBOL\"
1556 :button '(:toggle . SYMBOL)))
1558 \(fn SYMBOL VALUE DOC &rest ARGS)" nil (quote macro))
1560 (nxhtml-autoload 'define-toggle-old `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1563 \(fn SYMBOL VALUE DOC &rest ARGS)" nil (quote macro))
1565 (nxhtml-autoload 'unfill-paragraph `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1566 Unfill the current paragraph.
1570 (nxhtml-autoload 'unfill-region `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1571 Unfill the current region.
1575 (nxhtml-autoload 'unfill-individual-paragraphs `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1576 Unfill individual paragraphs in the current region.
1580 (nxhtml-autoload 'fill-dwim `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1581 Fill or unfill paragraph or region.
1582 With prefix ARG fill only current line.
1586 (nxhtml-autoload 'ourcomments-mark-whole-buffer-or-field `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1587 Mark whole buffer or editable field at point.
1591 (nxhtml-autoload 'ourcomments-move-beginning-of-line `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1592 Move point to beginning of line or indentation.
1593 See `beginning-of-line' for ARG.
1595 If `line-move-visual' is non-nil then the visual line beginning
1598 If in a widget field stay in that.
1602 (nxhtml-autoload 'ourcomments-move-end-of-line `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1603 Move point to end of line or after last non blank char.
1604 See `end-of-line' for ARG.
1606 Similar to `ourcomments-move-beginning-of-line' but for end of
1611 (nxhtml-autoload 'describe-key-and-map-briefly `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1612 Try to print names of keymap from which KEY fetch its definition.
1613 Look in current active keymaps and find keymap variables with the
1614 same value as the keymap where KEY is bound. Print a message
1615 with those keymap variable names. Return a list with the keymap
1618 When called interactively prompt for KEY.
1620 INSERT and UNTRANSLATED should normall be nil (and I am not sure
1621 what they will do ;-).
1623 \(fn &optional KEY INSERT UNTRANSLATED)" t nil)
1625 (defvar better-fringes-mode nil "\
1626 Non-nil if Better-Fringes mode is enabled.
1627 See the command `better-fringes-mode' for a description of this minor mode.
1628 Setting this variable directly does not take effect;
1629 either customize it (see the info node `Easy Customization')
1630 or call the function `better-fringes-mode'.")
1632 (nxhtml-custom-autoload 'better-fringes-mode 'ourcomments-util nil)
1634 (nxhtml-autoload 'better-fringes-mode `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1635 Choose another fringe bitmap color and bottom angle.
1637 \(fn &optional ARG)" t nil)
1639 (nxhtml-autoload 'ourcomments-copy+paste-set-point `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1640 Set point for copy+paste here.
1641 Enable temporary minor mode `ourcomments-copy+paste-mode'.
1642 However if point for copy+paste already is set then cancel it and
1643 disable the minor mode.
1645 The purpose of this command is to make it easy to grab a piece of
1646 text and paste it at current position. After this command you
1647 should select a piece of text to copy and then call the command
1648 `ourcomments-copy+paste'.
1652 (nxhtml-autoload 'describe-timers `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1653 Show timers with readable time format.
1657 (nxhtml-autoload 'ourcomments-insert-date-and-time `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1658 Insert date and time.
1659 See option `ourcomments-insert-date-and-time' for how to
1664 (nxhtml-autoload 'find-emacs-other-file `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1665 Find corresponding file to source or installed elisp file.
1666 If you have checked out and compiled Emacs yourself you may have
1667 Emacs lisp files in two places, the checked out source tree and
1668 the installed Emacs tree. If buffer contains an Emacs elisp file
1669 in one of these places then find the corresponding elisp file in
1670 the other place. Return the file name of this file.
1672 Rename current buffer using your `uniquify-buffer-name-style' if
1675 When DISPLAY-FILE is non-nil display this file in other window
1676 and go to the same line number as in the current buffer.
1678 \(fn DISPLAY-FILE)" t nil)
1680 (nxhtml-autoload 'ourcomments-ediff-files `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1681 In directory DEF-DIR run `ediff-files' on files FILE-A and FILE-B.
1682 The purpose of this function is to make it eaiser to start
1683 `ediff-files' from a shell through Emacs Client.
1685 This is used in EmacsW32 in the file ediff.cmd where Emacs Client
1686 is called like this:
1688 @%emacs_client% -e \"(setq default-directory \\\"%emacs_cd%\\\")\"
1689 @%emacs_client% -n -e \"(ediff-files \\\"%f1%\\\" \\\"%f2%\\\")\"
1691 It can of course be done in a similar way with other shells.
1693 \(fn DEF-DIR FILE-A FILE-B)" nil nil)
1695 (nxhtml-autoload 'describe-command `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1696 Like `describe-function', but prompts only for interactive commands.
1698 \(fn COMMAND)" t nil)
1700 (nxhtml-autoload 'buffer-narrowed-p `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1701 Return non-nil if the current buffer is narrowed.
1705 (nxhtml-autoload 'narrow-to-comment `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1710 (nxhtml-autoload 'describe-custom-group `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1711 Describe customization group SYMBOL.
1713 \(fn SYMBOL)" t nil)
1715 (nxhtml-autoload 'describe-defstruct `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1718 \(fn SYMBOL)" t nil)
1720 (nxhtml-autoload 'describe-symbol `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1721 Show information about SYMBOL.
1722 Show SYMBOL plist and whether is is a variable or/and a
1725 \(fn SYMBOL)" t nil)
1727 (nxhtml-autoload 'ourcomments-ido-buffer-other-window `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1728 Show buffer in other window.
1732 (nxhtml-autoload 'ourcomments-ido-buffer-other-frame `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1733 Show buffer in other frame.
1737 (nxhtml-autoload 'ourcomments-ido-buffer-raise-frame `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1738 Raise frame showing buffer.
1742 (defvar ourcomments-ido-ctrl-tab nil "\
1743 Non-nil if Ourcomments-Ido-Ctrl-Tab mode is enabled.
1744 See the command `ourcomments-ido-ctrl-tab' for a description of this minor mode.
1745 Setting this variable directly does not take effect;
1746 either customize it (see the info node `Easy Customization')
1747 or call the function `ourcomments-ido-ctrl-tab'.")
1749 (nxhtml-custom-autoload 'ourcomments-ido-ctrl-tab 'ourcomments-util nil)
1751 (nxhtml-autoload 'ourcomments-ido-ctrl-tab `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1752 Enable buffer switching using C-Tab with function `ido-mode'.
1753 This changes buffer switching with function `ido-mode' the
1756 - You can use C-Tab.
1758 - You can show the selected buffer in three ways independent of
1759 how you entered function `ido-mode' buffer switching:
1761 * S-return: other window
1762 * C-return: other frame
1763 * M-return: raise frame
1765 Those keys are selected to at least be a little bit reminiscent
1766 of those in for example common web browsers.
1768 \(fn &optional ARG)" t nil)
1770 (nxhtml-autoload 'emacs-restart `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1771 Restart Emacs and start `server-mode' if on before.
1775 (nxhtml-autoload 'emacs `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1776 Start a new Emacs with default parameters.
1777 Additional ARGS are passed to the new Emacs.
1779 See also `ourcomments-started-emacs-use-output-buffer'.
1781 \(fn &rest ARGS)" t nil)
1783 (nxhtml-autoload 'emacs-buffer-file `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1784 Start a new Emacs showing current buffer file.
1785 Go to the current line and column in that file.
1786 If there is no buffer file then instead start with `dired'.
1788 This calls the function `emacs' with argument --no-desktop and
1789 the file or a call to dired.
1793 (nxhtml-autoload 'emacs--debug-init `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1794 Start a new Emacs with --debug-init parameter.
1795 This calls the function `emacs' with added arguments ARGS.
1797 \(fn &rest ARGS)" t nil)
1799 (nxhtml-autoload 'emacs--no-desktop `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1800 Start a new Emacs with --no-desktop parameter.
1801 This calls the function `emacs' with added arguments ARGS.
1803 \(fn &rest ARGS)" t nil)
1805 (nxhtml-autoload 'emacs-Q `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1806 Start a new Emacs with -Q parameter.
1807 Start new Emacs without any customization whatsoever.
1808 This calls the function `emacs' with added arguments ARGS.
1810 \(fn &rest ARGS)" t nil)
1812 (nxhtml-autoload 'emacs-Q-nxhtml `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1813 Start new Emacs with -Q and load nXhtml.
1814 This calls the function `emacs' with added arguments ARGS.
1816 \(fn &rest ARGS)" t nil)
1818 (nxhtml-autoload 'grep-query-replace `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1819 Do `query-replace-regexp' of FROM with TO, on all files in *grep*.
1820 Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
1821 If you exit (\\[keyboard-quit], RET or q), you can resume the query replace
1822 with the command \\[tags-loop-continue].
1824 \(fn FROM TO &optional DELIMITED)" t nil)
1826 (nxhtml-autoload 'ldir-query-replace `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1827 Replace FROM with TO in FILES in directory DIR.
1828 This runs `query-replace-regexp' in files matching FILES in
1831 See `tags-query-replace' for DELIMETED and more information.
1833 \(fn FROM TO FILES DIR &optional DELIMITED)" t nil)
1835 (nxhtml-autoload 'rdir-query-replace `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1836 Replace FROM with TO in FILES in directory tree ROOT.
1837 This runs `query-replace-regexp' in files matching FILES in
1838 directory tree ROOT.
1840 See `tags-query-replace' for DELIMETED and more information.
1842 \(fn FROM TO FILE-REGEXP ROOT &optional DELIMITED)" t nil)
1844 (nxhtml-autoload 'replace-read-files `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1845 Read files arg for replace.
1847 \(fn REGEXP &optional REPLACE)" nil nil)
1849 (nxhtml-autoload 'info-open-file `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1850 Open an info file in `Info-mode'.
1852 \(fn INFO-FILE)" t nil)
1854 (nxhtml-autoload 'use-custom-style `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1855 Setup like in `Custom-mode', but without things specific to Custom.
1859 (defvar ourcomments-paste-with-convert-mode nil "\
1860 Non-nil if Ourcomments-Paste-With-Convert mode is enabled.
1861 See the command `ourcomments-paste-with-convert-mode' for a description of this minor mode.
1862 Setting this variable directly does not take effect;
1863 either customize it (see the info node `Easy Customization')
1864 or call the function `ourcomments-paste-with-convert-mode'.")
1866 (nxhtml-custom-autoload 'ourcomments-paste-with-convert-mode 'ourcomments-util nil)
1868 (nxhtml-autoload 'ourcomments-paste-with-convert-mode `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1869 Pasted text may be automatically converted in this mode.
1870 The functions in `ourcomments-paste-with-convert-hook' are run
1871 after commands in `ourcomments-paste-with-convert-commands' if any
1872 of the functions returns non-nil that text is inserted instead of
1875 For exampel when this mode is on and you paste an html link in an
1876 `org-mode' buffer it will be directly converted to an org style
1877 link. (This is the default behaviour.)
1879 Tip: The Firefox plugin Copy as HTML Link is handy, see URL
1880 `https://addons.mozilla.org/en-US/firefox/addon/2617'.
1882 Note: This minor mode will defadvice the paste commands.
1884 \(fn &optional ARG)" t nil)
1886 (defvar ourcomments-M-x-menu-mode nil "\
1887 Non-nil if Ourcomments-M-X-Menu mode is enabled.
1888 See the command `ourcomments-M-x-menu-mode' for a description of this minor mode.
1889 Setting this variable directly does not take effect;
1890 either customize it (see the info node `Easy Customization')
1891 or call the function `ourcomments-M-x-menu-mode'.")
1893 (nxhtml-custom-autoload 'ourcomments-M-x-menu-mode 'ourcomments-util nil)
1895 (nxhtml-autoload 'ourcomments-M-x-menu-mode `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1896 Add commands started from Emacs menus to M-x history.
1897 The purpose of this is to make it easier to redo them and easier
1898 to learn how to do them from the command line (which is often
1899 faster if you know how to do it).
1901 Only commands that are not already in M-x history are added.
1903 \(fn &optional ARG)" t nil)
1905 (nxhtml-autoload 'ourcomments-warning `(lp '(nxhtml-download-root-url nil) "util/ourcomments-util" nxhtml-install-dir) "\
1908 \(fn FORMAT-STRING &rest ARGS)" nil nil)
1912 ;;;### (autoloads (major-modep major-or-multi-majorp) "ourcomments-widgets"
1913 ;;;;;; "util/ourcomments-widgets.el" (19275 63380))
1914 ;;; Generated autoloads from util/ourcomments-widgets.el
1915 (web-autoload-require 'ourcomments-widgets 'lp '(nxhtml-download-root-url nil) "util/ourcomments-widgets" nxhtml-install-dir 'nxhtml-byte-compile-file)
1917 (nxhtml-autoload 'command "ourcomments-widgets")
1919 (nxhtml-autoload 'major-or-multi-majorp `(lp '(nxhtml-download-root-url nil) "util/ourcomments-widgets" nxhtml-install-dir) "\
1920 Return t if VALUE is a major or multi major mode function.
1922 \(fn VALUE)" nil nil)
1924 (nxhtml-autoload 'major-modep `(lp '(nxhtml-download-root-url nil) "util/ourcomments-widgets" nxhtml-install-dir) "\
1925 Return t if VALUE is a major mode function.
1927 \(fn VALUE)" nil nil)
1928 (nxhtml-autoload 'major-mode-function "ourcomments-widgets")
1932 ;;;### (autoloads (pause-start-in-new-emacs pause-mode pause) "pause"
1933 ;;;;;; "util/pause.el" (19335 58922))
1934 ;;; Generated autoloads from util/pause.el
1935 (web-autoload-require 'pause 'lp '(nxhtml-download-root-url nil) "util/pause" nxhtml-install-dir 'nxhtml-byte-compile-file)
1938 (let ((loads (get 'pause 'custom-loads))) (if (member '"pause" loads) nil (put 'pause 'custom-loads (cons '"pause" loads))))
1940 (defvar pause-mode nil "\
1941 Non-nil if Pause mode is enabled.
1942 See the command `pause-mode' for a description of this minor mode.
1943 Setting this variable directly does not take effect;
1944 either customize it (see the info node `Easy Customization')
1945 or call the function `pause-mode'.")
1947 (nxhtml-custom-autoload 'pause-mode 'pause nil)
1949 (nxhtml-autoload 'pause-mode `(lp '(nxhtml-download-root-url nil) "util/pause" nxhtml-install-dir) "\
1950 This minor mode tries to make you take a break.
1951 It will jump up and temporary stop your work - even if you are
1952 not in Emacs. If you are in Emacs it will however try to be
1953 gentle and wait until you have been idle with the keyboard for a
1954 short while. (If you are not in Emacs it can't be gentle. How
1957 Then it will show you a special screen with a link to a yoga
1958 exercise you can do when you pause.
1960 After the pause you continue your work where you were
1963 \(fn &optional ARG)" t nil)
1965 (nxhtml-autoload 'pause-start-in-new-emacs `(lp '(nxhtml-download-root-url nil) "util/pause" nxhtml-install-dir) "\
1966 Start pause with interval AFTER-MINUTES in a new Emacs instance.
1967 The new Emacs instance will be started with -Q. However if
1968 `custom-file' is non-nil it will be loaded so you can still
1971 One way of using this function may be to put in your .emacs
1974 ;; for just one Emacs running pause
1975 (when server-mode (pause-start-in-new-emacs 15))
1977 See `pause-start' for more info.
1979 \(fn AFTER-MINUTES)" t nil)
1983 ;;;### (autoloads (global-pointback-mode pointback-mode) "pointback"
1984 ;;;;;; "util/pointback.el" (19023 47096))
1985 ;;; Generated autoloads from util/pointback.el
1986 (web-autoload-require 'pointback 'lp '(nxhtml-download-root-url nil) "util/pointback" nxhtml-install-dir 'nxhtml-byte-compile-file)
1989 (nxhtml-autoload 'pointback-mode `(lp '(nxhtml-download-root-url nil) "util/pointback" nxhtml-install-dir) "\
1990 Restore previous window point when switching back to a buffer.
1992 \(fn &optional ARG)" t nil)
1994 (defvar global-pointback-mode nil "\
1995 Non-nil if Global-Pointback mode is enabled.
1996 See the command `global-pointback-mode' for a description of this minor mode.
1997 Setting this variable directly does not take effect;
1998 either customize it (see the info node `Easy Customization')
1999 or call the function `global-pointback-mode'.")
2001 (nxhtml-custom-autoload 'global-pointback-mode 'pointback nil)
2003 (nxhtml-autoload 'global-pointback-mode `(lp '(nxhtml-download-root-url nil) "util/pointback" nxhtml-install-dir) "\
2004 Toggle Pointback mode in every possible buffer.
2005 With prefix ARG, turn Global-Pointback mode on if and only if
2007 Pointback mode is enabled in all buffers where
2008 `pointback-on' would do it.
2009 See `pointback-mode' for more information on Pointback mode.
2011 \(fn &optional ARG)" t nil)
2015 ;;;### (autoloads (popcmp-completing-read popcmp-completion-style
2016 ;;;;;; popcmp) "popcmp" "util/popcmp.el" (19365 33760))
2017 ;;; Generated autoloads from util/popcmp.el
2018 (web-autoload-require 'popcmp 'lp '(nxhtml-download-root-url nil) "util/popcmp" nxhtml-install-dir 'nxhtml-byte-compile-file)
2021 (let ((loads (get 'popcmp 'custom-loads))) (if (member '"popcmp" loads) nil (put 'popcmp 'custom-loads (cons '"popcmp" loads))))
2023 (defvar popcmp-completion-style (cond (t 'popcmp-popup)) "\
2025 The currently available completion styles are:
2027 - popcmp-popup: Use OS popup menus (default).
2028 - emacs-default: Emacs default completion.
2029 - Company Mode completion.
2030 - anything: The Anything elisp lib completion style.
2032 The style of completion set here is not implemented for all
2033 completions. The scope varies however with which completion
2034 style you have choosen.
2036 For information about Company Mode and how to use it see URL
2037 `http://www.emacswiki.org/emacs/CompanyMode'.
2039 For information about Anything and how to use it see URL
2040 `http://www.emacswiki.org/emacs/Anything'.
2042 See also the options `popcmp-short-help-beside-alts' and
2043 `popcmp-group-alternatives' which are also availabe when popup
2044 completion is available.")
2046 (nxhtml-custom-autoload 'popcmp-completion-style 'popcmp nil)
2048 (nxhtml-autoload 'popcmp-completing-read `(lp '(nxhtml-download-root-url nil) "util/popcmp" nxhtml-install-dir) "\
2049 Read a string in the minubuffer with completion, or popup a menu.
2050 This function can be used instead `completing-read'. The main
2051 purpose is to provide a popup style menu for completion when
2052 completion is tighed to text at point in a buffer. If a popup
2053 menu is used it will be shown at window point. Whether a popup
2054 menu or minibuffer completion is used is governed by
2055 `popcmp-completion-style'.
2057 The variables PROMPT, TABLE, PREDICATE, REQUIRE-MATCH,
2058 INITIAL-INPUT, POP-HIST, DEF and INHERIT-INPUT-METHOD all have the
2059 same meaning is for `completing-read'.
2061 ALT-HELP should be nil or a hash variable or an association list
2062 with the completion alternative as key and a short help text as
2063 value. You do not need to supply help text for all alternatives.
2064 The use of ALT-HELP is set by `popcmp-short-help-beside-alts'.
2066 ALT-SETS should be nil or an association list that has as keys
2067 groups and as second element an alternative that should go into
2070 \(fn PROMPT TABLE &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT POP-HIST DEF INHERIT-INPUT-METHOD ALT-HELP ALT-SETS)" nil nil)
2074 ;;;### (autoloads (rebind-keys-mode rebind) "rebind" "util/rebind.el"
2075 ;;;;;; (19292 11678))
2076 ;;; Generated autoloads from util/rebind.el
2077 (web-autoload-require 'rebind 'lp '(nxhtml-download-root-url nil) "util/rebind" nxhtml-install-dir 'nxhtml-byte-compile-file)
2080 (let ((loads (get 'rebind 'custom-loads))) (if (member '"rebind" loads) nil (put 'rebind 'custom-loads (cons '"rebind" loads))))
2082 (defvar rebind-keys-mode nil "\
2083 Non-nil if Rebind-Keys mode is enabled.
2084 See the command `rebind-keys-mode' for a description of this minor mode.
2085 Setting this variable directly does not take effect;
2086 either customize it (see the info node `Easy Customization')
2087 or call the function `rebind-keys-mode'.")
2089 (nxhtml-custom-autoload 'rebind-keys-mode 'rebind nil)
2091 (nxhtml-autoload 'rebind-keys-mode `(lp '(nxhtml-download-root-url nil) "util/rebind" nxhtml-install-dir) "\
2092 Rebind keys as defined in `rebind-keys'.
2093 The key bindings will override almost all other key bindings
2094 since it is put on emulation level, like for example ``cua-mode'
2097 This is for using for example C-a to mark the whole buffer (or a
2098 field). There are some predifined keybindings for this.
2100 \(fn &optional ARG)" t nil)
2104 ;;;### (autoloads (rnc-mode) "rnc-mode" "util/rnc-mode.el" (18775
2106 ;;; Generated autoloads from util/rnc-mode.el
2107 (web-autoload-require 'rnc-mode 'lp '(nxhtml-download-root-url nil) "util/rnc-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
2110 (nxhtml-autoload 'rnc-mode `(lp '(nxhtml-download-root-url nil) "util/rnc-mode" nxhtml-install-dir) "\
2111 Major mode for editing RELAX NG Compact Syntax schemas.
2118 ;;;### (autoloads (search-form) "search-form" "util/search-form.el"
2119 ;;;;;; (19275 63380))
2120 ;;; Generated autoloads from util/search-form.el
2121 (web-autoload-require 'search-form 'lp '(nxhtml-download-root-url nil) "util/search-form" nxhtml-install-dir 'nxhtml-byte-compile-file)
2124 (nxhtml-autoload 'search-form `(lp '(nxhtml-download-root-url nil) "util/search-form" nxhtml-install-dir) "\
2125 Display a form for search and replace.
2131 ;;;### (autoloads (sex-mode sex) "sex-mode" "util/sex-mode.el" (19218
2133 ;;; Generated autoloads from util/sex-mode.el
2134 (web-autoload-require 'sex-mode 'lp '(nxhtml-download-root-url nil) "util/sex-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
2137 (let ((loads (get 'sex 'custom-loads))) (if (member '"sex-mode" loads) nil (put 'sex 'custom-loads (cons '"sex-mode" loads))))
2139 (defvar sex-mode nil "\
2140 Non-nil if Sex mode is enabled.
2141 See the command `sex-mode' for a description of this minor mode.
2142 Setting this variable directly does not take effect;
2143 either customize it (see the info node `Easy Customization')
2144 or call the function `sex-mode'.")
2146 (nxhtml-custom-autoload 'sex-mode 'sex-mode nil)
2148 (nxhtml-autoload 'sex-mode `(lp '(nxhtml-download-root-url nil) "util/sex-mode" nxhtml-install-dir) "\
2149 Open certain files in external programs.
2150 See `sex-get-file-open-cmd' for how to determine which files to
2151 open by external applications. Note that this selection is
2152 nearly the same as in `org-mode'. The main difference is that
2153 the fallback always is to open a file in Emacs. (This is
2154 necessary to avoid to disturb many of Emacs operations.)
2156 This affects all functions that opens files, like `find-file',
2157 `find-file-noselect' etc.
2159 However it does not affect files opened through Emacs client.
2161 Urls can also be handled, see `sex-handle-urls'.
2163 When opening a file with the shell a (temporary) dummy buffer is
2164 created in Emacs with major mode `sex-file-mode' and an external
2165 program is called to handle the file. How this dummy buffer is
2166 handled is governed by `sex-keep-dummy-buffer'.
2168 \(fn &optional ARG)" t nil)
2172 ;;;### (autoloads (sml-modeline-mode sml-modeline) "sml-modeline"
2173 ;;;;;; "util/sml-modeline.el" (19362 49086))
2174 ;;; Generated autoloads from util/sml-modeline.el
2175 (web-autoload-require 'sml-modeline 'lp '(nxhtml-download-root-url nil) "util/sml-modeline" nxhtml-install-dir 'nxhtml-byte-compile-file)
2178 (let ((loads (get 'sml-modeline 'custom-loads))) (if (member '"sml-modeline" loads) nil (put 'sml-modeline 'custom-loads (cons '"sml-modeline" loads))))
2180 (defvar sml-modeline-mode nil "\
2181 Non-nil if Sml-Modeline mode is enabled.
2182 See the command `sml-modeline-mode' for a description of this minor mode.
2183 Setting this variable directly does not take effect;
2184 either customize it (see the info node `Easy Customization')
2185 or call the function `sml-modeline-mode'.")
2187 (nxhtml-custom-autoload 'sml-modeline-mode 'sml-modeline nil)
2189 (nxhtml-autoload 'sml-modeline-mode `(lp '(nxhtml-download-root-url nil) "util/sml-modeline" nxhtml-install-dir) "\
2190 Show buffer size and position like scrollbar in mode line.
2191 You can customize this minor mode, see option `sml-modeline-mode'.
2193 Note: If you turn this mode on then you probably want to turn off
2194 option `scroll-bar-mode'.
2196 \(fn &optional ARG)" t nil)
2200 ;;;### (autoloads (tabkey2-emma-without-tabkey2 tabkey2-mode tabkey2)
2201 ;;;;;; "tabkey2" "util/tabkey2.el" (19277 65356))
2202 ;;; Generated autoloads from util/tabkey2.el
2203 (web-autoload-require 'tabkey2 'lp '(nxhtml-download-root-url nil) "util/tabkey2" nxhtml-install-dir 'nxhtml-byte-compile-file)
2206 (let ((loads (get 'tabkey2 'custom-loads))) (if (member '"tabkey2" loads) nil (put 'tabkey2 'custom-loads (cons '"tabkey2" loads))))
2208 (defvar tabkey2-mode nil "\
2209 Non-nil if Tabkey2 mode is enabled.
2210 See the command `tabkey2-mode' for a description of this minor mode.
2211 Setting this variable directly does not take effect;
2212 either customize it (see the info node `Easy Customization')
2213 or call the function `tabkey2-mode'.")
2215 (nxhtml-custom-autoload 'tabkey2-mode 'tabkey2 nil)
2217 (nxhtml-autoload 'tabkey2-mode `(lp '(nxhtml-download-root-url nil) "util/tabkey2" nxhtml-install-dir) "\
2218 More fun with Tab key number two (completion etc).
2219 This global minor mode by default binds Tab in a way that let you
2220 do completion with Tab in all buffers (where it is possible).
2222 The Tab key is easy to type on your keyboard. Then why not use
2223 it for completion, something that is very useful? Shells usually
2224 use Tab for completion so many are used to it. This was the idea
2225 of Smart Tabs and this is a generalization of that idea.
2227 However in Emacs the Tab key is usually used for indentation.
2228 The idea here is that if Tab has been pressed once for
2229 indentation, then as long as point stays further Tab keys might
2230 as well do completion.
2232 So you kind of do Tab-Tab for first completion (and then just
2233 Tab for further completions as long as point is not moved).
2235 And there is even kind of Tab-Tab-Tab completion: If completion
2236 fails the next completion function will be the one you try with
2237 next Tab. (You get some notification of this, of course.)
2239 See `tabkey2-first' for more information about usage.
2241 Note: If you do not want the Tab-Tab behaviour above, but still
2242 want an easy way to reach the available completion functions,
2243 then you can instead of turning on tabkey2-mode enter this in
2246 (global-set-key [f8] 'tabkey2-cycle-completion-functions)
2248 After hitting f8 you will then be in the same state as after the
2249 first in tabkey2-mode.
2251 \(fn &optional ARG)" t nil)
2253 (nxhtml-autoload 'tabkey2-emma-without-tabkey2 `(lp '(nxhtml-download-root-url nil) "util/tabkey2" nxhtml-install-dir) "\
2260 ;;;### (autoloads (tyda-mode) "tyda" "util/tyda.el" (19275 63380))
2261 ;;; Generated autoloads from util/tyda.el
2262 (web-autoload-require 'tyda 'lp '(nxhtml-download-root-url nil) "util/tyda" nxhtml-install-dir 'nxhtml-byte-compile-file)
2265 (defvar tyda-mode nil "\
2266 Non-nil if Tyda mode is enabled.
2267 See the command `tyda-mode' for a description of this minor mode.
2268 Setting this variable directly does not take effect;
2269 either customize it (see the info node `Easy Customization')
2270 or call the function `tyda-mode'.")
2272 (nxhtml-custom-autoload 'tyda-mode 'tyda nil)
2274 (nxhtml-autoload 'tyda-mode `(lp '(nxhtml-download-root-url nil) "util/tyda" nxhtml-install-dir) "\
2275 Minor mode for key bindings for `tyda-lookup-word'.
2276 It binds Alt-Mouse-1 just as the Tyda add-on does in Firefox.
2277 Here are all key bindings
2281 \(fn &optional ARG)" t nil)
2285 ;;;### (autoloads (udev-call-first-step) "udev" "util/udev.el" (19412
2287 ;;; Generated autoloads from util/udev.el
2288 (web-autoload-require 'udev 'lp '(nxhtml-download-root-url nil) "util/udev" nxhtml-install-dir 'nxhtml-byte-compile-file)
2291 (nxhtml-autoload 'udev-call-first-step `(lp '(nxhtml-download-root-url nil) "util/udev" nxhtml-install-dir) "\
2292 Set up and call first step.
2293 Set up buffer LOG-BUFFER to be used for log messages and
2294 controling of the execution of the functions in list STEPS which
2295 are executed one after another.
2297 Write HEADER at the end of LOG-BUFFER.
2301 If FINISH-FUN non-nil it should be a function. This is called
2302 after last step with LOG-BUFFER as parameter.
2304 \(fn LOG-BUFFER STEPS HEADER FINISH-FUN)" nil nil)
2308 ;;;### (autoloads (udev-ecb-customize-startup udev-ecb-update) "udev-ecb"
2309 ;;;;;; "util/udev-ecb.el" (19256 5410))
2310 ;;; Generated autoloads from util/udev-ecb.el
2311 (web-autoload-require 'udev-ecb 'lp '(nxhtml-download-root-url nil) "util/udev-ecb" nxhtml-install-dir 'nxhtml-byte-compile-file)
2314 (nxhtml-autoload 'udev-ecb-update `(lp '(nxhtml-download-root-url nil) "util/udev-ecb" nxhtml-install-dir) "\
2315 Fetch and install ECB from the devel sources.
2316 To determine where to store the sources see `udev-ecb-dir'.
2317 For how to start ECB see `udev-ecb-load-ecb'.
2321 (nxhtml-autoload 'udev-ecb-customize-startup `(lp '(nxhtml-download-root-url nil) "util/udev-ecb" nxhtml-install-dir) "\
2322 Customize ECB dev nXhtml startup group.
2328 ;;;### (autoloads (udev-rinari-update) "udev-rinari" "util/udev-rinari.el"
2329 ;;;;;; (19256 5410))
2330 ;;; Generated autoloads from util/udev-rinari.el
2331 (web-autoload-require 'udev-rinari 'lp '(nxhtml-download-root-url nil) "util/udev-rinari" nxhtml-install-dir 'nxhtml-byte-compile-file)
2334 (nxhtml-autoload 'udev-rinari-update `(lp '(nxhtml-download-root-url nil) "util/udev-rinari" nxhtml-install-dir) "\
2335 Fetch and install Rinari from the devel sources.
2336 To determine where to store the sources and how to start rinari
2337 see `udev-rinari-dir' and `udev-rinari-load-rinari'.
2343 ;;;### (autoloads (viper-tutorial) "viper-tut" "util/viper-tut.el"
2344 ;;;;;; (19388 44990))
2345 ;;; Generated autoloads from util/viper-tut.el
2346 (web-autoload-require 'viper-tut 'lp '(nxhtml-download-root-url nil) "util/viper-tut" nxhtml-install-dir 'nxhtml-byte-compile-file)
2349 (nxhtml-autoload 'viper-tutorial `(lp '(nxhtml-download-root-url nil) "util/viper-tut" nxhtml-install-dir) "\
2350 Run a tutorial for Viper.
2352 A simple classic tutorial in 5 parts that have been used by many
2353 people starting to learn vi keys. You may learn enough to start
2354 using `viper-mode' in Emacs.
2356 Some people find that vi keys helps against repetetive strain
2359 `http://www.emacswiki.org/emacs/RepeatedStrainInjury'.
2361 Note: There might be a few clashes between vi key binding and
2362 Emacs standard key bindings. You will be notified about those in
2363 the tutorial. Even more, if your own key bindings comes in
2364 between you will be notified about that too.
2366 \(fn PART &optional DONT-ASK-FOR-REVERT)" t nil)
2370 ;;;### (autoloads (vline-global-mode vline-mode) "vline" "util/vline.el"
2371 ;;;;;; (19157 2168))
2372 ;;; Generated autoloads from util/vline.el
2373 (web-autoload-require 'vline 'lp '(nxhtml-download-root-url nil) "util/vline" nxhtml-install-dir 'nxhtml-byte-compile-file)
2376 (nxhtml-autoload 'vline-mode `(lp '(nxhtml-download-root-url nil) "util/vline" nxhtml-install-dir) "\
2377 Display vertical line mode.
2379 \(fn &optional ARG)" t nil)
2381 (defvar vline-global-mode nil "\
2382 Non-nil if Vline-Global mode is enabled.
2383 See the command `vline-global-mode' for a description of this minor mode.
2384 Setting this variable directly does not take effect;
2385 either customize it (see the info node `Easy Customization')
2386 or call the function `vline-global-mode'.")
2388 (nxhtml-custom-autoload 'vline-global-mode 'vline nil)
2390 (nxhtml-autoload 'vline-global-mode `(lp '(nxhtml-download-root-url nil) "util/vline" nxhtml-install-dir) "\
2391 Display vertical line mode as globally.
2393 \(fn &optional ARG)" t nil)
2397 ;;;### (autoloads (whelp) "whelp" "util/whelp.el" (19277 65356))
2398 ;;; Generated autoloads from util/whelp.el
2399 (web-autoload-require 'whelp 'lp '(nxhtml-download-root-url nil) "util/whelp" nxhtml-install-dir 'nxhtml-byte-compile-file)
2402 (let ((loads (get 'whelp 'custom-loads))) (if (member '"whelp" loads) nil (put 'whelp 'custom-loads (cons '"whelp" loads))))
2406 ;;;### (autoloads (wikipedia-draft-buffer wikipedia-draft-page wikipedia-draft
2407 ;;;;;; wikipedia-mode) "wikipedia-mode" "related/wikipedia-mode.el"
2408 ;;;;;; (19277 65356))
2409 ;;; Generated autoloads from related/wikipedia-mode.el
2410 (web-autoload-require 'wikipedia-mode 'lp '(nxhtml-download-root-url nil) "related/wikipedia-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
2413 (nxhtml-autoload 'wikipedia-mode `(lp '(nxhtml-download-root-url nil) "related/wikipedia-mode" nxhtml-install-dir) "\
2414 Major mode for editing wikimedia style wikis.
2415 Major mode for editing articles written in the markup language
2416 used by Wikipedia, the free on-line
2417 encyclopedia (see URL `http://www.wikipedia.org').
2419 There are several ways to use wikipedia-mode:
2421 - You can simply cut and paste articles between Emacs and your
2422 web browser's text box.
2423 - If you are using Firefox you can use the It's All Text add-on
2425 - You can use MozEx, a Mozilla/Firefox web browser extension that
2426 allows you to call Emacs from a text
2427 box (see URL `http://mozex.mozdev.org/').
2428 - Another way is to use the PERL script ee-helper, which allows
2429 you to up and download wiki texts.
2431 Wikipedia articles are usually unfilled: newline characters are not
2432 used for breaking paragraphs into lines. Unfortunately, Emacs does not
2433 handle word wrapping yet. As a workaround, wikipedia-mode turns on
2434 longlines-mode automatically. In case something goes wrong, the
2435 following commands may come in handy:
2437 \\[wikipedia-fill-article] fills the buffer.
2438 \\[wikipedia-unfill-article] unfills the buffer.
2439 Be warned that function can be dead slow, better use wikipedia-unfill-paragraph-or-region.
2440 \\[wikipedia-unfill-paragraph-or-region] unfills the paragraph
2441 \\[wikipedia-unfill-paragraph-simple] doehe same but simpler.
2445 The following commands put in markup structures.
2447 \\[wikipedia-insert-bold-italic] bold+italic
2448 \\[wikipedia-insert-bold] bold text
2449 \\[wikipedia-insert-italics] italics
2450 \\[wikipedia-insert-nowiki] no wiki markup
2451 \\[wikipedia-insert-link-wiki] inserts a link
2453 The following commands are also defined:
2454 \\[wikipedia-insert-user] inserts user name
2455 \\[wikipedia-insert-signature] inserts ~~~~
2456 \\[wikipedia-insert-enumerate] inserts enumerate type structures
2457 \\[wikipedia-insert-itemize] inserts itemize type structures
2458 \\[wikipedia-insert-hline] inserts a hline
2460 The draft functionality
2462 \\[wikipedia-draft-region]
2463 \\[wikipedia-draft-view-draft]
2464 \\[wikipedia-draft-page]
2465 \\[wikipedia-draft-buffer]
2467 Replying and sending functionality
2468 \\[wikipedia-reply-at-point-simple]
2469 \\[wikipedia-draft-reply]
2472 The register functionality
2473 \\[wikipedia-copy-page-to-register]
2474 \\[defun wikipedia-insert-page-to-register]
2477 Some simple editing commands.
2478 \\[wikipedia-enhance-indent]
2479 \\[wikipedia-yank-prefix]
2480 \\[wikipedia-unfill-paragraph-or-region]
2484 \\[wikipedia-terminate-paragraph] starts a new list item or paragraph in a context-aware manner.
2488 (nxhtml-autoload 'wikipedia-draft `(lp '(nxhtml-download-root-url nil) "related/wikipedia-mode" nxhtml-install-dir) "\
2489 Open a temporary buffer in wikipedia mode for editing an
2490 wikipedia draft, which an arbitrary piece of data. After
2491 finishing the editing either use \\[wikipedia-draft-buffer] to
2492 send the data into the wikipedia-draft-data-file, or send the
2493 buffer using `wikipedia-draft-send-to-mozex' and insert it later
2494 into a wikipedia article.
2498 (nxhtml-autoload 'wikipedia-draft-page `(lp '(nxhtml-download-root-url nil) "related/wikipedia-mode" nxhtml-install-dir) "\
2503 (nxhtml-autoload 'wikipedia-draft-buffer `(lp '(nxhtml-download-root-url nil) "related/wikipedia-mode" nxhtml-install-dir) "\
2504 Wikipedia-draft-buffer sends the contents of the current (temporary)
2505 buffer to the wikipedia-draft-buffer, see the variable
2506 wikipedia-draft-data-file.
2510 (defvar wikipedia-draft-send-archive t "\
2511 *Archive the reply.")
2515 ;;;### (autoloads (visual-basic-mode) "visual-basic-mode" "related/visual-basic-mode.el"
2516 ;;;;;; (19235 1650))
2517 ;;; Generated autoloads from related/visual-basic-mode.el
2518 (web-autoload-require 'visual-basic-mode 'lp '(nxhtml-download-root-url nil) "related/visual-basic-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
2521 (nxhtml-autoload 'visual-basic-mode `(lp '(nxhtml-download-root-url nil) "related/visual-basic-mode" nxhtml-install-dir) "\
2522 A mode for editing Microsoft Visual Basic programs.
2523 Features automatic indentation, font locking, keyword capitalization,
2524 and some minor convenience functions.
2526 \\{visual-basic-mode-map}
2532 ;;;### (autoloads (tt-mode) "tt-mode" "related/tt-mode.el" (18603
2534 ;;; Generated autoloads from related/tt-mode.el
2535 (web-autoload-require 'tt-mode 'lp '(nxhtml-download-root-url nil) "related/tt-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
2538 (nxhtml-autoload 'tt-mode `(lp '(nxhtml-download-root-url nil) "related/tt-mode" nxhtml-install-dir) "\
2539 Major mode for editing Template Toolkit files.
2545 ;;;### (autoloads (smarty-mode smarty) "smarty-mode" "related/smarty-mode.el"
2546 ;;;;;; (19235 1650))
2547 ;;; Generated autoloads from related/smarty-mode.el
2548 (web-autoload-require 'smarty-mode 'lp '(nxhtml-download-root-url nil) "related/smarty-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
2551 (let ((loads (get 'smarty 'custom-loads))) (if (member '"smarty-mode" loads) nil (put 'smarty 'custom-loads (cons '"smarty-mode" loads))))
2553 (nxhtml-autoload 'smarty-mode `(lp '(nxhtml-download-root-url nil) "related/smarty-mode" nxhtml-install-dir) "\
2557 Smarty Mode is a GNU XEmacs major mode for editing Smarty templates.
2562 Smarty-Mode is a mode allowing easy edit of Smarty templates:
2563 highlight, templates, navigation into source files...
2567 Features (new features in bold) :
2580 - Built-in Functions
2584 - Variable Modifiers
2586 - Plugin (Functions)
2597 - Plugin (Variable Modifiers)
2598 * AlternativeDateModifierPlugin
2604 - Fonctions Non-Smarty
2608 This manual describes Smarty Mode version 0.0.5.
2616 Smarty Mode is a XEmacs major mode that needs the following
2619 * XEmacs (http://www.xemacs.org/).
2621 * `font-lock' mode generaly installed with XEmacs.
2623 * `assoc' mode generaly installed with XEmacs.
2625 * `easymenu' mode generaly installed with XEmacs.
2627 * `hippie-exp' mode generaly installed with XEmacs.
2629 Before continuing, you must be sure to have all this packages
2635 Two internet address to download Smarty Mode :
2637 * Principal: Smarty-Mode 0.0.5
2638 (http://deboutv.free.fr/lisp/smarty/download/smarty-0.0.5.tar.gz)
2639 (http://deboutv.free.fr/lisp/smarty/)
2641 * Secondary: Smarty-Mode 0.0.5
2642 (http://www.morinie.fr/lisp/smarty/download/smarty-0.0.5.tar.gz)
2643 (http://www.morinie.fr/lisp/smarty/)
2645 * Old releases: Smarty-Mode
2646 (http://deboutv.free.fr/lisp/smarty/download.php)
2647 (http://deboutv.free.fr/lisp/smarty/)
2655 To install Smarty Mode you need to choose an installation directory
2656 \(for example `/usr/local/share/lisp' or `c:lisp'). The administrator
2657 must have the write rights on this directory.
2659 With your favorite unzip software, unzip the archive in the
2660 installation directory.
2663 cd /usr/local/share/lisp
2664 tar zxvf smarty-0.0.5.tar.gz
2665 Now you have a `smarty' directory in the installation directory. This
2666 directory contains 2 files `smarty-mode.el' and `smarty-mode.elc' and
2667 another directory `docs' containing the documentation.
2669 You need to configure XEmacs. open you initialization file `init.el'
2670 \(open the file or start XEmacs then choose the Options menu and Edit
2671 Init File). Add the following lines (the installation directory in
2672 this example is `/usr/local/share/lisp') :
2675 (append (list \"/usr/local/share/lisp/\") load-path))
2676 (nxhtml-autoload 'smarty-mode \"smarty-mode\" \"Smarty Mode\" t)
2681 The update is easy. You need to unzip the archive in the installation
2682 directory to remove the old release.
2685 cd /usr/local/share/lisp
2687 tar zxvf smarty-0.0.5.tar.gz
2689 2.4 Invoke Smarty-Mode
2690 ======================
2692 You have two possibilities to invoke the Smarty Mode.
2694 - Manually: At each file opening you need to launch Smarty Mode
2695 with the following command:
2699 - Automatically: Add the following linesin your initialization
2702 (setq auto-mode-alist
2704 '((\"\\.tpl$\" . smarty-mode))
2711 This chapter describes the differents parameters and functions that
2712 you can change to customize Smarty Mode. To do that, open a Smarty
2713 file, click on the Smarty menu and choose Options then Browse
2722 Smarty Mode has 2 modes allowing to simplify the writing of Smarty
2723 templates. You can enable/disable each mode individually.
2725 `smarty-electric-mode'
2728 Description: If `t'; enable automatic generation of template.
2729 If `nil'; template generators can still be invoked through key
2730 bindings and menu. Is indicated in the modeline by \"/e\" after
2731 the mode name and can be toggled by `smarty-electric-mode'.
2733 `smarty-stutter-mode'
2736 Description: If `t'; enable the stuttering. Is indicated in the
2737 modeline by \"/s\" after the mode name and can be toggled by
2738 `smarty-stutter-mode'.
2743 Smarty Mode has also 1 menu that you can enable/disable. The menu
2744 Sources is specific to each Smarty files opened.
2746 `smarty-source-file-menu'
2749 Description: If `t'; the Sources menu is enabled. This menu
2750 contains the list of Smarty file located in the current
2751 directory. The Sources menu scans the directory when a file is
2757 `smarty-highlight-plugin-functions'
2760 Description: If `t'; the functions described in the smarty
2761 plugins are highlighted.
2769 `smarty-file-header'
2771 Default value: `\"\"'
2772 Description: String or file to insert as file header. If the
2773 string specifies an existing file name the contents of the file
2774 is inserted; otherwise the string itself is inserted as file
2776 Type `C-j' for newlines.
2777 The follonwing keywords are supported:
2778 <filename>: replaced by the file name.
2779 <author>: replaced by the user name and email address.
2780 <login>: replaced by `user-login-name'.
2781 <company>: replaced by `smarty-company-name' content.
2782 <date>: replaced by the current date.
2783 <year>: replaced by the current year.
2784 <copyright>: replaced by `smarty-copyright-string' content.
2785 <cursor>: final cursor position.
2787 `smarty-file-footer'
2789 Default value: `\"\"'
2790 Description: String or file to insert as file footer. See
2791 `smarty-file-header'
2793 `smarty-company-name'
2795 Default value: `\"\"'
2796 Description: Name of the company to insert in file header.
2798 `smarty-copyright-string'
2800 Default value: `\"\"'
2801 Description: Coryright string to insert in file header.
2803 `smarty-date-format'
2805 Default value: `\"%Y-%m-%d\"'
2806 Description: Date format.
2808 `smarty-modify-date-prefix-string'
2810 Default value: `\"\"'
2811 Description: Prefix string of modification date in Smarty file
2814 `smarty-modify-date-on-saving'
2816 Default value: `nil'
2817 Description: If `t'; update the modification date when the
2823 `smarty-left-delimiter'
2825 Default value: `\"\"'
2826 Description: Left escaping delimiter for Smarty templates.
2828 `smarty-right-delimiter'
2830 Default value: `\"\"'
2831 Description: Right escaping delimiter for Smarty templates.
2833 `smarty-intelligent-tab'
2836 Description: If `t'; TAB does indentation; completion and insert
2837 tabulations. If `nil'; TAB does only indentation.
2839 `smarty-word-completion-in-minibuffer'
2842 Description: If `t'; enable completion in the minibuffer.
2844 `smarty-word-completion-case-sensitive'
2846 Default value: `nil'
2847 Description: If `t'; completion is case sensitive.
2855 `smarty-electric-mode'
2856 Menu: Smarty -> Options -> Mode -> Electric Mode
2857 Keybinding: `C-c C-m C-e'
2858 Description: This functions is used to enable/disable the
2861 `smarty-stutter-mode'
2862 Menu: Smarty -> Options -> Mode -> Stutter Mode
2863 Keybinding: `C-c C-m C-s'
2864 Description: This function is used to enable/disable the stutter
2870 There are 2 menus: Smarty and Sources. All theses menus can be
2871 accessed from the menubar or from the right click. This chapter
2872 describes each menus.
2877 This is the main menu of Smarty Mode. It allows an easy access to the
2878 main features of the Smarty Mode: Templates (see *Note Templates::)
2879 and Options (see *Note Customization::).
2881 This menu contains also 3 functions that are discussed in the next
2887 `smarty-show-messages'
2888 Menu: Smarty -> Show Messages
2889 Keybinding: `C-c M-m'
2890 Description: This function opens the *Messages* buffer to
2891 display previous error messages.
2894 Menu: Smarty -> Smarty Mode Documentation
2895 Keybinding: `C-c C-h'
2896 Description: This function opens the *Help* buffer and prints in
2897 it the Smarty Mode documentation.
2900 Menu: Smarty -> Version
2901 Keybinding: `C-c C-v'
2902 Description: This function displays in the minibuffer the
2903 current Smarty Mode version with the timestamp.
2908 The Sources menu shows the Smarty files in the current directory. If
2909 you add or delete a file in the current directory, you need to
2915 `smarty-source-file-menu'
2918 Description: If `t'; the Sources menu is enabled. This menu
2919 contains the list of Smarty file located in the current
2920 directory. The Sources menu scans the directory when a file is
2926 `smarty-add-source-files-menu'
2927 Menu: Sources -> *Rescan*
2928 Keybinding: `C-c C-s C-u'
2929 Description: This function is used to refresh the Sources menu.
2934 The stutter mode is a mode that affects a function to a key. For
2935 example, when you use the `ENTER' key, the associated function will
2936 create a new line and indent it.
2941 `smarty-stutter-mode'
2944 Description: If `t'; enable the stuttering. Is indicated in the
2945 modeline by \"/s\" after the mode name and can be toggled by
2946 `smarty-stutter-mode'.
2952 If in comment, indent the comment and add new line if necessary.
2953 In other case, add a space.
2956 If the previous character is a `(', the `((' will be replaced by
2958 If the previous character is a `[', the `[(' will be replaced by
2960 In other case, insert a `('.
2963 If the previous character is a `)', the `))' will be replaced by
2965 If the previous character is a `]', the `])' will be replaced by
2967 In other case, insert a `)'.
2972 In the Smarty Mode, the Smarty functions (like if, while, for, fopen,
2973 fclose) are predefined in functions called \"Templates\".
2975 Each template can be invoked by the function name or by using the
2976 <SPACE> key after the Smarty function name in the buffer (Note, using
2977 `M-<SPACE>' disable the template).
2979 A template can be aborted by using the `C-g' or by lefting empty the
2980 tempate prompt (in the minibuffer).
2985 `smarty-electric-mode'
2988 Description: If `t'; enable automatic generation of template.
2989 If `nil'; template generators can still be invoked through key
2990 bindings and menu. Is indicated in the modeline by \"/e\" after
2991 the mode name and can be toggled by `smarty-electric-mode'.
2993 For a complete description of the template customizable variables,
2994 see *Note Cu01-Pa01-Template::
2999 6.2.1 Smarty Functions
3000 ----------------------
3002 For Smarty functions, see PDF or HTML documentation.
3004 6.2.2 Non-Smarty Functions
3005 --------------------------
3007 `smarty-template-header'
3008 Menu: Smarty -> Templates -> Insert Header
3009 Keybinding: `C-c C-t C-h'
3010 Description: This function is used to insert a header in the
3013 `smarty-template-footer'
3014 Menu: Smarty -> Templates -> Insert Footer
3015 Keybinding: `C-c C-t C-f'
3016 Description: This function is used to insert a footer in the
3019 `smarty-template-insert-date'
3020 Menu: Smarty -> Templates -> Insert Date
3021 Keybinding: `C-c C-t C-d i'
3022 Description: This function is used to insert the date in the
3025 `smarty-template-modify'
3026 Menu: Smarty -> Templates -> Modify Date
3027 Keybinding: `C-c C-t C-d m'
3028 Description: This function is used to modify the last
3029 modification date in the current buffer.
3034 * To report bugs: Bugtracker
3035 (http://bugtracker.morinie.fr/lisp/set_project.php?project_id=2)
3037 * To obtain help you can post on the dedicated forum: Forum
3038 (http://forum.morinie.fr/lisp/)
3049 ;;;### (autoloads (php-mode php-file-patterns php) "php-mode" "related/php-mode.el"
3050 ;;;;;; (19218 42180))
3051 ;;; Generated autoloads from related/php-mode.el
3052 (web-autoload-require 'php-mode 'lp '(nxhtml-download-root-url nil) "related/php-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
3055 (let ((loads (get 'php 'custom-loads))) (if (member '"php-mode" loads) nil (put 'php 'custom-loads (cons '"php-mode" loads))))
3057 (defvar php-file-patterns '("\\.php[s34]?\\'" "\\.phtml\\'" "\\.inc\\'") "\
3058 List of file patterns for which to automatically invoke `php-mode'.")
3060 (nxhtml-custom-autoload 'php-file-patterns 'php-mode nil)
3062 (nxhtml-autoload 'php-mode `(lp '(nxhtml-download-root-url nil) "related/php-mode" nxhtml-install-dir) "\
3063 Major mode for editing PHP code.
3071 ;;;### (autoloads (global-mozadd-mirror-mode mozadd-mirror-mode global-mozadd-refresh-edited-on-save-mode
3072 ;;;;;; mozadd-refresh-edited-on-save-mode) "mozadd" "related/mozadd.el"
3073 ;;;;;; (19235 1650))
3074 ;;; Generated autoloads from related/mozadd.el
3075 (web-autoload-require 'mozadd 'lp '(nxhtml-download-root-url nil) "related/mozadd" nxhtml-install-dir 'nxhtml-byte-compile-file)
3078 (nxhtml-autoload 'mozadd-refresh-edited-on-save-mode `(lp '(nxhtml-download-root-url nil) "related/mozadd" nxhtml-install-dir) "\
3079 Refresh mozadd edited file in Firefox when saving file.
3080 The mozadd edited file is the file in the last buffer visited in
3081 `mozadd-mirror-mode'.
3083 You can use this for example when you edit CSS files.
3085 The mozadd edited file must be shown in Firefox and visible.
3087 \(fn &optional ARG)" t nil)
3089 (defvar global-mozadd-refresh-edited-on-save-mode nil "\
3090 Non-nil if Global-Mozadd-Refresh-Edited-On-Save mode is enabled.
3091 See the command `global-mozadd-refresh-edited-on-save-mode' for a description of this minor mode.
3092 Setting this variable directly does not take effect;
3093 either customize it (see the info node `Easy Customization')
3094 or call the function `global-mozadd-refresh-edited-on-save-mode'.")
3096 (nxhtml-custom-autoload 'global-mozadd-refresh-edited-on-save-mode 'mozadd nil)
3098 (nxhtml-autoload 'global-mozadd-refresh-edited-on-save-mode `(lp '(nxhtml-download-root-url nil) "related/mozadd" nxhtml-install-dir) "\
3099 Toggle Mozadd-Refresh-Edited-On-Save mode in every possible buffer.
3100 With prefix ARG, turn Global-Mozadd-Refresh-Edited-On-Save mode on if and only if
3102 Mozadd-Refresh-Edited-On-Save mode is enabled in all buffers where
3103 `(lambda nil (when (or (derived-mode-p (quote css-mode)) (mozadd-html-buffer-file-p)) (mozadd-refresh-edited-on-save-mode 1)))' would do it.
3104 See `mozadd-refresh-edited-on-save-mode' for more information on Mozadd-Refresh-Edited-On-Save mode.
3106 \(fn &optional ARG)" t nil)
3108 (nxhtml-autoload 'mozadd-mirror-mode `(lp '(nxhtml-download-root-url nil) "related/mozadd" nxhtml-install-dir) "\
3109 Mirror content of current file buffer immediately in Firefox.
3110 When you turn on this mode the file will be opened in Firefox.
3111 Every change you make in the buffer will trigger a redraw in
3112 Firefox - regardless of if you save the file or not.
3114 For the mirroring to work the edited file must be shown in
3115 Firefox and visible.
3117 If `nxml-where-mode' is on the marks will also be shown in
3118 Firefox as CSS outline style. You can customize the style
3119 through the option `mozadd-xml-path-outline-style'.
3121 See also `mozadd-refresh-edited-on-save-mode'.
3123 \(fn &optional ARG)" t nil)
3125 (defvar global-mozadd-mirror-mode nil "\
3126 Non-nil if Global-Mozadd-Mirror mode is enabled.
3127 See the command `global-mozadd-mirror-mode' for a description of this minor mode.
3128 Setting this variable directly does not take effect;
3129 either customize it (see the info node `Easy Customization')
3130 or call the function `global-mozadd-mirror-mode'.")
3132 (nxhtml-custom-autoload 'global-mozadd-mirror-mode 'mozadd nil)
3134 (nxhtml-autoload 'global-mozadd-mirror-mode `(lp '(nxhtml-download-root-url nil) "related/mozadd" nxhtml-install-dir) "\
3135 Toggle Mozadd-Mirror mode in every possible buffer.
3136 With prefix ARG, turn Global-Mozadd-Mirror mode on if and only if
3138 Mozadd-Mirror mode is enabled in all buffers where
3139 `(lambda nil (when (mozadd-html-buffer-file-p) (mozadd-mirror-mode 1)))' would do it.
3140 See `mozadd-mirror-mode' for more information on Mozadd-Mirror mode.
3142 \(fn &optional ARG)" t nil)
3146 ;;;### (autoloads (inferior-moz-mode moz-minor-mode) "moz" "related/moz.el"
3147 ;;;;;; (19048 2102))
3148 ;;; Generated autoloads from related/moz.el
3149 (web-autoload-require 'moz 'lp '(nxhtml-download-root-url nil) "related/moz" nxhtml-install-dir 'nxhtml-byte-compile-file)
3152 (nxhtml-autoload 'moz-minor-mode `(lp '(nxhtml-download-root-url nil) "related/moz" nxhtml-install-dir) "\
3153 MozRepl minor mode for interaction with Firefox.
3154 With no argument, this command toggles the mode.
3155 Non-null prefix argument turns on the mode.
3156 Null prefix argument turns off the mode.
3158 When this minor mode is enabled, some commands become available
3159 to send current code area (as understood by c-mark-function) or
3160 region or buffer to an inferior MozRepl process (which will be
3163 The following keys are bound in this minor mode:
3165 \\{moz-minor-mode-map}
3167 \(fn &optional ARG)" t nil)
3169 (nxhtml-autoload 'inferior-moz-mode `(lp '(nxhtml-download-root-url nil) "related/moz" nxhtml-install-dir) "\
3170 Major mode for interacting with Firefox via MozRepl.
3176 ;;;### (autoloads (iss-mumamo-mode) "iss-mumamo" "related/iss-mumamo.el"
3177 ;;;;;; (19294 54042))
3178 ;;; Generated autoloads from related/iss-mumamo.el
3179 (web-autoload-require 'iss-mumamo 'lp '(nxhtml-download-root-url nil) "related/iss-mumamo" nxhtml-install-dir 'nxhtml-byte-compile-file)
3182 (nxhtml-autoload 'iss-mumamo-mode `(lp '(nxhtml-download-root-url nil) "related/iss-mumamo" nxhtml-install-dir) "\
3183 Turn on multiple major modes Inno Setup .iss files.
3184 The main major mode will be `iss-mode'.
3185 The [code] section, if any, will be in `pascal-mode'." t)
3189 ;;;### (autoloads (iss-mode) "iss-mode" "related/iss-mode.el" (19294
3191 ;;; Generated autoloads from related/iss-mode.el
3192 (web-autoload-require 'iss-mode 'lp '(nxhtml-download-root-url nil) "related/iss-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
3195 (nxhtml-autoload 'iss-mode `(lp '(nxhtml-download-root-url nil) "related/iss-mode" nxhtml-install-dir) "\
3196 Major mode for editing InnoSetup script files. Upon startup iss-mode-hook is run.
3202 ;;;### (autoloads (flymake-js-load flymake-js) "flymake-js" "related/flymake-js.el"
3203 ;;;;;; (19218 42180))
3204 ;;; Generated autoloads from related/flymake-js.el
3205 (web-autoload-require 'flymake-js 'lp '(nxhtml-download-root-url nil) "related/flymake-js" nxhtml-install-dir 'nxhtml-byte-compile-file)
3208 (let ((loads (get 'flymake-js 'custom-loads))) (if (member '"flymake-js" loads) nil (put 'flymake-js 'custom-loads (cons '"flymake-js" loads))))
3210 (nxhtml-autoload 'flymake-js-load `(lp '(nxhtml-download-root-url nil) "related/flymake-js" nxhtml-install-dir) "\
3217 ;;;### (autoloads (flymake-java-1-load) "flymake-java-1" "related/flymake-java-1.el"
3218 ;;;;;; (19264 27004))
3219 ;;; Generated autoloads from related/flymake-java-1.el
3220 (web-autoload-require 'flymake-java-1 'lp '(nxhtml-download-root-url nil) "related/flymake-java-1" nxhtml-install-dir 'nxhtml-byte-compile-file)
3223 (nxhtml-autoload 'flymake-java-1-load `(lp '(nxhtml-download-root-url nil) "related/flymake-java-1" nxhtml-install-dir) "\
3230 ;;;### (autoloads (flymake-css-load) "flymake-css" "related/flymake-css.el"
3231 ;;;;;; (19292 11678))
3232 ;;; Generated autoloads from related/flymake-css.el
3233 (web-autoload-require 'flymake-css 'lp '(nxhtml-download-root-url nil) "related/flymake-css" nxhtml-install-dir 'nxhtml-byte-compile-file)
3236 (nxhtml-autoload 'flymake-css-load `(lp '(nxhtml-download-root-url nil) "related/flymake-css" nxhtml-install-dir) "\
3243 ;;;### (autoloads (django-mode) "django" "related/django.el" (19411
3245 ;;; Generated autoloads from related/django.el
3246 (web-autoload-require 'django 'lp '(nxhtml-download-root-url nil) "related/django" nxhtml-install-dir 'nxhtml-byte-compile-file)
3249 (nxhtml-autoload 'django-mode `(lp '(nxhtml-download-root-url nil) "related/django" nxhtml-install-dir) "\
3250 Simple Django mode for use with mumamo.
3251 This mode only provides syntax highlighting.
3257 ;;;### (autoloads (csharp-mode csharp-mode-hook) "csharp-mode" "related/csharp-mode.el"
3258 ;;;;;; (19410 9973))
3259 ;;; Generated autoloads from related/csharp-mode.el
3260 (web-autoload-require 'csharp-mode 'lp '(nxhtml-download-root-url nil) "related/csharp-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
3263 (add-to-list 'auto-mode-alist '("\\.cs$" . csharp-mode))
3265 (defvar csharp-mode-hook nil "\
3266 *Hook called by `csharp-mode'.")
3268 (nxhtml-custom-autoload 'csharp-mode-hook 'csharp-mode t)
3270 (nxhtml-autoload 'csharp-mode `(lp '(nxhtml-download-root-url nil) "related/csharp-mode" nxhtml-install-dir) "\
3271 Major mode for editing C# code. This mode is derived from CC Mode to
3274 The hook `c-mode-common-hook' is run with no args at mode
3275 initialization, then `csharp-mode-hook'.
3277 This mode will automatically add a regexp for Csc.exe error and warning
3278 messages to the `compilation-error-regexp-alist'.
3287 ;;;### (autoloads (winring-rename-configuration winring-delete-configuration
3288 ;;;;;; winring-jump-to-configuration winring-prev-configuration
3289 ;;;;;; winring-next-configuration winring-duplicate-configuration
3290 ;;;;;; winring-new-configuration) "winring" "util/winring.el" (19392
3292 ;;; Generated autoloads from util/winring.el
3293 (web-autoload-require 'winring 'lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir 'nxhtml-byte-compile-file)
3296 (nxhtml-autoload 'winring-new-configuration `(lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir) "\
3297 Save the current window configuration and create an empty new one.
3298 The buffer shown in the new empty configuration is defined by
3299 `winring-new-config-buffer-name'.
3301 With \\[universal-argument] prompt for the new configuration's name.
3302 Otherwise, the function in `winring-name-generator' will be called to
3303 get the new configuration's name.
3305 \(fn &optional ARG)" t nil)
3307 (nxhtml-autoload 'winring-duplicate-configuration `(lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir) "\
3308 Push the current window configuration on the ring, and duplicate it.
3310 With \\[universal-argument] prompt for the new configuration's name.
3311 Otherwise, the function in `winring-name-generator' will be called to
3312 get the new configuration's name.
3314 \(fn &optional ARG)" t nil)
3316 (nxhtml-autoload 'winring-next-configuration `(lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir) "\
3317 Switch to the next window configuration for this frame.
3321 (nxhtml-autoload 'winring-prev-configuration `(lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir) "\
3322 Switch to the previous window configuration for this frame.
3326 (nxhtml-autoload 'winring-jump-to-configuration `(lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir) "\
3327 Go to the named window configuration.
3331 (nxhtml-autoload 'winring-delete-configuration `(lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir) "\
3332 Delete the current configuration and switch to the next one.
3333 With \\[universal-argument] prompt for named configuration to delete.
3335 \(fn &optional ARG)" t nil)
3337 (nxhtml-autoload 'winring-rename-configuration `(lp '(nxhtml-download-root-url nil) "util/winring" nxhtml-install-dir) "\
3338 Rename the current configuration to NAME.
3344 ;;;### (autoloads (winsav-switch-config winsav-save-full-config winsav-save-mode
3345 ;;;;;; winsav winsav-put-window-tree) "winsav" "util/winsav.el"
3346 ;;;;;; (19295 38082))
3347 ;;; Generated autoloads from util/winsav.el
3348 (web-autoload-require 'winsav 'lp '(nxhtml-download-root-url nil) "util/winsav" nxhtml-install-dir 'nxhtml-byte-compile-file)
3351 (nxhtml-autoload 'winsav-put-window-tree `(lp '(nxhtml-download-root-url nil) "util/winsav" nxhtml-install-dir) "\
3352 Put window structure SAVED-TREE into WINDOW.
3353 Restore a structure SAVED-TREE returned from
3354 `winsav-get-window-tree' into window WINDOW.
3356 If COPY-WIN-OVL is non-nil then overlays having a 'window
3357 property pointing to one of the windows in SAVED-TREE where this
3358 window still is shown will be copied to a new overlay with
3359 'window property pointing to the corresponding new window.
3361 If WIN-OVL-ALL-BUFS is non-nil then all buffers will be searched
3362 for overlays with a 'window property of the kind above.
3364 At the very end of this function the hook `winsav-after-put' is
3367 \(fn SAVED-TREE WINDOW &optional COPY-WIN-OVL WIN-OVL-ALL-BUFS)" nil nil)
3369 (let ((loads (get 'winsav 'custom-loads))) (if (member '"winsav" loads) nil (put 'winsav 'custom-loads (cons '"winsav" loads))))
3371 (defvar winsav-save-mode nil "\
3372 Non-nil if Winsav-Save mode is enabled.
3373 See the command `winsav-save-mode' for a description of this minor mode.")
3375 (nxhtml-custom-autoload 'winsav-save-mode 'winsav nil)
3377 (nxhtml-autoload 'winsav-save-mode `(lp '(nxhtml-download-root-url nil) "util/winsav" nxhtml-install-dir) "\
3378 Toggle winsav configuration saving mode.
3379 With numeric ARG, turn winsav saving on if ARG is positive, off
3382 When this mode is turned on, winsav configurations are saved from
3383 one session to another. A winsav configuration consists of
3384 frames, windows and visible buffers configurations plus
3385 optionally buffers and files managed by the functions used by
3386 option `desktop-save-mode'
3388 By default this is integrated with `desktop-save-mode'. If
3389 `desktop-save-mode' is on and `winsav-handle-also-desktop' is
3390 non-nil then save and restore also desktop.
3392 See the command `winsav-switch-config' for more information and
3393 other possibilities.
3395 Note: If you want to avoid saving when you exit just turn off
3398 For information about what is saved and restored and how to save
3399 and restore additional information see the function
3400 `winsav-save-configuration'.
3402 \(fn &optional ARG)" t nil)
3404 (nxhtml-autoload 'winsav-save-full-config `(lp '(nxhtml-download-root-url nil) "util/winsav" nxhtml-install-dir) "\
3405 Saved current winsav configuration in directory DIRNAME.
3406 Then change to this configuration.
3408 See also `winsav-switch-config'.
3410 \(fn DIRNAME)" nil nil)
3412 (nxhtml-autoload 'winsav-switch-config `(lp '(nxhtml-download-root-url nil) "util/winsav" nxhtml-install-dir) "\
3413 Change to winsav configuration in directory DIRNAME.
3414 If DIRNAME is the current winsav configuration directory then
3415 offer to save it or restore it from saved values.
3417 Otherwise, before switching offer to save the current winsav
3418 configuration. Then finally switch to the new winsav
3419 configuration, creating it if it does not exist.
3421 If option `desktop-save-mode' is on then buffers and files are also
3422 restored and saved the same way.
3424 See also option `winsav-save-mode' and command
3425 `winsav-tell-configuration'.
3427 \(fn DIRNAME)" t nil)
3431 ;;;### (autoloads (winsav-rotate winsize-set-mode-line-colors winsize-save-window-configuration
3432 ;;;;;; winsize-balance-siblings resize-windows) "winsize" "util/winsize.el"
3433 ;;;;;; (19292 49706))
3434 ;;; Generated autoloads from util/winsize.el
3435 (web-autoload-require 'winsize 'lp '(nxhtml-download-root-url nil) "util/winsize" nxhtml-install-dir 'nxhtml-byte-compile-file)
3438 (nxhtml-autoload 'resize-windows `(lp '(nxhtml-download-root-url nil) "util/winsize" nxhtml-install-dir) "\
3439 Start window resizing.
3440 During resizing a window is selected. You can move its
3441 borders. In the default configuration the arrow keys moves the
3442 right or bottom border if they are there. To move the opposite
3443 border use S-arrowkeys.
3445 You can also do other window operations, like splitting, deleting
3446 and balancing the sizes. The keybindings below describes the key
3447 bindings during resizing:\\<winsize-keymap>
3449 `balance-windows' \\[balance-windows]
3450 `winsize-balance-siblings' \\[winsize-balance-siblings]
3451 `fit-window-to-buffer' \\[fit-window-to-buffer]
3452 `shrink-window-if-larger-than-buffer' \\[shrink-window-if-larger-than-buffer]
3454 `winsav-rotate' \\[winsav-rotate]
3456 `winsize-move-border-up' \\[winsize-move-border-up]
3457 `winsize-move-border-down' \\[winsize-move-border-down]
3458 `winsize-move-border-left' \\[winsize-move-border-left]
3459 `winsize-move-border-right' \\[winsize-move-border-right]
3461 `winsize-to-border-or-window-left' \\[winsize-to-border-or-window-left]
3462 `winsize-to-border-or-window-up' \\[winsize-to-border-or-window-up]
3463 `winsize-to-border-or-window-right' \\[winsize-to-border-or-window-right]
3464 `winsize-to-border-or-window-down' \\[winsize-to-border-or-window-down]
3466 Note that you can also use your normal keys for
3467 `forward-char', `backward-char', `next-line', `previous-line'
3468 and what you have on HOME and END to move in the windows. That
3469 might sometimes be necessary to directly select a
3470 window. (You may however also use `other-window' or click
3471 with the mouse, see below.)
3473 `delete-window' \\[delete-window]
3474 `delete-other-windows' \\[delete-other-windows]
3475 `split-window-vertically' \\[split-window-vertically]
3476 `split-window-horizontally' \\[split-window-horizontally]
3477 `other-window' \\[other-window]
3479 `winsize-save-window-configuration' \\[winsize-save-window-configuration]
3480 `winsize-next-window-configuration' \\[winsize-next-window-configuration]
3481 `winsize-previous-window-configuration' \\[winsize-previous-window-configuration]
3483 `mouse-set-point' \\[mouse-set-point]
3485 `winsize-quit' \\[winsize-quit]
3486 `winsize-stop-go-back' \\[winsize-stop-go-back]
3487 `winsize-stop' \\[winsize-stop]
3488 `winsize-stop-and-execute' \\[winsize-stop-and-execute]
3490 `winsize-help' \\[winsize-help]
3491 `describe-key' \\[describe-key]
3492 `describe-key-briefly' \\[describe-key-briefly]
3493 (All the normal help keys work, and at least those above will
3494 play well with resizing.)
3496 Nearly all other keys exits window resizing and they are also
3497 executed. However, the key sequences in `winsize-let-me-use' and
3498 dito for commands there are also executed without exiting
3501 The colors of the modelines are changed to those given in
3502 `winsize-mode-line-colors' to indicate that you are resizing
3503 windows. To make this indication more prominent the text in the
3504 selected window is marked with the face hold in the variable
3505 `winsize-selected-window-face'.
3507 The option `winsize-juris-way' decides how the borders to move
3508 are selected. If this option is non-nil then the right or bottom
3509 border are the ones that are moved with the arrow keys and the
3510 opposite border with shift arrow keys.
3512 If `winsize-juris-way' is nil then the following apply:
3514 As you select other borders or move to new a window the mouse
3515 pointer is moved inside the selected window to show which borders
3516 are beeing moved. The mouse jumps a little bit to make its
3517 position more visible. You can turn this off by customizing
3518 `winsize-make-mouse-prominent'.
3520 Which borders initially are choosen are controlled by the
3521 variable `winsize-autoselect-borders'.
3523 ** Example: Border selection, movements and windows.
3525 Suppose you have a frame divided into windows like in the
3526 figure below. If window B is selected when you start resizing
3527 then (with default settings) the borders marked with 'v' and
3528 'h' will be the ones that the arrow keys moves. To indicate
3529 this the mouse pointer is placed in the right lower corner of
3530 the selected window B.
3532 +----------+-----------+--------+
3539 +hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
3546 +----------+---------+----------+
3548 Now if you press M-<left> then the picture below shows what has
3549 happened. Note that the selected vertical border is now the one
3550 between A and B. The mouse pointer has moved to the
3551 corresponding corner in the window B, which is still selected.
3553 +----------+-----------+--------+
3560 +hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
3567 +----------+---------+----------+
3569 Press M-<left> once again. This gives this picture:
3571 +----------+-----------+--------+
3578 +hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
3585 +----------+---------+----------+
3587 Note that the window A is now selected. However there is no
3588 border that could be moved to the left of this window (which
3589 would otherwise be chosen now) so the border between A and B is
3590 still the one that <left> and <right> moves. The mouse has
3593 If we now delete window A the new situation will look like
3596 +----------+-----------+--------+
3603 +hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh+
3610 +----------+---------+----------+
3614 >>>> testing stuff >>>>
3616 `temp-buffer-show-function'
3618 <<<<<<<<<<<<<<<<<<<<<<<
3622 (nxhtml-autoload 'winsize-balance-siblings `(lp '(nxhtml-download-root-url nil) "util/winsize" nxhtml-install-dir) "\
3623 Make current window siblings the same height or width.
3624 It works the same way as `balance-windows', but only for the
3625 current window and its siblings.
3629 (nxhtml-autoload 'winsize-save-window-configuration `(lp '(nxhtml-download-root-url nil) "util/winsize" nxhtml-install-dir) "\
3634 (nxhtml-autoload 'winsize-set-mode-line-colors `(lp '(nxhtml-download-root-url nil) "util/winsize" nxhtml-install-dir) "\
3635 Turn mode line colors on if ON is non-nil, otherwise off.
3639 (nxhtml-autoload 'winsav-rotate `(lp '(nxhtml-download-root-url nil) "util/winsize" nxhtml-install-dir) "\
3640 Rotate window configuration on selected frame.
3641 MIRROR should be either 'mirror-left-right, 'mirror-top-bottom or
3642 nil. In the first case the window configuration is mirrored
3643 vertically and in the second case horizontally. If MIRROR is nil
3644 the configuration is not mirrored.
3646 If TRANSPOSE is non-nil then the window structure is transposed
3647 along the diagonal from top left to bottom right (in analogy with
3648 matrix transosition).
3650 If called interactively MIRROR will is 'mirror-left-right by
3651 default, but 'mirror-top-bottom if called with prefix. TRANSPOSE
3652 is t. This mean that the window configuration will be turned one
3653 quarter clockwise (or counter clockwise with prefix).
3655 \(fn MIRROR TRANSPOSE)" t nil)
3659 ;;;### (autoloads (wrap-to-fill-column-mode wrap-to-fill-left-marg-modes
3660 ;;;;;; wrap-to-fill-left-marg wrap-to-fill) "wrap-to-fill" "util/wrap-to-fill.el"
3661 ;;;;;; (19306 50510))
3662 ;;; Generated autoloads from util/wrap-to-fill.el
3663 (web-autoload-require 'wrap-to-fill 'lp '(nxhtml-download-root-url nil) "util/wrap-to-fill" nxhtml-install-dir 'nxhtml-byte-compile-file)
3666 (let ((loads (get 'wrap-to-fill 'custom-loads))) (if (member '"wrap-to-fill" loads) nil (put 'wrap-to-fill 'custom-loads (cons '"wrap-to-fill" loads))))
3668 (defvar wrap-to-fill-left-marg nil "\
3669 Left margin handling for `wrap-to-fill-column-mode'.
3670 Used by `wrap-to-fill-column-mode'. If nil then center the
3671 display columns. Otherwise it should be a number which will be
3674 (nxhtml-custom-autoload 'wrap-to-fill-left-marg 'wrap-to-fill t)
3676 (defvar wrap-to-fill-left-marg-modes '(text-mode fundamental-mode) "\
3677 Major modes where `wrap-to-fill-left-margin' may be nil.")
3679 (nxhtml-custom-autoload 'wrap-to-fill-left-marg-modes 'wrap-to-fill t)
3681 (nxhtml-autoload 'wrap-to-fill-column-mode `(lp '(nxhtml-download-root-url nil) "util/wrap-to-fill" nxhtml-install-dir) "\
3682 Use `fill-column' display columns in buffer windows.
3683 By default the display columns are centered, but see the option
3684 `wrap-to-fill-left-marg'.
3687 Note 1: When turning this on `visual-line-mode' is also turned on. This
3688 is not reset when turning off this mode.
3690 Note 2: The text properties 'wrap-prefix and 'wrap-to-fill-prefix
3691 is set by this mode to indent continuation lines.
3693 Key bindings added by this minor mode:
3695 \\{wrap-to-fill-column-mode-map}
3697 \(fn &optional ARG)" t nil)
3701 ;;;### (autoloads (xhtml-help xhtml-help-show-tag-ref xhtml-help-tag-at-point
3702 ;;;;;; xhtml-help-show-css-ref) "xhtml-help" "nxhtml/xhtml-help.el"
3703 ;;;;;; (19364 56214))
3704 ;;; Generated autoloads from nxhtml/xhtml-help.el
3705 (web-autoload-require 'xhtml-help 'lp '(nxhtml-download-root-url nil) "nxhtml/xhtml-help" nxhtml-install-dir 'nxhtml-byte-compile-file)
3708 (nxhtml-autoload 'xhtml-help-show-css-ref `(lp '(nxhtml-download-root-url nil) "nxhtml/xhtml-help" nxhtml-install-dir) "\
3709 Show CSS reference for CSS property name at point.
3713 (nxhtml-autoload 'xhtml-help-tag-at-point `(lp '(nxhtml-download-root-url nil) "nxhtml/xhtml-help" nxhtml-install-dir) "\
3714 Get xhtml tag name at or before point.
3718 (nxhtml-autoload 'xhtml-help-show-tag-ref `(lp '(nxhtml-download-root-url nil) "nxhtml/xhtml-help" nxhtml-install-dir) "\
3719 Show xhtml reference for tag name at or before point.
3723 (let ((loads (get 'xhtml-help 'custom-loads))) (if (member '"xhtml-help" loads) nil (put 'xhtml-help 'custom-loads (cons '"xhtml-help" loads))))
3727 ;;;### (autoloads (tidy-build-menu tidy) "tidy-xhtml" "nxhtml/tidy-xhtml.el"
3728 ;;;;;; (19364 56214))
3729 ;;; Generated autoloads from nxhtml/tidy-xhtml.el
3730 (web-autoload-require 'tidy-xhtml 'lp '(nxhtml-download-root-url nil) "nxhtml/tidy-xhtml" nxhtml-install-dir 'nxhtml-byte-compile-file)
3733 (let ((loads (get 'tidy 'custom-loads))) (if (member '"tidy-xhtml" loads) nil (put 'tidy 'custom-loads (cons '"tidy-xhtml" loads))))
3735 (nxhtml-autoload 'tidy-build-menu `(lp '(nxhtml-download-root-url nil) "nxhtml/tidy-xhtml" nxhtml-install-dir) "\
3736 Set up the tidy menu in MAP.
3737 Used to set up a Tidy menu in your favourite mode.
3739 \(fn &optional MAP)" t nil)
3743 ;;;### (autoloads (rngalt-set-validation-header) "rngalt" "nxhtml/rngalt.el"
3744 ;;;;;; (19365 33760))
3745 ;;; Generated autoloads from nxhtml/rngalt.el
3746 (web-autoload-require 'rngalt 'lp '(nxhtml-download-root-url nil) "nxhtml/rngalt" nxhtml-install-dir 'nxhtml-byte-compile-file)
3749 (nxhtml-autoload 'rngalt-set-validation-header `(lp '(nxhtml-download-root-url nil) "nxhtml/rngalt" nxhtml-install-dir) "\
3752 \(fn START-OF-DOC)" nil nil)
3756 ;;;### (autoloads (nxml-where-global-mode nxml-where-mode nxml-where)
3757 ;;;;;; "nxml-where" "nxhtml/nxml-where.el" (19365 33760))
3758 ;;; Generated autoloads from nxhtml/nxml-where.el
3759 (web-autoload-require 'nxml-where 'lp '(nxhtml-download-root-url nil) "nxhtml/nxml-where" nxhtml-install-dir 'nxhtml-byte-compile-file)
3762 (let ((loads (get 'nxml-where 'custom-loads))) (if (member '"nxml-where" loads) nil (put 'nxml-where 'custom-loads (cons '"nxml-where" loads))))
3764 (nxhtml-autoload 'nxml-where-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxml-where" nxhtml-install-dir) "\
3765 Shows path in mode line.
3767 \(fn &optional ARG)" t nil)
3769 (defvar nxml-where-global-mode nil "\
3770 Non-nil if Nxml-Where-Global mode is enabled.
3771 See the command `nxml-where-global-mode' for a description of this minor mode.
3772 Setting this variable directly does not take effect;
3773 either customize it (see the info node `Easy Customization')
3774 or call the function `nxml-where-global-mode'.")
3776 (nxhtml-custom-autoload 'nxml-where-global-mode 'nxml-where nil)
3778 (nxhtml-autoload 'nxml-where-global-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxml-where" nxhtml-install-dir) "\
3779 Toggle Nxml-Where mode in every possible buffer.
3780 With prefix ARG, turn Nxml-Where-Global mode on if and only if
3782 Nxml-Where mode is enabled in all buffers where
3783 `nxml-where-turn-on-in-nxml-child' would do it.
3784 See `nxml-where-mode' for more information on Nxml-Where mode.
3786 \(fn &optional ARG)" t nil)
3790 ;;;### (autoloads (nxhtml-features-check nxhtml-customize nxhtml)
3791 ;;;;;; "nxhtml" "nxhtml/nxhtml.el" (19412 25954))
3792 ;;; Generated autoloads from nxhtml/nxhtml.el
3793 (web-autoload-require 'nxhtml 'lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml" nxhtml-install-dir 'nxhtml-byte-compile-file)
3796 (let ((loads (get 'nxhtml 'custom-loads))) (if (member '"nxhtml" loads) nil (put 'nxhtml 'custom-loads (cons '"nxhtml" loads))))
3798 (nxhtml-autoload 'nxhtml-customize `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml" nxhtml-install-dir) "\
3803 (nxhtml-autoload 'nxhtml-features-check `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml" nxhtml-install-dir) "\
3804 Check if external modules used by nXhtml are found.
3810 ;;;### (autoloads (mako-nxhtml-mumamo-mode asp-nxhtml-mumamo-mode
3811 ;;;;;; eruby-nxhtml-mumamo-mode jsp-nxhtml-mumamo-mode gsp-nxhtml-mumamo-mode
3812 ;;;;;; smarty-nxhtml-mumamo-mode mjt-nxhtml-mumamo-mode genshi-nxhtml-mumamo-mode
3813 ;;;;;; mason-nxhtml-mumamo-mode django-nxhtml-mumamo-mode embperl-nxhtml-mumamo-mode
3814 ;;;;;; nxhtml-mumamo-mode) "nxhtml-mumamo" "nxhtml/nxhtml-mumamo.el"
3815 ;;;;;; (19389 57826))
3816 ;;; Generated autoloads from nxhtml/nxhtml-mumamo.el
3817 (web-autoload-require 'nxhtml-mumamo 'lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir 'nxhtml-byte-compile-file)
3820 (nxhtml-autoload 'nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3821 Turn on multiple major modes for (X)HTML with main mode `nxhtml-mode'.
3822 This covers inlined style and javascript and PHP.
3824 See also `mumamo-alt-php-tags-mode'." t)
3826 (nxhtml-autoload 'embperl-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3827 Turn on multiple major modes for Embperl files with main mode `nxhtml-mode'.
3828 This also covers inlined style and javascript." t)
3830 (nxhtml-autoload 'django-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3831 Turn on multiple major modes for Django with main mode `nxhtml-mode'.
3832 This also covers inlined style and javascript." t)
3834 (nxhtml-autoload 'mason-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3835 Turn on multiple major modes for Mason using main mode `nxhtml-mode'.
3836 This covers inlined style and javascript." t)
3838 (nxhtml-autoload 'genshi-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3839 Turn on multiple major modes for Genshi with main mode `nxhtml-mode'.
3840 This also covers inlined style and javascript." t)
3842 (nxhtml-autoload 'mjt-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3843 Turn on multiple major modes for MJT with main mode `nxhtml-mode'.
3844 This also covers inlined style and javascript." t)
3846 (nxhtml-autoload 'smarty-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3847 Turn on multiple major modes for Smarty with main mode `nxhtml-mode'.
3848 This also covers inlined style and javascript." t)
3850 (nxhtml-autoload 'gsp-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3851 Turn on multiple major modes for GSP with main mode `nxhtml-mode'.
3852 This also covers inlined style and javascript." t)
3854 (nxhtml-autoload 'jsp-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3855 Turn on multiple major modes for JSP with main mode `nxhtml-mode'.
3856 This also covers inlined style and javascript." t)
3858 (nxhtml-autoload 'eruby-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3859 Turn on multiple major modes for eRuby with main mode `nxhtml-mode'.
3860 This also covers inlined style and javascript." t)
3862 (nxhtml-autoload 'asp-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3863 Turn on multiple major modes for ASP with main mode `nxhtml-mode'.
3864 This also covers inlined style and javascript." t)
3866 (nxhtml-autoload 'mako-nxhtml-mumamo-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mumamo" nxhtml-install-dir) "\
3867 Turn on multiple major modes for Mako with main mode `nxhtml-mode'.
3868 This also covers inlined style and javascript." t)
3872 ;;;### (autoloads (nxhtml-validation-header-mode nxhtml-short-tag-help
3873 ;;;;;; nxhtml-mode) "nxhtml-mode" "nxhtml/nxhtml-mode.el" (19412
3875 ;;; Generated autoloads from nxhtml/nxhtml-mode.el
3876 (web-autoload-require 'nxhtml-mode 'lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
3879 (when (fboundp 'nxml-mode)
3880 (nxhtml-autoload 'nxhtml-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mode" nxhtml-install-dir) "\
3881 Major mode for editing XHTML documents.
3882 It is based on `nxml-mode' and adds some features that are useful
3883 when editing XHTML files.\\<nxhtml-mode-map>
3885 To see an overview in html format do \\[nxhtml-overview].
3887 * Note: Please observe that when loading nXhtml some file
3888 associations are done, see `nxhtml-setup-file-assoc'.
3890 The nXhtml menu is added by this mode (or actually the minor
3891 mode `nxhtml-menu-mode') and gives quick access and an overview
3892 of some other important features. These includes:
3894 - multiple major modes, see `define-mumamo-multi-major-mode'
3895 - easy uploading and viewing of files, see for example
3896 `html-upl-upload-file'
3897 - validation in XHTML part for php etc, see
3898 `nxhtml-validation-header-mode' (you probably also want to know about
3899 `nxhtml-toggle-visible-warnings' for this!)
3900 - converting of html to xhtml, see `tidy-buffer'
3902 The XML menu contains functionality added by `nxml-mode' (on
3903 which this major mode is based). There is also a popup menu
3904 added to the [apps] key.
3906 The most important features are probably completion and
3907 validation, which is inherited from `nxml-mode' with some small
3908 addtions. In very many situation you can use completion. To
3909 access it type \\[nxml-complete]. Completion has been enhanced in
3912 - If region is active and visible then completion will surround the
3913 region with the chosen tag's start and end tag. However only the
3914 starting point is checked for validity. If something is wrong after
3915 insertion you will however immediately see it if you have validation
3917 - It can in some cases give assistance with attribute values.
3918 - Completion can be customized, see the menus XHTML - Completion:
3919 * You can use a menu popup style completion.
3920 * You can have alternatives grouped.
3921 * You can get a short help text shown for each alternative.
3922 - There does not have to be a '<' before point for tag name
3923 completion. (`nxml-mode' requires a '<' before point for tag name
3925 - Completes xml version and encoding.
3926 - Completes in an empty buffer, ie inserts a skeleton.
3928 Some smaller, useful, but easy-to-miss features:
3930 * Following links. The href and src attribute names are
3931 underlined and a special keymap is bound to
3932 them:\\<mlinks-mode-map>
3934 \\[mlinks-backward-link], \\[mlinks-forward-link] Move
3935 between underlined href/src attributes
3937 \\[mlinks-goto], Mouse-1 Follow link inside Emacs
3940 It is even a little bit quicker when the links are in an active
3941 state (marked with the face `isearch'):\\<mlinks-active-hilight-keymap>
3943 \\[mlinks-backward-link], \\[mlinks-forward-link] Move
3944 between underlined href/src attributes
3945 \\[mlinks-goto], Mouse-1 Follow link inside Emacs (if possible)
3947 If the link is not into a file that you can edit (a mailto link
3948 for example) you will be prompted for an alternative action.
3950 * Creating links. To make it easier to create links to id/name
3951 attribute in different files there are two special
3952 functions:\\<nxhtml-mode-map>
3954 \\[nxhtml-save-link-to-here] copy link to id/name (you must
3955 be in the tag to get the link)
3956 \\[nxhtml-paste-link-as-a-tag] paste this as an a-tag.
3958 Here are all key bindings in nxhtml-mode itself:
3962 The minor mode `nxhtml-menu-mode' adds some bindings:
3964 \\{nxhtml-menu-mode-map}
3966 Notice that other minor mode key bindings may also be active, as
3967 well as emulation modes. Do \\[describe-bindings] to get a list
3968 of all active key bindings. Also, *VERY IMPORTANT*, if mumamo is
3969 used in the buffer each mumamo chunk has a different major mode
3970 with different key bindings. You can however still see all
3971 bindings with \\[describe-bindings], but you have to do that with
3972 point in the mumamo chunk you want to know the key bindings in.
3975 * Note: Some of the features supported by this mode are optional
3976 and available only if other Emacs modules are found. Use
3977 \\[nxhtml-features-check] to get a list of these optional
3978 features and modules needed. You should however have no problem
3979 with this if you have followed the installation instructions
3984 (nxhtml-autoload 'nxhtml-short-tag-help `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mode" nxhtml-install-dir) "\
3985 Display description of tag TAG. If TAG is omitted, try tag at point.
3989 (when (fboundp 'nxml-mode)
3990 (nxhtml-autoload 'nxhtml-validation-header-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-mode" nxhtml-install-dir) "\
3991 If on use a Fictive XHTML Validation Header for the buffer.
3992 See `nxhtml-set-validation-header' for information about Fictive XHTML Validation Headers.
3994 This mode may be turned on automatically in two ways:
3995 - If you try to do completion of a XHTML tag or attribute then
3996 `nxthml-mode' may ask you if you want to turn this mode on if
3998 - You can also choose to have it turned on automatically whenever
3999 a mumamo multi major mode is used, see
4000 `nxhtml-validation-header-if-mumamo' for further information.
4002 \(fn &optional ARG)" t nil))
4006 ;;;### (autoloads (nxhtml-overview nxhtml-menu-mode nxhtml-browse-region
4007 ;;;;;; nxhtml-browse-file nxhtml-edit-with-gimp) "nxhtml-menu" "nxhtml/nxhtml-menu.el"
4008 ;;;;;; (19412 26360))
4009 ;;; Generated autoloads from nxhtml/nxhtml-menu.el
4010 (web-autoload-require 'nxhtml-menu 'lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-menu" nxhtml-install-dir 'nxhtml-byte-compile-file)
4013 (nxhtml-autoload 'nxhtml-edit-with-gimp `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-menu" nxhtml-install-dir) "\
4014 Edit with GIMP buffer or file at point.
4018 (nxhtml-autoload 'nxhtml-browse-file `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-menu" nxhtml-install-dir) "\
4019 View file in web browser.
4023 (nxhtml-autoload 'nxhtml-browse-region `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-menu" nxhtml-install-dir) "\
4024 View region in web browser.
4028 (defvar nxhtml-menu-mode nil "\
4029 Non-nil if Nxhtml-Menu mode is enabled.
4030 See the command `nxhtml-menu-mode' for a description of this minor mode.")
4032 (nxhtml-custom-autoload 'nxhtml-menu-mode 'nxhtml-menu nil)
4034 (nxhtml-autoload 'nxhtml-menu-mode `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-menu" nxhtml-install-dir) "\
4035 Minor mode to turn on some key and menu bindings.
4036 See `nxhtml-mode' for more information.
4038 \(fn &optional ARG)" t nil)
4040 (nxhtml-autoload 'nxhtml-overview `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-menu" nxhtml-install-dir) "\
4041 Show a HTML page with an overview of nXhtml.
4047 ;;;### (autoloads (nxhtml-report-bug) "nxhtml-bug" "nxhtml/nxhtml-bug.el"
4048 ;;;;;; (19277 65354))
4049 ;;; Generated autoloads from nxhtml/nxhtml-bug.el
4050 (web-autoload-require 'nxhtml-bug 'lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-bug" nxhtml-install-dir 'nxhtml-byte-compile-file)
4053 (nxhtml-autoload 'nxhtml-report-bug `(lp '(nxhtml-download-root-url nil) "nxhtml/nxhtml-bug" nxhtml-install-dir) "\
4054 Report a bug in nXhtml.
4060 ;;;### (autoloads (html-wtoc) "html-wtoc" "nxhtml/html-wtoc.el" (19364
4062 ;;; Generated autoloads from nxhtml/html-wtoc.el
4063 (web-autoload-require 'html-wtoc 'lp '(nxhtml-download-root-url nil) "nxhtml/html-wtoc" nxhtml-install-dir 'nxhtml-byte-compile-file)
4066 (let ((loads (get 'html-wtoc 'custom-loads))) (if (member '"html-wtoc" loads) nil (put 'html-wtoc 'custom-loads (cons '"html-wtoc" loads))))
4070 ;;;### (autoloads (html-upl-ediff-file html-upl-edit-remote-file-with-toc
4071 ;;;;;; html-upl-edit-remote-file html-upl-upload-file html-upl-remote-dired
4072 ;;;;;; html-upl-upload-site html-upl-upload-site-with-toc html-upl)
4073 ;;;;;; "html-upl" "nxhtml/html-upl.el" (19364 56214))
4074 ;;; Generated autoloads from nxhtml/html-upl.el
4075 (web-autoload-require 'html-upl 'lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir 'nxhtml-byte-compile-file)
4078 (let ((loads (get 'html-upl 'custom-loads))) (if (member '"html-upl" loads) nil (put 'html-upl 'custom-loads (cons '"html-upl" loads))))
4080 (nxhtml-autoload 'html-upl-upload-site-with-toc `(lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir) "\
4085 (nxhtml-autoload 'html-upl-upload-site `(lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir) "\
4090 (nxhtml-autoload 'html-upl-remote-dired `(lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir) "\
4091 Start dired for remote directory or its parent/ancestor.
4093 \(fn DIRNAME)" t nil)
4095 (nxhtml-autoload 'html-upl-upload-file `(lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir) "\
4096 Upload a single file in a site.
4097 For the definition of a site see `html-site-current'.
4099 \(fn FILENAME)" t nil)
4101 (nxhtml-autoload 'html-upl-edit-remote-file `(lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir) "\
4106 (nxhtml-autoload 'html-upl-edit-remote-file-with-toc `(lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir) "\
4111 (nxhtml-autoload 'html-upl-ediff-file `(lp '(nxhtml-download-root-url nil) "nxhtml/html-upl" nxhtml-install-dir) "\
4112 Run ediff on local and remote file.
4113 FILENAME could be either the remote or the local file.
4115 \(fn FILENAME)" t nil)
4119 ;;;### (autoloads (html-toc) "html-toc" "nxhtml/html-toc.el" (19364
4121 ;;; Generated autoloads from nxhtml/html-toc.el
4122 (web-autoload-require 'html-toc 'lp '(nxhtml-download-root-url nil) "nxhtml/html-toc" nxhtml-install-dir 'nxhtml-byte-compile-file)
4125 (let ((loads (get 'html-toc 'custom-loads))) (if (member '"html-toc" loads) nil (put 'html-toc 'custom-loads (cons '"html-toc" loads))))
4127 (defconst html-toc-menu-map (let ((map (make-sparse-keymap))) (define-key map [html-toc-browse-frames-file] (list 'menu-item "Browse Frames File" 'html-toc-browse-frames-file)) (define-key map [html-toc-write-frames-file] (list 'menu-item "Write Frames File" 'html-toc-write-frames-file)) (define-key map [html-toc-write-toc-file] (list 'menu-item "Write TOC File for Frames" 'html-toc-write-toc-file)) (define-key map [html-toc-sep1] (list 'menu-item "--")) (define-key map [html-toc-edit-pages-file] (list 'menu-item "Edit List of Pages for TOC" 'html-site-edit-pages-file)) (define-key map [html-toc-create-pages-file] (list 'menu-item "Write List of Pages for TOC" 'html-toc-create-pages-file)) map))
4131 ;;;### (autoloads (html-site-query-replace html-site-rgrep html-site-find-file
4132 ;;;;;; html-site-dired-current html-site-set-site html-site-buffer-or-dired-file-name
4133 ;;;;;; html-site) "html-site" "nxhtml/html-site.el" (19364 56214))
4134 ;;; Generated autoloads from nxhtml/html-site.el
4135 (web-autoload-require 'html-site 'lp '(nxhtml-download-root-url nil) "nxhtml/html-site" nxhtml-install-dir 'nxhtml-byte-compile-file)
4138 (let ((loads (get 'html-site 'custom-loads))) (if (member '"html-site" loads) nil (put 'html-site 'custom-loads (cons '"html-site" loads))))
4140 (nxhtml-autoload 'html-site-buffer-or-dired-file-name `(lp '(nxhtml-download-root-url nil) "nxhtml/html-site" nxhtml-install-dir) "\
4141 Return buffer file name or file pointed to in dired.
4145 (nxhtml-autoload 'html-site-set-site `(lp '(nxhtml-download-root-url nil) "nxhtml/html-site" nxhtml-install-dir) "\
4150 (nxhtml-autoload 'html-site-dired-current `(lp '(nxhtml-download-root-url nil) "nxhtml/html-site" nxhtml-install-dir) "\
4151 Open `dired' in current site top directory.
4155 (nxhtml-autoload 'html-site-find-file `(lp '(nxhtml-download-root-url nil) "nxhtml/html-site" nxhtml-install-dir) "\
4156 Find file in current site.
4160 (nxhtml-autoload 'html-site-rgrep `(lp '(nxhtml-download-root-url nil) "nxhtml/html-site" nxhtml-install-dir) "\
4161 Search current site's files with `rgrep'.
4162 See `rgrep' for the arguments REGEXP and FILES.
4164 \(fn REGEXP FILES)" t nil)
4166 (nxhtml-autoload 'html-site-query-replace `(lp '(nxhtml-download-root-url nil) "nxhtml/html-site" nxhtml-install-dir) "\
4167 Query replace in current site's files.
4169 \(fn FROM TO FILE-REGEXP DELIMITED)" t nil)
4173 ;;;### (autoloads (html-pagetoc-rebuild-toc html-pagetoc-insert-toc
4174 ;;;;;; html-pagetoc) "html-pagetoc" "nxhtml/html-pagetoc.el" (19364
4176 ;;; Generated autoloads from nxhtml/html-pagetoc.el
4177 (web-autoload-require 'html-pagetoc 'lp '(nxhtml-download-root-url nil) "nxhtml/html-pagetoc" nxhtml-install-dir 'nxhtml-byte-compile-file)
4180 (let ((loads (get 'html-pagetoc 'custom-loads))) (if (member '"html-pagetoc" loads) nil (put 'html-pagetoc 'custom-loads (cons '"html-pagetoc" loads))))
4182 (nxhtml-autoload 'html-pagetoc-insert-toc `(lp '(nxhtml-download-root-url nil) "nxhtml/html-pagetoc" nxhtml-install-dir) "\
4183 Inserts a table of contents for the current html file.
4184 The html header tags h1-h6 found in the file are inserted into
4185 this table. MIN-LEVEL and MAX-LEVEL specifies the minimum and
4186 maximum level of h1-h6 to include. They should be integers.
4188 \(fn &optional MIN-LEVEL MAX-LEVEL)" t nil)
4190 (nxhtml-autoload 'html-pagetoc-rebuild-toc `(lp '(nxhtml-download-root-url nil) "nxhtml/html-pagetoc" nxhtml-install-dir) "\
4191 Update the table of contents inserted by `html-pagetoc-insert-toc'.
4195 (defconst html-pagetoc-menu-map (let ((map (make-sparse-keymap))) (define-key map [html-pagetoc-rebuild-toc] (list 'menu-item "Update Page TOC" 'html-pagetoc-rebuild-toc)) (define-key map [html-pagetoc-insert-style-guide] (list 'menu-item "Insert CSS Style for Page TOC" 'html-pagetoc-insert-style-guide)) (define-key map [html-pagetoc-insert-toc] (list 'menu-item "Insert Page TOC" 'html-pagetoc-insert-toc)) map))
4199 ;;;### (autoloads (html-chklnk) "html-chklnk" "nxhtml/html-chklnk.el"
4200 ;;;;;; (19364 56214))
4201 ;;; Generated autoloads from nxhtml/html-chklnk.el
4202 (web-autoload-require 'html-chklnk 'lp '(nxhtml-download-root-url nil) "nxhtml/html-chklnk" nxhtml-install-dir 'nxhtml-byte-compile-file)
4205 (let ((loads (get 'html-chklnk 'custom-loads))) (if (member '"html-chklnk" loads) nil (put 'html-chklnk 'custom-loads (cons '"html-chklnk" loads))))
4209 ;;;### (autoloads (web-vcs-investigate-elisp-file web-vcs-byte-compile-file
4210 ;;;;;; web-vcs-message-with-face web-vcs-get-files-from-root web-vcs-log-edit
4211 ;;;;;; web-vcs-default-download-directory) "web-vcs" "web-vcs.el"
4212 ;;;;;; (19412 16397))
4213 ;;; Generated autoloads from web-vcs.el
4214 (web-autoload-require 'web-vcs 'lp '(nxhtml-download-root-url nil) "web-vcs" nxhtml-install-dir 'nxhtml-byte-compile-file)
4217 (nxhtml-autoload 'web-vcs-default-download-directory `(lp '(nxhtml-download-root-url nil) "web-vcs" nxhtml-install-dir) "\
4218 Try to find a suitable place.
4219 Considers site-start.el, site-
4223 (nxhtml-autoload 'web-vcs-log-edit `(lp '(nxhtml-download-root-url nil) "web-vcs" nxhtml-install-dir) "\
4228 (nxhtml-autoload 'web-vcs-get-files-from-root `(lp '(nxhtml-download-root-url nil) "web-vcs" nxhtml-install-dir) "\
4229 Download a file tree from VCS system using the web interface.
4230 Use WEB-VCS entry in variable `web-vcs-links-regexp' to download
4231 files via http from URL to directory DL-DIR.
4233 Show URL first and offer to visit the page. That page will give
4234 you information about version control system (VCS) system used
4237 \(fn WEB-VCS URL DL-DIR)" nil nil)
4239 (nxhtml-autoload 'web-vcs-message-with-face `(lp '(nxhtml-download-root-url nil) "web-vcs" nxhtml-install-dir) "\
4240 Display a colored message at the bottom of the string.
4241 FACE is the face to use for the message.
4242 FORMAT-STRING and ARGS are the same as for `message'.
4244 Also put FACE on the message in *Messages* buffer.
4246 \(fn FACE FORMAT-STRING &rest ARGS)" nil nil)
4248 (nxhtml-autoload 'web-vcs-byte-compile-file `(lp '(nxhtml-download-root-url nil) "web-vcs" nxhtml-install-dir) "\
4249 Byte compile FILE in a new Emacs sub process.
4250 EXTRA-LOAD-PATH is added to the front of `load-path' during
4253 FILE is set to `buffer-file-name' when called interactively.
4256 \(fn FILE &optional LOAD EXTRA-LOAD-PATH COMP-DIR)" t nil)
4258 (nxhtml-autoload 'web-vcs-investigate-elisp-file `(lp '(nxhtml-download-root-url nil) "web-vcs" nxhtml-install-dir) "\
4261 \(fn FILE-OR-BUFFER)" t nil)
4265 ;;;### (autoloads (nxhtmlmaint-byte-uncompile-all nxhtmlmaint-byte-recompile
4266 ;;;;;; nxhtmlmaint-start-byte-compilation) "nxhtmlmaint" "nxhtmlmaint.el"
4267 ;;;;;; (19378 31293))
4268 ;;; Generated autoloads from nxhtmlmaint.el
4269 (web-autoload-require 'nxhtmlmaint 'lp '(nxhtml-download-root-url nil) "nxhtmlmaint" nxhtml-install-dir 'nxhtml-byte-compile-file)
4272 (nxhtml-autoload 'nxhtmlmaint-start-byte-compilation `(lp '(nxhtml-download-root-url nil) "nxhtmlmaint" nxhtml-install-dir) "\
4273 Start byte compilation of nXhtml in new Emacs instance.
4274 Byte compiling in general makes elisp code run 5-10 times faster
4275 which is quite noticeable when you use nXhtml.
4277 This will also update the file nxhtml-loaddefs.el.
4279 You must restart Emacs to use the byte compiled files.
4281 If for some reason the byte compiled files does not work you can
4282 remove then with `nxhtmlmaint-byte-uncompile-all'.
4286 (nxhtml-autoload 'nxhtmlmaint-byte-recompile `(lp '(nxhtml-download-root-url nil) "nxhtmlmaint" nxhtml-install-dir) "\
4287 Recompile or compile all nXhtml files in current Emacs.
4291 (nxhtml-autoload 'nxhtmlmaint-byte-uncompile-all `(lp '(nxhtml-download-root-url nil) "nxhtmlmaint" nxhtml-install-dir) "\
4292 Delete byte compiled files in nXhtml.
4293 This will also update the file nxhtml-loaddefs.el.
4295 See `nxhtmlmaint-start-byte-compilation' for byte compiling.
4301 ;;;### (autoloads (zencoding-preview zencoding-expand-yas zencoding-mode
4302 ;;;;;; zencoding-expand-line zencoding) "zencoding-mode" "util/zencoding-mode.el"
4303 ;;;;;; (19275 63380))
4304 ;;; Generated autoloads from util/zencoding-mode.el
4305 (web-autoload-require 'zencoding-mode 'lp '(nxhtml-download-root-url nil) "util/zencoding-mode" nxhtml-install-dir 'nxhtml-byte-compile-file)
4308 (let ((loads (get 'zencoding 'custom-loads))) (if (member '"zencoding-mode" loads) nil (put 'zencoding 'custom-loads (cons '"zencoding-mode" loads))))
4310 (nxhtml-autoload 'zencoding-expand-line `(lp '(nxhtml-download-root-url nil) "util/zencoding-mode" nxhtml-install-dir) "\
4311 Replace the current line's zencode expression with the corresponding expansion.
4312 If prefix ARG is given or region is visible call `zencoding-preview' to start an
4313 interactive preview.
4315 Otherwise expand line directly.
4317 For more information see `zencoding-mode'.
4321 (nxhtml-autoload 'zencoding-mode `(lp '(nxhtml-download-root-url nil) "util/zencoding-mode" nxhtml-install-dir) "\
4322 Minor mode for writing HTML and CSS markup.
4323 With zen coding for HTML and CSS you can write a line like
4327 and have it expanded to
4330 <li class=\"item\"></li>
4331 <li class=\"item\"></li>
4334 This minor mode defines keys for quick access:
4336 \\{zencoding-mode-keymap}
4338 Home page URL `http://www.emacswiki.org/emacs/ZenCoding'.
4340 See also `zencoding-expand-line'.
4342 \(fn &optional ARG)" t nil)
4344 (nxhtml-autoload 'zencoding-expand-yas `(lp '(nxhtml-download-root-url nil) "util/zencoding-mode" nxhtml-install-dir) "\
4349 (nxhtml-autoload 'zencoding-preview `(lp '(nxhtml-download-root-url nil) "util/zencoding-mode" nxhtml-install-dir) "\
4350 Expand zencode between BEG and END interactively.
4351 This will show a preview of the expanded zen code and you can
4352 accept it or skip it.
4354 \(fn BEG END)" t nil)
4358 ;;;### (autoloads nil nil ("autostart.el" "autostart22.el" "etc/schema/schema-path-patch.el"
4359 ;;;;;; "nxhtml-base.el" "nxhtml/html-imenu.el" "nxhtml/html-move.el"
4360 ;;;;;; "nxhtml/html-quote.el" "nxhtml/nxhtml-autoload.el" "nxhtml/nxhtml-strval.el"
4361 ;;;;;; "nxhtml/nxhtmljs.el" "nxhtml/outline-magic.el" "nxhtml/wtest.el"
4362 ;;;;;; "related/flymake-helpers.el" "related/flymakemsg.el" "related/flymu.el"
4363 ;;;;;; "related/php-imenu.el" "tests/angus77-setup-jde.el" "tests/emacstest-suites.el"
4364 ;;;;;; "tests/ert2.el" "tests/hfy-test.el" "tests/inemacs/bug1013.el"
4365 ;;;;;; "tests/mumamo-test.el" "tests/nxhtmltest-helpers.el" "tests/temp-test.el"
4366 ;;;;;; "util/appmenu-fold.el" "util/css-simple-completion.el" "util/custsets.el"
4367 ;;;;;; "util/ecb-batch-compile.el" "util/fupd.el" "util/idn.el"
4368 ;;;;;; "util/key-cat.el" "util/mumamo-aspnet.el" "util/mumamo-trace.el"
4369 ;;;;;; "util/new-key-seq-widget.el" "util/nxml-mode-os-additions.el"
4370 ;;;;;; "util/org-panel.el" "util/rxi.el" "util/useful-commands.el"
4371 ;;;;;; "web-autoload.el") (19412 26385 593000))
4375 ;;;### (autoloads (nxhtml-byte-recompile-file nxhtml-byte-compile-file
4376 ;;;;;; nxhtml-get-missing-files nxhtml-update-existing-files nxhtml-setup-download-all
4377 ;;;;;; nxhtml-setup-auto-download nxhtml-setup-install) "nxhtml-web-vcs"
4378 ;;;;;; "nxhtml-web-vcs.el" (19412 16464))
4379 ;;; Generated autoloads from nxhtml-web-vcs.el
4380 (web-autoload-require 'nxhtml-web-vcs 'lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir 'nxhtml-byte-compile-file)
4383 (nxhtml-autoload 'nxhtml-setup-install `(lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir) "\
4384 Setup and start nXhtml installation.
4386 This is for installation and updating directly from the nXhtml
4387 development sources.
4389 There are two different ways to install:
4391 (1) Download all at once: `nxhtml-setup-download-all'
4392 (2) Automatically download part by part: `nxhtml-setup-auto-download'
4394 You can convert between those ways by calling this function again.
4395 You can also do this by setting the option `nxhtml-autoload-web' yourself.
4397 When you have nXhtml installed you can update it:
4399 (3) Update new files in nXhtml: `nxhtml-update-existing-files'
4401 To learn more about nXhtml visit its home page at URL
4402 `http://www.emacswiki.com/NxhtmlMode/'.
4404 If you want to test auto download (but not use it further) there
4405 is a special function for that, you answer T here:
4407 (T) Test automatic download part by part: `nxhtml-setup-test-auto-download'
4411 If you want to download a zip file with latest released version instead then
4412 please see URL `http://ourcomments.org/Emacs/nXhtml/doc/nxhtml.html'.
4416 (nxhtml-autoload 'nxhtml-setup-auto-download `(lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir) "\
4417 Set up to autoload nXhtml files from the web.
4419 This function will download some initial files and then setup to
4420 download the rest when you need them.
4422 Files will be downloaded under the directory root you specify in
4425 Note that files will not be upgraded automatically. The auto
4426 downloading is just for files you are missing. (This may change a
4427 bit in the future.) If you want to upgrade those files that you
4428 have downloaded you can just call `nxhtml-update-existing-files'.
4430 You can easily switch between this mode of downloading or
4431 downloading the whole of nXhtml by once. To switch just call the
4432 command `nxhtml-setup-install'.
4434 See also the command `nxhtml-setup-download-all'.
4436 Note: If your nXhtml is to old you can't use this function
4437 directly. You have to upgrade first, se the function
4438 above. Version 2.07 or above is good for this.
4440 \(fn DL-DIR)" t nil)
4442 (nxhtml-autoload 'nxhtml-setup-download-all `(lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir) "\
4443 Download or update all of nXhtml.
4445 You can download all if nXhtml with this command.
4447 To update existing files use `nxhtml-update-existing-files'.
4449 If you want to download only those files you are actually using
4450 then call `nxhtml-setup-auto-download' instead.
4452 See the command `nxhtml-setup-install' for a convenient way to
4453 call these commands.
4455 For more information about auto download of nXhtml files see
4456 `nxhtml-setup-auto-download'.
4458 \(fn DL-DIR)" t nil)
4460 (nxhtml-autoload 'nxhtml-update-existing-files `(lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir) "\
4461 Update existing nXhtml files from the development sources.
4462 Only files you already have will be updated.
4464 Note that this works both if you have setup nXhtml to auto
4465 download files as you need them or if you have downloaded all of
4468 For more information about installing and updating nXhtml see the
4469 command `nxhtml-setup-install'.
4473 (nxhtml-autoload 'nxhtml-get-missing-files `(lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir) "\
4476 \(fn SUB-DIR FILE-NAME-LIST)" nil nil)
4478 (nxhtml-autoload 'nxhtml-byte-compile-file `(lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir) "\
4481 \(fn FILE &optional LOAD)" nil nil)
4483 (nxhtml-autoload 'nxhtml-byte-recompile-file `(lp '(nxhtml-download-root-url nil) "nxhtml-web-vcs" nxhtml-install-dir) "\
4484 Byte recompile FILE file if necessary.
4485 For more information see `nxhtml-byte-compile-file'.
4486 Loading is done if recompiled and LOAD is t.
4488 \(fn FILE &optional LOAD)" t nil)