700 lines
23 KiB
C
700 lines
23 KiB
C
// widgetScrollPane.c -- ScrollPane container widget
|
|
//
|
|
// A clipping container that allows its children (laid out as a
|
|
// vertical box) to overflow and be scrolled into view. This is the
|
|
// general-purpose scrollable container -- unlike TreeView or ListBox
|
|
// which have item-specific scrolling, ScrollPane can wrap any
|
|
// collection of arbitrary child widgets.
|
|
//
|
|
// Architecture: ScrollPane is both a layout container and a paint
|
|
// container (WCLASS_PAINTS_CHILDREN flag). It lays out children at
|
|
// their virtual positions (offset by scroll position), then during
|
|
// paint, sets a clip rect to the inner content area before painting
|
|
// children. This means children are positioned at coordinates that
|
|
// may be outside the visible area -- the clip rect handles hiding
|
|
// the overflow. This is simpler and more efficient than per-widget
|
|
// visibility culling for the small widget counts typical on 486 DOS.
|
|
//
|
|
// Scrollbar visibility uses a two-pass determination: first check if
|
|
// V scrollbar is needed, then check H (accounting for the space the
|
|
// V scrollbar consumed), then re-check V in case H scrollbar's
|
|
// appearance reduced available height. This handles the mutual
|
|
// dependency where adding one scrollbar may trigger the other.
|
|
//
|
|
// The scroll pane has its own copies of the scrollbar drawing routines
|
|
// (drawSPHScrollbar, drawSPVScrollbar) rather than using the shared
|
|
// widgetDrawScrollbarH/V because it uses its own SP_SB_W constant.
|
|
// This is a minor duplication tradeoff for allowing different scrollbar
|
|
// widths in different contexts.
|
|
|
|
#include "widgetInternal.h"
|
|
|
|
#define SP_BORDER 2
|
|
#define SP_SB_W 14
|
|
#define SP_PAD 0
|
|
|
|
|
|
// ============================================================
|
|
// Prototypes
|
|
// ============================================================
|
|
|
|
static void drawSPHScrollbar(WidgetT *w, DisplayT *d, const BlitOpsT *ops, const ColorSchemeT *colors, int32_t sbX, int32_t sbY, int32_t sbW, int32_t totalW, int32_t visibleW);
|
|
static void drawSPVScrollbar(WidgetT *w, DisplayT *d, const BlitOpsT *ops, const ColorSchemeT *colors, int32_t sbX, int32_t sbY, int32_t sbH, int32_t totalH, int32_t visibleH);
|
|
static void spCalcNeeds(WidgetT *w, const BitmapFontT *font, int32_t *contentMinW, int32_t *contentMinH, int32_t *innerW, int32_t *innerH, bool *needVSb, bool *needHSb);
|
|
|
|
|
|
// ============================================================
|
|
// drawSPHScrollbar
|
|
// ============================================================
|
|
|
|
static void drawSPHScrollbar(WidgetT *w, DisplayT *d, const BlitOpsT *ops, const ColorSchemeT *colors, int32_t sbX, int32_t sbY, int32_t sbW, int32_t totalW, int32_t visibleW) {
|
|
if (sbW < SP_SB_W * 3) {
|
|
return;
|
|
}
|
|
|
|
uint32_t fg = colors->contentFg;
|
|
|
|
// Trough
|
|
BevelStyleT troughBevel = BEVEL_TROUGH(colors);
|
|
drawBevel(d, ops, sbX, sbY, sbW, SP_SB_W, &troughBevel);
|
|
|
|
// Left arrow button
|
|
BevelStyleT btnBevel = BEVEL_RAISED(colors, 1);
|
|
drawBevel(d, ops, sbX, sbY, SP_SB_W, SP_SB_W, &btnBevel);
|
|
|
|
{
|
|
int32_t cx = sbX + SP_SB_W / 2;
|
|
int32_t cy = sbY + SP_SB_W / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawVLine(d, ops, cx - 2 + i, cy - i, 1 + i * 2, fg);
|
|
}
|
|
}
|
|
|
|
// Right arrow button
|
|
int32_t rightX = sbX + sbW - SP_SB_W;
|
|
drawBevel(d, ops, rightX, sbY, SP_SB_W, SP_SB_W, &btnBevel);
|
|
|
|
{
|
|
int32_t cx = rightX + SP_SB_W / 2;
|
|
int32_t cy = sbY + SP_SB_W / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawVLine(d, ops, cx + 2 - i, cy - i, 1 + i * 2, fg);
|
|
}
|
|
}
|
|
|
|
// Thumb
|
|
int32_t trackLen = sbW - SP_SB_W * 2;
|
|
|
|
if (trackLen > 0 && totalW > 0) {
|
|
int32_t thumbPos;
|
|
int32_t thumbSize;
|
|
widgetScrollbarThumb(trackLen, totalW, visibleW, w->as.scrollPane.scrollPosH, &thumbPos, &thumbSize);
|
|
drawBevel(d, ops, sbX + SP_SB_W + thumbPos, sbY, thumbSize, SP_SB_W, &btnBevel);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// drawSPVScrollbar
|
|
// ============================================================
|
|
|
|
static void drawSPVScrollbar(WidgetT *w, DisplayT *d, const BlitOpsT *ops, const ColorSchemeT *colors, int32_t sbX, int32_t sbY, int32_t sbH, int32_t totalH, int32_t visibleH) {
|
|
if (sbH < SP_SB_W * 3) {
|
|
return;
|
|
}
|
|
|
|
uint32_t fg = colors->contentFg;
|
|
|
|
// Trough
|
|
BevelStyleT troughBevel = BEVEL_TROUGH(colors);
|
|
drawBevel(d, ops, sbX, sbY, SP_SB_W, sbH, &troughBevel);
|
|
|
|
// Up arrow button
|
|
BevelStyleT btnBevel = BEVEL_RAISED(colors, 1);
|
|
drawBevel(d, ops, sbX, sbY, SP_SB_W, SP_SB_W, &btnBevel);
|
|
|
|
{
|
|
int32_t cx = sbX + SP_SB_W / 2;
|
|
int32_t cy = sbY + SP_SB_W / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawHLine(d, ops, cx - i, cy - 2 + i, 1 + i * 2, fg);
|
|
}
|
|
}
|
|
|
|
// Down arrow button
|
|
int32_t downY = sbY + sbH - SP_SB_W;
|
|
drawBevel(d, ops, sbX, downY, SP_SB_W, SP_SB_W, &btnBevel);
|
|
|
|
{
|
|
int32_t cx = sbX + SP_SB_W / 2;
|
|
int32_t cy = downY + SP_SB_W / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawHLine(d, ops, cx - i, cy + 2 - i, 1 + i * 2, fg);
|
|
}
|
|
}
|
|
|
|
// Thumb
|
|
int32_t trackLen = sbH - SP_SB_W * 2;
|
|
|
|
if (trackLen > 0 && totalH > 0) {
|
|
int32_t thumbPos;
|
|
int32_t thumbSize;
|
|
widgetScrollbarThumb(trackLen, totalH, visibleH, w->as.scrollPane.scrollPosV, &thumbPos, &thumbSize);
|
|
drawBevel(d, ops, sbX, sbY + SP_SB_W + thumbPos, SP_SB_W, thumbSize, &btnBevel);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// spCalcNeeds -- determine scrollbar needs and inner dimensions
|
|
// ============================================================
|
|
|
|
// Central sizing function called by layout, paint, and mouse handlers.
|
|
// Computes the total content min size from children, then determines
|
|
// which scrollbars are needed and adjusts inner dimensions accordingly.
|
|
// The two-pass scrollbar dependency resolution handles the case where
|
|
// adding a V scrollbar shrinks the width enough to need an H scrollbar,
|
|
// which in turn shrinks the height enough to need a V scrollbar.
|
|
static void spCalcNeeds(WidgetT *w, const BitmapFontT *font, int32_t *contentMinW, int32_t *contentMinH, int32_t *innerW, int32_t *innerH, bool *needVSb, bool *needHSb) {
|
|
// Measure children
|
|
int32_t totalMinW = 0;
|
|
int32_t totalMinH = 0;
|
|
int32_t pad = wgtResolveSize(w->padding, 0, font->charWidth);
|
|
int32_t gap = wgtResolveSize(w->spacing, 0, font->charWidth);
|
|
int32_t count = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (!c->visible) {
|
|
continue;
|
|
}
|
|
|
|
totalMinH += c->calcMinH;
|
|
totalMinW = DVX_MAX(totalMinW, c->calcMinW);
|
|
count++;
|
|
}
|
|
|
|
if (count > 1) {
|
|
totalMinH += gap * (count - 1);
|
|
}
|
|
|
|
totalMinW += pad * 2;
|
|
totalMinH += pad * 2;
|
|
|
|
*contentMinW = totalMinW;
|
|
*contentMinH = totalMinH;
|
|
|
|
// Available inner area
|
|
*innerW = w->w - SP_BORDER * 2;
|
|
*innerH = w->h - SP_BORDER * 2;
|
|
|
|
// Determine scrollbar needs (two-pass for mutual dependency)
|
|
*needVSb = (totalMinH > *innerH);
|
|
*needHSb = false;
|
|
|
|
if (*needVSb) {
|
|
*innerW -= SP_SB_W;
|
|
}
|
|
|
|
if (totalMinW > *innerW) {
|
|
*needHSb = true;
|
|
*innerH -= SP_SB_W;
|
|
|
|
if (!*needVSb && totalMinH > *innerH) {
|
|
*needVSb = true;
|
|
*innerW -= SP_SB_W;
|
|
}
|
|
}
|
|
|
|
if (*innerW < 0) {
|
|
*innerW = 0;
|
|
}
|
|
|
|
if (*innerH < 0) {
|
|
*innerH = 0;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetScrollPaneCalcMinSize
|
|
// ============================================================
|
|
|
|
// The scroll pane reports a deliberately small min size (just enough
|
|
// for the scrollbar chrome) because its whole purpose is to contain
|
|
// content that doesn't fit. However, children still need their min
|
|
// sizes computed so spCalcNeeds can determine scrollbar visibility
|
|
// and the layout pass can distribute space correctly.
|
|
void widgetScrollPaneCalcMinSize(WidgetT *w, const BitmapFontT *font) {
|
|
// Recursively measure children so they have valid calcMinW/H
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
widgetCalcMinSizeTree(c, font);
|
|
}
|
|
|
|
// The scroll pane's own min size is small -- the whole point is scrolling
|
|
w->calcMinW = SP_SB_W * 3 + SP_BORDER * 2;
|
|
w->calcMinH = SP_SB_W * 3 + SP_BORDER * 2;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetScrollPaneLayout
|
|
// ============================================================
|
|
|
|
// Layout is a vertical box layout offset by the scroll position.
|
|
// Children are positioned at their "virtual" coordinates (baseX/baseY
|
|
// incorporate the negative scroll offset), so they may have negative
|
|
// or very large Y values. The paint pass clips to the visible area.
|
|
// This means child coordinates are always absolute screen coords,
|
|
// keeping the draw path simple -- no coordinate translation needed
|
|
// at paint time.
|
|
//
|
|
// Extra space distribution uses the same weight-based algorithm as
|
|
// the generic box layout: each child gets a share of surplus space
|
|
// proportional to its weight/totalWeight ratio. This allows stretch
|
|
// children inside the scrollable area.
|
|
void widgetScrollPaneLayout(WidgetT *w, const BitmapFontT *font) {
|
|
int32_t contentMinW;
|
|
int32_t contentMinH;
|
|
int32_t innerW;
|
|
int32_t innerH;
|
|
bool needVSb;
|
|
bool needHSb;
|
|
|
|
spCalcNeeds(w, font, &contentMinW, &contentMinH, &innerW, &innerH, &needVSb, &needHSb);
|
|
|
|
// Clamp scroll positions
|
|
int32_t maxScrollV = contentMinH - innerH;
|
|
int32_t maxScrollH = contentMinW - innerW;
|
|
|
|
if (maxScrollV < 0) {
|
|
maxScrollV = 0;
|
|
}
|
|
|
|
if (maxScrollH < 0) {
|
|
maxScrollH = 0;
|
|
}
|
|
|
|
w->as.scrollPane.scrollPosV = clampInt(w->as.scrollPane.scrollPosV, 0, maxScrollV);
|
|
w->as.scrollPane.scrollPosH = clampInt(w->as.scrollPane.scrollPosH, 0, maxScrollH);
|
|
|
|
// Layout children as a vertical box at virtual size
|
|
int32_t pad = wgtResolveSize(w->padding, 0, font->charWidth);
|
|
int32_t gap = wgtResolveSize(w->spacing, 0, font->charWidth);
|
|
int32_t virtualW = DVX_MAX(innerW, contentMinW);
|
|
int32_t virtualH = DVX_MAX(innerH, contentMinH);
|
|
int32_t baseX = w->x + SP_BORDER - w->as.scrollPane.scrollPosH;
|
|
int32_t baseY = w->y + SP_BORDER - w->as.scrollPane.scrollPosV;
|
|
int32_t childW = virtualW - pad * 2;
|
|
int32_t pos = baseY + pad;
|
|
|
|
if (childW < 0) {
|
|
childW = 0;
|
|
}
|
|
|
|
// Sum min sizes and weights for distribution
|
|
int32_t totalMin = 0;
|
|
int32_t totalWeight = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (!c->visible) {
|
|
continue;
|
|
}
|
|
|
|
totalMin += c->calcMinH;
|
|
totalWeight += c->weight;
|
|
}
|
|
|
|
int32_t count = widgetCountVisibleChildren(w);
|
|
int32_t totalGap = (count > 1) ? gap * (count - 1) : 0;
|
|
int32_t availMain = virtualH - pad * 2 - totalGap;
|
|
int32_t extraSpace = availMain - totalMin;
|
|
|
|
if (extraSpace < 0) {
|
|
extraSpace = 0;
|
|
}
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (!c->visible) {
|
|
continue;
|
|
}
|
|
|
|
int32_t mainSize = c->calcMinH;
|
|
|
|
if (totalWeight > 0 && c->weight > 0 && extraSpace > 0) {
|
|
mainSize += (extraSpace * c->weight) / totalWeight;
|
|
}
|
|
|
|
c->x = baseX + pad;
|
|
c->y = pos;
|
|
c->w = childW;
|
|
c->h = mainSize;
|
|
|
|
if (c->maxW) {
|
|
int32_t maxPx = wgtResolveSize(c->maxW, childW, font->charWidth);
|
|
|
|
if (c->w > maxPx) {
|
|
c->w = maxPx;
|
|
}
|
|
}
|
|
|
|
if (c->maxH) {
|
|
int32_t maxPx = wgtResolveSize(c->maxH, mainSize, font->charWidth);
|
|
|
|
if (c->h > maxPx) {
|
|
c->h = maxPx;
|
|
}
|
|
}
|
|
|
|
pos += mainSize + gap;
|
|
|
|
// Recurse into child containers
|
|
widgetLayoutChildren(c, font);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetScrollPaneOnKey
|
|
// ============================================================
|
|
|
|
// Keyboard scrolling uses font metrics for step sizes: charHeight for
|
|
// vertical line scroll, charWidth for horizontal, and the full inner
|
|
// height for page scroll. This makes scroll distance proportional to
|
|
// content size, which feels natural. The early return for unhandled
|
|
// keys avoids unnecessary invalidation.
|
|
void widgetScrollPaneOnKey(WidgetT *w, int32_t key, int32_t mod) {
|
|
(void)mod;
|
|
|
|
AppContextT *ctx = wgtGetContext(w);
|
|
const BitmapFontT *font = &ctx->font;
|
|
|
|
int32_t contentMinW;
|
|
int32_t contentMinH;
|
|
int32_t innerW;
|
|
int32_t innerH;
|
|
bool needVSb;
|
|
bool needHSb;
|
|
|
|
spCalcNeeds(w, font, &contentMinW, &contentMinH, &innerW, &innerH, &needVSb, &needHSb);
|
|
|
|
int32_t maxScrollV = contentMinH - innerH;
|
|
int32_t maxScrollH = contentMinW - innerW;
|
|
|
|
if (maxScrollV < 0) {
|
|
maxScrollV = 0;
|
|
}
|
|
|
|
if (maxScrollH < 0) {
|
|
maxScrollH = 0;
|
|
}
|
|
|
|
int32_t step = font->charHeight;
|
|
|
|
if (key == (0x48 | 0x100)) {
|
|
// Up
|
|
w->as.scrollPane.scrollPosV -= step;
|
|
} else if (key == (0x50 | 0x100)) {
|
|
// Down
|
|
w->as.scrollPane.scrollPosV += step;
|
|
} else if (key == (0x49 | 0x100)) {
|
|
// Page Up
|
|
w->as.scrollPane.scrollPosV -= innerH;
|
|
} else if (key == (0x51 | 0x100)) {
|
|
// Page Down
|
|
w->as.scrollPane.scrollPosV += innerH;
|
|
} else if (key == (0x47 | 0x100)) {
|
|
// Home
|
|
w->as.scrollPane.scrollPosV = 0;
|
|
} else if (key == (0x4F | 0x100)) {
|
|
// End
|
|
w->as.scrollPane.scrollPosV = maxScrollV;
|
|
} else if (key == (0x4B | 0x100)) {
|
|
// Left
|
|
w->as.scrollPane.scrollPosH -= font->charWidth;
|
|
} else if (key == (0x4D | 0x100)) {
|
|
// Right
|
|
w->as.scrollPane.scrollPosH += font->charWidth;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
w->as.scrollPane.scrollPosV = clampInt(w->as.scrollPane.scrollPosV, 0, maxScrollV);
|
|
w->as.scrollPane.scrollPosH = clampInt(w->as.scrollPane.scrollPosH, 0, maxScrollH);
|
|
wgtInvalidate(w);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetScrollPaneOnMouse
|
|
// ============================================================
|
|
|
|
// Mouse handling has priority order: V scrollbar > H scrollbar > dead
|
|
// corner > child content. The dead corner (where H and V scrollbars
|
|
// meet) is explicitly handled to prevent clicks from falling through
|
|
// to content behind it. Content clicks do recursive hit-testing into
|
|
// children and forward the mouse event, handling focus management
|
|
// along the way. This is necessary because scroll pane has
|
|
// WCLASS_NO_HIT_RECURSE -- the generic hit-test doesn't descend
|
|
// into scroll pane children since their coordinates may be outside
|
|
// the pane's visible bounds.
|
|
void widgetScrollPaneOnMouse(WidgetT *hit, WidgetT *root, int32_t vx, int32_t vy) {
|
|
AppContextT *ctx = (AppContextT *)root->userData;
|
|
const BitmapFontT *font = &ctx->font;
|
|
|
|
int32_t contentMinW;
|
|
int32_t contentMinH;
|
|
int32_t innerW;
|
|
int32_t innerH;
|
|
bool needVSb;
|
|
bool needHSb;
|
|
|
|
spCalcNeeds(hit, font, &contentMinW, &contentMinH, &innerW, &innerH, &needVSb, &needHSb);
|
|
|
|
// Clamp scroll positions
|
|
int32_t maxScrollV = contentMinH - innerH;
|
|
int32_t maxScrollH = contentMinW - innerW;
|
|
|
|
if (maxScrollV < 0) {
|
|
maxScrollV = 0;
|
|
}
|
|
|
|
if (maxScrollH < 0) {
|
|
maxScrollH = 0;
|
|
}
|
|
|
|
hit->as.scrollPane.scrollPosV = clampInt(hit->as.scrollPane.scrollPosV, 0, maxScrollV);
|
|
hit->as.scrollPane.scrollPosH = clampInt(hit->as.scrollPane.scrollPosH, 0, maxScrollH);
|
|
|
|
// Check vertical scrollbar
|
|
if (needVSb) {
|
|
int32_t sbX = hit->x + hit->w - SP_BORDER - SP_SB_W;
|
|
|
|
if (vx >= sbX && vy >= hit->y + SP_BORDER && vy < hit->y + SP_BORDER + innerH) {
|
|
int32_t sbY = hit->y + SP_BORDER;
|
|
int32_t sbH = innerH;
|
|
int32_t relY = vy - sbY;
|
|
int32_t trackLen = sbH - SP_SB_W * 2;
|
|
int32_t pageSize = innerH - font->charHeight;
|
|
|
|
if (pageSize < font->charHeight) {
|
|
pageSize = font->charHeight;
|
|
}
|
|
|
|
if (relY < SP_SB_W) {
|
|
hit->as.scrollPane.scrollPosV -= font->charHeight;
|
|
} else if (relY >= sbH - SP_SB_W) {
|
|
hit->as.scrollPane.scrollPosV += font->charHeight;
|
|
} else if (trackLen > 0) {
|
|
int32_t thumbPos;
|
|
int32_t thumbSize;
|
|
widgetScrollbarThumb(trackLen, contentMinH, innerH, hit->as.scrollPane.scrollPosV, &thumbPos, &thumbSize);
|
|
|
|
int32_t trackRelY = relY - SP_SB_W;
|
|
|
|
if (trackRelY < thumbPos) {
|
|
hit->as.scrollPane.scrollPosV -= pageSize;
|
|
} else if (trackRelY >= thumbPos + thumbSize) {
|
|
hit->as.scrollPane.scrollPosV += pageSize;
|
|
} else {
|
|
sDragScrollbar = hit;
|
|
sDragScrollbarOrient = 0;
|
|
sDragScrollbarOff = trackRelY - thumbPos;
|
|
return;
|
|
}
|
|
}
|
|
|
|
hit->as.scrollPane.scrollPosV = clampInt(hit->as.scrollPane.scrollPosV, 0, maxScrollV);
|
|
wgtInvalidate(hit);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Check horizontal scrollbar
|
|
if (needHSb) {
|
|
int32_t sbY = hit->y + hit->h - SP_BORDER - SP_SB_W;
|
|
|
|
if (vy >= sbY && vx >= hit->x + SP_BORDER && vx < hit->x + SP_BORDER + innerW) {
|
|
int32_t sbX = hit->x + SP_BORDER;
|
|
int32_t sbW = innerW;
|
|
int32_t relX = vx - sbX;
|
|
int32_t trackLen = sbW - SP_SB_W * 2;
|
|
int32_t pageSize = innerW - font->charWidth;
|
|
|
|
if (pageSize < font->charWidth) {
|
|
pageSize = font->charWidth;
|
|
}
|
|
|
|
if (relX < SP_SB_W) {
|
|
hit->as.scrollPane.scrollPosH -= font->charWidth;
|
|
} else if (relX >= sbW - SP_SB_W) {
|
|
hit->as.scrollPane.scrollPosH += font->charWidth;
|
|
} else if (trackLen > 0) {
|
|
int32_t thumbPos;
|
|
int32_t thumbSize;
|
|
widgetScrollbarThumb(trackLen, contentMinW, innerW, hit->as.scrollPane.scrollPosH, &thumbPos, &thumbSize);
|
|
|
|
int32_t trackRelX = relX - SP_SB_W;
|
|
|
|
if (trackRelX < thumbPos) {
|
|
hit->as.scrollPane.scrollPosH -= pageSize;
|
|
} else if (trackRelX >= thumbPos + thumbSize) {
|
|
hit->as.scrollPane.scrollPosH += pageSize;
|
|
} else {
|
|
sDragScrollbar = hit;
|
|
sDragScrollbarOrient = 1;
|
|
sDragScrollbarOff = trackRelX - thumbPos;
|
|
return;
|
|
}
|
|
}
|
|
|
|
hit->as.scrollPane.scrollPosH = clampInt(hit->as.scrollPane.scrollPosH, 0, maxScrollH);
|
|
wgtInvalidate(hit);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Dead corner
|
|
if (needVSb && needHSb) {
|
|
int32_t cornerX = hit->x + hit->w - SP_BORDER - SP_SB_W;
|
|
int32_t cornerY = hit->y + hit->h - SP_BORDER - SP_SB_W;
|
|
|
|
if (vx >= cornerX && vy >= cornerY) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Click on content area -- forward to child widgets
|
|
// Children are already positioned at scroll-adjusted coordinates
|
|
WidgetT *child = NULL;
|
|
|
|
for (WidgetT *c = hit->firstChild; c; c = c->nextSibling) {
|
|
WidgetT *ch = widgetHitTest(c, vx, vy);
|
|
|
|
if (ch) {
|
|
child = ch;
|
|
}
|
|
}
|
|
|
|
if (child && child->enabled && child->wclass && child->wclass->onMouse) {
|
|
// Clear old focus
|
|
if (sFocusedWidget && sFocusedWidget != child) {
|
|
sFocusedWidget->focused = false;
|
|
}
|
|
|
|
child->wclass->onMouse(child, root, vx, vy);
|
|
|
|
if (child->focused) {
|
|
sFocusedWidget = child;
|
|
}
|
|
} else {
|
|
hit->focused = true;
|
|
}
|
|
|
|
wgtInvalidatePaint(hit);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetScrollPanePaint
|
|
// ============================================================
|
|
|
|
// Paint saves and restores the clip rect around child painting.
|
|
// Children are painted with a clip rect that excludes the scrollbar
|
|
// area, so children that extend past the visible content area are
|
|
// automatically clipped. Scrollbars are painted after restoring the
|
|
// clip rect so they're always fully visible. The dead corner (when
|
|
// both scrollbars are present) is filled with windowFace color.
|
|
void widgetScrollPanePaint(WidgetT *w, DisplayT *d, const BlitOpsT *ops, const BitmapFontT *font, const ColorSchemeT *colors) {
|
|
uint32_t bg = w->bgColor ? w->bgColor : colors->contentBg;
|
|
|
|
int32_t contentMinW;
|
|
int32_t contentMinH;
|
|
int32_t innerW;
|
|
int32_t innerH;
|
|
bool needVSb;
|
|
bool needHSb;
|
|
|
|
spCalcNeeds(w, font, &contentMinW, &contentMinH, &innerW, &innerH, &needVSb, &needHSb);
|
|
|
|
// Clamp scroll
|
|
int32_t maxScrollV = contentMinH - innerH;
|
|
int32_t maxScrollH = contentMinW - innerW;
|
|
|
|
if (maxScrollV < 0) {
|
|
maxScrollV = 0;
|
|
}
|
|
|
|
if (maxScrollH < 0) {
|
|
maxScrollH = 0;
|
|
}
|
|
|
|
w->as.scrollPane.scrollPosV = clampInt(w->as.scrollPane.scrollPosV, 0, maxScrollV);
|
|
w->as.scrollPane.scrollPosH = clampInt(w->as.scrollPane.scrollPosH, 0, maxScrollH);
|
|
|
|
// Sunken border
|
|
BevelStyleT bevel = BEVEL_SUNKEN(colors, bg, SP_BORDER);
|
|
drawBevel(d, ops, w->x, w->y, w->w, w->h, &bevel);
|
|
|
|
// Clip to content area and paint children
|
|
int32_t oldClipX = d->clipX;
|
|
int32_t oldClipY = d->clipY;
|
|
int32_t oldClipW = d->clipW;
|
|
int32_t oldClipH = d->clipH;
|
|
setClipRect(d, w->x + SP_BORDER, w->y + SP_BORDER, innerW, innerH);
|
|
|
|
// Fill background
|
|
rectFill(d, ops, w->x + SP_BORDER, w->y + SP_BORDER, innerW, innerH, bg);
|
|
|
|
// Paint children (already positioned by layout with scroll offset)
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
widgetPaintOne(c, d, ops, font, colors);
|
|
}
|
|
|
|
setClipRect(d, oldClipX, oldClipY, oldClipW, oldClipH);
|
|
|
|
// Draw scrollbars
|
|
if (needVSb) {
|
|
int32_t sbX = w->x + w->w - SP_BORDER - SP_SB_W;
|
|
int32_t sbY = w->y + SP_BORDER;
|
|
drawSPVScrollbar(w, d, ops, colors, sbX, sbY, innerH, contentMinH, innerH);
|
|
}
|
|
|
|
if (needHSb) {
|
|
int32_t sbX = w->x + SP_BORDER;
|
|
int32_t sbY = w->y + w->h - SP_BORDER - SP_SB_W;
|
|
drawSPHScrollbar(w, d, ops, colors, sbX, sbY, innerW, contentMinW, innerW);
|
|
|
|
if (needVSb) {
|
|
rectFill(d, ops, sbX + innerW, sbY, SP_SB_W, SP_SB_W, colors->windowFace);
|
|
}
|
|
}
|
|
|
|
if (w->focused) {
|
|
uint32_t fg = w->fgColor ? w->fgColor : colors->contentFg;
|
|
drawFocusRect(d, ops, w->x + 1, w->y + 1, w->w - 2, w->h - 2, fg);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtScrollPane
|
|
// ============================================================
|
|
|
|
// Default weight=100 so the scroll pane stretches to fill available
|
|
// space in its parent container. Without this, a scroll pane in a
|
|
// vertical box would collapse to its minimal size.
|
|
WidgetT *wgtScrollPane(WidgetT *parent) {
|
|
WidgetT *w = widgetAlloc(parent, WidgetScrollPaneE);
|
|
|
|
if (w) {
|
|
w->as.scrollPane.scrollPosV = 0;
|
|
w->as.scrollPane.scrollPosH = 0;
|
|
w->weight = 100;
|
|
}
|
|
|
|
return w;
|
|
}
|