Mercurial > hg > xemacs-beta
annotate src/frame-impl.h @ 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 | 2a462149bd6a |
| children | 7be849cb8828 |
| rev | line source |
|---|---|
| 872 | 1 /* Define frame-object for XEmacs. |
| 2 Copyright (C) 1988, 1992, 1993, 1994 Free Software Foundation, Inc. | |
| 5045 | 3 Copyright (C) 1995, 2010 Ben Wing. |
| 872 | 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: FSF 19.30. */ | |
| 23 | |
| 24 #ifndef INCLUDED_frame_impl_h_ | |
| 25 #define INCLUDED_frame_impl_h_ | |
| 26 | |
| 27 #include "console-impl.h" /* for error_check_frame_type */ | |
| 28 #include "frame.h" | |
| 29 | |
| 30 #define FRAME_TYPE_NAME(f) ((f)->framemeths->name) | |
| 31 #define FRAME_TYPE(f) ((f)->framemeths->symbol) | |
| 32 | |
| 33 /******** Accessing / calling a frame method *********/ | |
| 34 | |
| 35 #define HAS_FRAMEMETH_P(f, m) HAS_CONTYPE_METH_P ((f)->framemeths, m) | |
| 36 #define FRAMEMETH(f, m, args) CONTYPE_METH ((f)->framemeths, m, args) | |
| 37 #define MAYBE_FRAMEMETH(f, m, args) \ | |
| 38 MAYBE_CONTYPE_METH ((f)->framemeths, m, args) | |
| 39 #define FRAMEMETH_OR_GIVEN(f, m, args, given) \ | |
| 40 CONTYPE_METH_OR_GIVEN((f)->framemeths, m, args, given) | |
| 41 | |
| 42 struct frame | |
| 43 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5126
diff
changeset
|
44 NORMAL_LISP_OBJECT_HEADER header; |
| 872 | 45 |
| 46 /* Methods for this frame's console. This can also be retrieved | |
| 47 through frame->device->console, but it's faster this way. */ | |
| 48 struct console_methods *framemeths; | |
| 49 | |
| 1204 | 50 /* Duplicates framemeths->symbol. See comment in struct console. */ |
| 51 enum console_variant frametype; | |
| 52 | |
| 872 | 53 /* Size of text only area of this frame, excluding scrollbars, |
| 54 toolbars and end of line glyphs. The size can be in characters | |
| 55 or pixels, depending on units in which window system resizes | |
| 56 its windows */ | |
| 57 int height, width; | |
| 58 | |
| 59 /* New height and width for pending size change, in the same units | |
| 60 as above. 0 if no change pending. */ | |
| 61 int new_height, new_width; | |
| 62 | |
| 63 /* Size of text-only are of the frame, in default font characters. | |
| 64 This may be inaccurate due to rounding error */ | |
| 65 int char_height, char_width; | |
| 66 | |
| 67 /* Size of the whole frame, including scrollbars, toolbars and end | |
| 68 of line glyphs, in pixels */ | |
| 69 int pixheight, pixwidth; | |
| 70 | |
| 71 #ifdef HAVE_TTY | |
| 72 /* The count of frame number. This applies to TTY frames only. */ | |
| 73 int order_count; | |
| 74 #endif | |
| 75 | |
| 76 /* Current page number for a printer frame. */ | |
| 77 int page_number; | |
| 78 | |
| 79 /* Width of the internal border. This is a line of background color | |
| 80 just inside the window's border. It is normally only non-zero on | |
| 81 X frames, but we put it here to avoid introducing window system | |
| 82 dependencies. */ | |
| 83 int internal_border_width; | |
| 84 | |
| 85 int modiff; | |
| 86 | |
| 87 struct expose_ignore *subwindow_exposures; | |
| 88 struct expose_ignore *subwindow_exposures_tail; | |
| 89 | |
| 90 #ifdef HAVE_SCROLLBARS | |
| 91 /* frame-local scrollbar information. See scrollbar.c. */ | |
| 92 int scrollbar_y_offset; | |
| 93 | |
| 94 /* cache of created scrollbars */ | |
| 95 struct scrollbar_instance *sb_vcache; | |
| 96 struct scrollbar_instance *sb_hcache; | |
| 97 #endif | |
| 98 | |
| 99 #ifdef HAVE_TOOLBARS | |
| 100 /* Size of toolbars as seen by redisplay. This is used to determine | |
| 101 whether to re-layout windows by a call to change_frame_size early | |
| 102 in redisplay_frame. */ | |
| 103 int current_toolbar_size[4]; | |
| 104 #endif | |
| 105 | |
| 106 /* Size of gutters as seen by redisplay. This is used to determine | |
| 107 whether to re-layout windows by a call to change_frame_size early | |
| 108 in redisplay_frame. */ | |
| 109 int current_gutter_bounds[4]; | |
| 110 | |
| 111 /* Dynamic arrays of display lines for gutters */ | |
| 112 display_line_dynarr *current_display_lines[4]; | |
| 113 display_line_dynarr *desired_display_lines[4]; | |
| 114 | |
| 1204 | 115 /* A structure of auxiliary data specific to the device type. For |
| 116 example, struct x_frame is for X window frames; defined in | |
| 117 console-x-impl.h. */ | |
| 872 | 118 void *frame_data; |
| 119 | |
| 120 #define FRAME_SLOT_DECLARATION | |
| 1204 | 121 #define MARKED_SLOT(x) Lisp_Object x; |
| 872 | 122 #include "frameslots.h" |
| 123 | |
| 124 /* Nonzero if frame is currently displayed. | |
| 125 Mutually exclusive with iconified | |
| 126 JV: This now a tristate flag: | |
| 127 Value : Emacs meaning :f-v-p : X meaning | |
| 128 0 : not displayed : nil : unmapped | |
| 129 >0 : user can access it,needs repainting : t : mapped and visible | |
| 130 <0 : user can access it,needs no repainting : hidden :mapped and invisible | |
| 131 where f-v-p is the return value of frame-visible-p */ | |
| 132 int visible; | |
| 133 | |
| 134 /* one-bit flags: */ | |
| 135 | |
| 136 /* Is focusing onto this frame disabled? (Modal dialog boxes) */ | |
| 137 unsigned int disabled :1; | |
| 138 | |
| 139 /* Are we finished initializing? */ | |
| 140 unsigned int init_finished :1; | |
| 141 | |
| 142 /* Is frame marked for deletion? This is used in XSetErrorHandler(). */ | |
| 143 unsigned int being_deleted :1; | |
| 144 | |
| 145 /* Nonzero if last attempt at redisplay on this frame was preempted. */ | |
| 146 unsigned int display_preempted :1; | |
| 147 | |
| 148 /* Nonzero if window is currently iconified. | |
| 149 This and visible are mutually exclusive. */ | |
| 150 unsigned int iconified :1; | |
| 151 | |
| 152 /* Nonzero if this frame should be cleared and then redrawn. | |
| 153 Setting this will also effectively set frame_changed. */ | |
| 154 unsigned int clear :1; | |
| 155 | |
| 156 /* True if frame actually has a minibuffer window on it. | |
| 157 0 if using a minibuffer window that isn't on this frame. */ | |
| 158 unsigned int has_minibuffer :1; | |
| 159 | |
| 160 /* True if frame's root window can't be split. */ | |
| 161 unsigned int no_split :1; | |
| 162 | |
| 163 unsigned int top_toolbar_was_visible :1; | |
| 164 unsigned int bottom_toolbar_was_visible :1; | |
| 165 unsigned int left_toolbar_was_visible :1; | |
| 166 unsigned int right_toolbar_was_visible :1; | |
| 167 /* gutter visibility */ | |
| 168 unsigned int top_gutter_was_visible :1; | |
| 169 unsigned int bottom_gutter_was_visible :1; | |
| 170 unsigned int left_gutter_was_visible :1; | |
| 171 unsigned int right_gutter_was_visible :1; | |
| 172 | |
| 173 /* redisplay flags */ | |
| 174 unsigned int buffers_changed :1; | |
| 175 unsigned int clip_changed :1; | |
| 176 unsigned int extents_changed :1; | |
| 177 unsigned int faces_changed :1; | |
| 178 unsigned int frame_changed :1; | |
| 905 | 179 unsigned int frame_layout_changed :1; /* The layout of frame |
| 180 elements has changed. */ | |
| 872 | 181 unsigned int subwindows_changed :1; |
| 182 unsigned int subwindows_state_changed :1; | |
| 183 unsigned int glyphs_changed :1; | |
| 184 unsigned int icon_changed :1; | |
| 185 unsigned int menubar_changed :1; | |
| 186 unsigned int modeline_changed :1; | |
| 187 unsigned int point_changed :1; | |
| 188 unsigned int size_changed :1; | |
| 189 unsigned int toolbar_changed :1; | |
| 190 unsigned int gutter_changed :1; | |
| 191 unsigned int windows_changed :1; | |
| 192 unsigned int windows_structure_changed :1; | |
| 193 unsigned int window_face_cache_reset :1; /* used by expose handler */ | |
| 194 unsigned int echo_area_garbaged :1; /* used by Fredisplay_echo_area */ | |
| 195 unsigned int size_slipped :1; | |
| 196 | |
| 197 unsigned int size_change_pending :1; | |
| 198 unsigned int mirror_dirty :1; | |
| 199 | |
| 200 /* flag indicating if any window on this frame is displaying a subwindow */ | |
| 201 unsigned int subwindows_being_displayed :1; | |
| 202 }; | |
| 203 | |
| 204 /* Redefine basic properties more efficiently */ | |
| 205 | |
| 206 #undef FRAME_LIVE_P | |
| 207 #define FRAME_LIVE_P(f) (!EQ (FRAME_TYPE (f), Qdead)) | |
| 208 #undef FRAME_DEVICE | |
| 209 #define FRAME_DEVICE(f) ((f)->device) | |
| 210 | |
| 211 #define FRAME_TYPE_P(f, type) EQ (FRAME_TYPE (f), Q##type) | |
| 212 | |
| 213 #ifdef ERROR_CHECK_TYPES | |
| 214 DECLARE_INLINE_HEADER ( | |
| 215 struct frame * | |
| 216 error_check_frame_type (struct frame * f, Lisp_Object sym) | |
| 217 ) | |
| 218 { | |
| 219 assert (EQ (FRAME_TYPE (f), sym)); | |
| 220 return f; | |
| 221 } | |
| 222 # define FRAME_TYPE_DATA(f, type) \ | |
| 223 ((struct type##_frame *) error_check_frame_type (f, Q##type)->frame_data) | |
| 224 #else | |
| 225 # define FRAME_TYPE_DATA(f, type) \ | |
| 226 ((struct type##_frame *) (f)->frame_data) | |
| 227 #endif | |
| 228 | |
| 229 #define CHECK_FRAME_TYPE(x, type) \ | |
| 230 do { \ | |
| 231 CHECK_FRAME (x); \ | |
| 232 if (!FRAME_TYPE_P (XFRAME (x), type)) \ | |
| 233 dead_wrong_type_argument \ | |
| 234 (type##_console_methods->predicate_symbol, x); \ | |
| 235 } while (0) | |
| 236 #define CONCHECK_FRAME_TYPE(x, type) \ | |
| 237 do { \ | |
| 238 CONCHECK_FRAME (x); \ | |
| 239 if (!FRAME_TYPE_P (XFRAME (x), type)) \ | |
| 240 x = wrong_type_argument \ | |
| 241 (type##_console_methods->predicate_symbol, x); \ | |
| 242 } while (0) | |
| 243 | |
| 244 #define FRAME_DISPLAY_P(frm) \ | |
| 245 (DEVICE_DISPLAY_P (XDEVICE (FRAME_DEVICE (frm)))) | |
| 246 | |
| 247 #define CHECK_DISPLAY_FRAME(frm) \ | |
| 248 do { \ | |
| 249 CHECK_FRAME (frm); \ | |
| 250 CHECK_LIVE_FRAME (frm); \ | |
| 251 CHECK_DISPLAY_DEVICE (FRAME_DEVICE (XFRAME (frm))); \ | |
| 252 } while (0) | |
| 253 | |
| 254 #define CONCHECK_DISPLAY_FRAME(frm) \ | |
| 255 do { \ | |
| 256 CONCHECK_FRAME (frm); \ | |
| 257 CONCHECK_LIVE_FRAME (frm); \ | |
| 258 CONCHECK_DISPLAY_DEVICE (FRAME_DEVICE (XFRAME (frm))); \ | |
| 259 } while (0) | |
| 260 | |
| 261 #define FRAME_PRINTER_P(frm) \ | |
| 262 (DEVICE_PRINTER_P (XDEVICE (FRAME_DEVICE (frm)))) | |
| 263 | |
| 264 #define CHECK_PRINTER_FRAME(frm) \ | |
| 265 do { \ | |
| 266 CHECK_FRAME (frm); \ | |
| 267 CHECK_LIVE_FRAME (frm); \ | |
| 268 CHECK_PRINTER_DEVICE (FRAME_DEVICE (XFRAME (frm))); \ | |
| 269 } while (0) | |
| 270 | |
| 271 #define CONCHECK_PRINTER_FRAME(frm) \ | |
| 272 do { \ | |
| 273 CONCHECK_FRAME (frm); \ | |
| 274 CONCHECK_LIVE_FRAME (frm); \ | |
| 275 CONCHECK_PRINTER_DEVICE (FRAME_DEVICE (XFRAME (frm))); \ | |
| 276 } while (0) | |
| 277 | |
| 278 /* #### These should be in the frame-*.h files but there are | |
| 279 too many places where the abstraction is broken. Need to | |
| 280 fix. */ | |
| 281 | |
| 282 #define FRAME_X_P(frm) CONSOLE_TYPESYM_X_P (FRAME_TYPE (frm)) | |
| 283 #define CHECK_X_FRAME(z) CHECK_FRAME_TYPE (z, x) | |
| 284 #define CONCHECK_X_FRAME(z) CONCHECK_FRAME_TYPE (z, x) | |
| 285 | |
| 286 #define FRAME_GTK_P(frm) CONSOLE_TYPESYM_GTK_P (FRAME_TYPE (frm)) | |
| 287 #define CHECK_GTK_FRAME(z) CHECK_FRAME_TYPE (z, gtk) | |
| 288 #define CONCHECK_GTK_FRAME(z) CONCHECK_FRAME_TYPE (z, gtk) | |
| 289 | |
| 290 #define FRAME_TTY_P(frm) CONSOLE_TYPESYM_TTY_P (FRAME_TYPE (frm)) | |
| 291 #define CHECK_TTY_FRAME(z) CHECK_FRAME_TYPE (z, tty) | |
| 292 #define CONCHECK_TTY_FRAME(z) CONCHECK_FRAME_TYPE (z, tty) | |
| 293 | |
| 294 #define FRAME_STREAM_P(frm) CONSOLE_TYPESYM_STREAM_P (FRAME_TYPE (frm)) | |
| 295 #define CHECK_STREAM_FRAME(z) CHECK_FRAME_TYPE (z, stream) | |
| 296 #define CONCHECK_STREAM_FRAME(z) CONCHECK_FRAME_TYPE (z, stream) | |
| 297 | |
| 298 #define FRAME_WIN_P(frm) CONSOLE_TYPESYM_WIN_P (FRAME_TYPE (frm)) | |
| 299 | |
| 300 extern int frame_changed; | |
| 301 | |
| 302 #define MARK_FRAME_FACES_CHANGED(f) do { \ | |
| 303 struct frame *mffc_f = (f); \ | |
| 304 mffc_f->faces_changed = 1; \ | |
| 305 mffc_f->modiff++; \ | |
| 306 if (!NILP (mffc_f->device)) \ | |
| 307 { \ | |
| 308 struct device *mffc_d = XDEVICE (mffc_f->device); \ | |
| 309 MARK_DEVICE_FACES_CHANGED (mffc_d); \ | |
| 310 } \ | |
| 311 else \ | |
| 312 faces_changed = 1; \ | |
| 313 } while (0) | |
| 314 | |
| 315 #define MARK_FRAME_GLYPHS_CHANGED(f) do { \ | |
| 316 struct frame *mfgc_f = (f); \ | |
| 317 mfgc_f->glyphs_changed = 1; \ | |
| 318 mfgc_f->modiff++; \ | |
| 319 if (!NILP (mfgc_f->device)) \ | |
| 320 { \ | |
| 321 struct device *mfgc_d = XDEVICE (mfgc_f->device); \ | |
| 322 MARK_DEVICE_GLYPHS_CHANGED (mfgc_d); \ | |
| 323 } \ | |
| 324 else \ | |
| 325 glyphs_changed = 1; \ | |
| 326 } while (0) | |
| 327 | |
| 328 #define MARK_FRAME_SUBWINDOWS_CHANGED(f) do { \ | |
| 329 struct frame *mfgc_f = (f); \ | |
| 330 mfgc_f->subwindows_changed = 1; \ | |
| 331 mfgc_f->modiff++; \ | |
| 332 if (!NILP (mfgc_f->device)) \ | |
| 333 { \ | |
| 334 struct device *mfgc_d = XDEVICE (mfgc_f->device); \ | |
| 335 MARK_DEVICE_SUBWINDOWS_CHANGED (mfgc_d); \ | |
| 336 } \ | |
| 337 else \ | |
| 338 subwindows_changed = 1; \ | |
| 339 } while (0) | |
| 340 | |
| 341 #define MARK_FRAME_SUBWINDOWS_STATE_CHANGED(f) do { \ | |
| 342 struct frame *mfgc_f = (f); \ | |
| 343 mfgc_f->subwindows_state_changed = 1; \ | |
| 344 mfgc_f->modiff++; \ | |
| 345 if (!NILP (mfgc_f->device)) \ | |
| 346 { \ | |
| 347 struct device *mfgc_d = XDEVICE (mfgc_f->device); \ | |
| 348 MARK_DEVICE_SUBWINDOWS_STATE_CHANGED (mfgc_d); \ | |
| 349 } \ | |
| 350 else \ | |
| 351 subwindows_state_changed = 1; \ | |
| 352 } while (0) | |
| 353 | |
| 354 #define MARK_FRAME_TOOLBARS_CHANGED(f) do { \ | |
| 355 struct frame *mftc_f = (f); \ | |
| 356 mftc_f->toolbar_changed = 1; \ | |
| 357 mftc_f->modiff++; \ | |
| 358 if (!NILP (mftc_f->device)) \ | |
| 359 { \ | |
| 360 struct device *mftc_d = XDEVICE (mftc_f->device); \ | |
| 361 MARK_DEVICE_TOOLBARS_CHANGED (mftc_d); \ | |
| 362 } \ | |
| 363 else \ | |
| 364 toolbar_changed = 1; \ | |
| 365 } while (0) | |
| 366 | |
| 367 #define MARK_FRAME_GUTTERS_CHANGED(f) do { \ | |
| 368 struct frame *mftc_f = (f); \ | |
| 369 mftc_f->gutter_changed = 1; \ | |
| 370 mftc_f->modiff++; \ | |
| 371 if (!NILP (mftc_f->device)) \ | |
| 372 { \ | |
| 373 struct device *mftc_d = XDEVICE (mftc_f->device); \ | |
| 374 MARK_DEVICE_GUTTERS_CHANGED (mftc_d); \ | |
| 375 } \ | |
| 376 else \ | |
| 377 gutter_changed = 1; \ | |
| 378 } while (0) | |
| 379 | |
| 380 #define MARK_FRAME_SIZE_CHANGED(f) do { \ | |
| 381 struct frame *mfsc_f = (f); \ | |
| 382 mfsc_f->size_changed = 1; \ | |
| 383 mfsc_f->size_change_pending = 1; \ | |
| 384 mfsc_f->modiff++; \ | |
| 385 if (!NILP (mfsc_f->device)) \ | |
| 386 { \ | |
| 387 struct device *mfsc_d = XDEVICE (mfsc_f->device); \ | |
| 388 MARK_DEVICE_SIZE_CHANGED (mfsc_d); \ | |
| 389 } \ | |
| 390 else \ | |
| 391 size_changed = 1; \ | |
| 392 } while (0) | |
| 393 | |
| 394 #define MARK_FRAME_CHANGED(f) do { \ | |
| 395 struct frame *mfc_f = (f); \ | |
| 396 mfc_f->frame_changed = 1; \ | |
| 397 mfc_f->modiff++; \ | |
| 398 if (!NILP (mfc_f->device)) \ | |
| 399 { \ | |
| 400 struct device *mfc_d = XDEVICE (mfc_f->device); \ | |
| 401 MARK_DEVICE_FRAME_CHANGED (mfc_d); \ | |
| 402 } \ | |
| 403 else \ | |
| 404 frame_changed = 1; \ | |
| 405 } while (0) | |
| 406 | |
| 905 | 407 #define MARK_FRAME_LAYOUT_CHANGED(f) do { \ |
| 408 struct frame *mfc_f = (f); \ | |
| 409 mfc_f->frame_layout_changed = 1; \ | |
| 410 mfc_f->modiff++; \ | |
| 411 if (!NILP (mfc_f->device)) \ | |
| 412 { \ | |
| 413 struct device *mfc_d = XDEVICE (mfc_f->device); \ | |
| 414 MARK_DEVICE_FRAME_LAYOUT_CHANGED (mfc_d); \ | |
| 415 } \ | |
| 416 else \ | |
| 417 frame_layout_changed = 1; \ | |
| 418 } while (0) | |
| 419 | |
| 872 | 420 #define MARK_FRAME_WINDOWS_CHANGED(f) do { \ |
| 421 struct frame *mfwc_f = (f); \ | |
| 422 mfwc_f->windows_changed = 1; \ | |
| 423 mfwc_f->modiff++; \ | |
| 424 if (!NILP (mfwc_f->device)) \ | |
| 425 { \ | |
| 426 struct device *mfwc_d = XDEVICE (mfwc_f->device); \ | |
| 427 MARK_DEVICE_WINDOWS_CHANGED (mfwc_d); \ | |
| 428 } \ | |
| 429 else \ | |
| 430 windows_changed = 1; \ | |
| 431 } while (0) | |
| 432 | |
| 433 #define MARK_FRAME_WINDOWS_STRUCTURE_CHANGED(f) do { \ | |
| 434 struct frame *fwsc_f = (f); \ | |
| 435 fwsc_f->windows_structure_changed = 1; \ | |
| 436 fwsc_f->modiff++; \ | |
| 437 if (!NILP (fwsc_f->device)) \ | |
| 438 { \ | |
| 439 struct device *fwsc_d = XDEVICE (fwsc_f->device); \ | |
| 440 MARK_DEVICE_WINDOWS_STRUCTURE_CHANGED (fwsc_d); \ | |
| 441 } \ | |
| 442 else \ | |
| 443 windows_structure_changed = 1; \ | |
| 444 invalidate_vertical_divider_cache_in_frame (fwsc_f); \ | |
| 445 } while (0) | |
| 446 | |
| 447 #define MARK_FRAME_SIZE_SLIPPED(f) do { \ | |
| 448 struct frame *fwsc_f = (f); \ | |
| 449 fwsc_f->size_slipped = 1; \ | |
| 450 fwsc_f->modiff++; \ | |
| 451 if (!NILP (fwsc_f->device)) \ | |
| 452 { \ | |
| 453 struct device *fwsc_d = XDEVICE (fwsc_f->device); \ | |
| 454 MARK_DEVICE_FRAME_CHANGED (fwsc_d); \ | |
| 455 } \ | |
| 456 else \ | |
| 457 frame_changed = 1; \ | |
| 458 } while (0) | |
| 459 | |
| 460 #define CLEAR_FRAME_SIZE_SLIPPED(f) do { \ | |
| 461 struct frame *fwsc_f = (f); \ | |
| 462 fwsc_f->size_slipped = 0; \ | |
| 463 } while (0) | |
| 464 | |
| 465 #define SET_FRAME_CLEAR(f) MARK_FRAME_CHANGED (f); (f)->clear = 1 | |
| 466 | |
| 467 #define FRAME_MINIBUF_ONLY_P(f) \ | |
| 468 EQ (FRAME_ROOT_WINDOW (f), FRAME_MINIBUF_WINDOW (f)) | |
| 469 #define FRAME_HAS_MINIBUF_P(f) ((f)->has_minibuffer) | |
| 470 #define FRAME_HEIGHT(f) ((f)->height) | |
| 471 #define FRAME_WIDTH(f) ((f)->width) | |
| 472 #define FRAME_CHARHEIGHT(f) ((f)->char_height) | |
| 473 #define FRAME_CHARWIDTH(f) ((f)->char_width) | |
| 474 #define FRAME_PIXHEIGHT(f) ((f)->pixheight) | |
| 475 #define FRAME_PIXWIDTH(f) ((f)->pixwidth) | |
| 476 #define FRAME_PAGENUMBER(f) ((f)->page_number + 0) | |
| 477 #define FRAME_SET_PAGENUMBER(f,x) (f)->page_number = (x); | |
| 478 #ifdef HAVE_SCROLLBARS | |
| 479 #define FRAME_SCROLLBAR_WIDTH(f) \ | |
| 480 (NILP ((f)->vertical_scrollbar_visible_p) ? \ | |
| 481 0 : XINT ((f)->scrollbar_width)) | |
| 482 #define FRAME_SCROLLBAR_HEIGHT(f) \ | |
| 483 (NILP ((f)->horizontal_scrollbar_visible_p) ? \ | |
| 484 0 : XINT ((f)->scrollbar_height)) | |
| 485 #else | |
| 486 #define FRAME_SCROLLBAR_WIDTH(f) 0 | |
| 487 #define FRAME_SCROLLBAR_HEIGHT(f) 0 | |
| 488 #endif | |
| 489 | |
| 490 #define FRAME_NEW_HEIGHT(f) ((f)->new_height) | |
| 491 #define FRAME_NEW_WIDTH(f) ((f)->new_width) | |
| 492 #define FRAME_CURSOR_X(f) ((f)->cursor_x) | |
| 493 #define FRAME_CURSOR_Y(f) ((f)->cursor_y) | |
| 494 #define FRAME_VISIBLE_P(f) ((f)->visible) | |
| 495 #define FRAME_REPAINT_P(f) ((f)->visible>0) | |
| 496 #define FRAME_NO_SPLIT_P(f) ((f)->no_split) | |
| 497 #define FRAME_ICONIFIED_P(f) ((f)->iconified) | |
| 498 #define FRAME_FOCUS_FRAME(f) ((f)->focus_frame) | |
| 499 #define FRAME_MINIBUF_WINDOW(f) ((f)->minibuffer_window) | |
| 500 #define FRAME_ROOT_WINDOW(f) ((f)->root_window) | |
| 501 /* Catch people attempting to set this. */ | |
| 502 #define FRAME_SELECTED_WINDOW(f) NON_LVALUE ((f)->selected_window) | |
| 503 #define FRAME_SELECTED_XWINDOW(f) XWINDOW (FRAME_SELECTED_WINDOW (f)) | |
| 504 #define FRAME_LAST_NONMINIBUF_WINDOW(f) \ | |
| 505 NON_LVALUE ((f)->last_nonminibuf_window) | |
| 506 #define FRAME_SB_VCACHE(f) ((f)->sb_vcache) | |
| 507 #define FRAME_SB_HCACHE(f) ((f)->sb_hcache) | |
| 508 #define FRAME_SUBWINDOW_CACHE(f) ((f)->subwindow_instance_cache) | |
| 509 | |
| 510 #if 0 /* FSFmacs */ | |
| 511 | |
| 512 #define FRAME_VISIBLE_P(f) ((f)->visible != 0) | |
| 513 #define FRAME_SET_VISIBLE(f,p) \ | |
| 514 ((f)->async_visible = (p), FRAME_SAMPLE_VISIBILITY (f)) | |
| 515 | |
| 516 /* Emacs's redisplay code could become confused if a frame's | |
| 517 visibility changes at arbitrary times. For example, if a frame is | |
| 518 visible while the desired glyphs are being built, but becomes | |
| 519 invisible before they are updated, then some rows of the | |
| 520 desired_glyphs will be left marked as enabled after redisplay is | |
| 521 complete, which should never happen. The next time the frame | |
| 522 becomes visible, redisplay will probably barf. | |
| 523 | |
| 524 Currently, there are no similar situations involving iconified, but | |
| 525 the principle is the same. | |
| 526 | |
| 527 So instead of having asynchronous input handlers directly set and | |
| 528 clear the frame's visibility and iconification flags, they just set | |
| 529 the async_visible and async_iconified flags; the redisplay code | |
| 530 calls the FRAME_SAMPLE_VISIBILITY macro before doing any redisplay, | |
| 531 which sets visible and iconified from their asynchronous | |
| 532 counterparts. | |
| 533 | |
| 534 Synchronous code must use the FRAME_SET_VISIBLE macro. | |
| 535 | |
| 536 Also, if a frame used to be invisible, but has just become visible, | |
| 537 it must be marked as garbaged, since redisplay hasn't been keeping | |
| 538 up its contents. */ | |
| 539 #define FRAME_SAMPLE_VISIBILITY(f) \ | |
| 540 (((f)->async_visible && ! (f)->visible) ? SET_FRAME_GARBAGED (f) : 0, \ | |
| 541 (f)->visible = (f)->async_visible, \ | |
| 542 (f)->iconified = (f)->async_iconified) | |
| 543 | |
| 544 #endif /* FSFmacs */ | |
| 545 | |
| 5045 | 546 #define FRAME_INTERNAL_BORDER_WIDTH(f) ((f)->internal_border_width) |
| 547 #define FRAME_INTERNAL_BORDER_HEIGHT(f) ((f)->internal_border_width) | |
| 548 #define FRAME_INTERNAL_BORDER_SIZE(f, pos) ((f)->internal_border_width) | |
| 549 | |
| 550 /************************************************************************/ | |
| 551 /* toolbars */ | |
| 552 /************************************************************************/ | |
| 553 | |
| 554 /*---------------- Theoretical and real toolbar values ----------------*/ | |
| 555 | |
| 872 | 556 |
| 557 /* This returns the frame-local value; that tells you what you should | |
| 558 use when computing the frame size. It is *not* the actual toolbar | |
| 559 size because that depends on the selected window. Use the macros | |
| 560 below for that. | |
| 561 */ | |
| 562 | |
| 563 #ifdef HAVE_TOOLBARS | |
| 564 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) \ | |
| 565 (!NILP((f)->toolbar_buttons[pos]) && !NILP ((f)->toolbar_visible_p[pos])) | |
| 566 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) \ | |
| 567 (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_size[pos]) ? \ | |
| 568 (XINT ((f)->toolbar_size[pos])) : 0) | |
| 569 #define FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) \ | |
| 570 (!NILP ((f)->toolbar_buttons[pos]) && INTP((f)->toolbar_border_width[pos]) ? \ | |
| 571 (XINT ((f)->toolbar_border_width[pos])) : 0) | |
| 572 #else | |
| 573 #define FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE(f, pos) 0 | |
| 574 #define FRAME_RAW_THEORETICAL_TOOLBAR_SIZE(f, pos) 0 | |
| 575 #define FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) 0 | |
| 576 #endif | |
| 577 | |
| 578 #define FRAME_THEORETICAL_TOOLBAR_SIZE(f, pos) \ | |
| 579 (FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE (f, pos) \ | |
| 580 ? FRAME_RAW_THEORETICAL_TOOLBAR_SIZE (f, pos) \ | |
| 581 : 0) | |
| 582 | |
| 583 #define FRAME_THEORETICAL_TOP_TOOLBAR_HEIGHT(f) \ | |
| 584 FRAME_THEORETICAL_TOOLBAR_SIZE (f, TOP_TOOLBAR) | |
| 585 #define FRAME_THEORETICAL_BOTTOM_TOOLBAR_HEIGHT(f) \ | |
| 586 FRAME_THEORETICAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR) | |
| 587 #define FRAME_THEORETICAL_LEFT_TOOLBAR_WIDTH(f) \ | |
| 588 FRAME_THEORETICAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR) | |
| 589 #define FRAME_THEORETICAL_RIGHT_TOOLBAR_WIDTH(f) \ | |
| 590 FRAME_THEORETICAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR) | |
| 591 | |
| 592 #define FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH(f, pos) \ | |
| 593 (FRAME_RAW_THEORETICAL_TOOLBAR_VISIBLE (f, pos) \ | |
| 594 ? FRAME_RAW_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, pos) \ | |
| 595 : 0) | |
| 596 | |
| 597 #define FRAME_THEORETICAL_TOP_TOOLBAR_BORDER_WIDTH(f) \ | |
| 598 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, TOP_TOOLBAR) | |
| 599 #define FRAME_THEORETICAL_BOTTOM_TOOLBAR_BORDER_WIDTH(f) \ | |
| 600 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, BOTTOM_TOOLBAR) | |
| 601 #define FRAME_THEORETICAL_LEFT_TOOLBAR_BORDER_WIDTH(f) \ | |
| 602 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, LEFT_TOOLBAR) | |
| 603 #define FRAME_THEORETICAL_RIGHT_TOOLBAR_BORDER_WIDTH(f) \ | |
| 604 FRAME_THEORETICAL_TOOLBAR_BORDER_WIDTH (f, RIGHT_TOOLBAR) | |
| 605 | |
| 606 /* This returns the window-local value rather than the frame-local value; | |
| 607 that tells you about what's actually visible rather than what should | |
| 608 be used when computing the frame size. */ | |
| 609 | |
| 610 #ifdef HAVE_TOOLBARS | |
| 611 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) \ | |
| 612 (HAS_FRAMEMETH_P (f, initialize_frame_toolbars) \ | |
| 613 && !NILP (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_visible_p[pos])) | |
| 614 #define FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH(f, pos) \ | |
| 615 ((INTP (XWINDOW \ | |
| 616 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) ? \ | |
| 617 (XINT (XWINDOW \ | |
| 618 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_border_width[pos])) \ | |
| 619 : 0) | |
| 620 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) \ | |
| 621 ((INTP (XWINDOW \ | |
| 622 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) ? \ | |
| 623 (XINT (XWINDOW \ | |
| 624 (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar_size[pos])) : 0) | |
| 625 #define FRAME_REAL_TOOLBAR(f, pos) \ | |
| 626 (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->toolbar[pos]) | |
| 627 #else | |
| 628 #define FRAME_RAW_REAL_TOOLBAR_VISIBLE(f, pos) 0 | |
| 629 #define FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH(f, pos) 0 | |
| 630 #define FRAME_RAW_REAL_TOOLBAR_SIZE(f, pos) 0 | |
| 631 #define FRAME_REAL_TOOLBAR(f, pos) Qnil | |
| 632 #endif | |
| 633 | |
| 634 /* Note to Chuck | |
| 635 Note to Chuck | |
| 636 Note to Chuck: | |
| 637 | |
| 638 The former definitions of FRAME_REAL_FOO_TOOLBAR_VISIBLE | |
| 639 looked at the toolbar data to see what was there. The | |
| 640 current ones look at the current values of the specifiers. | |
| 641 This is a semantic change; the former definition returned | |
| 642 what was *actually* there right at the moment, while the | |
| 643 current one returns what *ought* to be there once redisplay | |
| 644 has run to completion. I think this new definition is more | |
| 645 correct in almost all circumstances and is much less likely | |
| 646 to lead to strange race conditions. I'm not completely | |
| 647 sure that there aren't some places in the redisplay code | |
| 648 that use these macros and expect the former semantics, so | |
| 649 if you encounter some odd toolbar behavior, you might want | |
| 650 to look into this. --ben */ | |
| 651 | |
| 652 #define FRAME_REAL_TOOLBAR_VISIBLE(f, pos) \ | |
| 653 ((!NILP (FRAME_REAL_TOOLBAR (f, pos)) \ | |
| 654 && FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos) > 0) \ | |
| 655 ? FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos) \ | |
| 656 : 0) | |
| 657 #define FRAME_REAL_TOOLBAR_SIZE(f, pos) \ | |
| 658 ((!NILP (FRAME_REAL_TOOLBAR (f, pos)) \ | |
| 659 && FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos)) \ | |
| 660 ? FRAME_RAW_REAL_TOOLBAR_SIZE (f, pos) \ | |
| 661 : 0) | |
| 662 #define FRAME_REAL_TOOLBAR_BORDER_WIDTH(f, pos) \ | |
| 663 ((!NILP (FRAME_REAL_TOOLBAR (f, pos)) \ | |
| 664 && FRAME_RAW_REAL_TOOLBAR_VISIBLE (f, pos)) \ | |
| 665 ? FRAME_RAW_REAL_TOOLBAR_BORDER_WIDTH (f, pos) \ | |
| 666 : 0) | |
| 667 | |
| 5045 | 668 #define FRAME_REAL_TOOLBAR_BOUNDS(f, pos) \ |
| 669 (FRAME_REAL_TOOLBAR_SIZE (f, pos) + \ | |
| 670 2 * FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, pos)) | |
| 671 | |
| 872 | 672 #define FRAME_REAL_TOP_TOOLBAR_HEIGHT(f) \ |
| 673 FRAME_REAL_TOOLBAR_SIZE (f, TOP_TOOLBAR) | |
| 674 #define FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT(f) \ | |
| 675 FRAME_REAL_TOOLBAR_SIZE (f, BOTTOM_TOOLBAR) | |
| 676 #define FRAME_REAL_LEFT_TOOLBAR_WIDTH(f) \ | |
| 677 FRAME_REAL_TOOLBAR_SIZE (f, LEFT_TOOLBAR) | |
| 678 #define FRAME_REAL_RIGHT_TOOLBAR_WIDTH(f) \ | |
| 679 FRAME_REAL_TOOLBAR_SIZE (f, RIGHT_TOOLBAR) | |
| 680 | |
| 681 #define FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH(f) \ | |
| 682 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, TOP_TOOLBAR) | |
| 683 #define FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH(f) \ | |
| 684 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, BOTTOM_TOOLBAR) | |
| 685 #define FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH(f) \ | |
| 686 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, LEFT_TOOLBAR) | |
| 687 #define FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH(f) \ | |
| 688 FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, RIGHT_TOOLBAR) | |
| 689 | |
| 690 #define FRAME_REAL_TOP_TOOLBAR_VISIBLE(f) \ | |
| 691 FRAME_REAL_TOOLBAR_VISIBLE (f, TOP_TOOLBAR) | |
| 692 #define FRAME_REAL_BOTTOM_TOOLBAR_VISIBLE(f) \ | |
| 693 FRAME_REAL_TOOLBAR_VISIBLE (f, BOTTOM_TOOLBAR) | |
| 694 #define FRAME_REAL_LEFT_TOOLBAR_VISIBLE(f) \ | |
| 695 FRAME_REAL_TOOLBAR_VISIBLE (f, LEFT_TOOLBAR) | |
| 696 #define FRAME_REAL_RIGHT_TOOLBAR_VISIBLE(f) \ | |
| 697 FRAME_REAL_TOOLBAR_VISIBLE (f, RIGHT_TOOLBAR) | |
| 698 | |
| 5045 | 699 #define FRAME_REAL_TOP_TOOLBAR_BOUNDS(f) \ |
| 700 FRAME_REAL_TOOLBAR_BOUNDS (f, TOP_TOOLBAR) | |
| 701 #define FRAME_REAL_BOTTOM_TOOLBAR_BOUNDS(f) \ | |
| 702 FRAME_REAL_TOOLBAR_BOUNDS (f, BOTTOM_TOOLBAR) | |
| 703 #define FRAME_REAL_LEFT_TOOLBAR_BOUNDS(f) \ | |
| 704 FRAME_REAL_TOOLBAR_BOUNDS (f, LEFT_TOOLBAR) | |
| 705 #define FRAME_REAL_RIGHT_TOOLBAR_BOUNDS(f) \ | |
| 706 FRAME_REAL_TOOLBAR_BOUNDS (f, RIGHT_TOOLBAR) | |
| 707 | |
| 708 /************************************************************************/ | |
| 709 /* frame dimensions defined using toolbars and gutters */ | |
| 710 /************************************************************************/ | |
| 711 | |
| 712 /* #### These should be using the gutter sizes, but aren't yet */ | |
| 713 | |
| 872 | 714 #define FRAME_TOP_BORDER_START(f) \ |
| 5045 | 715 FRAME_REAL_TOP_TOOLBAR_BOUNDS (f) |
| 872 | 716 #define FRAME_TOP_BORDER_END(f) \ |
| 5045 | 717 (FRAME_TOP_BORDER_START (f) + FRAME_INTERNAL_BORDER_HEIGHT (f)) |
| 872 | 718 |
| 719 #define FRAME_BOTTOM_BORDER_START(f) \ | |
| 5045 | 720 (FRAME_BOTTOM_BORDER_END (f) - FRAME_INTERNAL_BORDER_HEIGHT (f)) |
| 872 | 721 #define FRAME_BOTTOM_BORDER_END(f) \ |
| 5045 | 722 (FRAME_PIXHEIGHT (f) - FRAME_REAL_BOTTOM_TOOLBAR_BOUNDS (f)) |
| 872 | 723 |
| 724 #define FRAME_LEFT_BORDER_START(f) \ | |
| 5045 | 725 FRAME_REAL_LEFT_TOOLBAR_BOUNDS (f) |
| 872 | 726 #define FRAME_LEFT_BORDER_END(f) \ |
| 5045 | 727 (FRAME_LEFT_BORDER_START (f) + FRAME_INTERNAL_BORDER_WIDTH (f)) |
| 872 | 728 |
| 729 #define FRAME_RIGHT_BORDER_START(f) \ | |
| 5045 | 730 (FRAME_RIGHT_BORDER_END (f) - FRAME_INTERNAL_BORDER_WIDTH (f)) |
| 872 | 731 #define FRAME_RIGHT_BORDER_END(f) \ |
| 5045 | 732 (FRAME_PIXWIDTH (f) - FRAME_REAL_RIGHT_TOOLBAR_BOUNDS (f)) |
| 872 | 733 |
| 734 #endif /* INCLUDED_frame_impl_h_ */ |