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

   1 /* scrollbar implementation -- X interface.
   2    Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
   3    Copyright (C) 1994 Amdahl 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
  26 #include <config.h>
  27 #include "lisp.h"
  28
  29 #include "console-x.h"
  30 #include "EmacsFrame.h"
  31 #include "glyphs-x.h"
  32 #include "gui-x.h"
  33 #include "scrollbar-x.h"
  34
  35 #include "frame.h"
  36 #include "window.h"
  37
  38 static void x_update_vertical_scrollbar_callback (Widget widget, LWLIB_ID id,
  39                                                   XtPointer client_data);
  40 static void x_update_horizontal_scrollbar_callback (Widget widget, LWLIB_ID id,
  41                                                     XtPointer client_data);
  42
  43 /* Used to prevent changing the size of the slider while drag
  44    scrolling, under Motif.  This is necessary because the Motif
  45    scrollbar is incredibly stupid about updating the slider and causes
  46    lots of flicker if it is done too often.  */
  47 static int inhibit_slider_size_change;
  48 int stupid_vertical_scrollbar_drag_hack;
  49
  50 /* Doesn't work with athena */
  51 #if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID)
  52 static int vertical_drag_in_progress;
  53 #endif
  54
  55 \f
  56 /* A device method. */
  57 static int
  58 x_inhibit_scrollbar_slider_size_change (void)
  59 {
  60   /* Doesn't work with Athena */
  61 #if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID)
  62   return inhibit_slider_size_change;
  63 #else
  64   return 0;
  65 #endif
  66 }
  67
  68 /* A device method. */
  69 static void
  70 x_free_scrollbar_instance (struct scrollbar_instance *instance)
  71 {
  72   if (SCROLLBAR_X_NAME (instance))
  73     xfree (SCROLLBAR_X_NAME (instance));
  74
  75   if (SCROLLBAR_X_WIDGET (instance))
  76     {
  77       if (XtIsManaged (SCROLLBAR_X_WIDGET (instance)))
  78         XtUnmanageChild (SCROLLBAR_X_WIDGET (instance));
  79
  80       lw_destroy_all_widgets (SCROLLBAR_X_ID (instance));
  81     }
  82
  83   if (instance->scrollbar_data)
  84     xfree (instance->scrollbar_data);
  85 }
  86
  87 /* A device method. */
  88 static void
  89 x_release_scrollbar_instance (struct scrollbar_instance *instance)
  90 {
  91   if (XtIsManaged (SCROLLBAR_X_WIDGET (instance)))
  92     XtUnmanageChild (SCROLLBAR_X_WIDGET (instance));
  93 }
  94
  95 /* A device method. */
  96 static void
  97 x_create_scrollbar_instance (struct frame *f, int vertical,
  98                              struct scrollbar_instance *instance)
  99 {
 100   char buffer[32];
 101
 102   /* initialize the X specific data section. */
 103   instance->scrollbar_data = xnew_and_zero (struct x_scrollbar_data);
 104
 105   SCROLLBAR_X_ID (instance) = new_lwlib_id ();
 106   sprintf (buffer, "scrollbar_%d", SCROLLBAR_X_ID (instance));
 107   SCROLLBAR_X_NAME (instance) = xstrdup (buffer);
 108 #if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID) || \
 109     defined (LWLIB_SCROLLBARS_ATHENA3D)
 110   SCROLLBAR_X_VDRAG_ORIG_VALUE (instance) = -1;
 111 #endif
 112
 113   if (vertical)
 114     {
 115       SCROLLBAR_X_WIDGET (instance) =
 116         lw_create_widget ("vertical-scrollbar", SCROLLBAR_X_NAME (instance),
 117                           SCROLLBAR_X_ID (instance),
 118                           NULL, FRAME_X_CONTAINER_WIDGET (f), 0,
 119                           x_update_vertical_scrollbar_callback, NULL, NULL);
 120     }
 121   else
 122     {
 123       SCROLLBAR_X_WIDGET (instance) =
 124         lw_create_widget ("horizontal-scrollbar", SCROLLBAR_X_NAME (instance),
 125                           SCROLLBAR_X_ID (instance),
 126                           NULL, FRAME_X_CONTAINER_WIDGET (f), 0,
 127                           x_update_horizontal_scrollbar_callback, NULL, NULL);
 128     }
 129 }
 130
 131 #define UPDATE_DATA_FIELD(field)                                \
 132   if (new_##field >= 0 &&                                       \
 133       SCROLLBAR_X_POS_DATA (inst).field != new_##field) {       \
 134     SCROLLBAR_X_POS_DATA (inst).field = new_##field;            \
 135     inst->scrollbar_instance_changed = 1;                       \
 136   }
 137
 138 /* A device method. */
 139 /* #### The -1 check is such a hack. */
 140 static void
 141 x_update_scrollbar_instance_values (struct window *w,
 142                                     struct scrollbar_instance *inst,
 143                                     int new_line_increment,
 144                                     int new_page_increment,
 145                                     int new_minimum, int new_maximum,
 146                                     int new_slider_size,
 147                                     int new_slider_position,
 148                                     int new_scrollbar_width,
 149                                     int new_scrollbar_height,
 150                                     int new_scrollbar_x, int new_scrollbar_y)
 151 {
 152   UPDATE_DATA_FIELD (line_increment);
 153   UPDATE_DATA_FIELD (page_increment);
 154   UPDATE_DATA_FIELD (minimum);
 155   UPDATE_DATA_FIELD (maximum);
 156   UPDATE_DATA_FIELD (slider_size);
 157   UPDATE_DATA_FIELD (slider_position);
 158   UPDATE_DATA_FIELD (scrollbar_width);
 159   UPDATE_DATA_FIELD (scrollbar_height);
 160   UPDATE_DATA_FIELD (scrollbar_x);
 161   UPDATE_DATA_FIELD (scrollbar_y);
 162
 163   /* This doesn't work with Athena, why? */
 164 #if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID)
 165   if (w && !vertical_drag_in_progress)
 166     {
 167       int new_vov = SCROLLBAR_X_POS_DATA (inst).slider_position;
 168       int new_vows = marker_position (w->start[CURRENT_DISP]);
 169
 170       if (SCROLLBAR_X_VDRAG_ORIG_VALUE (inst) != new_vov)
 171         {
 172           SCROLLBAR_X_VDRAG_ORIG_VALUE (inst) = new_vov;
 173           inst->scrollbar_instance_changed = 1;
 174         }
 175       if (SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (inst) != new_vows)
 176         {
 177           SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (inst) = new_vows;
 178           inst->scrollbar_instance_changed = 1;
 179         }
 180     }
 181 #endif
 182 }
 183
 184 /* Used by x_update_scrollbar_instance_status. */
 185 static void
 186 update_one_scrollbar_bs (struct frame *f, Widget sb_widget)
 187 {
 188   Boolean use_backing_store;
 189
 190   Xt_GET_VALUE (FRAME_X_TEXT_WIDGET (f), XtNuseBackingStore, &use_backing_store);
 191
 192   if (use_backing_store && sb_widget)
 193     {
 194       unsigned long mask = CWBackingStore;
 195       XSetWindowAttributes attrs;
 196
 197       attrs.backing_store = Always;
 198       XChangeWindowAttributes (XtDisplay (sb_widget),
 199                                XtWindow (sb_widget),
 200                                mask,
 201                                &attrs);
 202     }
 203 }
 204
 205 /* Create a widget value structure for passing down to lwlib so that
 206    it can update the scrollbar widgets.  Used by
 207    x_update_scrollbar_instance_status. */
 208 static widget_value *
 209 scrollbar_instance_to_widget_value (struct scrollbar_instance *instance)
 210 {
 211   widget_value *wv;
 212
 213   wv = xmalloc_widget_value ();
 214   /* #### maybe should add malloc_scrollbar_values to resource these? */
 215   wv->scrollbar_data = xnew (scrollbar_values);
 216
 217   wv->name = SCROLLBAR_X_NAME (instance);
 218   wv->name = xstrdup (wv->name);
 219   wv->value = 0;
 220   wv->key = 0;
 221   wv->enabled = instance->scrollbar_is_active;
 222   wv->selected = 0;
 223   wv->call_data = NULL;
 224
 225   *wv->scrollbar_data = SCROLLBAR_X_POS_DATA (instance);
 226
 227   wv->next = NULL;
 228
 229   return wv;
 230 }
 231
 232 /* Used by x_update_scrollbar_instance_status. */
 233 static void
 234 update_one_widget_scrollbar_pointer (struct window *w, Widget wid)
 235 {
 236   if (POINTER_IMAGE_INSTANCEP (w->scrollbar_pointer))
 237     {
 238       XDefineCursor (XtDisplay (wid), XtWindow (wid),
 239                      XIMAGE_INSTANCE_X_CURSOR (w->scrollbar_pointer));
 240       XSync (XtDisplay (wid), False);
 241     }
 242 }
 243
 244 /* A device method. */
 245 static void
 246 x_update_scrollbar_instance_status (struct window *w, int active, int size,
 247                                     struct scrollbar_instance *instance)
 248 {
 249   struct frame *f = XFRAME (w->frame);
 250   Boolean managed = XtIsManaged (SCROLLBAR_X_WIDGET (instance));
 251
 252   if (active && size)
 253     {
 254       widget_value *wv = scrollbar_instance_to_widget_value (instance);
 255
 256       if (instance->scrollbar_instance_changed)
 257         {
 258           lw_modify_all_widgets (SCROLLBAR_X_ID (instance), wv, 0);
 259           instance->scrollbar_instance_changed = 0;
 260         }
 261
 262       if (!managed)
 263         {
 264           XtManageChild (SCROLLBAR_X_WIDGET (instance));
 265           if (XtWindow (SCROLLBAR_X_WIDGET (instance)))
 266             {
 267               /* Raise this window so that it's visible on top of the
 268                  text window below it. */
 269               XRaiseWindow (XtDisplay (SCROLLBAR_X_WIDGET (instance)),
 270                             XtWindow (SCROLLBAR_X_WIDGET (instance)));
 271               update_one_widget_scrollbar_pointer
 272                 (w, SCROLLBAR_X_WIDGET (instance));
 273               if (!SCROLLBAR_X_BACKING_STORE_INITIALIZED (instance))
 274                 {
 275                   update_one_scrollbar_bs (f, SCROLLBAR_X_WIDGET (instance));
 276                   SCROLLBAR_X_BACKING_STORE_INITIALIZED (instance) = 1;
 277                 }
 278             }
 279         }
 280
 281       if (!wv->scrollbar_data) abort ();
 282       free_widget_value_tree (wv);
 283     }
 284   else if (managed)
 285     {
 286 #if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID)
 287       /* This isn't needed with Athena Scrollbars.  It might not be needed */
 288       /* with Motif scrollbars (it is apparently needed with Lesstif). */
 289       XtUngrabKeyboard (SCROLLBAR_X_WIDGET (instance), CurrentTime);
 290 #endif
 291       XtUnmanageChild (SCROLLBAR_X_WIDGET (instance));
 292     }
 293 }
 294
 295 enum x_scrollbar_loop
 296 {
 297   X_FIND_SCROLLBAR_WINDOW_MIRROR,
 298   X_SET_SCROLLBAR_POINTER,
 299   X_WINDOW_IS_SCROLLBAR,
 300   X_UPDATE_FRAME_SCROLLBARS
 301 };
 302
 303 static struct window_mirror *
 304 x_scrollbar_loop (enum x_scrollbar_loop type, Lisp_Object window,
 305                   struct window_mirror *mir,
 306                   LWLIB_ID id, Window 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 = x_scrollbar_loop (type, w->vchild, mir->vchild, id, x_win);
 318       else if (mir->hchild)
 319         retval = x_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 X_FIND_SCROLLBAR_WINDOW_MIRROR:
 328               if ((vinstance && SCROLLBAR_X_ID (vinstance) == id) ||
 329                   (hinstance && SCROLLBAR_X_ID (hinstance) == id))
 330                 return mir;
 331               break;
 332             case X_UPDATE_FRAME_SCROLLBARS:
 333               if (!mir->vchild && !mir->hchild)
 334                 update_window_scrollbars (w, mir, 1, 0);
 335               break;
 336             case X_SET_SCROLLBAR_POINTER:
 337               if (!mir->vchild && !mir->hchild)
 338                 {
 339                   Widget widget;
 340
 341                   widget = SCROLLBAR_X_WIDGET (hinstance);
 342                   if (widget && XtIsManaged (widget))
 343                     update_one_widget_scrollbar_pointer (w, widget);
 344
 345                   widget = SCROLLBAR_X_WIDGET (vinstance);
 346                   if (widget && XtIsManaged (widget))
 347                     update_one_widget_scrollbar_pointer (w, widget);
 348                 }
 349               break;
 350             case X_WINDOW_IS_SCROLLBAR:
 351               if (!mir->vchild && !mir->hchild)
 352                 {
 353                   Widget widget;
 354
 355                   widget = SCROLLBAR_X_WIDGET (hinstance);
 356                   if (widget && XtIsManaged (widget) &&
 357                       XtWindow (widget) == x_win)
 358                     return (struct window_mirror *) 1;
 359
 360                   widget = SCROLLBAR_X_WIDGET (vinstance);
 361                   if (widget && XtIsManaged (widget) &&
 362                       XtWindow (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, LWLIB_ID id)
 381 {
 382   if (f->mirror_dirty)
 383     update_frame_window_mirror (f);
 384   return x_scrollbar_loop (X_FIND_SCROLLBAR_WINDOW_MIRROR, f->root_window,
 385                            f->root_mirror, id, (Window) NULL);
 386 }
 387
 388 /*
 389  * This is the only callback provided for vertical scrollbars.  It
 390  * should be able to handle all of the scrollbar events in
 391  * scroll_action (see lwlib.h).  The client data will be of type
 392  * scroll_event (see lwlib.h). */
 393 static void
 394 x_update_vertical_scrollbar_callback (Widget widget, LWLIB_ID id,
 395                                       XtPointer client_data)
 396 {
 397   /* This function can GC */
 398   scroll_event *data = (scroll_event *) client_data;
 399   struct device *d = get_device_from_display (XtDisplay (widget));
 400   struct frame *f = x_any_window_to_frame (d, XtWindow (widget));
 401   Lisp_Object win, frame;
 402   struct scrollbar_instance *instance;
 403   struct window_mirror *mirror;
 404
 405   if (!f)
 406     return;
 407
 408   mirror = find_scrollbar_window_mirror (f, id);
 409   win = real_window (mirror, 1);
 410
 411   if (NILP (win))
 412     return;
 413   instance = mirror->scrollbar_vertical_instance;
 414   frame = WINDOW_FRAME (XWINDOW (win));
 415
 416   /* It seems that this is necessary whenever signal_special_Xt_user_event()
 417      is called.  #### Why??? */
 418   DEVICE_X_MOUSE_TIMESTAMP (d) = DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d);
 419
 420   switch (data->action)
 421     {
 422     case SCROLLBAR_LINE_UP:
 423       signal_special_Xt_user_event (frame, Qscrollbar_line_up, win);
 424       break;
 425
 426     case SCROLLBAR_LINE_DOWN:
 427       signal_special_Xt_user_event (frame, Qscrollbar_line_down, win);
 428       break;
 429
 430       /* The Athena scrollbar paging behavior is that of xterms.
 431          Depending on where you click the size of the page varies.
 432          Motif always does a standard Emacs page. */
 433     case SCROLLBAR_PAGE_UP:
 434 #if !defined (LWLIB_SCROLLBARS_MOTIF) && !defined (LWLIB_SCROLLBARS_LUCID) && \
 435     !defined (LWLIB_SCROLLBARS_ATHENA3D)
 436       {
 437         double tmp = ((double) data->slider_value /
 438                       (double) SCROLLBAR_X_POS_DATA(instance).scrollbar_height);
 439         double line = tmp *
 440           (double) window_displayed_height (XWINDOW (win));
 441
 442         if (line > -1.0)
 443           line = -1.0;
 444         signal_special_Xt_user_event (frame, Qscrollbar_page_up,
 445                                       Fcons (win, make_int ((int) line)));
 446       }
 447 #else
 448       signal_special_Xt_user_event (frame, Qscrollbar_page_up,
 449                                     Fcons (win, Qnil));
 450 #endif
 451       break;
 452
 453     case SCROLLBAR_PAGE_DOWN:
 454 #if !defined (LWLIB_SCROLLBARS_MOTIF) && !defined (LWLIB_SCROLLBARS_LUCID) && \
 455     !defined (LWLIB_SCROLLBARS_ATHENA3D)
 456       {
 457         double tmp = ((double) data->slider_value /
 458                       (double) SCROLLBAR_X_POS_DATA(instance).scrollbar_height);
 459         double line = tmp *
 460           (double) window_displayed_height (XWINDOW (win));
 461
 462         if (SCROLLBAR_X_POS_DATA(instance).maximum >
 463             (SCROLLBAR_X_POS_DATA(instance).slider_size + SCROLLBAR_X_POS_DATA(instance).slider_position))
 464           {
 465             if (line < 1.0)
 466               line = 1.0;
 467             signal_special_Xt_user_event (frame, Qscrollbar_page_down,
 468                                           Fcons (win,
 469                                                  make_int ((int) line)));
 470           }
 471       }
 472 #else
 473       signal_special_Xt_user_event (frame, Qscrollbar_page_down,
 474                                     Fcons (win, Qnil));
 475 #endif
 476       break;
 477
 478     case SCROLLBAR_TOP:
 479       signal_special_Xt_user_event (frame, Qscrollbar_to_top, win);
 480       break;
 481
 482     case SCROLLBAR_BOTTOM:
 483       signal_special_Xt_user_event (frame, Qscrollbar_to_bottom, win);
 484       break;
 485
 486
 487     case SCROLLBAR_CHANGE:
 488       inhibit_slider_size_change = 0;
 489 #if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID)
 490       vertical_drag_in_progress = 0;
 491       SCROLLBAR_X_VDRAG_ORIG_VALUE (instance) = data->slider_value;
 492       SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance) =
 493         XINT (Fwindow_start (win));
 494 #else
 495       stupid_vertical_scrollbar_drag_hack = 0;
 496 #endif
 497       break;
 498
 499     case SCROLLBAR_DRAG:
 500       {
 501         int value;
 502
 503         inhibit_slider_size_change = 1;
 504
 505 #if defined (LWLIB_SCROLLBARS_MOTIF) || defined (LWLIB_SCROLLBARS_LUCID)
 506         /* Doing drags with Motif-like scrollbars is a mess, since we
 507            want to avoid having the window position jump when you
 508            first grab the scrollbar, but we also want to ensure that
 509            you can scroll all the way to the top or bottom of the
 510            buffer.  This can all be replaced with something sane when
 511            we get line-based scrolling. */
 512
 513         vertical_drag_in_progress = 1;
 514
 515         if (SCROLLBAR_X_VDRAG_ORIG_VALUE (instance) < 0)
 516           {
 517             SCROLLBAR_X_VDRAG_ORIG_VALUE (instance) = data->slider_value;
 518             SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance) =
 519               XINT (Fwindow_start (win));
 520           }
 521
 522         /* Could replace this piecewise linear scrolling with a
 523            quadratic through the three points, but I'm not sure that
 524            would feel any nicer in practice. */
 525         if (data->slider_value < SCROLLBAR_X_VDRAG_ORIG_VALUE (instance))
 526           {
 527             /* We've dragged up; slide linearly from original position to
 528                window-start=data.minimum, slider-value=data.minimum. */
 529
 530             if (SCROLLBAR_X_VDRAG_ORIG_VALUE (instance)
 531                 <= SCROLLBAR_X_POS_DATA (instance).minimum)
 532               {
 533                 /* shouldn't get here, but just in case */
 534                 value = SCROLLBAR_X_POS_DATA (instance).minimum;
 535               }
 536             else
 537               {
 538                 value = (int)
 539                   (SCROLLBAR_X_POS_DATA (instance).minimum
 540                    + (((double)
 541                        (SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance)
 542                         - SCROLLBAR_X_POS_DATA (instance).minimum)
 543                        * (data->slider_value -
 544                           SCROLLBAR_X_POS_DATA (instance).minimum))
 545                       / (SCROLLBAR_X_VDRAG_ORIG_VALUE (instance)
 546                          - SCROLLBAR_X_POS_DATA (instance).minimum)));
 547               }
 548           }
 549         else
 550           {
 551             /* We've dragged down; slide linearly from original position to
 552                window-start=data.maximum, slider-value=data.maximum. */
 553
 554             if (SCROLLBAR_X_VDRAG_ORIG_VALUE (instance)
 555                 >= (SCROLLBAR_X_POS_DATA (instance).maximum -
 556                     SCROLLBAR_X_POS_DATA (instance).slider_size))
 557               {
 558                 /* avoid divide by zero */
 559                 value = SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance);
 560               }
 561             else
 562               {
 563                 value = (int)
 564                   (SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance)
 565                    + (((double)
 566                        (SCROLLBAR_X_POS_DATA (instance).maximum
 567                         - SCROLLBAR_X_VDRAG_ORIG_WINDOW_START (instance))
 568                        * (data->slider_value
 569                           - SCROLLBAR_X_VDRAG_ORIG_VALUE (instance)))
 570                       / (SCROLLBAR_X_POS_DATA (instance).maximum
 571                          - SCROLLBAR_X_POS_DATA (instance).slider_size
 572                          - SCROLLBAR_X_VDRAG_ORIG_VALUE (instance))));
 573               }
 574           }
 575 #else
 576         stupid_vertical_scrollbar_drag_hack = 0;
 577         value = data->slider_value;
 578 #endif
 579
 580         if (value >= SCROLLBAR_X_POS_DATA (instance).maximum)
 581           value = SCROLLBAR_X_POS_DATA (instance).maximum - 1;
 582         if (value < SCROLLBAR_X_POS_DATA (instance).minimum)
 583           value = SCROLLBAR_X_POS_DATA (instance).minimum;
 584
 585         signal_special_Xt_user_event (frame, Qscrollbar_vertical_drag,
 586                                       Fcons (win, make_int (value)));
 587       }
 588       break;
 589
 590     }
 591 }
 592
 593 /*
 594  * This is the only callback provided for horizontal scrollbars.  It
 595  * should be able to handle all of the scrollbar events in
 596  * scroll_action (see lwlib.h).  The client data will be of type
 597  * scroll_event (see lwlib.h). */
 598 static void
 599 x_update_horizontal_scrollbar_callback (Widget widget, LWLIB_ID id,
 600                                         XtPointer client_data)
 601 {
 602   scroll_event *data = (scroll_event *) client_data;
 603   struct device *d = get_device_from_display (XtDisplay (widget));
 604   struct frame *f = x_any_window_to_frame (d, XtWindow (widget));
 605   Lisp_Object win, frame;
 606   struct window_mirror *mirror;
 607
 608   if (!f)
 609     return;
 610
 611   mirror = find_scrollbar_window_mirror (f, id);
 612   win = real_window (mirror, 1);
 613
 614   if (NILP (win))
 615     return;
 616   frame = WINDOW_FRAME (XWINDOW (win));
 617
 618   /* It seems that this is necessary whenever signal_special_Xt_user_event()
 619      is called.  #### Why??? */
 620   DEVICE_X_MOUSE_TIMESTAMP (d) = DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d);
 621
 622   switch (data->action)
 623     {
 624     case SCROLLBAR_LINE_UP:
 625       signal_special_Xt_user_event (frame, Qscrollbar_char_left, win);
 626       break;
 627     case SCROLLBAR_LINE_DOWN:
 628       signal_special_Xt_user_event (frame, Qscrollbar_char_right, win);
 629       break;
 630     case SCROLLBAR_PAGE_UP:
 631       signal_special_Xt_user_event (frame, Qscrollbar_page_left, win);
 632       break;
 633     case SCROLLBAR_PAGE_DOWN:
 634       signal_special_Xt_user_event (frame, Qscrollbar_page_right, win);
 635       break;
 636     case SCROLLBAR_TOP:
 637       signal_special_Xt_user_event (frame, Qscrollbar_to_left, win);
 638       break;
 639     case SCROLLBAR_BOTTOM:
 640       signal_special_Xt_user_event (frame, Qscrollbar_to_right, win);
 641       break;
 642     case SCROLLBAR_CHANGE:
 643       inhibit_slider_size_change = 0;
 644       break;
 645     case SCROLLBAR_DRAG:
 646       inhibit_slider_size_change = 1;
 647       /* #### Fix the damn toolkit code so they all work the same way.
 648          Lucid is the one mostly wrong.*/
 649 #if defined (LWLIB_SCROLLBARS_LUCID) || defined (LWLIB_SCROLLBARS_ATHENA3D)
 650       signal_special_Xt_user_event (frame, Qscrollbar_horizontal_drag,
 651                                     (Fcons
 652                                      (win, make_int (data->slider_value))));
 653 #else
 654       signal_special_Xt_user_event (frame, Qscrollbar_horizontal_drag,
 655                                     (Fcons
 656                                      (win,
 657                                       make_int (data->slider_value - 1))));
 658 #endif
 659       break;
 660     default:
 661       break;
 662     }
 663 }
 664
 665 static void
 666 x_scrollbar_pointer_changed_in_window (struct window *w)
 667 {
 668   Lisp_Object window;
 669
 670   XSETWINDOW (window, w);
 671   x_scrollbar_loop (X_SET_SCROLLBAR_POINTER, window, find_window_mirror (w),
 672                     0, (Window) NULL);
 673 }
 674
 675 /* Make sure that all scrollbars on frame are up-to-date.  Called
 676    directly from x_set_frame_properties in frame-x.c*/
 677 void
 678 x_update_frame_scrollbars (struct frame *f)
 679 {
 680   /* Consider this code to be "in_display" so that we abort() if Fsignal()
 681      gets called. */
 682   in_display++;
 683   x_scrollbar_loop (X_UPDATE_FRAME_SCROLLBARS, f->root_window, f->root_mirror,
 684                     0, (Window) NULL);
 685   in_display--;
 686   if (in_display < 0) abort ();
 687 }
 688
 689 #ifdef MEMORY_USAGE_STATS
 690
 691 static int
 692 x_compute_scrollbar_instance_usage (struct device *d,
 693                                     struct scrollbar_instance *inst,
 694                                     struct overhead_stats *ovstats)
 695 {
 696   int total = 0;
 697
 698   while (inst)
 699     {
 700       struct x_scrollbar_data *data =
 701         (struct x_scrollbar_data *) inst->scrollbar_data;
 702
 703       total += malloced_storage_size (data, sizeof (*data), ovstats);
 704       total += malloced_storage_size (data->name, 1 + strlen (data->name),
 705                                       ovstats);
 706       inst = inst->next;
 707     }
 708
 709   return total;
 710 }
 711
 712 #endif /* MEMORY_USAGE_STATS */
 713
 714
 715 /************************************************************************/
 716 /*                            initialization                            */
 717 /************************************************************************/
 718
 719 void
 720 console_type_create_scrollbar_x (void)
 721 {
 722   CONSOLE_HAS_METHOD (x, inhibit_scrollbar_slider_size_change);
 723   CONSOLE_HAS_METHOD (x, free_scrollbar_instance);
 724   CONSOLE_HAS_METHOD (x, release_scrollbar_instance);
 725   CONSOLE_HAS_METHOD (x, create_scrollbar_instance);
 726   CONSOLE_HAS_METHOD (x, update_scrollbar_instance_values);
 727   CONSOLE_HAS_METHOD (x, update_scrollbar_instance_status);
 728   CONSOLE_HAS_METHOD (x, scrollbar_pointer_changed_in_window);
 729 #ifdef MEMORY_USAGE_STATS
 730   CONSOLE_HAS_METHOD (x, compute_scrollbar_instance_usage);
 731 #endif /* MEMORY_USAGE_STATS */
 732 }
 733
 734 void
 735 reinit_vars_of_scrollbar_x (void)
 736 {
 737   stupid_vertical_scrollbar_drag_hack = 1;
 738 }
 739
 740 void
 741 vars_of_scrollbar_x (void)
 742 {
 743   reinit_vars_of_scrollbar_x ();
 744
 745 #if defined (LWLIB_SCROLLBARS_LUCID)
 746   Fprovide (intern ("lucid-scrollbars"));
 747 #elif defined (LWLIB_SCROLLBARS_MOTIF)
 748   Fprovide (intern ("motif-scrollbars"));
 749 #elif defined (LWLIB_SCROLLBARS_ATHENA)
 750   Fprovide (intern ("athena-scrollbars"));
 751 #endif
 752 }