724 lines
22 KiB
C
724 lines
22 KiB
C
#define DVX_WIDGET_IMPL
|
|
// widgetTabControl.c -- TabControl and TabPage widgets
|
|
//
|
|
// Two-level architecture: TabControlE is the container holding
|
|
// selection state and rendering the tab header strip. TabPageE
|
|
// children act as invisible sub-containers, each holding the content
|
|
// widgets for that page. Only the active page's children are visible
|
|
// and receive layout.
|
|
//
|
|
// Tab header rendering: each tab is a manually-drawn chrome piece
|
|
// (not a button widget) with top/left/right edges in highlight/shadow.
|
|
// The active tab is 2px taller than inactive tabs, extending down to
|
|
// overlap the content panel's top border -- this creates the classic
|
|
// "folder tab" illusion where the active tab appears connected to the
|
|
// panel below it. The panel's top border is erased under the active
|
|
// tab to complete the effect.
|
|
//
|
|
// Scrolling tab headers: when the total tab header width exceeds the
|
|
// available space, left/right arrow buttons appear and the header area
|
|
// becomes a clipped scrolling region. The scrollOffset tracks how many
|
|
// pixels the tab strip has scrolled. tabEnsureVisible() auto-scrolls
|
|
// to keep the active tab visible after keyboard navigation.
|
|
//
|
|
// Tab switching closes any open dropdown/combobox popup before
|
|
// switching, because the popup's owning widget may be on the
|
|
// now-hidden page and would become orphaned visually.
|
|
//
|
|
// Layout: all tab pages are positioned at the same content area
|
|
// coordinates, but only the active page has visible=true. This means
|
|
// widgetLayoutChildren is only called for the active page, saving
|
|
// layout computation for hidden pages. When switching tabs, the old
|
|
// page becomes invisible and the new page becomes visible + relaid out.
|
|
|
|
#include "dvxWgtP.h"
|
|
|
|
#define TAB_PAD_H 8
|
|
#define TAB_PAD_V 4
|
|
#define TAB_BORDER 2
|
|
|
|
static int32_t sTabControlTypeId = -1;
|
|
static int32_t sTabPageTypeId = -1;
|
|
|
|
typedef struct {
|
|
int32_t activeTab;
|
|
int32_t scrollOffset;
|
|
} TabControlDataT;
|
|
|
|
typedef struct {
|
|
const char *title;
|
|
} TabPageDataT;
|
|
|
|
#define TAB_ARROW_W 16
|
|
|
|
|
|
// ============================================================
|
|
// Prototypes
|
|
// ============================================================
|
|
|
|
static void tabClosePopup(void);
|
|
static void tabEnsureVisible(WidgetT *w, const BitmapFontT *font);
|
|
static int32_t tabHeaderTotalW(const WidgetT *w, const BitmapFontT *font);
|
|
static bool tabNeedScroll(const WidgetT *w, const BitmapFontT *font);
|
|
|
|
|
|
// ============================================================
|
|
// tabClosePopup -- close any open dropdown/combobox popup
|
|
// ============================================================
|
|
|
|
static void tabClosePopup(void) {
|
|
if (sOpenPopup) {
|
|
wclsClosePopup(sOpenPopup);
|
|
sOpenPopup = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// tabEnsureVisible -- scroll so active tab is visible
|
|
// ============================================================
|
|
|
|
static void tabEnsureVisible(WidgetT *w, const BitmapFontT *font) {
|
|
TabControlDataT *d = (TabControlDataT *)w->data;
|
|
|
|
if (!tabNeedScroll(w, font)) {
|
|
d->scrollOffset = 0;
|
|
return;
|
|
}
|
|
|
|
int32_t headerW = w->w - TAB_ARROW_W * 2 - 4;
|
|
|
|
if (headerW < 1) {
|
|
return;
|
|
}
|
|
|
|
// Find start and end X of the active tab
|
|
int32_t tabX = 0;
|
|
int32_t tabIdx = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->type != sTabPageTypeId) {
|
|
continue;
|
|
}
|
|
|
|
TabPageDataT *pd = (TabPageDataT *)c->data;
|
|
int32_t tw = textWidthAccel(font, pd->title) + TAB_PAD_H * 2;
|
|
|
|
if (tabIdx == d->activeTab) {
|
|
int32_t tabLeft = tabX - d->scrollOffset;
|
|
int32_t tabRight = tabLeft + tw;
|
|
|
|
if (tabLeft < 0) {
|
|
d->scrollOffset += tabLeft;
|
|
} else if (tabRight > headerW) {
|
|
d->scrollOffset += tabRight - headerW;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
tabX += tw;
|
|
tabIdx++;
|
|
}
|
|
|
|
// Clamp
|
|
int32_t totalW = tabHeaderTotalW(w, font);
|
|
int32_t maxOff = totalW - headerW;
|
|
|
|
if (maxOff < 0) {
|
|
maxOff = 0;
|
|
}
|
|
|
|
d->scrollOffset = clampInt(d->scrollOffset, 0, maxOff);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// tabHeaderTotalW -- total width of all tab headers
|
|
// ============================================================
|
|
|
|
static int32_t tabHeaderTotalW(const WidgetT *w, const BitmapFontT *font) {
|
|
int32_t total = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->type == sTabPageTypeId) {
|
|
TabPageDataT *pd = (TabPageDataT *)c->data;
|
|
total += textWidthAccel(font, pd->title) + TAB_PAD_H * 2;
|
|
}
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// tabNeedScroll -- do tab headers overflow?
|
|
// ============================================================
|
|
|
|
static bool tabNeedScroll(const WidgetT *w, const BitmapFontT *font) {
|
|
int32_t totalW = tabHeaderTotalW(w, font);
|
|
return totalW > (w->w - 4);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetTabControlCalcMinSize
|
|
// ============================================================
|
|
|
|
// Min size: tab header height + the maximum min size across ALL pages
|
|
// (not just the active one). This ensures the tab control reserves
|
|
// enough space for the largest page, preventing resize flicker when
|
|
// switching tabs. Children are recursively measured.
|
|
void widgetTabControlCalcMinSize(WidgetT *w, const BitmapFontT *font) {
|
|
int32_t tabH = font->charHeight + TAB_PAD_V * 2;
|
|
int32_t maxPageW = 0;
|
|
int32_t maxPageH = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->type != sTabPageTypeId) {
|
|
continue;
|
|
}
|
|
|
|
widgetCalcMinSizeTree(c, font);
|
|
maxPageW = DVX_MAX(maxPageW, c->calcMinW);
|
|
maxPageH = DVX_MAX(maxPageH, c->calcMinH);
|
|
}
|
|
|
|
w->calcMinW = maxPageW + TAB_BORDER * 2;
|
|
w->calcMinH = tabH + maxPageH + TAB_BORDER * 2;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetTabControlLayout
|
|
// ============================================================
|
|
|
|
void widgetTabControlLayout(WidgetT *w, const BitmapFontT *font) {
|
|
TabControlDataT *d = (TabControlDataT *)w->data;
|
|
int32_t tabH = font->charHeight + TAB_PAD_V * 2;
|
|
int32_t contentX = w->x + TAB_BORDER;
|
|
int32_t contentY = w->y + tabH + TAB_BORDER;
|
|
int32_t contentW = w->w - TAB_BORDER * 2;
|
|
int32_t contentH = w->h - tabH - TAB_BORDER * 2;
|
|
|
|
if (contentW < 0) { contentW = 0; }
|
|
if (contentH < 0) { contentH = 0; }
|
|
|
|
tabEnsureVisible(w, font);
|
|
|
|
int32_t idx = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->type != sTabPageTypeId) {
|
|
continue;
|
|
}
|
|
|
|
c->x = contentX;
|
|
c->y = contentY;
|
|
c->w = contentW;
|
|
c->h = contentH;
|
|
|
|
if (idx == d->activeTab) {
|
|
c->visible = true;
|
|
widgetLayoutChildren(c, font);
|
|
} else {
|
|
c->visible = false;
|
|
}
|
|
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetTabControlOnKey
|
|
// ============================================================
|
|
|
|
// Keyboard navigation: Left/Right cycle through tabs with wrapping
|
|
// (modular arithmetic). Home/End jump to first/last tab. The tab
|
|
// control only handles these keys when it has focus -- if a child
|
|
// widget inside the active page has focus, keys go there instead.
|
|
void widgetTabControlOnKey(WidgetT *w, int32_t key, int32_t mod) {
|
|
(void)mod;
|
|
TabControlDataT *d = (TabControlDataT *)w->data;
|
|
|
|
int32_t tabCount = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->type == sTabPageTypeId) {
|
|
tabCount++;
|
|
}
|
|
}
|
|
|
|
if (tabCount <= 1) {
|
|
return;
|
|
}
|
|
|
|
int32_t active = d->activeTab;
|
|
|
|
if (key == (0x4D | 0x100)) {
|
|
active = (active + 1) % tabCount;
|
|
} else if (key == (0x4B | 0x100)) {
|
|
active = (active - 1 + tabCount) % tabCount;
|
|
} else if (key == (0x47 | 0x100)) {
|
|
active = 0;
|
|
} else if (key == (0x4F | 0x100)) {
|
|
active = tabCount - 1;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (active != d->activeTab) {
|
|
tabClosePopup();
|
|
d->activeTab = active;
|
|
|
|
if (w->onChange) {
|
|
w->onChange(w);
|
|
}
|
|
|
|
wgtInvalidate(w);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetTabControlOnMouse
|
|
// ============================================================
|
|
|
|
// Mouse clicks in the tab header area walk the tab list computing
|
|
// accumulated X positions to find which tab was clicked. Only clicks
|
|
// in the header strip (top tabH pixels) are handled here -- clicks
|
|
// on the content area go through normal child hit-testing. Scroll
|
|
// arrow clicks adjust scrollOffset by 4 character widths at a time.
|
|
void widgetTabControlOnMouse(WidgetT *hit, WidgetT *root, int32_t vx, int32_t vy) {
|
|
sFocusedWidget = hit;
|
|
TabControlDataT *d = (TabControlDataT *)hit->data;
|
|
AppContextT *ctx = (AppContextT *)root->userData;
|
|
const BitmapFontT *font = &ctx->font;
|
|
int32_t tabH = font->charHeight + TAB_PAD_V * 2;
|
|
|
|
// Only handle clicks in the tab header area
|
|
if (vy < hit->y || vy >= hit->y + tabH) {
|
|
return;
|
|
}
|
|
|
|
bool scroll = tabNeedScroll(hit, font);
|
|
|
|
// Check scroll arrow clicks
|
|
if (scroll) {
|
|
int32_t totalW = tabHeaderTotalW(hit, font);
|
|
int32_t headerW = hit->w - TAB_ARROW_W * 2 - 4;
|
|
int32_t maxOff = totalW - headerW;
|
|
|
|
if (maxOff < 0) {
|
|
maxOff = 0;
|
|
}
|
|
|
|
// Left arrow
|
|
if (vx >= hit->x && vx < hit->x + TAB_ARROW_W) {
|
|
d->scrollOffset -= font->charWidth * 4;
|
|
d->scrollOffset = clampInt(d->scrollOffset, 0, maxOff);
|
|
wgtInvalidatePaint(hit);
|
|
return;
|
|
}
|
|
|
|
// Right arrow
|
|
if (vx >= hit->x + hit->w - TAB_ARROW_W && vx < hit->x + hit->w) {
|
|
d->scrollOffset += font->charWidth * 4;
|
|
d->scrollOffset = clampInt(d->scrollOffset, 0, maxOff);
|
|
wgtInvalidatePaint(hit);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Click on tab header
|
|
int32_t headerLeft = hit->x + 2 + (scroll ? TAB_ARROW_W : 0);
|
|
int32_t tabX = headerLeft - d->scrollOffset;
|
|
int32_t tabIdx = 0;
|
|
|
|
for (WidgetT *c = hit->firstChild; c; c = c->nextSibling) {
|
|
if (c->type != sTabPageTypeId) {
|
|
continue;
|
|
}
|
|
|
|
TabPageDataT *pd = (TabPageDataT *)c->data;
|
|
int32_t tw = textWidthAccel(font, pd->title) + TAB_PAD_H * 2;
|
|
|
|
if (vx >= tabX && vx < tabX + tw && vx >= headerLeft) {
|
|
if (tabIdx != d->activeTab) {
|
|
tabClosePopup();
|
|
d->activeTab = tabIdx;
|
|
|
|
if (hit->onChange) {
|
|
hit->onChange(hit);
|
|
}
|
|
|
|
wgtInvalidate(hit);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
tabX += tw;
|
|
tabIdx++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetTabControlPaint
|
|
// ============================================================
|
|
|
|
// Paint order: content panel first (raised bevel below the tab strip),
|
|
// then scroll arrows if needed, then tab headers in a clipped region,
|
|
// then the active page's children. Tab headers are painted with a clip
|
|
// rect so partially-scrolled tabs at the edges are cleanly truncated.
|
|
//
|
|
// The active tab is drawn 2px taller (extending from w->y instead of
|
|
// w->y+2) and erases the panel's top border beneath it (2px of
|
|
// contentBg), creating the visual connection between tab and panel.
|
|
// Inactive tabs sit 2px lower and draw a bottom border to separate
|
|
// them from the panel.
|
|
//
|
|
// Only the active page's children are painted (WCLASS_PAINTS_CHILDREN
|
|
// flag means the generic paint won't descend into tab control children).
|
|
// This is critical for performance on 486 -- we skip painting all
|
|
// hidden pages entirely.
|
|
void widgetTabControlPaint(WidgetT *w, DisplayT *d, const BlitOpsT *ops, const BitmapFontT *font, const ColorSchemeT *colors) {
|
|
TabControlDataT *td = (TabControlDataT *)w->data;
|
|
int32_t tabH = font->charHeight + TAB_PAD_V * 2;
|
|
bool scroll = tabNeedScroll(w, font);
|
|
bool selfDirty = w->paintDirty;
|
|
|
|
if (!selfDirty) {
|
|
goto paintChildren;
|
|
}
|
|
|
|
// Content panel
|
|
BevelStyleT panelBevel;
|
|
panelBevel.highlight = colors->windowHighlight;
|
|
panelBevel.shadow = colors->windowShadow;
|
|
panelBevel.face = colors->contentBg;
|
|
panelBevel.width = 2;
|
|
drawBevel(d, ops, w->x, w->y + tabH, w->w, w->h - tabH, &panelBevel);
|
|
|
|
// Scroll arrows
|
|
if (scroll) {
|
|
int32_t totalW = tabHeaderTotalW(w, font);
|
|
int32_t headerW = w->w - TAB_ARROW_W * 2 - 4;
|
|
int32_t maxOff = totalW - headerW;
|
|
|
|
if (maxOff < 0) {
|
|
maxOff = 0;
|
|
}
|
|
|
|
td->scrollOffset = clampInt(td->scrollOffset, 0, maxOff);
|
|
|
|
bool canScrollLeft = (td->scrollOffset > 0);
|
|
bool canScrollRight = (td->scrollOffset < maxOff);
|
|
BevelStyleT btnBevel = BEVEL_RAISED(colors, 1);
|
|
|
|
// Left arrow button
|
|
drawBevel(d, ops, w->x, w->y, TAB_ARROW_W, tabH, &btnBevel);
|
|
{
|
|
uint32_t arrowFg = canScrollLeft ? colors->contentFg : colors->windowShadow;
|
|
int32_t cx = w->x + TAB_ARROW_W / 2;
|
|
int32_t cy = w->y + tabH / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawVLine(d, ops, cx - 2 + i, cy - i, 1 + i * 2, arrowFg);
|
|
}
|
|
}
|
|
|
|
// Right arrow button
|
|
int32_t rx = w->x + w->w - TAB_ARROW_W;
|
|
drawBevel(d, ops, rx, w->y, TAB_ARROW_W, tabH, &btnBevel);
|
|
{
|
|
uint32_t arrowFg = canScrollRight ? colors->contentFg : colors->windowShadow;
|
|
int32_t cx = rx + TAB_ARROW_W / 2;
|
|
int32_t cy = w->y + tabH / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawVLine(d, ops, cx + 2 - i, cy - i, 1 + i * 2, arrowFg);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tab headers -- clip to header area (tabH + 2 for the active tab's extra height)
|
|
int32_t headerLeft = w->x + 2 + (scroll ? TAB_ARROW_W : 0);
|
|
int32_t headerRight = scroll ? (w->x + w->w - TAB_ARROW_W) : (w->x + w->w);
|
|
|
|
int32_t oldClipX = d->clipX;
|
|
int32_t oldClipY = d->clipY;
|
|
int32_t oldClipW = d->clipW;
|
|
int32_t oldClipH = d->clipH;
|
|
setClipRect(d, headerLeft, w->y, headerRight - headerLeft, tabH + 2);
|
|
|
|
// Clear the header strip so scrolled-away tab pixels are erased.
|
|
// Only clear above the content panel border (tabH, not tabH+2).
|
|
rectFill(d, ops, headerLeft, w->y, headerRight - headerLeft, tabH, colors->contentBg);
|
|
|
|
// Draw the content panel top border across the header area.
|
|
// Individual active tabs will erase it under themselves below.
|
|
drawHLine(d, ops, headerLeft, w->y + tabH, headerRight - headerLeft, colors->windowHighlight);
|
|
drawHLine(d, ops, headerLeft, w->y + tabH + 1, headerRight - headerLeft, colors->windowHighlight);
|
|
|
|
int32_t tabX = headerLeft - td->scrollOffset;
|
|
int32_t tabIdx = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->type != sTabPageTypeId) {
|
|
continue;
|
|
}
|
|
|
|
TabPageDataT *pd = (TabPageDataT *)c->data;
|
|
int32_t tw = textWidthAccel(font, pd->title) + TAB_PAD_H * 2;
|
|
bool isActive = (tabIdx == td->activeTab);
|
|
int32_t ty = isActive ? w->y : w->y + 2;
|
|
int32_t th = isActive ? tabH + 2 : tabH;
|
|
uint32_t tabFace = isActive ? colors->contentBg : colors->windowFace;
|
|
|
|
// Only draw tabs that are at least partially visible
|
|
if (tabX + tw > headerLeft && tabX < headerRight) {
|
|
// Fill tab background
|
|
rectFill(d, ops, tabX + 2, ty + 2, tw - 4, th - 2, tabFace);
|
|
|
|
// Top edge
|
|
drawHLine(d, ops, tabX + 2, ty, tw - 4, colors->windowHighlight);
|
|
drawHLine(d, ops, tabX + 2, ty + 1, tw - 4, colors->windowHighlight);
|
|
|
|
// Left edge
|
|
drawVLine(d, ops, tabX, ty + 2, th - 2, colors->windowHighlight);
|
|
drawVLine(d, ops, tabX + 1, ty + 2, th - 2, colors->windowHighlight);
|
|
|
|
// Right edge
|
|
drawVLine(d, ops, tabX + tw - 1, ty + 2, th - 2, colors->windowShadow);
|
|
drawVLine(d, ops, tabX + tw - 2, ty + 2, th - 2, colors->windowShadow);
|
|
|
|
if (isActive) {
|
|
// Erase panel top border under active tab
|
|
rectFill(d, ops, tabX + 2, w->y + tabH, tw - 4, 2, colors->contentBg);
|
|
} else {
|
|
// Bottom edge for inactive tab
|
|
drawHLine(d, ops, tabX, ty + th - 1, tw, colors->windowShadow);
|
|
drawHLine(d, ops, tabX + 1, ty + th - 2, tw - 2, colors->windowShadow);
|
|
}
|
|
|
|
// Tab label
|
|
int32_t labelY = ty + TAB_PAD_V;
|
|
|
|
if (!isActive) {
|
|
labelY++;
|
|
}
|
|
|
|
drawTextAccel(d, ops, font, tabX + TAB_PAD_H, labelY, pd->title, colors->contentFg, tabFace, true);
|
|
|
|
if (isActive && w == sFocusedWidget) {
|
|
drawFocusRect(d, ops, tabX + 3, ty + 3, tw - 6, th - 4, colors->contentFg);
|
|
}
|
|
}
|
|
|
|
tabX += tw;
|
|
tabIdx++;
|
|
}
|
|
|
|
setClipRect(d, oldClipX, oldClipY, oldClipW, oldClipH);
|
|
|
|
paintChildren:
|
|
;
|
|
// Paint only active tab page's children
|
|
int32_t activeIdx = 0;
|
|
|
|
for (WidgetT *c = w->firstChild; c; c = c->nextSibling) {
|
|
if (c->type != sTabPageTypeId) {
|
|
continue;
|
|
}
|
|
|
|
if (activeIdx == td->activeTab) {
|
|
for (WidgetT *gc = c->firstChild; gc; gc = gc->nextSibling) {
|
|
widgetPaintOne(gc, d, ops, font, colors);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
activeIdx++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// DXE registration
|
|
// ============================================================
|
|
|
|
// ============================================================
|
|
// widgetTabPageAccelActivate
|
|
// ============================================================
|
|
|
|
void widgetTabPageAccelActivate(WidgetT *w, WidgetT *root) {
|
|
(void)root;
|
|
|
|
if (!w->parent || w->parent->type != sTabControlTypeId) {
|
|
return;
|
|
}
|
|
|
|
TabControlDataT *d = (TabControlDataT *)w->parent->data;
|
|
|
|
// Find our index among sibling tab pages
|
|
int32_t idx = 0;
|
|
|
|
for (WidgetT *c = w->parent->firstChild; c; c = c->nextSibling) {
|
|
if (c->type != sTabPageTypeId) {
|
|
continue;
|
|
}
|
|
|
|
if (c == w) {
|
|
tabClosePopup();
|
|
d->activeTab = idx;
|
|
wgtInvalidate(w->parent);
|
|
return;
|
|
}
|
|
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetTabControlDestroy
|
|
// ============================================================
|
|
|
|
void widgetTabControlDestroy(WidgetT *w) {
|
|
free(w->data);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetTabPageDestroy
|
|
// ============================================================
|
|
|
|
void widgetTabPageDestroy(WidgetT *w) {
|
|
free(w->data);
|
|
}
|
|
|
|
|
|
static const WidgetClassT sClassTabControl = {
|
|
.version = WGT_CLASS_VERSION,
|
|
.flags = WCLASS_FOCUSABLE | WCLASS_PAINTS_CHILDREN,
|
|
.handlers = {
|
|
[WGT_METHOD_PAINT] = (void *)widgetTabControlPaint,
|
|
[WGT_METHOD_CALC_MIN_SIZE] = (void *)widgetTabControlCalcMinSize,
|
|
[WGT_METHOD_LAYOUT] = (void *)widgetTabControlLayout,
|
|
[WGT_METHOD_ON_MOUSE] = (void *)widgetTabControlOnMouse,
|
|
[WGT_METHOD_ON_KEY] = (void *)widgetTabControlOnKey,
|
|
[WGT_METHOD_DESTROY] = (void *)widgetTabControlDestroy,
|
|
}
|
|
};
|
|
|
|
static const WidgetClassT sClassTabPage = {
|
|
.version = WGT_CLASS_VERSION,
|
|
.flags = WCLASS_ACCEL_WHEN_HIDDEN,
|
|
.handlers = {
|
|
[WGT_METHOD_ON_ACCEL_ACTIVATE] = (void *)widgetTabPageAccelActivate,
|
|
[WGT_METHOD_DESTROY] = (void *)widgetTabPageDestroy,
|
|
[WGT_METHOD_CALC_MIN_SIZE] = (void *)widgetCalcMinSizeBox,
|
|
[WGT_METHOD_LAYOUT] = (void *)widgetLayoutBox,
|
|
}
|
|
};
|
|
|
|
|
|
// ============================================================
|
|
// Widget creation functions
|
|
// ============================================================
|
|
|
|
|
|
WidgetT *wgtTabControl(WidgetT *parent) {
|
|
WidgetT *w = widgetAlloc(parent, sTabControlTypeId);
|
|
|
|
if (w) {
|
|
TabControlDataT *d = calloc(1, sizeof(TabControlDataT));
|
|
d->activeTab = 0;
|
|
d->scrollOffset = 0;
|
|
w->data = d;
|
|
w->weight = 100;
|
|
}
|
|
|
|
return w;
|
|
}
|
|
|
|
|
|
int32_t wgtTabControlGetActive(const WidgetT *w) {
|
|
VALIDATE_WIDGET(w, sTabControlTypeId, 0);
|
|
TabControlDataT *d = (TabControlDataT *)w->data;
|
|
|
|
return d->activeTab;
|
|
}
|
|
|
|
|
|
void wgtTabControlSetActive(WidgetT *w, int32_t idx) {
|
|
VALIDATE_WIDGET_VOID(w, sTabControlTypeId);
|
|
TabControlDataT *d = (TabControlDataT *)w->data;
|
|
|
|
d->activeTab = idx;
|
|
wgtInvalidate(w);
|
|
}
|
|
|
|
|
|
WidgetT *wgtTabPage(WidgetT *parent, const char *title) {
|
|
WidgetT *w = widgetAlloc(parent, sTabPageTypeId);
|
|
|
|
if (w) {
|
|
TabPageDataT *d = calloc(1, sizeof(TabPageDataT));
|
|
d->title = title;
|
|
w->data = d;
|
|
w->accelKey = accelParse(title);
|
|
}
|
|
|
|
return w;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// DXE registration
|
|
// ============================================================
|
|
|
|
|
|
static const struct {
|
|
WidgetT *(*create)(WidgetT *parent);
|
|
WidgetT *(*page)(WidgetT *parent, const char *title);
|
|
void (*setActive)(WidgetT *w, int32_t idx);
|
|
int32_t (*getActive)(const WidgetT *w);
|
|
} sApi = {
|
|
.create = wgtTabControl,
|
|
.page = wgtTabPage,
|
|
.setActive = wgtTabControlSetActive,
|
|
.getActive = wgtTabControlGetActive
|
|
};
|
|
|
|
static const WgtPropDescT sProps[] = {
|
|
{ "TabIndex", WGT_IFACE_INT, (void *)wgtTabControlGetActive, (void *)wgtTabControlSetActive, NULL }
|
|
};
|
|
|
|
static const WgtMethodDescT sMethods[] = {
|
|
{ "SetActive", WGT_SIG_INT, (void *)wgtTabControlSetActive }
|
|
};
|
|
|
|
static const WgtIfaceT sIface = {
|
|
.basName = "TabStrip",
|
|
.props = sProps,
|
|
.propCount = 1,
|
|
.methods = sMethods,
|
|
.methodCount = 1,
|
|
.events = NULL,
|
|
.eventCount = 0,
|
|
.createSig = WGT_CREATE_PARENT,
|
|
.isContainer = true,
|
|
.defaultEvent = "Click"
|
|
};
|
|
|
|
void wgtRegister(void) {
|
|
sTabControlTypeId = wgtRegisterClass(&sClassTabControl);
|
|
sTabPageTypeId = wgtRegisterClass(&sClassTabPage);
|
|
wgtRegisterApi("tabcontrol", &sApi);
|
|
wgtRegisterIface("tabcontrol", &sIface);
|
|
}
|