update.
[chise/xemacs-chise.git] / src / scrollbar-gtk.c
1 /* scrollbar implementation -- GTK interface.
2    Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
3    Copyright (C) 1994 Amdhal Corporation.
4    Copyright (C) 1995 Sun Microsystems, Inc.
5    Copyright (C) 1995 Darrell Kindred <dkindred+@cmu.edu>.
6
7 This file is part of XEmacs.
8
9 XEmacs is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
12 later version.
13
14 XEmacs is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with XEmacs; see the file COPYING.  If not, write to
21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA.  */
23
24 /* Synched up with: Not in FSF. */
25 /* Gtk version by William M. Perry */
26
27 #include <config.h>
28 #include "lisp.h"
29
30 #include "console-gtk.h"
31 #include "glyphs-gtk.h"
32 #include "gui-gtk.h"
33 #include "scrollbar-gtk.h"
34
35 #include "frame.h"
36 #include "window.h"
37
38 static gboolean scrollbar_cb (GtkAdjustment *adj, gpointer user_data);
39
40 /* Used to prevent changing the size of the slider while drag
41    scrolling, under Motif.  This is necessary because the Motif
42    scrollbar is incredibly stupid about updating the slider and causes
43    lots of flicker if it is done too often.  */
44 static int inhibit_slider_size_change;
45
46 static int vertical_drag_in_progress;
47
48 \f
49 /* A device method. */
50 static int
51 gtk_inhibit_scrollbar_slider_size_change (void)
52 {
53   return inhibit_slider_size_change;
54 }
55
56 /* A device method. */
57 static void
58 gtk_free_scrollbar_instance (struct scrollbar_instance *instance)
59 {
60   if (SCROLLBAR_GTK_WIDGET (instance))
61     {
62       gtk_widget_hide_all (SCROLLBAR_GTK_WIDGET (instance));
63       gtk_widget_destroy (SCROLLBAR_GTK_WIDGET (instance));
64     }
65
66   if (instance->scrollbar_data)
67     xfree (instance->scrollbar_data);
68 }
69
70 /* A device method. */
71 static void
72 gtk_release_scrollbar_instance (struct scrollbar_instance *instance)
73 {
74     /* It won't hurt to hide it all the time, will it? */
75     gtk_widget_hide_all (SCROLLBAR_GTK_WIDGET (instance));
76 }
77
78 static gboolean
79 scrollbar_drag_hack_cb (GtkWidget *w, GdkEventButton *ev, gpointer v)
80 {
81   vertical_drag_in_progress = (int) v;
82   inhibit_slider_size_change = (int) v;
83   return (FALSE);
84 }
85
86 /* A device method. */
87 static void
88 gtk_create_scrollbar_instance (struct frame *f, int vertical,
89                                struct scrollbar_instance *instance)
90 {
91   GtkAdjustment *adj = GTK_ADJUSTMENT (gtk_adjustment_new (0,0,0,0,0,0));
92   GtkScrollbar *sb = NULL;
93
94   /* initialize the X specific data section. */
95   instance->scrollbar_data = xnew_and_zero (struct gtk_scrollbar_data);
96
97   SCROLLBAR_GTK_ID (instance) = new_gui_id ();
98   SCROLLBAR_GTK_VDRAG_ORIG_VALUE (instance) = -1;
99   SCROLLBAR_GTK_LAST_VALUE (instance) = adj->value;
100
101   gtk_object_set_data (GTK_OBJECT (adj), GTK_DATA_GUI_IDENTIFIER,
102                        (void *) SCROLLBAR_GTK_ID (instance));
103   gtk_object_set_data (GTK_OBJECT (adj), GTK_DATA_FRAME_IDENTIFIER, f);
104   gtk_object_set_data (GTK_OBJECT (adj), "xemacs::sb_instance", instance);
105
106   sb = GTK_SCROLLBAR (vertical ? gtk_vscrollbar_new (adj) : gtk_hscrollbar_new (adj));
107   /* With gtk version > 1.2.8 the gtk code does not call
108      gtk_widget_request_size() on the newly created scrollbars
109      anymore (catering to theme engines).
110      #### Maybe it is better to postpone this call to just before
111      gtk_widget_show() is called on the scrollbar? */
112 #if GTK_MAJOR_VERSION == 1 && GTK_MINOR_VERSION == 2 && GTK_BINARY_AGE > 8
113   gtk_widget_size_request(GTK_WIDGET(sb), &(GTK_WIDGET(sb)->requisition));
114 #endif  
115   SCROLLBAR_GTK_WIDGET (instance) = GTK_WIDGET (sb);
116
117   gtk_signal_connect (GTK_OBJECT (adj),"value-changed",
118                       GTK_SIGNAL_FUNC (scrollbar_cb), (gpointer) vertical);
119
120   gtk_signal_connect (GTK_OBJECT (sb), "button-press-event",
121                       GTK_SIGNAL_FUNC (scrollbar_drag_hack_cb), (gpointer) 1);
122   gtk_signal_connect (GTK_OBJECT (sb), "button-release-event",
123                       GTK_SIGNAL_FUNC (scrollbar_drag_hack_cb), (gpointer) 0);
124
125   gtk_fixed_put (GTK_FIXED (FRAME_GTK_TEXT_WIDGET (f)), SCROLLBAR_GTK_WIDGET (instance), 0, 0);
126   gtk_widget_hide (SCROLLBAR_GTK_WIDGET (instance));
127 }
128
129 #define UPDATE_DATA_FIELD(field)                                \
130   if (new_##field >= 0 &&                                       \
131       SCROLLBAR_GTK_POS_DATA (inst).field != new_##field) {     \
132     SCROLLBAR_GTK_POS_DATA (inst).field = new_##field;          \
133     inst->scrollbar_instance_changed = 1;                       \
134   }
135
136 /* A device method. */
137 /* #### The -1 check is such a hack. */
138 static void
139 gtk_update_scrollbar_instance_values (struct window *w,
140                                       struct scrollbar_instance *inst,
141                                       int new_line_increment,
142                                       int new_page_increment,
143                                       int new_minimum, int new_maximum,
144                                       int new_slider_size,
145                                       int new_slider_position,
146                                       int new_scrollbar_width,
147                                       int new_scrollbar_height,
148                                       int new_scrollbar_x, int new_scrollbar_y)
149 {
150   UPDATE_DATA_FIELD (line_increment);
151   UPDATE_DATA_FIELD (page_increment);
152   UPDATE_DATA_FIELD (minimum);
153   UPDATE_DATA_FIELD (maximum);
154   UPDATE_DATA_FIELD (slider_size);
155   UPDATE_DATA_FIELD (slider_position);
156   UPDATE_DATA_FIELD (scrollbar_width);
157   UPDATE_DATA_FIELD (scrollbar_height);
158   UPDATE_DATA_FIELD (scrollbar_x);
159   UPDATE_DATA_FIELD (scrollbar_y);
160
161   if (w && !vertical_drag_in_progress)
162     {
163       int new_vov = SCROLLBAR_GTK_POS_DATA (inst).slider_position;
164       int new_vows = marker_position (w->start[CURRENT_DISP]);
165
166       if (SCROLLBAR_GTK_VDRAG_ORIG_VALUE (inst) != new_vov)
167         {
168           SCROLLBAR_GTK_VDRAG_ORIG_VALUE (inst) = new_vov;
169           inst->scrollbar_instance_changed = 1;
170         }
171       if (SCROLLBAR_GTK_VDRAG_ORIG_WINDOW_START (inst) != new_vows)
172         {
173           SCROLLBAR_GTK_VDRAG_ORIG_WINDOW_START (inst) = new_vows;
174           inst->scrollbar_instance_changed = 1;
175         }
176     }
177 }
178
179 /* Used by gtk_update_scrollbar_instance_status. */
180 static void
181 update_one_widget_scrollbar_pointer (struct window *w, GtkWidget *wid)
182 {
183   if (!wid->window)
184     gtk_widget_realize (wid);
185
186   if (POINTER_IMAGE_INSTANCEP (w->scrollbar_pointer))
187     {
188       gdk_window_set_cursor (GET_GTK_WIDGET_WINDOW (wid),
189                              XIMAGE_INSTANCE_GTK_CURSOR (w->scrollbar_pointer));
190       gdk_flush ();
191     }
192 }
193
194 /* A device method. */
195 static void
196 gtk_update_scrollbar_instance_status (struct window *w, int active, int size,
197                                       struct scrollbar_instance *instance)
198 {
199   struct frame *f = XFRAME (w->frame);
200   GtkWidget *wid = SCROLLBAR_GTK_WIDGET (instance);
201   gboolean managed = GTK_WIDGET_MAPPED (wid);
202
203   if (active && size)
204     {
205       if (instance->scrollbar_instance_changed)
206         {
207           /* Need to set the height, width, and position of the widget */
208           GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (wid));
209           scrollbar_values *pos_data = & SCROLLBAR_GTK_POS_DATA (instance);
210           int modified_p = 0;
211
212           /* We do not want to update the size all the time if we can
213              help it.  This cuts down on annoying flicker.
214           */
215           if ((wid->allocation.width != pos_data->scrollbar_width) ||
216               (wid->allocation.height != pos_data->scrollbar_height))
217             {
218               gtk_widget_set_usize (wid,
219                                     pos_data->scrollbar_width,
220                                     pos_data->scrollbar_height);
221
222               /*
223                 UGLY! UGLY! UGLY!  Changes to wid->allocation are queued and
224                 not performed until the GTK event loop.  However, when the
225                 fontlock progress bar is run, the vertical scrollbar's height
226                 is change and then changed back before events are again
227                 processed.  This means that the change back is not seen and
228                 the scrollbar is left too short.  Fix this by making the
229                 change manually so the test above sees the change.  This does
230                 not seem to cause problems in other cases.
231                */
232
233               wid->allocation.width = pos_data->scrollbar_width;
234               wid->allocation.height = pos_data->scrollbar_height;
235
236               modified_p = 1;
237             }
238
239           /* Ditto for the x/y position. */
240           if ((wid->allocation.x != pos_data->scrollbar_x) ||
241               (wid->allocation.y != pos_data->scrollbar_y))
242             {
243               gtk_fixed_move (GTK_FIXED (FRAME_GTK_TEXT_WIDGET (f)),
244                               wid,
245                               pos_data->scrollbar_x,
246                               pos_data->scrollbar_y);
247
248               /*
249                 UGLY! UGLY! UGLY!  Changes to wid->allocation are queued and
250                 not performed until the GTK event loop.  However, when the
251                 fontlock progress bar is run, the horizontal scrollbar's
252                 position is change and then changed back before events are
253                 again processed.  This means that the change back is not seen
254                 and the scrollbar is left in the wrong position.  Fix this by
255                 making the change manually so the test above sees the change.
256                 This does not seem to cause problems in other cases.
257                */
258
259               wid->allocation.x = pos_data->scrollbar_x;
260               wid->allocation.y = pos_data->scrollbar_y;
261
262               modified_p = 1;
263             }
264
265           adj->lower = pos_data->minimum;
266           adj->upper = pos_data->maximum;
267           adj->page_increment = pos_data->slider_size + 1;
268           adj->step_increment = w->max_line_len - 1;
269           adj->page_size = pos_data->slider_size + 1;
270           adj->value = pos_data->slider_position;
271
272           /* But, if we didn't resize or move the scrollbar, the
273              widget will not get redrawn correctly when the user
274              scrolls around in the XEmacs frame manually.  So we
275              update the slider manually here.
276           */
277           if (!modified_p)
278             gtk_range_slider_update (GTK_RANGE (wid));
279
280           instance->scrollbar_instance_changed = 0;
281         }
282
283       if (!managed)
284         {
285           gtk_widget_show (wid);
286           update_one_widget_scrollbar_pointer (w, wid);
287         }
288     }
289   else if (managed)
290     {
291       gtk_widget_hide (wid);
292     }
293 }
294
295 enum gtk_scrollbar_loop
296 {
297   GTK_FIND_SCROLLBAR_WINDOW_MIRROR,
298   GTK_SET_SCROLLBAR_POINTER,
299   GTK_WINDOW_IS_SCROLLBAR,
300   GTK_UPDATE_FRAME_SCROLLBARS
301 };
302
303 static struct window_mirror *
304 gtk_scrollbar_loop (enum gtk_scrollbar_loop type, Lisp_Object window,
305                     struct window_mirror *mir,
306                     GUI_ID id, GdkWindow *x_win)
307 {
308   struct window_mirror *retval = NULL;
309
310   while (mir)
311     {
312       struct scrollbar_instance *vinstance = mir->scrollbar_vertical_instance;
313       struct scrollbar_instance *hinstance = mir->scrollbar_horizontal_instance;
314       struct window *w = XWINDOW (window);
315
316       if (mir->vchild)
317         retval = gtk_scrollbar_loop (type, w->vchild, mir->vchild, id, x_win);
318       else if (mir->hchild)
319         retval = gtk_scrollbar_loop (type, w->hchild, mir->hchild, id, x_win);
320       if (retval)
321         return retval;
322
323       if (hinstance || vinstance)
324         {
325           switch (type)
326             {
327             case GTK_FIND_SCROLLBAR_WINDOW_MIRROR:
328               if ((vinstance && SCROLLBAR_GTK_ID (vinstance) == id) ||
329                   (hinstance && SCROLLBAR_GTK_ID (hinstance) == id))
330                 return mir;
331               break;
332             case GTK_UPDATE_FRAME_SCROLLBARS:
333               if (!mir->vchild && !mir->hchild)
334                 update_window_scrollbars (w, mir, 1, 0);
335               break;
336             case GTK_SET_SCROLLBAR_POINTER:
337               if (!mir->vchild && !mir->hchild)
338                 {
339                   GtkWidget *widget;
340
341                   widget = SCROLLBAR_GTK_WIDGET (hinstance);
342                   if (widget && GTK_WIDGET_MAPPED (widget))
343                     update_one_widget_scrollbar_pointer (w, widget);
344
345                   widget = SCROLLBAR_GTK_WIDGET (vinstance);
346                   if (widget && GTK_WIDGET_MAPPED (widget))
347                     update_one_widget_scrollbar_pointer (w, widget);
348                 }
349               break;
350             case GTK_WINDOW_IS_SCROLLBAR:
351               if (!mir->vchild && !mir->hchild)
352                 {
353                   GtkWidget *widget;
354
355                   widget = SCROLLBAR_GTK_WIDGET (hinstance);
356                   if (widget && GTK_WIDGET_MAPPED (widget) &&
357                       GET_GTK_WIDGET_WINDOW (widget) == x_win)
358                     return (struct window_mirror *) 1;
359
360                   widget = SCROLLBAR_GTK_WIDGET (vinstance);
361                   if (widget && GTK_WIDGET_MAPPED (widget) &&
362                       GET_GTK_WIDGET_WINDOW (widget) == x_win)
363                     return (struct window_mirror *) 1;
364                 }
365               break;
366             default:
367               ABORT ();
368             }
369         }
370
371       mir = mir->next;
372       window = w->next;
373     }
374
375   return NULL;
376 }
377
378 /* Used by callbacks. */
379 static struct window_mirror *
380 find_scrollbar_window_mirror (struct frame *f, GUI_ID id)
381 {
382   if (f->mirror_dirty)
383     update_frame_window_mirror (f);
384   return gtk_scrollbar_loop (GTK_FIND_SCROLLBAR_WINDOW_MIRROR, f->root_window,
385                              f->root_mirror, id, (GdkWindow *) NULL);
386 }
387
388 static gboolean
389 scrollbar_cb (GtkAdjustment *adj, gpointer user_data)
390 {
391   /* This function can GC */
392   int vertical = (int) user_data;
393   struct frame *f = gtk_object_get_data (GTK_OBJECT (adj), GTK_DATA_FRAME_IDENTIFIER);
394   struct scrollbar_instance *instance = gtk_object_get_data (GTK_OBJECT (adj), "xemacs::sb_instance");
395   GUI_ID id = (GUI_ID) gtk_object_get_data (GTK_OBJECT (adj), GTK_DATA_GUI_IDENTIFIER);
396   Lisp_Object win, frame;
397   struct window_mirror *mirror;
398   Lisp_Object event_type = Qnil;
399   Lisp_Object event_data = Qnil;
400
401   if (!f)
402     return(FALSE);
403
404   mirror = find_scrollbar_window_mirror (f, id);
405   if (!mirror)
406     return(FALSE);
407   
408   win = real_window (mirror, 1);
409
410   if (NILP (win))
411     return(FALSE);
412   instance = vertical ? mirror->scrollbar_vertical_instance : mirror->scrollbar_horizontal_instance;
413   frame = WINDOW_FRAME (XWINDOW (win));
414
415   inhibit_slider_size_change = 0;
416   switch (GTK_RANGE (SCROLLBAR_GTK_WIDGET (instance))->scroll_type)
417     {
418     case GTK_SCROLL_PAGE_BACKWARD:
419       event_type = vertical ? Qscrollbar_page_up : Qscrollbar_page_left;
420       event_data = Fcons (win, Qnil);
421       break;
422     case GTK_SCROLL_PAGE_FORWARD:
423       event_type = vertical ? Qscrollbar_page_down : Qscrollbar_page_right;
424       event_data = Fcons (win, Qnil);
425       break;
426     case GTK_SCROLL_STEP_FORWARD:
427       event_type = vertical ? Qscrollbar_line_down : Qscrollbar_char_right;
428       event_data = win;
429       break;
430     case GTK_SCROLL_STEP_BACKWARD:
431       event_type = vertical ? Qscrollbar_line_up : Qscrollbar_char_left;
432       event_data = win;
433       break;
434     case GTK_SCROLL_NONE:
435     case GTK_SCROLL_JUMP:
436       inhibit_slider_size_change = 1;
437       event_type = vertical ? Qscrollbar_vertical_drag : Qscrollbar_horizontal_drag;
438       event_data = Fcons (win, make_int ((int)adj->value));
439       break;
440     default:
441       ABORT();
442     }
443
444   signal_special_gtk_user_event (frame, event_type, event_data);
445
446   return (TRUE);
447 }
448
449 static void
450 gtk_scrollbar_pointer_changed_in_window (struct window *w)
451 {
452   Lisp_Object window;
453
454   XSETWINDOW (window, w);
455   gtk_scrollbar_loop (GTK_SET_SCROLLBAR_POINTER, window, find_window_mirror (w),
456                       0, (GdkWindow *) NULL);
457 }
458
459 /* #### BILL!!! This comment is not true for Gtk - should it be? */
460 /* Make sure that all scrollbars on frame are up-to-date.  Called
461    directly from gtk_set_frame_properties in frame-gtk.c*/
462 void
463 gtk_update_frame_scrollbars (struct frame *f)
464 {
465   /* Consider this code to be "in_display" so that we ABORT() if Fsignal()
466      gets called. */
467   in_display++;
468   gtk_scrollbar_loop (GTK_UPDATE_FRAME_SCROLLBARS, f->root_window, f->root_mirror,
469                       0, (GdkWindow *) NULL);
470   in_display--;
471   if (in_display < 0) ABORT ();
472 }
473
474 #ifdef MEMORY_USAGE_STATS
475 static int
476 gtk_compute_scrollbar_instance_usage (struct device *d,
477                                       struct scrollbar_instance *inst,
478                                       struct overhead_stats *ovstats)
479 {
480   int total = 0;
481
482   while (inst)
483     {
484       struct gtk_scrollbar_data *data =
485         (struct gtk_scrollbar_data *) inst->scrollbar_data;
486
487       total += malloced_storage_size (data, sizeof (*data), ovstats);
488       inst = inst->next;
489     }
490
491   return total;
492 }
493
494 #endif /* MEMORY_USAGE_STATS */
495
496
497 /************************************************************************/
498 /*                            initialization                            */
499 /************************************************************************/
500
501 void
502 console_type_create_scrollbar_gtk (void)
503 {
504   CONSOLE_HAS_METHOD (gtk, inhibit_scrollbar_slider_size_change);
505   CONSOLE_HAS_METHOD (gtk, free_scrollbar_instance);
506   CONSOLE_HAS_METHOD (gtk, release_scrollbar_instance);
507   CONSOLE_HAS_METHOD (gtk, create_scrollbar_instance);
508   CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_values);
509   CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_status);
510   CONSOLE_HAS_METHOD (gtk, scrollbar_pointer_changed_in_window);
511 #ifdef MEMORY_USAGE_STATS
512   CONSOLE_HAS_METHOD (gtk, compute_scrollbar_instance_usage);
513 #endif /* MEMORY_USAGE_STATS */
514 }
515
516 void
517 vars_of_scrollbar_gtk (void)
518 {
519   Fprovide (intern ("gtk-scrollbars"));
520 }