428
+ − 1 /* Generic toolbar implementation.
+ − 2 Copyright (C) 1995 Board of Trustees, University of Illinois.
+ − 3 Copyright (C) 1995 Sun Microsystems, Inc.
2367
+ − 4 Copyright (C) 1995, 1996, 2003, 2004 Ben Wing.
428
+ − 5 Copyright (C) 1996 Chuck Thompson.
+ − 6
+ − 7 This file is part of XEmacs.
+ − 8
+ − 9 XEmacs is free software; you can redistribute it and/or modify it
+ − 10 under the terms of the GNU General Public License as published by the
+ − 11 Free Software Foundation; either version 2, or (at your option) any
+ − 12 later version.
+ − 13
+ − 14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
+ − 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ − 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ − 17 for more details.
+ − 18
+ − 19 You should have received a copy of the GNU General Public License
+ − 20 along with XEmacs; see the file COPYING. If not, write to
+ − 21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ − 22 Boston, MA 02111-1307, USA. */
+ − 23
+ − 24 /* Synched up with: Not in FSF. */
+ − 25
+ − 26 /* Original implementation by Chuck Thompson for 19.12.
+ − 27 Default-toolbar-position and specifier-related stuff by Ben Wing. */
+ − 28
+ − 29 #include <config.h>
+ − 30 #include "lisp.h"
+ − 31
+ − 32 #include "buffer.h"
872
+ − 33 #include "frame-impl.h"
+ − 34 #include "device-impl.h"
428
+ − 35 #include "glyphs.h"
+ − 36 #include "redisplay.h"
+ − 37 #include "toolbar.h"
+ − 38 #include "window.h"
+ − 39
+ − 40 Lisp_Object Vtoolbar[4];
+ − 41 Lisp_Object Vtoolbar_size[4];
+ − 42 Lisp_Object Vtoolbar_visible_p[4];
+ − 43 Lisp_Object Vtoolbar_border_width[4];
+ − 44
+ − 45 Lisp_Object Vdefault_toolbar, Vdefault_toolbar_visible_p;
+ − 46 Lisp_Object Vdefault_toolbar_width, Vdefault_toolbar_height;
+ − 47 Lisp_Object Vdefault_toolbar_border_width;
744
+ − 48 Lisp_Object Vtoolbar_shadow_thickness;
428
+ − 49
+ − 50 Lisp_Object Vdefault_toolbar_position;
+ − 51 Lisp_Object Vtoolbar_buttons_captioned_p;
+ − 52
+ − 53 Lisp_Object Qtoolbar_buttonp;
+ − 54 Lisp_Object Q2D, Q3D, Q2d, Q3d;
+ − 55 Lisp_Object Q_size;
+ − 56
+ − 57 Lisp_Object Qinit_toolbar_from_resources;
+ − 58
1204
+ − 59 static const struct memory_description toolbar_button_description [] = {
934
+ − 60 { XD_LISP_OBJECT, offsetof (struct toolbar_button, next) },
+ − 61 { XD_LISP_OBJECT, offsetof (struct toolbar_button, frame) },
+ − 62 { XD_LISP_OBJECT, offsetof (struct toolbar_button, up_glyph) },
+ − 63 { XD_LISP_OBJECT, offsetof (struct toolbar_button, down_glyph) },
+ − 64 { XD_LISP_OBJECT, offsetof (struct toolbar_button, disabled_glyph) },
+ − 65 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_up_glyph) },
+ − 66 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_down_glyph) },
+ − 67 { XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_disabled_glyph) },
+ − 68 { XD_LISP_OBJECT, offsetof (struct toolbar_button, callback) },
+ − 69 { XD_LISP_OBJECT, offsetof (struct toolbar_button, enabled_p) },
+ − 70 { XD_LISP_OBJECT, offsetof (struct toolbar_button, help_string) },
+ − 71 { XD_END }
+ − 72 };
428
+ − 73
+ − 74 static Lisp_Object
+ − 75 mark_toolbar_button (Lisp_Object obj)
+ − 76 {
+ − 77 struct toolbar_button *data = XTOOLBAR_BUTTON (obj);
+ − 78 mark_object (data->next);
+ − 79 mark_object (data->frame);
+ − 80 mark_object (data->up_glyph);
+ − 81 mark_object (data->down_glyph);
+ − 82 mark_object (data->disabled_glyph);
+ − 83 mark_object (data->cap_up_glyph);
+ − 84 mark_object (data->cap_down_glyph);
+ − 85 mark_object (data->cap_disabled_glyph);
+ − 86 mark_object (data->callback);
+ − 87 mark_object (data->enabled_p);
+ − 88 return data->help_string;
+ − 89 }
+ − 90
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
+ − 235 static enum toolbar_pos
+ − 236 decode_toolbar_position (Lisp_Object position)
+ − 237 {
+ − 238 if (EQ (position, Qtop)) return TOP_TOOLBAR;
+ − 239 if (EQ (position, Qbottom)) return BOTTOM_TOOLBAR;
+ − 240 if (EQ (position, Qleft)) return LEFT_TOOLBAR;
+ − 241 if (EQ (position, Qright)) return RIGHT_TOOLBAR;
563
+ − 242 invalid_constant ("Invalid toolbar position", position);
428
+ − 243
1204
+ − 244 RETURN_NOT_REACHED (TOP_TOOLBAR);
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 {
+ − 254 enum toolbar_pos cur = decode_toolbar_position (Vdefault_toolbar_position);
3025
+ − 255 enum toolbar_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_],
+ − 267 new_ == TOP_TOOLBAR || new_ == BOTTOM_TOOLBAR
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
+ − 593 mark_frame_toolbar_buttons_dirty (struct frame *f, enum toolbar_pos pos)
+ − 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
+ − 607 compute_frame_toolbar_buttons (struct frame *f, enum toolbar_pos pos,
+ − 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
+ − 716 set_frame_toolbar (struct frame *f, enum toolbar_pos pos)
+ − 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 {
442
+ − 728 set_frame_toolbar (f, TOP_TOOLBAR);
+ − 729 set_frame_toolbar (f, BOTTOM_TOOLBAR);
+ − 730 set_frame_toolbar (f, LEFT_TOOLBAR);
+ − 731 set_frame_toolbar (f, RIGHT_TOOLBAR);
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
+ − 765 for (pos = 0; pos < 4; pos++)
+ − 766 if (FRAME_REAL_TOOLBAR_SIZE (f, pos)
+ − 767 != FRAME_CURRENT_TOOLBAR_SIZE (f, pos))
1559
+ − 768 frame_size_changed = 1;
428
+ − 769
905
+ − 770 for (pos = 0; pos < 4; pos++) {
428
+ − 771 f->current_toolbar_size[pos] = FRAME_REAL_TOOLBAR_SIZE (f, pos);
905
+ − 772 }
428
+ − 773
+ − 774 /* Removed the check for the minibuffer here. We handle this
+ − 775 more correctly now by consistently using
+ − 776 FRAME_LAST_NONMINIBUF_WINDOW instead of FRAME_SELECTED_WINDOW
+ − 777 throughout the toolbar code. */
+ − 778 compute_frame_toolbars_data (f);
1559
+ − 779
+ − 780 if (frame_size_changed)
+ − 781 {
+ − 782 int width, height;
2367
+ − 783 if (!window_system_pixelated_geometry (wrap_frame (f)))
+ − 784 pixel_to_char_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
+ − 785 &width, &height);
+ − 786 else
+ − 787 width = FRAME_PIXWIDTH (f), height = FRAME_PIXHEIGHT (f);
1559
+ − 788 if (!HAS_FRAMEMETH_P (f, set_frame_size))
+ − 789 change_frame_size (f, height, width, 0);
+ − 790 else
+ − 791 FRAMEMETH (f, set_frame_size, (f, width, height));
+ − 792 MARK_FRAME_LAYOUT_CHANGED (f);
+ − 793 }
905
+ − 794
+ − 795 /* Clear the previous toolbar locations. If we do it later
+ − 796 (after redisplay) we end up clearing what we have just
+ − 797 displayed. */
+ − 798 MAYBE_DEVMETH (d, clear_frame_toolbars, (f));
1559
+ − 799
905
+ − 800 }
+ − 801 }
428
+ − 802
905
+ − 803 /* Actually redisplay the toolbar buttons. */
+ − 804 void
+ − 805 update_frame_toolbars (struct frame *f)
+ − 806 {
+ − 807 struct device *d = XDEVICE (f->device);
+ − 808
+ − 809 if (DEVICE_SUPPORTS_TOOLBARS_P (d)
+ − 810 && (f->toolbar_changed
+ − 811 || f->frame_layout_changed
+ − 812 || f->frame_changed
+ − 813 || f->clear))
+ − 814 {
428
+ − 815 DEVMETH (d, output_frame_toolbars, (f));
+ − 816 }
+ − 817
+ − 818 f->toolbar_changed = 0;
+ − 819 }
+ − 820
+ − 821 void
+ − 822 init_frame_toolbars (struct frame *f)
+ − 823 {
+ − 824 struct device *d = XDEVICE (f->device);
+ − 825
+ − 826 if (DEVICE_SUPPORTS_TOOLBARS_P (d))
+ − 827 {
+ − 828 Lisp_Object frame;
+ − 829 int pos;
+ − 830
+ − 831 compute_frame_toolbars_data (f);
793
+ − 832 frame = wrap_frame (f);
428
+ − 833 call_critical_lisp_code (XDEVICE (FRAME_DEVICE (f)),
+ − 834 Qinit_toolbar_from_resources,
+ − 835 frame);
+ − 836 MAYBE_DEVMETH (d, initialize_frame_toolbars, (f));
+ − 837
+ − 838 /* We are here as far in frame creation so cached specifiers are
+ − 839 already recomputed, and possibly modified by resource
+ − 840 initialization. Remember current toolbar geometry so next
+ − 841 redisplay will not needlessly relayout toolbars. */
+ − 842 for (pos = 0; pos < 4; pos++)
+ − 843 f->current_toolbar_size[pos] = FRAME_REAL_TOOLBAR_SIZE (f, pos);
+ − 844 }
+ − 845 }
+ − 846
+ − 847 void
+ − 848 init_device_toolbars (struct device *d)
+ − 849 {
793
+ − 850 Lisp_Object device = wrap_device (d);
428
+ − 851
+ − 852 if (DEVICE_SUPPORTS_TOOLBARS_P (d))
+ − 853 call_critical_lisp_code (d,
+ − 854 Qinit_toolbar_from_resources,
+ − 855 device);
+ − 856 }
+ − 857
+ − 858 void
+ − 859 init_global_toolbars (struct device *d)
+ − 860 {
+ − 861 if (DEVICE_SUPPORTS_TOOLBARS_P (d))
+ − 862 call_critical_lisp_code (d,
+ − 863 Qinit_toolbar_from_resources,
+ − 864 Qglobal);
+ − 865 }
+ − 866
+ − 867 void
+ − 868 free_frame_toolbars (struct frame *f)
+ − 869 {
+ − 870 /* If we had directly allocated any memory for the toolbars instead
+ − 871 of using all Lisp_Objects this is where we would now free it. */
+ − 872
+ − 873 MAYBE_FRAMEMETH (f, free_frame_toolbars, (f));
+ − 874 }
+ − 875
+ − 876 void
+ − 877 get_toolbar_coords (struct frame *f, enum toolbar_pos pos, int *x, int *y,
+ − 878 int *width, int *height, int *vert, int for_layout)
+ − 879 {
+ − 880 int visible_top_toolbar_height, visible_bottom_toolbar_height;
+ − 881 int adjust = (for_layout ? 1 : 0);
+ − 882
+ − 883 /* The top and bottom toolbars take precedence over the left and
+ − 884 right. */
+ − 885 visible_top_toolbar_height = (FRAME_REAL_TOP_TOOLBAR_VISIBLE (f)
+ − 886 ? FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) +
+ − 887 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f)
+ − 888 : 0);
+ − 889 visible_bottom_toolbar_height = (FRAME_REAL_BOTTOM_TOOLBAR_VISIBLE (f)
+ − 890 ? FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) +
+ − 891 2 *
+ − 892 FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f)
+ − 893 : 0);
+ − 894
+ − 895 /* We adjust the width and height by one to give us a narrow border
+ − 896 at the outside edges. However, when we are simply determining
+ − 897 toolbar location we don't want to do that. */
+ − 898
+ − 899 switch (pos)
+ − 900 {
+ − 901 case TOP_TOOLBAR:
+ − 902 *x = 1;
+ − 903 *y = 0; /* #### should be 1 if no menubar */
+ − 904 *width = FRAME_PIXWIDTH (f) - 2;
+ − 905 *height = FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) +
+ − 906 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f) - adjust;
+ − 907 *vert = 0;
+ − 908 break;
+ − 909 case BOTTOM_TOOLBAR:
+ − 910 *x = 1;
+ − 911 *y = FRAME_PIXHEIGHT (f) - FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) -
+ − 912 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f);
+ − 913 *width = FRAME_PIXWIDTH (f) - 2;
+ − 914 *height = FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) +
+ − 915 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f) - adjust;
+ − 916 *vert = 0;
+ − 917 break;
+ − 918 case LEFT_TOOLBAR:
+ − 919 *x = 1;
+ − 920 *y = visible_top_toolbar_height;
+ − 921 *width = FRAME_REAL_LEFT_TOOLBAR_WIDTH (f) +
+ − 922 2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f) - adjust;
+ − 923 *height = (FRAME_PIXHEIGHT (f) - visible_top_toolbar_height -
+ − 924 visible_bottom_toolbar_height - 1);
+ − 925 *vert = 1;
+ − 926 break;
+ − 927 case RIGHT_TOOLBAR:
+ − 928 *x = FRAME_PIXWIDTH (f) - FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) -
+ − 929 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f);
+ − 930 *y = visible_top_toolbar_height;
+ − 931 *width = FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) +
+ − 932 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f) - adjust;
+ − 933 *height = (FRAME_PIXHEIGHT (f) - visible_top_toolbar_height -
+ − 934 visible_bottom_toolbar_height);
+ − 935 *vert = 1;
+ − 936 break;
+ − 937 default:
2500
+ − 938 ABORT ();
428
+ − 939 }
+ − 940 }
+ − 941
+ − 942 #define CHECK_TOOLBAR(pos) do { \
+ − 943 if (FRAME_REAL_##pos##_VISIBLE (f)) \
+ − 944 { \
+ − 945 int x, y, width, height, vert; \
+ − 946 \
+ − 947 get_toolbar_coords (f, pos, &x, &y, &width, &height, &vert, 0); \
+ − 948 if ((x_coord >= x) && (x_coord < (x + width))) \
+ − 949 { \
+ − 950 if ((y_coord >= y) && (y_coord < (y + height))) \
+ − 951 return FRAME_TOOLBAR_BUTTONS (f, pos); \
+ − 952 } \
+ − 953 } \
+ − 954 } while (0)
+ − 955
+ − 956 static Lisp_Object
+ − 957 toolbar_buttons_at_pixpos (struct frame *f, int x_coord, int y_coord)
+ − 958 {
+ − 959 CHECK_TOOLBAR (TOP_TOOLBAR);
+ − 960 CHECK_TOOLBAR (BOTTOM_TOOLBAR);
+ − 961 CHECK_TOOLBAR (LEFT_TOOLBAR);
+ − 962 CHECK_TOOLBAR (RIGHT_TOOLBAR);
+ − 963
+ − 964 return Qnil;
+ − 965 }
+ − 966 #undef CHECK_TOOLBAR
+ − 967
+ − 968 /* The device dependent code actually does the work of positioning the
+ − 969 buttons, but we are free to access that information at this
+ − 970 level. */
+ − 971 Lisp_Object
+ − 972 toolbar_button_at_pixpos (struct frame *f, int x_coord, int y_coord)
+ − 973 {
+ − 974 Lisp_Object buttons = toolbar_buttons_at_pixpos (f, x_coord, y_coord);
+ − 975
+ − 976 while (!NILP (buttons))
+ − 977 {
+ − 978 struct toolbar_button *tb = XTOOLBAR_BUTTON (buttons);
+ − 979
+ − 980 if ((x_coord >= tb->x) && (x_coord < (tb->x + tb->width)))
+ − 981 {
+ − 982 if ((y_coord >= tb->y) && (y_coord < (tb->y + tb->height)))
+ − 983 {
+ − 984 /* If we are over a blank, return nil. */
+ − 985 if (tb->blank)
+ − 986 return Qnil;
+ − 987 else
+ − 988 return buttons;
+ − 989 }
+ − 990 }
+ − 991
+ − 992 buttons = tb->next;
+ − 993 }
+ − 994
+ − 995 /* We are not over a toolbar or we are over a blank in the toolbar. */
+ − 996 return Qnil;
+ − 997 }
+ − 998
+ − 999
+ − 1000 /************************************************************************/
+ − 1001 /* Toolbar specifier type */
+ − 1002 /************************************************************************/
+ − 1003
+ − 1004 DEFINE_SPECIFIER_TYPE (toolbar);
+ − 1005
563
+ − 1006 #define CTB_ERROR(msg) do { \
+ − 1007 maybe_signal_error (Qinvalid_argument, msg, button, Qtoolbar, errb); \
+ − 1008 RETURN_SANS_WARNINGS Qnil; \
428
+ − 1009 } while (0)
+ − 1010
+ − 1011 /* Returns Q_style if key was :style, Qt if ok otherwise, Qnil if error. */
+ − 1012 static Lisp_Object
+ − 1013 check_toolbar_button_keywords (Lisp_Object button, Lisp_Object key,
578
+ − 1014 Lisp_Object val, Error_Behavior errb)
428
+ − 1015 {
+ − 1016 if (!KEYWORDP (key))
+ − 1017 {
563
+ − 1018 maybe_signal_error_2 (Qinvalid_argument, "Not a keyword", key, button,
+ − 1019 Qtoolbar, errb);
428
+ − 1020 return Qnil;
+ − 1021 }
+ − 1022
+ − 1023 if (EQ (key, Q_style))
+ − 1024 {
+ − 1025 if (!EQ (val, Q2D)
+ − 1026 && !EQ (val, Q3D)
+ − 1027 && !EQ (val, Q2d)
+ − 1028 && !EQ (val, Q3d))
+ − 1029 CTB_ERROR ("Unrecognized toolbar blank style");
+ − 1030
+ − 1031 return Q_style;
+ − 1032 }
+ − 1033 else if (EQ (key, Q_size))
+ − 1034 {
+ − 1035 if (!NATNUMP (val))
+ − 1036 CTB_ERROR ("invalid toolbar blank size");
+ − 1037 }
+ − 1038 else
+ − 1039 {
+ − 1040 CTB_ERROR ("invalid toolbar blank keyword");
+ − 1041 }
+ − 1042
+ − 1043 return Qt;
+ − 1044 }
+ − 1045
+ − 1046 /* toolbar button spec is [pixmap-pair function enabled-p help]
+ − 1047 or [:style 2d-or-3d :size width-or-height] */
+ − 1048
+ − 1049 DEFUN ("check-toolbar-button-syntax", Fcheck_toolbar_button_syntax, 1, 2, 0, /*
+ − 1050 Verify the syntax of entry BUTTON in a toolbar description list.
+ − 1051 If you want to verify the syntax of a toolbar description list as a
3025
+ − 1052 whole, use `check-valid-instantiator' with a specifier type of `toolbar'.
428
+ − 1053 */
444
+ − 1054 (button, noerror))
428
+ − 1055 {
+ − 1056 Lisp_Object *elt, glyphs, value;
+ − 1057 int len;
578
+ − 1058 Error_Behavior errb = decode_error_behavior_flag (noerror);
428
+ − 1059
+ − 1060 if (!VECTORP (button))
+ − 1061 CTB_ERROR ("toolbar button descriptors must be vectors");
+ − 1062 elt = XVECTOR_DATA (button);
+ − 1063
+ − 1064 if (XVECTOR_LENGTH (button) == 2)
+ − 1065 {
+ − 1066 if (!EQ (Q_style, check_toolbar_button_keywords (button, elt[0],
+ − 1067 elt[1], errb)))
+ − 1068 CTB_ERROR ("must specify toolbar blank style");
+ − 1069
+ − 1070 return Qt;
+ − 1071 }
+ − 1072
+ − 1073 if (XVECTOR_LENGTH (button) != 4)
+ − 1074 CTB_ERROR ("toolbar button descriptors must be 2 or 4 long");
+ − 1075
+ − 1076 /* The first element must be a list of glyphs of length 1-6. The
+ − 1077 first entry is the pixmap for the up state, the second for the
+ − 1078 down state, the third for the disabled state, the fourth for the
+ − 1079 captioned up state, the fifth for the captioned down state and
+ − 1080 the sixth for the captioned disabled state. Only the up state is
+ − 1081 mandatory. */
+ − 1082 if (!CONSP (elt[0]))
+ − 1083 {
+ − 1084 /* We can't check the buffer-local here because we don't know
442
+ − 1085 which buffer to check in. #### I think this is a bad thing.
+ − 1086 See if we can't get enough information to this function so
+ − 1087 that it can check.
428
+ − 1088
+ − 1089 #### Wrong. We shouldn't be checking the value at all here.
+ − 1090 The user might set or change the value at any time. */
+ − 1091 value = Fsymbol_value (elt[0]);
+ − 1092
+ − 1093 if (!CONSP (value))
+ − 1094 {
+ − 1095 if (KEYWORDP (elt[0]))
+ − 1096 {
+ − 1097 int fsty = 0;
+ − 1098
+ − 1099 if (EQ (Q_style, check_toolbar_button_keywords (button, elt[0],
+ − 1100 elt[1],
+ − 1101 errb)))
+ − 1102 fsty++;
+ − 1103
+ − 1104 if (EQ (Q_style, check_toolbar_button_keywords (button, elt[2],
+ − 1105 elt[3],
+ − 1106 errb)))
+ − 1107 fsty++;
+ − 1108
+ − 1109 if (!fsty)
+ − 1110 CTB_ERROR ("must specify toolbar blank style");
+ − 1111 else if (EQ (elt[0], elt[2]))
+ − 1112 CTB_ERROR
+ − 1113 ("duplicate keywords in toolbar button blank description");
+ − 1114
+ − 1115 return Qt;
+ − 1116 }
+ − 1117 else
+ − 1118 CTB_ERROR ("first element of button must be a list (of glyphs)");
+ − 1119 }
+ − 1120 }
+ − 1121 else
+ − 1122 value = elt[0];
+ − 1123
+ − 1124 len = XINT (Flength (value));
+ − 1125 if (len < 1)
+ − 1126 CTB_ERROR ("toolbar button glyph list must have at least 1 entry");
+ − 1127
+ − 1128 if (len > 6)
+ − 1129 CTB_ERROR ("toolbar button glyph list can have at most 6 entries");
+ − 1130
+ − 1131 glyphs = value;
+ − 1132 while (!NILP (glyphs))
+ − 1133 {
+ − 1134 if (!GLYPHP (XCAR (glyphs)))
+ − 1135 {
+ − 1136 /* We allow nil for the down and disabled glyphs but not for
+ − 1137 the up glyph. */
+ − 1138 if (EQ (glyphs, value) || !NILP (XCAR (glyphs)))
+ − 1139 {
+ − 1140 CTB_ERROR
+ − 1141 ("all elements of toolbar button glyph list must be glyphs.");
+ − 1142 }
+ − 1143 }
+ − 1144 glyphs = XCDR (glyphs);
+ − 1145 }
+ − 1146
+ − 1147 /* The second element is the function to run when the button is
+ − 1148 activated. We do not do any checking on it because it is legal
+ − 1149 for the function to not be defined until after the toolbar is.
+ − 1150 It is the user's problem to get this right.
+ − 1151
+ − 1152 The third element is either a boolean indicating the enabled
+ − 1153 status or a function used to determine it. Again, it is the
+ − 1154 user's problem if this is wrong.
+ − 1155
+ − 1156 The fourth element, if not nil, must be a string which will be
+ − 1157 displayed as the help echo. */
+ − 1158
+ − 1159 /* #### This should be allowed to be a function returning a string
+ − 1160 as well as just a string. */
+ − 1161 if (!NILP (elt[3]) && !STRINGP (elt[3]))
+ − 1162 CTB_ERROR ("toolbar button help echo string must be a string");
+ − 1163
+ − 1164 return Qt;
+ − 1165 }
+ − 1166 #undef CTB_ERROR
+ − 1167
+ − 1168 static void
+ − 1169 toolbar_validate (Lisp_Object instantiator)
+ − 1170 {
+ − 1171 int pushright_seen = 0;
+ − 1172 Lisp_Object rest;
+ − 1173
+ − 1174 if (NILP (instantiator))
+ − 1175 return;
+ − 1176
+ − 1177 if (!CONSP (instantiator))
563
+ − 1178 sferror ("Toolbar spec must be list or nil", instantiator);
428
+ − 1179
+ − 1180 for (rest = instantiator; !NILP (rest); rest = XCDR (rest))
+ − 1181 {
+ − 1182 if (!CONSP (rest))
563
+ − 1183 sferror ("Bad list in toolbar spec", instantiator);
428
+ − 1184
+ − 1185 if (NILP (XCAR (rest)))
+ − 1186 {
+ − 1187 if (pushright_seen)
563
+ − 1188 sferror
+ − 1189 ("More than one partition (nil) in instantiator description",
+ − 1190 instantiator);
428
+ − 1191 else
+ − 1192 pushright_seen = 1;
+ − 1193 }
+ − 1194 else
+ − 1195 Fcheck_toolbar_button_syntax (XCAR (rest), Qnil);
+ − 1196 }
+ − 1197 }
+ − 1198
+ − 1199 static void
2286
+ − 1200 toolbar_after_change (Lisp_Object UNUSED (specifier),
+ − 1201 Lisp_Object UNUSED (locale))
428
+ − 1202 {
+ − 1203 /* #### This is overkill. I really need to rethink the after-change
+ − 1204 functions to make them easier to use. */
+ − 1205 MARK_TOOLBAR_CHANGED;
+ − 1206 }
+ − 1207
+ − 1208 DEFUN ("toolbar-specifier-p", Ftoolbar_specifier_p, 1, 1, 0, /*
+ − 1209 Return non-nil if OBJECT is a toolbar specifier.
+ − 1210
442
+ − 1211 See `make-toolbar-specifier' for a description of possible toolbar
+ − 1212 instantiators.
428
+ − 1213 */
+ − 1214 (object))
+ − 1215 {
+ − 1216 return TOOLBAR_SPECIFIERP (object) ? Qt : Qnil;
+ − 1217 }
+ − 1218
+ − 1219
+ − 1220 /*
+ − 1221 Helper for invalidating the real specifier when default
+ − 1222 specifier caching changes
+ − 1223 */
+ − 1224 static void
+ − 1225 recompute_overlaying_specifier (Lisp_Object real_one[4])
+ − 1226 {
+ − 1227 enum toolbar_pos pos = decode_toolbar_position (Vdefault_toolbar_position);
+ − 1228 Fset_specifier_dirty_flag (real_one[pos]);
+ − 1229 }
+ − 1230
+ − 1231 static void
2286
+ − 1232 toolbar_specs_changed (Lisp_Object UNUSED (specifier),
+ − 1233 struct window *UNUSED (w),
+ − 1234 Lisp_Object UNUSED (oldval))
428
+ − 1235 {
+ − 1236 /* This could be smarter but I doubt that it would make any
+ − 1237 noticeable difference given the infrequency with which this is
+ − 1238 probably going to be called.
+ − 1239 */
+ − 1240 MARK_TOOLBAR_CHANGED;
+ − 1241 }
+ − 1242
+ − 1243 static void
2286
+ − 1244 default_toolbar_specs_changed (Lisp_Object UNUSED (specifier),
+ − 1245 struct window *UNUSED (w),
+ − 1246 Lisp_Object UNUSED (oldval))
428
+ − 1247 {
+ − 1248 recompute_overlaying_specifier (Vtoolbar);
+ − 1249 }
+ − 1250
+ − 1251 static void
2286
+ − 1252 default_toolbar_size_changed_in_frame (Lisp_Object UNUSED (specifier),
+ − 1253 struct frame *UNUSED (f),
+ − 1254 Lisp_Object UNUSED (oldval))
428
+ − 1255 {
+ − 1256 recompute_overlaying_specifier (Vtoolbar_size);
+ − 1257 }
+ − 1258
+ − 1259 static void
2286
+ − 1260 default_toolbar_border_width_changed_in_frame (Lisp_Object UNUSED (specifier),
+ − 1261 struct frame *UNUSED (f),
+ − 1262 Lisp_Object UNUSED (oldval))
428
+ − 1263 {
+ − 1264 recompute_overlaying_specifier (Vtoolbar_border_width);
+ − 1265 }
+ − 1266
+ − 1267 static void
2286
+ − 1268 default_toolbar_visible_p_changed_in_frame (Lisp_Object UNUSED (specifier),
+ − 1269 struct frame *UNUSED (f),
+ − 1270 Lisp_Object UNUSED (oldval))
428
+ − 1271 {
+ − 1272 recompute_overlaying_specifier (Vtoolbar_visible_p);
+ − 1273 }
+ − 1274
+ − 1275 static void
2286
+ − 1276 toolbar_geometry_changed_in_window (Lisp_Object UNUSED (specifier),
+ − 1277 struct window *w,
+ − 1278 Lisp_Object UNUSED (oldval))
428
+ − 1279 {
+ − 1280 MARK_TOOLBAR_CHANGED;
+ − 1281 MARK_WINDOWS_CHANGED (w);
+ − 1282 }
+ − 1283
+ − 1284 static void
2286
+ − 1285 default_toolbar_size_changed_in_window (Lisp_Object UNUSED (specifier),
+ − 1286 struct window *UNUSED (w),
+ − 1287 Lisp_Object UNUSED (oldval))
428
+ − 1288 {
+ − 1289 recompute_overlaying_specifier (Vtoolbar_size);
+ − 1290 }
+ − 1291
+ − 1292 static void
2286
+ − 1293 default_toolbar_border_width_changed_in_window (Lisp_Object UNUSED (specifier),
+ − 1294 struct window *UNUSED (w),
+ − 1295 Lisp_Object UNUSED (oldval))
428
+ − 1296 {
+ − 1297 recompute_overlaying_specifier (Vtoolbar_border_width);
+ − 1298 }
+ − 1299
+ − 1300 static void
2286
+ − 1301 default_toolbar_visible_p_changed_in_window (Lisp_Object UNUSED (specifier),
+ − 1302 struct window *UNUSED (w),
+ − 1303 Lisp_Object UNUSED (oldval))
428
+ − 1304 {
+ − 1305 recompute_overlaying_specifier (Vtoolbar_visible_p);
+ − 1306 }
+ − 1307
+ − 1308 static void
2286
+ − 1309 toolbar_buttons_captioned_p_changed (Lisp_Object UNUSED (specifier),
+ − 1310 struct window *UNUSED (w),
+ − 1311 Lisp_Object UNUSED (oldval))
428
+ − 1312 {
+ − 1313 /* This could be smarter but I doubt that it would make any
+ − 1314 noticeable difference given the infrequency with which this is
+ − 1315 probably going to be called. */
+ − 1316 MARK_TOOLBAR_CHANGED;
+ − 1317 }
+ − 1318
744
+ − 1319 static void
2286
+ − 1320 toolbar_shadows_changed (Lisp_Object UNUSED (specifier),
+ − 1321 struct window *w,
+ − 1322 Lisp_Object UNUSED (oldval))
744
+ − 1323 {
+ − 1324 struct frame *f = XFRAME (w->frame);
+ − 1325
+ − 1326 if (!f->frame_data)
+ − 1327 {
+ − 1328 /* If there is not frame data yet, we need to get the hell out
+ − 1329 ** of here. This can happen when the initial frame is being
+ − 1330 ** created and we set our specifiers internally.
+ − 1331 */
+ − 1332 return;
+ − 1333 }
+ − 1334 MAYBE_DEVMETH (XDEVICE (f->device), redraw_frame_toolbars, (f));
+ − 1335 }
+ − 1336
428
+ − 1337
+ − 1338 void
+ − 1339 syms_of_toolbar (void)
+ − 1340 {
442
+ − 1341 INIT_LRECORD_IMPLEMENTATION (toolbar_button);
+ − 1342
563
+ − 1343 DEFSYMBOL_MULTIWORD_PREDICATE (Qtoolbar_buttonp);
+ − 1344 DEFSYMBOL (Q2D);
+ − 1345 DEFSYMBOL (Q3D);
+ − 1346 DEFSYMBOL (Q2d);
+ − 1347 DEFSYMBOL (Q3d);
+ − 1348 DEFKEYWORD (Q_size);
428
+ − 1349
563
+ − 1350 DEFSYMBOL (Qinit_toolbar_from_resources);
428
+ − 1351 DEFSUBR (Ftoolbar_button_p);
+ − 1352 DEFSUBR (Ftoolbar_button_callback);
+ − 1353 DEFSUBR (Ftoolbar_button_help_string);
+ − 1354 DEFSUBR (Ftoolbar_button_enabled_p);
+ − 1355 DEFSUBR (Fset_toolbar_button_down_flag);
+ − 1356 DEFSUBR (Fcheck_toolbar_button_syntax);
+ − 1357 DEFSUBR (Fset_default_toolbar_position);
+ − 1358 DEFSUBR (Fdefault_toolbar_position);
+ − 1359 DEFSUBR (Ftoolbar_specifier_p);
+ − 1360 }
+ − 1361
+ − 1362 void
+ − 1363 vars_of_toolbar (void)
+ − 1364 {
+ − 1365 staticpro (&Vdefault_toolbar_position);
+ − 1366 Vdefault_toolbar_position = Qtop;
+ − 1367
+ − 1368 #ifdef HAVE_WINDOW_SYSTEM
+ − 1369 Fprovide (Qtoolbar);
+ − 1370 #endif
+ − 1371 }
+ − 1372
+ − 1373 void
+ − 1374 specifier_type_create_toolbar (void)
+ − 1375 {
+ − 1376 INITIALIZE_SPECIFIER_TYPE (toolbar, "toolbar", "toolbar-specifier-p");
+ − 1377
+ − 1378 SPECIFIER_HAS_METHOD (toolbar, validate);
+ − 1379 SPECIFIER_HAS_METHOD (toolbar, after_change);
+ − 1380 }
+ − 1381
+ − 1382 void
+ − 1383 reinit_specifier_type_create_toolbar (void)
+ − 1384 {
+ − 1385 REINITIALIZE_SPECIFIER_TYPE (toolbar);
+ − 1386 }
+ − 1387
+ − 1388 void
+ − 1389 specifier_vars_of_toolbar (void)
+ − 1390 {
+ − 1391 Lisp_Object fb;
+ − 1392
+ − 1393 DEFVAR_SPECIFIER ("default-toolbar", &Vdefault_toolbar /*
+ − 1394 Specifier for a fallback toolbar.
+ − 1395 Use `set-specifier' to change this.
+ − 1396
+ − 1397 The position of this toolbar is specified in the function
+ − 1398 `default-toolbar-position'. If the corresponding position-specific
3025
+ − 1399 toolbar (e.g. `top-toolbar' if `default-toolbar-position' is `top')
428
+ − 1400 does not specify a toolbar in a particular domain (usually a window),
+ − 1401 then the value of `default-toolbar' in that domain, if any, will be
+ − 1402 used instead.
+ − 1403
+ − 1404 Note that the toolbar at any particular position will not be
+ − 1405 displayed unless its visibility flag is true and its thickness
+ − 1406 \(width or height, depending on orientation) is non-zero. The
+ − 1407 visibility is controlled by the specifiers `top-toolbar-visible-p',
+ − 1408 `bottom-toolbar-visible-p', `left-toolbar-visible-p', and
+ − 1409 `right-toolbar-visible-p', and the thickness is controlled by the
+ − 1410 specifiers `top-toolbar-height', `bottom-toolbar-height',
+ − 1411 `left-toolbar-width', and `right-toolbar-width'.
+ − 1412
+ − 1413 Note that one of the four visibility specifiers inherits from
+ − 1414 `default-toolbar-visibility' and one of the four thickness
+ − 1415 specifiers inherits from either `default-toolbar-width' or
+ − 1416 `default-toolbar-height' (depending on orientation), just
+ − 1417 like for the toolbar description specifiers (e.g. `top-toolbar')
+ − 1418 mentioned above.
+ − 1419
+ − 1420 Therefore, if you are setting `default-toolbar', you should control
+ − 1421 the visibility and thickness using `default-toolbar-visible-p',
+ − 1422 `default-toolbar-width', and `default-toolbar-height', rather than
+ − 1423 using position-specific specifiers. That way, you will get sane
+ − 1424 behavior if the user changes the default toolbar position.
+ − 1425
+ − 1426 The format of the instantiator for a toolbar is a list of
+ − 1427 toolbar-button-descriptors. Each toolbar-button-descriptor
+ − 1428 is a vector in one of the following formats:
+ − 1429
+ − 1430 [GLYPH-LIST FUNCTION ENABLED-P HELP] or
+ − 1431 [:style 2D-OR-3D] or
+ − 1432 [:style 2D-OR-3D :size WIDTH-OR-HEIGHT] or
+ − 1433 [:size WIDTH-OR-HEIGHT :style 2D-OR-3D]
+ − 1434
+ − 1435 Optionally, one of the toolbar-button-descriptors may be nil
+ − 1436 instead of a vector; this signifies the division between
+ − 1437 the toolbar buttons that are to be displayed flush-left,
+ − 1438 and the buttons to be displayed flush-right.
+ − 1439
+ − 1440 The first vector format above specifies a normal toolbar button;
+ − 1441 the others specify blank areas in the toolbar.
+ − 1442
+ − 1443 For the first vector format:
+ − 1444
+ − 1445 -- GLYPH-LIST should be a list of one to six glyphs (as created by
+ − 1446 `make-glyph') or a symbol whose value is such a list. The first
+ − 1447 glyph, which must be provided, is the glyph used to display the
+ − 1448 toolbar button when it is in the "up" (not pressed) state. The
+ − 1449 optional second glyph is for displaying the button when it is in
+ − 1450 the "down" (pressed) state. The optional third glyph is for when
+ − 1451 the button is disabled. The optional fourth, fifth and sixth glyphs
+ − 1452 are used to specify captioned versions for the up, down and disabled
+ − 1453 states respectively. The function `toolbar-make-button-list' is
+ − 1454 useful in creating these glyph lists. The specifier variable
+ − 1455 `toolbar-buttons-captioned-p' controls which glyphs are actually used.
+ − 1456
+ − 1457 -- Even if you do not provide separate down-state and disabled-state
+ − 1458 glyphs, the user will still get visual feedback to indicate which
+ − 1459 state the button is in. Buttons in the up-state are displayed
+ − 1460 with a shadowed border that gives a raised appearance to the
+ − 1461 button. Buttons in the down-state are displayed with shadows that
+ − 1462 give a recessed appearance. Buttons in the disabled state are
+ − 1463 displayed with no shadows, giving a 2-d effect.
+ − 1464
+ − 1465 -- If some of the toolbar glyphs are not provided, they inherit as follows:
+ − 1466
+ − 1467 UP: up
+ − 1468 DOWN: down -> up
+ − 1469 DISABLED: disabled -> up
+ − 1470 CAP-UP: cap-up -> up
+ − 1471 CAP-DOWN: cap-down -> cap-up -> down -> up
+ − 1472 CAP-DISABLED: cap-disabled -> cap-up -> disabled -> up
+ − 1473
+ − 1474 -- The second element FUNCTION is a function to be called when the
+ − 1475 toolbar button is activated (i.e. when the mouse is released over
+ − 1476 the toolbar button, if the press occurred in the toolbar). It
+ − 1477 can be any form accepted by `call-interactively', since this is
+ − 1478 how it is invoked.
+ − 1479
+ − 1480 -- The third element ENABLED-P specifies whether the toolbar button
+ − 1481 is enabled (disabled buttons do nothing when they are activated,
+ − 1482 and are displayed differently; see above). It should be either
+ − 1483 a boolean or a form that evaluates to a boolean.
+ − 1484
+ − 1485 -- The fourth element HELP, if non-nil, should be a string. This
+ − 1486 string is displayed in the echo area when the mouse passes over
+ − 1487 the toolbar button.
+ − 1488
+ − 1489 For the other vector formats (specifying blank areas of the toolbar):
+ − 1490
3025
+ − 1491 -- 2D-OR-3D should be one of the symbols `2d' or `3d', indicating
428
+ − 1492 whether the area is displayed with shadows (giving it a raised,
+ − 1493 3-d appearance) or without shadows (giving it a flat appearance).
+ − 1494
+ − 1495 -- WIDTH-OR-HEIGHT specifies the length, in pixels, of the blank
+ − 1496 area. If omitted, it defaults to a device-specific value
+ − 1497 (8 pixels for X devices).
+ − 1498 */ );
+ − 1499
+ − 1500 Vdefault_toolbar = Fmake_specifier (Qtoolbar);
+ − 1501 /* #### It would be even nicer if the specifier caching
+ − 1502 automatically knew about specifier fallbacks, so we didn't
+ − 1503 have to do it ourselves. */
+ − 1504 set_specifier_caching (Vdefault_toolbar,
438
+ − 1505 offsetof (struct window, default_toolbar),
428
+ − 1506 default_toolbar_specs_changed,
444
+ − 1507 0, 0, 0);
428
+ − 1508
+ − 1509 DEFVAR_SPECIFIER ("top-toolbar",
+ − 1510 &Vtoolbar[TOP_TOOLBAR] /*
+ − 1511 Specifier for the toolbar at the top of the frame.
+ − 1512 Use `set-specifier' to change this.
+ − 1513 See `default-toolbar' for a description of a valid toolbar instantiator.
+ − 1514 */ );
+ − 1515 Vtoolbar[TOP_TOOLBAR] = Fmake_specifier (Qtoolbar);
+ − 1516 set_specifier_caching (Vtoolbar[TOP_TOOLBAR],
438
+ − 1517 offsetof (struct window, toolbar[TOP_TOOLBAR]),
428
+ − 1518 toolbar_specs_changed,
444
+ − 1519 0, 0, 0);
428
+ − 1520
+ − 1521 DEFVAR_SPECIFIER ("bottom-toolbar",
+ − 1522 &Vtoolbar[BOTTOM_TOOLBAR] /*
+ − 1523 Specifier for the toolbar at the bottom of the frame.
+ − 1524 Use `set-specifier' to change this.
+ − 1525 See `default-toolbar' for a description of a valid toolbar instantiator.
+ − 1526
+ − 1527 Note that, unless the `default-toolbar-position' is `bottom', by
+ − 1528 default the height of the bottom toolbar (controlled by
+ − 1529 `bottom-toolbar-height') is 0; thus, a bottom toolbar will not be
+ − 1530 displayed even if you provide a value for `bottom-toolbar'.
+ − 1531 */ );
+ − 1532 Vtoolbar[BOTTOM_TOOLBAR] = Fmake_specifier (Qtoolbar);
+ − 1533 set_specifier_caching (Vtoolbar[BOTTOM_TOOLBAR],
438
+ − 1534 offsetof (struct window, toolbar[BOTTOM_TOOLBAR]),
428
+ − 1535 toolbar_specs_changed,
444
+ − 1536 0, 0, 0);
428
+ − 1537
+ − 1538 DEFVAR_SPECIFIER ("left-toolbar",
+ − 1539 &Vtoolbar[LEFT_TOOLBAR] /*
+ − 1540 Specifier for the toolbar at the left edge of the frame.
+ − 1541 Use `set-specifier' to change this.
+ − 1542 See `default-toolbar' for a description of a valid toolbar instantiator.
+ − 1543
+ − 1544 Note that, unless the `default-toolbar-position' is `left', by
+ − 1545 default the height of the left toolbar (controlled by
+ − 1546 `left-toolbar-width') is 0; thus, a left toolbar will not be
+ − 1547 displayed even if you provide a value for `left-toolbar'.
+ − 1548 */ );
+ − 1549 Vtoolbar[LEFT_TOOLBAR] = Fmake_specifier (Qtoolbar);
+ − 1550 set_specifier_caching (Vtoolbar[LEFT_TOOLBAR],
438
+ − 1551 offsetof (struct window, toolbar[LEFT_TOOLBAR]),
428
+ − 1552 toolbar_specs_changed,
444
+ − 1553 0, 0, 0);
428
+ − 1554
+ − 1555 DEFVAR_SPECIFIER ("right-toolbar",
+ − 1556 &Vtoolbar[RIGHT_TOOLBAR] /*
+ − 1557 Specifier for the toolbar at the right edge of the frame.
+ − 1558 Use `set-specifier' to change this.
+ − 1559 See `default-toolbar' for a description of a valid toolbar instantiator.
+ − 1560
+ − 1561 Note that, unless the `default-toolbar-position' is `right', by
+ − 1562 default the height of the right toolbar (controlled by
+ − 1563 `right-toolbar-width') is 0; thus, a right toolbar will not be
+ − 1564 displayed even if you provide a value for `right-toolbar'.
+ − 1565 */ );
+ − 1566 Vtoolbar[RIGHT_TOOLBAR] = Fmake_specifier (Qtoolbar);
+ − 1567 set_specifier_caching (Vtoolbar[RIGHT_TOOLBAR],
438
+ − 1568 offsetof (struct window, toolbar[RIGHT_TOOLBAR]),
428
+ − 1569 toolbar_specs_changed,
444
+ − 1570 0, 0, 0);
428
+ − 1571
+ − 1572 /* initially, top inherits from default; this can be
+ − 1573 changed with `set-default-toolbar-position'. */
+ − 1574 fb = list1 (Fcons (Qnil, Qnil));
+ − 1575 set_specifier_fallback (Vdefault_toolbar, fb);
+ − 1576 set_specifier_fallback (Vtoolbar[TOP_TOOLBAR], Vdefault_toolbar);
+ − 1577 set_specifier_fallback (Vtoolbar[BOTTOM_TOOLBAR], fb);
+ − 1578 set_specifier_fallback (Vtoolbar[LEFT_TOOLBAR], fb);
+ − 1579 set_specifier_fallback (Vtoolbar[RIGHT_TOOLBAR], fb);
+ − 1580
+ − 1581 DEFVAR_SPECIFIER ("default-toolbar-height", &Vdefault_toolbar_height /*
+ − 1582 *Height of the default toolbar, if it's oriented horizontally.
+ − 1583 This is a specifier; use `set-specifier' to change it.
+ − 1584
+ − 1585 The position of the default toolbar is specified by the function
+ − 1586 `set-default-toolbar-position'. If the corresponding position-specific
+ − 1587 toolbar thickness specifier (e.g. `top-toolbar-height' if
3025
+ − 1588 `default-toolbar-position' is `top') does not specify a thickness in a
428
+ − 1589 particular domain (a window or a frame), then the value of
+ − 1590 `default-toolbar-height' or `default-toolbar-width' (depending on the
+ − 1591 toolbar orientation) in that domain, if any, will be used instead.
+ − 1592
+ − 1593 Note that `default-toolbar-height' is only used when
3025
+ − 1594 `default-toolbar-position' is `top' or `bottom', and `default-toolbar-width'
+ − 1595 is only used when `default-toolbar-position' is `left' or `right'.
428
+ − 1596
+ − 1597 Note that all of the position-specific toolbar thickness specifiers
+ − 1598 have a fallback value of zero when they do not correspond to the
+ − 1599 default toolbar. Therefore, you will have to set a non-zero thickness
+ − 1600 value if you want a position-specific toolbar to be displayed.
+ − 1601
+ − 1602 Internally, toolbar thickness specifiers are instantiated in both
+ − 1603 window and frame domains, for different purposes. The value in the
+ − 1604 domain of a frame's selected window specifies the actual toolbar
+ − 1605 thickness that you will see in that frame. The value in the domain of
+ − 1606 a frame itself specifies the toolbar thickness that is used in frame
+ − 1607 geometry calculations.
+ − 1608
+ − 1609 Thus, for example, if you set the frame width to 80 characters and the
+ − 1610 left toolbar width for that frame to 68 pixels, then the frame will
+ − 1611 be sized to fit 80 characters plus a 68-pixel left toolbar. If you
+ − 1612 then set the left toolbar width to 0 for a particular buffer (or if
+ − 1613 that buffer does not specify a left toolbar or has a nil value
+ − 1614 specified for `left-toolbar-visible-p'), you will find that, when
+ − 1615 that buffer is displayed in the selected window, the window will have
+ − 1616 a width of 86 or 87 characters -- the frame is sized for a 68-pixel
+ − 1617 left toolbar but the selected window specifies that the left toolbar
+ − 1618 is not visible, so it is expanded to take up the slack.
+ − 1619 */ );
+ − 1620 Vdefault_toolbar_height = Fmake_specifier (Qnatnum);
+ − 1621 set_specifier_caching (Vdefault_toolbar_height,
438
+ − 1622 offsetof (struct window, default_toolbar_height),
428
+ − 1623 default_toolbar_size_changed_in_window,
438
+ − 1624 offsetof (struct frame, default_toolbar_height),
444
+ − 1625 default_toolbar_size_changed_in_frame, 0);
428
+ − 1626
+ − 1627 DEFVAR_SPECIFIER ("default-toolbar-width", &Vdefault_toolbar_width /*
+ − 1628 *Width of the default toolbar, if it's oriented vertically.
+ − 1629 This is a specifier; use `set-specifier' to change it.
+ − 1630
+ − 1631 See `default-toolbar-height' for more information.
+ − 1632 */ );
+ − 1633 Vdefault_toolbar_width = Fmake_specifier (Qnatnum);
+ − 1634 set_specifier_caching (Vdefault_toolbar_width,
438
+ − 1635 offsetof (struct window, default_toolbar_width),
428
+ − 1636 default_toolbar_size_changed_in_window,
438
+ − 1637 offsetof (struct frame, default_toolbar_width),
444
+ − 1638 default_toolbar_size_changed_in_frame, 0);
428
+ − 1639
+ − 1640 DEFVAR_SPECIFIER ("top-toolbar-height",
+ − 1641 &Vtoolbar_size[TOP_TOOLBAR] /*
+ − 1642 *Height of the top toolbar.
+ − 1643 This is a specifier; use `set-specifier' to change it.
+ − 1644
+ − 1645 See `default-toolbar-height' for more information.
+ − 1646 */ );
+ − 1647 Vtoolbar_size[TOP_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1648 set_specifier_caching (Vtoolbar_size[TOP_TOOLBAR],
438
+ − 1649 offsetof (struct window, toolbar_size[TOP_TOOLBAR]),
428
+ − 1650 toolbar_geometry_changed_in_window,
438
+ − 1651 offsetof (struct frame, toolbar_size[TOP_TOOLBAR]),
444
+ − 1652 frame_size_slipped, 0);
428
+ − 1653
+ − 1654 DEFVAR_SPECIFIER ("bottom-toolbar-height",
+ − 1655 &Vtoolbar_size[BOTTOM_TOOLBAR] /*
+ − 1656 *Height of the bottom toolbar.
+ − 1657 This is a specifier; use `set-specifier' to change it.
+ − 1658
+ − 1659 See `default-toolbar-height' for more information.
+ − 1660 */ );
+ − 1661 Vtoolbar_size[BOTTOM_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1662 set_specifier_caching (Vtoolbar_size[BOTTOM_TOOLBAR],
438
+ − 1663 offsetof (struct window, toolbar_size[BOTTOM_TOOLBAR]),
428
+ − 1664 toolbar_geometry_changed_in_window,
438
+ − 1665 offsetof (struct frame, toolbar_size[BOTTOM_TOOLBAR]),
444
+ − 1666 frame_size_slipped, 0);
428
+ − 1667
+ − 1668 DEFVAR_SPECIFIER ("left-toolbar-width",
+ − 1669 &Vtoolbar_size[LEFT_TOOLBAR] /*
+ − 1670 *Width of left toolbar.
+ − 1671 This is a specifier; use `set-specifier' to change it.
+ − 1672
+ − 1673 See `default-toolbar-height' for more information.
+ − 1674 */ );
+ − 1675 Vtoolbar_size[LEFT_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1676 set_specifier_caching (Vtoolbar_size[LEFT_TOOLBAR],
438
+ − 1677 offsetof (struct window, toolbar_size[LEFT_TOOLBAR]),
428
+ − 1678 toolbar_geometry_changed_in_window,
438
+ − 1679 offsetof (struct frame, toolbar_size[LEFT_TOOLBAR]),
444
+ − 1680 frame_size_slipped, 0);
428
+ − 1681
+ − 1682 DEFVAR_SPECIFIER ("right-toolbar-width",
+ − 1683 &Vtoolbar_size[RIGHT_TOOLBAR] /*
+ − 1684 *Width of right toolbar.
+ − 1685 This is a specifier; use `set-specifier' to change it.
+ − 1686
+ − 1687 See `default-toolbar-height' for more information.
+ − 1688 */ );
+ − 1689 Vtoolbar_size[RIGHT_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1690 set_specifier_caching (Vtoolbar_size[RIGHT_TOOLBAR],
438
+ − 1691 offsetof (struct window, toolbar_size[RIGHT_TOOLBAR]),
428
+ − 1692 toolbar_geometry_changed_in_window,
438
+ − 1693 offsetof (struct frame, toolbar_size[RIGHT_TOOLBAR]),
444
+ − 1694 frame_size_slipped, 0);
428
+ − 1695
744
+ − 1696 DEFVAR_SPECIFIER ("toolbar-shadow-thickness",
+ − 1697 &Vtoolbar_shadow_thickness /*
+ − 1698 *Width of shadows around toolbar buttons.
+ − 1699 This is a specifier; use `set-specifier' to change it.
+ − 1700 */ );
+ − 1701 Vtoolbar_shadow_thickness = Fmake_specifier (Qnatnum);
+ − 1702 set_specifier_caching(Vtoolbar_shadow_thickness,
+ − 1703 offsetof (struct window, toolbar_shadow_thickness),
+ − 1704 toolbar_shadows_changed,
+ − 1705 0,0, 0);
+ − 1706
+ − 1707 fb = Qnil;
+ − 1708
+ − 1709 #ifdef HAVE_TTY
+ − 1710 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
+ − 1711 #endif
+ − 1712 #ifdef HAVE_GTK
+ − 1713 fb = Fcons (Fcons (list1 (Qgtk), make_int (2)), fb);
+ − 1714 #endif
+ − 1715 #ifdef HAVE_X_WINDOWS
+ − 1716 fb = Fcons (Fcons (list1 (Qx), make_int (2)), fb);
+ − 1717 #endif
+ − 1718 #ifdef HAVE_MS_WINDOWS
+ − 1719 fb = Fcons (Fcons (list1 (Qmswindows), make_int (2)), fb);
+ − 1720 #endif
+ − 1721
+ − 1722 if (!NILP (fb))
+ − 1723 set_specifier_fallback (Vtoolbar_shadow_thickness, fb);
+ − 1724
428
+ − 1725 fb = Qnil;
+ − 1726 #ifdef HAVE_TTY
+ − 1727 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
+ − 1728 #endif
462
+ − 1729 #ifdef HAVE_GTK
+ − 1730 fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_HEIGHT)), fb);
+ − 1731 #endif
428
+ − 1732 #ifdef HAVE_X_WINDOWS
+ − 1733 fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_HEIGHT)), fb);
+ − 1734 #endif
+ − 1735 #ifdef HAVE_MS_WINDOWS
442
+ − 1736 fb = Fcons (Fcons (list1 (Qmswindows),
428
+ − 1737 make_int (MSWINDOWS_DEFAULT_TOOLBAR_HEIGHT)), fb);
+ − 1738 #endif
+ − 1739 if (!NILP (fb))
+ − 1740 set_specifier_fallback (Vdefault_toolbar_height, fb);
+ − 1741
+ − 1742 fb = Qnil;
+ − 1743 #ifdef HAVE_TTY
+ − 1744 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
+ − 1745 #endif
462
+ − 1746 #ifdef HAVE_GTK
+ − 1747 fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_WIDTH)), fb);
+ − 1748 #endif
428
+ − 1749 #ifdef HAVE_X_WINDOWS
+ − 1750 fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_WIDTH)), fb);
+ − 1751 #endif
+ − 1752 #ifdef HAVE_MS_WINDOWS
442
+ − 1753 fb = Fcons (Fcons (list1 (Qmswindows),
428
+ − 1754 make_int (MSWINDOWS_DEFAULT_TOOLBAR_WIDTH)), fb);
+ − 1755 #endif
+ − 1756 if (!NILP (fb))
+ − 1757 set_specifier_fallback (Vdefault_toolbar_width, fb);
+ − 1758
+ − 1759 set_specifier_fallback (Vtoolbar_size[TOP_TOOLBAR], Vdefault_toolbar_height);
+ − 1760 fb = list1 (Fcons (Qnil, Qzero));
+ − 1761 set_specifier_fallback (Vtoolbar_size[BOTTOM_TOOLBAR], fb);
+ − 1762 set_specifier_fallback (Vtoolbar_size[LEFT_TOOLBAR], fb);
+ − 1763 set_specifier_fallback (Vtoolbar_size[RIGHT_TOOLBAR], fb);
+ − 1764
+ − 1765 DEFVAR_SPECIFIER ("default-toolbar-border-width",
+ − 1766 &Vdefault_toolbar_border_width /*
+ − 1767 *Width of the border around the default toolbar.
+ − 1768 This is a specifier; use `set-specifier' to change it.
+ − 1769
+ − 1770 The position of the default toolbar is specified by the function
+ − 1771 `set-default-toolbar-position'. If the corresponding position-specific
+ − 1772 toolbar border width specifier (e.g. `top-toolbar-border-width' if
3025
+ − 1773 `default-toolbar-position' is `top') does not specify a border width in a
428
+ − 1774 particular domain (a window or a frame), then the value of
+ − 1775 `default-toolbar-border-width' in that domain, if any, will be used
+ − 1776 instead.
+ − 1777
+ − 1778 Internally, toolbar border width specifiers are instantiated in both
+ − 1779 window and frame domains, for different purposes. The value in the
+ − 1780 domain of a frame's selected window specifies the actual toolbar border
+ − 1781 width that you will see in that frame. The value in the domain of a
+ − 1782 frame itself specifies the toolbar border width that is used in frame
+ − 1783 geometry calculations. Changing the border width value in the frame
+ − 1784 domain will result in a size change in the frame itself, while changing
+ − 1785 the value in a window domain will not.
+ − 1786 */ );
+ − 1787 Vdefault_toolbar_border_width = Fmake_specifier (Qnatnum);
+ − 1788 set_specifier_caching (Vdefault_toolbar_border_width,
438
+ − 1789 offsetof (struct window, default_toolbar_border_width),
428
+ − 1790 default_toolbar_border_width_changed_in_window,
438
+ − 1791 offsetof (struct frame, default_toolbar_border_width),
444
+ − 1792 default_toolbar_border_width_changed_in_frame, 0);
428
+ − 1793
+ − 1794 DEFVAR_SPECIFIER ("top-toolbar-border-width",
+ − 1795 &Vtoolbar_border_width[TOP_TOOLBAR] /*
+ − 1796 *Border width of the top toolbar.
+ − 1797 This is a specifier; use `set-specifier' to change it.
+ − 1798
+ − 1799 See `default-toolbar-height' for more information.
+ − 1800 */ );
+ − 1801 Vtoolbar_border_width[TOP_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1802 set_specifier_caching (Vtoolbar_border_width[TOP_TOOLBAR],
438
+ − 1803 offsetof (struct window,
+ − 1804 toolbar_border_width[TOP_TOOLBAR]),
428
+ − 1805 toolbar_geometry_changed_in_window,
438
+ − 1806 offsetof (struct frame,
+ − 1807 toolbar_border_width[TOP_TOOLBAR]),
444
+ − 1808 frame_size_slipped, 0);
428
+ − 1809
+ − 1810 DEFVAR_SPECIFIER ("bottom-toolbar-border-width",
+ − 1811 &Vtoolbar_border_width[BOTTOM_TOOLBAR] /*
+ − 1812 *Border width of the bottom toolbar.
+ − 1813 This is a specifier; use `set-specifier' to change it.
+ − 1814
+ − 1815 See `default-toolbar-height' for more information.
+ − 1816 */ );
+ − 1817 Vtoolbar_border_width[BOTTOM_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1818 set_specifier_caching (Vtoolbar_border_width[BOTTOM_TOOLBAR],
438
+ − 1819 offsetof (struct window,
+ − 1820 toolbar_border_width[BOTTOM_TOOLBAR]),
428
+ − 1821 toolbar_geometry_changed_in_window,
438
+ − 1822 offsetof (struct frame,
+ − 1823 toolbar_border_width[BOTTOM_TOOLBAR]),
444
+ − 1824 frame_size_slipped, 0);
428
+ − 1825
+ − 1826 DEFVAR_SPECIFIER ("left-toolbar-border-width",
+ − 1827 &Vtoolbar_border_width[LEFT_TOOLBAR] /*
+ − 1828 *Border width of left toolbar.
+ − 1829 This is a specifier; use `set-specifier' to change it.
+ − 1830
+ − 1831 See `default-toolbar-height' for more information.
+ − 1832 */ );
+ − 1833 Vtoolbar_border_width[LEFT_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1834 set_specifier_caching (Vtoolbar_border_width[LEFT_TOOLBAR],
438
+ − 1835 offsetof (struct window,
+ − 1836 toolbar_border_width[LEFT_TOOLBAR]),
428
+ − 1837 toolbar_geometry_changed_in_window,
438
+ − 1838 offsetof (struct frame,
+ − 1839 toolbar_border_width[LEFT_TOOLBAR]),
444
+ − 1840 frame_size_slipped, 0);
428
+ − 1841
+ − 1842 DEFVAR_SPECIFIER ("right-toolbar-border-width",
+ − 1843 &Vtoolbar_border_width[RIGHT_TOOLBAR] /*
+ − 1844 *Border width of right toolbar.
+ − 1845 This is a specifier; use `set-specifier' to change it.
+ − 1846
+ − 1847 See `default-toolbar-height' for more information.
+ − 1848 */ );
+ − 1849 Vtoolbar_border_width[RIGHT_TOOLBAR] = Fmake_specifier (Qnatnum);
+ − 1850 set_specifier_caching (Vtoolbar_border_width[RIGHT_TOOLBAR],
438
+ − 1851 offsetof (struct window,
+ − 1852 toolbar_border_width[RIGHT_TOOLBAR]),
428
+ − 1853 toolbar_geometry_changed_in_window,
438
+ − 1854 offsetof (struct frame,
+ − 1855 toolbar_border_width[RIGHT_TOOLBAR]),
444
+ − 1856 frame_size_slipped, 0);
428
+ − 1857
+ − 1858 fb = Qnil;
+ − 1859 #ifdef HAVE_TTY
+ − 1860 fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
+ − 1861 #endif
+ − 1862 #ifdef HAVE_X_WINDOWS
+ − 1863 fb = Fcons (Fcons (list1 (Qx), make_int (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb);
+ − 1864 #endif
462
+ − 1865 #ifdef HAVE_GTK
+ − 1866 fb = Fcons (Fcons (list1 (Qgtk), make_int (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb);
+ − 1867 #endif
428
+ − 1868 #ifdef HAVE_MS_WINDOWS
+ − 1869 fb = Fcons (Fcons (list1 (Qmswindows), make_int (MSWINDOWS_DEFAULT_TOOLBAR_BORDER_WIDTH)), fb);
+ − 1870 #endif
+ − 1871 if (!NILP (fb))
+ − 1872 set_specifier_fallback (Vdefault_toolbar_border_width, fb);
+ − 1873
+ − 1874 set_specifier_fallback (Vtoolbar_border_width[TOP_TOOLBAR], Vdefault_toolbar_border_width);
+ − 1875 fb = list1 (Fcons (Qnil, Qzero));
+ − 1876 set_specifier_fallback (Vtoolbar_border_width[BOTTOM_TOOLBAR], fb);
+ − 1877 set_specifier_fallback (Vtoolbar_border_width[LEFT_TOOLBAR], fb);
+ − 1878 set_specifier_fallback (Vtoolbar_border_width[RIGHT_TOOLBAR], fb);
+ − 1879
+ − 1880 DEFVAR_SPECIFIER ("default-toolbar-visible-p", &Vdefault_toolbar_visible_p /*
+ − 1881 *Whether the default toolbar is visible.
+ − 1882 This is a specifier; use `set-specifier' to change it.
+ − 1883
+ − 1884 The position of the default toolbar is specified by the function
+ − 1885 `set-default-toolbar-position'. If the corresponding position-specific
+ − 1886 toolbar visibility specifier (e.g. `top-toolbar-visible-p' if
3025
+ − 1887 `default-toolbar-position' is `top') does not specify a visible-p value
428
+ − 1888 in a particular domain (a window or a frame), then the value of
+ − 1889 `default-toolbar-visible-p' in that domain, if any, will be used
+ − 1890 instead.
+ − 1891
+ − 1892 Both window domains and frame domains are used internally, for
+ − 1893 different purposes. The distinction here is exactly the same as
+ − 1894 for thickness specifiers; see `default-toolbar-height' for more
+ − 1895 information.
+ − 1896
+ − 1897 `default-toolbar-visible-p' and all of the position-specific toolbar
+ − 1898 visibility specifiers have a fallback value of true.
+ − 1899 */ );
+ − 1900 Vdefault_toolbar_visible_p = Fmake_specifier (Qboolean);
+ − 1901 set_specifier_caching (Vdefault_toolbar_visible_p,
438
+ − 1902 offsetof (struct window, default_toolbar_visible_p),
428
+ − 1903 default_toolbar_visible_p_changed_in_window,
438
+ − 1904 offsetof (struct frame, default_toolbar_visible_p),
444
+ − 1905 default_toolbar_visible_p_changed_in_frame, 0);
428
+ − 1906
+ − 1907 DEFVAR_SPECIFIER ("top-toolbar-visible-p",
+ − 1908 &Vtoolbar_visible_p[TOP_TOOLBAR] /*
+ − 1909 *Whether the top toolbar is visible.
+ − 1910 This is a specifier; use `set-specifier' to change it.
+ − 1911
+ − 1912 See `default-toolbar-visible-p' for more information.
+ − 1913 */ );
+ − 1914 Vtoolbar_visible_p[TOP_TOOLBAR] = Fmake_specifier (Qboolean);
+ − 1915 set_specifier_caching (Vtoolbar_visible_p[TOP_TOOLBAR],
438
+ − 1916 offsetof (struct window,
+ − 1917 toolbar_visible_p[TOP_TOOLBAR]),
428
+ − 1918 toolbar_geometry_changed_in_window,
438
+ − 1919 offsetof (struct frame,
+ − 1920 toolbar_visible_p[TOP_TOOLBAR]),
444
+ − 1921 frame_size_slipped, 0);
428
+ − 1922
+ − 1923 DEFVAR_SPECIFIER ("bottom-toolbar-visible-p",
+ − 1924 &Vtoolbar_visible_p[BOTTOM_TOOLBAR] /*
+ − 1925 *Whether the bottom toolbar is visible.
+ − 1926 This is a specifier; use `set-specifier' to change it.
+ − 1927
+ − 1928 See `default-toolbar-visible-p' for more information.
+ − 1929 */ );
+ − 1930 Vtoolbar_visible_p[BOTTOM_TOOLBAR] = Fmake_specifier (Qboolean);
+ − 1931 set_specifier_caching (Vtoolbar_visible_p[BOTTOM_TOOLBAR],
438
+ − 1932 offsetof (struct window,
+ − 1933 toolbar_visible_p[BOTTOM_TOOLBAR]),
428
+ − 1934 toolbar_geometry_changed_in_window,
438
+ − 1935 offsetof (struct frame,
+ − 1936 toolbar_visible_p[BOTTOM_TOOLBAR]),
444
+ − 1937 frame_size_slipped, 0);
428
+ − 1938
+ − 1939 DEFVAR_SPECIFIER ("left-toolbar-visible-p",
+ − 1940 &Vtoolbar_visible_p[LEFT_TOOLBAR] /*
+ − 1941 *Whether the left toolbar is visible.
+ − 1942 This is a specifier; use `set-specifier' to change it.
+ − 1943
+ − 1944 See `default-toolbar-visible-p' for more information.
+ − 1945 */ );
+ − 1946 Vtoolbar_visible_p[LEFT_TOOLBAR] = Fmake_specifier (Qboolean);
+ − 1947 set_specifier_caching (Vtoolbar_visible_p[LEFT_TOOLBAR],
438
+ − 1948 offsetof (struct window,
+ − 1949 toolbar_visible_p[LEFT_TOOLBAR]),
428
+ − 1950 toolbar_geometry_changed_in_window,
438
+ − 1951 offsetof (struct frame,
+ − 1952 toolbar_visible_p[LEFT_TOOLBAR]),
444
+ − 1953 frame_size_slipped, 0);
428
+ − 1954
+ − 1955 DEFVAR_SPECIFIER ("right-toolbar-visible-p",
+ − 1956 &Vtoolbar_visible_p[RIGHT_TOOLBAR] /*
+ − 1957 *Whether the right toolbar is visible.
+ − 1958 This is a specifier; use `set-specifier' to change it.
+ − 1959
+ − 1960 See `default-toolbar-visible-p' for more information.
+ − 1961 */ );
+ − 1962 Vtoolbar_visible_p[RIGHT_TOOLBAR] = Fmake_specifier (Qboolean);
+ − 1963 set_specifier_caching (Vtoolbar_visible_p[RIGHT_TOOLBAR],
438
+ − 1964 offsetof (struct window,
+ − 1965 toolbar_visible_p[RIGHT_TOOLBAR]),
428
+ − 1966 toolbar_geometry_changed_in_window,
438
+ − 1967 offsetof (struct frame,
+ − 1968 toolbar_visible_p[RIGHT_TOOLBAR]),
444
+ − 1969 frame_size_slipped, 0);
428
+ − 1970
+ − 1971 /* initially, top inherits from default; this can be
+ − 1972 changed with `set-default-toolbar-position'. */
+ − 1973 fb = list1 (Fcons (Qnil, Qt));
+ − 1974 set_specifier_fallback (Vdefault_toolbar_visible_p, fb);
+ − 1975 set_specifier_fallback (Vtoolbar_visible_p[TOP_TOOLBAR],
+ − 1976 Vdefault_toolbar_visible_p);
+ − 1977 set_specifier_fallback (Vtoolbar_visible_p[BOTTOM_TOOLBAR], fb);
+ − 1978 set_specifier_fallback (Vtoolbar_visible_p[LEFT_TOOLBAR], fb);
+ − 1979 set_specifier_fallback (Vtoolbar_visible_p[RIGHT_TOOLBAR], fb);
+ − 1980
+ − 1981 DEFVAR_SPECIFIER ("toolbar-buttons-captioned-p",
+ − 1982 &Vtoolbar_buttons_captioned_p /*
+ − 1983 *Whether the toolbar buttons are captioned.
+ − 1984 This will only have a visible effect for those toolbar buttons which had
+ − 1985 captioned versions specified.
+ − 1986 This is a specifier; use `set-specifier' to change it.
+ − 1987 */ );
+ − 1988 Vtoolbar_buttons_captioned_p = Fmake_specifier (Qboolean);
+ − 1989 set_specifier_caching (Vtoolbar_buttons_captioned_p,
438
+ − 1990 offsetof (struct window, toolbar_buttons_captioned_p),
428
+ − 1991 toolbar_buttons_captioned_p_changed,
444
+ − 1992 0, 0, 0);
428
+ − 1993 set_specifier_fallback (Vtoolbar_buttons_captioned_p,
+ − 1994 list1 (Fcons (Qnil, Qt)));
+ − 1995 }
