/* Generic toolbar implementation.
Copyright (C) 1995 Board of Trustees, University of Illinois.
Copyright (C) 1995 Sun Microsystems, Inc.
Copyright (C) 1995, 1996, 2003, 2004, 2010 Ben Wing.
Copyright (C) 1996 Chuck Thompson.
This file is part of XEmacs.
XEmacs is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.
XEmacs is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with XEmacs. If not, see . */
/* Synched up with: Not in FSF. */
/* Original implementation by Chuck Thompson for 19.12.
Default-toolbar-position and specifier-related stuff by Ben Wing. */
#include
#include "lisp.h"
#include "buffer.h"
#include "frame-impl.h"
#include "device-impl.h"
#include "glyphs.h"
#include "redisplay.h"
#include "toolbar.h"
#include "window.h"
Lisp_Object Vtoolbar[NUM_EDGES];
Lisp_Object Vtoolbar_size[NUM_EDGES];
Lisp_Object Vtoolbar_visible_p[NUM_EDGES];
Lisp_Object Vtoolbar_border_width[NUM_EDGES];
Lisp_Object Vdefault_toolbar, Vdefault_toolbar_visible_p;
Lisp_Object Vdefault_toolbar_width, Vdefault_toolbar_height;
Lisp_Object Vdefault_toolbar_border_width;
Lisp_Object Vtoolbar_shadow_thickness;
Lisp_Object Vdefault_toolbar_position;
Lisp_Object Vtoolbar_buttons_captioned_p;
Lisp_Object Qtoolbar_buttonp;
Lisp_Object Q2D, Q3D, Q2d, Q3d;
Lisp_Object Q_size;
Lisp_Object Qinit_toolbar_from_resources;
static const struct memory_description toolbar_button_description [] = {
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, next) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, frame) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, up_glyph) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, down_glyph) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, disabled_glyph) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_up_glyph) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_down_glyph) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, cap_disabled_glyph) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, callback) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, enabled_p) },
{ XD_LISP_OBJECT, offsetof (struct toolbar_button, help_string) },
{ XD_END }
};
static Lisp_Object
allocate_toolbar_button (struct frame *f, int pushright)
{
struct toolbar_button *tb;
tb = XTOOLBAR_BUTTON (ALLOC_NORMAL_LISP_OBJECT (toolbar_button));
tb->next = Qnil;
tb->frame = wrap_frame (f);
tb->up_glyph = Qnil;
tb->down_glyph = Qnil;
tb->disabled_glyph = Qnil;
tb->cap_up_glyph = Qnil;
tb->cap_down_glyph = Qnil;
tb->cap_disabled_glyph = Qnil;
tb->callback = Qnil;
tb->enabled_p = Qnil;
tb->help_string = Qnil;
tb->pushright = pushright;
tb->x = tb->y = tb->width = tb->height = -1;
tb->dirty = 1;
return wrap_toolbar_button (tb);
}
static Lisp_Object
mark_toolbar_button (Lisp_Object obj)
{
struct toolbar_button *data = XTOOLBAR_BUTTON (obj);
mark_object (data->next);
mark_object (data->frame);
mark_object (data->up_glyph);
mark_object (data->down_glyph);
mark_object (data->disabled_glyph);
mark_object (data->cap_up_glyph);
mark_object (data->cap_down_glyph);
mark_object (data->cap_disabled_glyph);
mark_object (data->callback);
mark_object (data->enabled_p);
return data->help_string;
}
DEFINE_NODUMP_INTERNAL_LISP_OBJECT ("toolbar-button", toolbar_button,
mark_toolbar_button,
toolbar_button_description,
struct toolbar_button);
DEFUN ("toolbar-button-p", Ftoolbar_button_p, 1, 1, 0, /*
Return non-nil if OBJECT is a toolbar button.
*/
(object))
{
return TOOLBAR_BUTTONP (object) ? Qt : Qnil;
}
/* Only query functions are provided for toolbar buttons. They are
generated and updated from a toolbar description list. Any
directly made changes would be wiped out the first time the toolbar
was marked as dirty and was regenerated. The exception to this is
set-toolbar-button-down-flag. Having this allows us to control the
toolbar from elisp. Since we only trigger the button callbacks on
up-mouse events and we reset the flag first, there shouldn't be any
way for this to get us in trouble (like if someone decides to
change the toolbar from a toolbar callback). */
DEFUN ("toolbar-button-callback", Ftoolbar_button_callback, 1, 1, 0, /*
Return the callback function associated with the toolbar BUTTON.
*/
(button))
{
CHECK_TOOLBAR_BUTTON (button);
return XTOOLBAR_BUTTON (button)->callback;
}
DEFUN ("toolbar-button-help-string", Ftoolbar_button_help_string, 1, 1, 0, /*
Return the help string function associated with the toolbar BUTTON.
*/
(button))
{
CHECK_TOOLBAR_BUTTON (button);
return XTOOLBAR_BUTTON (button)->help_string;
}
DEFUN ("toolbar-button-enabled-p", Ftoolbar_button_enabled_p, 1, 1, 0, /*
Return t if BUTTON is active.
*/
(button))
{
CHECK_TOOLBAR_BUTTON (button);
return XTOOLBAR_BUTTON (button)->enabled ? Qt : Qnil;
}
DEFUN ("set-toolbar-button-down-flag", Fset_toolbar_button_down_flag, 2, 2, 0, /*
Don't touch.
*/
(button, flag))
{
struct toolbar_button *tb;
char old_flag;
CHECK_TOOLBAR_BUTTON (button);
tb = XTOOLBAR_BUTTON (button);
old_flag = tb->down;
/* If the button is ignored, don't do anything. */
if (!tb->enabled)
return Qnil;
/* If flag is nil, unset the down flag, otherwise set it to true.
This also triggers an immediate redraw of the button if the flag
does change. */
if (NILP (flag))
tb->down = 0;
else
tb->down = 1;
if (tb->down != old_flag)
{
struct frame *f = XFRAME (tb->frame);
struct device *d;
if (DEVICEP (f->device))
{
d = XDEVICE (f->device);
if (DEVICE_LIVE_P (XDEVICE (f->device)))
{
tb->dirty = 1;
MAYBE_DEVMETH (d, output_toolbar_button, (f, button));
}
}
}
return Qnil;
}
Lisp_Object
get_toolbar_button_glyph (struct window *w, struct toolbar_button *tb)
{
Lisp_Object glyph = Qnil;
/* The selected glyph logic:
UP: up
DOWN: down -> up
DISABLED: disabled -> up
CAP-UP: cap-up -> up
CAP-DOWN: cap-down -> cap-up -> down -> up
CAP-DISABLED: cap-disabled -> cap-up -> disabled -> up
*/
if (!NILP (w->toolbar_buttons_captioned_p))
{
if (tb->enabled && tb->down)
glyph = tb->cap_down_glyph;
else if (!tb->enabled)
glyph = tb->cap_disabled_glyph;
if (NILP (glyph))
glyph = tb->cap_up_glyph;
}
if (NILP (glyph))
{
if (tb->enabled && tb->down)
glyph = tb->down_glyph;
else if (!tb->enabled)
glyph = tb->disabled_glyph;
}
/* The non-captioned up button is the ultimate fallback. It is
the only one we guarantee exists. */
if (NILP (glyph))
glyph = tb->up_glyph;
return glyph;
}
static enum edge_pos
decode_toolbar_position (Lisp_Object position)
{
if (EQ (position, Qtop)) return TOP_EDGE;
if (EQ (position, Qbottom)) return BOTTOM_EDGE;
if (EQ (position, Qleft)) return LEFT_EDGE;
if (EQ (position, Qright)) return RIGHT_EDGE;
invalid_constant ("Invalid toolbar position", position);
RETURN_NOT_REACHED (TOP_EDGE);
}
DEFUN ("set-default-toolbar-position", Fset_default_toolbar_position, 1, 1, 0, /*
Set the position that the `default-toolbar' will be displayed at.
Valid positions are `top', `bottom', `left' and `right'.
See `default-toolbar-position'.
*/
(position))
{
enum edge_pos cur = decode_toolbar_position (Vdefault_toolbar_position);
enum edge_pos new_ = decode_toolbar_position (position);
if (cur != new_)
{
/* The following calls will automatically cause the dirty
flags to be set; we delay frame size changes to avoid
lots of frame flickering. */
int depth = begin_hold_frame_size_changes ();
set_specifier_fallback (Vtoolbar[cur], list1 (Fcons (Qnil, Qnil)));
set_specifier_fallback (Vtoolbar[new_], Vdefault_toolbar);
set_specifier_fallback (Vtoolbar_size[cur], list1 (Fcons (Qnil, Qzero)));
set_specifier_fallback (Vtoolbar_size[new_],
new_ == TOP_EDGE || new_ == BOTTOM_EDGE
? Vdefault_toolbar_height
: Vdefault_toolbar_width);
set_specifier_fallback (Vtoolbar_border_width[cur],
list1 (Fcons (Qnil, Qzero)));
set_specifier_fallback (Vtoolbar_border_width[new_],
Vdefault_toolbar_border_width);
set_specifier_fallback (Vtoolbar_visible_p[cur],
list1 (Fcons (Qnil, Qt)));
set_specifier_fallback (Vtoolbar_visible_p[new_],
Vdefault_toolbar_visible_p);
Vdefault_toolbar_position = position;
unbind_to (depth);
}
return position;
}
DEFUN ("default-toolbar-position", Fdefault_toolbar_position, 0, 0, 0, /*
Return the position that the `default-toolbar' will be displayed at.
The `default-toolbar' will only be displayed here if the corresponding
position-specific toolbar specifier does not provide a value.
*/
())
{
return Vdefault_toolbar_position;
}
static Lisp_Object
update_toolbar_button (struct frame *f, struct toolbar_button *tb,
Lisp_Object desc, int pushright)
{
Lisp_Object *elt, glyphs, retval, buffer;
struct gcpro gcpro1, gcpro2;
elt = XVECTOR_DATA (desc);
buffer = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->buffer;
if (!tb)
tb = XTOOLBAR_BUTTON (allocate_toolbar_button (f, pushright));
retval = wrap_toolbar_button (tb);
/* Let's make sure nothing gets mucked up by the potential call to
eval farther down. */
GCPRO2 (retval, desc);
glyphs = (CONSP (elt[0]) ? elt[0] : symbol_value_in_buffer (elt[0], buffer));
/* If this is true we have a blank, otherwise it is an actual
button. */
if (KEYWORDP (glyphs))
{
int pos;
int style_seen = 0;
int size_seen = 0;
int len = XVECTOR_LENGTH (desc);
if (!tb->blank)
{
tb->blank = 1;
tb->dirty = 1;
}
for (pos = 0; pos < len; pos += 2)
{
Lisp_Object key = elt[pos];
Lisp_Object val = elt[pos + 1];
if (EQ (key, Q_style))
{
style_seen = 1;
if (EQ (val, Q2D) || EQ (val, Q2d))
{
if (!EQ (Qnil, tb->up_glyph) || !EQ (Qt, tb->disabled_glyph))
{
tb->up_glyph = Qnil;
tb->disabled_glyph = Qt;
tb->dirty = 1;
}
}
else if (EQ (val, Q3D) || (EQ (val, Q3d)))
{
if (!EQ (Qt, tb->up_glyph) || !EQ (Qnil, tb->disabled_glyph))
{
tb->up_glyph = Qt;
tb->disabled_glyph = Qnil;
tb->dirty = 1;
}
}
}
else if (EQ (key, Q_size))
{
size_seen = 1;
if (!EQ (val, tb->down_glyph))
{
tb->down_glyph = val;
tb->dirty = 1;
}
}
}
if (!style_seen)
{
/* The default style is 3D. */
if (!EQ (Qt, tb->up_glyph) || !EQ (Qnil, tb->disabled_glyph))
{
tb->up_glyph = Qt;
tb->disabled_glyph = Qnil;
tb->dirty = 1;
}
}
if (!size_seen)
{
/* The default width is set to nil. The device specific
code will fill it in at its discretion. */
if (!NILP (tb->down_glyph))
{
tb->down_glyph = Qnil;
tb->dirty = 1;
}
}
/* The rest of these fields are not used by blanks. We make
sure they are nulled out in case this button object formerly
represented a real button. */
if (!NILP (tb->callback)
|| !NILP (tb->enabled_p)
|| !NILP (tb->help_string))
{
tb->cap_up_glyph = Qnil;
tb->cap_down_glyph = Qnil;
tb->cap_disabled_glyph = Qnil;
tb->callback = Qnil;
tb->enabled_p = Qnil;
tb->help_string = Qnil;
tb->dirty = 1;
}
}
else
{
if (tb->blank)
{
tb->blank = 0;
tb->dirty = 1;
}
/* We know that we at least have an up_glyph. Well, no, we
don't. The user may have changed the button glyph on us. */
if (CONSP (glyphs))
{
if (!EQ (XCAR (glyphs), tb->up_glyph))
{
tb->up_glyph = XCAR (glyphs);
tb->dirty = 1;
}
glyphs = XCDR (glyphs);
}
else
tb->up_glyph = Qnil;
/* We might have a down_glyph. */
if (CONSP (glyphs))
{
if (!EQ (XCAR (glyphs), tb->down_glyph))
{
tb->down_glyph = XCAR (glyphs);
tb->dirty = 1;
}
glyphs = XCDR (glyphs);
}
else
tb->down_glyph = Qnil;
/* We might have a disabled_glyph. */
if (CONSP (glyphs))
{
if (!EQ (XCAR (glyphs), tb->disabled_glyph))
{
tb->disabled_glyph = XCAR (glyphs);
tb->dirty = 1;
}
glyphs = XCDR (glyphs);
}
else
tb->disabled_glyph = Qnil;
/* We might have a cap_up_glyph. */
if (CONSP (glyphs))
{
if (!EQ (XCAR (glyphs), tb->cap_up_glyph))
{
tb->cap_up_glyph = XCAR (glyphs);
tb->dirty = 1;
}
glyphs = XCDR (glyphs);
}
else
tb->cap_up_glyph = Qnil;
/* We might have a cap_down_glyph. */
if (CONSP (glyphs))
{
if (!EQ (XCAR (glyphs), tb->cap_down_glyph))
{
tb->cap_down_glyph = XCAR (glyphs);
tb->dirty = 1;
}
glyphs = XCDR (glyphs);
}
else
tb->cap_down_glyph = Qnil;
/* We might have a cap_disabled_glyph. */
if (CONSP (glyphs))
{
if (!EQ (XCAR (glyphs), tb->cap_disabled_glyph))
{
tb->cap_disabled_glyph = XCAR (glyphs);
tb->dirty = 1;
}
}
else
tb->cap_disabled_glyph = Qnil;
/* Update the callback. */
if (!EQ (tb->callback, elt[1]))
{
tb->callback = elt[1];
/* This does not have an impact on the display properties of the
button so we do not mark it as dirty if it has changed. */
}
/* Update the enabled field. */
if (!EQ (tb->enabled_p, elt[2]))
{
tb->enabled_p = elt[2];
tb->dirty = 1;
}
/* We always do the following because if the enabled status is
determined by a function its decision may change without us being
able to detect it. */
{
int old_enabled = tb->enabled;
if (NILP (tb->enabled_p))
tb->enabled = 0;
else if (EQ (tb->enabled_p, Qt))
tb->enabled = 1;
else
{
if (NILP (tb->enabled_p) || EQ (tb->enabled_p, Qt))
/* short-circuit the common case for speed */
tb->enabled = !NILP (tb->enabled_p);
else
{
/* #### do we really need to protect this call? */
Lisp_Object result =
eval_in_buffer_trapping_problems
("Error in toolbar enabled-p form",
XBUFFER
(WINDOW_BUFFER
(XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f)))),
tb->enabled_p, 0);
if (UNBOUNDP (result))
/* #### if there was an error in the enabled-p
form, should we pretend like it's enabled
or disabled? */
tb->enabled = 0;
else
tb->enabled = !NILP (result);
}
}
if (old_enabled != tb->enabled)
tb->dirty = 1;
}
/* Update the help echo string. */
if (!EQ (tb->help_string, elt[3]))
{
tb->help_string = elt[3];
/* This does not have an impact on the display properties of the
button so we do not mark it as dirty if it has changed. */
}
}
/* If this flag changes, the position is changing for sure unless
some very unlikely geometry occurs. */
if (tb->pushright != pushright)
{
tb->pushright = pushright;
tb->dirty = 1;
}
/* The position and size fields are only manipulated in the
device-dependent code. */
UNGCPRO;
return retval;
}
void
mark_frame_toolbar_buttons_dirty (struct frame *f, enum edge_pos pos)
{
Lisp_Object button = FRAME_TOOLBAR_BUTTONS (f, pos);
while (!NILP (button))
{
struct toolbar_button *tb = XTOOLBAR_BUTTON (button);
tb->dirty = 1;
button = tb->next;
}
return;
}
static Lisp_Object
compute_frame_toolbar_buttons (struct frame *f, enum edge_pos pos,
Lisp_Object toolbar)
{
Lisp_Object buttons, prev_button, first_button;
Lisp_Object orig_toolbar = toolbar;
int pushright_seen = 0;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
first_button = FRAME_TOOLBAR_BUTTONS (f, pos);
buttons = prev_button = first_button;
/* Yes, we're being paranoid. */
GCPRO5 (toolbar, buttons, prev_button, first_button, orig_toolbar);
if (NILP (toolbar))
{
/* The output mechanisms will take care of clearing the former
toolbar. */
UNGCPRO;
return Qnil;
}
if (!CONSP (toolbar))
sferror ("toolbar description must be a list", toolbar);
/* First synchronize any existing buttons. */
while (!NILP (toolbar) && !NILP (buttons))
{
struct toolbar_button *tb;
if (NILP (XCAR (toolbar)))
{
if (pushright_seen)
sferror
("more than one partition (nil) in toolbar description",
orig_toolbar);
else
pushright_seen = 1;
}
else
{
tb = XTOOLBAR_BUTTON (buttons);
update_toolbar_button (f, tb, XCAR (toolbar), pushright_seen);
prev_button = buttons;
buttons = tb->next;
}
toolbar = XCDR (toolbar);
}
/* If we hit the end of the toolbar, then clean up any excess
buttons and return. */
if (NILP (toolbar))
{
if (!NILP (buttons))
{
/* If this is the case the only thing we saw was a
pushright marker. */
if (EQ (buttons, first_button))
{
UNGCPRO;
return Qnil;
}
else
XTOOLBAR_BUTTON (prev_button)->next = Qnil;
}
UNGCPRO;
return first_button;
}
/* At this point there are more buttons on the toolbar than we
actually have in existence. */
while (!NILP (toolbar))
{
Lisp_Object new_button;
if (NILP (XCAR (toolbar)))
{
if (pushright_seen)
sferror
("more than one partition (nil) in toolbar description",
orig_toolbar);
else
pushright_seen = 1;
}
else
{
new_button = update_toolbar_button (f, NULL, XCAR (toolbar),
pushright_seen);
if (NILP (first_button))
{
first_button = prev_button = new_button;
}
else
{
XTOOLBAR_BUTTON (prev_button)->next = new_button;
prev_button = new_button;
}
}
toolbar = XCDR (toolbar);
}
UNGCPRO;
return first_button;
}
static void
set_frame_toolbar (struct frame *f, enum edge_pos pos)
{
struct window *w = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f));
Lisp_Object toolbar = w->toolbar[pos];
f->toolbar_buttons[pos] = (FRAME_REAL_TOOLBAR_VISIBLE (f, pos)
? compute_frame_toolbar_buttons (f, pos, toolbar)
: Qnil);
}
static void
compute_frame_toolbars_data (struct frame *f)
{
set_frame_toolbar (f, TOP_EDGE);
set_frame_toolbar (f, BOTTOM_EDGE);
set_frame_toolbar (f, LEFT_EDGE);
set_frame_toolbar (f, RIGHT_EDGE);
}
/* Update the toolbar geometry separately from actually displaying the
toolbar. This is necessary because both the gutter and the toolbar
are competing for redisplay cycles and, unfortunately, gutter
updates happen late in the game. Firstly they are done inside of
redisplay proper and secondly subcontrols may not get moved until
the next screen refresh. Only after subcontrols have been moved to
their final destinations can we be certain of updating the
toolbar. Under X this probably is exacerbated by the toolbar button
dirty flags which prevent updates happening when they possibly
should. */
void
update_frame_toolbars_geometry (struct frame *f)
{
struct device *d = XDEVICE (f->device);
if (DEVICE_SUPPORTS_TOOLBARS_P (d)
&& (f->toolbar_changed
|| f->frame_layout_changed
|| f->frame_changed
|| f->clear))
{
int pos, frame_size_changed = 0;
/* We're not officially "in redisplay", so we still have a
chance to re-layout toolbars and windows. This is done here,
because toolbar is the only thing which currently might
necessitate this layout, as it is outside any windows. We
take care not to change size if toolbar geometry is really
unchanged, as it will hose windows whose pixsizes are not
multiple of character sizes. */
EDGE_POS_LOOP (pos)
if (FRAME_REAL_TOOLBAR_SIZE (f, pos)
!= FRAME_CURRENT_TOOLBAR_SIZE (f, pos))
frame_size_changed = 1;
EDGE_POS_LOOP (pos)
{
f->current_toolbar_size[pos] = FRAME_REAL_TOOLBAR_SIZE (f, pos);
}
/* Removed the check for the minibuffer here. We handle this
more correctly now by consistently using
FRAME_LAST_NONMINIBUF_WINDOW instead of FRAME_SELECTED_WINDOW
throughout the toolbar code. */
compute_frame_toolbars_data (f);
/* #### GEOM! Turning the toolbar on and off repeatedly causes the
frame to steadily shrink. Basically, turning it on doesn't
increase the frame size, while turning it off does reduce the
frame size. The cause has something to do with the combination
of this maybe questionable code here, plus the fact that toolbars
are included in the displayable area, and the difference between
real and theoretical toolbar sizes, and exactly when the various
computations happen w.r.t. the specifiers or whatever that control
whether toolbars are visible and hence whether their thickness is
greater than zero. --ben */
if (frame_size_changed)
{
int width, height;
pixel_to_frame_unit_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
&width, &height);
internal_set_frame_size (f, width, height, 0);
MARK_FRAME_LAYOUT_CHANGED (f);
}
/* Clear the previous toolbar locations. If we do it later
(after redisplay) we end up clearing what we have just
displayed. */
MAYBE_DEVMETH (d, clear_frame_toolbars, (f));
}
}
/* Actually redisplay the toolbar buttons. */
void
update_frame_toolbars (struct frame *f)
{
struct device *d = XDEVICE (f->device);
if (DEVICE_SUPPORTS_TOOLBARS_P (d)
&& (f->toolbar_changed
|| f->frame_layout_changed
|| f->frame_changed
|| f->clear))
{
DEVMETH (d, output_frame_toolbars, (f));
}
f->toolbar_changed = 0;
}
void
init_frame_toolbars (struct frame *f)
{
struct device *d = XDEVICE (f->device);
if (DEVICE_SUPPORTS_TOOLBARS_P (d))
{
Lisp_Object frame;
int pos;
compute_frame_toolbars_data (f);
frame = wrap_frame (f);
call_critical_lisp_code (XDEVICE (FRAME_DEVICE (f)),
Qinit_toolbar_from_resources,
frame);
MAYBE_DEVMETH (d, initialize_frame_toolbars, (f));
/* We are here as far in frame creation so cached specifiers are
already recomputed, and possibly modified by resource
initialization. Remember current toolbar geometry so next
redisplay will not needlessly relayout toolbars. */
EDGE_POS_LOOP (pos)
f->current_toolbar_size[pos] = FRAME_REAL_TOOLBAR_SIZE (f, pos);
}
}
void
init_device_toolbars (struct device *d)
{
Lisp_Object device = wrap_device (d);
if (DEVICE_SUPPORTS_TOOLBARS_P (d))
call_critical_lisp_code (d,
Qinit_toolbar_from_resources,
device);
}
void
init_global_toolbars (struct device *d)
{
if (DEVICE_SUPPORTS_TOOLBARS_P (d))
call_critical_lisp_code (d,
Qinit_toolbar_from_resources,
Qglobal);
}
void
free_frame_toolbars (struct frame *f)
{
/* If we had directly allocated any memory for the toolbars instead
of using all Lisp_Objects this is where we would now free it. */
MAYBE_FRAMEMETH (f, free_frame_toolbars, (f));
}
void
get_toolbar_coords (struct frame *f, enum edge_pos pos, int *x, int *y,
int *width, int *height, int *vert, int for_layout)
{
int visible_top_toolbar_height, visible_bottom_toolbar_height;
int adjust = (for_layout ? 1 : 0);
/* The top and bottom toolbars take precedence over the left and
right. */
visible_top_toolbar_height = (FRAME_REAL_TOP_TOOLBAR_VISIBLE (f)
? FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) +
2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f)
: 0);
visible_bottom_toolbar_height = (FRAME_REAL_BOTTOM_TOOLBAR_VISIBLE (f)
? FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) +
2 *
FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f)
: 0);
/* We adjust the width and height by one to give us a narrow border
at the outside edges. However, when we are simply determining
toolbar location we don't want to do that. */
switch (pos)
{
case TOP_EDGE:
*x = 1;
*y = 0; /* #### should be 1 if no menubar */
*width = FRAME_PIXWIDTH (f) - 2;
*height = FRAME_REAL_TOP_TOOLBAR_HEIGHT (f) +
2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f) - adjust;
*vert = 0;
break;
case BOTTOM_EDGE:
*x = 1;
*y = FRAME_PIXHEIGHT (f) - FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) -
2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f);
*width = FRAME_PIXWIDTH (f) - 2;
*height = FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f) +
2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f) - adjust;
*vert = 0;
break;
case LEFT_EDGE:
*x = 1;
*y = visible_top_toolbar_height;
*width = FRAME_REAL_LEFT_TOOLBAR_WIDTH (f) +
2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f) - adjust;
*height = (FRAME_PIXHEIGHT (f) - visible_top_toolbar_height -
visible_bottom_toolbar_height - 1);
*vert = 1;
break;
case RIGHT_EDGE:
*x = FRAME_PIXWIDTH (f) - FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) -
2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f);
*y = visible_top_toolbar_height;
*width = FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f) +
2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f) - adjust;
*height = (FRAME_PIXHEIGHT (f) - visible_top_toolbar_height -
visible_bottom_toolbar_height);
*vert = 1;
break;
default:
ABORT ();
}
}
#define CHECK_TOOLBAR(pos) do { \
if (FRAME_REAL_TOOLBAR_VISIBLE (f, pos)) \
{ \
int x, y, width, height, vert; \
\
get_toolbar_coords (f, pos, &x, &y, &width, &height, &vert, 0); \
if ((x_coord >= x) && (x_coord < (x + width))) \
{ \
if ((y_coord >= y) && (y_coord < (y + height))) \
return FRAME_TOOLBAR_BUTTONS (f, pos); \
} \
} \
} while (0)
static Lisp_Object
toolbar_buttons_at_pixpos (struct frame *f, int x_coord, int y_coord)
{
CHECK_TOOLBAR (TOP_EDGE);
CHECK_TOOLBAR (BOTTOM_EDGE);
CHECK_TOOLBAR (LEFT_EDGE);
CHECK_TOOLBAR (RIGHT_EDGE);
return Qnil;
}
#undef CHECK_TOOLBAR
/* The device dependent code actually does the work of positioning the
buttons, but we are free to access that information at this
level. */
Lisp_Object
toolbar_button_at_pixpos (struct frame *f, int x_coord, int y_coord)
{
Lisp_Object buttons = toolbar_buttons_at_pixpos (f, x_coord, y_coord);
while (!NILP (buttons))
{
struct toolbar_button *tb = XTOOLBAR_BUTTON (buttons);
if ((x_coord >= tb->x) && (x_coord < (tb->x + tb->width)))
{
if ((y_coord >= tb->y) && (y_coord < (tb->y + tb->height)))
{
/* If we are over a blank, return nil. */
if (tb->blank)
return Qnil;
else
return buttons;
}
}
buttons = tb->next;
}
/* We are not over a toolbar or we are over a blank in the toolbar. */
return Qnil;
}
/************************************************************************/
/* Toolbar specifier type */
/************************************************************************/
DEFINE_SPECIFIER_TYPE (toolbar);
#define CTB_ERROR(msg) do { \
maybe_signal_error (Qinvalid_argument, msg, button, Qtoolbar, errb); \
RETURN_SANS_WARNINGS Qnil; \
} while (0)
/* Returns Q_style if key was :style, Qt if ok otherwise, Qnil if error. */
static Lisp_Object
check_toolbar_button_keywords (Lisp_Object button, Lisp_Object key,
Lisp_Object val, Error_Behavior errb)
{
if (!KEYWORDP (key))
{
maybe_signal_error_2 (Qinvalid_argument, "Not a keyword", key, button,
Qtoolbar, errb);
return Qnil;
}
if (EQ (key, Q_style))
{
if (!EQ (val, Q2D)
&& !EQ (val, Q3D)
&& !EQ (val, Q2d)
&& !EQ (val, Q3d))
CTB_ERROR ("Unrecognized toolbar blank style");
return Q_style;
}
else if (EQ (key, Q_size))
{
if (!NATNUMP (val))
CTB_ERROR ("invalid toolbar blank size");
}
else
{
CTB_ERROR ("invalid toolbar blank keyword");
}
return Qt;
}
/* toolbar button spec is [pixmap-pair function enabled-p help]
or [:style 2d-or-3d :size width-or-height] */
DEFUN ("check-toolbar-button-syntax", Fcheck_toolbar_button_syntax, 1, 2, 0, /*
Verify the syntax of entry BUTTON in a toolbar description list.
If you want to verify the syntax of a toolbar description list as a
whole, use `check-valid-instantiator' with a specifier type of `toolbar'.
*/
(button, noerror))
{
Lisp_Object *elt, glyphs, value;
int len;
Error_Behavior errb = decode_error_behavior_flag (noerror);
if (!VECTORP (button))
CTB_ERROR ("toolbar button descriptors must be vectors");
elt = XVECTOR_DATA (button);
if (XVECTOR_LENGTH (button) == 2)
{
if (!EQ (Q_style, check_toolbar_button_keywords (button, elt[0],
elt[1], errb)))
CTB_ERROR ("must specify toolbar blank style");
return Qt;
}
if (XVECTOR_LENGTH (button) != 4)
CTB_ERROR ("toolbar button descriptors must be 2 or 4 long");
/* The first element must be a list of glyphs of length 1-6. The
first entry is the pixmap for the up state, the second for the
down state, the third for the disabled state, the fourth for the
captioned up state, the fifth for the captioned down state and
the sixth for the captioned disabled state. Only the up state is
mandatory. */
if (!CONSP (elt[0]))
{
/* We can't check the buffer-local here because we don't know
which buffer to check in. #### I think this is a bad thing.
See if we can't get enough information to this function so
that it can check.
#### Wrong. We shouldn't be checking the value at all here.
The user might set or change the value at any time. */
value = Fsymbol_value (elt[0]);
if (!CONSP (value))
{
if (KEYWORDP (elt[0]))
{
int fsty = 0;
if (EQ (Q_style, check_toolbar_button_keywords (button, elt[0],
elt[1],
errb)))
fsty++;
if (EQ (Q_style, check_toolbar_button_keywords (button, elt[2],
elt[3],
errb)))
fsty++;
if (!fsty)
CTB_ERROR ("must specify toolbar blank style");
else if (EQ (elt[0], elt[2]))
CTB_ERROR
("duplicate keywords in toolbar button blank description");
return Qt;
}
else
CTB_ERROR ("first element of button must be a list (of glyphs)");
}
}
else
value = elt[0];
len = XFIXNUM (Flength (value));
if (len < 1)
CTB_ERROR ("toolbar button glyph list must have at least 1 entry");
if (len > 6)
CTB_ERROR ("toolbar button glyph list can have at most 6 entries");
glyphs = value;
while (!NILP (glyphs))
{
if (!GLYPHP (XCAR (glyphs)))
{
/* We allow nil for the down and disabled glyphs but not for
the up glyph. */
if (EQ (glyphs, value) || !NILP (XCAR (glyphs)))
{
CTB_ERROR
("all elements of toolbar button glyph list must be glyphs.");
}
}
glyphs = XCDR (glyphs);
}
/* The second element is the function to run when the button is
activated. We do not do any checking on it because it is legal
for the function to not be defined until after the toolbar is.
It is the user's problem to get this right.
The third element is either a boolean indicating the enabled
status or a function used to determine it. Again, it is the
user's problem if this is wrong.
The fourth element, if not nil, must be a string which will be
displayed as the help echo. */
/* #### This should be allowed to be a function returning a string
as well as just a string. */
if (!NILP (elt[3]) && !STRINGP (elt[3]))
CTB_ERROR ("toolbar button help echo string must be a string");
return Qt;
}
#undef CTB_ERROR
static void
toolbar_validate (Lisp_Object instantiator)
{
int pushright_seen = 0;
Lisp_Object rest;
if (NILP (instantiator))
return;
if (!CONSP (instantiator))
sferror ("Toolbar spec must be list or nil", instantiator);
for (rest = instantiator; !NILP (rest); rest = XCDR (rest))
{
if (!CONSP (rest))
sferror ("Bad list in toolbar spec", instantiator);
if (NILP (XCAR (rest)))
{
if (pushright_seen)
sferror
("More than one partition (nil) in instantiator description",
instantiator);
else
pushright_seen = 1;
}
else
Fcheck_toolbar_button_syntax (XCAR (rest), Qnil);
}
}
static void
toolbar_after_change (Lisp_Object UNUSED (specifier),
Lisp_Object UNUSED (locale))
{
/* #### This is overkill. I really need to rethink the after-change
functions to make them easier to use. */
MARK_TOOLBAR_CHANGED;
}
DEFUN ("toolbar-specifier-p", Ftoolbar_specifier_p, 1, 1, 0, /*
Return non-nil if OBJECT is a toolbar specifier.
See `make-toolbar-specifier' for a description of possible toolbar
instantiators.
*/
(object))
{
return TOOLBAR_SPECIFIERP (object) ? Qt : Qnil;
}
/*
Helper for invalidating the real specifier when default
specifier caching changes
*/
static void
recompute_overlaying_specifier (Lisp_Object real_one[NUM_EDGES])
{
enum edge_pos pos = decode_toolbar_position (Vdefault_toolbar_position);
Fset_specifier_dirty_flag (real_one[pos]);
}
static void
toolbar_specs_changed (Lisp_Object UNUSED (specifier),
struct window *UNUSED (w),
Lisp_Object UNUSED (oldval))
{
/* This could be smarter but I doubt that it would make any
noticeable difference given the infrequency with which this is
probably going to be called.
*/
MARK_TOOLBAR_CHANGED;
}
static void
default_toolbar_specs_changed (Lisp_Object UNUSED (specifier),
struct window *UNUSED (w),
Lisp_Object UNUSED (oldval))
{
recompute_overlaying_specifier (Vtoolbar);
}
static void
default_toolbar_size_changed_in_frame (Lisp_Object UNUSED (specifier),
struct frame *UNUSED (f),
Lisp_Object UNUSED (oldval))
{
recompute_overlaying_specifier (Vtoolbar_size);
}
static void
default_toolbar_border_width_changed_in_frame (Lisp_Object UNUSED (specifier),
struct frame *UNUSED (f),
Lisp_Object UNUSED (oldval))
{
recompute_overlaying_specifier (Vtoolbar_border_width);
}
static void
default_toolbar_visible_p_changed_in_frame (Lisp_Object UNUSED (specifier),
struct frame *UNUSED (f),
Lisp_Object UNUSED (oldval))
{
recompute_overlaying_specifier (Vtoolbar_visible_p);
}
static void
toolbar_geometry_changed_in_window (Lisp_Object UNUSED (specifier),
struct window *w,
Lisp_Object UNUSED (oldval))
{
MARK_TOOLBAR_CHANGED;
MARK_WINDOWS_CHANGED (w);
}
static void
default_toolbar_size_changed_in_window (Lisp_Object UNUSED (specifier),
struct window *UNUSED (w),
Lisp_Object UNUSED (oldval))
{
recompute_overlaying_specifier (Vtoolbar_size);
}
static void
default_toolbar_border_width_changed_in_window (Lisp_Object UNUSED (specifier),
struct window *UNUSED (w),
Lisp_Object UNUSED (oldval))
{
recompute_overlaying_specifier (Vtoolbar_border_width);
}
static void
default_toolbar_visible_p_changed_in_window (Lisp_Object UNUSED (specifier),
struct window *UNUSED (w),
Lisp_Object UNUSED (oldval))
{
recompute_overlaying_specifier (Vtoolbar_visible_p);
}
static void
toolbar_buttons_captioned_p_changed (Lisp_Object UNUSED (specifier),
struct window *UNUSED (w),
Lisp_Object UNUSED (oldval))
{
/* This could be smarter but I doubt that it would make any
noticeable difference given the infrequency with which this is
probably going to be called. */
MARK_TOOLBAR_CHANGED;
}
static void
toolbar_shadows_changed (Lisp_Object UNUSED (specifier),
struct window *w,
Lisp_Object UNUSED (oldval))
{
struct frame *f = XFRAME (w->frame);
if (!f->frame_data)
{
/* If there is not frame data yet, we need to get the hell out
** of here. This can happen when the initial frame is being
** created and we set our specifiers internally.
*/
return;
}
MAYBE_DEVMETH (XDEVICE (f->device), redraw_frame_toolbars, (f));
}
void
syms_of_toolbar (void)
{
INIT_LISP_OBJECT (toolbar_button);
DEFSYMBOL_MULTIWORD_PREDICATE (Qtoolbar_buttonp);
DEFSYMBOL (Q2D);
DEFSYMBOL (Q3D);
DEFSYMBOL (Q2d);
DEFSYMBOL (Q3d);
DEFKEYWORD (Q_size);
DEFSYMBOL (Qinit_toolbar_from_resources);
DEFSUBR (Ftoolbar_button_p);
DEFSUBR (Ftoolbar_button_callback);
DEFSUBR (Ftoolbar_button_help_string);
DEFSUBR (Ftoolbar_button_enabled_p);
DEFSUBR (Fset_toolbar_button_down_flag);
DEFSUBR (Fcheck_toolbar_button_syntax);
DEFSUBR (Fset_default_toolbar_position);
DEFSUBR (Fdefault_toolbar_position);
DEFSUBR (Ftoolbar_specifier_p);
}
void
vars_of_toolbar (void)
{
staticpro (&Vdefault_toolbar_position);
Vdefault_toolbar_position = Qtop;
#ifdef HAVE_WINDOW_SYSTEM
Fprovide (Qtoolbar);
#endif
}
void
specifier_type_create_toolbar (void)
{
INITIALIZE_SPECIFIER_TYPE (toolbar, "toolbar", "toolbar-specifier-p");
SPECIFIER_HAS_METHOD (toolbar, validate);
SPECIFIER_HAS_METHOD (toolbar, after_change);
}
void
reinit_specifier_type_create_toolbar (void)
{
REINITIALIZE_SPECIFIER_TYPE (toolbar);
}
void
specifier_vars_of_toolbar (void)
{
Lisp_Object fb;
DEFVAR_SPECIFIER ("default-toolbar", &Vdefault_toolbar /*
Specifier for a fallback toolbar.
Use `set-specifier' to change this.
The position of this toolbar is specified in the function
`default-toolbar-position'. If the corresponding position-specific
toolbar (e.g. `top-toolbar' if `default-toolbar-position' is `top')
does not specify a toolbar in a particular domain (usually a window),
then the value of `default-toolbar' in that domain, if any, will be
used instead.
Note that the toolbar at any particular position will not be
displayed unless its visibility flag is true and its thickness
\(width or height, depending on orientation) is non-zero. The
visibility is controlled by the specifiers `top-toolbar-visible-p',
`bottom-toolbar-visible-p', `left-toolbar-visible-p', and
`right-toolbar-visible-p', and the thickness is controlled by the
specifiers `top-toolbar-height', `bottom-toolbar-height',
`left-toolbar-width', and `right-toolbar-width'.
Note that one of the four visibility specifiers inherits from
`default-toolbar-visibility' and one of the four thickness
specifiers inherits from either `default-toolbar-width' or
`default-toolbar-height' (depending on orientation), just
like for the toolbar description specifiers (e.g. `top-toolbar')
mentioned above.
Therefore, if you are setting `default-toolbar', you should control
the visibility and thickness using `default-toolbar-visible-p',
`default-toolbar-width', and `default-toolbar-height', rather than
using position-specific specifiers. That way, you will get sane
behavior if the user changes the default toolbar position.
The format of the instantiator for a toolbar is a list of
toolbar-button-descriptors. Each toolbar-button-descriptor
is a vector in one of the following formats:
[GLYPH-LIST FUNCTION ENABLED-P HELP] or
[:style 2D-OR-3D] or
[:style 2D-OR-3D :size WIDTH-OR-HEIGHT] or
[:size WIDTH-OR-HEIGHT :style 2D-OR-3D]
Optionally, one of the toolbar-button-descriptors may be nil
instead of a vector; this signifies the division between
the toolbar buttons that are to be displayed flush-left,
and the buttons to be displayed flush-right.
The first vector format above specifies a normal toolbar button;
the others specify blank areas in the toolbar.
For the first vector format:
-- GLYPH-LIST should be a list of one to six glyphs (as created by
`make-glyph') or a symbol whose value is such a list. The first
glyph, which must be provided, is the glyph used to display the
toolbar button when it is in the "up" (not pressed) state. The
optional second glyph is for displaying the button when it is in
the "down" (pressed) state. The optional third glyph is for when
the button is disabled. The optional fourth, fifth and sixth glyphs
are used to specify captioned versions for the up, down and disabled
states respectively. The function `toolbar-make-button-list' is
useful in creating these glyph lists. The specifier variable
`toolbar-buttons-captioned-p' controls which glyphs are actually used.
-- Even if you do not provide separate down-state and disabled-state
glyphs, the user will still get visual feedback to indicate which
state the button is in. Buttons in the up-state are displayed
with a shadowed border that gives a raised appearance to the
button. Buttons in the down-state are displayed with shadows that
give a recessed appearance. Buttons in the disabled state are
displayed with no shadows, giving a 2-d effect.
-- If some of the toolbar glyphs are not provided, they inherit as follows:
UP: up
DOWN: down -> up
DISABLED: disabled -> up
CAP-UP: cap-up -> up
CAP-DOWN: cap-down -> cap-up -> down -> up
CAP-DISABLED: cap-disabled -> cap-up -> disabled -> up
-- The second element FUNCTION is a function to be called when the
toolbar button is activated (i.e. when the mouse is released over
the toolbar button, if the press occurred in the toolbar). It
can be any form accepted by `call-interactively', since this is
how it is invoked.
-- The third element ENABLED-P specifies whether the toolbar button
is enabled (disabled buttons do nothing when they are activated,
and are displayed differently; see above). It should be either
a boolean or a form that evaluates to a boolean.
-- The fourth element HELP, if non-nil, should be a string. This
string is displayed in the echo area when the mouse passes over
the toolbar button.
For the other vector formats (specifying blank areas of the toolbar):
-- 2D-OR-3D should be one of the symbols `2d' or `3d', indicating
whether the area is displayed with shadows (giving it a raised,
3-d appearance) or without shadows (giving it a flat appearance).
-- WIDTH-OR-HEIGHT specifies the length, in pixels, of the blank
area. If omitted, it defaults to a device-specific value
(8 pixels for X devices).
*/ );
Vdefault_toolbar = Fmake_specifier (Qtoolbar);
/* #### It would be even nicer if the specifier caching
automatically knew about specifier fallbacks, so we didn't
have to do it ourselves. */
set_specifier_caching (Vdefault_toolbar,
offsetof (struct window, default_toolbar),
default_toolbar_specs_changed,
0, 0, 0);
DEFVAR_SPECIFIER ("top-toolbar",
&Vtoolbar[TOP_EDGE] /*
Specifier for the toolbar at the top of the frame.
Use `set-specifier' to change this.
See `default-toolbar' for a description of a valid toolbar instantiator.
*/ );
Vtoolbar[TOP_EDGE] = Fmake_specifier (Qtoolbar);
set_specifier_caching (Vtoolbar[TOP_EDGE],
offsetof (struct window, toolbar[TOP_EDGE]),
toolbar_specs_changed,
0, 0, 0);
DEFVAR_SPECIFIER ("bottom-toolbar",
&Vtoolbar[BOTTOM_EDGE] /*
Specifier for the toolbar at the bottom of the frame.
Use `set-specifier' to change this.
See `default-toolbar' for a description of a valid toolbar instantiator.
Note that, unless the `default-toolbar-position' is `bottom', by
default the height of the bottom toolbar (controlled by
`bottom-toolbar-height') is 0; thus, a bottom toolbar will not be
displayed even if you provide a value for `bottom-toolbar'.
*/ );
Vtoolbar[BOTTOM_EDGE] = Fmake_specifier (Qtoolbar);
set_specifier_caching (Vtoolbar[BOTTOM_EDGE],
offsetof (struct window, toolbar[BOTTOM_EDGE]),
toolbar_specs_changed,
0, 0, 0);
DEFVAR_SPECIFIER ("left-toolbar",
&Vtoolbar[LEFT_EDGE] /*
Specifier for the toolbar at the left edge of the frame.
Use `set-specifier' to change this.
See `default-toolbar' for a description of a valid toolbar instantiator.
Note that, unless the `default-toolbar-position' is `left', by
default the height of the left toolbar (controlled by
`left-toolbar-width') is 0; thus, a left toolbar will not be
displayed even if you provide a value for `left-toolbar'.
*/ );
Vtoolbar[LEFT_EDGE] = Fmake_specifier (Qtoolbar);
set_specifier_caching (Vtoolbar[LEFT_EDGE],
offsetof (struct window, toolbar[LEFT_EDGE]),
toolbar_specs_changed,
0, 0, 0);
DEFVAR_SPECIFIER ("right-toolbar",
&Vtoolbar[RIGHT_EDGE] /*
Specifier for the toolbar at the right edge of the frame.
Use `set-specifier' to change this.
See `default-toolbar' for a description of a valid toolbar instantiator.
Note that, unless the `default-toolbar-position' is `right', by
default the height of the right toolbar (controlled by
`right-toolbar-width') is 0; thus, a right toolbar will not be
displayed even if you provide a value for `right-toolbar'.
*/ );
Vtoolbar[RIGHT_EDGE] = Fmake_specifier (Qtoolbar);
set_specifier_caching (Vtoolbar[RIGHT_EDGE],
offsetof (struct window, toolbar[RIGHT_EDGE]),
toolbar_specs_changed,
0, 0, 0);
/* initially, top inherits from default; this can be
changed with `set-default-toolbar-position'. */
fb = list1 (Fcons (Qnil, Qnil));
set_specifier_fallback (Vdefault_toolbar, fb);
set_specifier_fallback (Vtoolbar[TOP_EDGE], Vdefault_toolbar);
set_specifier_fallback (Vtoolbar[BOTTOM_EDGE], fb);
set_specifier_fallback (Vtoolbar[LEFT_EDGE], fb);
set_specifier_fallback (Vtoolbar[RIGHT_EDGE], fb);
DEFVAR_SPECIFIER ("default-toolbar-height", &Vdefault_toolbar_height /*
*Height of the default toolbar, if it's oriented horizontally.
This is a specifier; use `set-specifier' to change it.
The position of the default toolbar is specified by the function
`set-default-toolbar-position'. If the corresponding position-specific
toolbar thickness specifier (e.g. `top-toolbar-height' if
`default-toolbar-position' is `top') does not specify a thickness in a
particular domain (a window or a frame), then the value of
`default-toolbar-height' or `default-toolbar-width' (depending on the
toolbar orientation) in that domain, if any, will be used instead.
Note that `default-toolbar-height' is only used when
`default-toolbar-position' is `top' or `bottom', and `default-toolbar-width'
is only used when `default-toolbar-position' is `left' or `right'.
Note that all of the position-specific toolbar thickness specifiers
have a fallback value of zero when they do not correspond to the
default toolbar. Therefore, you will have to set a non-zero thickness
value if you want a position-specific toolbar to be displayed.
Internally, toolbar thickness specifiers are instantiated in both
window and frame domains, for different purposes. The value in the
domain of a frame's selected window specifies the actual toolbar
thickness that you will see in that frame. The value in the domain of
a frame itself specifies the toolbar thickness that is used in frame
geometry calculations.
Thus, for example, if you set the frame width to 80 characters and the
left toolbar width for that frame to 68 pixels, then the frame will
be sized to fit 80 characters plus a 68-pixel left toolbar. If you
then set the left toolbar width to 0 for a particular buffer (or if
that buffer does not specify a left toolbar or has a nil value
specified for `left-toolbar-visible-p'), you will find that, when
that buffer is displayed in the selected window, the window will have
a width of 86 or 87 characters -- the frame is sized for a 68-pixel
left toolbar but the selected window specifies that the left toolbar
is not visible, so it is expanded to take up the slack.
*/ );
Vdefault_toolbar_height = Fmake_specifier (Qnatnum);
set_specifier_caching (Vdefault_toolbar_height,
offsetof (struct window, default_toolbar_height),
default_toolbar_size_changed_in_window,
offsetof (struct frame, default_toolbar_height),
default_toolbar_size_changed_in_frame, 0);
DEFVAR_SPECIFIER ("default-toolbar-width", &Vdefault_toolbar_width /*
*Width of the default toolbar, if it's oriented vertically.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vdefault_toolbar_width = Fmake_specifier (Qnatnum);
set_specifier_caching (Vdefault_toolbar_width,
offsetof (struct window, default_toolbar_width),
default_toolbar_size_changed_in_window,
offsetof (struct frame, default_toolbar_width),
default_toolbar_size_changed_in_frame, 0);
DEFVAR_SPECIFIER ("top-toolbar-height",
&Vtoolbar_size[TOP_EDGE] /*
*Height of the top toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_size[TOP_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_size[TOP_EDGE],
offsetof (struct window, toolbar_size[TOP_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame, toolbar_size[TOP_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("bottom-toolbar-height",
&Vtoolbar_size[BOTTOM_EDGE] /*
*Height of the bottom toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_size[BOTTOM_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_size[BOTTOM_EDGE],
offsetof (struct window, toolbar_size[BOTTOM_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame, toolbar_size[BOTTOM_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("left-toolbar-width",
&Vtoolbar_size[LEFT_EDGE] /*
*Width of left toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_size[LEFT_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_size[LEFT_EDGE],
offsetof (struct window, toolbar_size[LEFT_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame, toolbar_size[LEFT_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("right-toolbar-width",
&Vtoolbar_size[RIGHT_EDGE] /*
*Width of right toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_size[RIGHT_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_size[RIGHT_EDGE],
offsetof (struct window, toolbar_size[RIGHT_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame, toolbar_size[RIGHT_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("toolbar-shadow-thickness",
&Vtoolbar_shadow_thickness /*
*Width of shadows around toolbar buttons.
This is a specifier; use `set-specifier' to change it.
*/ );
Vtoolbar_shadow_thickness = Fmake_specifier (Qnatnum);
set_specifier_caching(Vtoolbar_shadow_thickness,
offsetof (struct window, toolbar_shadow_thickness),
toolbar_shadows_changed,
0,0, 0);
fb = Qnil;
#ifdef HAVE_TTY
fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
#endif
#ifdef HAVE_GTK
fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (2)), fb);
#endif
#ifdef HAVE_X_WINDOWS
fb = Fcons (Fcons (list1 (Qx), make_fixnum (2)), fb);
#endif
#ifdef HAVE_MS_WINDOWS
fb = Fcons (Fcons (list1 (Qmswindows), make_fixnum (2)), fb);
#endif
if (!NILP (fb))
set_specifier_fallback (Vtoolbar_shadow_thickness, fb);
fb = Qnil;
#ifdef HAVE_TTY
fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
#endif
#ifdef HAVE_GTK
fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (DEFAULT_TOOLBAR_HEIGHT)), fb);
#endif
#ifdef HAVE_X_WINDOWS
fb = Fcons (Fcons (list1 (Qx), make_fixnum (DEFAULT_TOOLBAR_HEIGHT)), fb);
#endif
#ifdef HAVE_MS_WINDOWS
fb = Fcons (Fcons (list1 (Qmswindows),
make_fixnum (MSWINDOWS_DEFAULT_TOOLBAR_HEIGHT)), fb);
#endif
if (!NILP (fb))
set_specifier_fallback (Vdefault_toolbar_height, fb);
fb = Qnil;
#ifdef HAVE_TTY
fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
#endif
#ifdef HAVE_GTK
fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (DEFAULT_TOOLBAR_WIDTH)), fb);
#endif
#ifdef HAVE_X_WINDOWS
fb = Fcons (Fcons (list1 (Qx), make_fixnum (DEFAULT_TOOLBAR_WIDTH)), fb);
#endif
#ifdef HAVE_MS_WINDOWS
fb = Fcons (Fcons (list1 (Qmswindows),
make_fixnum (MSWINDOWS_DEFAULT_TOOLBAR_WIDTH)), fb);
#endif
if (!NILP (fb))
set_specifier_fallback (Vdefault_toolbar_width, fb);
set_specifier_fallback (Vtoolbar_size[TOP_EDGE], Vdefault_toolbar_height);
fb = list1 (Fcons (Qnil, Qzero));
set_specifier_fallback (Vtoolbar_size[BOTTOM_EDGE], fb);
set_specifier_fallback (Vtoolbar_size[LEFT_EDGE], fb);
set_specifier_fallback (Vtoolbar_size[RIGHT_EDGE], fb);
DEFVAR_SPECIFIER ("default-toolbar-border-width",
&Vdefault_toolbar_border_width /*
*Width of the border around the default toolbar.
This is a specifier; use `set-specifier' to change it.
The position of the default toolbar is specified by the function
`set-default-toolbar-position'. If the corresponding position-specific
toolbar border width specifier (e.g. `top-toolbar-border-width' if
`default-toolbar-position' is `top') does not specify a border width in a
particular domain (a window or a frame), then the value of
`default-toolbar-border-width' in that domain, if any, will be used
instead.
Internally, toolbar border width specifiers are instantiated in both
window and frame domains, for different purposes. The value in the
domain of a frame's selected window specifies the actual toolbar border
width that you will see in that frame. The value in the domain of a
frame itself specifies the toolbar border width that is used in frame
geometry calculations. Changing the border width value in the frame
domain will result in a size change in the frame itself, while changing
the value in a window domain will not.
*/ );
Vdefault_toolbar_border_width = Fmake_specifier (Qnatnum);
set_specifier_caching (Vdefault_toolbar_border_width,
offsetof (struct window, default_toolbar_border_width),
default_toolbar_border_width_changed_in_window,
offsetof (struct frame, default_toolbar_border_width),
default_toolbar_border_width_changed_in_frame, 0);
DEFVAR_SPECIFIER ("top-toolbar-border-width",
&Vtoolbar_border_width[TOP_EDGE] /*
*Border width of the top toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_border_width[TOP_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_border_width[TOP_EDGE],
offsetof (struct window,
toolbar_border_width[TOP_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_border_width[TOP_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("bottom-toolbar-border-width",
&Vtoolbar_border_width[BOTTOM_EDGE] /*
*Border width of the bottom toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_border_width[BOTTOM_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_border_width[BOTTOM_EDGE],
offsetof (struct window,
toolbar_border_width[BOTTOM_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_border_width[BOTTOM_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("left-toolbar-border-width",
&Vtoolbar_border_width[LEFT_EDGE] /*
*Border width of left toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_border_width[LEFT_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_border_width[LEFT_EDGE],
offsetof (struct window,
toolbar_border_width[LEFT_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_border_width[LEFT_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("right-toolbar-border-width",
&Vtoolbar_border_width[RIGHT_EDGE] /*
*Border width of right toolbar.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-height' for more information.
*/ );
Vtoolbar_border_width[RIGHT_EDGE] = Fmake_specifier (Qnatnum);
set_specifier_caching (Vtoolbar_border_width[RIGHT_EDGE],
offsetof (struct window,
toolbar_border_width[RIGHT_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_border_width[RIGHT_EDGE]),
frame_size_slipped, 0);
fb = Qnil;
#ifdef HAVE_TTY
fb = Fcons (Fcons (list1 (Qtty), Qzero), fb);
#endif
#ifdef HAVE_X_WINDOWS
fb = Fcons (Fcons (list1 (Qx), make_fixnum (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb);
#endif
#ifdef HAVE_GTK
fb = Fcons (Fcons (list1 (Qgtk), make_fixnum (DEFAULT_TOOLBAR_BORDER_WIDTH)), fb);
#endif
#ifdef HAVE_MS_WINDOWS
fb = Fcons (Fcons (list1 (Qmswindows), make_fixnum (MSWINDOWS_DEFAULT_TOOLBAR_BORDER_WIDTH)), fb);
#endif
if (!NILP (fb))
set_specifier_fallback (Vdefault_toolbar_border_width, fb);
set_specifier_fallback (Vtoolbar_border_width[TOP_EDGE], Vdefault_toolbar_border_width);
fb = list1 (Fcons (Qnil, Qzero));
set_specifier_fallback (Vtoolbar_border_width[BOTTOM_EDGE], fb);
set_specifier_fallback (Vtoolbar_border_width[LEFT_EDGE], fb);
set_specifier_fallback (Vtoolbar_border_width[RIGHT_EDGE], fb);
DEFVAR_SPECIFIER ("default-toolbar-visible-p", &Vdefault_toolbar_visible_p /*
*Whether the default toolbar is visible.
This is a specifier; use `set-specifier' to change it.
The position of the default toolbar is specified by the function
`set-default-toolbar-position'. If the corresponding position-specific
toolbar visibility specifier (e.g. `top-toolbar-visible-p' if
`default-toolbar-position' is `top') does not specify a visible-p value
in a particular domain (a window or a frame), then the value of
`default-toolbar-visible-p' in that domain, if any, will be used
instead.
Both window domains and frame domains are used internally, for
different purposes. The distinction here is exactly the same as
for thickness specifiers; see `default-toolbar-height' for more
information.
`default-toolbar-visible-p' and all of the position-specific toolbar
visibility specifiers have a fallback value of true.
*/ );
Vdefault_toolbar_visible_p = Fmake_specifier (Qboolean);
set_specifier_caching (Vdefault_toolbar_visible_p,
offsetof (struct window, default_toolbar_visible_p),
default_toolbar_visible_p_changed_in_window,
offsetof (struct frame, default_toolbar_visible_p),
default_toolbar_visible_p_changed_in_frame, 0);
DEFVAR_SPECIFIER ("top-toolbar-visible-p",
&Vtoolbar_visible_p[TOP_EDGE] /*
*Whether the top toolbar is visible.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-visible-p' for more information.
*/ );
Vtoolbar_visible_p[TOP_EDGE] = Fmake_specifier (Qboolean);
set_specifier_caching (Vtoolbar_visible_p[TOP_EDGE],
offsetof (struct window,
toolbar_visible_p[TOP_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_visible_p[TOP_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("bottom-toolbar-visible-p",
&Vtoolbar_visible_p[BOTTOM_EDGE] /*
*Whether the bottom toolbar is visible.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-visible-p' for more information.
*/ );
Vtoolbar_visible_p[BOTTOM_EDGE] = Fmake_specifier (Qboolean);
set_specifier_caching (Vtoolbar_visible_p[BOTTOM_EDGE],
offsetof (struct window,
toolbar_visible_p[BOTTOM_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_visible_p[BOTTOM_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("left-toolbar-visible-p",
&Vtoolbar_visible_p[LEFT_EDGE] /*
*Whether the left toolbar is visible.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-visible-p' for more information.
*/ );
Vtoolbar_visible_p[LEFT_EDGE] = Fmake_specifier (Qboolean);
set_specifier_caching (Vtoolbar_visible_p[LEFT_EDGE],
offsetof (struct window,
toolbar_visible_p[LEFT_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_visible_p[LEFT_EDGE]),
frame_size_slipped, 0);
DEFVAR_SPECIFIER ("right-toolbar-visible-p",
&Vtoolbar_visible_p[RIGHT_EDGE] /*
*Whether the right toolbar is visible.
This is a specifier; use `set-specifier' to change it.
See `default-toolbar-visible-p' for more information.
*/ );
Vtoolbar_visible_p[RIGHT_EDGE] = Fmake_specifier (Qboolean);
set_specifier_caching (Vtoolbar_visible_p[RIGHT_EDGE],
offsetof (struct window,
toolbar_visible_p[RIGHT_EDGE]),
toolbar_geometry_changed_in_window,
offsetof (struct frame,
toolbar_visible_p[RIGHT_EDGE]),
frame_size_slipped, 0);
/* initially, top inherits from default; this can be
changed with `set-default-toolbar-position'. */
fb = list1 (Fcons (Qnil, Qt));
set_specifier_fallback (Vdefault_toolbar_visible_p, fb);
set_specifier_fallback (Vtoolbar_visible_p[TOP_EDGE],
Vdefault_toolbar_visible_p);
set_specifier_fallback (Vtoolbar_visible_p[BOTTOM_EDGE], fb);
set_specifier_fallback (Vtoolbar_visible_p[LEFT_EDGE], fb);
set_specifier_fallback (Vtoolbar_visible_p[RIGHT_EDGE], fb);
DEFVAR_SPECIFIER ("toolbar-buttons-captioned-p",
&Vtoolbar_buttons_captioned_p /*
*Whether the toolbar buttons are captioned.
This will only have a visible effect for those toolbar buttons which had
captioned versions specified.
This is a specifier; use `set-specifier' to change it.
*/ );
Vtoolbar_buttons_captioned_p = Fmake_specifier (Qboolean);
set_specifier_caching (Vtoolbar_buttons_captioned_p,
offsetof (struct window, toolbar_buttons_captioned_p),
toolbar_buttons_captioned_p_changed,
0, 0, 0);
set_specifier_fallback (Vtoolbar_buttons_captioned_p,
list1 (Fcons (Qnil, Qt)));
}