|
428
|
1 /* Generic scrollbar implementation.
|
|
|
2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
|
|
|
3 Copyright (C) 1995 Free Software Foundation, Inc.
|
|
|
4 Copyright (C) 1995 Sun Microsystems, Inc.
|
|
|
5 Copyright (C) 1995 Darrell Kindred <dkindred+@cmu.edu>.
|
|
1318
|
6 Copyright (C) 2003 Ben Wing.
|
|
428
|
7
|
|
|
8 This file is part of XEmacs.
|
|
|
9
|
|
|
10 XEmacs is free software; you can redistribute it and/or modify it
|
|
|
11 under the terms of the GNU General Public License as published by the
|
|
|
12 Free Software Foundation; either version 2, or (at your option) any
|
|
|
13 later version.
|
|
|
14
|
|
|
15 XEmacs is distributed in the hope that it will be useful, but WITHOUT
|
|
|
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
18 for more details.
|
|
|
19
|
|
|
20 You should have received a copy of the GNU General Public License
|
|
|
21 along with XEmacs; see the file COPYING. If not, write to
|
|
|
22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
23 Boston, MA 02111-1307, USA. */
|
|
|
24
|
|
|
25 /* Synched up with: Not in FSF. */
|
|
|
26
|
|
|
27 /* This file has been Mule-ized. */
|
|
|
28
|
|
|
29 #include <config.h>
|
|
|
30 #include "lisp.h"
|
|
|
31
|
|
|
32 #include "buffer.h"
|
|
|
33 #include "commands.h"
|
|
|
34 #include "scrollbar.h"
|
|
872
|
35 #include "device-impl.h"
|
|
|
36 #include "frame-impl.h"
|
|
428
|
37 #include "glyphs.h"
|
|
|
38 #include "gutter.h"
|
|
|
39 #include "window.h"
|
|
|
40
|
|
|
41 Lisp_Object Qinit_scrollbar_from_resources;
|
|
|
42
|
|
|
43 Lisp_Object Qscrollbar_line_up;
|
|
|
44 Lisp_Object Qscrollbar_line_down;
|
|
|
45 Lisp_Object Qscrollbar_page_up;
|
|
|
46 Lisp_Object Qscrollbar_page_down;
|
|
|
47 Lisp_Object Qscrollbar_to_top;
|
|
|
48 Lisp_Object Qscrollbar_to_bottom;
|
|
|
49 Lisp_Object Qscrollbar_vertical_drag;
|
|
|
50
|
|
|
51 Lisp_Object Qscrollbar_char_left;
|
|
|
52 Lisp_Object Qscrollbar_char_right;
|
|
|
53 Lisp_Object Qscrollbar_page_left;
|
|
|
54 Lisp_Object Qscrollbar_page_right;
|
|
|
55 Lisp_Object Qscrollbar_to_left;
|
|
|
56 Lisp_Object Qscrollbar_to_right;
|
|
|
57 Lisp_Object Qscrollbar_horizontal_drag;
|
|
|
58
|
|
|
59 #define DEFAULT_SCROLLBAR_WIDTH 15
|
|
|
60 #define DEFAULT_SCROLLBAR_HEIGHT 15
|
|
|
61
|
|
|
62 /* Width and height of the scrollbar. */
|
|
|
63 Lisp_Object Vscrollbar_width;
|
|
|
64 Lisp_Object Vscrollbar_height;
|
|
|
65
|
|
|
66 /* Scrollbar visibility specifiers */
|
|
|
67 Lisp_Object Vhorizontal_scrollbar_visible_p;
|
|
|
68 Lisp_Object Vvertical_scrollbar_visible_p;
|
|
|
69
|
|
|
70 /* Scrollbar location specifiers */
|
|
|
71 Lisp_Object Vscrollbar_on_left_p;
|
|
|
72 Lisp_Object Vscrollbar_on_top_p;
|
|
|
73
|
|
|
74 Lisp_Object Vscrollbar_pointer_glyph;
|
|
|
75
|
|
|
76 EXFUN (Fcenter_to_window_line, 2);
|
|
|
77
|
|
|
78 static void update_scrollbar_instance (struct window *w, int vertical,
|
|
|
79 struct scrollbar_instance *instance);
|
|
|
80
|
|
1204
|
81 static const struct memory_description scrollbar_instance_description [] = {
|
|
934
|
82 { XD_LISP_OBJECT, offsetof (struct scrollbar_instance, mirror) },
|
|
|
83 { XD_LISP_OBJECT, offsetof (struct scrollbar_instance, next) },
|
|
|
84 { XD_END }
|
|
|
85 };
|
|
|
86
|
|
428
|
87
|
|
617
|
88 static Lisp_Object
|
|
|
89 mark_scrollbar_instance (Lisp_Object obj)
|
|
|
90 {
|
|
|
91 struct scrollbar_instance *data = XSCROLLBAR_INSTANCE (obj);
|
|
|
92 mark_object (wrap_window_mirror (data->mirror));
|
|
|
93 if (data->next)
|
|
|
94 return wrap_scrollbar_instance (data->next);
|
|
|
95 else
|
|
|
96 return Qnil;
|
|
|
97 }
|
|
|
98
|
|
934
|
99 DEFINE_LRECORD_IMPLEMENTATION ("scrollbar-instance", scrollbar_instance,
|
|
|
100 0, /*dumpable-flag*/
|
|
|
101 mark_scrollbar_instance,
|
|
|
102 internal_object_printer, 0, 0, 0,
|
|
|
103 scrollbar_instance_description,
|
|
|
104 struct scrollbar_instance);
|
|
617
|
105
|
|
428
|
106 static void
|
|
|
107 free_scrollbar_instance (struct scrollbar_instance *instance,
|
|
|
108 struct frame *frame)
|
|
|
109 {
|
|
|
110 if (!instance)
|
|
|
111 return;
|
|
|
112 else
|
|
|
113 {
|
|
|
114 struct device *d = XDEVICE (frame->device);
|
|
|
115
|
|
|
116 MAYBE_DEVMETH (d, free_scrollbar_instance, (instance));
|
|
617
|
117 /* not worth calling free_managed_lcrecord() -- scrollbar instances
|
|
|
118 are not created that frequently and it's dangerous. */
|
|
428
|
119 }
|
|
|
120 }
|
|
|
121
|
|
|
122 static void
|
|
|
123 free_window_mirror_scrollbars (struct window_mirror *mir)
|
|
|
124 {
|
|
|
125 free_scrollbar_instance (mir->scrollbar_vertical_instance, mir->frame);
|
|
|
126 mir->scrollbar_vertical_instance = 0;
|
|
|
127
|
|
|
128 free_scrollbar_instance (mir->scrollbar_horizontal_instance, mir->frame);
|
|
|
129 mir->scrollbar_horizontal_instance = 0;
|
|
|
130 }
|
|
|
131
|
|
|
132 static struct window_mirror *
|
|
|
133 free_scrollbars_loop (Lisp_Object window, struct window_mirror *mir)
|
|
|
134 {
|
|
|
135 struct window_mirror *retval = NULL;
|
|
|
136
|
|
|
137 while (mir)
|
|
|
138 {
|
|
|
139 assert (!NILP (window));
|
|
|
140
|
|
|
141 if (mir->vchild)
|
|
|
142 {
|
|
|
143 retval = free_scrollbars_loop (XWINDOW (window)->vchild,
|
|
|
144 mir->vchild);
|
|
|
145 }
|
|
|
146 else if (mir->hchild)
|
|
|
147 {
|
|
|
148 retval = free_scrollbars_loop (XWINDOW (window)->hchild,
|
|
|
149 mir->hchild);
|
|
|
150 }
|
|
|
151
|
|
|
152 if (retval != NULL)
|
|
|
153 return retval;
|
|
|
154
|
|
|
155 if (mir->scrollbar_vertical_instance ||
|
|
|
156 mir->scrollbar_horizontal_instance)
|
|
|
157 free_window_mirror_scrollbars (mir);
|
|
|
158
|
|
|
159 mir = mir->next;
|
|
|
160 window = XWINDOW (window)->next;
|
|
|
161 }
|
|
|
162
|
|
|
163 return NULL;
|
|
|
164 }
|
|
|
165
|
|
|
166 /* Destroy all scrollbars associated with FRAME. Only called from
|
|
|
167 delete_frame_internal. */
|
|
|
168 void
|
|
|
169 free_frame_scrollbars (struct frame *f)
|
|
|
170 {
|
|
|
171 if (!HAS_FRAMEMETH_P (f, create_scrollbar_instance))
|
|
|
172 return;
|
|
|
173
|
|
|
174 if (f->mirror_dirty)
|
|
|
175 update_frame_window_mirror (f);
|
|
|
176
|
|
617
|
177 free_scrollbars_loop (f->root_window, XWINDOW_MIRROR (f->root_mirror));
|
|
428
|
178
|
|
|
179 while (FRAME_SB_VCACHE (f))
|
|
|
180 {
|
|
|
181 struct scrollbar_instance *tofree = FRAME_SB_VCACHE (f);
|
|
|
182 FRAME_SB_VCACHE (f) = FRAME_SB_VCACHE (f)->next;
|
|
|
183 tofree->next = NULL;
|
|
|
184 free_scrollbar_instance (tofree, f);
|
|
|
185 }
|
|
|
186
|
|
|
187 while (FRAME_SB_HCACHE (f))
|
|
|
188 {
|
|
|
189 struct scrollbar_instance *tofree = FRAME_SB_HCACHE (f);
|
|
|
190 FRAME_SB_HCACHE (f) = FRAME_SB_HCACHE (f)->next;
|
|
|
191 tofree->next = NULL;
|
|
|
192 free_scrollbar_instance (tofree, f);
|
|
|
193 }
|
|
|
194 }
|
|
|
195
|
|
|
196
|
|
|
197 static struct scrollbar_instance *
|
|
|
198 create_scrollbar_instance (struct frame *f, int vertical)
|
|
|
199 {
|
|
|
200 struct device *d = XDEVICE (f->device);
|
|
|
201 struct scrollbar_instance *instance =
|
|
2720
|
202 #ifdef MC_ALLOC
|
|
|
203 alloc_lrecord_type (struct scrollbar_instance,
|
|
|
204 &lrecord_scrollbar_instance);
|
|
|
205 #else /* not MC_ALLOC */
|
|
617
|
206 alloc_lcrecord_type (struct scrollbar_instance,
|
|
|
207 &lrecord_scrollbar_instance);
|
|
2720
|
208 #endif /* not MC_ALLOC */
|
|
428
|
209
|
|
|
210 MAYBE_DEVMETH (d, create_scrollbar_instance, (f, vertical, instance));
|
|
|
211
|
|
|
212 return instance;
|
|
|
213 }
|
|
|
214
|
|
|
215
|
|
|
216 #define GET_SCROLLBAR_INSTANCE_INTERNAL(cache) \
|
|
|
217 do { \
|
|
|
218 if (FRAME_SB_##cache (f)) \
|
|
|
219 { \
|
|
|
220 struct scrollbar_instance *retval = FRAME_SB_##cache (f); \
|
|
|
221 FRAME_SB_##cache (f) = FRAME_SB_##cache (f)->next; \
|
|
|
222 retval->next = NULL; \
|
|
|
223 return retval; \
|
|
|
224 } \
|
|
|
225 } while (0)
|
|
|
226
|
|
|
227 static struct scrollbar_instance *
|
|
|
228 get_scrollbar_instance (struct frame *f, int vertical)
|
|
|
229 {
|
|
|
230 /* Check if there are any available scrollbars already in existence. */
|
|
|
231 if (vertical)
|
|
|
232 GET_SCROLLBAR_INSTANCE_INTERNAL (VCACHE);
|
|
|
233 else
|
|
|
234 GET_SCROLLBAR_INSTANCE_INTERNAL (HCACHE);
|
|
|
235
|
|
|
236 return create_scrollbar_instance (f, vertical);
|
|
|
237 }
|
|
|
238 #undef GET_SCROLLBAR_INSTANCE_INTERNAL
|
|
|
239
|
|
|
240 #define RELEASE_SCROLLBAR_INSTANCE_INTERNAL(cache) \
|
|
|
241 do { \
|
|
|
242 if (!FRAME_SB_##cache (f)) \
|
|
|
243 { \
|
|
|
244 instance->next = NULL; \
|
|
|
245 FRAME_SB_##cache (f) = instance; \
|
|
|
246 } \
|
|
|
247 else \
|
|
|
248 { \
|
|
|
249 instance->next = FRAME_SB_##cache (f); \
|
|
|
250 FRAME_SB_##cache (f) = instance; \
|
|
|
251 } \
|
|
|
252 } while (0)
|
|
|
253
|
|
|
254 static void
|
|
|
255 release_scrollbar_instance (struct frame *f, int vertical,
|
|
|
256 struct scrollbar_instance *instance)
|
|
|
257 {
|
|
|
258 /* #### should we do "instance->mir = 0;" for safety? */
|
|
|
259 if (vertical)
|
|
|
260 RELEASE_SCROLLBAR_INSTANCE_INTERNAL (VCACHE);
|
|
|
261 else
|
|
|
262 RELEASE_SCROLLBAR_INSTANCE_INTERNAL (HCACHE);
|
|
|
263 }
|
|
|
264 #undef RELEASE_SCROLLBAR_INSTANCE_INTERNAL
|
|
|
265
|
|
|
266 #ifdef MEMORY_USAGE_STATS
|
|
|
267
|
|
|
268 int
|
|
|
269 compute_scrollbar_instance_usage (struct device *d,
|
|
|
270 struct scrollbar_instance *inst,
|
|
|
271 struct overhead_stats *ovstats)
|
|
|
272 {
|
|
|
273 int total = 0;
|
|
|
274
|
|
2469
|
275 if (HAS_DEVMETH_P(d, compute_scrollbar_instance_usage))
|
|
|
276 total += DEVMETH (d, compute_scrollbar_instance_usage, (d, inst, ovstats));
|
|
428
|
277
|
|
|
278 while (inst)
|
|
|
279 {
|
|
2720
|
280 #ifdef MC_ALLOC
|
|
|
281 total += mc_alloced_storage_size (sizeof (*inst), ovstats);
|
|
|
282 #else /* not MC_ALLOC */
|
|
428
|
283 total += malloced_storage_size (inst, sizeof (*inst), ovstats);
|
|
2720
|
284 #endif /* not MC_ALLOC */
|
|
428
|
285 inst = inst->next;
|
|
|
286 }
|
|
|
287
|
|
|
288 return total;
|
|
|
289 }
|
|
|
290
|
|
|
291 #endif /* MEMORY_USAGE_STATS */
|
|
|
292
|
|
|
293 void
|
|
|
294 update_window_scrollbars (struct window *w, struct window_mirror *mirror,
|
|
|
295 int active, int horiz_only)
|
|
|
296 {
|
|
|
297 struct frame *f = XFRAME (w->frame);
|
|
|
298 struct device *d = XDEVICE (f->device);
|
|
1318
|
299 int depth;
|
|
428
|
300
|
|
|
301 if (!HAS_DEVMETH_P (d, create_scrollbar_instance))
|
|
|
302 return;
|
|
|
303
|
|
1318
|
304 depth = enter_redisplay_critical_section_maybe ();
|
|
428
|
305
|
|
|
306 /* It is possible for this to get called from the mirror update
|
|
|
307 routines. In that case the structure is in an indeterminate
|
|
|
308 state but we know exactly what struct we are working with. So we
|
|
|
309 pass it in in that case. We also take advantage of it at some
|
|
|
310 other points where we know what the mirror struct is. */
|
|
|
311 if (!mirror)
|
|
|
312 mirror = find_window_mirror (w);
|
|
|
313
|
|
|
314 if (!mirror->scrollbar_vertical_instance && active)
|
|
|
315 mirror->scrollbar_vertical_instance = get_scrollbar_instance (f, 1);
|
|
|
316
|
|
|
317 if (!mirror->scrollbar_horizontal_instance && active)
|
|
|
318 mirror->scrollbar_horizontal_instance = get_scrollbar_instance (f, 0);
|
|
|
319
|
|
|
320 if (!horiz_only && mirror->scrollbar_vertical_instance)
|
|
|
321 {
|
|
|
322 int size = (active ? window_scrollbar_width (w) : 0);
|
|
|
323 struct scrollbar_instance *instance;
|
|
|
324
|
|
|
325 instance = mirror->scrollbar_vertical_instance;
|
|
|
326 instance->scrollbar_is_active = active;
|
|
|
327 instance->mirror = mirror;
|
|
|
328
|
|
|
329 if (active && size)
|
|
|
330 update_scrollbar_instance (w, 1, instance);
|
|
|
331 MAYBE_DEVMETH (d, update_scrollbar_instance_status,
|
|
|
332 (w, active, size, instance));
|
|
|
333
|
|
|
334 if (!active)
|
|
|
335 {
|
|
|
336 release_scrollbar_instance (f, 1, instance);
|
|
|
337 mirror->scrollbar_vertical_instance = NULL;
|
|
|
338 }
|
|
|
339 }
|
|
|
340
|
|
|
341 if (mirror->scrollbar_horizontal_instance)
|
|
|
342 {
|
|
|
343 int size = (active ? window_scrollbar_height (w) : 0);
|
|
|
344 struct scrollbar_instance *instance;
|
|
|
345
|
|
|
346 instance = mirror->scrollbar_horizontal_instance;
|
|
|
347 instance->scrollbar_is_active = active;
|
|
|
348 instance->mirror = mirror;
|
|
|
349
|
|
|
350 if (active && size)
|
|
|
351 update_scrollbar_instance (w, 0, instance);
|
|
|
352 MAYBE_DEVMETH (d, update_scrollbar_instance_status,
|
|
|
353 (w, active, size, instance));
|
|
|
354
|
|
|
355 if (!active)
|
|
|
356 {
|
|
|
357 release_scrollbar_instance (f, 0, instance);
|
|
|
358 mirror->scrollbar_horizontal_instance = NULL;
|
|
|
359 }
|
|
|
360 }
|
|
|
361
|
|
1318
|
362 exit_redisplay_critical_section_maybe (depth);
|
|
428
|
363 }
|
|
|
364
|
|
|
365 void
|
|
|
366 release_window_mirror_scrollbars (struct window_mirror *mir)
|
|
|
367 {
|
|
|
368 struct device *d = XDEVICE (mir->frame->device);
|
|
|
369
|
|
|
370 if (!HAS_DEVMETH_P (d, create_scrollbar_instance))
|
|
|
371 return;
|
|
|
372
|
|
|
373 if (mir->scrollbar_vertical_instance)
|
|
|
374 {
|
|
|
375 release_scrollbar_instance (mir->frame, 1,
|
|
|
376 mir->scrollbar_vertical_instance);
|
|
|
377 MAYBE_DEVMETH (d, release_scrollbar_instance,
|
|
|
378 (mir->scrollbar_vertical_instance));
|
|
|
379 }
|
|
|
380 mir->scrollbar_vertical_instance = 0;
|
|
|
381
|
|
|
382 if (mir->scrollbar_horizontal_instance)
|
|
|
383 {
|
|
|
384 release_scrollbar_instance (mir->frame, 0,
|
|
|
385 mir->scrollbar_horizontal_instance);
|
|
|
386 MAYBE_DEVMETH (d, release_scrollbar_instance,
|
|
|
387 (mir->scrollbar_horizontal_instance));
|
|
|
388 }
|
|
|
389 mir->scrollbar_horizontal_instance = 0;
|
|
|
390 }
|
|
|
391
|
|
|
392 /*
|
|
|
393 * If w->sb_point is on the top line then return w->sb_point else
|
|
|
394 * return w->start. If flag, then return beginning point of line
|
|
|
395 * which w->sb_point lies on.
|
|
|
396 */
|
|
665
|
397 static Charbpos
|
|
428
|
398 scrollbar_point (struct window *w, int flag)
|
|
|
399 {
|
|
665
|
400 Charbpos start_pos, end_pos, sb_pos;
|
|
428
|
401 Lisp_Object buf;
|
|
|
402 struct buffer *b;
|
|
|
403
|
|
|
404 if (NILP (w->buffer)) /* non-leaf window */
|
|
|
405 return 0;
|
|
|
406
|
|
|
407 start_pos = marker_position (w->start[CURRENT_DISP]);
|
|
|
408 sb_pos = marker_position (w->sb_point);
|
|
|
409
|
|
|
410 if (!flag && sb_pos < start_pos)
|
|
|
411 return start_pos;
|
|
|
412
|
|
|
413 buf = get_buffer (w->buffer, 0);
|
|
|
414 if (!NILP (buf))
|
|
|
415 b = XBUFFER (buf);
|
|
|
416 else
|
|
|
417 return start_pos;
|
|
|
418
|
|
|
419 if (flag)
|
|
|
420 end_pos = find_next_newline_no_quit (b, sb_pos, -1);
|
|
|
421 else
|
|
|
422 end_pos = find_next_newline_no_quit (b, start_pos, 1);
|
|
|
423
|
|
|
424 if (flag)
|
|
|
425 return end_pos;
|
|
|
426 else if (sb_pos > end_pos)
|
|
|
427 return start_pos;
|
|
|
428 else
|
|
|
429 return sb_pos;
|
|
|
430 }
|
|
|
431
|
|
|
432 /*
|
|
|
433 * Update a window's horizontal or vertical scrollbar.
|
|
|
434 */
|
|
|
435 static void
|
|
|
436 update_scrollbar_instance (struct window *w, int vertical,
|
|
|
437 struct scrollbar_instance *instance)
|
|
|
438 {
|
|
|
439 struct frame *f = XFRAME (w->frame);
|
|
|
440 struct device *d = XDEVICE (f->device);
|
|
|
441 struct buffer *b = XBUFFER (w->buffer);
|
|
665
|
442 Charbpos start_pos, end_pos, sb_pos;
|
|
428
|
443 int scrollbar_width = window_scrollbar_width (w);
|
|
|
444 int scrollbar_height = window_scrollbar_height (w);
|
|
|
445
|
|
|
446 int new_line_increment = -1, new_page_increment = -1;
|
|
|
447 int new_minimum = -1, new_maximum = -1;
|
|
|
448 int new_slider_size = -1, new_slider_position = -1;
|
|
|
449 int new_width = -1, new_height = -1, new_x = -1, new_y = -1;
|
|
2286
|
450 #if 0
|
|
444
|
451 struct window *new_window = 0; /* #### currently unused */
|
|
2286
|
452 #endif
|
|
428
|
453
|
|
|
454 end_pos = BUF_Z (b) - w->window_end_pos[CURRENT_DISP];
|
|
|
455 sb_pos = scrollbar_point (w, 0);
|
|
|
456 start_pos = sb_pos;
|
|
|
457
|
|
|
458 /* The end position must be strictly greater than the start
|
|
|
459 position, at least for the Motify scrollbar. It shouldn't hurt
|
|
|
460 anything for other scrollbar implementations. */
|
|
|
461 if (end_pos <= start_pos)
|
|
|
462 end_pos = start_pos + 1;
|
|
|
463
|
|
|
464 if (vertical)
|
|
|
465 {
|
|
|
466 new_height = WINDOW_TEXT_HEIGHT (w);
|
|
|
467 new_width = scrollbar_width;
|
|
|
468 }
|
|
|
469 else
|
|
|
470 {
|
|
|
471 new_height = scrollbar_height;
|
|
|
472 new_width = WINDOW_TEXT_WIDTH (w);
|
|
|
473 }
|
|
|
474
|
|
|
475 /* If the height and width are not greater than 0, then later on the
|
|
|
476 Motif widgets will bitch and moan. */
|
|
|
477 if (new_height <= 0)
|
|
|
478 new_height = 1;
|
|
|
479 if (new_width <= 0)
|
|
|
480 new_width = 1;
|
|
|
481
|
|
|
482 assert (instance->mirror && XWINDOW (real_window(instance->mirror, 0)) == w);
|
|
|
483
|
|
|
484 /* Only character-based scrollbars are implemented at the moment.
|
|
|
485 Line-based will be implemented in the future. */
|
|
|
486
|
|
|
487 instance->scrollbar_is_active = 1;
|
|
|
488 new_line_increment = 1;
|
|
|
489 new_page_increment = 1;
|
|
|
490
|
|
|
491 /* We used to check for inhibit_scrollbar_slider_size_change here,
|
|
|
492 but that seems bogus. */
|
|
|
493 {
|
|
|
494 int x_offset, y_offset;
|
|
|
495
|
|
|
496 /* Scrollbars are always the farthest from the text area, barring
|
|
|
497 gutters. */
|
|
|
498 if (vertical)
|
|
|
499 {
|
|
|
500 if (!NILP (w->scrollbar_on_left_p))
|
|
|
501 {
|
|
|
502 x_offset = WINDOW_LEFT (w);
|
|
|
503 }
|
|
442
|
504 else
|
|
428
|
505 {
|
|
|
506 x_offset = WINDOW_RIGHT (w) - scrollbar_width;
|
|
|
507 if (window_needs_vertical_divider (w))
|
|
|
508 x_offset -= window_divider_width (w);
|
|
|
509 }
|
|
|
510 y_offset = WINDOW_TEXT_TOP (w) + f->scrollbar_y_offset;
|
|
|
511 }
|
|
|
512 else
|
|
|
513 {
|
|
|
514 x_offset = WINDOW_TEXT_LEFT (w);
|
|
|
515 y_offset = f->scrollbar_y_offset;
|
|
|
516
|
|
|
517 if (!NILP (w->scrollbar_on_top_p))
|
|
|
518 {
|
|
|
519 y_offset += WINDOW_TOP (w);
|
|
|
520 }
|
|
|
521 else
|
|
|
522 {
|
|
|
523 y_offset += WINDOW_TEXT_BOTTOM (w);
|
|
|
524 }
|
|
|
525 }
|
|
|
526
|
|
|
527 new_x = x_offset;
|
|
|
528 new_y = y_offset;
|
|
|
529 }
|
|
|
530
|
|
|
531 /* A disabled scrollbar has its slider sized to the entire height of
|
|
|
532 the scrollbar. Currently the minibuffer scrollbar is
|
|
|
533 disabled. */
|
|
|
534 if (!MINI_WINDOW_P (w) && vertical)
|
|
|
535 {
|
|
|
536 if (!DEVMETH_OR_GIVEN (d, inhibit_scrollbar_slider_size_change, (), 0))
|
|
|
537 {
|
|
|
538 new_minimum = BUF_BEGV (b);
|
|
|
539 new_maximum = max (BUF_ZV (b), new_minimum + 1);
|
|
|
540 new_slider_size = min ((end_pos - start_pos),
|
|
|
541 (new_maximum - new_minimum));
|
|
|
542 new_slider_position = sb_pos;
|
|
2286
|
543 #if 0
|
|
428
|
544 new_window = w;
|
|
2286
|
545 #endif
|
|
428
|
546 }
|
|
|
547 }
|
|
|
548 else if (!MINI_WINDOW_P (w))
|
|
|
549 {
|
|
|
550 /* The minus one is to account for the truncation glyph. */
|
|
|
551 int wcw = window_char_width (w, 0) - 1;
|
|
|
552 int max_width, max_slide;
|
|
|
553
|
|
|
554 if (w->max_line_len < wcw)
|
|
|
555 {
|
|
|
556 max_width = 1;
|
|
|
557 max_slide = 1;
|
|
|
558 wcw = 1;
|
|
|
559 }
|
|
|
560 else
|
|
|
561 {
|
|
|
562 max_width = w->max_line_len + 2;
|
|
|
563 max_slide = max_width - wcw;
|
|
|
564 }
|
|
|
565
|
|
|
566 new_minimum = 0;
|
|
|
567 new_maximum = max_width;
|
|
|
568 new_slider_size = wcw;
|
|
|
569 new_slider_position = min (w->hscroll, max_slide);
|
|
|
570 }
|
|
|
571 else /* MINI_WINDOW_P (w) */
|
|
|
572 {
|
|
|
573 new_minimum = 1;
|
|
|
574 new_maximum = 2;
|
|
|
575 new_slider_size = 1;
|
|
|
576 new_slider_position = 1;
|
|
|
577 instance->scrollbar_is_active = 0;
|
|
|
578 }
|
|
|
579
|
|
|
580 DEVMETH (d, update_scrollbar_instance_values, (w, instance,
|
|
|
581 new_line_increment,
|
|
|
582 new_page_increment,
|
|
|
583 new_minimum,
|
|
|
584 new_maximum,
|
|
|
585 new_slider_size,
|
|
|
586 new_slider_position,
|
|
|
587 new_width, new_height,
|
|
|
588 new_x, new_y));
|
|
|
589 }
|
|
|
590
|
|
|
591 void
|
|
|
592 init_frame_scrollbars (struct frame *f)
|
|
|
593 {
|
|
|
594 struct device *d = XDEVICE (f->device);
|
|
|
595
|
|
|
596 if (HAS_DEVMETH_P (d, create_scrollbar_instance))
|
|
|
597 {
|
|
|
598 int depth = unlock_ghost_specifiers_protected ();
|
|
793
|
599 Lisp_Object frame = wrap_frame (f);
|
|
|
600
|
|
428
|
601 call_critical_lisp_code (XDEVICE (FRAME_DEVICE (f)),
|
|
|
602 Qinit_scrollbar_from_resources,
|
|
|
603 frame);
|
|
771
|
604 unbind_to (depth);
|
|
428
|
605 }
|
|
|
606 }
|
|
|
607
|
|
|
608 void
|
|
|
609 init_device_scrollbars (struct device *d)
|
|
|
610 {
|
|
|
611 if (HAS_DEVMETH_P (d, create_scrollbar_instance))
|
|
|
612 {
|
|
|
613 int depth = unlock_ghost_specifiers_protected ();
|
|
793
|
614 Lisp_Object device = wrap_device (d);
|
|
|
615
|
|
428
|
616 call_critical_lisp_code (d,
|
|
|
617 Qinit_scrollbar_from_resources,
|
|
|
618 device);
|
|
771
|
619 unbind_to (depth);
|
|
428
|
620 }
|
|
|
621 }
|
|
|
622
|
|
|
623 void
|
|
|
624 init_global_scrollbars (struct device *d)
|
|
|
625 {
|
|
|
626 if (HAS_DEVMETH_P (d, create_scrollbar_instance))
|
|
|
627 {
|
|
|
628 int depth = unlock_ghost_specifiers_protected ();
|
|
|
629 call_critical_lisp_code (d,
|
|
|
630 Qinit_scrollbar_from_resources,
|
|
|
631 Qglobal);
|
|
771
|
632 unbind_to (depth);
|
|
428
|
633 }
|
|
|
634 }
|
|
|
635
|
|
|
636 static void
|
|
2286
|
637 vertical_scrollbar_changed_in_window (Lisp_Object UNUSED (specifier),
|
|
428
|
638 struct window *w,
|
|
2286
|
639 Lisp_Object UNUSED (oldval))
|
|
428
|
640 {
|
|
|
641 /* Hold on your cerebella guys. If we always show the dividers,
|
|
|
642 changing scrollbar affects only how the text and scrollbar are
|
|
|
643 laid out in the window. If we do not want the dividers to show up
|
|
|
644 always, then we mark more drastic change, because changing
|
|
|
645 divider appearance changes lotta things. Although we actually need
|
|
|
646 to do this only if the scrollbar has appeared or disappeared
|
|
|
647 completely at either window edge, we do this always, as users
|
|
|
648 usually do not reposition scrollbars 200 times a second or so. Do
|
|
|
649 you? */
|
|
|
650 if (NILP (w->vertical_divider_always_visible_p))
|
|
|
651 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (XFRAME (WINDOW_FRAME (w)));
|
|
|
652 else
|
|
|
653 MARK_WINDOWS_CHANGED (w);
|
|
|
654 }
|
|
|
655
|
|
|
656 /* This function is called as a result of a change to the
|
|
|
657 `scrollbar-pointer' glyph. */
|
|
|
658 static void
|
|
2286
|
659 scrollbar_pointer_changed_in_window (Lisp_Object UNUSED (specifier),
|
|
|
660 struct window *w,
|
|
|
661 Lisp_Object UNUSED (oldval))
|
|
428
|
662 {
|
|
|
663 struct frame *f = XFRAME (WINDOW_FRAME (w));
|
|
|
664
|
|
|
665 if (f->init_finished)
|
|
|
666 MAYBE_FRAMEMETH (f, scrollbar_pointer_changed_in_window, (w));
|
|
|
667 }
|
|
|
668
|
|
|
669 /* ####
|
|
|
670
|
|
|
671 All of the following stuff is functions that handle scrollbar
|
|
|
672 actions. All of it should be moved into Lisp. This may require
|
|
|
673 adding some badly-needed primitives. */
|
|
|
674
|
|
|
675 /********** vertical scrollbar stuff **********/
|
|
|
676
|
|
|
677 /*
|
|
|
678 * If the original point is still visible, put the cursor back there.
|
|
|
679 * Otherwise, when scrolling down stick it at the beginning of the
|
|
|
680 * first visible line and when scrolling up stick it at the beginning
|
|
|
681 * of the last visible line.
|
|
|
682 */
|
|
|
683
|
|
|
684 /* #### This function should be moved into Lisp */
|
|
|
685 static void
|
|
|
686 scrollbar_reset_cursor (Lisp_Object win, Lisp_Object orig_pt)
|
|
|
687 {
|
|
|
688 /* When this function is called we know that start is already
|
|
|
689 accurate. We know this because either set-window-start or
|
|
|
690 recenter was called immediately prior to it being called. */
|
|
|
691 Lisp_Object buf;
|
|
665
|
692 Charbpos start_pos = XINT (Fwindow_start (win));
|
|
|
693 Charbpos ptint = XINT (orig_pt);
|
|
428
|
694 struct window *w = XWINDOW (win);
|
|
|
695 int selected = ((w == XWINDOW (Fselected_window (XFRAME (w->frame)->device)))
|
|
|
696 ? 1
|
|
|
697 : 0);
|
|
|
698
|
|
|
699 buf = Fwindow_buffer (win);
|
|
|
700 if (NILP (buf))
|
|
|
701 return; /* the window was deleted out from under us */
|
|
|
702
|
|
|
703 if (ptint < XINT (Fwindow_start (win)))
|
|
|
704 {
|
|
|
705 if (selected)
|
|
|
706 Fgoto_char (make_int (start_pos), buf);
|
|
|
707 else
|
|
|
708 Fset_window_point (win, make_int (start_pos));
|
|
|
709 }
|
|
1708
|
710 else if (!point_would_be_visible (XWINDOW (win), start_pos, ptint, 0))
|
|
428
|
711 {
|
|
|
712 Fmove_to_window_line (make_int (-1), win);
|
|
|
713
|
|
|
714 if (selected)
|
|
|
715 Fbeginning_of_line (Qnil, buf);
|
|
|
716 else
|
|
|
717 {
|
|
|
718 /* #### Taken from forward-line. */
|
|
665
|
719 Charbpos pos;
|
|
428
|
720
|
|
|
721 pos = find_next_newline (XBUFFER (buf),
|
|
|
722 marker_position (w->pointm[CURRENT_DISP]),
|
|
|
723 -1);
|
|
|
724 Fset_window_point (win, make_int (pos));
|
|
|
725 }
|
|
|
726 }
|
|
|
727 else
|
|
|
728 {
|
|
|
729 if (selected)
|
|
|
730 Fgoto_char (orig_pt, buf);
|
|
|
731 else
|
|
|
732 Fset_window_point (win, orig_pt);
|
|
|
733 }
|
|
|
734 }
|
|
|
735
|
|
|
736 DEFUN ("scrollbar-line-up", Fscrollbar_line_up, 1, 1, 0, /*
|
|
|
737 Function called when the line-up arrow on the scrollbar is clicked.
|
|
|
738 This is the little arrow at the top of the scrollbar. One argument, the
|
|
|
739 scrollbar's window. You can advise this function to change the scrollbar
|
|
|
740 behavior.
|
|
|
741 */
|
|
|
742 (window))
|
|
|
743 {
|
|
|
744 CHECK_LIVE_WINDOW (window);
|
|
|
745 window_scroll (window, make_int (1), -1, ERROR_ME_NOT);
|
|
|
746 zmacs_region_stays = 1;
|
|
|
747 return Qnil;
|
|
|
748 }
|
|
|
749
|
|
|
750 DEFUN ("scrollbar-line-down", Fscrollbar_line_down, 1, 1, 0, /*
|
|
|
751 Function called when the line-down arrow on the scrollbar is clicked.
|
|
|
752 This is the little arrow at the bottom of the scrollbar. One argument, the
|
|
|
753 scrollbar's window. You can advise this function to change the scrollbar
|
|
|
754 behavior.
|
|
|
755 */
|
|
|
756 (window))
|
|
|
757 {
|
|
|
758 CHECK_LIVE_WINDOW (window);
|
|
|
759 window_scroll (window, make_int (1), 1, ERROR_ME_NOT);
|
|
|
760 zmacs_region_stays = 1;
|
|
|
761 return Qnil;
|
|
|
762 }
|
|
|
763
|
|
|
764 DEFUN ("scrollbar-page-up", Fscrollbar_page_up, 1, 1, 0, /*
|
|
|
765 Function called when the user gives the "page-up" scrollbar action.
|
|
|
766 \(The way this is done can vary from scrollbar to scrollbar.) One argument,
|
|
|
767 a cons containing the scrollbar's window and a value (#### document me!
|
|
|
768 This value is nil for Motif/Lucid scrollbars and a number for Athena
|
|
|
769 scrollbars). You can advise this function to change the scrollbar
|
|
|
770 behavior.
|
|
|
771 */
|
|
|
772 (object))
|
|
|
773 {
|
|
|
774 Lisp_Object window = Fcar (object);
|
|
|
775
|
|
|
776 CHECK_LIVE_WINDOW (window);
|
|
|
777 /* Motif and Athena scrollbars behave differently, but in accordance
|
|
|
778 with their standard behaviors. It is not possible to hide the
|
|
|
779 differences down in lwlib because knowledge of XEmacs buffer and
|
|
|
780 cursor motion routines is necessary. */
|
|
442
|
781
|
|
|
782 if (NILP (XCDR (object)))
|
|
|
783 window_scroll (window, Qnil, -1, ERROR_ME_NOT);
|
|
|
784 else
|
|
|
785 {
|
|
665
|
786 Charbpos charbpos;
|
|
442
|
787 Lisp_Object value = Fcdr (object);
|
|
428
|
788
|
|
442
|
789 CHECK_INT (value);
|
|
|
790 Fmove_to_window_line (Qzero, window);
|
|
|
791 /* can't use Fvertical_motion() because it moves the buffer point
|
|
|
792 rather than the window's point.
|
|
428
|
793
|
|
442
|
794 #### It does? Why does it take a window argument then? */
|
|
665
|
795 charbpos = vmotion (XWINDOW (window), XINT (Fwindow_point (window)),
|
|
442
|
796 XINT (value), 0);
|
|
665
|
797 Fset_window_point (window, make_int (charbpos));
|
|
442
|
798 Fcenter_to_window_line (Qzero, window);
|
|
|
799 }
|
|
|
800
|
|
428
|
801 zmacs_region_stays = 1;
|
|
|
802 return Qnil;
|
|
|
803 }
|
|
|
804
|
|
|
805 DEFUN ("scrollbar-page-down", Fscrollbar_page_down, 1, 1, 0, /*
|
|
|
806 Function called when the user gives the "page-down" scrollbar action.
|
|
|
807 \(The way this is done can vary from scrollbar to scrollbar.) One argument,
|
|
|
808 a cons containing the scrollbar's window and a value (#### document me!
|
|
|
809 This value is nil for Motif/Lucid scrollbars and a number for Athena
|
|
|
810 scrollbars). You can advise this function to change the scrollbar
|
|
|
811 behavior.
|
|
|
812 */
|
|
|
813 (object))
|
|
|
814 {
|
|
|
815 Lisp_Object window = Fcar (object);
|
|
|
816
|
|
|
817 CHECK_LIVE_WINDOW (window);
|
|
|
818 /* Motif and Athena scrollbars behave differently, but in accordance
|
|
|
819 with their standard behaviors. It is not possible to hide the
|
|
|
820 differences down in lwlib because knowledge of XEmacs buffer and
|
|
|
821 cursor motion routines is necessary. */
|
|
442
|
822
|
|
|
823 if (NILP (XCDR (object)))
|
|
|
824 window_scroll (window, Qnil, 1, ERROR_ME_NOT);
|
|
|
825 else
|
|
|
826 {
|
|
|
827 Lisp_Object value = Fcdr (object);
|
|
|
828 CHECK_INT (value);
|
|
|
829 Fmove_to_window_line (value, window);
|
|
|
830 Fcenter_to_window_line (Qzero, window);
|
|
|
831 }
|
|
|
832
|
|
428
|
833 zmacs_region_stays = 1;
|
|
|
834 return Qnil;
|
|
|
835 }
|
|
|
836
|
|
|
837 DEFUN ("scrollbar-to-top", Fscrollbar_to_top, 1, 1, 0, /*
|
|
|
838 Function called when the user invokes the "to-top" scrollbar action.
|
|
|
839 The way this is done can vary from scrollbar to scrollbar, but
|
|
|
840 C-button1 on the up-arrow is very common. One argument, the
|
|
|
841 scrollbar's window. You can advise this function to change the
|
|
|
842 scrollbar behavior.
|
|
|
843 */
|
|
|
844 (window))
|
|
|
845 {
|
|
|
846 Lisp_Object orig_pt = Fwindow_point (window);
|
|
|
847 Fset_window_point (window, Fpoint_min (Fwindow_buffer (window)));
|
|
|
848 Fcenter_to_window_line (Qzero, window);
|
|
|
849 scrollbar_reset_cursor (window, orig_pt);
|
|
|
850 zmacs_region_stays = 1;
|
|
|
851 return Qnil;
|
|
|
852 }
|
|
|
853
|
|
|
854 DEFUN ("scrollbar-to-bottom", Fscrollbar_to_bottom, 1, 1, 0, /*
|
|
|
855 Function called when the user invokes the "to-bottom" scrollbar action.
|
|
|
856 The way this is done can vary from scrollbar to scrollbar, but
|
|
|
857 C-button1 on the down-arrow is very common. One argument, the
|
|
|
858 scrollbar's window. You can advise this function to change the
|
|
|
859 scrollbar behavior.
|
|
|
860 */
|
|
|
861 (window))
|
|
|
862 {
|
|
|
863 Lisp_Object orig_pt = Fwindow_point (window);
|
|
|
864 Fset_window_point (window, Fpoint_max (Fwindow_buffer (window)));
|
|
|
865 Fcenter_to_window_line (make_int (-3), window);
|
|
|
866 scrollbar_reset_cursor (window, orig_pt);
|
|
|
867 zmacs_region_stays = 1;
|
|
|
868 return Qnil;
|
|
|
869 }
|
|
|
870
|
|
|
871 DEFUN ("scrollbar-vertical-drag", Fscrollbar_vertical_drag, 1, 1, 0, /*
|
|
|
872 Function called when the user drags the vertical scrollbar slider.
|
|
|
873 One argument, a cons containing the scrollbar's window and a value
|
|
|
874 between point-min and point-max. You can advise this function to
|
|
|
875 change the scrollbar behavior.
|
|
|
876 */
|
|
|
877 (object))
|
|
|
878 {
|
|
665
|
879 Charbpos start_pos;
|
|
428
|
880 Lisp_Object orig_pt;
|
|
|
881 Lisp_Object window = Fcar (object);
|
|
|
882 Lisp_Object value = Fcdr (object);
|
|
|
883
|
|
|
884 orig_pt = Fwindow_point (window);
|
|
|
885 Fset_marker (XWINDOW (window)->sb_point, value, Fwindow_buffer (window));
|
|
|
886 start_pos = scrollbar_point (XWINDOW (window), 1);
|
|
|
887 Fset_window_start (window, make_int (start_pos), Qnil);
|
|
|
888 scrollbar_reset_cursor (window, orig_pt);
|
|
|
889 Fsit_for(Qzero, Qnil);
|
|
|
890 zmacs_region_stays = 1;
|
|
|
891 return Qnil;
|
|
|
892 }
|
|
|
893
|
|
|
894 DEFUN ("scrollbar-set-hscroll", Fscrollbar_set_hscroll, 2, 2, 0, /*
|
|
|
895 Set WINDOW's hscroll position to VALUE.
|
|
|
896 This ensures that VALUE is in the proper range for the horizontal scrollbar.
|
|
|
897 */
|
|
|
898 (window, value))
|
|
|
899 {
|
|
|
900 struct window *w;
|
|
|
901 int hscroll, wcw, max_len;
|
|
|
902
|
|
|
903 CHECK_LIVE_WINDOW (window);
|
|
|
904 if (!EQ (value, Qmax))
|
|
|
905 CHECK_INT (value);
|
|
|
906
|
|
|
907 w = XWINDOW (window);
|
|
|
908 wcw = window_char_width (w, 0) - 1;
|
|
440
|
909 /* #### We should be able to scroll further right as long as there is
|
|
428
|
910 a visible truncation glyph. This calculation for max is bogus. */
|
|
|
911 max_len = w->max_line_len + 2;
|
|
|
912
|
|
|
913 if (EQ (value, Qmax) || (XINT (value) > (max_len - wcw)))
|
|
|
914 hscroll = max_len - wcw;
|
|
|
915 else
|
|
|
916 hscroll = XINT (value);
|
|
|
917
|
|
|
918 /* Can't allow this out of set-window-hscroll's acceptable range. */
|
|
|
919 /* #### What hell on the earth this code limits scroll size to the
|
|
|
920 machine-dependent SHORT size? -- kkm */
|
|
|
921 if (hscroll < 0)
|
|
|
922 hscroll = 0;
|
|
|
923 else if (hscroll >= (1 << (SHORTBITS - 1)) - 1)
|
|
|
924 hscroll = (1 << (SHORTBITS - 1)) - 1;
|
|
|
925
|
|
|
926 if (hscroll != w->hscroll)
|
|
|
927 Fset_window_hscroll (window, make_int (hscroll));
|
|
|
928
|
|
|
929 return Qnil;
|
|
|
930 }
|
|
|
931
|
|
|
932
|
|
|
933 /************************************************************************/
|
|
|
934 /* initialization */
|
|
|
935 /************************************************************************/
|
|
|
936
|
|
|
937 void
|
|
|
938 syms_of_scrollbar (void)
|
|
|
939 {
|
|
617
|
940 INIT_LRECORD_IMPLEMENTATION (scrollbar_instance);
|
|
|
941
|
|
563
|
942 DEFSYMBOL (Qscrollbar_line_up);
|
|
|
943 DEFSYMBOL (Qscrollbar_line_down);
|
|
|
944 DEFSYMBOL (Qscrollbar_page_up);
|
|
|
945 DEFSYMBOL (Qscrollbar_page_down);
|
|
|
946 DEFSYMBOL (Qscrollbar_to_top);
|
|
|
947 DEFSYMBOL (Qscrollbar_to_bottom);
|
|
|
948 DEFSYMBOL (Qscrollbar_vertical_drag);
|
|
428
|
949
|
|
563
|
950 DEFSYMBOL (Qscrollbar_char_left);
|
|
|
951 DEFSYMBOL (Qscrollbar_char_right);
|
|
|
952 DEFSYMBOL (Qscrollbar_page_left);
|
|
|
953 DEFSYMBOL (Qscrollbar_page_right);
|
|
|
954 DEFSYMBOL (Qscrollbar_to_left);
|
|
|
955 DEFSYMBOL (Qscrollbar_to_right);
|
|
|
956 DEFSYMBOL (Qscrollbar_horizontal_drag);
|
|
428
|
957
|
|
563
|
958 DEFSYMBOL (Qinit_scrollbar_from_resources);
|
|
428
|
959
|
|
|
960 /* #### All these functions should be moved into Lisp.
|
|
|
961 See comment above. */
|
|
|
962 DEFSUBR (Fscrollbar_line_up);
|
|
|
963 DEFSUBR (Fscrollbar_line_down);
|
|
|
964 DEFSUBR (Fscrollbar_page_up);
|
|
|
965 DEFSUBR (Fscrollbar_page_down);
|
|
|
966 DEFSUBR (Fscrollbar_to_top);
|
|
|
967 DEFSUBR (Fscrollbar_to_bottom);
|
|
|
968 DEFSUBR (Fscrollbar_vertical_drag);
|
|
|
969
|
|
|
970 DEFSUBR (Fscrollbar_set_hscroll);
|
|
|
971 }
|
|
|
972
|
|
|
973 void
|
|
|
974 vars_of_scrollbar (void)
|
|
|
975 {
|
|
|
976 DEFVAR_LISP ("scrollbar-pointer-glyph", &Vscrollbar_pointer_glyph /*
|
|
|
977 *The shape of the mouse-pointer when over a scrollbar.
|
|
|
978 This is a glyph; use `set-glyph-image' to change it.
|
|
|
979 If unspecified in a particular domain, the window-system-provided
|
|
|
980 default pointer is used.
|
|
|
981 */ );
|
|
|
982
|
|
|
983 Fprovide (intern ("scrollbar"));
|
|
|
984 }
|
|
|
985
|
|
|
986 void
|
|
|
987 specifier_vars_of_scrollbar (void)
|
|
|
988 {
|
|
|
989 DEFVAR_SPECIFIER ("scrollbar-width", &Vscrollbar_width /*
|
|
|
990 *Width of vertical scrollbars.
|
|
|
991 This is a specifier; use `set-specifier' to change it.
|
|
|
992 */ );
|
|
|
993 Vscrollbar_width = make_magic_specifier (Qnatnum);
|
|
|
994 set_specifier_fallback
|
|
|
995 (Vscrollbar_width,
|
|
1295
|
996 #ifdef HAVE_TTY
|
|
1287
|
997 list2 (Fcons (list1 (Qtty), make_int (0)),
|
|
1295
|
998 Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_WIDTH)))
|
|
|
999 #else
|
|
|
1000 list1 (Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_WIDTH)))
|
|
|
1001 #endif
|
|
|
1002 );
|
|
428
|
1003 set_specifier_caching (Vscrollbar_width,
|
|
438
|
1004 offsetof (struct window, scrollbar_width),
|
|
428
|
1005 vertical_scrollbar_changed_in_window,
|
|
438
|
1006 offsetof (struct frame, scrollbar_width),
|
|
444
|
1007 frame_size_slipped, 0);
|
|
428
|
1008
|
|
|
1009 DEFVAR_SPECIFIER ("scrollbar-height", &Vscrollbar_height /*
|
|
|
1010 *Height of horizontal scrollbars.
|
|
|
1011 This is a specifier; use `set-specifier' to change it.
|
|
|
1012 */ );
|
|
|
1013 Vscrollbar_height = make_magic_specifier (Qnatnum);
|
|
|
1014 set_specifier_fallback
|
|
|
1015 (Vscrollbar_height,
|
|
1295
|
1016 #ifdef HAVE_TTY
|
|
1287
|
1017 list2 (Fcons (list1 (Qtty), make_int (0)),
|
|
1295
|
1018 Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_HEIGHT)))
|
|
|
1019 #else
|
|
|
1020 list1 (Fcons (Qnil, make_int (DEFAULT_SCROLLBAR_HEIGHT)))
|
|
|
1021 #endif
|
|
|
1022 );
|
|
428
|
1023 set_specifier_caching (Vscrollbar_height,
|
|
438
|
1024 offsetof (struct window, scrollbar_height),
|
|
428
|
1025 some_window_value_changed,
|
|
438
|
1026 offsetof (struct frame, scrollbar_height),
|
|
444
|
1027 frame_size_slipped, 0);
|
|
428
|
1028
|
|
|
1029 DEFVAR_SPECIFIER ("horizontal-scrollbar-visible-p", &Vhorizontal_scrollbar_visible_p /*
|
|
|
1030 *Whether the horizontal scrollbar is visible.
|
|
|
1031 This is a specifier; use `set-specifier' to change it.
|
|
|
1032 */ );
|
|
|
1033 Vhorizontal_scrollbar_visible_p = Fmake_specifier (Qboolean);
|
|
|
1034 set_specifier_fallback (Vhorizontal_scrollbar_visible_p,
|
|
|
1035 list1 (Fcons (Qnil, Qt)));
|
|
|
1036 set_specifier_caching (Vhorizontal_scrollbar_visible_p,
|
|
438
|
1037 offsetof (struct window,
|
|
|
1038 horizontal_scrollbar_visible_p),
|
|
428
|
1039 some_window_value_changed,
|
|
438
|
1040 offsetof (struct frame,
|
|
|
1041 horizontal_scrollbar_visible_p),
|
|
444
|
1042 frame_size_slipped, 0);
|
|
428
|
1043
|
|
|
1044 DEFVAR_SPECIFIER ("vertical-scrollbar-visible-p", &Vvertical_scrollbar_visible_p /*
|
|
|
1045 *Whether the vertical scrollbar is visible.
|
|
|
1046 This is a specifier; use `set-specifier' to change it.
|
|
|
1047 */ );
|
|
|
1048 Vvertical_scrollbar_visible_p = Fmake_specifier (Qboolean);
|
|
|
1049 set_specifier_fallback (Vvertical_scrollbar_visible_p,
|
|
|
1050 list1 (Fcons (Qnil, Qt)));
|
|
|
1051 set_specifier_caching (Vvertical_scrollbar_visible_p,
|
|
438
|
1052 offsetof (struct window,
|
|
|
1053 vertical_scrollbar_visible_p),
|
|
428
|
1054 vertical_scrollbar_changed_in_window,
|
|
438
|
1055 offsetof (struct frame,
|
|
|
1056 vertical_scrollbar_visible_p),
|
|
444
|
1057 frame_size_slipped, 0);
|
|
428
|
1058
|
|
|
1059 DEFVAR_SPECIFIER ("scrollbar-on-left-p", &Vscrollbar_on_left_p /*
|
|
|
1060 *Whether the vertical scrollbar is on the left side of window or frame.
|
|
|
1061 This is a specifier; use `set-specifier' to change it.
|
|
|
1062 */ );
|
|
|
1063 Vscrollbar_on_left_p = Fmake_specifier (Qboolean);
|
|
442
|
1064
|
|
428
|
1065 {
|
|
|
1066 /* Kludge. Under X, we want athena scrollbars on the left,
|
|
|
1067 while all other scrollbars go on the right by default. */
|
|
|
1068 Lisp_Object fallback = list1 (Fcons (Qnil, Qnil));
|
|
|
1069 #if defined (HAVE_X_WINDOWS) \
|
|
|
1070 && !defined (LWLIB_SCROLLBARS_MOTIF) \
|
|
|
1071 && !defined (LWLIB_SCROLLBARS_LUCID) \
|
|
|
1072 && !defined (LWLIB_SCROLLBARS_ATHENA3D)
|
|
|
1073
|
|
|
1074 fallback = Fcons (Fcons (list1 (Qx), Qt), fallback);
|
|
|
1075 #endif
|
|
|
1076 set_specifier_fallback (Vscrollbar_on_left_p, fallback);
|
|
|
1077 }
|
|
|
1078
|
|
|
1079 set_specifier_caching (Vscrollbar_on_left_p,
|
|
438
|
1080 offsetof (struct window, scrollbar_on_left_p),
|
|
428
|
1081 vertical_scrollbar_changed_in_window,
|
|
438
|
1082 offsetof (struct frame, scrollbar_on_left_p),
|
|
444
|
1083 frame_size_slipped, 0);
|
|
428
|
1084
|
|
|
1085 DEFVAR_SPECIFIER ("scrollbar-on-top-p", &Vscrollbar_on_top_p /*
|
|
|
1086 *Whether the horizontal scrollbar is on the top side of window or frame.
|
|
|
1087 This is a specifier; use `set-specifier' to change it.
|
|
|
1088 */ );
|
|
|
1089 Vscrollbar_on_top_p = Fmake_specifier (Qboolean);
|
|
|
1090 set_specifier_fallback (Vscrollbar_on_top_p,
|
|
|
1091 list1 (Fcons (Qnil, Qnil)));
|
|
|
1092 set_specifier_caching (Vscrollbar_on_top_p,
|
|
438
|
1093 offsetof (struct window, scrollbar_on_top_p),
|
|
428
|
1094 some_window_value_changed,
|
|
438
|
1095 offsetof (struct frame, scrollbar_on_top_p),
|
|
444
|
1096 frame_size_slipped, 0);
|
|
428
|
1097 }
|
|
|
1098
|
|
|
1099 void
|
|
|
1100 complex_vars_of_scrollbar (void)
|
|
|
1101 {
|
|
|
1102 Vscrollbar_pointer_glyph = Fmake_glyph_internal (Qpointer);
|
|
|
1103
|
|
|
1104 set_specifier_caching (XGLYPH (Vscrollbar_pointer_glyph)->image,
|
|
438
|
1105 offsetof (struct window, scrollbar_pointer),
|
|
428
|
1106 scrollbar_pointer_changed_in_window,
|
|
444
|
1107 0, 0, 0);
|
|
428
|
1108 }
|
