Mercurial > hg > xemacs-beta
annotate lwlib/xlwgcs.c @ 5127:a9c41067dd88 ben-lisp-object
more cleanups, terminology clarification, lots of doc work
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Introduction to Allocation):
* internals/internals.texi (Integers and Characters):
* internals/internals.texi (Allocation from Frob Blocks):
* internals/internals.texi (lrecords):
* internals/internals.texi (Low-level allocation):
Rewrite section on allocation of Lisp objects to reflect the new
reality. Remove references to nonexistent XSETINT and XSETCHAR.
modules/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (allocate_pgconn):
* postgresql/postgresql.c (allocate_pgresult):
* postgresql/postgresql.h (struct Lisp_PGconn):
* postgresql/postgresql.h (struct Lisp_PGresult):
* ldap/eldap.c (allocate_ldap):
* ldap/eldap.h (struct Lisp_LDAP):
Same changes as in src/ dir. See large log there in ChangeLog,
but basically:
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
../hlo/src/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (very_old_free_lcrecord):
* alloc.c (copy_lisp_object):
* alloc.c (zero_sized_lisp_object):
* alloc.c (zero_nonsized_lisp_object):
* alloc.c (lisp_object_storage_size):
* alloc.c (free_normal_lisp_object):
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC):
* alloc.c (ALLOC_FROB_BLOCK_LISP_OBJECT):
* alloc.c (Fcons):
* alloc.c (noseeum_cons):
* alloc.c (make_float):
* alloc.c (make_bignum):
* alloc.c (make_bignum_bg):
* alloc.c (make_ratio):
* alloc.c (make_ratio_bg):
* alloc.c (make_ratio_rt):
* alloc.c (make_bigfloat):
* alloc.c (make_bigfloat_bf):
* alloc.c (size_vector):
* alloc.c (make_compiled_function):
* alloc.c (Fmake_symbol):
* alloc.c (allocate_extent):
* alloc.c (allocate_event):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (Fmake_marker):
* alloc.c (noseeum_make_marker):
* alloc.c (size_string_direct_data):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* alloc.c (malloced_storage_size):
* buffer.c (allocate_buffer):
* buffer.c (compute_buffer_usage):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.c (nuke_all_buffer_slots):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.h (struct buffer_text):
* buffer.h (struct buffer):
* bytecode.c:
* bytecode.c (make_compiled_function_args):
* bytecode.c (size_compiled_function_args):
* bytecode.h (struct compiled_function_args):
* casetab.c (allocate_case_table):
* casetab.h (struct Lisp_Case_Table):
* charset.h (struct Lisp_Charset):
* chartab.c (fill_char_table):
* chartab.c (Fmake_char_table):
* chartab.c (make_char_table_entry):
* chartab.c (copy_char_table_entry):
* chartab.c (Fcopy_char_table):
* chartab.c (put_char_table):
* chartab.h (struct Lisp_Char_Table_Entry):
* chartab.h (struct Lisp_Char_Table):
* console-gtk-impl.h (struct gtk_device):
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h (struct console):
* console-msw-impl.h (struct Lisp_Devmode):
* console-msw-impl.h (struct mswindows_device):
* console-msw-impl.h (struct msprinter_device):
* console-msw-impl.h (struct mswindows_frame):
* console-msw-impl.h (struct mswindows_dialog_id):
* console-stream-impl.h (struct stream_console):
* console-stream.c (stream_init_console):
* console-tty-impl.h (struct tty_console):
* console-tty-impl.h (struct tty_device):
* console-tty.c (allocate_tty_console_struct):
* console-x-impl.h (struct x_device):
* console-x-impl.h (struct x_frame):
* console.c (allocate_console):
* console.c (nuke_all_console_slots):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.c (common_init_complex_vars_of_console):
* data.c (make_weak_list):
* data.c (make_weak_box):
* data.c (make_ephemeron):
* database.c:
* database.c (struct Lisp_Database):
* database.c (allocate_database):
* database.c (finalize_database):
* device-gtk.c (allocate_gtk_device_struct):
* device-impl.h (struct device):
* device-msw.c:
* device-msw.c (mswindows_init_device):
* device-msw.c (msprinter_init_device):
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device-tty.c (allocate_tty_device_struct):
* device-x.c (allocate_x_device_struct):
* device.c:
* device.c (nuke_all_device_slots):
* device.c (allocate_device):
* dialog-msw.c (handle_question_dialog_box):
* elhash.c:
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (finalize_hash_table):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (Fcopy_hash_table):
* elhash.h (htentry):
* emacs.c (main_1):
* eval.c:
* eval.c (size_multiple_value):
* event-stream.c (finalize_command_builder):
* event-stream.c (allocate_command_builder):
* event-stream.c (free_command_builder):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (event_stream_resignal_wakeup):
* event-stream.c (event_stream_disable_wakeup):
* event-stream.c (event_stream_wakeup_pending_p):
* events.h (struct Lisp_Timeout):
* events.h (struct command_builder):
* extents-impl.h:
* extents-impl.h (struct extent_auxiliary):
* extents-impl.h (struct extent_info):
* extents-impl.h (set_extent_no_chase_aux_field):
* extents-impl.h (set_extent_no_chase_normal_field):
* extents.c:
* extents.c (gap_array_marker):
* extents.c (gap_array):
* extents.c (extent_list_marker):
* extents.c (extent_list):
* extents.c (stack_of_extents):
* extents.c (gap_array_make_marker):
* extents.c (extent_list_make_marker):
* extents.c (allocate_extent_list):
* extents.c (SLOT):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (attach_extent_auxiliary):
* extents.c (size_gap_array):
* extents.c (finalize_extent_info):
* extents.c (allocate_extent_info):
* extents.c (uninit_buffer_extents):
* extents.c (allocate_soe):
* extents.c (copy_extent):
* extents.c (vars_of_extents):
* extents.h:
* faces.c (allocate_face):
* faces.h (struct Lisp_Face):
* faces.h (struct face_cachel):
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.c (sizeof_coding_system):
* file-coding.c (Fcopy_coding_system):
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (MARKED_SLOT):
* fns.c (size_bit_vector):
* font-mgr.c:
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (print_fc_pattern):
* font-mgr.c (Ffc_pattern_p):
* font-mgr.c (Ffc_pattern_create):
* font-mgr.c (Ffc_name_parse):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* font-mgr.c (Ffc_pattern_add):
* font-mgr.c (Ffc_pattern_del):
* font-mgr.c (Ffc_pattern_get):
* font-mgr.c (fc_config_create_using):
* font-mgr.c (fc_strlist_to_lisp_using):
* font-mgr.c (fontset_to_list):
* font-mgr.c (Ffc_config_p):
* font-mgr.c (Ffc_config_up_to_date):
* font-mgr.c (Ffc_config_build_fonts):
* font-mgr.c (Ffc_config_get_cache):
* font-mgr.c (Ffc_config_get_fonts):
* font-mgr.c (Ffc_config_set_current):
* font-mgr.c (Ffc_config_get_blanks):
* font-mgr.c (Ffc_config_get_rescan_interval):
* font-mgr.c (Ffc_config_set_rescan_interval):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_app_font_clear):
* font-mgr.c (size):
* font-mgr.c (Ffc_config_substitute):
* font-mgr.c (Ffc_font_render_prepare):
* font-mgr.c (Ffc_font_match):
* font-mgr.c (Ffc_font_sort):
* font-mgr.c (finalize_fc_config):
* font-mgr.c (print_fc_config):
* font-mgr.h:
* font-mgr.h (struct fc_pattern):
* font-mgr.h (XFC_PATTERN):
* font-mgr.h (struct fc_config):
* font-mgr.h (XFC_CONFIG):
* frame-gtk.c (allocate_gtk_frame_struct):
* frame-impl.h (struct frame):
* frame-msw.c (mswindows_init_frame_1):
* frame-x.c (allocate_x_frame_struct):
* frame.c (nuke_all_frame_slots):
* frame.c (allocate_frame_core):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c (finalize_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (Fcolorize_image_instance):
* glyphs.c (allocate_glyph):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* glyphs.c (register_ignored_expose):
* glyphs.h (struct Lisp_Image_Instance):
* glyphs.h (struct Lisp_Glyph):
* glyphs.h (struct glyph_cachel):
* glyphs.h (struct expose_ignore):
* gui.c (allocate_gui_item):
* gui.h (struct Lisp_Gui_Item):
* keymap.c (struct Lisp_Keymap):
* keymap.c (make_keymap):
* lisp.h:
* lisp.h (struct Lisp_String_Direct_Data):
* lisp.h (struct Lisp_String_Indirect_Data):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (DECLARE_INLINE_LISP_BIT_VECTOR):
* lisp.h (struct weak_box):
* lisp.h (struct ephemeron):
* lisp.h (struct weak_list):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (struct lcrecord_list):
* lstream.c (finalize_lstream):
* lstream.c (sizeof_lstream):
* lstream.c (Lstream_new):
* lstream.c (Lstream_delete):
* lstream.h (struct lstream):
* marker.c:
* marker.c (finalize_marker):
* marker.c (compute_buffer_marker_usage):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (compute_charset_usage):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty-impl.h (struct tty_color_instance_data):
* objects-tty-impl.h (struct tty_font_instance_data):
* objects-tty.c (tty_initialize_color_instance):
* objects-tty.c (tty_initialize_font_instance):
* objects.c (finalize_color_instance):
* objects.c (Fmake_color_instance):
* objects.c (finalize_font_instance):
* objects.c (Fmake_font_instance):
* objects.c (reinit_vars_of_objects):
* opaque.c:
* opaque.c (sizeof_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (free_opaque_ptr):
* opaque.h:
* opaque.h (Lisp_Opaque):
* opaque.h (Lisp_Opaque_Ptr):
* print.c (printing_unreadable_lcrecord):
* print.c (external_object_printer):
* print.c (debug_p4):
* process.c (finalize_process):
* process.c (make_process_internal):
* procimpl.h (struct Lisp_Process):
* rangetab.c (Fmake_range_table):
* rangetab.c (Fcopy_range_table):
* rangetab.h (struct Lisp_Range_Table):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h (struct scrollbar_instance):
* specifier.c (finalize_specifier):
* specifier.c (sizeof_specifier):
* specifier.c (set_specifier_caching):
* specifier.h (struct Lisp_Specifier):
* specifier.h (struct specifier_caching):
* symeval.h:
* symeval.h (SYMBOL_VALUE_MAGIC_P):
* symeval.h (DEFVAR_SYMVAL_FWD):
* symsinit.h:
* syntax.c (init_buffer_syntax_cache):
* syntax.h (struct syntax_cache):
* toolbar.c:
* toolbar.c (allocate_toolbar_button):
* toolbar.c (update_toolbar_button):
* toolbar.h (struct toolbar_button):
* tooltalk.c (struct Lisp_Tooltalk_Message):
* tooltalk.c (make_tooltalk_message):
* tooltalk.c (struct Lisp_Tooltalk_Pattern):
* tooltalk.c (make_tooltalk_pattern):
* ui-gtk.c:
* ui-gtk.c (allocate_ffi_data):
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_object_data):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* ui-gtk.h:
* window-impl.h (struct window):
* window-impl.h (struct window_mirror):
* window.c (finalize_window):
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (mark_window_as_deleted):
* window.c (make_dummy_parent):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
Overall point of this change and previous ones in this repository:
(1) Introduce new, clearer terminology: everything other than int
or char is a "record" object, which comes in two types: "normal
objects" and "frob-block objects". Fix up all places that
referred to frob-block objects as "simple", "basic", etc.
(2) Provide an advertised interface for doing operations on Lisp
objects, including creating new types, that is clean and
consistent in its naming, uses the above-referenced terms and
avoids referencing "lrecords", "old lcrecords", etc., which should
hide under the surface.
(3) Make the size_in_bytes and finalizer methods take a
Lisp_Object rather than a void * for consistency with other methods.
(4) Separate finalizer method into finalizer and disksaver, so
that normal finalize methods don't have to worry about disksaving.
Other specifics:
(1) Renaming:
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
implementation->basic_p -> implementation->frob_block_p
ALLOCATE_FIXED_TYPE_AND_SET_IMPL -> ALLOC_FROB_BLOCK_LISP_OBJECT
*FCCONFIG*, wrap_fcconfig -> *FC_CONFIG*, wrap_fc_config
*FCPATTERN*, wrap_fcpattern -> *FC_PATTERN*, wrap_fc_pattern
(the last two changes make the naming of these macros consistent
with the naming of all other macros, since the objects are named
fc-config and fc-pattern with a hyphen)
(2) Lots of documentation fixes in lrecord.h.
(3) Eliminate macros for copying, freeing, zeroing objects, getting
their storage size. Instead, new functions:
zero_sized_lisp_object()
zero_nonsized_lisp_object()
lisp_object_storage_size()
free_normal_lisp_object()
(copy_lisp_object() already exists)
LISP_OBJECT_FROB_BLOCK_P() (actually a macro)
Eliminated:
free_lrecord()
zero_lrecord()
copy_lrecord()
copy_sized_lrecord()
old_copy_lcrecord()
old_copy_sized_lcrecord()
old_zero_lcrecord()
old_zero_sized_lcrecord()
LISP_OBJECT_STORAGE_SIZE()
COPY_SIZED_LISP_OBJECT()
COPY_SIZED_LCRECORD()
COPY_LISP_OBJECT()
ZERO_LISP_OBJECT()
FREE_LISP_OBJECT()
(4) Catch the remaining places where lrecord stuff was used directly
and use the advertised interface, e.g. alloc_sized_lrecord() ->
ALLOC_SIZED_LISP_OBJECT().
(5) Make certain statically-declared pseudo-objects
(buffer_local_flags, console_local_flags) have their lheader
initialized correctly, so things like copy_lisp_object() can work
on them. Make extent_auxiliary_defaults a proper heap object
Vextent_auxiliary_defaults, and make extent auxiliaries dumpable
so that this object can be dumped. allocate_extent_auxiliary()
now just creates the object, and attach_extent_auxiliary()
creates an extent auxiliary and attaches to an extent, like the
old allocate_extent_auxiliary().
(6) Create EXTENT_AUXILIARY_SLOTS macro, similar to the foo-slots.h
files but in a macro instead of a file. The purpose is to avoid
duplication when iterating over all the slots in an extent auxiliary.
Use it.
(7) In lstream.c, don't zero out object after allocation because
allocation routines take care of this.
(8) In marker.c, fix a mistake in computing marker overhead.
(9) In print.c, clean up printing_unreadable_lcrecord(),
external_object_printer() to avoid lots of ifdef NEW_GC's.
(10) Separate toolbar-button allocation into a separate
allocate_toolbar_button() function for use in the example code
in lrecord.h.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Mar 2010 04:08:17 -0600 |
| parents | 5460287a3327 |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 398 | 1 /* Tabs Widget for XEmacs. |
| 2 Copyright (C) 1999 Edward A. Falk | |
| 442 | 3 |
| 398 | 4 This file is part of XEmacs. |
| 442 | 5 |
| 398 | 6 XEmacs is free software; you can redistribute it and/or modify it |
| 7 under the terms of the GNU General Public License as published by the | |
| 8 Free Software Foundation; either version 2, or (at your option) any | |
| 9 later version. | |
| 442 | 10 |
| 398 | 11 XEmacs is distributed in the hope that it will be useful, but WITHOUT |
| 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 14 for more details. | |
| 442 | 15 |
| 398 | 16 You should have received a copy of the GNU General Public License |
| 17 along with XEmacs; see the file COPYING. If not, write to | |
| 18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 19 Boston, MA 02111-1307, USA. */ | |
| 442 | 20 |
| 398 | 21 /* Synched up with: Gcs.c 1.7 */ |
| 442 | 22 |
| 398 | 23 /* #### This code is duplicated many times within lwlib and XEmacs. It |
| 24 should be modularised. */ | |
| 25 | |
| 26 /* | |
| 27 * Gcs.c - Utility functions to allocate GCs. | |
| 28 * | |
| 29 * Author: Edward A. Falk | |
| 30 * falk@falconer.vip.best.com | |
| 31 * | |
| 32 * Date: Sept 29, 1998 | |
| 33 */ | |
| 34 | |
| 35 /* Functions: | |
| 36 * | |
| 37 * GC AllocFgGC(w, fg, font) | |
| 38 * Return a GC with foreground set as specified. | |
| 39 * If font is None, then the returned GC is allocated with font specified | |
| 40 * as a "don't care" value. | |
| 41 * | |
| 42 * GC | |
| 43 * AllocBackgroundGC(w, font) | |
| 44 * Return a GC with the foreground set to the widget's background color. | |
| 45 * | |
| 46 * GC | |
| 47 * AllocGreyGC(w, fg, font, contrast, be_nice_to_cmap) | |
| 48 * Widget w ; | |
| 49 * Pixel fg ; | |
| 50 * Font font ; | |
| 51 * int contrast ; | |
| 52 * int be_nice_to_cmap ; | |
| 53 * | |
| 54 * Return a GC suitable for rendering a widget in its "inactive" color. | |
| 55 * Normally returns a GC with a color somewhere between the widget's | |
| 56 * background color and the specified foreground. If font is None, then | |
| 57 * the returned GC is allocated with font specified as "don't care". | |
| 58 * If be_nice_to_cmap is True, the returned GC is created using a 50% | |
| 59 * dither instead of a new color. | |
| 60 * | |
| 61 * | |
| 62 * GC | |
| 63 * AllocShadeGC(w, fg, bg, font, contrast, be_nice_to_cmap) | |
| 64 * Widget w ; | |
| 65 * Pixel fg, bg ; | |
| 66 * Font font ; | |
| 67 * int contrast ; | |
| 68 * int be_nice_to_cmap ; | |
| 69 * | |
| 70 * Return a GC suitable for rendering in a shade somewhere between | |
| 71 * bg and fg, as determined by contrast (0 = bg, 100 = fg) | |
| 72 * If font is None, then the returned GC is allocated with | |
| 73 * font specified as "don't care". If be_nice_to_cmap | |
| 74 * is True, the returned GC is created using a 50% dither | |
| 75 * instead of a new color. | |
| 76 * | |
| 77 * | |
| 78 * GC | |
| 79 * AllocTopShadowGC(w, contrast, be_nice_to_cmap) | |
| 80 * Return a GC suitable for rendering the "top shadow" decorations of | |
| 81 * a widget. Returns a GC with foreground computed from widget's | |
| 82 * background color and contrast. If be_nice_to_cmap is True, the | |
| 83 * returned GC will use a foreground color of white. If widget depth | |
| 84 * is 1, this function will use a foreground color of black. | |
| 85 * | |
| 86 * GC | |
| 87 * AllocBotShadowGC(w, contrast, be_nice_to_cmap) | |
| 88 * Return a GC suitable for rendering the "bottom shadow" decorations | |
| 89 * of a widget. Returns a GC with foreground computed from widget's | |
| 90 * background color and contrast. If be_nice_to_cmap is True, the | |
| 91 * returned GC will use a foreground color of black. | |
| 92 * | |
| 93 * GC | |
| 94 * AllocArmGC(w, contrast, be_nice_to_cmap) | |
| 95 * Return a GC suitable for rendering the "armed" decorations of a | |
| 96 * widget. This GC would typically be used to fill in the widget's | |
| 97 * background. Returns a GC with foreground computed from widget's | |
| 98 * background color and contrast. If be_nice_to_cmap is True, the | |
| 99 * returned GC will use a foreground color of black and a 50% dither. | |
| 100 * | |
| 101 * | |
| 102 * void | |
| 103 * Draw3dBox(w, x,y,wid,hgt,s, topgc, botgc) | |
| 104 * Utility function. Draws a raised shadow box with outside dimensions | |
| 105 * as specified by x,y,wid,hgt and shadow width specified by s. | |
| 106 * A lowered shadow box may be generated by swapping topgc and botgc. | |
| 107 * | |
| 108 */ | |
| 109 | |
| 110 #include <config.h> | |
| 111 #include <stdio.h> | |
| 112 | |
| 113 #include <X11/Xlib.h> | |
| 114 #include <X11/IntrinsicP.h> | |
| 115 #include <X11/StringDefs.h> | |
|
4769
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
2286
diff
changeset
|
116 #include <X11/Xmu/Drawing.h> |
|
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
2286
diff
changeset
|
117 #include <X11/Xmu/Misc.h> |
| 398 | 118 #include "xlwgcs.h" |
| 119 | |
| 120 /* Color & GC allocation. | |
| 121 * | |
| 122 * Frame widgets use the following graphics contexts: | |
| 123 * | |
| 124 * Foreground tab label text drawn this way | |
| 125 * Insensitive Fg foreground color greyed out. | |
| 126 * Background frame background color | |
| 127 * Top shadow upper-left highlight around widget | |
| 128 * Bottom shadow lower-right highlight around widget | |
| 129 * Arm shadow button pressed and ready to be released | |
| 130 * | |
| 131 * | |
| 132 * GC's are defined as follows, depending on attributes and | |
| 133 * window depth: | |
| 134 * | |
| 135 * Monochrome: | |
| 136 * Foreground = foreground color attribute or BlackPixel() | |
| 137 * Grey = Foreground color + 50% dither | |
| 138 * Background = background color attribute or WhitePixel() | |
| 139 * top shadow = foreground | |
| 140 * bottom shadow = foreground | |
| 141 * arm shadow = (what?) | |
| 142 * | |
| 143 * Color, beNiceToColormap=true: | |
| 144 * Foreground = foreground color attribute or BlackPixel() | |
| 145 * Grey = Foreground color + 50% dither | |
| 146 * Background = background color attribute or WhitePixel() | |
| 147 * top shadow = white | |
| 148 * bottom shadow = black | |
| 149 * arm shadow = (what?) | |
| 150 * | |
| 151 * Color, beNiceToColormap=false: | |
| 152 * Foreground = foreground color attribute or BlackPixel() | |
| 153 * Grey = (foreground color + background color)/2 | |
| 154 * Background = background color attribute or WhitePixel() | |
| 155 * top shadow = background * 1.2 | |
| 156 * bottom shadow = background * .6 | |
| 157 * arm shadow = background * .8 | |
| 158 * | |
| 159 * Special cases: | |
| 160 * If background is white, ?? | |
| 161 * if background is black, ?? | |
| 162 * | |
| 163 * | |
| 164 * If the widget's background is solid white or solid black, | |
| 165 * this code just picks some numbers. (The choice is designed | |
| 442 | 166 * to be compatible with ThreeD interface.) |
| 398 | 167 */ |
| 168 | |
| 169 | |
| 170 | |
| 171 #if NeedFunctionPrototypes | |
| 172 static Pixmap getDitherPixmap(Widget, int contrast) ; | |
| 173 #else | |
| 174 static Pixmap getDitherPixmap() ; | |
| 175 #endif | |
| 176 | |
| 177 /* return a GC with the specified foreground and optional font */ | |
| 178 | |
| 179 GC | |
| 180 AllocFgGC(Widget w, Pixel fg, Font font) | |
| 181 { | |
| 182 XGCValues values ; | |
| 458 | 183 unsigned long vmask, dcmask ; |
| 398 | 184 |
| 185 values.foreground = fg ; | |
| 186 values.font = font ; | |
| 187 | |
| 188 if( font != None ) { | |
| 189 vmask = GCForeground|GCFont ; | |
| 190 dcmask = GCSubwindowMode|GCDashOffset| | |
| 191 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ; | |
| 192 } else { | |
| 193 vmask = GCForeground ; | |
| 194 dcmask = GCFont|GCSubwindowMode|GCDashOffset| | |
| 195 GCDashList|GCArcMode|GCBackground|GCGraphicsExposures ; | |
| 196 } | |
| 197 | |
| 198 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ; | |
| 199 } | |
| 200 | |
| 201 | |
| 202 /* return gc with widget background color as the foreground */ | |
| 203 | |
| 204 GC | |
| 205 AllocBackgroundGC(Widget w, Font font) | |
| 206 { | |
| 207 return AllocFgGC(w, w->core.background_pixel, font) ; | |
| 208 } | |
| 209 | |
| 210 | |
| 211 /* Allocate an "inactive" GC. Color is grey (possibly via | |
| 212 * dither pattern). | |
| 213 */ | |
| 214 | |
| 215 GC | |
| 216 AllocGreyGC(Widget w, Pixel fg, Font font, int contrast, Bool be_nice_to_cmap) | |
| 217 { | |
| 218 return AllocShadeGC(w, fg, w->core.background_pixel, | |
| 219 font, contrast, be_nice_to_cmap) ; | |
| 220 } | |
| 221 | |
| 222 | |
| 223 /* Allocate a GC somewhere between two colors. */ | |
| 224 | |
| 225 GC | |
| 226 AllocShadeGC(Widget w, Pixel fg, Pixel bg, Font font, | |
|
4769
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
2286
diff
changeset
|
227 int contrast, Bool be_nice_to_cmap) |
| 398 | 228 { |
| 229 XGCValues values ; | |
| 458 | 230 unsigned long vmask, dcmask ; |
| 398 | 231 |
| 232 values.foreground = fg ; | |
| 233 values.background = bg ; | |
| 234 values.font = font ; | |
| 235 | |
| 236 if( font != None ) { | |
| 237 vmask = GCForeground|GCFont ; | |
| 238 dcmask = GCSubwindowMode|GCDashOffset| | |
| 239 GCDashList|GCArcMode|GCGraphicsExposures ; | |
| 240 } else { | |
| 241 vmask = GCForeground; | |
| 242 dcmask = GCFont|GCSubwindowMode|GCDashOffset| | |
| 243 GCDashList|GCArcMode|GCGraphicsExposures ; | |
| 244 } | |
| 245 if( be_nice_to_cmap || w->core.depth == 1) | |
| 246 { | |
| 247 if( contrast <= 5 ) | |
| 248 values.foreground = bg ; | |
| 249 else if( contrast >= 95 ) | |
| 250 values.foreground = fg ; | |
| 251 else { | |
| 252 vmask |= GCBackground|GCStipple|GCFillStyle ; | |
| 253 values.fill_style = FillOpaqueStippled ; | |
| 254 values.stipple = getDitherPixmap(w, contrast) ; | |
| 255 } | |
| 256 | |
| 257 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ; | |
|
4769
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
2286
diff
changeset
|
258 } else { |
| 398 | 259 dcmask |= GCBackground ; |
| 260 values.foreground = AllocGreyPixel(w, fg, bg, contrast) ; | |
| 261 return XtAllocateGC(w, w->core.depth, vmask, &values, 0L, dcmask) ; | |
| 262 } | |
| 263 } | |
| 264 | |
| 265 /* return top-shadow gc. */ | |
| 266 | |
| 267 GC | |
| 268 AllocTopShadowGC(Widget w, int contrast, Bool be_nice_to_cmap) | |
| 269 { | |
| 270 Screen *scr = XtScreen (w); | |
| 271 XGCValues values ; | |
| 272 | |
| 273 if( w->core.depth == 1 ) | |
| 274 values.foreground = BlackPixelOfScreen(scr) ; | |
| 275 else if( be_nice_to_cmap ) | |
| 276 values.foreground = WhitePixelOfScreen(scr) ; | |
| 277 else | |
| 278 values.foreground = AllocShadowPixel(w, 100+contrast) ; | |
| 279 | |
| 280 return XtAllocateGC(w, w->core.depth, | |
| 281 GCForeground, &values, | |
| 282 0L, | |
| 283 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures| | |
| 284 GCDashOffset|GCDashList|GCArcMode) ; | |
| 285 } | |
| 286 | |
| 287 /* return bottom-shadow gc. */ | |
| 288 | |
| 289 GC | |
| 290 AllocBotShadowGC(Widget w, int contrast, Bool be_nice_to_cmap) | |
| 291 { | |
| 292 Screen *scr = XtScreen (w); | |
| 293 XGCValues values ; | |
| 294 | |
| 295 if( w->core.depth == 1 || be_nice_to_cmap ) | |
| 296 values.foreground = BlackPixelOfScreen(scr) ; | |
| 297 else | |
| 298 values.foreground = AllocShadowPixel(w, 100-contrast) ; | |
| 299 | |
| 300 return XtAllocateGC(w, w->core.depth, | |
| 301 GCForeground, &values, | |
| 302 0L, | |
| 303 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures| | |
| 304 GCDashOffset|GCDashList|GCArcMode) ; | |
| 305 } | |
| 306 | |
| 307 /* return arm-shadow gc. */ | |
| 308 | |
| 309 GC | |
|
4769
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
2286
diff
changeset
|
310 AllocArmGC(Widget w, int contrast, Bool be_nice_to_cmap) |
| 398 | 311 { |
| 312 Screen *scr = XtScreen (w); | |
| 313 XGCValues values ; | |
| 314 | |
| 315 /* Not clear exactly what we should do here. Take a look at | |
| 316 * Xaw3d to see what they do. | |
| 317 */ | |
| 318 if( w->core.depth == 1 || be_nice_to_cmap ) | |
| 319 { | |
| 320 values.background = w->core.background_pixel ; | |
| 321 if( values.background == BlackPixelOfScreen(scr) ) | |
| 322 values.foreground = WhitePixelOfScreen(scr) ; | |
| 323 else | |
| 324 values.foreground = BlackPixelOfScreen(scr) ; | |
| 325 values.fill_style = FillStippled ; | |
| 326 values.stipple = XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ; | |
| 327 | |
| 328 return XtAllocateGC(w, w->core.depth, | |
| 329 GCForeground|GCBackground|GCStipple|GCFillStyle, | |
| 330 &values, 0L, | |
| 331 GCFont|GCSubwindowMode|GCGraphicsExposures| | |
| 332 GCDashOffset|GCDashList|GCArcMode) ; | |
|
4769
5460287a3327
Remove support for pre-X11R5 systems, including systems without Xmu. See
Jerry James <james@xemacs.org>
parents:
2286
diff
changeset
|
333 } else { |
| 398 | 334 values.foreground = AllocShadowPixel(w, 100-contrast) ; |
| 335 return XtAllocateGC(w, w->core.depth, | |
| 336 GCForeground, &values, | |
| 337 0L, | |
| 338 GCBackground|GCFont|GCSubwindowMode|GCGraphicsExposures| | |
| 339 GCDashOffset|GCDashList|GCArcMode) ; | |
| 340 } | |
| 341 } | |
| 342 | |
| 343 | |
| 344 Pixel | |
| 345 AllocShadowPixel(Widget w, int scale) | |
| 346 { | |
| 347 XColor get_c, set_c ; | |
| 348 Display *dpy = XtDisplay(w) ; | |
| 349 Screen *scr = XtScreen(w) ; | |
| 350 Colormap cmap ; | |
| 351 Pixel maxColor ; | |
| 352 | |
| 353 cmap = w->core.colormap ; | |
| 354 | |
| 355 get_c.pixel = w->core.background_pixel ; | |
| 356 if( get_c.pixel == WhitePixelOfScreen(scr) || | |
| 357 get_c.pixel == BlackPixelOfScreen(scr) ) | |
| 358 { | |
| 359 /* what we *ought* to do is choose gray75 as the base color, | |
| 360 * or perhaps gray83. Instead, we choose colors that are | |
| 361 * the same as ThreeD would choose. | |
| 362 */ | |
| 363 if( scale > 100 ) scale = 200 - scale ; | |
| 364 set_c.red = set_c.green = set_c.blue = 65535*scale/100 ; | |
| 365 } | |
| 366 else | |
| 367 { | |
| 368 XQueryColor(dpy, cmap, &get_c) ; | |
| 369 /* adjust scale so that brightest component does not | |
| 370 * exceed 65535; otherwise hue would change. | |
| 371 */ | |
| 372 if( scale > 100 ) { | |
| 373 maxColor = Max(get_c.red, Max(get_c.green, get_c.blue)) ; | |
| 374 if( scale*maxColor > 65535*100 ) | |
| 375 scale = 65535*100/maxColor ; | |
| 376 } | |
| 377 set_c.red = scale * get_c.red / 100 ; | |
| 378 set_c.green = scale * get_c.green / 100 ; | |
| 379 set_c.blue = scale * get_c.blue / 100 ; | |
| 380 } | |
| 381 set_c.flags = DoRed | DoGreen | DoBlue ; | |
| 382 if( XAllocColor(dpy, cmap, &set_c) ) | |
| 383 return set_c.pixel ; | |
| 384 else if( scale > 100 ) | |
| 385 return WhitePixelOfScreen(scr) ; | |
| 386 else | |
| 387 return BlackPixelOfScreen(scr) ; | |
| 388 } | |
| 389 | |
| 390 | |
| 391 /* Allocate a pixel partway between foreground and background */ | |
| 392 | |
| 393 | |
| 394 Pixel | |
| 395 AllocGreyPixel(Widget w, Pixel fg, Pixel bg, int scale) | |
| 396 { | |
| 397 XColor get_cf, get_cb ; | |
| 398 Display *dpy = XtDisplay(w) ; | |
| 399 Colormap cmap ; | |
| 400 | |
| 401 cmap = w->core.colormap ; | |
| 402 | |
| 403 get_cf.pixel = fg ; | |
| 404 get_cb.pixel = bg ; | |
| 405 | |
| 406 XQueryColor(dpy, cmap, &get_cf) ; | |
| 407 XQueryColor(dpy, cmap, &get_cb) ; | |
| 408 | |
| 409 return AllocGreyPixelC(w, &get_cf, &get_cb, scale) ; | |
| 410 } | |
| 411 | |
| 412 | |
| 413 | |
| 414 /* Allocate a pixel partway between foreground and background */ | |
| 415 | |
| 416 | |
| 417 Pixel | |
| 418 AllocGreyPixelC(Widget w, XColor *fg, XColor *bg, int scale) | |
| 419 { | |
| 420 XColor set_c ; | |
| 421 Display *dpy = XtDisplay(w) ; | |
| 422 int r,g,b ; | |
| 423 Colormap cmap = w->core.colormap ; | |
| 424 | |
| 425 r = (fg->red * scale + bg->red * (100-scale)) / 100 ; | |
| 426 g = (fg->green * scale + bg->green * (100-scale)) / 100 ; | |
| 427 b = (fg->blue * scale + bg->blue * (100-scale)) / 100 ; | |
| 428 | |
| 429 if( scale > 100 || scale < 0 ) /* look out for overflow */ | |
| 430 { | |
| 431 int minc, maxc ; | |
| 432 maxc = Max(r, Max(g,b)) ; | |
| 433 minc = Min(r, Min(g,b)) ; | |
| 434 if( maxc > 65535 ) | |
| 435 { | |
| 436 maxc /= 16 ; | |
| 437 r = r*(65535/16) / maxc ; | |
| 438 g = g*(65535/16) / maxc ; | |
| 439 b = b*(65535/16) / maxc ; | |
| 440 } | |
| 441 if( minc < 0 ) | |
| 442 { | |
| 443 r = Max(r,0) ; | |
| 444 g = Max(g,0) ; | |
| 445 b = Max(b,0) ; | |
| 446 } | |
| 447 } | |
| 448 | |
| 449 set_c.red = r ; set_c.green = g ; set_c.blue = b ; | |
| 450 set_c.flags = DoRed | DoGreen | DoBlue ; | |
| 451 (void)XAllocColor(dpy, cmap, &set_c) ; | |
| 452 return set_c.pixel ; | |
| 453 } | |
| 454 | |
| 455 | |
| 456 | |
| 457 | |
| 458 | |
| 459 /* draw a 3-d box */ | |
| 460 | |
| 461 void | |
| 462 Draw3dBox(Widget w, int x, int y, int wid, int hgt, int s, GC topgc, GC botgc) | |
| 463 { | |
| 464 Display *dpy = XtDisplay(w) ; | |
| 465 Window win = XtWindow(w) ; | |
| 466 | |
| 467 if( s == 0 ) return ; | |
| 468 | |
| 469 if( s == 1 ) { | |
| 470 XDrawLine(dpy,win,botgc, x,y+hgt-1, x+wid-1,y+hgt-1) ; | |
| 471 XDrawLine(dpy,win,botgc, x+wid-1,y, x+wid-1,y+hgt-1) ; | |
| 472 XDrawLine(dpy,win,topgc, x,y, x,y+hgt-1) ; | |
| 473 XDrawLine(dpy,win,topgc, x,y, x+wid-1,y) ; | |
| 474 } | |
| 475 else | |
| 476 { | |
| 477 XPoint pts[6] ; | |
| 478 | |
| 479 /* bottom-right shadow */ | |
| 480 pts[0].x = x ; pts[0].y = y + hgt ; | |
| 481 pts[1].x = s ; pts[1].y = -s ; | |
| 482 pts[2].x = wid-2*s ; pts[2].y = 0 ; | |
| 483 pts[3].x = 0 ; pts[3].y = -(hgt-2*s) ; | |
| 484 pts[4].x = s ; pts[4].y = -s ; | |
| 485 pts[5].x = 0 ; pts[5].y = hgt ; | |
| 486 XFillPolygon(dpy,win,botgc, pts,6, Nonconvex,CoordModePrevious) ; | |
| 487 | |
| 488 /* top-left shadow */ | |
| 489 pts[0].x = x ; pts[0].y = y ; | |
| 490 pts[1].x = wid ; pts[1].y = 0 ; | |
| 491 pts[2].x = -s ; pts[2].y = s ; | |
| 492 pts[3].x = -wid+2*s ; pts[3].y = 0 ; | |
| 493 pts[4].x = 0 ; pts[4].y = hgt-2*s ; | |
| 494 pts[5].x = -s ; pts[5].y = s ; | |
| 495 XFillPolygon(dpy,win,topgc, pts,6, Nonconvex,CoordModePrevious) ; | |
| 496 } | |
| 497 } | |
| 498 | |
| 458 | 499 static unsigned char screen0[2] = {0,0} ; |
| 500 static unsigned char screen25[2] = {0,0xaa} ; | |
| 501 static unsigned char screen75[2] = {0xaa,0xff} ; | |
| 502 static unsigned char screen100[2] = {0xff,0xff} ; | |
| 398 | 503 |
| 504 static Pixmap | |
| 505 getDitherPixmap(Widget w, int contrast) | |
| 506 { | |
| 507 Display *dpy = XtDisplay(w) ; | |
| 508 Window win = XtWindow(w) ; | |
| 509 | |
| 510 if( contrast <= 5 ) | |
| 511 return XCreateBitmapFromData(dpy,win, (char *)screen0, 2,2) ; | |
| 512 else if( contrast <= 37 ) | |
| 513 return XCreateBitmapFromData(dpy,win, (char *)screen25, 2,2) ; | |
| 514 else if( contrast <= 62 ) | |
| 515 return XmuCreateStippledPixmap(XtScreen(w), 1L, 0L, 1) ; | |
| 516 else if( contrast <= 95 ) | |
| 517 return XCreateBitmapFromData(dpy,win, (char *)screen75, 2,2) ; | |
| 518 else | |
| 519 return XCreateBitmapFromData(dpy,win, (char *)screen100, 2,2) ; | |
| 520 } |