The actions supported by the Scrollbar widget are:

StartScroll()	This must be the first action to begin a new movement.
NotifyScroll()	This executes the scrollProc callbacks and passes the position of the pointer.
EndScroll()	This must be the last action after a movement is complete.
MoveThumb()	Repositions the Scrollbar's thumb to the current pointer location. It executes the valueChangedProc callbacks with reason XawSB_VALUE_CHANGED and the thumbProc and jumpProc callbacks for backward compatibility with the Athena.
NotifyThumb()	This is the same as MoveThumb(). It is used just for backward compatibility with the Athena.
PageDownOrRight(value)	If the value is Right and the Scrollbar widget is horizontal or if the value is Down and the Scrollbar widget is vertical, then it increases topOfThumb by one pages.
PageUpOrLeft(value)	If the value is Left and the Scrollbar widget is horizontal or if the value is Up and the Scrollbar widget is vertical, then it reduces topOfThumb by one pages.

The default bindings for Scrollbar are:

     <Btn1Down>:     StartScroll()                 
     <Btn2Down>:     StartScroll() NotifyThumb()   
     <Btn3Down>:     StartScroll()                 
     <Btn1Motion>:   Moved()                       
     <Btn2Motion>:   NotifyThumb()                 
     <BtnUp>:        NotifyScroll() EndScroll()    
     Ctrl<Key>Right: PageDownOrRight(Right)      
     Ctrl<Key>Left:  PageUpOrLeft(Left)          
     Ctrl<Key>Down:  PageDownOrRight(Down)       
     Ctrl<Key>Up:    PageUpOrLeft(Up)            
     Meta<Key>Right: ToBottom(Right)             
     Meta<Key>Left:  ToTop(Left)                 
     Meta<Key>Down:  ToBottom(Down)              
     Meta<Key>Up:    ToTop(Up)                   
     <Key>Right:     IncrementDownOrRight(Right) 
     <Key>Left:      IncrementUpOrLeft(Left)     
     <Key>Down:      IncrementDownOrRight(Down)  
     <Key>Up:        IncrementUpOrLeft(Up)

Scrollbar Callbacks

There are two callback lists provided by the Scrollbar widget. The procedural interface for these functions is described here.

The calling interface to the scrollProc callback procedure is:

void ScrollProc(scrollbar, client_data, position)
	Widget scrollbar;
	XtPointer client_data;
	XtPointer position;        /* int */

The scrollProc callback is used for incremental scrolling and is called by the NotifyScroll action. The position argument is a signed quantity and should be cast to an int when used. Using the default button bindings, button 1 returns a positive value, and button 3 returns a negative value. In both cases, the magnitude of the value is the distance of the pointer in pixels from the top (or left) of the Scrollbar. The value will never be greater than the length of the Scrollbar.

The calling interface to the jumpProc callback procedure is:

void JumpProc(scrollbar, client_data, percent)
	Widget scrollbar;
	XtPointer client_data;
	XtPointer percent_ptr; /* float* */

The jumpProc callback is used to implement smooth scrolling and is called by the NotifyThumb action. Percent_ptr must be cast to a pointer to float before use; i.e.

	float percent = *(float*)percent_ptr;

With the default button bindings, button 2 moves the thumb interactively, and the jumpProc is called on each new position of the pointer, while the pointer button remains down. The value specified by percent_ptr is the current location of the thumb (from the top or left of the Scrollbar) expressed as a percentage of the length of the Scrollbar.

Convenience routines

To set the position and length of a Scrollbar thumb, use XawScrollbarSetThumb.

void XawScrollbarSetThumb(w, top, shown)
	Widget w;
	float top;
	float shown;

XawScrollbarThumb moves the visible thumb to a new position (0.0 - 1.0) and length (0.0 - 1.0). Either the top or shown arguments can be specified as -1.0, in which case the current value is left unchanged. Values greater than 1.0 are truncated to 1.0.

If called from jumpProc, XawScrollbarSetThumb has no effect.

Setting Float Resources

The shown and topOfThumb resources are of type float. These resources can be difficult to get into an argument list. The reason is that C performs an automatic cast of the float value to an integer value, usually truncating the important information. The following code fragment is one portable method of getting a float into an argument list.

  top = 0.5;
  if (sizeof(float) > sizeof(XtArgVal)) {
  /*
   * If a float is larger than an XtArgVal then pass this 
   * resource value by reference.
   */
       XtSetArg(args[0], XtNshown, &top);
  }
  else {
  /*
   * Convince C not to perform an automatic conversion, which
   * would truncate 0.5 to 0. 
   */
       XtArgVal * l_top = (XtArgVal *) ⊤
       XtSetArg(args[0], XtNshown, *l_top);
  }