/[cmucl]/src/hemlock/struct.lisp
ViewVC logotype

Contents of /src/hemlock/struct.lisp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.1.1.1 - (show annotations) (vendor branch)
Sun Jun 17 12:23:43 1990 UTC (23 years, 10 months ago) by ram
Changes since 1.1: +1 -2 lines
Made FAST-FONT-MARK-P be FONT-MARK-P.
1 ;;; -*- Log: hemlock.log; Package: Hemlock-Internals -*-
2 ;;;
3 ;;; **********************************************************************
4 ;;; This code was written as part of the Spice Lisp project at
5 ;;; Carnegie-Mellon University, and has been placed in the public domain.
6 ;;; Spice Lisp is currently incomplete and under active development.
7 ;;; If you want to use this code or any part of Spice Lisp, please contact
8 ;;; Scott Fahlman (FAHLMAN@CMUC).
9 ;;; **********************************************************************
10 ;;;
11 ;;; Structures and assorted macros for Hemlock.
12 ;;;
13
14 (in-package "HEMLOCK-INTERNALS")
15
16 (export '(mark mark-line mark-charpos markp region region-start region-end
17 regionp buffer bufferp buffer-modes buffer-point buffer-writable
18 buffer-delete-hook buffer-windows buffer-variables buffer-write-date
19 region regionp region-start region-end window windowp window-height
20 window-width window-display-start window-display-end window-point
21 commandp command command-function command-documentation
22 modeline-field modeline-field-p))
23
24
25 ;;;; Marks.
26
27 (defstruct (mark (:print-function %print-hmark)
28 (:predicate markp)
29 (:copier nil)
30 (:constructor internal-make-mark (line charpos %kind)))
31 "A Hemlock mark object. See Hemlock Command Implementor's Manual for details."
32 line ; pointer to line
33 charpos ; character position
34 %kind) ; type of mark
35
36 (setf (documentation 'markp 'function)
37 "Returns true if its argument is a Hemlock mark object, false otherwise.")
38 (setf (documentation 'mark-line 'function)
39 "Returns line that a Hemlock mark points to.")
40 (setf (documentation 'mark-charpos 'function)
41 "Returns the character position of a Hemlock mark.
42 A mark's character position is the index within the line of the character
43 following the mark.")
44
45 (defstruct (font-mark (:print-function
46 (lambda (s stream d)
47 (declare (ignore d))
48 (write-string "#<Hemlock Font-Mark \"" stream)
49 (%print-before-mark s stream)
50 (write-string "/\\" stream)
51 (%print-after-mark s stream)
52 (write-string "\">" stream)))
53 (:include mark)
54 (:copier nil)
55 (:constructor internal-make-font-mark
56 (line charpos %kind font)))
57 font)
58
59 (defmacro fast-font-mark-p (s)
60 `(typep ,s 'font-mark))
61
62
63 ;;;; Regions, buffers, modeline fields.
64
65 ;;; The region object:
66 ;;;
67 (defstruct (region (:print-function %print-hregion)
68 (:predicate regionp)
69 (:copier nil)
70 (:constructor internal-make-region (start end)))
71 "A Hemlock region object. See Hemlock Command Implementor's Manual for details."
72 start ; starting mark
73 end) ; ending mark
74
75 (setf (documentation 'regionp 'function)
76 "Returns true if its argument is a Hemlock region object, Nil otherwise.")
77 (setf (documentation 'region-end 'function)
78 "Returns the mark that is the end of a Hemlock region.")
79 (setf (documentation 'region-start 'function)
80 "Returns the mark that is the start of a Hemlock region.")
81
82
83 ;;; The buffer object:
84 ;;;
85 (defstruct (buffer (:constructor internal-make-buffer)
86 (:print-function %print-hbuffer)
87 (:copier nil)
88 (:predicate bufferp))
89 "A Hemlock buffer object. See Hemlock Command Implementor's Manual for details."
90 %name ; name of the buffer (a string)
91 %region ; the buffer's region
92 %pathname ; associated pathname
93 modes ; list of buffer's mode names
94 mode-objects ; list of buffer's mode objects
95 bindings ; buffer's command table
96 point ; current position in buffer
97 (%writable t) ; t => can alter buffer's region
98 (modified-tick -2) ; The last time the buffer was modified.
99 (unmodified-tick -1) ; The last time the buffer was unmodified
100 windows ; List of all windows into this buffer.
101 var-values ; the buffer's local variables
102 variables ; string-table of local variables
103 write-date ; File-Write-Date for pathname.
104 display-start ; Window display start when switching to buf.
105 %modeline-fields ; List of modeline-field-info's.
106 (delete-hook nil)) ; List of functions to call upon deletion.
107
108 (setf (documentation 'buffer-modes 'function)
109 "Return the list of the names of the modes active in a given buffer.")
110 (setf (documentation 'buffer-point 'function)
111 "Return the mark that is the current focus of attention in a buffer.")
112 (setf (documentation 'buffer-windows 'function)
113 "Return the list of windows that are displaying a given buffer.")
114 (setf (documentation 'buffer-variables 'function)
115 "Return the string-table of the variables local to the specifed buffer.")
116 (setf (documentation 'buffer-write-date 'function)
117 "Return in universal time format the write date for the file associated
118 with the buffer. If the pathname is set, then this should probably
119 be as well. Should be NIL if the date is unknown or there is no file.")
120 (setf (documentation 'buffer-delete-hook 'function)
121 "This is the list of buffer specific functions that Hemlock invokes when
122 deleting this buffer.")
123
124
125 ;;; Modeline fields.
126 ;;;
127 (defstruct (modeline-field (:print-function print-modeline-field)
128 (:constructor %make-modeline-field
129 (%name %function %width)))
130 "This is one item displayed in a Hemlock window's modeline."
131 %name ; EQL name of this field.
132 %function ; Function that returns a string for this field.
133 %width) ; Width to display this field in.
134
135 (setf (documentation 'modeline-field-p 'function)
136 "Returns true if its argument is a modeline field object, nil otherwise.")
137
138 (defstruct (modeline-field-info (:print-function print-modeline-field-info)
139 (:conc-name ml-field-info-)
140 (:constructor make-ml-field-info (field)))
141 field
142 (start nil)
143 (end nil))
144
145
146
147 ;;;; The mode object.
148
149 (defstruct (mode-object (:predicate modep)
150 (:copier nil)
151 (:print-function %print-hemlock-mode))
152 name ; name of this mode
153 setup-function ; setup function for this mode
154 cleanup-function ; Cleanup function for this mode
155 bindings ; The mode's command table.
156 transparent-p ; Are key-bindings transparent?
157 hook-name ; The name of the mode hook.
158 major-p ; Is this a major mode?
159 precedence ; The precedence for a minor mode.
160 character-attributes ; Mode local character attributes
161 variables ; String-table of mode variables
162 var-values ; Alist for saving mode variables
163 documentation) ; Introductory comments for mode describing commands.
164
165 (defun %print-hemlock-mode (object stream depth)
166 (declare (ignore depth))
167 (write-string "#<Hemlock Mode \"" stream)
168 (write-string (mode-object-name object) stream)
169 (write-string "\">" stream))
170
171
172
173 ;;;; Variables.
174
175 ;;; This holds information about Hemlock variables, and the system stores
176 ;;; these structures on the property list of the variable's symbolic
177 ;;; representation under the 'hemlock-variable-value property.
178 ;;;
179 (defstruct (variable-object
180 (:print-function
181 (lambda (object stream depth)
182 (declare (ignore depth))
183 (format stream "#<Hemlock Variable-Object ~S>"
184 (variable-object-name object))))
185 (:copier nil)
186 (:constructor make-variable-object (documentation name)))
187 value ; The value of this variable.
188 hooks ; The hook list for this variable.
189 down ; The variable-object for the previous value.
190 documentation ; The documentation.
191 name) ; The string name.
192
193
194
195 ;;;; Windows, dis-lines, and font-changes.
196
197 ;;; The window object:
198 ;;;
199 (defstruct (window (:constructor internal-make-window)
200 (:predicate windowp)
201 (:copier nil)
202 (:print-function %print-hwindow))
203 "This structure implements a Hemlock window."
204 tick ; The last time this window was updated.
205 %buffer ; buffer displayed in this window.
206 height ; Height of window in lines.
207 width ; Width of the window in characters.
208 old-start ; The charpos of the first char displayed.
209 first-line ; The head of the list of dis-lines.
210 last-line ; The last dis-line displayed.
211 first-changed ; The first changed dis-line on last update.
212 last-changed ; The last changed dis-line.
213 spare-lines ; The head of the list of unused dis-lines
214 (old-lines 0) ; Slot used by display to keep state info
215 hunk ; The device hunk that displays this window.
216 display-start ; first character position displayed
217 display-end ; last character displayed
218 point ; Where the cursor is in this window.
219 modeline-dis-line ; Dis-line for modeline display.
220 modeline-buffer ; Complete string of all modeline data.
221 modeline-buffer-len) ; Valid chars in modeline-buffer.
222
223 (setf (documentation 'windowp 'function)
224 "Returns true if its argument is a Hemlock window object, Nil otherwise.")
225 (setf (documentation 'window-height 'function)
226 "Return the height of a Hemlock window in character positions.")
227 (setf (documentation 'window-width 'function)
228 "Return the width of a Hemlock window in character positions.")
229 (setf (documentation 'window-display-start 'function)
230 "Return the mark which points before the first character displayed in
231 the supplied window.")
232 (setf (documentation 'window-display-end 'function)
233 "Return the mark which points after the last character displayed in
234 the supplied window.")
235 (setf (documentation 'window-point 'function)
236 "Return the mark that points to where the cursor is displayed in this
237 window. When the window is made current, the Buffer-Point of this
238 window's buffer is moved to this position. While the window is
239 current, redisplay makes this mark point to the same position as the
240 Buffer-Point of its buffer.")
241
242 (defstruct (dis-line (:copier nil)
243 (:constructor nil))
244 chars ; The line-image to be displayed.
245 (length 0 :type fixnum) ; Length of line-image.
246 font-changes) ; Font-Change structures for changes in this line.
247
248 (defstruct (window-dis-line (:copier nil)
249 (:include dis-line)
250 (:constructor make-window-dis-line (chars))
251 (:conc-name dis-line-))
252 old-chars ; Line-Chars of line displayed.
253 line ; Line displayed.
254 (flags 0 :type fixnum) ; Bit flags indicate line status.
255 (delta 0 :type fixnum) ; # lines moved from previous position.
256 (position 0 :type fixnum) ; Line # to be displayed on.
257 (end 0 :type fixnum)) ; Index after last logical character displayed.
258
259 (defstruct (font-change (:copier nil)
260 (:constructor make-font-change (next)))
261 x ; X position that change takes effect.
262 font ; Index into font-map of font to use.
263 next ; The next Font-Change on this dis-line.
264 mark) ; Font-Mark responsible for this change.
265
266
267
268 ;;;; Font family.
269
270 (defstruct font-family
271 map ; Font-map for hunk.
272 height ; Height of char box includung VSP.
273 width ; Width of font.
274 baseline ; Pixels from top of char box added to Y.
275 cursor-width ; Pixel width of cursor.
276 cursor-height ; Pixel height of cursor.
277 cursor-x-offset ; Added to pos of UL corner of char box to get
278 cursor-y-offset) ; UL corner of cursor blotch.
279
280
281
282 ;;;; Attribute descriptors.
283
284 (defstruct (attribute-descriptor
285 (:copier nil)
286 (:print-function %print-attribute-descriptor))
287 "This structure is used internally in Hemlock to describe a character
288 attribute."
289 name
290 keyword
291 documentation
292 vector
293 hooks
294 end-value)
295
296
297
298 ;;;; Commands.
299
300 (defstruct (command (:constructor internal-make-command
301 (%name documentation function))
302 (:copier nil)
303 (:predicate commandp)
304 (:print-function %print-hcommand))
305 %name ;The name of the command
306 documentation ;Command documentation string or function
307 function ;The function which implements the command
308 %bindings) ;Places where command is bound
309
310 (setf (documentation 'commandp 'function)
311 "Returns true if its argument is a Hemlock command object, Nil otherwise.")
312 (setf (documentation 'command-documentation 'function)
313 "Return the documentation for a Hemlock command, given the command-object.
314 Command documentation may be either a string or a function. This may
315 be set with Setf.")
316
317
318
319 ;;;; Random typeout streams.
320
321 ;;; These streams write to random typeout buffers for WITH-POP-UP-DISPLAY.
322 ;;;
323 (defstruct (random-typeout-stream (:include stream)
324 (:print-function print-random-typeout-stream)
325 (:constructor
326 make-random-typeout-stream (mark)))
327 mark ; The buffer point of the associated buffer.
328 window ; The hemlock window all this shit is in.
329 more-mark ; The mark that is not displayed when we need to more.
330 no-prompt ; T when we want to exit, still collecting output.
331 (first-more-p t)) ; T until the first time we more. Nil after.
332
333 (defun print-random-typeout-stream (object stream ignore)
334 (declare (ignore ignore))
335 (format stream "#<Hemlock Random-Typeout-Stream ~S>"
336 (buffer-name
337 (line-buffer (mark-line (random-typeout-stream-mark object))))))
338
339
340
341 ;;;; Redisplay devices.
342
343 ;;; Devices contain monitor specific redisplay methods referenced by
344 ;;; redisplay independent code.
345 ;;;
346 (defstruct (device (:print-function print-device)
347 (:constructor %make-device))
348 name ; simple-string such as "concept" or "lnz".
349 init ; fun to call whenever going into the editor.
350 ; args: device
351 exit ; fun to call whenever leaving the editor.
352 ; args: device
353 smart-redisplay ; fun to redisplay a window on this device.
354 ; args: window &optional recenterp
355 dumb-redisplay ; fun to redisplay a window on this device.
356 ; args: window &optional recenterp
357 after-redisplay ; args: device
358 ; fun to call at the end of redisplay entry points.
359 clear ; fun to clear the entire display.
360 ; args: device
361 note-read-wait ; fun to somehow note on display that input is expected.
362 ; args: on-or-off
363 put-cursor ; fun to put the cursor at (x,y) or (column,line).
364 ; args: hunk &optional x y
365 show-mark ; fun to display the screens cursor at a certain mark.
366 ; args: window x y time
367 next-window ; funs to return the next and previous window
368 previous-window ; of some window.
369 ; args: window
370 make-window ; fun to make a window on the screen.
371 ; args: device start-mark
372 ; &optional modeline-string modeline-function
373 delete-window ; fun to remove a window from the screen.
374 ; args: window
375 random-typeout-setup ; fun to prepare for random typeout.
376 ; args: device n
377 random-typeout-cleanup; fun to clean up after random typeout.
378 ; args: device degree
379 random-typeout-line-more ; fun to keep line-buffered streams up to date.
380 random-typeout-full-more ; fun to do full-buffered more-prompting.
381 ; args: # of newlines in the object just inserted
382 ; in the buffer.
383 force-output ; if non-nil, fun to force any output possibly buffered.
384 finish-output ; if non-nil, fun to force output and hand until done.
385 ; args: device window
386 beep ; fun to beep or flash the screen.
387 bottom-window-base ; bottom text line of bottom window.
388 hunks) ; list of hunks on the screen.
389
390 (defun print-device (obj str n)
391 (declare (ignore n))
392 (format str "#<Hemlock Device ~S>" (device-name obj)))
393
394
395 (defstruct (bitmap-device #|(:print-function print-device)|#
396 (:include device))
397 display) ; CLX display object.
398
399
400 (defstruct (tty-device #|(:print-function print-device)|#
401 (:constructor %make-tty-device)
402 (:include device))
403 dumbp ; t if it does not have line insertion and deletion.
404 lines ; number of lines on device.
405 columns ; number of columns per line.
406 display-string ; fun to display a string of characters at (x,y).
407 ; args: hunk x y string &optional start end
408 standout-init ; fun to put terminal in standout mode.
409 ; args: hunk
410 standout-end ; fun to take terminal out of standout mode.
411 ; args: hunk
412 clear-lines ; fun to clear n lines starting at (x,y).
413 ; args: hunk x y n
414 clear-to-eol ; fun to clear to the end of a line from (x,y).
415 ; args: hunk x y
416 clear-to-eow ; fun to clear to the end of a window from (x,y).
417 ; args: hunk x y
418 open-line ; fun to open a line moving lines below it down.
419 ; args: hunk x y &optional n
420 delete-line ; fun to delete a line moving lines below it up.
421 ; args: hunk x y &optional n
422 insert-string ; fun to insert a string in the middle of a line.
423 ; args: hunk x y string &optional start end
424 delete-char ; fun to delete a character from the middle of a line.
425 ; args: hunk x y &optional n
426 (cursor-x 0) ; column the cursor is in.
427 (cursor-y 0) ; line the cursor is on.
428 standout-init-string ; string to put terminal in standout mode.
429 standout-end-string ; string to take terminal out of standout mode.
430 clear-to-eol-string ; string to cause device to clear to eol at (x,y).
431 clear-string ; string to cause device to clear entire screen.
432 open-line-string ; string to cause device to open a blank line.
433 delete-line-string ; string to cause device to delete a line, moving
434 ; lines below it up.
435 insert-init-string ; string to put terminal in insert mode.
436 insert-char-init-string ; string to prepare terminal for insert-mode character.
437 insert-char-end-string ; string to affect terminal after insert-mode character.
438 insert-end-string ; string to take terminal out of insert mode.
439 delete-init-string ; string to put terminal in delete mode.
440 delete-char-string ; string to delete a character.
441 delete-end-string ; string to take terminal out of delete mode.
442 init-string ; device init string.
443 cm-end-string ; takes device out of cursor motion mode.
444 (cm-x-add-char nil) ; char-code to unconditionally add to x coordinate.
445 (cm-y-add-char nil) ; char-code to unconditionally add to y coordinate.
446 (cm-x-condx-char nil) ; char-code threshold for adding to x coordinate.
447 (cm-y-condx-char nil) ; char-code threshold for adding to y coordinate.
448 (cm-x-condx-add-char nil) ; char-code to conditionally add to x coordinate.
449 (cm-y-condx-add-char nil) ; char-code to conditionally add to y coordinate.
450 cm-string1 ; initial substring of cursor motion string.
451 cm-string2 ; substring of cursor motion string between coordinates.
452 cm-string3 ; substring of cursor motion string after coordinates.
453 cm-one-origin ; non-nil if need to add one to coordinates.
454 cm-reversep ; non-nil if need to reverse coordinates.
455 (cm-x-pad nil) ; nil, 0, 2, or 3 for places to pad.
456 ; 0 sends digit-chars.
457 (cm-y-pad nil) ; nil, 0, 2, or 3 for places to pad.
458 ; 0 sends digit-chars.
459 screen-image) ; vector device-lines long of strings
460 ; device-columns long.
461
462
463
464 ;;;; Device screen hunks.
465
466 ;;; Device-hunks are used to claim a piece of the screen and for ordering
467 ;;; pieces of the screen. Window motion primitives and splitting/merging
468 ;;; primitives use hunks. Hunks are somewhat of an interface between the
469 ;;; portable and non-portable parts of screen management, between what the
470 ;;; user sees on the screen and how Hemlock internals deal with window
471 ;;; sequencing and creation. Note: the echo area hunk is not hooked into
472 ;;; the ring of other hunks via the next and previous fields.
473 ;;;
474 (defstruct (device-hunk (:print-function %print-device-hunk))
475 "This structure is used internally by Hemlock's screen management system."
476 window ; Window displayed in this hunk.
477 position ; Bottom Y position of hunk.
478 height ; Height of hunk in pixels or lines.
479 next ; Next and previous hunks.
480 previous
481 device) ; Display device hunk is on.
482
483 (defun %print-device-hunk (object stream depth)
484 (declare (ignore depth))
485 (format stream "#<Hemlock Device-Hunk ~D+~D~@[, ~S~]>"
486 (device-hunk-position object)
487 (device-hunk-height object)
488 (let* ((window (device-hunk-window object))
489 (buffer (if window (window-buffer window))))
490 (if buffer (buffer-name buffer)))))
491
492
493 ;;; Bitmap hunks.
494 ;;;
495 ;;; The lock field is no longer used. If events could be handled while we
496 ;;; were in the middle of something with the hunk, then this could be set
497 ;;; for exclusion purposes.
498 ;;;
499 (defstruct (bitmap-hunk #|(:print-function %print-device-hunk)|#
500 (:include device-hunk))
501 width ; Pixel width.
502 char-height ; Height of text body in characters.
503 char-width ; Width in characters.
504 xwindow ; X window for this hunk.
505 gcontext ; X gcontext for xwindow.
506 start ; Head of dis-line list (no dummy).
507 end ; Exclusive end, i.e. nil if nil-terminated.
508 modeline-dis-line ; Dis-line for modeline, or NIL if none.
509 modeline-pos ; Position of modeline in pixels.
510 (lock t) ; Something going on, set trashed if we're changed.
511 trashed ; Something bad happened, recompute image.
512 font-family ; Font-family used in this window.
513 input-handler ; Gets hunk, char, x, y when char read.
514 changed-handler ; Gets hunk when size changed.
515 (thumb-bar-p nil)) ; True if we draw a thumb bar in the top border.
516
517
518 ;;; Terminal hunks.
519 ;;;
520 (defstruct (tty-hunk #|(:print-function %print-device-hunk)|#
521 (:include device-hunk))
522 text-position ; Bottom Y position of text in hunk.
523 text-height) ; Number of lines of text.
524
525
526
527 ;;;; Some defsetfs:
528
529 (defsetf buffer-writable %set-buffer-writable
530 "Sets whether the buffer is writable and invokes the Buffer Writable Hook.")
531 (defsetf buffer-name %set-buffer-name
532 "Sets the name of a specified buffer, invoking the Buffer Name Hook.")
533 (defsetf buffer-modified %set-buffer-modified
534 "Make a buffer modified or unmodified.")
535 (defsetf buffer-pathname %set-buffer-pathname
536 "Sets the pathname of a buffer, invoking the Buffer Pathname Hook.")
537
538 (defsetf getstring %set-string-table
539 "Sets the value for a string-table entry, making a new one if necessary.")
540
541 (defsetf window-buffer %set-window-buffer
542 "Change the buffer a window is mapped to.")
543
544 (lisp::define-setf-method value (var)
545 "Set the value of a Hemlock variable, calling any hooks."
546 (let ((svar (gensym)))
547 (values
548 ()
549 ()
550 (list svar)
551 `(%set-value ',var ,svar)
552 `(value ,var))))
553
554 (defsetf variable-value (name &optional (kind :current) where) (new-value)
555 "Set the value of a Hemlock variable, calling any hooks."
556 `(%set-variable-value ,name ,kind ,where ,new-value))
557
558 (defsetf variable-hooks (name &optional (kind :current) where) (new-value)
559 "Set the list of hook functions for a Hemlock variable."
560 `(%set-variable-hooks ,name ,kind ,where ,new-value))
561
562 (defsetf variable-documentation (name &optional (kind :current) where) (new-value)
563 "Set a Hemlock variable's documentation."
564 `(%set-variable-documentation ,name ,kind ,where ,new-value))
565
566 (defsetf buffer-minor-mode %set-buffer-minor-mode
567 "Turn a buffer minor mode on or off.")
568 (defsetf buffer-major-mode %set-buffer-major-mode
569 "Set a buffer's major mode.")
570 (defsetf previous-character %set-previous-character
571 "Sets the character to the left of the given Mark.")
572 (defsetf next-character %set-next-character
573 "Sets the characters to the right of the given Mark.")
574 (defsetf character-attribute %set-character-attribute
575 "Set the value for a character attribute.")
576 (defsetf character-attribute-hooks %set-character-attribute-hooks
577 "Set the hook list for a Hemlock character attribute.")
578 (defsetf ring-ref %set-ring-ref "Set an element in a ring.")
579 (defsetf current-window %set-current-window "Set the current window.")
580 (defsetf current-buffer %set-current-buffer
581 "Set the current buffer, doing necessary stuff.")
582 (defsetf mark-kind %set-mark-kind "Used to set the kind of a mark.")
583 (defsetf buffer-region %set-buffer-region "Set a buffer's region.")
584 (defsetf command-name %set-command-name
585 "Change a Hemlock command's name.")
586 (defsetf line-string %set-line-string
587 "Replace the contents of a line.")
588 (defsetf last-command-type %set-last-command-type
589 "Set the Last-Command-Type for use by the next command.")
590 (defsetf prefix-argument %set-prefix-argument
591 "Set the prefix argument for the next command.")
592 (defsetf logical-char= %set-logical-char=
593 "Change what Logical-Char= returns for the specified arguments.")
594 (defsetf window-font %set-window-font
595 "Change the font-object associated with a font-number in a window.")
596 (defsetf default-font %set-default-font
597 "Change the font-object associated with a font-number in new windows.")
598
599 (defsetf buffer-modeline-fields %set-buffer-modeline-fields
600 "Sets the buffer's list of modeline fields causing all windows into buffer
601 to be updated for the next redisplay.")
602 (defsetf modeline-field-name %set-modeline-field-name
603 "Sets a modeline-field's name. If one already exists with that name, an
604 error is signaled.")
605 (defsetf modeline-field-width %set-modeline-field-width
606 "Sets a modeline-field's width and updates all the fields for all windows
607 in any buffer whose fields list contains the field.")
608 (defsetf modeline-field-function %set-modeline-field-function
609 "Sets a modeline-field's function and updates this field for all windows in
610 any buffer whose fields list contains the field.")

  ViewVC Help
Powered by ViewVC 1.1.5