Mercurial > hg > xemacs-beta
annotate src/gccache-gtk.c @ 872:79c6ff3eef26
[xemacs-hg @ 2002-06-20 21:18:01 by ben]
font changes etc.; some 21.4 changes
mule/mule-msw-init-late.el: Specify charset->windows-registry conversion.
mule/mule-x-init.el: Delete extra mule font additions here. Put them in faces.c.
cl-macs.el: Document better.
font-lock.el: Move Lisp function regexp to lisp-mode.el.
lisp-mode.el: Various indentation fixes:
Handle flet functions better.
Handle argument lists in defuns and flets.
Handle quoted lists, e.g. property lists -- don't indent like
function calls. Distinguish between lambdas and other lists.
lisp-mode.el: Handle this form.
faces.el, font-menu.el, font.el, gtk-faces.el, msw-faces.el, msw-font-menu.el, x-faces.el, x-init.el: Major overhaul of face-handling code:
-- Fix lots of bogus code in msw-faces.el, msw-font-menu.el,
font-menu.el that was "truenaming" font specs -- i.e. in the
process of frobbing a particular field in a general user-specified
font spec with wildcarded fields, sticking in particular values
for all the remaining wildcarded fields. This bug was rampant
everywhere except in x-faces.el (the oldest and only correctly
written code). This also means that we need to work with font
names at all times and not font instances, because a font instance
is essentially a truenamed font.
-- Total rewrite of extremely junky code in msw-faces.el. Work
with names as well as font instances, and return names; stop
truenaming when canonicalizing and frobbing; fix handling of the
combined style field, i.e. weight/slant (also fixed in font.el).
-- Totally rewrite the frobbing functions in faces.el. This time,
we frob all the instantiators rather than just computing a single
instance value and working backwards. That way, e.g., `bold' will
work for all charsets that have bold available, rather than only
for whatever charset was part of the computed font instance
(another example of the truename virus). Also fix up code to look
at the fallbacks (all of them) when no global value present, so we
don't need to put something in the global value. Intelligently
handle a request to frob a buffer locale, rather than signalling
an error. When frobbing instantiators, try hard to figure out
what device type is associated with them, and frob each according
to its own proper device type. Correctly handle inheritance
vectors given as instantiators. Preserve existing tags when
putting back frobbed instantiators. Extract out general
specifier-frobbing code into specifier.el. Document everything
cleanly. Do lots of other things better, etc.
-- Don't duplicatively set a global specification for the default
font -- it's already in the fallback and we no longer need a
default global specification present. Delete various code in
x-faces.el and msw-faces.el that duplicated the lists of fonts in
faces.c.
-- init-global-faces was not being called at all under MS Windows!
Major bogosity. That caused device-specific values to get stuck
into all the fonts, making it very hard to change them -- setting
global specs caused nothing to happen.
-- Correct weight names in font.el.
-- Lots more font fixups in objects*.c.
Printer.el: Warning fix.
specifier.el: Add more args to map-specifier.
Add various "heuristic" specifier functions to aid in creation of
specifier-munging code such as in faces.el.
subr.el: New functions.
lwlib.c: Fix warning.
config.inc.samp: Clean up, add args to control fastcall (not yet supported! the
changes needed are in another ws of mine), profile support, vc6
support, union-type.
xemacs.dsp, xemacs.mak: Semi-major overhaul.
Fix bug where dump-id was always getting recomputed, forcing a
redump even when nothing changed.
Add support for fastcall. Support edit-and-continue (on by
default) with vc6. Use incremental linking when doing a debug
compilation. Add support for profiling.
Consolidate the various debug flags.
Partial support for "batch-compiling" -- compiling many files on a
single invocation of the compiler. Doesn't seem to help that much
for me, so it's not finished or enabled by default.
Remove HAVE_MSW_C_DIRED, we always do.
Correct some sloppy use of directories.
s/cygwin32.h: Allow pdump to work under Cygwin (mmap is broken, so need to undefine
HAVE_MMAP).
s/win32-common.h, s/windowsnt.h: Support for fastcall. Add WIN32_ANY for identifying all Win32
variants (Cygwin, native, MinGW). Both of these are properly used
in another ws.
alloc.c, balloon-x.c, buffer.c, bytecode.c, callint.c, cm.c, cmdloop.c, cmds.c, console-gtk.c, console-gtk.h, console-msw.c, console-msw.h, console-stream.c, console-stream.h, console-tty.c, console-tty.h, console-x.c, console-x.h, console.c, console.h, device-gtk.c, device-msw.c, device-tty.c, device-x.c, device.c, device.h, devslots.h, dialog-gtk.c, dialog-msw.c, dialog-x.c, dialog.c, dired-msw.c, editfns.c, emacs.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-tty.c, event-unixoid.c, events.c, extents.c, extents.h, faces.c, fileio.c, fns.c, frame-gtk.c, frame-msw.c, frame-tty.c, frame-x.c, frame.c, frame.h, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-widget.c, glyphs-x.c, glyphs.c, glyphs.h, gui-gtk.c, gui-msw.c, gui-x.c, gui.c, gutter.c, input-method-xlib.c, intl-encap-win32.c, intl-win32.c, keymap.c, lisp.h, macros.c, menubar-gtk.c, menubar-msw.c, menubar-x.c, menubar.c, menubar.h, minibuf.c, mule-charset.c, nt.c, objects-gtk.c, objects-gtk.h, objects-msw.c, objects-msw.h, objects-tty.c, objects-tty.h, objects-x.c, objects-x.h, objects.c, objects.h, postgresql.c, print.c, process.h, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-tty.c, redisplay-x.c, redisplay.c, redisplay.h, scrollbar-gtk.c, scrollbar-msw.c, scrollbar-x.c, scrollbar.c, select-gtk.c, select-msw.c, select-x.c, select.c, signal.c, sound.c, specifier.c, symbols.c, syntax.c, sysdep.c, syssignal.h, syswindows.h, toolbar-common.c, toolbar-gtk.c, toolbar-msw.c, toolbar-x.c, toolbar.c, unicode.c, window.c, window.h: The following are the major changes made:
(1) Separation of various header files into an external and an
internal version, similar to the existing separation of process.h
and procimpl.h. Eventually this should be done for all Lisp
objects. The external version has the same name as currently; the
internal adds -impl. The external file has XFOO() macros for
objects, but the structure is opaque and defined only in the
internal file. It's now reasonable to move all prototypes in
lisp.h into the appropriate external file, and this should be
done. Currently, separation has been done on extents.h,
objects*.h, console.h, device.h, frame.h, and window.h.
For c/d/f/w, the most basic properties are available in the
external header file, with the macros resolving to functions. In
the internal header file, the macros are redefined to directly
access the structure. Also, the global MARK_FOO_CHANGED macros
have been made into functions so that they can be accessed without
needing to include lots of -impl headers -- they are used in
almost exclusively in non-time-critical functions, and take up
enough time that the function overhead will be negligible.
Similarly, the function overhead from making the basic properties
mentioned above into functions is negligible, and code that does
heavy accessing of c/d/f/w structures inevitably ends up needing
the internal header files, anyway.
(2) More face changes.
-- Major rewrite of objects-msw.c. Now handles wildcard specs
properly, rather than "truenaming" (or even worse, signalling an
error, which previously happened with some of the fallbacks if you
tried to use them in make-font-instance!).
-- Split charset matching of fonts into two stages -- one to find
a font specifically designed for a particular charset (by
examining its registry), the second to find a Unicode font that
can support the charset. This needs to proceed as two complete,
separate instantiations in order to work properly (otherwise many
of the fonts in the HELLO page look wrong). This should also make
it easy to support iso10646 (Unicode) fonts under X.
-- All default values for fonts are now completely specified in
the fallbacks. Stuff from mule-x-init.el has all been moved here,
merged with the existing specs, and totally rethought so you get
sensible results. (HELLO now looks much better!).
-- Generalize the "default X/GTK device" stuff into a
per-device-type "default device".
-- Add mswindows-{set-}charset-registry. In time,
charset<->code-page conversion functions will be removed.
-- Wrap protective code around calls to compute device specifier tags,
and do this computation before calling the face initialization code
because the latter may need these tags to be correctly updated.
(3) Other changes.
EmacsFrame.c, glyphs-msw.c, eval.c, gui-x.c, intl-encap-win32.c, search.c, signal.c, toolbar-msw.c, unicode.c: Warning fixes.
config.h.in: #undefs meant to be frobbed by configure *MUST* go inside of
#ifndef WIN32_NO_CONFIGURE, and everything else *MUST* go outside!
eval.c: Let detailed backtraces be detailed.
specifier.c: Don't override user's print-string-length/print-length settings.
glyphs.c: New function image-instance-instantiator.
config.h.in, sysdep.c: Changes for fastcall.
sysdep.c, nt.c: Fix up a previous botched patch that tried to add support for both
EEXIST and EACCES. IF THE BOTCHED PATCH WENT INTO 21.4, THIS FIXUP
NEEDS TO GO IN, TOO.
search.c: Fix *evil* crash due to incorrect synching of syntax-cache code
with 21.1. THIS SHOULD GO INTO 21.4.
author | ben |
---|---|
date | Thu, 20 Jun 2002 21:19:10 +0000 |
parents | 2923009caf47 |
children | a8d8f419b459 |
rev | line source |
---|---|
462 | 1 /* Efficient caching of Gtk GCs (graphics contexts). |
2 Copyright (C) 1993 Free Software Foundation, Inc. | |
3 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois. | |
4 | |
5 This file is part of XEmacs. | |
6 | |
7 XEmacs is free software; you can redistribute it and/or modify it | |
8 under the terms of the GNU General Public License as published by the | |
9 Free Software Foundation; either version 2, or (at your option) any | |
10 later version. | |
11 | |
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 for more details. | |
16 | |
17 You should have received a copy of the GNU General Public License | |
18 along with XEmacs; see the file COPYING. If not, write to | |
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
20 Boston, MA 02111-1307, USA. */ | |
21 | |
22 /* Synched up with: Not in FSF. */ | |
23 | |
24 /* Emacs uses a lot of different display attributes; for example, assume | |
25 that only four fonts are in use (normal, bold, italic, and bold-italic). | |
26 Then assume that one stipple or background is used for text selections, | |
27 and another is used for highlighting mousable regions. That makes 16 | |
28 GCs already. Add in the fact that another GC may be needed to display | |
29 the text cursor in any of those regions, and you've got 32. Add in | |
30 more fonts, and it keeps increasing exponentially. | |
31 | |
32 We used to keep these GCs in a cache of merged (fully qualified) faces. | |
33 However, a lot of other code in xterm.c used XChangeGC of existing GCs, | |
34 which is kind of slow and kind of random. Also, managing the face cache | |
35 was tricky because it was hard to know when a face was no longer visible | |
36 on the frame -- we had to mark all frames as garbaged whenever a face | |
37 was changed, which caused an unpleasant amount of flicker (since faces are | |
38 created/destroyed (= changed) whenever a frame is created/destroyed. | |
39 | |
40 So this code maintains a cache at the GC level instead of at the face | |
41 level. There is an upper limit on the size of the cache, after which we | |
42 will stop creating GCs and start reusing them (reusing the least-recently- | |
43 used ones first). So if faces get changed, their GCs will eventually be | |
44 recycled. Also more sharing of GCs is possible. | |
45 | |
46 This code uses hashtables. It could be that, if the cache size is small | |
47 enough, a linear search might be faster; but I doubt it, since we need | |
48 `equal' comparisons, not `eq', and I expect that the optimal cache size | |
49 will be ~100. | |
50 | |
51 Written by jwz, 14 jun 93 | |
52 Hacked by William Perry, apr 2000 | |
53 */ | |
54 | |
55 #include <config.h> | |
56 #include <gtk/gtk.h> | |
57 #include "lisp.h" | |
58 #include "gccache-gtk.h" | |
59 | |
60 #define GC_CACHE_SIZE 100 | |
61 | |
62 #define GCCACHE_HASH | |
63 | |
64 #ifdef GCCACHE_HASH | |
65 #include "lisp.h" | |
66 #include "hash.h" | |
67 #endif | |
68 | |
69 struct gcv_and_mask { | |
70 GdkGCValues gcv; | |
71 GdkGCValuesMask mask; | |
72 }; | |
73 | |
74 struct gc_cache_cell { | |
75 GdkGC *gc; | |
76 struct gcv_and_mask gcvm; | |
77 struct gc_cache_cell *prev, *next; | |
78 }; | |
79 | |
80 struct gc_cache { | |
81 GdkWindow *window; /* used only as arg to XCreateGC */ | |
82 int size; | |
83 struct gc_cache_cell *head; | |
84 struct gc_cache_cell *tail; | |
85 #ifdef GCCACHE_HASH | |
86 struct hash_table * table; | |
87 #endif | |
88 | |
89 int create_count; | |
90 int delete_count; | |
91 }; | |
92 | |
93 #ifdef GCCACHE_HASH | |
94 static unsigned long | |
95 gc_cache_hash (const void *arg) | |
96 { | |
97 const struct gcv_and_mask *gcvm = (const struct gcv_and_mask *) arg; | |
98 unsigned long *longs = (unsigned long *) &gcvm->gcv; | |
99 unsigned long hash = gcvm->mask; | |
778 | 100 unsigned int i; |
462 | 101 /* This could look at the mask and only use the used slots in the |
102 hash code. That would win in that we wouldn't have to initialize | |
103 every slot of the gcv when calling gc_cache_lookup. But we need | |
104 the hash function to be as fast as possible; some timings should | |
105 be done. */ | |
106 for (i = 0; i < (sizeof (GdkGCValues) / sizeof (unsigned long)); i++) | |
107 hash = (hash<<1) ^ *longs++; | |
108 return hash; | |
109 } | |
110 | |
111 #endif /* GCCACHE_HASH */ | |
112 | |
113 static int | |
114 gc_cache_eql (const void *arg1, const void *arg2) | |
115 { | |
116 /* See comment in gc_cache_hash */ | |
117 const struct gcv_and_mask *gcvm1 = (const struct gcv_and_mask *) arg1; | |
118 const struct gcv_and_mask *gcvm2 = (const struct gcv_and_mask *) arg2; | |
119 | |
120 return !memcmp(&gcvm1->gcv, &gcvm2->gcv, sizeof(gcvm1->gcv)) | |
121 && gcvm1->mask == gcvm2->mask; | |
122 } | |
123 | |
124 struct gc_cache * | |
125 make_gc_cache (GtkWidget *widget) | |
126 { | |
127 struct gc_cache *cache = xnew (struct gc_cache); | |
128 cache->window = widget->window; | |
129 cache->size = 0; | |
130 cache->head = cache->tail = 0; | |
131 cache->create_count = cache->delete_count = 0; | |
132 #ifdef GCCACHE_HASH | |
133 cache->table = | |
134 make_general_hash_table (GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql); | |
135 #endif | |
136 return cache; | |
137 } | |
138 | |
139 void | |
140 free_gc_cache (struct gc_cache *cache) | |
141 { | |
142 struct gc_cache_cell *rest, *next; | |
143 rest = cache->head; | |
144 while (rest) | |
145 { | |
146 gdk_gc_destroy(rest->gc); | |
147 next = rest->next; | |
148 xfree (rest); | |
149 rest = next; | |
150 } | |
151 #ifdef GCCACHE_HASH | |
152 free_hash_table (cache->table); | |
153 #endif | |
154 xfree (cache); | |
155 } | |
156 | |
157 GdkGC * | |
158 gc_cache_lookup (struct gc_cache *cache, GdkGCValues *gcv, GdkGCValuesMask mask) | |
159 { | |
160 struct gc_cache_cell *cell, *next, *prev; | |
161 struct gcv_and_mask gcvm; | |
162 | |
163 if ((!!cache->head) != (!!cache->tail)) abort (); | |
164 if (cache->head && (cache->head->prev || cache->tail->next)) abort (); | |
165 | |
166 /* Gdk does not have the equivalent of 'None' for the clip_mask, so | |
167 we need to check it carefully, or gdk_gc_new_with_values will | |
168 coredump */ | |
169 if ((mask & GDK_GC_CLIP_MASK) && !gcv->clip_mask) | |
170 { | |
171 mask &= ~GDK_GC_CLIP_MASK; | |
172 } | |
173 | |
174 gcvm.mask = mask; | |
175 gcvm.gcv = *gcv; /* this copies... */ | |
176 | |
177 #ifdef GCCACHE_HASH | |
178 | |
179 if (gethash (&gcvm, cache->table, (const void **) &cell)) | |
180 | |
181 #else /* !GCCACHE_HASH */ | |
182 | |
183 cell = cache->tail; /* start at the end (most recently used) */ | |
184 while (cell) | |
185 { | |
186 if (gc_cache_eql (&gcvm, &cell->gcvm)) | |
187 break; | |
188 else | |
189 cell = cell->prev; | |
190 } | |
191 | |
192 /* #### This whole file needs some serious overhauling. */ | |
193 if (!(mask | GDK_GC_TILE) && cell->gcvm.gcv.tile) | |
194 cell = 0; | |
195 else if (!(mask | GDK_GC_STIPPLE) && cell->gcvm.gcv.stipple) | |
196 cell = 0; | |
197 | |
198 if (cell) | |
199 | |
200 #endif /* !GCCACHE_HASH */ | |
201 | |
202 { | |
203 /* Found a cell. Move this cell to the end of the list, so that it | |
204 will be less likely to be collected than a cell that was accessed | |
205 less recently. | |
206 */ | |
207 if (cell == cache->tail) | |
208 return cell->gc; | |
209 | |
210 next = cell->next; | |
211 prev = cell->prev; | |
212 if (prev) prev->next = next; | |
213 if (next) next->prev = prev; | |
214 if (cache->head == cell) cache->head = next; | |
215 cell->next = 0; | |
216 cell->prev = cache->tail; | |
217 cache->tail->next = cell; | |
218 cache->tail = cell; | |
219 if (cache->head == cell) abort (); | |
220 if (cell->next) abort (); | |
221 if (cache->head->prev) abort (); | |
222 if (cache->tail->next) abort (); | |
223 return cell->gc; | |
224 } | |
225 | |
226 /* else, cache miss. */ | |
227 | |
228 if (cache->size == GC_CACHE_SIZE) | |
229 /* Reuse the first cell on the list (least-recently-used). | |
230 Remove it from the list, and unhash it from the table. | |
231 */ | |
232 { | |
233 cell = cache->head; | |
234 cache->head = cell->next; | |
235 cache->head->prev = 0; | |
236 if (cache->tail == cell) cache->tail = 0; /* only one */ | |
237 gdk_gc_destroy (cell->gc); | |
238 cache->delete_count++; | |
239 #ifdef GCCACHE_HASH | |
240 remhash (&cell->gcvm, cache->table); | |
241 #endif | |
242 } | |
243 else if (cache->size > GC_CACHE_SIZE) | |
244 abort (); | |
245 else | |
246 { | |
247 /* Allocate a new cell (don't put it in the list or table yet). */ | |
248 cell = xnew (struct gc_cache_cell); | |
249 cache->size++; | |
250 } | |
251 | |
252 /* Now we've got a cell (new or reused). Fill it in. */ | |
253 memcpy (&cell->gcvm.gcv, gcv, sizeof (GdkGCValues)); | |
254 cell->gcvm.mask = mask; | |
255 | |
256 /* Put the cell on the end of the list. */ | |
257 cell->next = 0; | |
258 cell->prev = cache->tail; | |
259 if (cache->tail) cache->tail->next = cell; | |
260 cache->tail = cell; | |
261 if (! cache->head) cache->head = cell; | |
262 | |
263 cache->create_count++; | |
264 #ifdef GCCACHE_HASH | |
265 /* Hash it in the table */ | |
266 puthash (&cell->gcvm, cell, cache->table); | |
267 #endif | |
268 | |
269 /* Now make and return the GC. */ | |
270 cell->gc = gdk_gc_new_with_values (cache->window, gcv, mask); | |
271 | |
272 /* debug */ | |
273 assert (cell->gc == gc_cache_lookup (cache, gcv, mask)); | |
274 | |
275 return cell->gc; | |
276 } |