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

Contents of /src/hemlock/struct.lisp

Parent Directory Parent Directory | Revision Log Revision Log


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

  ViewVC Help
Powered by ViewVC 1.1.5