Mercurial > hg > xemacs-beta
annotate src/toolbar.c @ 5124:623d57b7fbe8 ben-lisp-object
separate regular and disksave finalization, print method fixes.
Create separate disksave method and make the finalize method only be for
actual object finalization, not disksave finalization.
Fix places where 0 was given in place of a printer -- print methods are
mandatory, and internal objects formerly without a print method now must
explicitly specify internal_object_printer().
Change the defn of CONSOLE_LIVE_P to avoid problems in some weird situations.
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-01-20 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (very_old_free_lcrecord):
* alloc.c (disksave_object_finalization_1):
* alloc.c (make_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* buffer.c:
* bytecode.c:
* bytecode.c (Fcompiled_function_p):
* chartab.c:
* console-impl.h:
* console-impl.h (CONSOLE_TYPE_P):
* console.c:
* console.c (set_quit_events):
* data.c:
* data.c (Fmake_ephemeron):
* database.c:
* database.c (finalize_database):
* database.c (Fclose_database):
* device-msw.c:
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device.c:
* elhash.c:
* elhash.c (finalize_hash_table):
* eval.c:
* eval.c (bind_multiple_value_limits):
* event-stream.c:
* event-stream.c (finalize_command_builder):
* events.c:
* events.c (mark_event):
* extents.c:
* extents.c (finalize_extent_info):
* extents.c (uninit_buffer_extents):
* faces.c:
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.h:
* file-coding.h (struct coding_system_methods):
* file-coding.h (struct detector):
* floatfns.c:
* floatfns.c (extract_float):
* fns.c:
* fns.c (Fidentity):
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (finalize_fc_config):
* frame.c:
* glyphs.c:
* glyphs.c (finalize_image_instance):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* gui.c:
* gui.c (gui_error):
* keymap.c:
* lisp.h (struct Lisp_Symbol):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE):
* lrecord.h (DEFINE_DUMPABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_FROB_BLOCK_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_INTERNAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_SIZABLE_INTERNAL_LISP_OBJECT):
* lrecord.h (MAKE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_GENERAL_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_LISP_OBJECT):
* lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_GENERAL_LISP_OBJECT):
* lrecord.h (MAKE_MODULE_LISP_OBJECT):
* lstream.c:
* lstream.c (finalize_lstream):
* lstream.c (disksave_lstream):
* marker.c:
* marker.c (finalize_marker):
* mule-charset.c (make_charset):
* number.c:
* objects.c:
* objects.c (finalize_color_instance):
* objects.c (finalize_font_instance):
* opaque.c:
* opaque.c (make_opaque_ptr):
* process-nt.c:
* process-nt.c (nt_finalize_process_data):
* process-nt.c (nt_deactivate_process):
* process.c:
* process.c (finalize_process):
* procimpl.h (struct process_methods):
* scrollbar.c:
* scrollbar.c (free_scrollbar_instance):
* specifier.c (finalize_specifier):
* symbols.c:
* toolbar.c:
* toolbar.c (Ftoolbar_button_p):
* tooltalk.c:
* ui-gtk.c:
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* window.c:
* window.c (finalize_window):
* window.c (mark_window_as_deleted):
Separate out regular and disksave finalization. Instead of a
FOR_DISKSAVE argument to the finalizer, create a separate object
method `disksaver'. Make `finalizer' have only one argument.
Go through and separate out all finalize methods into finalize
and disksave. Delete lots of thereby redundant disksave checking.
Delete places that signal an error if we attempt to disksave --
all of these objects are non-dumpable and we will get an error
from pdump anyway if we attempt to dump them. After this is done,
only one object remains that has a disksave method -- lstream.
Change DEFINE_*_LISP_OBJECT_WITH_PROPS to DEFINE_*_GENERAL_LISP_OBJECT,
which is used for specifying either property methods or disksave
methods (or in the future, any other less-used methods).
Remove the for_disksave argument to finalize_process_data. Don't
provide a disksaver for processes because no one currently needs
it.
Clean up various places where objects didn't provide a print method.
It was made mandatory in previous changes, and all methods now
either provide their own print method or use internal_object_printer
or external_object_printer.
Change the definition of CONSOLE_LIVE_P to use the contype enum
rather than looking into the conmeths structure -- in some weird
situations with dead objects, the conmeths structure is NULL,
and printing such objects from debug_print() will crash if we try
to look into the conmeths structure.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Wed, 20 Jan 2010 07:05:57 -0600 |
| parents | e0db3c197671 |
| children | 2a462149bd6a |
| rev | line source |
|---|---|
| 428 | 1 /* Generic toolbar implementation. |
| 2 Copyright (C) 1995 Board of Trustees, University of Illinois. | |
| 3 Copyright (C) 1995 Sun Microsystems, Inc. | |
| 2367 | 4 Copyright (C) 1995, 1996, 2003, 2004 Ben Wing. |
| 428 | 5 Copyright (C) 1996 Chuck Thompson. |
| 6 | |
| 7 This file is part of XEmacs. | |
| 8 | |
| 9 XEmacs is free software; you can redistribute it and/or modify it | |
| 10 under the terms of the GNU General Public License as published by the | |
| 11 Free Software Foundation; either version 2, or (at your option) any | |
| 12 later version. | |
| 13 | |
| 14 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 17 for more details. | |
| 18 | |
| 19 You should have received a copy of the GNU General Public License | |
| 20 along with XEmacs; see the file COPYING. If not, write to | |
| 21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 22 Boston, MA 02111-1307, USA. */ | |
| 23 | |
| 24 /* Synched up with: Not in FSF. */ | |
| 25 | |
| 26 /* Original implementation by Chuck Thompson for 19.12. | |
| 27 Default-toolbar-position and specifier-related stuff by Ben Wing. */ | |
| 28 | |
| 29 #include <config.h> | |
| 30 #include "lisp.h" | |
| 31 | |
| 32 #include "buffer.h" | |
| 872 | 33 #include "frame-impl.h" |
| 34 #include "device-impl.h" | |
| 428 | 35 #include "glyphs.h" |
| 36 #include "redisplay.h" | |
| 37 #include "toolbar.h" | |
| 38 #include "window.h" | |
| 39 | |
| 40 Lisp_Object Vtoolbar[4]; | |
| 41 Lisp_Object Vtoolbar_size[4]; | |
| 42 Lisp_Object Vtoolbar_visible_p[4]; | |
| 43 Lisp_Object Vtoolbar_border_width[4]; | |
| 44 | |
| 45 Lisp_Object Vdefault_toolbar, Vdefault_toolbar_visible_p; | |
| 46 Lisp_Object Vdefault_toolbar_width, Vdefault_toolbar_height; | |
| 47 Lisp_Object Vdefault_toolbar_border_width; | |
| 744 | 48 Lisp_Object Vtoolbar_shadow_thickness; |
| 428 | 49 |
| 50 Lisp_Object Vdefault_toolbar_position; | |
| 51 Lisp_Object Vtoolbar_buttons_captioned_p; | |
| 52 | |
| 53 Lisp_Object Qtoolbar_buttonp; | |
| 54 Lisp_Object Q2D, Q3D, Q2d, Q3d; | |
| 55 Lisp_Object Q_size; | |
| 56 | |
| 57 Lisp_Object Qinit_toolbar_from_resources; | |
| 58 | |
| 1204 | 59 static const struct memory_description toolbar_button_description [] = { |
| 934 | 60 { XD_LISP_OBJECT, offsetof (struct toolbar_button, next) }, |
| 61 { XD_LISP_OBJECT, offsetof (struct toolbar_button, frame) }, | |
| 62 { XD_LISP_OBJECT, offsetof (struct toolbar_button, up_glyph) }, | |
| 63 { XD_LISP_OBJECT, offsetof (struct toolbar_button, down_glyph) }, | |
| 64 { XD_LISP_OBJECT, offsetof (struct toolbar_button, disabled_glyph) }, | |
| 65 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_up_glyph) }, | |
| 66 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_down_glyph) }, | |
| 67 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_disabled_glyph) }, | |
| 68 { XD_LISP_OBJECT, offsetof (struct toolbar_button, callback) }, | |
| 69 { XD_LISP_OBJECT, offsetof (struct toolbar_button, enabled_p) }, | |
| 70 { XD_LISP_OBJECT, offsetof (struct toolbar_button, help_string) }, | |
| 71 { XD_END } | |
| 72 }; | |
| 428 | 73 |
| 74 static Lisp_Object | |
| 75 mark_toolbar_button (Lisp_Object obj) | |
| 76 { | |
| 77 struct toolbar_button *data = XTOOLBAR_BUTTON (obj); | |
| 78 mark_object (data->next); | |
| 79 mark_object (data->frame); | |
| 80 mark_object (data->up_glyph); | |
| 81 mark_object (data->down_glyph); | |
| 82 mark_object (data->disabled_glyph); | |
| 83 mark_object (data->cap_up_glyph); | |
| 84 mark_object (data->cap_down_glyph); | |
| 85 mark_object (data->cap_disabled_glyph); | |
| 86 mark_object (data->callback); | |
| 87 mark_object (data->enabled_p); | |
| 88 return data->help_string; | |
| 89 } | |
| 90 | |
|
5124
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
91 DEFINE_NODUMP_INTERNAL_LISP_OBJECT ("toolbar-button", toolbar_button, |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
92 mark_toolbar_button, |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
93 toolbar_button_description, |
|
623d57b7fbe8
separate regular and disksave finalization, print method fixes.
Ben Wing <ben@xemacs.org>
parents:
5118
diff
changeset
|
94 struct toolbar_button); |
| 428 | 95 |
| 96 DEFUN ("toolbar-button-p", Ftoolbar_button_p, 1, 1, 0, /* | |
| 97 Return non-nil if OBJECT is a toolbar button. | |
| 98 */ | |
| 99 (object)) | |
| 100 { | |
| 101 return TOOLBAR_BUTTONP (object) ? Qt : Qnil; | |
| 102 } | |
| 103 | |
| 104 /* Only query functions are provided for toolbar buttons. They are | |
| 105 generated and updated from a toolbar description list. Any | |
| 106 directly made changes would be wiped out the first time the toolbar | |
| 107 was marked as dirty and was regenerated. The exception to this is | |
| 108 set-toolbar-button-down-flag. Having this allows us to control the | |
| 109 toolbar from elisp. Since we only trigger the button callbacks on | |
| 110 up-mouse events and we reset the flag first, there shouldn't be any | |
| 111 way for this to get us in trouble (like if someone decides to | |
| 112 change the toolbar from a toolbar callback). */ | |
| 113 | |
| 114 DEFUN ("toolbar-button-callback", Ftoolbar_button_callback, 1, 1, 0, /* | |
| 115 Return the callback function associated with the toolbar BUTTON. | |
| 116 */ | |
| 117 (button)) | |
| 118 { | |
| 119 CHECK_TOOLBAR_BUTTON (button); | |
| 120 | |
| 121 return XTOOLBAR_BUTTON (button)->callback; | |
| 122 } | |
| 123 | |
| 124 DEFUN ("toolbar-button-help-string", Ftoolbar_button_help_string, 1, 1, 0, /* | |
| 125 Return the help string function associated with the toolbar BUTTON. | |
| 126 */ | |
| 127 (button)) | |
| 128 { | |
| 129 CHECK_TOOLBAR_BUTTON (button); | |
| 130 | |
| 131 return XTOOLBAR_BUTTON (button)->help_string; | |
| 132 } | |
| 133 | |
| 134 DEFUN ("toolbar-button-enabled-p", Ftoolbar_button_enabled_p, 1, 1, 0, /* | |
| 135 Return t if BUTTON is active. | |
| 136 */ | |
| 137 (button)) | |
| 138 { | |
| 139 CHECK_TOOLBAR_BUTTON (button); | |
| 140 | |
| 141 return XTOOLBAR_BUTTON (button)->enabled ? Qt : Qnil; | |
| 142 } | |
| 143 | |
| 144 DEFUN ("set-toolbar-button-down-flag", Fset_toolbar_button_down_flag, 2, 2, 0, /* | |
| 145 Don't touch. | |
| 146 */ | |
| 147 (button, flag)) | |
| 148 { | |
| 149 struct toolbar_button *tb; | |
| 150 char old_flag; | |
| 151 | |
| 152 CHECK_TOOLBAR_BUTTON (button); | |
| 153 tb = XTOOLBAR_BUTTON (button); | |
| 154 old_flag = tb->down; | |
| 155 | |
| 156 /* If the button is ignored, don't do anything. */ | |
| 157 if (!tb->enabled) | |
| 158 return Qnil; | |
| 159 | |
| 160 /* If flag is nil, unset the down flag, otherwise set it to true. | |
| 161 This also triggers an immediate redraw of the button if the flag | |
| 162 does change. */ | |
| 163 | |
| 164 if (NILP (flag)) | |
| 165 tb->down = 0; | |
| 166 else | |
| 167 tb->down = 1; | |
| 168 | |
| 169 if (tb->down != old_flag) | |
| 170 { | |
| 171 struct frame *f = XFRAME (tb->frame); | |
| 172 struct device *d; | |
| 173 | |
| 174 if (DEVICEP (f->device)) | |
| 175 { | |
| 176 d = XDEVICE (f->device); | |
| 177 | |
| 178 if (DEVICE_LIVE_P (XDEVICE (f->device))) | |
| 179 { | |
| 180 tb->dirty = 1; | |
| 181 MAYBE_DEVMETH (d, output_toolbar_button, (f, button)); | |
| 182 } | |
| 183 } | |
| 184 } | |
| 185 | |
| 186 return Qnil; | |
| 187 } | |
| 188 | |
| 189 Lisp_Object | |
| 190 get_toolbar_button_glyph (struct window *w, struct toolbar_button *tb) | |
| 191 { | |
| 192 Lisp_Object glyph = Qnil; | |
| 193 | |
| 194 /* The selected glyph logic: | |
| 195 | |
| 196 UP: up | |
| 197 DOWN: down -> up | |
| 198 DISABLED: disabled -> up | |
| 199 CAP-UP: cap-up -> up | |
| 200 CAP-DOWN: cap-down -> cap-up -> down -> up | |
| 201 CAP-DISABLED: cap-disabled -> cap-up -> disabled -> up | |
| 202 */ | |
| 203 | |
| 204 if (!NILP (w->toolbar_buttons_captioned_p)) | |
| 205 { | |
| 206 if (tb->enabled && tb->down) | |
| 207 glyph = tb->cap_down_glyph; | |
| 208 else if (!tb->enabled) | |
| 209 glyph = tb->cap_disabled_glyph; | |
| 210 | |
| 211 if (NILP (glyph)) | |
| 212 glyph = tb->cap_up_glyph; | |
| 213 } | |
| 214 | |
| 215 if (NILP (glyph)) | |
| 216 { | |
| 217 if (tb->enabled && tb->down) | |
| 218 glyph = tb->down_glyph; | |
| 219 else if (!tb->enabled) | |
| 220 glyph = tb->disabled_glyph; | |
| 221 } | |
| 222 | |
| 223 /* The non-captioned up button is the ultimate fallback. It is | |
| 224 the only one we guarantee exists. */ | |
| 225 if (NILP (glyph)) | |
| 226 glyph = tb->up_glyph; | |
| 227 | |
| 228 return glyph; | |
| 229 } | |
| 230 | |
| 231 | |
| 232 static enum toolbar_pos | |
| 233 decode_toolbar_position (Lisp_Object position) | |
| 234 { | |
| 235 if (EQ (position, Qtop)) return TOP_TOOLBAR; | |
| 236 if (EQ (position, Qbottom)) return BOTTOM_TOOLBAR; | |
| 237 if (EQ (position, Qleft)) return LEFT_TOOLBAR; | |
| 238 if (EQ (position, Qright)) return RIGHT_TOOLBAR; | |
| 563 | 239 invalid_constant ("Invalid toolbar position", position); |
| 428 | 240 |
| 1204 | 241 RETURN_NOT_REACHED (TOP_TOOLBAR); |
| 428 | 242 } |
| 243 | |
| 244 DEFUN ("set-default-toolbar-position", Fset_default_toolbar_position, 1, 1, 0, /* | |
| 245 Set the position that the `default-toolbar' will be displayed at. | |
| 3025 | 246 Valid positions are `top', `bottom', `left' and `right'. |
| 428 | 247 See `default-toolbar-position'. |
| 248 */ | |
| 249 (position)) | |
| 250 { | |
| 251 enum toolbar_pos cur = decode_toolbar_position (Vdefault_toolbar_position); | |
| 3025 | 252 enum toolbar_pos new_ = decode_toolbar_position (position); |
| 428 | 253 |
| 3025 | 254 if (cur != new_) |
| 428 | 255 { |
| 256 /* The following calls will automatically cause the dirty | |
| 257 flags to be set; we delay frame size changes to avoid | |
| 258 lots of frame flickering. */ | |
| 1318 | 259 int depth = begin_hold_frame_size_changes (); |
| 428 | 260 set_specifier_fallback (Vtoolbar[cur], list1 (Fcons (Qnil, Qnil))); |
| 3025 | 261 set_specifier_fallback (Vtoolbar[new_], Vdefault_toolbar); |
| 428 | 262 set_specifier_fallback (Vtoolbar_size[cur], list1 (Fcons (Qnil, Qzero))); |
| 3025 | 263 set_specifier_fallback (Vtoolbar_size[new_], |
| 264 new_ == TOP_TOOLBAR || new_ == BOTTOM_TOOLBAR | |
| 428 | 265 ? Vdefault_toolbar_height |
| 266 : Vdefault_toolbar_width); | |
| 267 set_specifier_fallback (Vtoolbar_border_width[cur], | |
| 268 list1 (Fcons (Qnil, Qzero))); | |
| 3025 | 269 set_specifier_fallback (Vtoolbar_border_width[new_], |
| 428 | 270 Vdefault_toolbar_border_width); |
| 271 set_specifier_fallback (Vtoolbar_visible_p[cur], | |
| 272 list1 (Fcons (Qnil, Qt))); | |
| 3025 | 273 set_specifier_fallback (Vtoolbar_visible_p[new_], |
| 428 | 274 Vdefault_toolbar_visible_p); |
| 275 Vdefault_toolbar_position = position; | |
| 1318 | 276 unbind_to (depth); |
| 428 | 277 } |
| 278 | |
| 279 return position; | |
| 280 } | |
| 281 | |
| 282 DEFUN ("default-toolbar-position", Fdefault_toolbar_position, 0, 0, 0, /* | |
| 283 Return the position that the `default-toolbar' will be displayed at. | |
| 284 The `default-toolbar' will only be displayed here if the corresponding | |
| 285 position-specific toolbar specifier does not provide a value. | |
| 286 */ | |
| 287 ()) | |
| 288 { | |
| 289 return Vdefault_toolbar_position; | |
| 290 } | |
| 291 | |
| 292 | |
| 293 static Lisp_Object | |
| 294 update_toolbar_button (struct frame *f, struct toolbar_button *tb, | |
| 295 Lisp_Object desc, int pushright) | |
| 296 { | |
| 297 Lisp_Object *elt, glyphs, retval, buffer; | |
| 298 struct gcpro gcpro1, gcpro2; | |
| 299 | |
| 300 elt = XVECTOR_DATA (desc); | |
| 301 buffer = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->buffer; | |
| 302 | |
| 303 if (!tb) | |
| 304 { | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3025
diff
changeset
|
305 tb = XTOOLBAR_BUTTON (ALLOC_LISP_OBJECT (toolbar_button)); |
| 428 | 306 tb->next = Qnil; |
| 793 | 307 tb->frame = wrap_frame (f); |
| 428 | 308 tb->up_glyph = Qnil; |
| 309 tb->down_glyph = Qnil; | |
| 310 tb->disabled_glyph = Qnil; | |
| 311 tb->cap_up_glyph = Qnil; | |
| 312 tb->cap_down_glyph = Qnil; | |
| 313 tb->cap_disabled_glyph = Qnil; | |
| 314 tb->callback = Qnil; | |
| 315 tb->enabled_p = Qnil; | |
| 316 tb->help_string = Qnil; | |
| 317 | |
| 318 tb->enabled = 0; | |
| 319 tb->down = 0; | |
| 320 tb->pushright = pushright; | |
| 321 tb->blank = 0; | |
| 322 tb->x = tb->y = tb->width = tb->height = -1; | |
| 323 tb->dirty = 1; | |
| 324 } | |
| 793 | 325 retval = wrap_toolbar_button (tb); |
| 428 | 326 |
| 327 /* Let's make sure nothing gets mucked up by the potential call to | |
| 328 eval farther down. */ | |
| 329 GCPRO2 (retval, desc); | |
| 330 | |
| 331 glyphs = (CONSP (elt[0]) ? elt[0] : symbol_value_in_buffer (elt[0], buffer)); | |
| 332 | |
| 333 /* If this is true we have a blank, otherwise it is an actual | |
| 334 button. */ | |
| 335 if (KEYWORDP (glyphs)) | |
| 336 { | |
| 337 int pos; | |
| 338 int style_seen = 0; | |
| 339 int size_seen = 0; | |
| 340 int len = XVECTOR_LENGTH (desc); | |
| 341 | |
| 342 if (!tb->blank) | |
| 343 { | |
| 344 tb->blank = 1; | |
| 345 tb->dirty = 1; | |
| 346 } | |
| 347 | |
| 348 for (pos = 0; pos < len; pos += 2) | |
| 349 { | |
| 350 Lisp_Object key = elt[pos]; | |
| 351 Lisp_Object val = elt[pos + 1]; | |
| 352 | |
| 353 if (EQ (key, Q_style)) | |
| 354 { | |
| 355 style_seen = 1; | |
| 356 | |
| 357 if (EQ (val, Q2D) || EQ (val, Q2d)) | |
| 358 { | |
| 359 if (!EQ (Qnil, tb->up_glyph) || !EQ (Qt, tb->disabled_glyph)) | |
| 360 { | |
| 361 tb->up_glyph = Qnil; | |
| 362 tb->disabled_glyph = Qt; | |
| 363 tb->dirty = 1; | |
| 364 } | |
| 365 } | |
| 366 else if (EQ (val, Q3D) || (EQ (val, Q3d))) | |
| 367 { | |
| 368 if (!EQ (Qt, tb->up_glyph) || !EQ (Qnil, tb->disabled_glyph)) | |
| 369 { | |
| 370 tb->up_glyph = Qt; | |
| 371 tb->disabled_glyph = Qnil; | |
| 372 tb->dirty = 1; | |
| 373 } | |
| 374 } | |
| 375 } | |
| 376 else if (EQ (key, Q_size)) | |
| 377 { | |
| 378 size_seen = 1; | |
| 379 | |
| 380 if (!EQ (val, tb->down_glyph)) | |
| 381 { | |
| 382 tb->down_glyph = val; | |
| 383 tb->dirty = 1; | |
| 384 } | |
| 385 } | |
| 386 } | |
| 387 | |
| 388 if (!style_seen) | |
| 389 { | |
| 390 /* The default style is 3D. */ | |
| 391 if (!EQ (Qt, tb->up_glyph) || !EQ (Qnil, tb->disabled_glyph)) | |
| 392 { | |
| 393 tb->up_glyph = Qt; | |
| 394 tb->disabled_glyph = Qnil; | |
| 395 tb->dirty = 1; | |
| 396 } | |
| 397 } | |
| 398 | |
| 399 if (!size_seen) | |
| 400 { | |
| 401 /* The default width is set to nil. The device specific | |
| 402 code will fill it in at its discretion. */ | |
| 403 if (!NILP (tb->down_glyph)) | |
| 404 { | |
| 405 tb->down_glyph = Qnil; | |
| 406 tb->dirty = 1; | |
| 407 } | |
| 408 } | |
| 409 | |
| 410 /* The rest of these fields are not used by blanks. We make | |
| 411 sure they are nulled out in case this button object formerly | |
| 412 represented a real button. */ | |
| 413 if (!NILP (tb->callback) | |
| 414 || !NILP (tb->enabled_p) | |
| 415 || !NILP (tb->help_string)) | |
| 416 { | |
| 417 tb->cap_up_glyph = Qnil; | |
| 418 tb->cap_down_glyph = Qnil; | |
| 419 tb->cap_disabled_glyph = Qnil; | |
| 420 tb->callback = Qnil; | |
| 421 tb->enabled_p = Qnil; | |
| 422 tb->help_string = Qnil; | |
| 423 tb->dirty = 1; | |
| 424 } | |
| 425 } | |
| 426 else | |
| 427 { | |
| 428 if (tb->blank) | |
| 429 { | |
| 430 tb->blank = 0; | |
| 431 tb->dirty = 1; | |
| 432 } | |
| 433 | |
| 434 /* We know that we at least have an up_glyph. Well, no, we | |
| 435 don't. The user may have changed the button glyph on us. */ | |
| 436 if (CONSP (glyphs)) | |
| 437 { | |
| 438 if (!EQ (XCAR (glyphs), tb->up_glyph)) | |
| 439 { | |
| 440 tb->up_glyph = XCAR (glyphs); | |
| 441 tb->dirty = 1; | |
| 442 } | |
| 443 glyphs = XCDR (glyphs); | |
| 444 } | |
| 445 else | |
| 446 tb->up_glyph = Qnil; | |
| 447 | |
| 448 /* We might have a down_glyph. */ | |
| 449 if (CONSP (glyphs)) | |
| 450 { | |
| 451 if (!EQ (XCAR (glyphs), tb->down_glyph)) | |
| 452 { | |
| 453 tb->down_glyph = XCAR (glyphs); | |
| 454 tb->dirty = 1; | |
| 455 } | |
| 456 glyphs = XCDR (glyphs); | |
| 457 } | |
| 458 else | |
| 459 tb->down_glyph = Qnil; | |
| 460 | |
| 461 /* We might have a disabled_glyph. */ | |
| 462 if (CONSP (glyphs)) | |
| 463 { | |
| 464 if (!EQ (XCAR (glyphs), tb->disabled_glyph)) | |
| 465 { | |
| 466 tb->disabled_glyph = XCAR (glyphs); | |
| 467 tb->dirty = 1; | |
| 468 } | |
| 469 glyphs = XCDR (glyphs); | |
| 470 } | |
| 471 else | |
| 472 tb->disabled_glyph = Qnil; | |
| 473 | |
| 474 /* We might have a cap_up_glyph. */ | |
| 475 if (CONSP (glyphs)) | |
| 476 { | |
| 477 if (!EQ (XCAR (glyphs), tb->cap_up_glyph)) | |
| 478 { | |
| 479 tb->cap_up_glyph = XCAR (glyphs); | |
| 480 tb->dirty = 1; | |
| 481 } | |
| 482 glyphs = XCDR (glyphs); | |
| 483 } | |
| 484 else | |
| 485 tb->cap_up_glyph = Qnil; | |
| 486 | |
| 487 /* We might have a cap_down_glyph. */ | |
| 488 if (CONSP (glyphs)) | |
| 489 { | |
| 490 if (!EQ (XCAR (glyphs), tb->cap_down_glyph)) | |
| 491 { | |
| 492 tb->cap_down_glyph = XCAR (glyphs); | |
| 493 tb->dirty = 1; | |
| 494 } | |
| 495 glyphs = XCDR (glyphs); | |
| 496 } | |
| 497 else | |
| 498 tb->cap_down_glyph = Qnil; | |
| 499 | |
| 500 /* We might have a cap_disabled_glyph. */ | |
| 501 if (CONSP (glyphs)) | |
| 502 { | |
| 503 if (!EQ (XCAR (glyphs), tb->cap_disabled_glyph)) | |
| 504 { | |
| 505 tb->cap_disabled_glyph = XCAR (glyphs); | |
| 506 tb->dirty = 1; | |
| 507 } | |
| 508 } | |
| 509 else | |
| 510 tb->cap_disabled_glyph = Qnil; | |
| 511 | |
| 512 /* Update the callback. */ | |
| 513 if (!EQ (tb->callback, elt[1])) | |
| 514 { | |
| 515 tb->callback = elt[1]; | |
| 516 /* This does not have an impact on the display properties of the | |
| 517 button so we do not mark it as dirty if it has changed. */ | |
| 518 } | |
| 519 | |
| 520 /* Update the enabled field. */ | |
| 521 if (!EQ (tb->enabled_p, elt[2])) | |
| 522 { | |
| 523 tb->enabled_p = elt[2]; | |
| 524 tb->dirty = 1; | |
| 525 } | |
| 526 | |
| 527 /* We always do the following because if the enabled status is | |
| 528 determined by a function its decision may change without us being | |
| 529 able to detect it. */ | |
| 530 { | |
| 531 int old_enabled = tb->enabled; | |
| 532 | |
| 533 if (NILP (tb->enabled_p)) | |
| 534 tb->enabled = 0; | |
| 535 else if (EQ (tb->enabled_p, Qt)) | |
| 536 tb->enabled = 1; | |
| 537 else | |
| 538 { | |
| 539 if (NILP (tb->enabled_p) || EQ (tb->enabled_p, Qt)) | |
| 540 /* short-circuit the common case for speed */ | |
| 541 tb->enabled = !NILP (tb->enabled_p); | |
| 542 else | |
| 543 { | |
| 853 | 544 /* #### do we really need to protect this call? */ |
| 428 | 545 Lisp_Object result = |
| 853 | 546 eval_in_buffer_trapping_problems |
| 428 | 547 ("Error in toolbar enabled-p form", |
| 548 XBUFFER | |
| 549 (WINDOW_BUFFER | |
| 550 (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f)))), | |
| 853 | 551 tb->enabled_p, 0); |
| 428 | 552 if (UNBOUNDP (result)) |
| 553 /* #### if there was an error in the enabled-p | |
| 554 form, should we pretend like it's enabled | |
| 555 or disabled? */ | |
| 556 tb->enabled = 0; | |
| 557 else | |
| 558 tb->enabled = !NILP (result); | |
| 559 } | |
| 560 } | |
| 561 | |
| 562 if (old_enabled != tb->enabled) | |
| 563 tb->dirty = 1; | |
| 564 } | |
| 565 | |
| 566 /* Update the help echo string. */ | |
| 567 if (!EQ (tb->help_string, elt[3])) | |
| 568 { | |
| 569 tb->help_string = elt[3]; | |
| 570 /* This does not have an impact on the display properties of the | |
| 571 button so we do not mark it as dirty if it has changed. */ | |
| 572 } | |
| 573 } | |
| 574 | |
| 575 /* If this flag changes, the position is changing for sure unless | |
| 576 some very unlikely geometry occurs. */ | |
| 577 if (tb->pushright != pushright) | |
| 578 { | |
| 579 tb->pushright = pushright; | |
| 580 tb->dirty = 1; | |
| 581 } | |
| 582 | |
| 583 /* The position and size fields are only manipulated in the | |
| 584 device-dependent code. */ | |
| 585 UNGCPRO; | |
| 586 return retval; | |
| 587 } | |
| 588 | |
| 589 void | |
| 590 mark_frame_toolbar_buttons_dirty (struct frame *f, enum toolbar_pos pos) | |
| 591 { | |
| 592 Lisp_Object button = FRAME_TOOLBAR_BUTTONS (f, pos); | |
| 593 | |
| 594 while (!NILP (button)) | |
| 595 { | |
| 596 struct toolbar_button *tb = XTOOLBAR_BUTTON (button); | |
| 597 tb->dirty = 1; | |
| 598 button = tb->next; | |
| 599 } | |
| 600 return; | |
| 601 } | |
| 602 | |
| 603 static Lisp_Object | |
| 604 compute_frame_toolbar_buttons (struct frame *f, enum toolbar_pos pos, | |
| 605 Lisp_Object toolbar) | |
| 606 { | |
| 607 Lisp_Object buttons, prev_button, first_button; | |
| 608 Lisp_Object orig_toolbar = toolbar; | |
| 609 int pushright_seen = 0; | |
| 610 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5; | |
| 611 | |
| 612 first_button = FRAME_TOOLBAR_BUTTONS (f, pos); | |
| 613 buttons = prev_button = first_button; | |
| 614 | |
| 615 /* Yes, we're being paranoid. */ | |
| 616 GCPRO5 (toolbar, buttons, prev_button, first_button, orig_toolbar); | |
| 617 | |
| 618 if (NILP (toolbar)) | |
| 619 { | |
| 620 /* The output mechanisms will take care of clearing the former | |
| 621 toolbar. */ | |
| 622 UNGCPRO; | |
| 623 return Qnil; | |
| 624 } | |
| 625 | |
| 626 if (!CONSP (toolbar)) | |
| 563 | 627 sferror ("toolbar description must be a list", toolbar); |
| 428 | 628 |
| 629 /* First synchronize any existing buttons. */ | |
| 630 while (!NILP (toolbar) && !NILP (buttons)) | |
| 631 { | |
| 632 struct toolbar_button *tb; | |
| 633 | |
| 634 if (NILP (XCAR (toolbar))) | |
| 635 { | |
| 636 if (pushright_seen) | |
| 563 | 637 sferror |
| 428 | 638 ("more than one partition (nil) in toolbar description", |
| 639 orig_toolbar); | |
| 640 else | |
| 641 pushright_seen = 1; | |
| 642 } | |
| 643 else | |
| 644 { | |
| 645 tb = XTOOLBAR_BUTTON (buttons); | |
| 646 update_toolbar_button (f, tb, XCAR (toolbar), pushright_seen); | |
| 647 prev_button = buttons; | |
| 648 buttons = tb->next; | |
| 649 } | |
| 650 | |
| 651 toolbar = XCDR (toolbar); | |
| 652 } | |
| 653 | |
| 654 /* If we hit the end of the toolbar, then clean up any excess | |
| 655 buttons and return. */ | |
| 656 if (NILP (toolbar)) | |
| 657 { | |
| 658 if (!NILP (buttons)) | |
| 659 { | |
| 660 /* If this is the case the only thing we saw was a | |
| 661 pushright marker. */ | |
| 662 if (EQ (buttons, first_button)) | |
| 663 { | |
| 664 UNGCPRO; | |
| 665 return Qnil; | |
| 666 } | |
| 667 else | |
| 668 XTOOLBAR_BUTTON (prev_button)->next = Qnil; | |
| 669 } | |
| 670 UNGCPRO; | |
| 671 return first_button; | |
| 672 } | |
| 673 | |
| 674 /* At this point there are more buttons on the toolbar than we | |
| 675 actually have in existence. */ | |
| 676 while (!NILP (toolbar)) | |
| 677 { | |
| 678 Lisp_Object new_button; | |
| 679 | |
| 680 if (NILP (XCAR (toolbar))) | |
| 681 { | |
| 682 if (pushright_seen) | |
| 563 | 683 sferror |
| 428 | 684 ("more than one partition (nil) in toolbar description", |
| 685 orig_toolbar); | |
| 686 else | |
| 687 pushright_seen = 1; | |
| 688 } | |
| 689 else | |
| 690 { | |
| 691 new_button = update_toolbar_button (f, NULL, XCAR (toolbar), | |
| 692 pushright_seen); | |
| 693 | |
| 694 if (NILP (first_button)) | |
| 695 { | |
| 696 first_button = prev_button = new_button; | |
| 697 } | |
| 698 else | |
| 699 { | |
| 700 XTOOLBAR_BUTTON (prev_button)->next = new_button; | |
| 701 prev_button = new_button; | |
| 702 } | |
| 703 } | |
| 704 | |
| 705 toolbar = XCDR (toolbar); | |
| 706 } | |
| 707 | |
| 708 UNGCPRO; | |
| 709 return first_button; | |
| 710 } | |
| 711 | |
| 712 static void | |
| 713 set_frame_toolbar (struct frame *f, enum toolbar_pos pos) | |
| 714 { | |
| 715 struct window *w = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f)); | |
| 716 Lisp_Object toolbar = w->toolbar[pos]; | |
| 717 f->toolbar_buttons[pos] = (FRAME_REAL_TOOLBAR_VISIBLE (f, pos) | |
| 718 ? compute_frame_toolbar_buttons (f, pos, toolbar) | |
| 719 : Qnil); | |
| 720 } | |
| 721 | |
| 722 static void | |
| 723 compute_frame_toolbars_data (struct frame *f) | |
| 724 { | |
| 442 | 725 set_frame_toolbar (f, TOP_TOOLBAR); |
| 726 set_frame_toolbar (f, BOTTOM_TOOLBAR); | |
| 727 set_frame_toolbar (f, LEFT_TOOLBAR); | |
| 728 set_frame_toolbar (f, RIGHT_TOOLBAR); | |
| 428 | 729 } |
| 730 | |
| 905 | 731 /* Update the toolbar geometry separately from actually displaying the |
| 732 toolbar. This is necessary because both the gutter and the toolbar | |
| 733 are competing for redisplay cycles and, unfortunately, gutter | |
| 734 updates happen late in the game. Firstly they are done inside of | |
| 735 redisplay proper and secondly subcontrols may not get moved until | |
| 736 the next screen refresh. Only after subcontrols have been moved to | |
| 737 their final destinations can we be certain of updating the | |
| 738 toolbar. Under X this probably is exacerbated by the toolbar button | |
| 739 dirty flags which prevent updates happening when they possibly | |
| 740 should. */ | |
| 428 | 741 void |
| 905 | 742 update_frame_toolbars_geometry (struct frame *f) |
| 428 | 743 { |
| 744 struct device *d = XDEVICE (f->device); | |
| 745 | |
| 746 if (DEVICE_SUPPORTS_TOOLBARS_P (d) | |
| 905 | 747 && (f->toolbar_changed |
| 748 || f->frame_layout_changed | |
| 749 || f->frame_changed | |
| 750 || f->clear)) | |
| 428 | 751 { |
| 1559 | 752 int pos, frame_size_changed = 0; |
| 442 | 753 |
| 428 | 754 /* We're not officially "in redisplay", so we still have a |
| 755 chance to re-layout toolbars and windows. This is done here, | |
| 756 because toolbar is the only thing which currently might | |
| 757 necessitate this layout, as it is outside any windows. We | |
| 758 take care not to change size if toolbar geometry is really | |
| 759 unchanged, as it will hose windows whose pixsizes are not | |
| 760 multiple of character sizes. */ | |
| 761 | |
| 762 for (pos = 0; pos < 4; pos++) | |
| 763 if (FRAME_REAL_TOOLBAR_SIZE (f, pos) | |
| 764 != FRAME_CURRENT_TOOLBAR_SIZE (f, pos)) | |
| 1559 | 765 frame_size_changed = 1; |
| 428 | 766 |
| 905 | 767 for (pos = 0; pos < 4; pos++) { |
| 428 | 768 f->current_toolbar_size[pos] = FRAME_REAL_TOOLBAR_SIZE (f, pos); |
| 905 | 769 } |
| 428 | 770 |
| 771 /* Removed the check for the minibuffer here. We handle this | |
| 772 more correctly now by consistently using | |
| 773 FRAME_LAST_NONMINIBUF_WINDOW instead of FRAME_SELECTED_WINDOW | |
| 774 throughout the toolbar code. */ | |
| 775 compute_frame_toolbars_data (f); | |
| 1559 | 776 |
| 777 if (frame_size_changed) | |
| 778 { | |
| 779 int width, height; | |
| 2367 | 780 if (!window_system_pixelated_geometry (wrap_frame (f))) |
| 781 pixel_to_char_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f), | |
| 782 &width, &height); | |
| 783 else | |
| 784 width = FRAME_PIXWIDTH (f), height = FRAME_PIXHEIGHT (f); | |
| 1559 | 785 if (!HAS_FRAMEMETH_P (f, set_frame_size)) |
| 786 change_frame_size (f, height, width, 0); | |
| 787 else | |
| 788 FRAMEMETH (f, set_frame_size, (f, width, height)); | |
| 789 MARK_FRAME_LAYOUT_CHANGED (f); | |
| 790 } | |
| 905 | 791 |
| 792 /* Clear the previous toolbar locations. If we do it later | |
| 793 (after redisplay) we end up clearing what we have just | |
| 794 displayed. */ | |
| 795 MAYBE_DEVMETH (d, clear_frame_toolbars, (f)); | |
| 1559 | 796 |
| 905 | 797 } |
| 798 } | |
| 428 | 799 |
| 905 | 800 /* Actually redisplay the toolbar buttons. */ |
| 801 void | |
| 802 update_frame_toolbars (struct frame *f) | |
| 803 { | |
| 804 struct device *d = XDEVICE (f->device); | |
| 805 | |
| 806 if (DEVICE_SUPPORTS_TOOLBARS_P (d) | |
| 807 && (f->toolbar_changed | |
| 808 || f->frame_layout_changed | |
| 809 || f->frame_changed | |
| 810 || f->clear)) | |
| 811 { | |
| 428 | 812 DEVMETH (d, output_frame_toolbars, (f)); |
| 813 } | |
| 814 | |
| 815 f->toolbar_changed = 0; | |
| 816 } | |
| 817 | |
| 818 void | |
| 819 init_frame_toolbars (struct frame *f) | |
| 820 { | |
| 821 struct device *d = XDEVICE (f->device); | |
| 822 | |
| 823 if (DEVICE_SUPPORTS_TOOLBARS_P (d)) | |
| 824 { | |
| 825 Lisp_Object frame; | |
| 826 int pos; | |
| 827 | |
| 828 compute_frame_toolbars_data (f); | |
| 793 | 829 frame = wrap_frame (f); |
| 428 | 830 call_critical_lisp_code (XDEVICE (FRAME_DEVICE (f)), |
| 831 Qinit_toolbar_from_resources, | |
| 832 frame); | |
| 833 MAYBE_DEVMETH (d, initialize_frame_toolbars, (f)); | |
| 834 | |
| 835 /* We are here as far in frame creation so cached specifiers are | |
| 836 already recomputed, and possibly modified by resource | |
| 837 initialization. Remember current toolbar geometry so next | |
| 838 redisplay will not needlessly relayout toolbars. */ | |
| 839 for (pos = 0; pos < 4; pos++) | |
| 840 f->current_toolbar_size[pos] = FRAME_REAL_TOOLBAR_SIZE (f, pos); | |
| 841 } | |
| 842 } | |
| 843 | |
| 844 void | |
| 845 init_device_toolbars (struct device *d) | |
| 846 { | |
| 793 | 847 Lisp_Object device = wrap_device (d); |
| 428 | 848 |
| 849 if (DEVICE_SUPPORTS_TOOLBARS_P (d)) | |
| 850 call_critical_lisp_code (d, | |
| 851 Qinit_toolbar_from_resources, | |
| 852 device); | |
| 853 } | |
| 854 | |
| 855 void | |
| 856 init_global_toolbars (struct device *d) | |
| 857 { | |
| 858 if (DEVICE_SUPPORTS_TOOLBARS_P (d)) | |
| 859 call_critical_lisp_code (d, | |
| 860 Qinit_toolbar_from_resources, | |
| 861 Qglobal); | |
| 862 } | |
| 863 | |
| 864 void | |
| 865 free_frame_toolbars (struct frame *f) | |
| 866 { | |
| 867 /* If we had directly allocated any memory for the toolbars instead | |
| 868 of using all Lisp_Objects this is where we would now free it. */ | |
| 869 | |
| 870 MAYBE_FRAMEMETH (f, free_frame_toolbars, (f)); | |
| 871 } | |
| 872 | |
| 873 void | |
| 874 get_toolbar_coords (struct frame *f, enum toolbar_pos pos, int *x, int *y, | |
| 875 int *width, int *height, int *vert, int for_layout) | |
| 876 { | |
| 877 int visible_top_toolbar_height, visible_bottom_toolbar_height; | |
| 878 int adjust = (for_layout ? 1 : 0); | |
| 879 | |
| 880 /* The top and bottom toolbars take precedence over the left and | |
| 881 right. */ | |
| 882 visible_top_toolbar_height = (FRAME_REAL_TOP_TOOLBAR_VISIBLE (f) | |
| 883 ? FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) + | |
| 884 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f) | |
| 885 : 0); | |
| 886 visible_bottom_toolbar_height = (FRAME_REAL_BOTTOM_TOOLBAR_VISIBLE (f) | |
| 887 ? FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) + | |
| 888 2 * | |
| 889 FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f) | |
| 890 : 0); | |
| 891 | |
| 892 /* We adjust the width and height by one to give us a narrow border | |
| 893 at the outside edges. However, when we are simply determining | |
| 894 toolbar location we don't want to do that. */ | |
| 895 | |
| 896 switch (pos) | |
| 897 { | |
| 898 case TOP_TOOLBAR: | |
| 899 *x = 1; | |
| 900 *y = 0; /* #### should be 1 if no menubar */ | |
| 901 *width = FRAME_PIXWIDTH (f) - 2; | |
| 902 *height = FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) + | |
| 903 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f) - adjust; | |
| 904 *vert = 0; | |
| 905 break; | |
| 906 case BOTTOM_TOOLBAR: | |
| 907 *x = 1; | |
| 908 *y = FRAME_PIXHEIGHT (f) - FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) - | |
| 909 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f); | |
| 910 *width = FRAME_PIXWIDTH (f) - 2; | |
| 911 *height = FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) + | |
| 912 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f) - adjust; | |
| 913 *vert = 0; | |
| 914 break; | |
| 915 case LEFT_TOOLBAR: | |
| 916 *x = 1; | |
| 917 *y = visible_top_toolbar_height; | |
| 918 *width = FRAME_REAL_LEFT_TOOLBAR_WIDTH (f) + | |
| 919 2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f) - adjust; | |
| 920 *height = (FRAME_PIXHEIGHT (f) - visible_top_toolbar_height - | |
| 921 visible_bottom_toolbar_height - 1); | |
| 922 *vert = 1; | |
| 923 break; | |
| 924 case RIGHT_TOOLBAR: | |
| 925 *x = FRAME_PIXWIDTH (f) - FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) - | |
| 926 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f); | |
| 927 *y = visible_top_toolbar_height; | |
| 928 *width = FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) + | |
| 929 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f) - adjust; | |
| 930 *height = (FRAME_PIXHEIGHT (f) - visible_top_toolbar_height - | |
| 931 visible_bottom_toolbar_height); | |
| 932 *vert = 1; | |
| 933 break; | |
| 934 default: | |
| 2500 | 935 ABORT (); |
| 428 | 936 } |
| 937 } | |
| 938 | |
| 939 #define CHECK_TOOLBAR(pos) do { \ | |
| 940 if (FRAME_REAL_##pos##_VISIBLE (f)) \ | |
| 941 { \ | |
| 942 int x, y, width, height, vert; \ | |
| 943 \ | |
| 944 get_toolbar_coords (f, pos, &x, &y, &width, &height, &vert, 0); \ | |
| 945 if ((x_coord >= x) && (x_coord < (x + width))) \ | |
| 946 { \ | |
| 947 if ((y_coord >= y) && (y_coord < (y + height))) \ | |
| 948 return FRAME_TOOLBAR_BUTTONS (f, pos); \ | |
| 949 } \ | |
| 950 } \ | |
| 951 } while (0) | |
| 952 | |
| 953 static Lisp_Object | |
| 954 toolbar_buttons_at_pixpos (struct frame *f, int x_coord, int y_coord) | |
| 955 { | |
| 956 CHECK_TOOLBAR (TOP_TOOLBAR); | |
| 957 CHECK_TOOLBAR (BOTTOM_TOOLBAR); | |
| 958 CHECK_TOOLBAR (LEFT_TOOLBAR); | |
| 959 CHECK_TOOLBAR (RIGHT_TOOLBAR); | |
| 960 | |
| 961 return Qnil; | |
| 962 } | |
| 963 #undef CHECK_TOOLBAR | |
| 964 | |
| 965 /* The device dependent code actually does the work of positioning the | |
| 966 buttons, but we are free to access that information at this | |
| 967 level. */ | |
| 968 Lisp_Object | |
| 969 toolbar_button_at_pixpos (struct frame *f, int x_coord, int y_coord) | |
| 970 { | |
| 971 Lisp_Object buttons = toolbar_buttons_at_pixpos (f, x_coord, y_coord); | |
| 972 | |
| 973 while (!NILP (buttons)) | |
| 974 { | |
| 975 struct toolbar_button *tb = XTOOLBAR_BUTTON (buttons); | |
| 976 | |
| 977 if ((x_coord >= tb->x) && (x_coord < (tb->x + tb->width))) | |
| 978 { | |
| 979 if ((y_coord >= tb->y) && (y_coord < (tb->y + tb->height))) | |
| 980 { | |
| 981 /* If we are over a blank, return nil. */ | |
| 982 if (tb->blank) | |
| 983 return Qnil; | |
| 984 else | |
| 985 return buttons; | |
| 986 } | |
| 987 } | |
| 988 | |
| 989 buttons = tb->next; | |
| 990 } | |
| 991 | |
| 992 /* We are not over a toolbar or we are over a blank in the toolbar. */ | |
| 993 return Qnil; | |
| 994 } | |
| 995 | |
| 996 | |
| 997 /************************************************************************/ | |
| 998 /* Toolbar specifier type */ | |
| 999 /************************************************************************/ | |
| 1000 | |
| 1001 DEFINE_SPECIFIER_TYPE (toolbar); | |
| 1002 | |
| 563 | 1003 #define CTB_ERROR(msg) do { \ |
| 1004 maybe_signal_error (Qinvalid_argument, msg, button, Qtoolbar, errb); \ | |
| 1005 RETURN_SANS_WARNINGS Qnil; \ | |
| 428 | 1006 } while (0) |
| 1007 | |
| 1008 /* Returns Q_style if key was :style, Qt if ok otherwise, Qnil if error. */ | |
| 1009 static Lisp_Object | |
| 1010 check_toolbar_button_keywords (Lisp_Object button, Lisp_Object key, | |
| 578 | 1011 Lisp_Object val, Error_Behavior errb) |
| 428 | 1012 { |
| 1013 if (!KEYWORDP (key)) | |
| 1014 { | |
| 563 | 1015 maybe_signal_error_2 (Qinvalid_argument, "Not a keyword", key, button, |
| 1016 Qtoolbar, errb); | |
| 428 | 1017 return Qnil; |
| 1018 } | |
| 1019 | |
| 1020 if (EQ (key, Q_style)) | |
| 1021 { | |
| 1022 if (!EQ (val, Q2D) | |
| 1023 && !EQ (val, Q3D) | |
| 1024 && !EQ (val, Q2d) | |
| 1025 && !EQ (val, Q3d)) | |
| 1026 CTB_ERROR ("Unrecognized toolbar blank style"); | |
| 1027 | |
| 1028 return Q_style; | |
| 1029 } | |
| 1030 else if (EQ (key, Q_size)) | |
| 1031 { | |
| 1032 if (!NATNUMP (val)) | |
| 1033 CTB_ERROR ("invalid toolbar blank size"); | |
| 1034 } | |
| 1035 else | |
| 1036 { | |
| 1037 CTB_ERROR ("invalid toolbar blank keyword"); | |
| 1038 } | |
| 1039 | |
| 1040 return Qt; | |
| 1041 } | |
| 1042 | |
| 1043 /* toolbar button spec is [pixmap-pair function enabled-p help] | |
| 1044 or [:style 2d-or-3d :size width-or-height] */ | |
| 1045 | |
| 1046 DEFUN ("check-toolbar-button-syntax", Fcheck_toolbar_button_syntax, 1, 2, 0, /* | |
| 1047 Verify the syntax of entry BUTTON in a toolbar description list. | |
| 1048 If you want to verify the syntax of a toolbar description list as a | |
| 3025 | 1049 whole, use `check-valid-instantiator' with a specifier type of `toolbar'. |
| 428 | 1050 */ |
| 444 | 1051 (button, noerror)) |
| 428 | 1052 { |
| 1053 Lisp_Object *elt, glyphs, value; | |
| 1054 int len; | |
| 578 | 1055 Error_Behavior errb = decode_error_behavior_flag (noerror); |
| 428 | 1056 |
| 1057 if (!VECTORP (button)) | |
| 1058 CTB_ERROR ("toolbar button descriptors must be vectors"); | |
| 1059 elt = XVECTOR_DATA (button); | |
| 1060 | |
| 1061 if (XVECTOR_LENGTH (button) == 2) | |
| 1062 { | |
| 1063 if (!EQ (Q_style, check_toolbar_button_keywords (button, elt[0], | |
| 1064 elt[1], errb))) | |
| 1065 CTB_ERROR ("must specify toolbar blank style"); | |
| 1066 | |
| 1067 return Qt; | |
| 1068 } | |
| 1069 | |
| 1070 if (XVECTOR_LENGTH (button) != 4) | |
| 1071 CTB_ERROR ("toolbar button descriptors must be 2 or 4 long"); | |
| 1072 | |
| 1073 /* The first element must be a list of glyphs of length 1-6. The | |
| 1074 first entry is the pixmap for the up state, the second for the | |
| 1075 down state, the third for the disabled state, the fourth for the | |
| 1076 captioned up state, the fifth for the captioned down state and | |
| 1077 the sixth for the captioned disabled state. Only the up state is | |
| 1078 mandatory. */ | |
| 1079 if (!CONSP (elt[0])) | |
| 1080 { | |
| 1081 /* We can't check the buffer-local here because we don't know | |
| 442 | 1082 which buffer to check in. #### I think this is a bad thing. |
| 1083 See if we can't get enough information to this function so | |
| 1084 that it can check. | |
| 428 | 1085 |
| 1086 #### Wrong. We shouldn't be checking the value at all here. | |
| 1087 The user might set or change the value at any time. */ | |
| 1088 value = Fsymbol_value (elt[0]); | |
| 1089 | |
| 1090 if (!CONSP (value)) | |
| 1091 { | |
| 1092 if (KEYWORDP (elt[0])) | |
| 1093 { | |
| 1094 int fsty = 0; | |
| 1095 | |
| 1096 if (EQ (Q_style, check_toolbar_button_keywords (button, elt[0], | |
| 1097 elt[1], | |
| 1098 errb))) | |
| 1099 fsty++; | |
| 1100 | |
| 1101 if (EQ (Q_style, check_toolbar_button_keywords (button, elt[2], | |
| 1102 elt[3], | |
| 1103 errb))) | |
| 1104 fsty++; | |
| 1105 | |
| 1106 if (!fsty) | |
| 1107 CTB_ERROR ("must specify toolbar blank style"); | |
| 1108 else if (EQ (elt[0], elt[2])) | |
| 1109 CTB_ERROR | |
| 1110 ("duplicate keywords in toolbar button blank description"); | |
| 1111 | |
| 1112 return Qt; | |
| 1113 } | |
| 1114 else | |
| 1115 CTB_ERROR ("first element of button must be a list (of glyphs)"); | |
| 1116 } | |
| 1117 } | |
| 1118 else | |
| 1119 value = elt[0]; | |
| 1120 | |
| 1121 len = XINT (Flength (value)); | |
| 1122 if (len < 1) | |
| 1123 CTB_ERROR ("toolbar button glyph list must have at least 1 entry"); | |
| 1124 | |
| 1125 if (len > 6) | |
| 1126 CTB_ERROR ("toolbar button glyph list can have at most 6 entries"); | |
| 1127 | |
| 1128 glyphs = value; | |
| 1129 while (!NILP (glyphs)) | |
| 1130 { | |
| 1131 if (!GLYPHP (XCAR (glyphs))) | |
| 1132 { | |
| 1133 /* We allow nil for the down and disabled glyphs but not for | |
| 1134 the up glyph. */ | |
| 1135 if (EQ (glyphs, value) || !NILP (XCAR (glyphs))) | |
| 1136 { | |
| 1137 CTB_ERROR | |
| 1138 ("all elements of toolbar button glyph list must be glyphs."); | |
| 1139 } | |
| 1140 } | |
| 1141 glyphs = XCDR (glyphs); | |
| 1142 } | |
| 1143 | |
| 1144 /* The second element is the function to run when the button is | |
| 1145 activated. We do not do any checking on it because it is legal | |
| 1146 for the function to not be defined until after the toolbar is. | |
| 1147 It is the user's problem to get this right. | |
| 1148 | |
| 1149 The third element is either a boolean indicating the enabled | |
| 1150 status or a function used to determine it. Again, it is the | |
| 1151 user's problem if this is wrong. | |
| 1152 | |
| 1153 The fourth element, if not nil, must be a string which will be | |
| 1154 displayed as the help echo. */ | |
| 1155 | |
| 1156 /* #### This should be allowed to be a function returning a string | |
| 1157 as well as just a string. */ | |
| 1158 if (!NILP (elt[3]) && !STRINGP (elt[3])) | |
| 1159 CTB_ERROR ("toolbar button help echo string must be a string"); | |
| 1160 | |
| 1161 return Qt; | |
| 1162 } | |
| 1163 #undef CTB_ERROR | |
| 1164 | |
| 1165 static void | |
| 1166 toolbar_validate (Lisp_Object instantiator) | |
| 1167 { | |
| 1168 int pushright_seen = 0; | |
| 1169 Lisp_Object rest; | |
| 1170 | |
| 1171 if (NILP (instantiator)) | |
| 1172 return; | |
| 1173 | |
| 1174 if (!CONSP (instantiator)) | |
| 563 | 1175 sferror ("Toolbar spec must be list or nil", instantiator); |
| 428 | 1176 |
| 1177 for (rest = instantiator; !NILP (rest); rest = XCDR (rest)) | |
| 1178 { | |
| 1179 if (!CONSP (rest)) | |
| 563 | 1180 sferror ("Bad list in toolbar spec", instantiator); |
| 428 | 1181 |
| 1182 if (NILP (XCAR (rest))) | |
| 1183 { | |
| 1184 if (pushright_seen) | |
| 563 | 1185 sferror |
| 1186 ("More than one partition (nil) in instantiator description", | |
| 1187 instantiator); | |
| 428 | 1188 else |
| 1189 pushright_seen = 1; | |
| 1190 } | |
| 1191 else | |
| 1192 Fcheck_toolbar_button_syntax (XCAR (rest), Qnil); | |
| 1193 } | |
| 1194 } | |
| 1195 | |
| 1196 static void | |
| 2286 | 1197 toolbar_after_change (Lisp_Object UNUSED (specifier), |
| 1198 Lisp_Object UNUSED (locale)) | |
| 428 | 1199 { |
| 1200 /* #### This is overkill. I really need to rethink the after-change | |
| 1201 functions to make them easier to use. */ | |
| 1202 MARK_TOOLBAR_CHANGED; | |
| 1203 } | |
| 1204 | |
| 1205 DEFUN ("toolbar-specifier-p", Ftoolbar_specifier_p, 1, 1, 0, /* | |
| 1206 Return non-nil if OBJECT is a toolbar specifier. | |
| 1207 | |
| 442 | 1208 See `make-toolbar-specifier' for a description of possible toolbar |
| 1209 instantiators. | |
| 428 | 1210 */ |
| 1211 (object)) | |
| 1212 { | |
| 1213 return TOOLBAR_SPECIFIERP (object) ? Qt : Qnil; | |
| 1214 } | |
| 1215 | |
| 1216 | |
| 1217 /* | |
| 1218 Helper for invalidating the real specifier when default | |
| 1219 specifier caching changes | |
| 1220 */ | |
| 1221 static void | |
| 1222 recompute_overlaying_specifier (Lisp_Object real_one[4]) | |
| 1223 { | |
| 1224 enum toolbar_pos pos = decode_toolbar_position (Vdefault_toolbar_position); | |
| 1225 Fset_specifier_dirty_flag (real_one[pos]); | |
| 1226 } | |
| 1227 | |
| 1228 static void | |
| 2286 | 1229 toolbar_specs_changed (Lisp_Object UNUSED (specifier), |
| 1230 struct window *UNUSED (w), | |
| 1231 Lisp_Object UNUSED (oldval)) | |
| 428 | 1232 { |
| 1233 /* This could be smarter but I doubt that it would make any | |
| 1234 noticeable difference given the infrequency with which this is | |
| 1235 probably going to be called. | |
| 1236 */ | |
| 1237 MARK_TOOLBAR_CHANGED; | |
| 1238 } | |
| 1239 | |
| 1240 static void | |
| 2286 | 1241 default_toolbar_specs_changed (Lisp_Object UNUSED (specifier), |
| 1242 struct window *UNUSED (w), | |
| 1243 Lisp_Object UNUSED (oldval)) | |
| 428 | 1244 { |
| 1245 recompute_overlaying_specifier (Vtoolbar); | |
| 1246 } | |
| 1247 | |
| 1248 static void | |
| 2286 | 1249 default_toolbar_size_changed_in_frame (Lisp_Object UNUSED (specifier), |
| 1250 struct frame *UNUSED (f), | |
| 1251 Lisp_Object UNUSED (oldval)) | |
| 428 | 1252 { |
| 1253 recompute_overlaying_specifier (Vtoolbar_size); | |
| 1254 } | |
| 1255 | |
| 1256 static void | |
| 2286 | 1257 default_toolbar_border_width_changed_in_frame (Lisp_Object UNUSED (specifier), |
| 1258 struct frame *UNUSED (f), | |
| 1259 Lisp_Object UNUSED (oldval)) | |
| 428 | 1260 { |
| 1261 recompute_overlaying_specifier (Vtoolbar_border_width); | |
| 1262 } | |
| 1263 | |
| 1264 static void | |
| 2286 | 1265 default_toolbar_visible_p_changed_in_frame (Lisp_Object UNUSED (specifier), |
| 1266 struct frame *UNUSED (f), | |
| 1267 Lisp_Object UNUSED (oldval)) | |
| 428 | 1268 { |
| 1269 recompute_overlaying_specifier (Vtoolbar_visible_p); | |
| 1270 } | |
| 1271 | |
| 1272 static void | |
| 2286 | 1273 toolbar_geometry_changed_in_window (Lisp_Object UNUSED (specifier), |
| 1274 struct window *w, | |
| 1275 Lisp_Object UNUSED (oldval)) | |
| 428 | 1276 { |
| 1277 MARK_TOOLBAR_CHANGED; | |
| 1278 MARK_WINDOWS_CHANGED (w); | |
| 1279 } | |
| 1280 | |
| 1281 static void | |
| 2286 | 1282 default_toolbar_size_changed_in_window (Lisp_Object UNUSED (specifier), |
| 1283 struct window *UNUSED (w), | |
| 1284 Lisp_Object UNUSED (oldval)) | |
| 428 | 1285 { |
| 1286 recompute_overlaying_specifier (Vtoolbar_size); | |
| 1287 } | |
| 1288 | |
| 1289 static void | |
| 2286 | 1290 default_toolbar_border_width_changed_in_window (Lisp_Object UNUSED (specifier), |
| 1291 struct window *UNUSED (w), | |
| 1292 Lisp_Object UNUSED (oldval)) | |
| 428 | 1293 { |
| 1294 recompute_overlaying_specifier (Vtoolbar_border_width); | |
| 1295 } | |
| 1296 | |
| 1297 static void | |
| 2286 | 1298 default_toolbar_visible_p_changed_in_window (Lisp_Object UNUSED (specifier), |
| 1299 struct window *UNUSED (w), | |
| 1300 Lisp_Object UNUSED (oldval)) | |
| 428 | 1301 { |
| 1302 recompute_overlaying_specifier (Vtoolbar_visible_p); | |
| 1303 } | |
| 1304 | |
| 1305 static void | |
| 2286 | 1306 toolbar_buttons_captioned_p_changed (Lisp_Object UNUSED (specifier), |
| 1307 struct window *UNUSED (w), | |
| 1308 Lisp_Object UNUSED (oldval)) | |
| 428 | 1309 { |
| 1310 /* This could be smarter but I doubt that it would make any | |
| 1311 noticeable difference given the infrequency with which this is | |
| 1312 probably going to be called. */ | |
| 1313 MARK_TOOLBAR_CHANGED; | |
| 1314 } | |
| 1315 | |
| 744 | 1316 static void |
| 2286 | 1317 toolbar_shadows_changed (Lisp_Object UNUSED (specifier), |
| 1318 struct window *w, | |
| 1319 Lisp_Object UNUSED (oldval)) | |
| 744 | 1320 { |
| 1321 struct frame *f = XFRAME (w->frame); | |
| 1322 | |
| 1323 if (!f->frame_data) | |
| 1324 { | |
| 1325 /* If there is not frame data yet, we need to get the hell out | |
| 1326 ** of here. This can happen when the initial frame is being | |
| 1327 ** created and we set our specifiers internally. | |
| 1328 */ | |
| 1329 return; | |
| 1330 } | |
| 1331 MAYBE_DEVMETH (XDEVICE (f->device), redraw_frame_toolbars, (f)); | |
| 1332 } | |
| 1333 | |
| 428 | 1334 |
| 1335 void | |
| 1336 syms_of_toolbar (void) | |
| 1337 { | |
|
5117
3742ea8250b5
Checking in final CVS version of workspace 'ben-lisp-object'
Ben Wing <ben@xemacs.org>
parents:
3025
diff
changeset
|
1338 INIT_LISP_OBJECT (toolbar_button); |
| 442 | 1339 |
| 563 | 1340 DEFSYMBOL_MULTIWORD_PREDICATE (Qtoolbar_buttonp); |
| 1341 DEFSYMBOL (Q2D); | |
| 1342 DEFSYMBOL (Q3D); | |
| 1343 DEFSYMBOL (Q2d); | |
| 1344 DEFSYMBOL (Q3d); | |
| 1345 DEFKEYWORD (Q_size); | |
| 428 | 1346 |
| 563 | 1347 DEFSYMBOL (Qinit_toolbar_from_resources); |
| 428 | 1348 DEFSUBR (Ftoolbar_button_p); |
| 1349 DEFSUBR (Ftoolbar_button_callback); | |
| 1350 DEFSUBR (Ftoolbar_button_help_string); | |
| 1351 DEFSUBR (Ftoolbar_button_enabled_p); | |
| 1352 DEFSUBR (Fset_toolbar_button_down_flag); | |
| 1353 DEFSUBR (Fcheck_toolbar_button_syntax); | |
| 1354 DEFSUBR (Fset_default_toolbar_position); | |
| 1355 DEFSUBR (Fdefault_toolbar_position); | |
| 1356 DEFSUBR (Ftoolbar_specifier_p); | |
| 1357 } | |
| 1358 | |
| 1359 void | |
| 1360 vars_of_toolbar (void) | |
| 1361 { | |
| 1362 staticpro (&Vdefault_toolbar_position); | |
| 1363 Vdefault_toolbar_position = Qtop; | |
| 1364 | |
| 1365 #ifdef HAVE_WINDOW_SYSTEM | |
| 1366 Fprovide (Qtoolbar); | |
| 1367 #endif | |
| 1368 } | |
| 1369 | |
| 1370 void | |
| 1371 specifier_type_create_toolbar (void) | |
| 1372 { | |
| 1373 INITIALIZE_SPECIFIER_TYPE (toolbar, "toolbar", "toolbar-specifier-p"); | |
| 1374 | |
| 1375 SPECIFIER_HAS_METHOD (toolbar, validate); | |
| 1376 SPECIFIER_HAS_METHOD (toolbar, after_change); | |
| 1377 } | |
| 1378 | |
| 1379 void | |
| 1380 reinit_specifier_type_create_toolbar (void) | |
| 1381 { | |
| 1382 REINITIALIZE_SPECIFIER_TYPE (toolbar); | |
| 1383 } | |
| 1384 | |
| 1385 void | |
| 1386 specifier_vars_of_toolbar (void) | |
| 1387 { | |
| 1388 Lisp_Object fb; | |
| 1389 | |
| 1390 DEFVAR_SPECIFIER ("default-toolbar", &Vdefault_toolbar /* | |
| 1391 Specifier for a fallback toolbar. | |
| 1392 Use `set-specifier' to change this. | |
| 1393 | |
| 1394 The position of this toolbar is specified in the function | |
| 1395 `default-toolbar-position'. If the corresponding position-specific | |
| 3025 | 1396 toolbar (e.g. `top-toolbar' if `default-toolbar-position' is `top') |
| 428 | 1397 does not specify a toolbar in a particular domain (usually a window), |
| 1398 then the value of `default-toolbar' in that domain, if any, will be | |
| 1399 used instead. | |
| 1400 | |
| 1401 Note that the toolbar at any particular position will not be | |
| 1402 displayed unless its visibility flag is true and its thickness | |
| 1403 \(width or height, depending on orientation) is non-zero. The | |
| 1404 visibility is controlled by the specifiers `top-toolbar-visible-p', | |
| 1405 `bottom-toolbar-visible-p', `left-toolbar-visible-p', and | |
| 1406 `right-toolbar-visible-p', and the thickness is controlled by the | |
| 1407 specifiers `top-toolbar-height', `bottom-toolbar-height', | |
| 1408 `left-toolbar-width', and `right-toolbar-width'. | |
| 1409 | |
| 1410 Note that one of the four visibility specifiers inherits from | |
| 1411 `default-toolbar-visibility' and one of the four thickness | |
| 1412 specifiers inherits from either `default-toolbar-width' or | |
| 1413 `default-toolbar-height' (depending on orientation), just | |
| 1414 like for the toolbar description specifiers (e.g. `top-toolbar') | |
| 1415 mentioned above. | |
| 1416 | |
| 1417 Therefore, if you are setting `default-toolbar', you should control | |
| 1418 the visibility and thickness using `default-toolbar-visible-p', | |
| 1419 `default-toolbar-width', and `default-toolbar-height', rather than | |
| 1420 using position-specific specifiers. That way, you will get sane | |
| 1421 behavior if the user changes the default toolbar position. | |
| 1422 | |
| 1423 The format of the instantiator for a toolbar is a list of | |
| 1424 toolbar-button-descriptors. Each toolbar-button-descriptor | |
| 1425 is a vector in one of the following formats: | |
| 1426 | |
| 1427 [GLYPH-LIST FUNCTION ENABLED-P HELP] or | |
| 1428 [:style 2D-OR-3D] or | |
| 1429 [:style 2D-OR-3D :size WIDTH-OR-HEIGHT] or | |
| 1430 [:size WIDTH-OR-HEIGHT :style 2D-OR-3D] | |
| 1431 | |
| 1432 Optionally, one of the toolbar-button-descriptors may be nil | |
| 1433 instead of a vector; this signifies the division between | |
| 1434 the toolbar buttons that are to be displayed flush-left, | |
| 1435 and the buttons to be displayed flush-right. | |
| 1436 | |
| 1437 The first vector format above specifies a normal toolbar button; | |
| 1438 the others specify blank areas in the toolbar. | |
| 1439 | |
| 1440 For the first vector format: | |
| 1441 | |
| 1442 -- GLYPH-LIST should be a list of one to six glyphs (as created by | |
| 1443 `make-glyph') or a symbol whose value is such a list. The first | |
| 1444 glyph, which must be provided, is the glyph used to display the | |
| 1445 toolbar button when it is in the "up" (not pressed) state. The | |
| 1446 optional second glyph is for displaying the button when it is in | |
| 1447 the "down" (pressed) state. The optional third glyph is for when | |
| 1448 the button is disabled. The optional fourth, fifth and sixth glyphs | |
| 1449 are used to specify captioned versions for the up, down and disabled | |
| 1450 states respectively. The function `toolbar-make-button-list' is | |
| 1451 useful in creating these glyph lists. The specifier variable | |
| 1452 `toolbar-buttons-captioned-p' controls which glyphs are actually used. | |
| 1453 | |
| 1454 -- Even if you do not provide separate down-state and disabled-state | |
| 1455 glyphs, the user will still get visual feedback to indicate which | |
| 1456 state the button is in. Buttons in the up-state are displayed | |
| 1457 with a shadowed border that gives a raised appearance to the | |
| 1458 button. Buttons in the down-state are displayed with shadows that | |
| 1459 give a recessed appearance. Buttons in the disabled state are | |
| 1460 displayed with no shadows, giving a 2-d effect. | |
| 1461 | |
| 1462 -- If some of the toolbar glyphs are not provided, they inherit as follows: | |
| 1463 | |
| 1464 UP: up | |
| 1465 DOWN: down -> up | |
| 1466 DISABLED: disabled -> up | |
| 1467 CAP-UP: cap-up -> up | |
| 1468 CAP-DOWN: cap-down -> cap-up -> down -> up | |
| 1469 CAP-DISABLED: cap-disabled -> cap-up -> disabled -> up | |
| 1470 | |
| 1471 -- The second element FUNCTION is a function to be called when the | |
| 1472 toolbar button is activated (i.e. when the mouse is released over | |
| 1473 the toolbar button, if the press occurred in the toolbar). It | |
| 1474 can be any form accepted by `call-interactively', since this is | |
| 1475 how it is invoked. | |
| 1476 | |
| 1477 -- The third element ENABLED-P specifies whether the toolbar button | |
| 1478 is enabled (disabled buttons do nothing when they are activated, | |
| 1479 and are displayed differently; see above). It should be either | |
| 1480 a boolean or a form that evaluates to a boolean. | |
| 1481 | |
| 1482 -- The fourth element HELP, if non-nil, should be a string. This | |
| 1483 string is displayed in the echo area when the mouse passes over | |
| 1484 the toolbar button. | |
| 1485 | |
| 1486 For the other vector formats (specifying blank areas of the toolbar): | |
| 1487 | |
| 3025 | 1488 -- 2D-OR-3D should be one of the symbols `2d' or `3d', indicating |
| 428 | 1489 whether the area is displayed with shadows (giving it a raised, |
| 1490 3-d appearance) or without shadows (giving it a flat appearance). | |
| 1491 | |
| 1492 -- WIDTH-OR-HEIGHT specifies the length, in pixels, of the blank | |
| 1493 area. If omitted, it defaults to a device-specific value | |
| 1494 (8 pixels for X devices). | |
| 1495 */ ); | |
| 1496 | |
| 1497 Vdefault_toolbar = Fmake_specifier (Qtoolbar); | |
| 1498 /* #### It would be even nicer if the specifier caching | |
| 1499 automatically knew about specifier fallbacks, so we didn't | |
| 1500 have to do it ourselves. */ | |
| 1501 set_specifier_caching (Vdefault_toolbar, | |
| 438 | 1502 offsetof (struct window, default_toolbar), |
| 428 | 1503 default_toolbar_specs_changed, |
| 444 | 1504 0, 0, 0); |
| 428 | 1505 |
| 1506 DEFVAR_SPECIFIER ("top-toolbar", | |
| 1507 &Vtoolbar[TOP_TOOLBAR] /* | |
| 1508 Specifier for the toolbar at the top of the frame. | |
| 1509 Use `set-specifier' to change this. | |
| 1510 See `default-toolbar' for a description of a valid toolbar instantiator. | |
| 1511 */ ); | |
| 1512 Vtoolbar[TOP_TOOLBAR] = Fmake_specifier (Qtoolbar); | |
| 1513 set_specifier_caching (Vtoolbar[TOP_TOOLBAR], | |
| 438 | 1514 offsetof (struct window, toolbar[TOP_TOOLBAR]), |
| 428 | 1515 toolbar_specs_changed, |
| 444 | 1516 0, 0, 0); |
| 428 | 1517 |
| 1518 DEFVAR_SPECIFIER ("bottom-toolbar", | |
| 1519 &Vtoolbar[BOTTOM_TOOLBAR] /* | |
| 1520 Specifier for the toolbar at the bottom of the frame. | |
| 1521 Use `set-specifier' to change this. | |
| 1522 See `default-toolbar' for a description of a valid toolbar instantiator. | |
| 1523 | |
| 1524 Note that, unless the `default-toolbar-position' is `bottom', by | |
| 1525 default the height of the bottom toolbar (controlled by | |
| 1526 `bottom-toolbar-height') is 0; thus, a bottom toolbar will not be | |
| 1527 displayed even if you provide a value for `bottom-toolbar'. | |
| 1528 */ ); | |
| 1529 Vtoolbar[BOTTOM_TOOLBAR] = Fmake_specifier (Qtoolbar); | |
| 1530 set_specifier_caching (Vtoolbar[BOTTOM_TOOLBAR], | |
| 438 | 1531 offsetof (struct window, toolbar[BOTTOM_TOOLBAR]), |
| 428 | 1532 toolbar_specs_changed, |
| 444 | 1533 0, 0, 0); |
| 428 | 1534 |
| 1535 DEFVAR_SPECIFIER ("left-toolbar", | |
| 1536 &Vtoolbar[LEFT_TOOLBAR] /* | |
| 1537 Specifier for the toolbar at the left edge of the frame. | |
| 1538 Use `set-specifier' to change this. | |
| 1539 See `default-toolbar' for a description of a valid toolbar instantiator. | |
| 1540 | |
| 1541 Note that, unless the `default-toolbar-position' is `left', by | |
| 1542 default the height of the left toolbar (controlled by | |
| 1543 `left-toolbar-width') is 0; thus, a left toolbar will not be | |
| 1544 displayed even if you provide a value for `left-toolbar'. | |
| 1545 */ ); | |
| 1546 Vtoolbar[LEFT_TOOLBAR] = Fmake_specifier (Qtoolbar); | |
| 1547 set_specifier_caching (Vtoolbar[LEFT_TOOLBAR], | |
| 438 | 1548 offsetof (struct window, toolbar[LEFT_TOOLBAR]), |
| 428 | 1549 toolbar_specs_changed, |
| 444 | 1550 0, 0, 0); |
| 428 | 1551 |
| 1552 DEFVAR_SPECIFIER ("right-toolbar", | |
| 1553 &Vtoolbar[RIGHT_TOOLBAR] /* | |
| 1554 Specifier for the toolbar at the right edge of the frame. | |
| 1555 Use `set-specifier' to change this. | |
| 1556 See `default-toolbar' for a description of a valid toolbar instantiator. | |
| 1557 | |
| 1558 Note that, unless the `default-toolbar-position' is `right', by | |
| 1559 default the height of the right toolbar (controlled by | |
| 1560 `right-toolbar-width') is 0; thus, a right toolbar will not be | |
| 1561 displayed even if you provide a value for `right-toolbar'. | |
| 1562 */ ); | |
| 1563 Vtoolbar[RIGHT_TOOLBAR] = Fmake_specifier (Qtoolbar); | |
| 1564 set_specifier_caching (Vtoolbar[RIGHT_TOOLBAR], | |
| 438 | 1565 offsetof (struct window, toolbar[RIGHT_TOOLBAR]), |
| 428 | 1566 toolbar_specs_changed, |
| 444 | 1567 0, 0, 0); |
| 428 | 1568 |
| 1569 /* initially, top inherits from default; this can be | |
| 1570 changed with `set-default-toolbar-position'. */ | |
| 1571 fb = list1 (Fcons (Qnil, Qnil)); | |
| 1572 set_specifier_fallback (Vdefault_toolbar, fb); | |
| 1573 set_specifier_fallback (Vtoolbar[TOP_TOOLBAR], Vdefault_toolbar); | |
| 1574 set_specifier_fallback (Vtoolbar[BOTTOM_TOOLBAR], fb); | |
| 1575 set_specifier_fallback (Vtoolbar[LEFT_TOOLBAR], fb); | |
| 1576 set_specifier_fallback (Vtoolbar[RIGHT_TOOLBAR], fb); | |
| 1577 | |
| 1578 DEFVAR_SPECIFIER ("default-toolbar-height", &Vdefault_toolbar_height /* | |
| 1579 *Height of the default toolbar, if it's oriented horizontally. | |
| 1580 This is a specifier; use `set-specifier' to change it. | |
| 1581 | |
| 1582 The position of the default toolbar is specified by the function | |
| 1583 `set-default-toolbar-position'. If the corresponding position-specific | |
| 1584 toolbar thickness specifier (e.g. `top-toolbar-height' if | |
| 3025 | 1585 `default-toolbar-position' is `top') does not specify a thickness in a |
| 428 | 1586 particular domain (a window or a frame), then the value of |
| 1587 `default-toolbar-height' or `default-toolbar-width' (depending on the | |
| 1588 toolbar orientation) in that domain, if any, will be used instead. | |
| 1589 | |
| 1590 Note that `default-toolbar-height' is only used when | |
| 3025 | 1591 `default-toolbar-position' is `top' or `bottom', and `default-toolbar-width' |
| 1592 is only used when `default-toolbar-position' is `left' or `right'. | |
| 428 | 1593 |
| 1594 Note that all of the position-specific toolbar thickness specifiers | |
| 1595 have a fallback value of zero when they do not correspond to the | |
| 1596 default toolbar. Therefore, you will have to set a non-zero thickness | |
| 1597 value if you want a position-specific toolbar to be displayed. | |
| 1598 | |
| 1599 Internally, toolbar thickness specifiers are instantiated in both | |
| 1600 window and frame domains, for different purposes. The value in the | |
| 1601 domain of a frame's selected window specifies the actual toolbar | |
| 1602 thickness that you will see in that frame. The value in the domain of | |
| 1603 a frame itself specifies the toolbar thickness that is used in frame | |
| 1604 geometry calculations. | |
| 1605 | |
| 1606 Thus, for example, if you set the frame width to 80 characters and the | |
| 1607 left toolbar width for that frame to 68 pixels, then the frame will | |
| 1608 be sized to fit 80 characters plus a 68-pixel left toolbar. If you | |
| 1609 then set the left toolbar width to 0 for a particular buffer (or if | |
| 1610 that buffer does not specify a left toolbar or has a nil value | |
| 1611 specified for `left-toolbar-visible-p'), you will find that, when | |
| 1612 that buffer is displayed in the selected window, the window will have | |
| 1613 a width of 86 or 87 characters -- the frame is sized for a 68-pixel | |
| 1614 left toolbar but the selected window specifies that the left toolbar | |
| 1615 is not visible, so it is expanded to take up the slack. | |
| 1616 */ ); | |
| 1617 Vdefault_toolbar_height = Fmake_specifier (Qnatnum); | |
| 1618 set_specifier_caching (Vdefault_toolbar_height, | |
| 438 | 1619 offsetof (struct window, default_toolbar_height), |
| 428 | 1620 default_toolbar_size_changed_in_window, |
| 438 | 1621 offsetof (struct frame, default_toolbar_height), |
| 444 | 1622 default_toolbar_size_changed_in_frame, 0); |
| 428 | 1623 |
| 1624 DEFVAR_SPECIFIER ("default-toolbar-width", &Vdefault_toolbar_width /* | |
| 1625 *Width of the default toolbar, if it's oriented vertically. | |
| 1626 This is a specifier; use `set-specifier' to change it. | |
| 1627 | |
| 1628 See `default-toolbar-height' for more information. | |
| 1629 */ ); | |
| 1630 Vdefault_toolbar_width = Fmake_specifier (Qnatnum); | |
| 1631 set_specifier_caching (Vdefault_toolbar_width, | |
| 438 | 1632 offsetof (struct window, default_toolbar_width), |
| 428 | 1633 default_toolbar_size_changed_in_window, |
| 438 | 1634 offsetof (struct frame, default_toolbar_width), |
| 444 | 1635 default_toolbar_size_changed_in_frame, 0); |
| 428 | 1636 |
| 1637 DEFVAR_SPECIFIER ("top-toolbar-height", | |
| 1638 &Vtoolbar_size[TOP_TOOLBAR] /* | |
| 1639 *Height of the top toolbar. | |
| 1640 This is a specifier; use `set-specifier' to change it. | |
| 1641 | |
| 1642 See `default-toolbar-height' for more information. | |
| 1643 */ ); | |
| 1644 Vtoolbar_size[TOP_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1645 set_specifier_caching (Vtoolbar_size[TOP_TOOLBAR], | |
| 438 | 1646 offsetof (struct window, toolbar_size[TOP_TOOLBAR]), |
| 428 | 1647 toolbar_geometry_changed_in_window, |
| 438 | 1648 offsetof (struct frame, toolbar_size[TOP_TOOLBAR]), |
| 444 | 1649 frame_size_slipped, 0); |
| 428 | 1650 |
| 1651 DEFVAR_SPECIFIER ("bottom-toolbar-height", | |
| 1652 &Vtoolbar_size[BOTTOM_TOOLBAR] /* | |
| 1653 *Height of the bottom toolbar. | |
| 1654 This is a specifier; use `set-specifier' to change it. | |
| 1655 | |
| 1656 See `default-toolbar-height' for more information. | |
| 1657 */ ); | |
| 1658 Vtoolbar_size[BOTTOM_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1659 set_specifier_caching (Vtoolbar_size[BOTTOM_TOOLBAR], | |
| 438 | 1660 offsetof (struct window, toolbar_size[BOTTOM_TOOLBAR]), |
| 428 | 1661 toolbar_geometry_changed_in_window, |
| 438 | 1662 offsetof (struct frame, toolbar_size[BOTTOM_TOOLBAR]), |
| 444 | 1663 frame_size_slipped, 0); |
| 428 | 1664 |
| 1665 DEFVAR_SPECIFIER ("left-toolbar-width", | |
| 1666 &Vtoolbar_size[LEFT_TOOLBAR] /* | |
| 1667 *Width of left toolbar. | |
| 1668 This is a specifier; use `set-specifier' to change it. | |
| 1669 | |
| 1670 See `default-toolbar-height' for more information. | |
| 1671 */ ); | |
| 1672 Vtoolbar_size[LEFT_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1673 set_specifier_caching (Vtoolbar_size[LEFT_TOOLBAR], | |
| 438 | 1674 offsetof (struct window, toolbar_size[LEFT_TOOLBAR]), |
| 428 | 1675 toolbar_geometry_changed_in_window, |
| 438 | 1676 offsetof (struct frame, toolbar_size[LEFT_TOOLBAR]), |
| 444 | 1677 frame_size_slipped, 0); |
| 428 | 1678 |
| 1679 DEFVAR_SPECIFIER ("right-toolbar-width", | |
| 1680 &Vtoolbar_size[RIGHT_TOOLBAR] /* | |
| 1681 *Width of right toolbar. | |
| 1682 This is a specifier; use `set-specifier' to change it. | |
| 1683 | |
| 1684 See `default-toolbar-height' for more information. | |
| 1685 */ ); | |
| 1686 Vtoolbar_size[RIGHT_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1687 set_specifier_caching (Vtoolbar_size[RIGHT_TOOLBAR], | |
| 438 | 1688 offsetof (struct window, toolbar_size[RIGHT_TOOLBAR]), |
| 428 | 1689 toolbar_geometry_changed_in_window, |
| 438 | 1690 offsetof (struct frame, toolbar_size[RIGHT_TOOLBAR]), |
| 444 | 1691 frame_size_slipped, 0); |
| 428 | 1692 |
| 744 | 1693 DEFVAR_SPECIFIER ("toolbar-shadow-thickness", |
| 1694 &Vtoolbar_shadow_thickness /* | |
| 1695 *Width of shadows around toolbar buttons. | |
| 1696 This is a specifier; use `set-specifier' to change it. | |
| 1697 */ ); | |
| 1698 Vtoolbar_shadow_thickness = Fmake_specifier (Qnatnum); | |
| 1699 set_specifier_caching(Vtoolbar_shadow_thickness, | |
| 1700 offsetof (struct window, toolbar_shadow_thickness), | |
| 1701 toolbar_shadows_changed, | |
| 1702 0,0, 0); | |
| 1703 | |
| 1704 fb = Qnil; | |
| 1705 | |
| 1706 #ifdef HAVE_TTY | |
| 1707 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); | |
| 1708 #endif | |
| 1709 #ifdef HAVE_GTK | |
| 1710 fb = Fcons (Fcons (list1 (Qgtk), make_int (2)), fb); | |
| 1711 #endif | |
| 1712 #ifdef HAVE_X_WINDOWS | |
| 1713 fb = Fcons (Fcons (list1 (Qx), make_int (2)), fb); | |
| 1714 #endif | |
| 1715 #ifdef HAVE_MS_WINDOWS | |
| 1716 fb = Fcons (Fcons (list1 (Qmswindows), make_int (2)), fb); | |
| 1717 #endif | |
| 1718 | |
| 1719 if (!NILP (fb)) | |
| 1720 set_specifier_fallback (Vtoolbar_shadow_thickness, fb); | |
| 1721 | |
| 428 | 1722 fb = Qnil; |
| 1723 #ifdef HAVE_TTY | |
| 1724 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); | |
| 1725 #endif | |
| 462 | 1726 #ifdef HAVE_GTK |
| 1727 fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_HEIGHT)), fb); | |
| 1728 #endif | |
| 428 | 1729 #ifdef HAVE_X_WINDOWS |
| 1730 fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_HEIGHT)), fb); | |
| 1731 #endif | |
| 1732 #ifdef HAVE_MS_WINDOWS | |
| 442 | 1733 fb = Fcons (Fcons (list1 (Qmswindows), |
| 428 | 1734 make_int (MSWINDOWS_DEFAULT_TOOLBAR_HEIGHT)), fb); |
| 1735 #endif | |
| 1736 if (!NILP (fb)) | |
| 1737 set_specifier_fallback (Vdefault_toolbar_height, fb); | |
| 1738 | |
| 1739 fb = Qnil; | |
| 1740 #ifdef HAVE_TTY | |
| 1741 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); | |
| 1742 #endif | |
| 462 | 1743 #ifdef HAVE_GTK |
| 1744 fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_WIDTH)), fb); | |
| 1745 #endif | |
| 428 | 1746 #ifdef HAVE_X_WINDOWS |
| 1747 fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_WIDTH)), fb); | |
| 1748 #endif | |
| 1749 #ifdef HAVE_MS_WINDOWS | |
| 442 | 1750 fb = Fcons (Fcons (list1 (Qmswindows), |
| 428 | 1751 make_int (MSWINDOWS_DEFAULT_TOOLBAR_WIDTH)), fb); |
| 1752 #endif | |
| 1753 if (!NILP (fb)) | |
| 1754 set_specifier_fallback (Vdefault_toolbar_width, fb); | |
| 1755 | |
| 1756 set_specifier_fallback (Vtoolbar_size[TOP_TOOLBAR], Vdefault_toolbar_height); | |
| 1757 fb = list1 (Fcons (Qnil, Qzero)); | |
| 1758 set_specifier_fallback (Vtoolbar_size[BOTTOM_TOOLBAR], fb); | |
| 1759 set_specifier_fallback (Vtoolbar_size[LEFT_TOOLBAR], fb); | |
| 1760 set_specifier_fallback (Vtoolbar_size[RIGHT_TOOLBAR], fb); | |
| 1761 | |
| 1762 DEFVAR_SPECIFIER ("default-toolbar-border-width", | |
| 1763 &Vdefault_toolbar_border_width /* | |
| 1764 *Width of the border around the default toolbar. | |
| 1765 This is a specifier; use `set-specifier' to change it. | |
| 1766 | |
| 1767 The position of the default toolbar is specified by the function | |
| 1768 `set-default-toolbar-position'. If the corresponding position-specific | |
| 1769 toolbar border width specifier (e.g. `top-toolbar-border-width' if | |
| 3025 | 1770 `default-toolbar-position' is `top') does not specify a border width in a |
| 428 | 1771 particular domain (a window or a frame), then the value of |
| 1772 `default-toolbar-border-width' in that domain, if any, will be used | |
| 1773 instead. | |
| 1774 | |
| 1775 Internally, toolbar border width specifiers are instantiated in both | |
| 1776 window and frame domains, for different purposes. The value in the | |
| 1777 domain of a frame's selected window specifies the actual toolbar border | |
| 1778 width that you will see in that frame. The value in the domain of a | |
| 1779 frame itself specifies the toolbar border width that is used in frame | |
| 1780 geometry calculations. Changing the border width value in the frame | |
| 1781 domain will result in a size change in the frame itself, while changing | |
| 1782 the value in a window domain will not. | |
| 1783 */ ); | |
| 1784 Vdefault_toolbar_border_width = Fmake_specifier (Qnatnum); | |
| 1785 set_specifier_caching (Vdefault_toolbar_border_width, | |
| 438 | 1786 offsetof (struct window, default_toolbar_border_width), |
| 428 | 1787 default_toolbar_border_width_changed_in_window, |
| 438 | 1788 offsetof (struct frame, default_toolbar_border_width), |
| 444 | 1789 default_toolbar_border_width_changed_in_frame, 0); |
| 428 | 1790 |
| 1791 DEFVAR_SPECIFIER ("top-toolbar-border-width", | |
| 1792 &Vtoolbar_border_width[TOP_TOOLBAR] /* | |
| 1793 *Border width of the top toolbar. | |
| 1794 This is a specifier; use `set-specifier' to change it. | |
| 1795 | |
| 1796 See `default-toolbar-height' for more information. | |
| 1797 */ ); | |
| 1798 Vtoolbar_border_width[TOP_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1799 set_specifier_caching (Vtoolbar_border_width[TOP_TOOLBAR], | |
| 438 | 1800 offsetof (struct window, |
| 1801 toolbar_border_width[TOP_TOOLBAR]), | |
| 428 | 1802 toolbar_geometry_changed_in_window, |
| 438 | 1803 offsetof (struct frame, |
| 1804 toolbar_border_width[TOP_TOOLBAR]), | |
| 444 | 1805 frame_size_slipped, 0); |
| 428 | 1806 |
| 1807 DEFVAR_SPECIFIER ("bottom-toolbar-border-width", | |
| 1808 &Vtoolbar_border_width[BOTTOM_TOOLBAR] /* | |
| 1809 *Border width of the bottom toolbar. | |
| 1810 This is a specifier; use `set-specifier' to change it. | |
| 1811 | |
| 1812 See `default-toolbar-height' for more information. | |
| 1813 */ ); | |
| 1814 Vtoolbar_border_width[BOTTOM_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1815 set_specifier_caching (Vtoolbar_border_width[BOTTOM_TOOLBAR], | |
| 438 | 1816 offsetof (struct window, |
| 1817 toolbar_border_width[BOTTOM_TOOLBAR]), | |
| 428 | 1818 toolbar_geometry_changed_in_window, |
| 438 | 1819 offsetof (struct frame, |
| 1820 toolbar_border_width[BOTTOM_TOOLBAR]), | |
| 444 | 1821 frame_size_slipped, 0); |
| 428 | 1822 |
| 1823 DEFVAR_SPECIFIER ("left-toolbar-border-width", | |
| 1824 &Vtoolbar_border_width[LEFT_TOOLBAR] /* | |
| 1825 *Border width of left toolbar. | |
| 1826 This is a specifier; use `set-specifier' to change it. | |
| 1827 | |
| 1828 See `default-toolbar-height' for more information. | |
| 1829 */ ); | |
| 1830 Vtoolbar_border_width[LEFT_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1831 set_specifier_caching (Vtoolbar_border_width[LEFT_TOOLBAR], | |
| 438 | 1832 offsetof (struct window, |
| 1833 toolbar_border_width[LEFT_TOOLBAR]), | |
| 428 | 1834 toolbar_geometry_changed_in_window, |
| 438 | 1835 offsetof (struct frame, |
| 1836 toolbar_border_width[LEFT_TOOLBAR]), | |
| 444 | 1837 frame_size_slipped, 0); |
| 428 | 1838 |
| 1839 DEFVAR_SPECIFIER ("right-toolbar-border-width", | |
| 1840 &Vtoolbar_border_width[RIGHT_TOOLBAR] /* | |
| 1841 *Border width of right toolbar. | |
| 1842 This is a specifier; use `set-specifier' to change it. | |
| 1843 | |
| 1844 See `default-toolbar-height' for more information. | |
| 1845 */ ); | |
| 1846 Vtoolbar_border_width[RIGHT_TOOLBAR] = Fmake_specifier (Qnatnum); | |
| 1847 set_specifier_caching (Vtoolbar_border_width[RIGHT_TOOLBAR], | |
| 438 | 1848 offsetof (struct window, |
| 1849 toolbar_border_width[RIGHT_TOOLBAR]), | |
| 428 | 1850 toolbar_geometry_changed_in_window, |
| 438 | 1851 offsetof (struct frame, |
| 1852 toolbar_border_width[RIGHT_TOOLBAR]), | |
| 444 | 1853 frame_size_slipped, 0); |
| 428 | 1854 |
| 1855 fb = Qnil; | |
| 1856 #ifdef HAVE_TTY | |
| 1857 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb); | |
| 1858 #endif | |
| 1859 #ifdef HAVE_X_WINDOWS | |
| 1860 fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); | |
| 1861 #endif | |
| 462 | 1862 #ifdef HAVE_GTK |
| 1863 fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); | |
| 1864 #endif | |
| 428 | 1865 #ifdef HAVE_MS_WINDOWS |
| 1866 fb = Fcons (Fcons (list1 (Qmswindows), make_int (MSWINDOWS_DEFAULT_TOOLBAR_BORDER_WIDTH)), fb); | |
| 1867 #endif | |
| 1868 if (!NILP (fb)) | |
| 1869 set_specifier_fallback (Vdefault_toolbar_border_width, fb); | |
| 1870 | |
| 1871 set_specifier_fallback (Vtoolbar_border_width[TOP_TOOLBAR], Vdefault_toolbar_border_width); | |
| 1872 fb = list1 (Fcons (Qnil, Qzero)); | |
| 1873 set_specifier_fallback (Vtoolbar_border_width[BOTTOM_TOOLBAR], fb); | |
| 1874 set_specifier_fallback (Vtoolbar_border_width[LEFT_TOOLBAR], fb); | |
| 1875 set_specifier_fallback (Vtoolbar_border_width[RIGHT_TOOLBAR], fb); | |
| 1876 | |
| 1877 DEFVAR_SPECIFIER ("default-toolbar-visible-p", &Vdefault_toolbar_visible_p /* | |
| 1878 *Whether the default toolbar is visible. | |
| 1879 This is a specifier; use `set-specifier' to change it. | |
| 1880 | |
| 1881 The position of the default toolbar is specified by the function | |
| 1882 `set-default-toolbar-position'. If the corresponding position-specific | |
| 1883 toolbar visibility specifier (e.g. `top-toolbar-visible-p' if | |
| 3025 | 1884 `default-toolbar-position' is `top') does not specify a visible-p value |
| 428 | 1885 in a particular domain (a window or a frame), then the value of |
| 1886 `default-toolbar-visible-p' in that domain, if any, will be used | |
| 1887 instead. | |
| 1888 | |
| 1889 Both window domains and frame domains are used internally, for | |
| 1890 different purposes. The distinction here is exactly the same as | |
| 1891 for thickness specifiers; see `default-toolbar-height' for more | |
| 1892 information. | |
| 1893 | |
| 1894 `default-toolbar-visible-p' and all of the position-specific toolbar | |
| 1895 visibility specifiers have a fallback value of true. | |
| 1896 */ ); | |
| 1897 Vdefault_toolbar_visible_p = Fmake_specifier (Qboolean); | |
| 1898 set_specifier_caching (Vdefault_toolbar_visible_p, | |
| 438 | 1899 offsetof (struct window, default_toolbar_visible_p), |
| 428 | 1900 default_toolbar_visible_p_changed_in_window, |
| 438 | 1901 offsetof (struct frame, default_toolbar_visible_p), |
| 444 | 1902 default_toolbar_visible_p_changed_in_frame, 0); |
| 428 | 1903 |
| 1904 DEFVAR_SPECIFIER ("top-toolbar-visible-p", | |
| 1905 &Vtoolbar_visible_p[TOP_TOOLBAR] /* | |
| 1906 *Whether the top toolbar is visible. | |
| 1907 This is a specifier; use `set-specifier' to change it. | |
| 1908 | |
| 1909 See `default-toolbar-visible-p' for more information. | |
| 1910 */ ); | |
| 1911 Vtoolbar_visible_p[TOP_TOOLBAR] = Fmake_specifier (Qboolean); | |
| 1912 set_specifier_caching (Vtoolbar_visible_p[TOP_TOOLBAR], | |
| 438 | 1913 offsetof (struct window, |
| 1914 toolbar_visible_p[TOP_TOOLBAR]), | |
| 428 | 1915 toolbar_geometry_changed_in_window, |
| 438 | 1916 offsetof (struct frame, |
| 1917 toolbar_visible_p[TOP_TOOLBAR]), | |
| 444 | 1918 frame_size_slipped, 0); |
| 428 | 1919 |
| 1920 DEFVAR_SPECIFIER ("bottom-toolbar-visible-p", | |
| 1921 &Vtoolbar_visible_p[BOTTOM_TOOLBAR] /* | |
| 1922 *Whether the bottom toolbar is visible. | |
| 1923 This is a specifier; use `set-specifier' to change it. | |
| 1924 | |
| 1925 See `default-toolbar-visible-p' for more information. | |
| 1926 */ ); | |
| 1927 Vtoolbar_visible_p[BOTTOM_TOOLBAR] = Fmake_specifier (Qboolean); | |
| 1928 set_specifier_caching (Vtoolbar_visible_p[BOTTOM_TOOLBAR], | |
| 438 | 1929 offsetof (struct window, |
| 1930 toolbar_visible_p[BOTTOM_TOOLBAR]), | |
| 428 | 1931 toolbar_geometry_changed_in_window, |
| 438 | 1932 offsetof (struct frame, |
| 1933 toolbar_visible_p[BOTTOM_TOOLBAR]), | |
| 444 | 1934 frame_size_slipped, 0); |
| 428 | 1935 |
| 1936 DEFVAR_SPECIFIER ("left-toolbar-visible-p", | |
| 1937 &Vtoolbar_visible_p[LEFT_TOOLBAR] /* | |
| 1938 *Whether the left toolbar is visible. | |
| 1939 This is a specifier; use `set-specifier' to change it. | |
| 1940 | |
| 1941 See `default-toolbar-visible-p' for more information. | |
| 1942 */ ); | |
| 1943 Vtoolbar_visible_p[LEFT_TOOLBAR] = Fmake_specifier (Qboolean); | |
| 1944 set_specifier_caching (Vtoolbar_visible_p[LEFT_TOOLBAR], | |
| 438 | 1945 offsetof (struct window, |
| 1946 toolbar_visible_p[LEFT_TOOLBAR]), | |
| 428 | 1947 toolbar_geometry_changed_in_window, |
| 438 | 1948 offsetof (struct frame, |
| 1949 toolbar_visible_p[LEFT_TOOLBAR]), | |
| 444 | 1950 frame_size_slipped, 0); |
| 428 | 1951 |
| 1952 DEFVAR_SPECIFIER ("right-toolbar-visible-p", | |
| 1953 &Vtoolbar_visible_p[RIGHT_TOOLBAR] /* | |
| 1954 *Whether the right toolbar is visible. | |
| 1955 This is a specifier; use `set-specifier' to change it. | |
| 1956 | |
| 1957 See `default-toolbar-visible-p' for more information. | |
| 1958 */ ); | |
| 1959 Vtoolbar_visible_p[RIGHT_TOOLBAR] = Fmake_specifier (Qboolean); | |
| 1960 set_specifier_caching (Vtoolbar_visible_p[RIGHT_TOOLBAR], | |
| 438 | 1961 offsetof (struct window, |
| 1962 toolbar_visible_p[RIGHT_TOOLBAR]), | |
| 428 | 1963 toolbar_geometry_changed_in_window, |
| 438 | 1964 offsetof (struct frame, |
| 1965 toolbar_visible_p[RIGHT_TOOLBAR]), | |
| 444 | 1966 frame_size_slipped, 0); |
| 428 | 1967 |
| 1968 /* initially, top inherits from default; this can be | |
| 1969 changed with `set-default-toolbar-position'. */ | |
| 1970 fb = list1 (Fcons (Qnil, Qt)); | |
| 1971 set_specifier_fallback (Vdefault_toolbar_visible_p, fb); | |
| 1972 set_specifier_fallback (Vtoolbar_visible_p[TOP_TOOLBAR], | |
| 1973 Vdefault_toolbar_visible_p); | |
| 1974 set_specifier_fallback (Vtoolbar_visible_p[BOTTOM_TOOLBAR], fb); | |
| 1975 set_specifier_fallback (Vtoolbar_visible_p[LEFT_TOOLBAR], fb); | |
| 1976 set_specifier_fallback (Vtoolbar_visible_p[RIGHT_TOOLBAR], fb); | |
| 1977 | |
| 1978 DEFVAR_SPECIFIER ("toolbar-buttons-captioned-p", | |
| 1979 &Vtoolbar_buttons_captioned_p /* | |
| 1980 *Whether the toolbar buttons are captioned. | |
| 1981 This will only have a visible effect for those toolbar buttons which had | |
| 1982 captioned versions specified. | |
| 1983 This is a specifier; use `set-specifier' to change it. | |
| 1984 */ ); | |
| 1985 Vtoolbar_buttons_captioned_p = Fmake_specifier (Qboolean); | |
| 1986 set_specifier_caching (Vtoolbar_buttons_captioned_p, | |
| 438 | 1987 offsetof (struct window, toolbar_buttons_captioned_p), |
| 428 | 1988 toolbar_buttons_captioned_p_changed, |
| 444 | 1989 0, 0, 0); |
| 428 | 1990 set_specifier_fallback (Vtoolbar_buttons_captioned_p, |
| 1991 list1 (Fcons (Qnil, Qt))); | |
| 1992 } |