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