/* PDCurses */
#include "pdcx11.h"
/*man-start**************************************************************
sb
--
### Synopsis
int sb_init(void)
int sb_set_horz(int total, int viewport, int cur)
int sb_set_vert(int total, int viewport, int cur)
int sb_get_horz(int *total, int *viewport, int *cur)
int sb_get_vert(int *total, int *viewport, int *cur)
int sb_refresh(void);
### Description
These functions manipulate the scrollbar.
### Return Value
All functions return OK on success and ERR on error.
### Portability
X/Open ncurses NetBSD
sb_init - - -
sb_set_horz - - -
sb_set_vert - - -
sb_get_horz - - -
sb_get_vert - - -
sb_refresh - - -
**man-end****************************************************************/
#ifdef USE_XAW3D
# include <Xaw3d/Box.h>
# include <Xaw3d/Scrollbar.h>
#elif defined(USE_NEXTAW)
# include <neXtaw/Box.h>
# include <neXtaw/Scrollbar.h>
#else
# include <Xaw/Box.h>
# include <Xaw/Scrollbar.h>
#endif
#include "scrlbox.h"
bool sb_started = FALSE;
#if NeedWidePrototypes
# define PDC_SCROLLBAR_TYPE double
#else
# define PDC_SCROLLBAR_TYPE float
#endif
static Widget scrollBox, scrollVert, scrollHoriz;
static int sb_viewport_y, sb_viewport_x;
static int sb_total_y, sb_total_x, sb_cur_y, sb_cur_x;
static void _scroll_up_down(Widget w, XtPointer client_data,
XtPointer call_data)
{
int pixels = (long) call_data;
int total_y = sb_total_y * pdc_fheight;
int viewport_y = sb_viewport_y * pdc_fheight;
int cur_y = sb_cur_y * pdc_fheight;
/* When pixels is negative, right button pressed, move data down,
thumb moves up. Otherwise, left button pressed, pixels positive,
move data up, thumb down. */
cur_y += pixels;
/* limit panning to size of overall */
if (cur_y < 0)
cur_y = 0;
else
if (cur_y > (total_y - viewport_y))
cur_y = total_y - viewport_y;
sb_cur_y = cur_y / pdc_fheight;
XawScrollbarSetThumb(w, (double)((double)cur_y / (double)total_y),
(double)((double)viewport_y / (double)total_y));
}
static void _scroll_left_right(Widget w, XtPointer client_data,
XtPointer call_data)
{
int pixels = (long) call_data;
int total_x = sb_total_x * pdc_fwidth;
int viewport_x = sb_viewport_x * pdc_fwidth;
int cur_x = sb_cur_x * pdc_fwidth;
cur_x += pixels;
/* limit panning to size of overall */
if (cur_x < 0)
cur_x = 0;
else
if (cur_x > (total_x - viewport_x))
cur_x = total_x - viewport_x;
sb_cur_x = cur_x / pdc_fwidth;
XawScrollbarSetThumb(w, (double)((double)cur_x / (double)total_x),
(double)((double)viewport_x / (double)total_x));
}
static void _thumb_up_down(Widget w, XtPointer client_data,
XtPointer call_data)
{
double percent = *(double *) call_data;
double total_y = (double) sb_total_y;
double viewport_y = (double) sb_viewport_y;
int cur_y = sb_cur_y;
/* If the size of the viewport is > overall area simply return,
as no scrolling is permitted. */
if (sb_viewport_y >= sb_total_y)
return;
if ((sb_cur_y = (int)((double)total_y * percent)) >=
(total_y - viewport_y))
sb_cur_y = total_y - viewport_y;
XawScrollbarSetThumb(w, (double)(cur_y / total_y),
(double)(viewport_y / total_y));
}
static void _thumb_left_right(Widget w, XtPointer client_data,
XtPointer call_data)
{
double percent = *(double *) call_data;
double total_x = (double) sb_total_x;
double viewport_x = (double) sb_viewport_x;
int cur_x = sb_cur_x;
if (sb_viewport_x >= sb_total_x)
return;
if ((sb_cur_x = (int)((float)total_x * percent)) >=
(total_x - viewport_x))
sb_cur_x = total_x - viewport_x;
XawScrollbarSetThumb(w, (double)(cur_x / total_x),
(double)(viewport_x / total_x));
}
bool PDC_scrollbar_init(const char *program_name)
{
if (pdc_app_data.scrollbarWidth && sb_started)
{
scrollBox = XtVaCreateManagedWidget(program_name,
scrollBoxWidgetClass, pdc_toplevel, XtNwidth,
pdc_wwidth + pdc_app_data.scrollbarWidth,
XtNheight, pdc_wheight + pdc_app_data.scrollbarWidth,
XtNwidthInc, pdc_fwidth, XtNheightInc, pdc_fheight, NULL);
pdc_drawing = XtVaCreateManagedWidget(program_name,
boxWidgetClass, scrollBox, XtNwidth,
pdc_wwidth, XtNheight, pdc_wheight, XtNwidthInc,
pdc_fwidth, XtNheightInc, pdc_fheight, NULL);
scrollVert = XtVaCreateManagedWidget("scrollVert",
scrollbarWidgetClass, scrollBox, XtNorientation,
XtorientVertical, XtNheight, pdc_wheight, XtNwidth,
pdc_app_data.scrollbarWidth, NULL);
XtAddCallback(scrollVert, XtNscrollProc, _scroll_up_down, pdc_drawing);
XtAddCallback(scrollVert, XtNjumpProc, _thumb_up_down, pdc_drawing);
scrollHoriz = XtVaCreateManagedWidget("scrollHoriz",
scrollbarWidgetClass, scrollBox, XtNorientation,
XtorientHorizontal, XtNwidth, pdc_wwidth, XtNheight,
pdc_app_data.scrollbarWidth, NULL);
XtAddCallback(scrollHoriz, XtNscrollProc, _scroll_left_right,
pdc_drawing);
XtAddCallback(scrollHoriz, XtNjumpProc, _thumb_left_right,
pdc_drawing);
return TRUE;
}
return FALSE;
}
/* sb_init() is the sb initialization routine.
This must be called before initscr(). */
int sb_init(void)
{
PDC_LOG(("sb_init() - called\n"));
if (SP)
return ERR;
sb_started = TRUE;
sb_viewport_y = sb_viewport_x = 0;
sb_total_y = sb_total_x = sb_cur_y = sb_cur_x = 0;
return OK;
}
/* sb_set_horz() - Used to set horizontal scrollbar.
total = total number of columns
viewport = size of viewport in columns
cur = current column in total */
int sb_set_horz(int total, int viewport, int cur)
{
PDC_LOG(("sb_set_horz() - called: total %d viewport %d cur %d\n",
total, viewport, cur));
if (!SP)
return ERR;
sb_total_x = total;
sb_viewport_x = viewport;
sb_cur_x = cur;
return OK;
}
/* sb_set_vert() - Used to set vertical scrollbar.
total = total number of columns on line
viewport = size of viewport in columns
cur = current column in total */
int sb_set_vert(int total, int viewport, int cur)
{
PDC_LOG(("sb_set_vert() - called: total %d viewport %d cur %d\n",
total, viewport, cur));
if (!SP)
return ERR;
sb_total_y = total;
sb_viewport_y = viewport;
sb_cur_y = cur;
return OK;
}
/* sb_get_horz() - Used to get horizontal scrollbar.
total = total number of lines
viewport = size of viewport in lines
cur = current line in total */
int sb_get_horz(int *total, int *viewport, int *cur)
{
PDC_LOG(("sb_get_horz() - called\n"));
if (!SP)
return ERR;
if (total)
*total = sb_total_x;
if (viewport)
*viewport = sb_viewport_x;
if (cur)
*cur = sb_cur_x;
return OK;
}
/* sb_get_vert() - Used to get vertical scrollbar.
total = total number of lines
viewport = size of viewport in lines
cur = current line in total */
int sb_get_vert(int *total, int *viewport, int *cur)
{
PDC_LOG(("sb_get_vert() - called\n"));
if (!SP)
return ERR;
if (total)
*total = sb_total_y;
if (viewport)
*viewport = sb_viewport_y;
if (cur)
*cur = sb_cur_y;
return OK;
}
/* sb_refresh() - Used to draw the scrollbars. */
int sb_refresh(void)
{
PDC_LOG(("sb_refresh() - called\n"));
if (!SP)
return ERR;
if (sb_started)
{
PDC_SCROLLBAR_TYPE total_y = sb_total_y;
PDC_SCROLLBAR_TYPE total_x = sb_total_x;
if (total_y)
XawScrollbarSetThumb(scrollVert,
(PDC_SCROLLBAR_TYPE)(sb_cur_y) / total_y,
(PDC_SCROLLBAR_TYPE)(sb_viewport_y) / total_y);
if (total_x)
XawScrollbarSetThumb(scrollHoriz,
(PDC_SCROLLBAR_TYPE)(sb_cur_x) / total_x,
(PDC_SCROLLBAR_TYPE)(sb_viewport_x) / total_x);
}
return OK;
}