Mercurial > hg > xemacs-beta
annotate src/gccache-gtk.c @ 4976:16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-02-04 Ben Wing <ben@xemacs.org>
* alloc.c (release_breathing_space):
* alloc.c (resize_string):
* alloc.c (sweep_lcrecords_1):
* alloc.c (SWEEP_FIXED_TYPE_BLOCK_1):
* alloc.c (ADDITIONAL_FREE_compiled_function):
* alloc.c (compact_string_chars):
* alloc.c (ADDITIONAL_FREE_string):
* alloc.c (sweep_strings):
* alloca.c (xemacs_c_alloca):
* alsaplay.c (alsa_play_sound_file):
* buffer.c (init_initial_directory):
* buffer.h:
* buffer.h (BUFFER_FREE):
* console-stream.c (stream_delete_console):
* console-tty.c (free_tty_console_struct):
* data.c (Fnumber_to_string):
* device-gtk.c (gtk_init_device):
* device-gtk.c (free_gtk_device_struct):
* device-gtk.c (gtk_delete_device):
* device-msw.c (mswindows_delete_device):
* device-msw.c (msprinter_delete_device):
* device-tty.c (free_tty_device_struct):
* device-tty.c (tty_delete_device):
* device-x.c (x_init_device):
* device-x.c (free_x_device_struct):
* device-x.c (x_delete_device):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-x.c (dbox_descriptor_to_widget_value):
* dired-msw.c (Fmswindows_insert_directory):
* dired.c (free_user_cache):
* dired.c (user_name_completion_unwind):
* doc.c (unparesseuxify_doc_string):
* doc.c (Fsubstitute_command_keys):
* doprnt.c (emacs_doprnt_1):
* dumper.c (pdump_load_finish):
* dumper.c (pdump_file_free):
* dumper.c (pdump_file_unmap):
* dynarr.c:
* dynarr.c (Dynarr_free):
* editfns.c (uncache_home_directory):
* editfns.c (Fset_time_zone_rule):
* elhash.c:
* elhash.c (pdump_reorganize_hash_table):
* elhash.c (maphash_unwind):
* emacs.c (make_arg_list_1):
* emacs.c (free_argc_argv):
* emacs.c (sort_args):
* emacs.c (Frunning_temacs_p):
* emodules.c (attempt_module_delete):
* eval.c (free_pointer):
* event-Xt.c (unselect_filedesc):
* event-Xt.c (emacs_Xt_select_process):
* event-gtk.c (unselect_filedesc):
* event-gtk.c (dragndrop_data_received):
* event-msw.c (winsock_closer):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* event-stream.c (finalize_command_builder):
* event-stream.c (free_command_builder):
* extents.c (free_gap_array):
* extents.c (free_extent_list):
* extents.c (free_soe):
* extents.c (extent_fragment_delete):
* extents.c (extent_priority_sort_function):
* file-coding.c (make_coding_system_1):
* file-coding.c (coding_finalizer):
* file-coding.c (set_coding_stream_coding_system):
* file-coding.c (chain_finalize_coding_stream_1):
* file-coding.c (chain_finalize):
* file-coding.c (free_detection_state):
* file-coding.c (coding_category_symbol_to_id):
* fileio.c:
* fileio.c (Ffile_name_directory):
* fileio.c (if):
* fileio.c (Ffile_symlink_p):
* filelock.c (FREE_LOCK_INFO):
* filelock.c (current_lock_owner):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* frame-gtk.c (gtk_delete_frame):
* frame-msw.c (mswindows_delete_frame):
* frame-msw.c (msprinter_delete_frame):
* frame-x.c (x_cde_destroy_callback):
* frame-x.c (Fcde_start_drag_internal):
* frame-x.c (x_cde_transfer_callback):
* frame-x.c (x_delete_frame):
* frame.c (update_frame_title):
* frame.c (Fset_frame_pointer):
* gc.c (register_for_finalization):
* gccache-gtk.c (free_gc_cache):
* gccache-gtk.c (gc_cache_lookup):
* gccache-x.c (free_gc_cache):
* gccache-x.c (gc_cache_lookup):
* glyphs-eimage.c:
* glyphs-eimage.c (jpeg_instantiate_unwind):
* glyphs-eimage.c (gif_instantiate_unwind):
* glyphs-eimage.c (png_instantiate_unwind):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate_unwind):
* glyphs-gtk.c (convert_EImage_to_GDKImage):
* glyphs-gtk.c (gtk_finalize_image_instance):
* glyphs-gtk.c (gtk_init_image_instance_from_eimage):
* glyphs-gtk.c (gtk_xpm_instantiate):
* glyphs-msw.c (convert_EImage_to_DIBitmap):
* glyphs-msw.c (mswindows_init_image_instance_from_eimage):
* glyphs-msw.c (mswindows_initialize_image_instance_mask):
* glyphs-msw.c (xpm_to_eimage):
* glyphs-msw.c (mswindows_xpm_instantiate):
* glyphs-msw.c (xbm_create_bitmap_from_data):
* glyphs-msw.c (mswindows_finalize_image_instance):
* glyphs-x.c (convert_EImage_to_XImage):
* glyphs-x.c (x_finalize_image_instance):
* glyphs-x.c (x_init_image_instance_from_eimage):
* glyphs-x.c (x_xpm_instantiate):
* gui-x.c (free_popup_widget_value_tree):
* hash.c (free_hash_table):
* hash.c (grow_hash_table):
* hash.c (pregrow_hash_table_if_necessary):
* imgproc.c (build_EImage_quantable):
* insdel.c (uninit_buffer_text):
* intl-win32.c (convert_multibyte_to_internal_malloc):
* intl.c:
* intl.c (Fset_current_locale):
* keymap.c:
* keymap.c (where_is_recursive_mapper):
* keymap.c (where_is_internal):
* lisp.h:
* lisp.h (xfree):
* lstream.c (Lstream_close):
* lstream.c (resizing_buffer_closer):
* mule-coding.c:
* mule-coding.c (iso2022_finalize_detection_state):
* nt.c:
* nt.c (mswindows_get_long_filename):
* nt.c (nt_get_resource):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_opendir):
* nt.c (mswindows_closedir):
* nt.c (mswindows_readdir):
* nt.c (mswindows_stat):
* nt.c (mswindows_getdcwd):
* nt.c (Fmswindows_long_file_name):
* ntplay.c (nt_play_sound_file):
* ntplay.c (play_sound_data_1):
* number-gmp.c (gmp_free):
* number-gmp.c (init_number_gmp):
* number-mp.c (bignum_to_string):
* number-mp.c (BIGNUM_TO_TYPE):
* number.c (bignum_print):
* number.c (bignum_convfree):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-gtk.c (gtk_finalize_color_instance):
* objects-gtk.c (gtk_finalize_font_instance):
* objects-msw.c (mswindows_finalize_color_instance):
* objects-msw.c (mswindows_finalize_font_instance):
* objects-tty.c (tty_finalize_color_instance):
* objects-tty.c (tty_finalize_font_instance):
* objects-tty.c (tty_font_list):
* objects-x.c (x_finalize_color_instance):
* objects-x.c (x_finalize_font_instance):
* process.c:
* process.c (finalize_process):
* realpath.c:
* redisplay.c (add_propagation_runes):
* regex.c:
* regex.c (xfree):
* regex.c (REGEX_FREE_STACK):
* regex.c (FREE_STACK_RETURN):
* regex.c (regex_compile):
* regex.c (regexec):
* regex.c (regfree):
* scrollbar-gtk.c (gtk_free_scrollbar_instance):
* scrollbar-gtk.c (gtk_release_scrollbar_instance):
* scrollbar-msw.c (mswindows_free_scrollbar_instance):
* scrollbar-msw.c (unshow_that_mofo):
* scrollbar-x.c (x_free_scrollbar_instance):
* scrollbar-x.c (x_release_scrollbar_instance):
* select-gtk.c (emacs_gtk_selection_handle):
* select-msw.c (mswindows_own_selection):
* select-x.c:
* select-x.c (x_handle_selection_request):
* select-x.c (unexpect_property_change):
* select-x.c (x_handle_property_notify):
* select-x.c (receive_incremental_selection):
* select-x.c (x_get_window_property_as_lisp_data):
* select-x.c (Fx_get_cutbuffer_internal):
* specifier.c (finalize_specifier):
* syntax.c (uninit_buffer_syntax_cache):
* sysdep.c (qxe_allocating_getcwd):
* sysdep.c (qxe_lstat):
* sysdep.c (copy_in_passwd):
* sysdep.c (qxe_ctime):
* sysdep.c (closedir):
* sysdep.c (DIRSIZ):
* termcap.c (tgetent):
* termcap.c (tprint):
* tests.c (Ftest_data_format_conversion):
* text.c (new_dfc_convert_copy_data):
* text.h (eifree):
* text.h (eito_alloca):
* text.h (eito_external):
* toolbar-msw.c (mswindows_output_toolbar):
* ui-gtk.c (CONVERT_RETVAL):
* ui-gtk.c (__allocate_object_storage):
* unicode.c (free_from_unicode_table):
* unicode.c (free_to_unicode_table):
* unicode.c (free_charset_unicode_tables):
* win32.c (mswindows_read_link_1):
Rename: xfree(VAL, TYPE)->xfree(VAL)
Command used:
gr 'xfree *\((.*),.*\);' 'xfree (\1);' *.[ch]
Followed by grepping for 'xfree.*,' and fixing anything left.
Rationale: Having to specify the TYPE argument is annoying and
error-prone. It was originally put in to work around warnings
due to strict aliasing but years and years ago I rewrote it
in a way that doesn't use the TYPE argument at all and no one
has complained since then. (And anyway, XEmacs is far from
ever being in compliance with strict aliasing and would require
far-reaching changes to get that way.)
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Thu, 04 Feb 2010 07:28:14 -0600 |
| parents | b3ce27ca7647 |
| children | 6f2158fa75ed |
| 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 | |
|
4908
b3ce27ca7647
various fixes related to gtk, redisplay-xlike-inc.c
Ben Wing <ben@xemacs.org>
parents:
2515
diff
changeset
|
24 /* XEmacs uses a lot of different display attributes; for example, assume |
| 462 | 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 "lisp.h" | |
|
4908
b3ce27ca7647
various fixes related to gtk, redisplay-xlike-inc.c
Ben Wing <ben@xemacs.org>
parents:
2515
diff
changeset
|
57 #include "hash.h" |
|
b3ce27ca7647
various fixes related to gtk, redisplay-xlike-inc.c
Ben Wing <ben@xemacs.org>
parents:
2515
diff
changeset
|
58 |
| 462 | 59 #include "gccache-gtk.h" |
| 60 | |
| 61 #define GC_CACHE_SIZE 100 | |
| 62 | |
| 63 #define GCCACHE_HASH | |
| 64 | |
| 65 struct gcv_and_mask { | |
| 66 GdkGCValues gcv; | |
| 2054 | 67 unsigned long mask; /* contains a GdkGCValuesMask bitmask. */ |
| 462 | 68 }; |
| 69 | |
| 70 struct gc_cache_cell { | |
| 71 GdkGC *gc; | |
| 72 struct gcv_and_mask gcvm; | |
| 73 struct gc_cache_cell *prev, *next; | |
| 74 }; | |
| 75 | |
| 76 struct gc_cache { | |
| 77 GdkWindow *window; /* used only as arg to XCreateGC */ | |
| 78 int size; | |
| 79 struct gc_cache_cell *head; | |
| 80 struct gc_cache_cell *tail; | |
| 81 #ifdef GCCACHE_HASH | |
| 82 struct hash_table * table; | |
| 83 #endif | |
| 84 | |
| 85 int create_count; | |
| 86 int delete_count; | |
| 87 }; | |
| 88 | |
| 89 #ifdef GCCACHE_HASH | |
| 2515 | 90 static Hashcode |
| 462 | 91 gc_cache_hash (const void *arg) |
| 92 { | |
| 93 const struct gcv_and_mask *gcvm = (const struct gcv_and_mask *) arg; | |
| 94 unsigned long *longs = (unsigned long *) &gcvm->gcv; | |
| 2515 | 95 Hashcode hash = gcvm->mask; |
| 778 | 96 unsigned int i; |
| 462 | 97 /* This could look at the mask and only use the used slots in the |
| 98 hash code. That would win in that we wouldn't have to initialize | |
| 99 every slot of the gcv when calling gc_cache_lookup. But we need | |
| 100 the hash function to be as fast as possible; some timings should | |
| 101 be done. */ | |
| 102 for (i = 0; i < (sizeof (GdkGCValues) / sizeof (unsigned long)); i++) | |
| 2515 | 103 hash = (hash << 1) ^ *longs++; |
| 462 | 104 return hash; |
| 105 } | |
| 106 | |
| 107 #endif /* GCCACHE_HASH */ | |
| 108 | |
| 109 static int | |
| 110 gc_cache_eql (const void *arg1, const void *arg2) | |
| 111 { | |
| 112 /* See comment in gc_cache_hash */ | |
| 113 const struct gcv_and_mask *gcvm1 = (const struct gcv_and_mask *) arg1; | |
| 114 const struct gcv_and_mask *gcvm2 = (const struct gcv_and_mask *) arg2; | |
| 115 | |
| 116 return !memcmp(&gcvm1->gcv, &gcvm2->gcv, sizeof(gcvm1->gcv)) | |
| 117 && gcvm1->mask == gcvm2->mask; | |
| 118 } | |
| 119 | |
| 120 struct gc_cache * | |
| 121 make_gc_cache (GtkWidget *widget) | |
| 122 { | |
| 123 struct gc_cache *cache = xnew (struct gc_cache); | |
| 124 cache->window = widget->window; | |
| 125 cache->size = 0; | |
| 126 cache->head = cache->tail = 0; | |
| 127 cache->create_count = cache->delete_count = 0; | |
| 128 #ifdef GCCACHE_HASH | |
| 129 cache->table = | |
| 130 make_general_hash_table (GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql); | |
| 131 #endif | |
| 132 return cache; | |
| 133 } | |
| 134 | |
| 135 void | |
| 136 free_gc_cache (struct gc_cache *cache) | |
| 137 { | |
| 138 struct gc_cache_cell *rest, *next; | |
| 139 rest = cache->head; | |
| 140 while (rest) | |
| 141 { | |
| 142 gdk_gc_destroy(rest->gc); | |
| 143 next = rest->next; | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4908
diff
changeset
|
144 xfree (rest); |
| 462 | 145 rest = next; |
| 146 } | |
| 147 #ifdef GCCACHE_HASH | |
| 148 free_hash_table (cache->table); | |
| 149 #endif | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4908
diff
changeset
|
150 xfree (cache); |
| 462 | 151 } |
| 152 | |
| 153 GdkGC * | |
| 2054 | 154 gc_cache_lookup (struct gc_cache *cache, GdkGCValues *gcv, unsigned long mask) |
| 462 | 155 { |
| 156 struct gc_cache_cell *cell, *next, *prev; | |
| 157 struct gcv_and_mask gcvm; | |
| 158 | |
| 2500 | 159 if ((!!cache->head) != (!!cache->tail)) ABORT (); |
| 160 if (cache->head && (cache->head->prev || cache->tail->next)) ABORT (); | |
| 462 | 161 |
| 162 /* Gdk does not have the equivalent of 'None' for the clip_mask, so | |
| 163 we need to check it carefully, or gdk_gc_new_with_values will | |
| 164 coredump */ | |
| 165 if ((mask & GDK_GC_CLIP_MASK) && !gcv->clip_mask) | |
| 166 { | |
| 167 mask &= ~GDK_GC_CLIP_MASK; | |
| 168 } | |
| 169 | |
| 170 gcvm.mask = mask; | |
| 171 gcvm.gcv = *gcv; /* this copies... */ | |
| 172 | |
| 173 #ifdef GCCACHE_HASH | |
| 174 | |
| 175 if (gethash (&gcvm, cache->table, (const void **) &cell)) | |
| 176 | |
| 177 #else /* !GCCACHE_HASH */ | |
| 178 | |
| 179 cell = cache->tail; /* start at the end (most recently used) */ | |
| 180 while (cell) | |
| 181 { | |
| 182 if (gc_cache_eql (&gcvm, &cell->gcvm)) | |
| 183 break; | |
| 184 else | |
| 185 cell = cell->prev; | |
| 186 } | |
| 187 | |
| 188 /* #### This whole file needs some serious overhauling. */ | |
| 189 if (!(mask | GDK_GC_TILE) && cell->gcvm.gcv.tile) | |
| 190 cell = 0; | |
| 191 else if (!(mask | GDK_GC_STIPPLE) && cell->gcvm.gcv.stipple) | |
| 192 cell = 0; | |
| 193 | |
| 194 if (cell) | |
| 195 | |
| 196 #endif /* !GCCACHE_HASH */ | |
| 197 | |
| 198 { | |
| 199 /* Found a cell. Move this cell to the end of the list, so that it | |
| 200 will be less likely to be collected than a cell that was accessed | |
| 201 less recently. | |
| 202 */ | |
| 203 if (cell == cache->tail) | |
| 204 return cell->gc; | |
| 205 | |
| 206 next = cell->next; | |
| 207 prev = cell->prev; | |
| 208 if (prev) prev->next = next; | |
| 209 if (next) next->prev = prev; | |
| 210 if (cache->head == cell) cache->head = next; | |
| 211 cell->next = 0; | |
| 212 cell->prev = cache->tail; | |
| 213 cache->tail->next = cell; | |
| 214 cache->tail = cell; | |
| 2500 | 215 if (cache->head == cell) ABORT (); |
| 216 if (cell->next) ABORT (); | |
| 217 if (cache->head->prev) ABORT (); | |
| 218 if (cache->tail->next) ABORT (); | |
| 462 | 219 return cell->gc; |
| 220 } | |
| 221 | |
| 222 /* else, cache miss. */ | |
| 223 | |
| 224 if (cache->size == GC_CACHE_SIZE) | |
| 225 /* Reuse the first cell on the list (least-recently-used). | |
| 226 Remove it from the list, and unhash it from the table. | |
| 227 */ | |
| 228 { | |
| 229 cell = cache->head; | |
| 230 cache->head = cell->next; | |
| 231 cache->head->prev = 0; | |
| 232 if (cache->tail == cell) cache->tail = 0; /* only one */ | |
| 233 gdk_gc_destroy (cell->gc); | |
| 234 cache->delete_count++; | |
| 235 #ifdef GCCACHE_HASH | |
| 236 remhash (&cell->gcvm, cache->table); | |
| 237 #endif | |
| 238 } | |
| 239 else if (cache->size > GC_CACHE_SIZE) | |
| 2500 | 240 ABORT (); |
| 462 | 241 else |
| 242 { | |
| 243 /* Allocate a new cell (don't put it in the list or table yet). */ | |
| 244 cell = xnew (struct gc_cache_cell); | |
| 245 cache->size++; | |
| 246 } | |
| 247 | |
| 248 /* Now we've got a cell (new or reused). Fill it in. */ | |
| 249 memcpy (&cell->gcvm.gcv, gcv, sizeof (GdkGCValues)); | |
| 250 cell->gcvm.mask = mask; | |
| 251 | |
| 252 /* Put the cell on the end of the list. */ | |
| 253 cell->next = 0; | |
| 254 cell->prev = cache->tail; | |
| 255 if (cache->tail) cache->tail->next = cell; | |
| 256 cache->tail = cell; | |
| 257 if (! cache->head) cache->head = cell; | |
| 258 | |
| 259 cache->create_count++; | |
| 260 #ifdef GCCACHE_HASH | |
| 261 /* Hash it in the table */ | |
| 262 puthash (&cell->gcvm, cell, cache->table); | |
| 263 #endif | |
| 264 | |
| 265 /* Now make and return the GC. */ | |
| 2054 | 266 cell->gc = gdk_gc_new_with_values (cache->window, gcv, (GdkGCValuesMask) mask); |
| 462 | 267 |
| 268 /* debug */ | |
| 269 assert (cell->gc == gc_cache_lookup (cache, gcv, mask)); | |
| 270 | |
| 271 return cell->gc; | |
| 272 } |