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