1 This is ../info/internals.info, produced by makeinfo version 4.0 from
2 internals/internals.texi.
4 INFO-DIR-SECTION XEmacs Editor
6 * Internals: (internals). XEmacs Internals Manual.
9 Copyright (C) 1992 - 1996 Ben Wing. Copyright (C) 1996, 1997 Sun
10 Microsystems. Copyright (C) 1994 - 1998 Free Software Foundation.
11 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
13 Permission is granted to make and distribute verbatim copies of this
14 manual provided the copyright notice and this permission notice are
15 preserved on all copies.
17 Permission is granted to copy and distribute modified versions of
18 this manual under the conditions for verbatim copying, provided that the
19 entire resulting derived work is distributed under the terms of a
20 permission notice identical to this one.
22 Permission is granted to copy and distribute translations of this
23 manual into another language, under the above conditions for modified
24 versions, except that this permission notice may be stated in a
25 translation approved by the Foundation.
27 Permission is granted to copy and distribute modified versions of
28 this manual under the conditions for verbatim copying, provided also
29 that the section entitled "GNU General Public License" is included
30 exactly as in the original, and provided that the entire resulting
31 derived work is distributed under the terms of a permission notice
32 identical to this one.
34 Permission is granted to copy and distribute translations of this
35 manual into another language, under the above conditions for modified
36 versions, except that the section entitled "GNU General Public License"
37 may be included in a translation approved by the Free Software
38 Foundation instead of in the original English.
41 File: internals.info, Node: Lucid Widget Library, Up: Interface to the X Window System
46 Lwlib is extremely poorly documented and quite hairy. The author(s)
47 blame that on X, Xt, and Motif, with some justice, but also sufficient
48 hypocrisy to avoid drawing the obvious conclusion about their own work.
50 The Lucid Widget Library is composed of two more or less independent
51 pieces. The first, as the name suggests, is a set of widgets. These
52 widgets are intended to resemble and improve on widgets provided in the
53 Motif toolkit but not in the Athena widgets, including menubars and
54 scrollbars. Recent additions by Andy Piper integrate some "modern"
55 widgets by Edward Falk, including checkboxes, radio buttons, progress
56 gauges, and index tab controls (aka notebooks).
58 The second piece of the Lucid widget library is a generic interface
59 to several toolkits for X (including Xt, the Athena widget set, and
60 Motif, as well as the Lucid widgets themselves) so that core XEmacs
61 code need not know which widget set has been used to build the
62 graphical user interface.
66 * Generic Widget Interface:: The lwlib generic widget interface.
69 * Checkboxes and Radio Buttons::
74 File: internals.info, Node: Generic Widget Interface, Next: Scrollbars, Up: Lucid Widget Library
76 Generic Widget Interface
77 ------------------------
79 In general in any toolkit a widget may be a composite object. In Xt,
80 all widgets have an X window that they manage, but typically a complex
81 widget will have widget children, each of which manages a subwindow of
82 the parent widget's X window. These children may themselves be
83 composite widgets. Thus a widget is actually a tree or hierarchy of
86 For each toolkit widget, lwlib maintains a tree of `widget_values'
87 which mirror the hierarchical state of Xt widgets (including Motif,
88 Athena, 3D Athena, and Falk's widget sets). Each `widget_value' has
89 `contents' member, which points to the head of a linked list of its
90 children. The linked list of siblings is chained through the `next'
91 member of `widget_value'.
99 +-------+ next +-------+ next +-------+
100 | child |----->| child |----->| child |
101 +-------+ +-------+ +-------+
105 +-------------+ next +-------------+
106 | grand child |----->| grand child |
107 +-------------+ +-------------+
109 The `widget_value' hierarchy of a composite widget with two simple
110 children and one composite child.
112 The `widget_instance' structure maintains the inverse view of the
113 tree. As for the `widget_value', siblings are chained through the
114 `next' member. However, rather than naming children, the
115 `widget_instance' tree links to parents.
123 +-------+ next +-------+ next +-------+
124 | child |----->| child |----->| child |
125 +-------+ +-------+ +-------+
129 +-------------+ next +-------------+
130 | grand child |----->| grand child |
131 +-------------+ +-------------+
133 The `widget_value' hierarchy of a composite widget with two simple
134 children and one composite child.
136 This permits widgets derived from different toolkits to be updated
137 and manipulated generically by the lwlib library. For instance
138 `update_one_widget_instance' can cope with multiple types of widget and
139 multiple types of toolkit. Each element in the widget hierarchy is
140 updated from its corresponding `widget_value' by walking the
141 `widget_value' tree. This has desirable properties. For example,
142 `lw_modify_all_widgets' is called from `glyphs-x.c' and updates all the
143 properties of a widget without having to know what the widget is or
144 what toolkit it is from. Unfortunately this also has its hairy
145 properties; the lwlib code quite complex. And of course lwlib has to
146 know at some level what the widget is and how to set its properties.
148 The `widget_instance' structure also contains a pointer to the root
149 of its tree. Widget instances are further confi
152 File: internals.info, Node: Scrollbars, Next: Menubars, Prev: Generic Widget Interface, Up: Lucid Widget Library
158 File: internals.info, Node: Menubars, Next: Checkboxes and Radio Buttons, Prev: Scrollbars, Up: Lucid Widget Library
164 File: internals.info, Node: Checkboxes and Radio Buttons, Next: Progress Bars, Prev: Menubars, Up: Lucid Widget Library
166 Checkboxes and Radio Buttons
167 ----------------------------
170 File: internals.info, Node: Progress Bars, Next: Tab Controls, Prev: Checkboxes and Radio Buttons, Up: Lucid Widget Library
176 File: internals.info, Node: Tab Controls, Prev: Progress Bars, Up: Lucid Widget Library
182 File: internals.info, Node: Index, Prev: Interface to the X Window System, Up: Top
189 * allocation from frob blocks: Allocation from Frob Blocks.
190 * allocation of objects in XEmacs Lisp: Allocation of Objects in XEmacs Lisp.
191 * allocation, introduction to: Introduction to Allocation.
192 * allocation, low-level: Low-level allocation.
193 * Amdahl Corporation: XEmacs.
194 * Andreessen, Marc: XEmacs.
195 * asynchronous subprocesses: Modules for Interfacing with the Operating System.
196 * bars, progress: Progress Bars.
197 * Baur, Steve: XEmacs.
198 * Benson, Eric: Lucid Emacs.
199 * binding; the specbinding stack; unwind-protects, dynamic: Dynamic Binding; The specbinding Stack; Unwind-Protects.
200 * bindings, evaluation; stack frames;: Evaluation; Stack Frames; Bindings.
201 * bit vector: Bit Vector.
202 * bridge, playing: XEmacs From the Outside.
203 * Buchholz, Martin: XEmacs.
204 * Bufbyte: Character-Related Data Types.
205 * Bufbytes and Emchars: Bufbytes and Emchars.
206 * buffer lists: Buffer Lists.
207 * buffer object, the: The Buffer Object.
208 * buffer, the text in a: The Text in a Buffer.
209 * buffers and textual representation: Buffers and Textual Representation.
210 * buffers, introduction to: Introduction to Buffers.
211 * Bufpos: Character-Related Data Types.
212 * building, XEmacs from the perspective of: XEmacs From the Perspective of Building.
213 * buttons, checkboxes and radio: Checkboxes and Radio Buttons.
214 * byte positions, working with character and: Working With Character and Byte Positions.
215 * Bytecount: Character-Related Data Types.
216 * bytecount_to_charcount: Working With Character and Byte Positions.
217 * Bytind: Character-Related Data Types.
218 * C code, rules when writing new: Rules When Writing New C Code.
219 * C vs. Lisp: The Lisp Language.
220 * callback routines, the event stream: The Event Stream Callback Routines.
221 * caller-protects (GCPRO rule): Writing Lisp Primitives.
222 * case table: Modules for Other Aspects of the Lisp Interpreter and Object System.
223 * catch and throw: Catch and Throw.
225 * character and byte positions, working with: Working With Character and Byte Positions.
226 * character encoding, internal: Internal Character Encoding.
227 * character sets: Character Sets.
228 * character sets and encodings, Mule: MULE Character Sets and Encodings.
229 * character-related data types: Character-Related Data Types.
230 * characters, integers and: Integers and Characters.
231 * Charcount: Character-Related Data Types.
232 * charcount_to_bytecount: Working With Character and Byte Positions.
233 * charptr_emchar: Working With Character and Byte Positions.
234 * charptr_n_addr: Working With Character and Byte Positions.
235 * checkboxes and radio buttons: Checkboxes and Radio Buttons.
236 * closer: Lstream Methods.
237 * closure: The XEmacs Object System (Abstractly Speaking).
238 * code, an example of Mule-aware: An Example of Mule-Aware Code.
239 * code, general guidelines for writing Mule-aware: General Guidelines for Writing Mule-Aware Code.
240 * code, rules when writing new C: Rules When Writing New C Code.
241 * coding for Mule: Coding for Mule.
242 * coding rules, general: General Coding Rules.
243 * command builder, dispatching events; the: Dispatching Events; The Command Builder.
244 * comments, writing good: Writing Good Comments.
245 * Common Lisp: The Lisp Language.
246 * compact_string_chars: compact_string_chars.
247 * compiled function: Compiled Function.
248 * compiler, the Lisp reader and: The Lisp Reader and Compiler.
250 * conservative garbage collection: GCPROing.
251 * consoles; devices; frames; windows: Consoles; Devices; Frames; Windows.
252 * consoles; devices; frames; windows, introduction to: Introduction to Consoles; Devices; Frames; Windows.
253 * control flow modules, editor-level: Editor-Level Control Flow Modules.
254 * conversion to and from external data: Conversion to and from External Data.
255 * converting events: Converting Events.
256 * copy-on-write: General Coding Rules.
257 * creating Lisp object types: Techniques for XEmacs Developers.
258 * critical redisplay sections: Critical Redisplay Sections.
259 * data dumping: Data dumping.
260 * data types, character-related: Character-Related Data Types.
261 * DEC_CHARPTR: Working With Character and Byte Positions.
262 * developers, techniques for XEmacs: Techniques for XEmacs Developers.
263 * devices; frames; windows, consoles;: Consoles; Devices; Frames; Windows.
264 * devices; frames; windows, introduction to consoles;: Introduction to Consoles; Devices; Frames; Windows.
265 * Devin, Matthieu: Lucid Emacs.
266 * dispatching events; the command builder: Dispatching Events; The Command Builder.
267 * display order of extents: Mathematics of Extent Ordering.
268 * display-related Lisp objects, modules for other: Modules for other Display-Related Lisp Objects.
269 * displayable Lisp objects, modules for the basic: Modules for the Basic Displayable Lisp Objects.
271 * dumping address allocation: Address allocation.
272 * dumping and its justification, what is: Dumping.
273 * dumping data descriptions: Data descriptions.
274 * dumping object inventory: Object inventory.
275 * dumping overview: Overview.
276 * dumping phase: Dumping phase.
277 * dumping, data: Data dumping.
278 * dumping, file loading: Reloading phase.
279 * dumping, object relocation: Reloading phase.
280 * dumping, pointers: Pointers dumping.
281 * dumping, putting back the pdump_opaques: Reloading phase.
282 * dumping, putting back the pdump_root_objects and pdump_weak_object_chains: Reloading phase.
283 * dumping, putting back the pdump_root_struct_ptrs: Reloading phase.
284 * dumping, reloading phase: Reloading phase.
285 * dumping, remaining issues: Remaining issues.
286 * dumping, reorganize the hash tables: Reloading phase.
287 * dumping, the header: The header.
288 * dynamic array: Low-Level Modules.
289 * dynamic binding; the specbinding stack; unwind-protects: Dynamic Binding; The specbinding Stack; Unwind-Protects.
290 * dynamic scoping: The Lisp Language.
291 * dynamic types: The Lisp Language.
292 * editing operations, modules for standard: Modules for Standard Editing Operations.
293 * Emacs 19, GNU: GNU Emacs 19.
294 * Emacs 20, GNU: GNU Emacs 20.
295 * Emacs, a history of: A History of Emacs.
296 * Emchar: Character-Related Data Types.
297 * Emchars, Bufbytes and: Bufbytes and Emchars.
298 * encoding, internal character: Internal Character Encoding.
299 * encoding, internal string: Internal String Encoding.
300 * encodings, internal Mule: Internal Mule Encodings.
301 * encodings, Mule: Encodings.
302 * encodings, Mule character sets and: MULE Character Sets and Encodings.
303 * Energize: Lucid Emacs.
305 * Epoch: Lucid Emacs.
306 * error checking: Techniques for XEmacs Developers.
307 * EUC (Extended Unix Code), Japanese: Japanese EUC (Extended Unix Code).
308 * evaluation: Evaluation.
309 * evaluation; stack frames; bindings: Evaluation; Stack Frames; Bindings.
310 * event gathering mechanism, specifics of the: Specifics of the Event Gathering Mechanism.
311 * event loop functions, other: Other Event Loop Functions.
312 * event loop, events and the: Events and the Event Loop.
313 * event stream callback routines, the: The Event Stream Callback Routines.
314 * event, specifics about the Lisp object: Specifics About the Emacs Event.
315 * events and the event loop: Events and the Event Loop.
316 * events, converting: Converting Events.
317 * events, introduction to: Introduction to Events.
318 * events, main loop: Main Loop.
319 * events; the command builder, dispatching: Dispatching Events; The Command Builder.
320 * Extbyte: Character-Related Data Types.
321 * Extcount: Character-Related Data Types.
322 * Extended Unix Code, Japanese EUC: Japanese EUC (Extended Unix Code).
323 * extent fragments: Extent Fragments.
324 * extent info, format of the: Format of the Extent Info.
325 * extent mathematics: Mathematics of Extent Ordering.
326 * extent ordering <1>: Mathematics of Extent Ordering.
327 * extent ordering: Extent Ordering.
329 * extents, display order: Mathematics of Extent Ordering.
330 * extents, introduction to: Introduction to Extents.
331 * extents, markers and: Markers and Extents.
332 * extents, zero-length: Zero-Length Extents.
333 * external data, conversion to and from: Conversion to and from External Data.
334 * external widget: Modules for Interfacing with X Windows.
336 * file system, modules for interfacing with the: Modules for Interfacing with the File System.
337 * flusher: Lstream Methods.
338 * fragments, extent: Extent Fragments.
339 * frames; windows, consoles; devices;: Consoles; Devices; Frames; Windows.
340 * frames; windows, introduction to consoles; devices;: Introduction to Consoles; Devices; Frames; Windows.
341 * Free Software Foundation: A History of Emacs.
342 * frob blocks, allocation from: Allocation from Frob Blocks.
343 * FSF: A History of Emacs.
344 * FSF Emacs <1>: GNU Emacs 20.
345 * FSF Emacs: GNU Emacs 19.
346 * function, compiled: Compiled Function.
347 * garbage collection: Garbage Collection.
348 * garbage collection - step by step: Garbage Collection - Step by Step.
349 * garbage collection protection <1>: GCPROing.
350 * garbage collection protection: Writing Lisp Primitives.
351 * garbage collection, conservative: GCPROing.
352 * garbage collection, invocation: Invocation.
353 * garbage_collect_1: garbage_collect_1.
354 * gc_sweep: gc_sweep.
355 * GCPROing: GCPROing.
356 * global Lisp variables, adding: Adding Global Lisp Variables.
357 * glyph instantiation: Glyphs.
359 * GNU Emacs 19: GNU Emacs 19.
360 * GNU Emacs 20: GNU Emacs 20.
361 * Gosling, James <1>: The Lisp Language.
362 * Gosling, James: Through Version 18.
363 * Great Usenet Renaming: Through Version 18.
364 * Hackers (Steven Levy): A History of Emacs.
365 * header files, inline functions: Techniques for XEmacs Developers.
366 * hierarchy of windows: Window Hierarchy.
367 * history of Emacs, a: A History of Emacs.
368 * Illinois, University of: XEmacs.
369 * INC_CHARPTR: Working With Character and Byte Positions.
370 * inline functions: Techniques for XEmacs Developers.
371 * inline functions, headers: Techniques for XEmacs Developers.
372 * inside, XEmacs from the: XEmacs From the Inside.
373 * instantiation, glyph: Glyphs.
374 * integers and characters: Integers and Characters.
375 * interactive: Modules for Standard Editing Operations.
376 * interfacing with the file system, modules for: Modules for Interfacing with the File System.
377 * interfacing with the operating system, modules for: Modules for Interfacing with the Operating System.
378 * interfacing with X Windows, modules for: Modules for Interfacing with X Windows.
379 * internal character encoding: Internal Character Encoding.
380 * internal Mule encodings: Internal Mule Encodings.
381 * internal string encoding: Internal String Encoding.
382 * internationalization, modules for: Modules for Internationalization.
383 * interning: The XEmacs Object System (Abstractly Speaking).
384 * interpreter and object system, modules for other aspects of the Lisp: Modules for Other Aspects of the Lisp Interpreter and Object System.
385 * ITS (Incompatible Timesharing System): A History of Emacs.
386 * Japanese EUC (Extended Unix Code): Japanese EUC (Extended Unix Code).
387 * Java: The Lisp Language.
388 * Java vs. Lisp: The Lisp Language.
390 * Jones, Kyle: XEmacs.
391 * Kaplan, Simon: XEmacs.
392 * Levy, Steven: A History of Emacs.
393 * library, Lucid Widget: Lucid Widget Library.
394 * line start cache: Line Start Cache.
395 * Lisp interpreter and object system, modules for other aspects of the: Modules for Other Aspects of the Lisp Interpreter and Object System.
396 * Lisp language, the: The Lisp Language.
397 * Lisp modules, basic: Basic Lisp Modules.
398 * Lisp object types, creating: Techniques for XEmacs Developers.
399 * Lisp objects are represented in C, how: How Lisp Objects Are Represented in C.
400 * Lisp objects, allocation of in XEmacs: Allocation of Objects in XEmacs Lisp.
401 * Lisp objects, modules for other display-related: Modules for other Display-Related Lisp Objects.
402 * Lisp objects, modules for the basic displayable: Modules for the Basic Displayable Lisp Objects.
403 * Lisp primitives, writing: Writing Lisp Primitives.
404 * Lisp reader and compiler, the: The Lisp Reader and Compiler.
405 * Lisp vs. C: The Lisp Language.
406 * Lisp vs. Java: The Lisp Language.
407 * low-level allocation: Low-level allocation.
408 * low-level modules: Low-Level Modules.
409 * lrecords: lrecords.
410 * lstream: Modules for Interfacing with the File System.
411 * lstream functions: Lstream Functions.
412 * lstream methods: Lstream Methods.
413 * lstream types: Lstream Types.
414 * lstream, creating an: Creating an Lstream.
415 * Lstream_close: Lstream Functions.
416 * Lstream_fgetc: Lstream Functions.
417 * Lstream_flush: Lstream Functions.
418 * Lstream_fputc: Lstream Functions.
419 * Lstream_fungetc: Lstream Functions.
420 * Lstream_getc: Lstream Functions.
421 * Lstream_new: Lstream Functions.
422 * Lstream_putc: Lstream Functions.
423 * Lstream_read: Lstream Functions.
424 * Lstream_reopen: Lstream Functions.
425 * Lstream_rewind: Lstream Functions.
426 * Lstream_set_buffering: Lstream Functions.
427 * Lstream_ungetc: Lstream Functions.
428 * Lstream_unread: Lstream Functions.
429 * Lstream_write: Lstream Functions.
430 * lstreams: Lstreams.
431 * Lucid Emacs: Lucid Emacs.
432 * Lucid Inc.: Lucid Emacs.
433 * Lucid Widget Library: Lucid Widget Library.
434 * macro hygiene: Techniques for XEmacs Developers.
435 * main loop: Main Loop.
436 * mark and sweep: Garbage Collection.
437 * mark method <1>: lrecords.
438 * mark method: Modules for Other Aspects of the Lisp Interpreter and Object System.
439 * mark_object: mark_object.
440 * marker <1>: Lstream Methods.
442 * markers and extents: Markers and Extents.
443 * mathematics of extent ordering: Mathematics of Extent Ordering.
444 * MAX_EMCHAR_LEN: Working With Character and Byte Positions.
445 * menubars: Menubars.
447 * merging attempts: XEmacs.
448 * MIT: A History of Emacs.
449 * Mlynarik, Richard: GNU Emacs 19.
450 * modules for interfacing with the file system: Modules for Interfacing with the File System.
451 * modules for interfacing with the operating system: Modules for Interfacing with the Operating System.
452 * modules for interfacing with X Windows: Modules for Interfacing with X Windows.
453 * modules for internationalization: Modules for Internationalization.
454 * modules for other aspects of the Lisp interpreter and object system: Modules for Other Aspects of the Lisp Interpreter and Object System.
455 * modules for other display-related Lisp objects: Modules for other Display-Related Lisp Objects.
456 * modules for standard editing operations: Modules for Standard Editing Operations.
457 * modules for the basic displayable Lisp objects: Modules for the Basic Displayable Lisp Objects.
458 * modules for the redisplay mechanism: Modules for the Redisplay Mechanism.
459 * modules, a summary of the various XEmacs: A Summary of the Various XEmacs Modules.
460 * modules, basic Lisp: Basic Lisp Modules.
461 * modules, editor-level control flow: Editor-Level Control Flow Modules.
462 * modules, low-level: Low-Level Modules.
463 * MS-Windows environment, widget-glyphs in the: Glyphs.
464 * Mule character sets and encodings: MULE Character Sets and Encodings.
465 * Mule encodings: Encodings.
466 * Mule encodings, internal: Internal Mule Encodings.
467 * MULE merged XEmacs appears: XEmacs.
468 * Mule, coding for: Coding for Mule.
469 * Mule-aware code, an example of: An Example of Mule-Aware Code.
470 * Mule-aware code, general guidelines for writing: General Guidelines for Writing Mule-Aware Code.
471 * NAS: Modules for Interfacing with the Operating System.
472 * native sound: Modules for Interfacing with the Operating System.
473 * network connections: Modules for Interfacing with the Operating System.
474 * network sound: Modules for Interfacing with the Operating System.
475 * Niksic, Hrvoje: XEmacs.
476 * obarrays: Obarrays.
477 * object system (abstractly speaking), the XEmacs: The XEmacs Object System (Abstractly Speaking).
478 * object system, modules for other aspects of the Lisp interpreter and: Modules for Other Aspects of the Lisp Interpreter and Object System.
479 * object types, creating Lisp: Techniques for XEmacs Developers.
480 * object, the buffer: The Buffer Object.
481 * object, the window: The Window Object.
482 * objects are represented in C, how Lisp: How Lisp Objects Are Represented in C.
483 * objects in XEmacs Lisp, allocation of: Allocation of Objects in XEmacs Lisp.
484 * objects, modules for the basic displayable Lisp: Modules for the Basic Displayable Lisp Objects.
485 * operating system, modules for interfacing with the: Modules for Interfacing with the Operating System.
486 * outside, XEmacs from the: XEmacs From the Outside.
487 * pane: Modules for the Basic Displayable Lisp Objects.
488 * permanent objects: The XEmacs Object System (Abstractly Speaking).
489 * pi, calculating: XEmacs From the Outside.
491 * pointers dumping: Pointers dumping.
492 * positions, working with character and byte: Working With Character and Byte Positions.
493 * primitives, writing Lisp: Writing Lisp Primitives.
494 * progress bars: Progress Bars.
495 * protection, garbage collection: GCPROing.
496 * pseudo_closer: Lstream Methods.
497 * Purify: Techniques for XEmacs Developers.
498 * Quantify: Techniques for XEmacs Developers.
499 * radio buttons, checkboxes and: Checkboxes and Radio Buttons.
500 * read syntax: The XEmacs Object System (Abstractly Speaking).
501 * read-eval-print: XEmacs From the Outside.
502 * reader: Lstream Methods.
503 * reader and compiler, the Lisp: The Lisp Reader and Compiler.
504 * redisplay mechanism, modules for the: Modules for the Redisplay Mechanism.
505 * redisplay mechanism, the: The Redisplay Mechanism.
506 * redisplay piece by piece: Redisplay Piece by Piece.
507 * redisplay sections, critical: Critical Redisplay Sections.
508 * reloading phase: Reloading phase.
509 * relocating allocator: Low-Level Modules.
510 * rename to XEmacs: XEmacs.
511 * represented in C, how Lisp objects are: How Lisp Objects Are Represented in C.
512 * rewinder: Lstream Methods.
513 * RMS: A History of Emacs.
514 * scanner: Modules for Other Aspects of the Lisp Interpreter and Object System.
515 * scoping, dynamic: The Lisp Language.
516 * scrollbars: Scrollbars.
517 * seekable_p: Lstream Methods.
518 * selections: Modules for Interfacing with X Windows.
519 * set_charptr_emchar: Working With Character and Byte Positions.
520 * Sexton, Harlan: Lucid Emacs.
521 * sound, native: Modules for Interfacing with the Operating System.
522 * sound, network: Modules for Interfacing with the Operating System.
523 * SPARCWorks: XEmacs.
524 * specbinding stack; unwind-protects, dynamic binding; the: Dynamic Binding; The specbinding Stack; Unwind-Protects.
525 * special forms, simple: Simple Special Forms.
526 * specifiers: Specifiers.
527 * stack frames; bindings, evaluation;: Evaluation; Stack Frames; Bindings.
528 * Stallman, Richard: A History of Emacs.
530 * string encoding, internal: Internal String Encoding.
531 * subprocesses: Subprocesses.
532 * subprocesses, asynchronous: Modules for Interfacing with the Operating System.
533 * subprocesses, synchronous: Modules for Interfacing with the Operating System.
534 * Sun Microsystems: XEmacs.
535 * sweep_bit_vectors_1: sweep_bit_vectors_1.
536 * sweep_lcrecords_1: sweep_lcrecords_1.
537 * sweep_strings: sweep_strings.
539 * symbol values: Symbol Values.
540 * symbols and variables: Symbols and Variables.
541 * symbols, introduction to: Introduction to Symbols.
542 * synchronous subprocesses: Modules for Interfacing with the Operating System.
543 * tab controls: Tab Controls.
544 * taxes, doing: XEmacs From the Outside.
545 * techniques for XEmacs developers: Techniques for XEmacs Developers.
546 * TECO: A History of Emacs.
547 * temporary objects: The XEmacs Object System (Abstractly Speaking).
548 * text in a buffer, the: The Text in a Buffer.
549 * textual representation, buffers and: Buffers and Textual Representation.
550 * Thompson, Chuck: XEmacs.
551 * throw, catch and: Catch and Throw.
552 * types, dynamic: The Lisp Language.
553 * types, lstream: Lstream Types.
554 * types, proper use of unsigned: Proper Use of Unsigned Types.
555 * University of Illinois: XEmacs.
556 * unsigned types, proper use of: Proper Use of Unsigned Types.
557 * unwind-protects, dynamic binding; the specbinding stack;: Dynamic Binding; The specbinding Stack; Unwind-Protects.
558 * values, symbol: Symbol Values.
559 * variables, adding global Lisp: Adding Global Lisp Variables.
560 * variables, symbols and: Symbols and Variables.
562 * vector, bit: Bit Vector.
563 * version 18, through: Through Version 18.
564 * version 19, GNU Emacs: GNU Emacs 19.
565 * version 20, GNU Emacs: GNU Emacs 20.
566 * widget interface, generic: Generic Widget Interface.
567 * widget library, Lucid: Lucid Widget Library.
568 * widget-glyphs: Glyphs.
569 * widget-glyphs in the MS-Windows environment: Glyphs.
570 * widget-glyphs in the X environment: Glyphs.
572 * window (in Emacs): Modules for the Basic Displayable Lisp Objects.
573 * window hierarchy: Window Hierarchy.
574 * window object, the: The Window Object.
575 * window point internals: The Window Object.
576 * windows, consoles; devices; frames;: Consoles; Devices; Frames; Windows.
577 * windows, introduction to consoles; devices; frames;: Introduction to Consoles; Devices; Frames; Windows.
579 * writer: Lstream Methods.
580 * writing good comments: Writing Good Comments.
581 * writing Lisp primitives: Writing Lisp Primitives.
582 * writing Mule-aware code, general guidelines for: General Guidelines for Writing Mule-Aware Code.
583 * writing new C code, rules when: Rules When Writing New C Code.
584 * X environment, widget-glyphs in the: Glyphs.
585 * X Window System, interface to the: Interface to the X Window System.
586 * X Windows, modules for interfacing with: Modules for Interfacing with X Windows.
588 * XEmacs from the inside: XEmacs From the Inside.
589 * XEmacs from the outside: XEmacs From the Outside.
590 * XEmacs from the perspective of building: XEmacs From the Perspective of Building.
591 * XEmacs goes it alone: XEmacs.
592 * XEmacs object system (abstractly speaking), the: The XEmacs Object System (Abstractly Speaking).
593 * Zawinski, Jamie: Lucid Emacs.
594 * zero-length extents: Zero-Length Extents.
projects / chise / xemacs-chise.git- / blob