git.chise.org Git - chise/xemacs-chise.git.1/blob - src/scrollbar-gtk.c

   1 /* scrollbar implementation -- X 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), "xemacs::gui_id", (void *) SCROLLBAR_GTK_ID (instance));
 102   gtk_object_set_data (GTK_OBJECT (adj), "xemacs::frame", f);
 103   gtk_object_set_data (GTK_OBJECT (adj), "xemacs::sb_instance", instance);
 104
 105   sb = GTK_SCROLLBAR (vertical ? gtk_vscrollbar_new (adj) : gtk_hscrollbar_new (adj));
 106   /* With gtk version > 1.2.8 the gtk code does not call
 107      gtk_widget_request_size() on the newly created scrollbars
 108      anymore (catering to theme engines).
 109      #### Maybe it is better to postpone this call to just before
 110      gtk_widget_show() is called on the scrollbar? */
 111 #if GTK_MAJOR_VERSION == 1 && GTK_MINOR_VERSION == 2 && GTK_BINARY_AGE > 8
 112   gtk_widget_size_request(GTK_WIDGET(sb), &(GTK_WIDGET(sb)->requisition));
 113 #endif
 114   SCROLLBAR_GTK_WIDGET (instance) = GTK_WIDGET (sb);
 115
 116   gtk_signal_connect (GTK_OBJECT (adj),"value-changed",
 117                       GTK_SIGNAL_FUNC (scrollbar_cb), (gpointer) vertical);
 118
 119   gtk_signal_connect (GTK_OBJECT (sb), "button-press-event",
 120                       GTK_SIGNAL_FUNC (scrollbar_drag_hack_cb), (gpointer) 1);
 121   gtk_signal_connect (GTK_OBJECT (sb), "button-release-event",
 122                       GTK_SIGNAL_FUNC (scrollbar_drag_hack_cb), (gpointer) 0);
 123
 124   gtk_fixed_put (GTK_FIXED (FRAME_GTK_TEXT_WIDGET (f)), SCROLLBAR_GTK_WIDGET (instance), 0, 0);
 125   gtk_widget_hide (SCROLLBAR_GTK_WIDGET (instance));
 126 }
 127
 128 #define UPDATE_DATA_FIELD(field)                                \
 129   if (new_##field >= 0 &&                                       \
 130       SCROLLBAR_GTK_POS_DATA (inst).field != new_##field) {     \
 131     SCROLLBAR_GTK_POS_DATA (inst).field = new_##field;          \
 132     inst->scrollbar_instance_changed = 1;                       \
 133   }
 134
 135 /* A device method. */
 136 /* #### The -1 check is such a hack. */
 137 static void
 138 gtk_update_scrollbar_instance_values (struct window *w,
 139                                       struct scrollbar_instance *inst,
 140                                       int new_line_increment,
 141                                       int new_page_increment,
 142                                       int new_minimum, int new_maximum,
 143                                       int new_slider_size,
 144                                       int new_slider_position,
 145                                       int new_scrollbar_width,
 146                                       int new_scrollbar_height,
 147                                       int new_scrollbar_x, int new_scrollbar_y)
 148 {
 149   UPDATE_DATA_FIELD (line_increment);
 150   UPDATE_DATA_FIELD (page_increment);
 151   UPDATE_DATA_FIELD (minimum);
 152   UPDATE_DATA_FIELD (maximum);
 153   UPDATE_DATA_FIELD (slider_size);
 154   UPDATE_DATA_FIELD (slider_position);
 155   UPDATE_DATA_FIELD (scrollbar_width);
 156   UPDATE_DATA_FIELD (scrollbar_height);
 157   UPDATE_DATA_FIELD (scrollbar_x);
 158   UPDATE_DATA_FIELD (scrollbar_y);
 159
 160   if (w && !vertical_drag_in_progress)
 161     {
 162       int new_vov = SCROLLBAR_GTK_POS_DATA (inst).slider_position;
 163       int new_vows = marker_position (w->start[CURRENT_DISP]);
 164
 165       if (SCROLLBAR_GTK_VDRAG_ORIG_VALUE (inst) != new_vov)
 166         {
 167           SCROLLBAR_GTK_VDRAG_ORIG_VALUE (inst) = new_vov;
 168           inst->scrollbar_instance_changed = 1;
 169         }
 170       if (SCROLLBAR_GTK_VDRAG_ORIG_WINDOW_START (inst) != new_vows)
 171         {
 172           SCROLLBAR_GTK_VDRAG_ORIG_WINDOW_START (inst) = new_vows;
 173           inst->scrollbar_instance_changed = 1;
 174         }
 175     }
 176 }
 177
 178 /* Used by gtk_update_scrollbar_instance_status. */
 179 static void
 180 update_one_widget_scrollbar_pointer (struct window *w, GtkWidget *wid)
 181 {
 182   if (!wid->window)
 183     gtk_widget_realize (wid);
 184
 185   if (POINTER_IMAGE_INSTANCEP (w->scrollbar_pointer))
 186     {
 187       gdk_window_set_cursor (GET_GTK_WIDGET_WINDOW (wid),
 188                              XIMAGE_INSTANCE_GTK_CURSOR (w->scrollbar_pointer));
 189       gdk_flush ();
 190     }
 191 }
 192
 193 /* A device method. */
 194 static void
 195 gtk_update_scrollbar_instance_status (struct window *w, int active, int size,
 196                                       struct scrollbar_instance *instance)
 197 {
 198   struct frame *f = XFRAME (w->frame);
 199   GtkWidget *wid = SCROLLBAR_GTK_WIDGET (instance);
 200   gboolean managed = GTK_WIDGET_MAPPED (wid);
 201
 202   if (active && size)
 203     {
 204       if (instance->scrollbar_instance_changed)
 205         {
 206           /* Need to set the height, width, and position of the widget */
 207           GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (wid));
 208           scrollbar_values *pos_data = & SCROLLBAR_GTK_POS_DATA (instance);
 209           int modified_p = 0;
 210
 211           /* We do not want to update the size all the time if we can
 212              help it.  This cuts down on annoying flicker.
 213           */
 214           if ((wid->allocation.width != pos_data->scrollbar_width) ||
 215               (wid->allocation.height != pos_data->scrollbar_height))
 216             {
 217               gtk_widget_set_usize (wid,
 218                                     pos_data->scrollbar_width,
 219                                     pos_data->scrollbar_height);
 220               modified_p = 1;
 221             }
 222
 223           /* Ditto for the x/y position. */
 224           if ((wid->allocation.x != pos_data->scrollbar_x) ||
 225               (wid->allocation.y != pos_data->scrollbar_y))
 226             {
 227               gtk_fixed_move (GTK_FIXED (FRAME_GTK_TEXT_WIDGET (f)),
 228                               wid,
 229                               pos_data->scrollbar_x,
 230                               pos_data->scrollbar_y);
 231               modified_p = 1;
 232             }
 233
 234           adj->lower = pos_data->minimum;
 235           adj->upper = pos_data->maximum;
 236           adj->page_increment = pos_data->slider_size + 1;
 237           adj->step_increment = w->max_line_len - 1;
 238           adj->page_size = pos_data->slider_size + 1;
 239           adj->value = pos_data->slider_position;
 240
 241           /* But, if we didn't resize or move the scrollbar, the
 242              widget will not get redrawn correctly when the user
 243              scrolls around in the XEmacs frame manually.  So we
 244              update the slider manually here.
 245           */
 246           if (!modified_p)
 247             gtk_range_slider_update (GTK_RANGE (wid));
 248
 249           instance->scrollbar_instance_changed = 0;
 250         }
 251
 252       if (!managed)
 253         {
 254           gtk_widget_show (wid);
 255           update_one_widget_scrollbar_pointer (w, wid);
 256         }
 257     }
 258   else if (managed)
 259     {
 260       gtk_widget_hide (wid);
 261     }
 262 }
 263
 264 enum gtk_scrollbar_loop
 265 {
 266   GTK_FIND_SCROLLBAR_WINDOW_MIRROR,
 267   GTK_SET_SCROLLBAR_POINTER,
 268   GTK_WINDOW_IS_SCROLLBAR,
 269   GTK_UPDATE_FRAME_SCROLLBARS
 270 };
 271
 272 static struct window_mirror *
 273 gtk_scrollbar_loop (enum gtk_scrollbar_loop type, Lisp_Object window,
 274                     struct window_mirror *mir,
 275                     GUI_ID id, GdkWindow *x_win)
 276 {
 277   struct window_mirror *retval = NULL;
 278
 279   while (mir)
 280     {
 281       struct scrollbar_instance *vinstance = mir->scrollbar_vertical_instance;
 282       struct scrollbar_instance *hinstance = mir->scrollbar_horizontal_instance;
 283       struct window *w = XWINDOW (window);
 284
 285       if (mir->vchild)
 286         retval = gtk_scrollbar_loop (type, w->vchild, mir->vchild, id, x_win);
 287       else if (mir->hchild)
 288         retval = gtk_scrollbar_loop (type, w->hchild, mir->hchild, id, x_win);
 289       if (retval)
 290         return retval;
 291
 292       if (hinstance || vinstance)
 293         {
 294           switch (type)
 295             {
 296             case GTK_FIND_SCROLLBAR_WINDOW_MIRROR:
 297               if ((vinstance && SCROLLBAR_GTK_ID (vinstance) == id) ||
 298                   (hinstance && SCROLLBAR_GTK_ID (hinstance) == id))
 299                 return mir;
 300               break;
 301             case GTK_UPDATE_FRAME_SCROLLBARS:
 302               if (!mir->vchild && !mir->hchild)
 303                 update_window_scrollbars (w, mir, 1, 0);
 304               break;
 305             case GTK_SET_SCROLLBAR_POINTER:
 306               if (!mir->vchild && !mir->hchild)
 307                 {
 308                   GtkWidget *widget;
 309
 310                   widget = SCROLLBAR_GTK_WIDGET (hinstance);
 311                   if (widget && GTK_WIDGET_MAPPED (widget))
 312                     update_one_widget_scrollbar_pointer (w, widget);
 313
 314                   widget = SCROLLBAR_GTK_WIDGET (vinstance);
 315                   if (widget && GTK_WIDGET_MAPPED (widget))
 316                     update_one_widget_scrollbar_pointer (w, widget);
 317                 }
 318               break;
 319             case GTK_WINDOW_IS_SCROLLBAR:
 320               if (!mir->vchild && !mir->hchild)
 321                 {
 322                   GtkWidget *widget;
 323
 324                   widget = SCROLLBAR_GTK_WIDGET (hinstance);
 325                   if (widget && GTK_WIDGET_MAPPED (widget) &&
 326                       GET_GTK_WIDGET_WINDOW (widget) == x_win)
 327                     return (struct window_mirror *) 1;
 328
 329                   widget = SCROLLBAR_GTK_WIDGET (vinstance);
 330                   if (widget && GTK_WIDGET_MAPPED (widget) &&
 331                       GET_GTK_WIDGET_WINDOW (widget) == x_win)
 332                     return (struct window_mirror *) 1;
 333                 }
 334               break;
 335             default:
 336               abort ();
 337             }
 338         }
 339
 340       mir = mir->next;
 341       window = w->next;
 342     }
 343
 344   return NULL;
 345 }
 346
 347 /* Used by callbacks. */
 348 static struct window_mirror *
 349 find_scrollbar_window_mirror (struct frame *f, GUI_ID id)
 350 {
 351   if (f->mirror_dirty)
 352     update_frame_window_mirror (f);
 353   return gtk_scrollbar_loop (GTK_FIND_SCROLLBAR_WINDOW_MIRROR, f->root_window,
 354                              f->root_mirror, id, (GdkWindow *) NULL);
 355 }
 356
 357 static gboolean
 358 scrollbar_cb (GtkAdjustment *adj, gpointer user_data)
 359 {
 360   /* This function can GC */
 361   int vertical = (int) user_data;
 362   struct frame *f = gtk_object_get_data (GTK_OBJECT (adj), "xemacs::frame");
 363   struct scrollbar_instance *instance = gtk_object_get_data (GTK_OBJECT (adj), "xemacs::sb_instance");
 364   GUI_ID id = (GUI_ID) gtk_object_get_data (GTK_OBJECT (adj), "xemacs::gui_id");
 365   Lisp_Object win, frame;
 366   struct window_mirror *mirror;
 367   Lisp_Object event_type = Qnil;
 368   Lisp_Object event_data = Qnil;
 369
 370   if (!f)
 371     return(FALSE);
 372
 373   mirror = find_scrollbar_window_mirror (f, id);
 374   if (!mirror)
 375     return(FALSE);
 376
 377   win = real_window (mirror, 1);
 378
 379   if (NILP (win))
 380     return(FALSE);
 381   instance = vertical ? mirror->scrollbar_vertical_instance : mirror->scrollbar_horizontal_instance;
 382   frame = WINDOW_FRAME (XWINDOW (win));
 383
 384   inhibit_slider_size_change = 0;
 385   switch (GTK_RANGE (SCROLLBAR_GTK_WIDGET (instance))->scroll_type)
 386     {
 387     case GTK_SCROLL_PAGE_BACKWARD:
 388       event_type = vertical ? Qscrollbar_page_up : Qscrollbar_page_left;
 389       event_data = Fcons (win, Qnil);
 390       break;
 391     case GTK_SCROLL_PAGE_FORWARD:
 392       event_type = vertical ? Qscrollbar_page_down : Qscrollbar_page_right;
 393       event_data = Fcons (win, Qnil);
 394       break;
 395     case GTK_SCROLL_STEP_FORWARD:
 396       event_type = vertical ? Qscrollbar_line_down : Qscrollbar_char_right;
 397       event_data = win;
 398       break;
 399     case GTK_SCROLL_STEP_BACKWARD:
 400       event_type = vertical ? Qscrollbar_line_up : Qscrollbar_char_left;
 401       event_data = win;
 402       break;
 403     case GTK_SCROLL_NONE:
 404     case GTK_SCROLL_JUMP:
 405       inhibit_slider_size_change = 1;
 406       event_type = vertical ? Qscrollbar_vertical_drag : Qscrollbar_horizontal_drag;
 407       event_data = Fcons (win, make_int ((int)adj->value));
 408       break;
 409     default:
 410       abort();
 411     }
 412
 413   signal_special_gtk_user_event (frame, event_type, event_data);
 414
 415   return (TRUE);
 416 }
 417
 418 static void
 419 gtk_scrollbar_pointer_changed_in_window (struct window *w)
 420 {
 421   Lisp_Object window;
 422
 423   XSETWINDOW (window, w);
 424   gtk_scrollbar_loop (GTK_SET_SCROLLBAR_POINTER, window, find_window_mirror (w),
 425                       0, (GdkWindow *) NULL);
 426 }
 427
 428 /* #### BILL!!! This comment is not true for Gtk - should it be? */
 429 /* Make sure that all scrollbars on frame are up-to-date.  Called
 430    directly from gtk_set_frame_properties in frame-gtk.c*/
 431 void
 432 gtk_update_frame_scrollbars (struct frame *f)
 433 {
 434   /* Consider this code to be "in_display" so that we abort() if Fsignal()
 435      gets called. */
 436   in_display++;
 437   gtk_scrollbar_loop (GTK_UPDATE_FRAME_SCROLLBARS, f->root_window, f->root_mirror,
 438                       0, (GdkWindow *) NULL);
 439   in_display--;
 440   if (in_display < 0) abort ();
 441 }
 442
 443 #ifdef MEMORY_USAGE_STATS
 444 static int
 445 gtk_compute_scrollbar_instance_usage (struct device *d,
 446                                       struct scrollbar_instance *inst,
 447                                       struct overhead_stats *ovstats)
 448 {
 449   int total = 0;
 450
 451   while (inst)
 452     {
 453       struct gtk_scrollbar_data *data =
 454         (struct gtk_scrollbar_data *) inst->scrollbar_data;
 455
 456       total += malloced_storage_size (data, sizeof (*data), ovstats);
 457       inst = inst->next;
 458     }
 459
 460   return total;
 461 }
 462
 463 #endif /* MEMORY_USAGE_STATS */
 464
 465
 466 /************************************************************************/
 467 /*                            initialization                            */
 468 /************************************************************************/
 469
 470 void
 471 console_type_create_scrollbar_gtk (void)
 472 {
 473   CONSOLE_HAS_METHOD (gtk, inhibit_scrollbar_slider_size_change);
 474   CONSOLE_HAS_METHOD (gtk, free_scrollbar_instance);
 475   CONSOLE_HAS_METHOD (gtk, release_scrollbar_instance);
 476   CONSOLE_HAS_METHOD (gtk, create_scrollbar_instance);
 477   CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_values);
 478   CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_status);
 479   CONSOLE_HAS_METHOD (gtk, scrollbar_pointer_changed_in_window);
 480 #ifdef MEMORY_USAGE_STATS
 481   CONSOLE_HAS_METHOD (gtk, compute_scrollbar_instance_usage);
 482 #endif /* MEMORY_USAGE_STATS */
 483 }
 484
 485 void
 486 vars_of_scrollbar_gtk (void)
 487 {
 488   Fprovide (intern ("gtk-scrollbars"));
 489 }