/[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.2 - (hide annotations) (vendor branch)
Fri Jul 13 19:29:05 1990 UTC (23 years, 9 months ago) by ram
Changes since 1.1.1.1: +1 -1 lines
*** empty log message ***
1 ram 1.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 ram 1.1.1.1 `(typep ,s 'font-mark))
61 ram 1.1
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 ram 1.1.1.2 (defsetf logical-key-event-p %set-logical-key-event-p
593 ram 1.1 "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